vue-files-preview-inno 1.0.38-e

package/es/node_modules/highlight.js/lib/languages/fsharp.mjs

@@ -0,0 +1,524 @@
+var I, D;
+function X() {
+  if (D) return I;
+  D = 1;
+  function v(n) {
+    return new RegExp(n.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"), "m");
+  }
+  function S(n) {
+    return n ? typeof n == "string" ? n : n.source : null;
+  }
+  function i(n) {
+    return e("(?=", n, ")");
+  }
+  function e(...n) {
+    return n.map((s) => S(s)).join("");
+  }
+  function w(n) {
+    const o = n[n.length - 1];
+    return typeof o == "object" && o.constructor === Object ? (n.splice(n.length - 1, 1), o) : {};
+  }
+  function t(...n) {
+    return "(" + (w(n).capture ? "" : "?:") + n.map((R) => S(R)).join("|") + ")";
+  }
+  function U(n) {
+    const o = [
+      "abstract",
+      "and",
+      "as",
+      "assert",
+      "base",
+      "begin",
+      "class",
+      "default",
+      "delegate",
+      "do",
+      "done",
+      "downcast",
+      "downto",
+      "elif",
+      "else",
+      "end",
+      "exception",
+      "extern",
+      // "false", // literal
+      "finally",
+      "fixed",
+      "for",
+      "fun",
+      "function",
+      "global",
+      "if",
+      "in",
+      "inherit",
+      "inline",
+      "interface",
+      "internal",
+      "lazy",
+      "let",
+      "match",
+      "member",
+      "module",
+      "mutable",
+      "namespace",
+      "new",
+      // "not", // built_in
+      // "null", // literal
+      "of",
+      "open",
+      "or",
+      "override",
+      "private",
+      "public",
+      "rec",
+      "return",
+      "static",
+      "struct",
+      "then",
+      "to",
+      // "true", // literal
+      "try",
+      "type",
+      "upcast",
+      "use",
+      "val",
+      "void",
+      "when",
+      "while",
+      "with",
+      "yield"
+    ], s = {
+      // monad builder keywords (matches before non-bang keywords)
+      scope: "keyword",
+      match: /\b(yield|return|let|do|match|use)!/
+    }, R = [
+      "if",
+      "else",
+      "endif",
+      "line",
+      "nowarn",
+      "light",
+      "r",
+      "i",
+      "I",
+      "load",
+      "time",
+      "help",
+      "quit"
+    ], B = [
+      "true",
+      "false",
+      "null",
+      "Some",
+      "None",
+      "Ok",
+      "Error",
+      "infinity",
+      "infinityf",
+      "nan",
+      "nanf"
+    ], Y = [
+      "__LINE__",
+      "__SOURCE_DIRECTORY__",
+      "__SOURCE_FILE__"
+    ], k = [
+      // basic types
+      "bool",
+      "byte",
+      "sbyte",
+      "int8",
+      "int16",
+      "int32",
+      "uint8",
+      "uint16",
+      "uint32",
+      "int",
+      "uint",
+      "int64",
+      "uint64",
+      "nativeint",
+      "unativeint",
+      "decimal",
+      "float",
+      "double",
+      "float32",
+      "single",
+      "char",
+      "string",
+      "unit",
+      "bigint",
+      // other native types or lowercase aliases
+      "option",
+      "voption",
+      "list",
+      "array",
+      "seq",
+      "byref",
+      "exn",
+      "inref",
+      "nativeptr",
+      "obj",
+      "outref",
+      "voidptr",
+      // other important FSharp types
+      "Result"
+    ], a = {
+      keyword: o,
+      literal: B,
+      built_in: [
+        // Somewhat arbitrary list of builtin functions and values.
+        // Most of them are declared in Microsoft.FSharp.Core
+        // I tried to stay relevant by adding only the most idiomatic
+        // and most used symbols that are not already declared as types.
+        "not",
+        "ref",
+        "raise",
+        "reraise",
+        "dict",
+        "readOnlyDict",
+        "set",
+        "get",
+        "enum",
+        "sizeof",
+        "typeof",
+        "typedefof",
+        "nameof",
+        "nullArg",
+        "invalidArg",
+        "invalidOp",
+        "id",
+        "fst",
+        "snd",
+        "ignore",
+        "lock",
+        "using",
+        "box",
+        "unbox",
+        "tryUnbox",
+        "printf",
+        "printfn",
+        "sprintf",
+        "eprintf",
+        "eprintfn",
+        "fprintf",
+        "fprintfn",
+        "failwith",
+        "failwithf"
+      ],
+      "variable.constant": Y
+    }, E = {
+      variants: [
+        n.COMMENT(/\(\*(?!\))/, /\*\)/, {
+          contains: ["self"]
+        }),
+        n.C_LINE_COMMENT_MODE
+      ]
+    }, F = /[a-zA-Z_](\w|')*/, r = {
+      scope: "variable",
+      begin: /``/,
+      end: /``/
+    }, N = /\B('|\^)/, _ = {
+      scope: "symbol",
+      variants: [
+        // the type name is a quoted identifier:
+        { match: e(N, /``.*?``/) },
+        // the type name is a normal identifier (we don't use IDENTIFIER_RE because there cannot be another apostrophe here):
+        { match: e(N, n.UNDERSCORE_IDENT_RE) }
+      ],
+      relevance: 0
+    }, b = function({ includeEqual: d }) {
+      let c;
+      d ? c = "!%&*+-/<=>@^|~?" : c = "!%&*+-/<>@^|~?";
+      const $ = Array.from(c), M = e("[", ...$.map(v), "]"), A = t(M, /\./), q = e(A, i(A)), W = t(
+        e(q, A, "*"),
+        // Matches at least 2 chars operators
+        e(M, "+")
+        // Matches at least one char operators
+      );
+      return {
+        scope: "operator",
+        match: t(
+          // symbolic operators:
+          W,
+          // other symbolic keywords:
+          // Type casting and conversion operators:
+          /:\?>/,
+          /:\?/,
+          /:>/,
+          /:=/,
+          // Reference cell assignment
+          /::?/,
+          // : or ::
+          /\$/
+        ),
+        // A single $ can be used as an operator
+        relevance: 0
+      };
+    }, m = b({ includeEqual: !0 }), x = b({ includeEqual: !1 }), g = function(d, c) {
+      return {
+        begin: e(
+          // a type annotation is a
+          d,
+          // should be a colon or the 'of' keyword
+          i(
+            // that has to be followed by
+            e(
+              /\s*/,
+              // optional space
+              t(
+                // then either of:
+                /\w/,
+                // word
+                /'/,
+                // generic type name
+                /\^/,
+                // generic type name
+                /#/,
+                // flexible type name
+                /``/,
+                // quoted type name
+                /\(/,
+                // parens type expression
+                /{\|/
+                // anonymous type annotation
+              )
+            )
+          )
+        ),
+        beginScope: c,
+        // BUG: because ending with \n is necessary for some cases, multi-line type annotations are not properly supported.
+        // Examples where \n is required at the end:
+        // - abstract member definitions in classes: abstract Property : int * string
+        // - return type annotations: let f f' = f' () : returnTypeAnnotation
+        // - record fields definitions: { A : int \n B : string }
+        end: i(
+          t(
+            /\n/,
+            /=/
+          )
+        ),
+        relevance: 0,
+        // we need the known types, and we need the type constraint keywords and literals. e.g.: when 'a : null
+        keywords: n.inherit(a, { type: k }),
+        contains: [
+          E,
+          _,
+          n.inherit(r, { scope: null }),
+          // match to avoid strange patterns inside that may break the parsing
+          x
+        ]
+      };
+    }, p = g(/:/, "operator"), G = g(/\bof\b/, "keyword"), H = {
+      begin: [
+        /(^|\s+)/,
+        // prevents matching the following: `match s.stype with`
+        /type/,
+        /\s+/,
+        F
+      ],
+      beginScope: {
+        2: "keyword",
+        4: "title.class"
+      },
+      end: i(/\(|=|$/),
+      keywords: a,
+      // match keywords in type constraints. e.g.: when 'a : null
+      contains: [
+        E,
+        n.inherit(r, { scope: null }),
+        // match to avoid strange patterns inside that may break the parsing
+        _,
+        {
+          // For visual consistency, highlight type brackets as operators.
+          scope: "operator",
+          match: /<|>/
+        },
+        p
+        // generic types can have constraints, which are type annotations. e.g. type MyType<'T when 'T : delegate<obj * string>> =
+      ]
+    }, C = {
+      // computation expressions:
+      scope: "computation-expression",
+      // BUG: might conflict with record deconstruction. e.g. let f { Name = name } = name // will highlight f
+      match: /\b[_a-z]\w*(?=\s*\{)/
+    }, y = {
+      // preprocessor directives and fsi commands:
+      begin: [
+        /^\s*/,
+        e(/#/, t(...R)),
+        /\b/
+      ],
+      beginScope: { 2: "meta" },
+      end: i(/\s|$/)
+    }, u = {
+      variants: [
+        n.BINARY_NUMBER_MODE,
+        n.C_NUMBER_MODE
+      ]
+    }, f = {
+      scope: "string",
+      begin: /"/,
+      end: /"/,
+      contains: [
+        n.BACKSLASH_ESCAPE
+      ]
+    }, O = {
+      scope: "string",
+      begin: /@"/,
+      end: /"/,
+      contains: [
+        {
+          match: /""/
+          // escaped "
+        },
+        n.BACKSLASH_ESCAPE
+      ]
+    }, L = {
+      scope: "string",
+      begin: /"""/,
+      end: /"""/,
+      relevance: 2
+    }, l = {
+      scope: "subst",
+      begin: /\{/,
+      end: /\}/,
+      keywords: a
+    }, P = {
+      scope: "string",
+      begin: /\$"/,
+      end: /"/,
+      contains: [
+        {
+          match: /\{\{/
+          // escaped {
+        },
+        {
+          match: /\}\}/
+          // escaped }
+        },
+        n.BACKSLASH_ESCAPE,
+        l
+      ]
+    }, h = {
+      scope: "string",
+      begin: /(\$@|@\$)"/,
+      end: /"/,
+      contains: [
+        {
+          match: /\{\{/
+          // escaped {
+        },
+        {
+          match: /\}\}/
+          // escaped }
+        },
+        {
+          match: /""/
+        },
+        n.BACKSLASH_ESCAPE,
+        l
+      ]
+    }, K = {
+      scope: "string",
+      begin: /\$"""/,
+      end: /"""/,
+      contains: [
+        {
+          match: /\{\{/
+          // escaped {
+        },
+        {
+          match: /\}\}/
+          // escaped }
+        },
+        l
+      ],
+      relevance: 2
+    }, T = {
+      scope: "string",
+      match: e(
+        /'/,
+        t(
+          /[^\\']/,
+          // either a single non escaped char...
+          /\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8})/
+          // ...or an escape sequence
+        ),
+        /'/
+      )
+    };
+    return l.contains = [
+      h,
+      P,
+      O,
+      f,
+      T,
+      s,
+      E,
+      r,
+      p,
+      C,
+      y,
+      u,
+      _,
+      m
+    ], {
+      name: "F#",
+      aliases: [
+        "fs",
+        "f#"
+      ],
+      keywords: a,
+      illegal: /\/\*/,
+      classNameAliases: {
+        "computation-expression": "keyword"
+      },
+      contains: [
+        s,
+        {
+          variants: [
+            K,
+            h,
+            P,
+            L,
+            O,
+            f,
+            T
+          ]
+        },
+        E,
+        r,
+        H,
+        {
+          // e.g. [<Attributes("")>] or [<``module``: MyCustomAttributeThatWorksOnModules>]
+          // or [<Sealed; NoEquality; NoComparison; CompiledName("FSharpAsync`1")>]
+          scope: "meta",
+          begin: /\[</,
+          end: />\]/,
+          relevance: 2,
+          contains: [
+            r,
+            // can contain any constant value
+            L,
+            O,
+            f,
+            T,
+            u
+          ]
+        },
+        G,
+        p,
+        C,
+        y,
+        u,
+        _,
+        m
+      ]
+    };
+  }
+  return I = U, I;
+}
+export {
+  X as __require
+};
+//# sourceMappingURL=fsharp.mjs.map

package/es/node_modules/highlight.js/lib/languages/fsharp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fsharp.mjs","sources":["../../../../../../node_modules/highlight.js/lib/languages/fsharp.js"],"sourcesContent":["/**\n * @param {string} value\n * @returns {RegExp}\n * */\nfunction escape(value) {\n  return new RegExp(value.replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&'), 'm');\n}\n\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\nfunction source(re) {\n  if (!re) return null;\n  if (typeof re === \"string\") return re;\n\n  return re.source;\n}\n\n/**\n * @param {RegExp | string } re\n * @returns {string}\n */\nfunction lookahead(re) {\n  return concat('(?=', re, ')');\n}\n\n/**\n * @param {...(RegExp | string) } args\n * @returns {string}\n */\nfunction concat(...args) {\n  const joined = args.map((x) => source(x)).join(\"\");\n  return joined;\n}\n\n/**\n * @param { Array<string | RegExp | Object> } args\n * @returns {object}\n */\nfunction stripOptionsFromArgs(args) {\n  const opts = args[args.length - 1];\n\n  if (typeof opts === 'object' && opts.constructor === Object) {\n    args.splice(args.length - 1, 1);\n    return opts;\n  } else {\n    return {};\n  }\n}\n\n/** @typedef { {capture?: boolean} } RegexEitherOptions */\n\n/**\n * Any of the passed expresssions may match\n *\n * Creates a huge this | this | that | that match\n * @param {(RegExp | string)[] | [...(RegExp | string)[], RegexEitherOptions]} args\n * @returns {string}\n */\nfunction either(...args) {\n  /** @type { object & {capture?: boolean} }  */\n  const opts = stripOptionsFromArgs(args);\n  const joined = '('\n    + (opts.capture ? \"\" : \"?:\")\n    + args.map((x) => source(x)).join(\"|\") + \")\";\n  return joined;\n}\n\n/*\nLanguage: F#\nAuthor: Jonas Follesø <jonas@follesoe.no>\nContributors: Troy Kershaw <hello@troykershaw.com>, Henrik Feldt <henrik@haf.se>, Melvyn Laïly <melvyn.laily@gmail.com>\nWebsite: https://docs.microsoft.com/en-us/dotnet/fsharp/\nCategory: functional\n*/\n\n\n/** @type LanguageFn */\nfunction fsharp(hljs) {\n  const KEYWORDS = [\n    \"abstract\",\n    \"and\",\n    \"as\",\n    \"assert\",\n    \"base\",\n    \"begin\",\n    \"class\",\n    \"default\",\n    \"delegate\",\n    \"do\",\n    \"done\",\n    \"downcast\",\n    \"downto\",\n    \"elif\",\n    \"else\",\n    \"end\",\n    \"exception\",\n    \"extern\",\n    // \"false\", // literal\n    \"finally\",\n    \"fixed\",\n    \"for\",\n    \"fun\",\n    \"function\",\n    \"global\",\n    \"if\",\n    \"in\",\n    \"inherit\",\n    \"inline\",\n    \"interface\",\n    \"internal\",\n    \"lazy\",\n    \"let\",\n    \"match\",\n    \"member\",\n    \"module\",\n    \"mutable\",\n    \"namespace\",\n    \"new\",\n    // \"not\", // built_in\n    // \"null\", // literal\n    \"of\",\n    \"open\",\n    \"or\",\n    \"override\",\n    \"private\",\n    \"public\",\n    \"rec\",\n    \"return\",\n    \"static\",\n    \"struct\",\n    \"then\",\n    \"to\",\n    // \"true\", // literal\n    \"try\",\n    \"type\",\n    \"upcast\",\n    \"use\",\n    \"val\",\n    \"void\",\n    \"when\",\n    \"while\",\n    \"with\",\n    \"yield\"\n  ];\n\n  const BANG_KEYWORD_MODE = {\n    // monad builder keywords (matches before non-bang keywords)\n    scope: 'keyword',\n    match: /\\b(yield|return|let|do|match|use)!/\n  };\n\n  const PREPROCESSOR_KEYWORDS = [\n    \"if\",\n    \"else\",\n    \"endif\",\n    \"line\",\n    \"nowarn\",\n    \"light\",\n    \"r\",\n    \"i\",\n    \"I\",\n    \"load\",\n    \"time\",\n    \"help\",\n    \"quit\"\n  ];\n\n  const LITERALS = [\n    \"true\",\n    \"false\",\n    \"null\",\n    \"Some\",\n    \"None\",\n    \"Ok\",\n    \"Error\",\n    \"infinity\",\n    \"infinityf\",\n    \"nan\",\n    \"nanf\"\n  ];\n\n  const SPECIAL_IDENTIFIERS = [\n    \"__LINE__\",\n    \"__SOURCE_DIRECTORY__\",\n    \"__SOURCE_FILE__\"\n  ];\n\n  // Since it's possible to re-bind/shadow names (e.g. let char = 'c'),\n  // these builtin types should only be matched when a type name is expected.\n  const KNOWN_TYPES = [\n    // basic types\n    \"bool\",\n    \"byte\",\n    \"sbyte\",\n    \"int8\",\n    \"int16\",\n    \"int32\",\n    \"uint8\",\n    \"uint16\",\n    \"uint32\",\n    \"int\",\n    \"uint\",\n    \"int64\",\n    \"uint64\",\n    \"nativeint\",\n    \"unativeint\",\n    \"decimal\",\n    \"float\",\n    \"double\",\n    \"float32\",\n    \"single\",\n    \"char\",\n    \"string\",\n    \"unit\",\n    \"bigint\",\n    // other native types or lowercase aliases\n    \"option\",\n    \"voption\",\n    \"list\",\n    \"array\",\n    \"seq\",\n    \"byref\",\n    \"exn\",\n    \"inref\",\n    \"nativeptr\",\n    \"obj\",\n    \"outref\",\n    \"voidptr\",\n    // other important FSharp types\n    \"Result\"\n  ];\n\n  const BUILTINS = [\n    // Somewhat arbitrary list of builtin functions and values.\n    // Most of them are declared in Microsoft.FSharp.Core\n    // I tried to stay relevant by adding only the most idiomatic\n    // and most used symbols that are not already declared as types.\n    \"not\",\n    \"ref\",\n    \"raise\",\n    \"reraise\",\n    \"dict\",\n    \"readOnlyDict\",\n    \"set\",\n    \"get\",\n    \"enum\",\n    \"sizeof\",\n    \"typeof\",\n    \"typedefof\",\n    \"nameof\",\n    \"nullArg\",\n    \"invalidArg\",\n    \"invalidOp\",\n    \"id\",\n    \"fst\",\n    \"snd\",\n    \"ignore\",\n    \"lock\",\n    \"using\",\n    \"box\",\n    \"unbox\",\n    \"tryUnbox\",\n    \"printf\",\n    \"printfn\",\n    \"sprintf\",\n    \"eprintf\",\n    \"eprintfn\",\n    \"fprintf\",\n    \"fprintfn\",\n    \"failwith\",\n    \"failwithf\"\n  ];\n\n  const ALL_KEYWORDS = {\n    keyword: KEYWORDS,\n    literal: LITERALS,\n    built_in: BUILTINS,\n    'variable.constant': SPECIAL_IDENTIFIERS\n  };\n\n  // (* potentially multi-line Meta Language style comment *)\n  const ML_COMMENT =\n    hljs.COMMENT(/\\(\\*(?!\\))/, /\\*\\)/, {\n      contains: [\"self\"]\n    });\n  // Either a multi-line (* Meta Language style comment *) or a single line // C style comment.\n  const COMMENT = {\n    variants: [\n      ML_COMMENT,\n      hljs.C_LINE_COMMENT_MODE,\n    ]\n  };\n\n  // Most identifiers can contain apostrophes\n  const IDENTIFIER_RE = /[a-zA-Z_](\\w|')*/;\n\n  const QUOTED_IDENTIFIER = {\n    scope: 'variable',\n    begin: /``/,\n    end: /``/\n  };\n\n  // 'a or ^a where a can be a ``quoted identifier``\n  const BEGIN_GENERIC_TYPE_SYMBOL_RE = /\\B('|\\^)/;\n  const GENERIC_TYPE_SYMBOL = {\n    scope: 'symbol',\n    variants: [\n      // the type name is a quoted identifier:\n      { match: concat(BEGIN_GENERIC_TYPE_SYMBOL_RE, /``.*?``/) },\n      // the type name is a normal identifier (we don't use IDENTIFIER_RE because there cannot be another apostrophe here):\n      { match: concat(BEGIN_GENERIC_TYPE_SYMBOL_RE, hljs.UNDERSCORE_IDENT_RE) }\n    ],\n    relevance: 0\n  };\n\n  const makeOperatorMode = function({ includeEqual }) {\n    // List or symbolic operator characters from the FSharp Spec 4.1, minus the dot, and with `?` added, used for nullable operators.\n    let allOperatorChars;\n    if (includeEqual)\n      allOperatorChars = \"!%&*+-/<=>@^|~?\";\n    else\n      allOperatorChars = \"!%&*+-/<>@^|~?\";\n    const OPERATOR_CHARS = Array.from(allOperatorChars);\n    const OPERATOR_CHAR_RE = concat('[', ...OPERATOR_CHARS.map(escape), ']');\n    // The lone dot operator is special. It cannot be redefined, and we don't want to highlight it. It can be used as part of a multi-chars operator though.\n    const OPERATOR_CHAR_OR_DOT_RE = either(OPERATOR_CHAR_RE, /\\./);\n    // When a dot is present, it must be followed by another operator char:\n    const OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE = concat(OPERATOR_CHAR_OR_DOT_RE, lookahead(OPERATOR_CHAR_OR_DOT_RE));\n    const SYMBOLIC_OPERATOR_RE = either(\n      concat(OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE, OPERATOR_CHAR_OR_DOT_RE, '*'), // Matches at least 2 chars operators\n      concat(OPERATOR_CHAR_RE, '+'), // Matches at least one char operators\n    );\n    return {\n      scope: 'operator',\n      match: either(\n        // symbolic operators:\n        SYMBOLIC_OPERATOR_RE,\n        // other symbolic keywords:\n        // Type casting and conversion operators:\n        /:\\?>/,\n        /:\\?/,\n        /:>/,\n        /:=/, // Reference cell assignment\n        /::?/, // : or ::\n        /\\$/), // A single $ can be used as an operator\n      relevance: 0\n    };\n  };\n\n  const OPERATOR = makeOperatorMode({ includeEqual: true });\n  // This variant is used when matching '=' should end a parent mode:\n  const OPERATOR_WITHOUT_EQUAL = makeOperatorMode({ includeEqual: false });\n\n  const makeTypeAnnotationMode = function(prefix, prefixScope) {\n    return {\n      begin: concat( // a type annotation is a\n        prefix,            // should be a colon or the 'of' keyword\n        lookahead(   // that has to be followed by\n          concat(\n            /\\s*/,         // optional space\n            either(  // then either of:\n              /\\w/,        // word\n              /'/,         // generic type name\n              /\\^/,        // generic type name\n              /#/,         // flexible type name\n              /``/,        // quoted type name\n              /\\(/,        // parens type expression\n              /{\\|/,       // anonymous type annotation\n      )))),\n      beginScope: prefixScope,\n      // BUG: because ending with \\n is necessary for some cases, multi-line type annotations are not properly supported.\n      // Examples where \\n is required at the end:\n      // - abstract member definitions in classes: abstract Property : int * string\n      // - return type annotations: let f f' = f' () : returnTypeAnnotation\n      // - record fields definitions: { A : int \\n B : string }\n      end: lookahead(\n        either(\n          /\\n/,\n          /=/)),\n      relevance: 0,\n      // we need the known types, and we need the type constraint keywords and literals. e.g.: when 'a : null\n      keywords: hljs.inherit(ALL_KEYWORDS, { type: KNOWN_TYPES }),\n      contains: [\n        COMMENT,\n        GENERIC_TYPE_SYMBOL,\n        hljs.inherit(QUOTED_IDENTIFIER, { scope: null }), // match to avoid strange patterns inside that may break the parsing\n        OPERATOR_WITHOUT_EQUAL\n      ]\n    };\n  };\n\n  const TYPE_ANNOTATION = makeTypeAnnotationMode(/:/, 'operator');\n  const DISCRIMINATED_UNION_TYPE_ANNOTATION = makeTypeAnnotationMode(/\\bof\\b/, 'keyword');\n\n  // type MyType<'a> = ...\n  const TYPE_DECLARATION = {\n    begin: [\n      /(^|\\s+)/, // prevents matching the following: `match s.stype with`\n      /type/,\n      /\\s+/,\n      IDENTIFIER_RE\n    ],\n    beginScope: {\n      2: 'keyword',\n      4: 'title.class'\n    },\n    end: lookahead(/\\(|=|$/),\n    keywords: ALL_KEYWORDS, // match keywords in type constraints. e.g.: when 'a : null\n    contains: [\n      COMMENT,\n      hljs.inherit(QUOTED_IDENTIFIER, { scope: null }), // match to avoid strange patterns inside that may break the parsing\n      GENERIC_TYPE_SYMBOL,\n      {\n        // For visual consistency, highlight type brackets as operators.\n        scope: 'operator',\n        match: /<|>/\n      },\n      TYPE_ANNOTATION // generic types can have constraints, which are type annotations. e.g. type MyType<'T when 'T : delegate<obj * string>> =\n    ]\n  };\n\n  const COMPUTATION_EXPRESSION = {\n    // computation expressions:\n    scope: 'computation-expression',\n    // BUG: might conflict with record deconstruction. e.g. let f { Name = name } = name // will highlight f\n    match: /\\b[_a-z]\\w*(?=\\s*\\{)/\n  };\n\n  const PREPROCESSOR = {\n    // preprocessor directives and fsi commands:\n    begin: [\n      /^\\s*/,\n      concat(/#/, either(...PREPROCESSOR_KEYWORDS)),\n      /\\b/\n    ],\n    beginScope: { 2: 'meta' },\n    end: lookahead(/\\s|$/)\n  };\n\n  // TODO: this definition is missing support for type suffixes and octal notation.\n  // BUG: range operator without any space is wrongly interpreted as a single number (e.g. 1..10 )\n  const NUMBER = {\n    variants: [\n      hljs.BINARY_NUMBER_MODE,\n      hljs.C_NUMBER_MODE\n    ]\n  };\n\n  // All the following string definitions are potentially multi-line.\n  // BUG: these definitions are missing support for byte strings (suffixed with B)\n\n  // \"...\"\n  const QUOTED_STRING = {\n    scope: 'string',\n    begin: /\"/,\n    end: /\"/,\n    contains: [\n      hljs.BACKSLASH_ESCAPE\n    ]\n  };\n  // @\"...\"\n  const VERBATIM_STRING = {\n    scope: 'string',\n    begin: /@\"/,\n    end: /\"/,\n    contains: [\n      {\n        match: /\"\"/ // escaped \"\n      },\n      hljs.BACKSLASH_ESCAPE\n    ]\n  };\n  // \"\"\"...\"\"\"\n  const TRIPLE_QUOTED_STRING = {\n    scope: 'string',\n    begin: /\"\"\"/,\n    end: /\"\"\"/,\n    relevance: 2\n  };\n  const SUBST = {\n    scope: 'subst',\n    begin: /\\{/,\n    end: /\\}/,\n    keywords: ALL_KEYWORDS\n  };\n  // $\"...{1+1}...\"\n  const INTERPOLATED_STRING = {\n    scope: 'string',\n    begin: /\\$\"/,\n    end: /\"/,\n    contains: [\n      {\n        match: /\\{\\{/ // escaped {\n      },\n      {\n        match: /\\}\\}/ // escaped }\n      },\n      hljs.BACKSLASH_ESCAPE,\n      SUBST\n    ]\n  };\n  // $@\"...{1+1}...\"\n  const INTERPOLATED_VERBATIM_STRING = {\n    scope: 'string',\n    begin: /(\\$@|@\\$)\"/,\n    end: /\"/,\n    contains: [\n      {\n        match: /\\{\\{/ // escaped {\n      },\n      {\n        match: /\\}\\}/ // escaped }\n      },\n      {\n        match: /\"\"/\n      },\n      hljs.BACKSLASH_ESCAPE,\n      SUBST\n    ]\n  };\n  // $\"\"\"...{1+1}...\"\"\"\n  const INTERPOLATED_TRIPLE_QUOTED_STRING = {\n    scope: 'string',\n    begin: /\\$\"\"\"/,\n    end: /\"\"\"/,\n    contains: [\n      {\n        match: /\\{\\{/ // escaped {\n      },\n      {\n        match: /\\}\\}/ // escaped }\n      },\n      SUBST\n    ],\n    relevance: 2\n  };\n  // '.'\n  const CHAR_LITERAL = {\n    scope: 'string',\n    match: concat(\n      /'/,\n      either(\n        /[^\\\\']/, // either a single non escaped char...\n        /\\\\(?:.|\\d{3}|x[a-fA-F\\d]{2}|u[a-fA-F\\d]{4}|U[a-fA-F\\d]{8})/ // ...or an escape sequence\n      ),\n      /'/\n    )\n  };\n  // F# allows a lot of things inside string placeholders.\n  // Things that don't currently seem allowed by the compiler: types definition, attributes usage.\n  // (Strictly speaking, some of the followings are only allowed inside triple quoted interpolated strings...)\n  SUBST.contains = [\n    INTERPOLATED_VERBATIM_STRING,\n    INTERPOLATED_STRING,\n    VERBATIM_STRING,\n    QUOTED_STRING,\n    CHAR_LITERAL,\n    BANG_KEYWORD_MODE,\n    COMMENT,\n    QUOTED_IDENTIFIER,\n    TYPE_ANNOTATION,\n    COMPUTATION_EXPRESSION,\n    PREPROCESSOR,\n    NUMBER,\n    GENERIC_TYPE_SYMBOL,\n    OPERATOR\n  ];\n  const STRING = {\n    variants: [\n      INTERPOLATED_TRIPLE_QUOTED_STRING,\n      INTERPOLATED_VERBATIM_STRING,\n      INTERPOLATED_STRING,\n      TRIPLE_QUOTED_STRING,\n      VERBATIM_STRING,\n      QUOTED_STRING,\n      CHAR_LITERAL\n    ]\n  };\n\n  return {\n    name: 'F#',\n    aliases: [\n      'fs',\n      'f#'\n    ],\n    keywords: ALL_KEYWORDS,\n    illegal: /\\/\\*/,\n    classNameAliases: {\n      'computation-expression': 'keyword'\n    },\n    contains: [\n      BANG_KEYWORD_MODE,\n      STRING,\n      COMMENT,\n      QUOTED_IDENTIFIER,\n      TYPE_DECLARATION,\n      {\n        // e.g. [<Attributes(\"\")>] or [<``module``: MyCustomAttributeThatWorksOnModules>]\n        // or [<Sealed; NoEquality; NoComparison; CompiledName(\"FSharpAsync`1\")>]\n        scope: 'meta',\n        begin: /\\[</,\n        end: />\\]/,\n        relevance: 2,\n        contains: [\n          QUOTED_IDENTIFIER,\n          // can contain any constant value\n          TRIPLE_QUOTED_STRING,\n          VERBATIM_STRING,\n          QUOTED_STRING,\n          CHAR_LITERAL,\n          NUMBER\n        ]\n      },\n      DISCRIMINATED_UNION_TYPE_ANNOTATION,\n      TYPE_ANNOTATION,\n      COMPUTATION_EXPRESSION,\n      PREPROCESSOR,\n      NUMBER,\n      GENERIC_TYPE_SYMBOL,\n      OPERATOR\n    ]\n  };\n}\n\nmodule.exports = fsharp;\n"],"names":["escape","value","source","re","lookahead","concat","args","x","stripOptionsFromArgs","opts","either","fsharp","hljs","KEYWORDS","BANG_KEYWORD_MODE","PREPROCESSOR_KEYWORDS","LITERALS","SPECIAL_IDENTIFIERS","KNOWN_TYPES","ALL_KEYWORDS","COMMENT","IDENTIFIER_RE","QUOTED_IDENTIFIER","BEGIN_GENERIC_TYPE_SYMBOL_RE","GENERIC_TYPE_SYMBOL","makeOperatorMode","includeEqual","allOperatorChars","OPERATOR_CHARS","OPERATOR_CHAR_RE","OPERATOR_CHAR_OR_DOT_RE","OPERATOR_FIRST_CHAR_OF_MULTIPLE_RE","SYMBOLIC_OPERATOR_RE","OPERATOR","OPERATOR_WITHOUT_EQUAL","makeTypeAnnotationMode","prefix","prefixScope","TYPE_ANNOTATION","DISCRIMINATED_UNION_TYPE_ANNOTATION","TYPE_DECLARATION","COMPUTATION_EXPRESSION","PREPROCESSOR","NUMBER","QUOTED_STRING","VERBATIM_STRING","TRIPLE_QUOTED_STRING","SUBST","INTERPOLATED_STRING","INTERPOLATED_VERBATIM_STRING","INTERPOLATED_TRIPLE_QUOTED_STRING","CHAR_LITERAL","fsharp_1"],"mappings":"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","x_google_ignoreList":[0]}