(function (Prism) { function literal(str) { return function () { return str; }; } var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/; var IDENTIFIER = '\\b(?!' + keyword.source + ')(?!\\d)\\w+\\b'; var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source; var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace( //g, literal(ALIGN) ); var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?(?:\.)*(?!\s+))/.source.replace( //g, literal(IDENTIFIER) ); var TYPE = '(?!\\s)(?:!?\\s*(?:' + PREFIX_TYPE_OP + '\\s*)*' + SUFFIX_EXPR + ')+'; /* * A simplified grammar for Zig compile time type literals: * * TypeExpr = ( "!"? PREFIX_TYPE_OP* SUFFIX_EXPR )+ * * SUFFIX_EXPR = ( \b "promise" \b | ( \b "error" "." )? IDENTIFIER ( "." IDENTIFIER )* (?! \s+ IDENTIFIER ) ) * * PREFIX_TYPE_OP = "?" * | \b "promise" "->" * | ( "[" [^\[\]]* "]" | "*" | "**" ) ( ALIGN | "const" \b | "volatile" \b | "allowzero" \b )* * * ALIGN = "align" "(" ( [^()] | "(" [^()]* ")" )* ")" * * IDENTIFIER = \b (?! KEYWORD ) [a-zA-Z_] \w* \b * */ Prism.languages.zig = { comment: [ { pattern: /\/\/[/!].*/, alias: 'doc-comment', }, /\/{2}.*/, ], string: [ { // "string" and c"string" pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/, lookbehind: true, greedy: true, }, { // multiline strings and c-strings pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/, lookbehind: true, greedy: true, }, ], char: { // characters 'a', '\n', '\xFF', '\u{10FFFF}' pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/, lookbehind: true, greedy: true, }, builtin: /\B@(?!\d)\w+(?=\s*\()/, label: { pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/, lookbehind: true, }, 'class-name': [ // const Foo = struct {}; /\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/, { // const x: i32 = 9; // var x: Bar; // fn foo(x: bool, y: f32) void {} pattern: RegExp( /(:\s*)(?=\s*(?:\s*)?[=;,)])|(?=\s*(?:\s*)?\{)/.source .replace(//g, literal(TYPE)) .replace(//g, literal(ALIGN)) ), lookbehind: true, inside: null, // see below }, { // extern fn foo(x: f64) f64; (optional alignment) pattern: RegExp( /(\)\s*)(?=\s*(?:\s*)?;)/.source .replace(//g, literal(TYPE)) .replace(//g, literal(ALIGN)) ), lookbehind: true, inside: null, // see below }, ], 'builtin-type': { pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/, alias: 'keyword', }, keyword: keyword, function: /\b(?!\d)\w+(?=\s*\()/, number: /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/, boolean: /\b(?:false|true)\b/, operator: /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/, punctuation: /[.:,;(){}[\]]/, }; Prism.languages.zig['class-name'].forEach(function (obj) { if (obj.inside === null) { obj.inside = Prism.languages.zig; } }); })(Prism); >

Prism.languages.ocaml = {
  comment: { pattern: /\(\*[\s\S]*?\*\)/, greedy: !0 },
  char: { pattern: /'(?:[^\\\r\n']|\\(?:.|[ox]?[0-9a-f]{1,3}))'/i, greedy: !0 },
  string: [
    { pattern: /"(?:\\(?:[\s\S]|\r\n)|[^\\\r\n"])*"/, greedy: !0 },
    { pattern: /\{([a-z_]*)\|[\s\S]*?\|\1\}/, greedy: !0 },
  ],
  number: [
    /\b(?:0b[01][01_]*|0o[0-7][0-7_]*)\b/i,
    /\b0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]*)?(?:p[+-]?\d[\d_]*)?(?!\w)/i,
    /\b\d[\d_]*(?:\.[\d_]*)?(?:e[+-]?\d[\d_]*)?(?!\w)/i,
  ],
  directive: { pattern: /\B#\w+/, alias: 'property' },
  label: { pattern: /\B~\w+/, alias: 'property' },
  'type-variable': { pattern: /\B'\w+/, alias: 'function' },
  variant: { pattern: /`\w+/, alias: 'symbol' },
  keyword:
    /\b(?:as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|match|method|module|mutable|new|nonrec|object|of|open|private|rec|sig|struct|then|to|try|type|val|value|virtual|when|where|while|with)\b/,
  boolean: /\b(?:false|true)\b/,
  'operator-like-punctuation': {
    pattern: /\[[<>|]|[>|]\]|\{<|>\}/,
    alias: 'punctuation',
  },
  operator:
    /\.[.~]|:[=>]|[=<>@^|&+\-*\/$%!?~][!$%&*+\-.\/:<=>?@^|~]*|\b(?:and|asr|land|lor|lsl|lsr|lxor|mod|or)\b/,
  punctuation: /;;|::|[(){}\[\].,:;#]|\b_\b/,
};