vue-files-preview-inno 1.0.38-e

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

@@ -0,0 +1,217 @@
+var i, T;
+function M() {
+  if (T) return i;
+  T = 1;
+  function d(e) {
+    const n = e.regex, a = {
+      $pattern: /[\w.\/]+/,
+      built_in: [
+        "action",
+        "bindattr",
+        "collection",
+        "component",
+        "concat",
+        "debugger",
+        "each",
+        "each-in",
+        "get",
+        "hash",
+        "if",
+        "in",
+        "input",
+        "link-to",
+        "loc",
+        "log",
+        "lookup",
+        "mut",
+        "outlet",
+        "partial",
+        "query-params",
+        "render",
+        "template",
+        "textarea",
+        "unbound",
+        "unless",
+        "view",
+        "with",
+        "yield"
+      ]
+    }, A = {
+      $pattern: /[\w.\/]+/,
+      literal: [
+        "true",
+        "false",
+        "undefined",
+        "null"
+      ]
+    }, R = /""|"[^"]+"/, m = /''|'[^']+'/, r = /\[\]|\[[^\]]+\]/, _ = /[^\s!"#%&'()*+,.\/;<=>@\[\\\]^`{|}~]+/, b = /(\.|\/)/, c = n.either(
+      R,
+      m,
+      r,
+      _
+    ), u = n.concat(
+      n.optional(/\.|\.\/|\//),
+      // relative or absolute path
+      c,
+      n.anyNumberOfTimes(n.concat(
+        b,
+        c
+      ))
+    ), I = n.concat(
+      "(",
+      r,
+      "|",
+      _,
+      ")(?==)"
+    ), t = { begin: u }, o = e.inherit(t, { keywords: A }), s = {
+      begin: /\(/,
+      end: /\)/
+      // the "contains" is added below when all necessary sub-modes are defined
+    }, g = {
+      // fka "attribute-assignment", parameters of the form 'key=value'
+      className: "attr",
+      begin: I,
+      relevance: 0,
+      starts: {
+        begin: /=/,
+        end: /=/,
+        starts: { contains: [
+          e.NUMBER_MODE,
+          e.QUOTE_STRING_MODE,
+          e.APOS_STRING_MODE,
+          o,
+          s
+        ] }
+      }
+    }, O = {
+      // parameters of the form '{{#with x as | y |}}...{{/with}}'
+      begin: /as\s+\|/,
+      keywords: { keyword: "as" },
+      end: /\|/,
+      contains: [
+        {
+          // define sub-mode in order to prevent highlighting of block-parameter named "as"
+          begin: /\w+/
+        }
+      ]
+    }, E = {
+      contains: [
+        e.NUMBER_MODE,
+        e.QUOTE_STRING_MODE,
+        e.APOS_STRING_MODE,
+        O,
+        g,
+        o,
+        s
+      ],
+      returnEnd: !0
+      // the property "end" is defined through inheritance when the mode is used. If depends
+      // on the surrounding mode, but "endsWithParent" does not work here (i.e. it includes the
+      // end-token of the surrounding mode)
+    }, C = e.inherit(t, {
+      className: "name",
+      keywords: a,
+      starts: e.inherit(E, { end: /\)/ })
+    });
+    s.contains = [C];
+    const N = e.inherit(t, {
+      keywords: a,
+      className: "name",
+      starts: e.inherit(E, { end: /\}\}/ })
+    }), S = e.inherit(t, {
+      keywords: a,
+      className: "name"
+    }), l = e.inherit(t, {
+      className: "name",
+      keywords: a,
+      starts: e.inherit(E, { end: /\}\}/ })
+    });
+    return {
+      name: "Handlebars",
+      aliases: [
+        "hbs",
+        "html.hbs",
+        "html.handlebars",
+        "htmlbars"
+      ],
+      case_insensitive: !0,
+      subLanguage: "xml",
+      contains: [
+        {
+          begin: /\\\{\{/,
+          skip: !0
+        },
+        {
+          begin: /\\\\(?=\{\{)/,
+          skip: !0
+        },
+        e.COMMENT(/\{\{!--/, /--\}\}/),
+        e.COMMENT(/\{\{!/, /\}\}/),
+        {
+          // open raw block "{{{{raw}}}} content not evaluated {{{{/raw}}}}"
+          className: "template-tag",
+          begin: /\{\{\{\{(?!\/)/,
+          end: /\}\}\}\}/,
+          contains: [N],
+          starts: {
+            end: /\{\{\{\{\//,
+            returnEnd: !0,
+            subLanguage: "xml"
+          }
+        },
+        {
+          // close raw block
+          className: "template-tag",
+          begin: /\{\{\{\{\//,
+          end: /\}\}\}\}/,
+          contains: [S]
+        },
+        {
+          // open block statement
+          className: "template-tag",
+          begin: /\{\{#/,
+          end: /\}\}/,
+          contains: [N]
+        },
+        {
+          className: "template-tag",
+          begin: /\{\{(?=else\}\})/,
+          end: /\}\}/,
+          keywords: "else"
+        },
+        {
+          className: "template-tag",
+          begin: /\{\{(?=else if)/,
+          end: /\}\}/,
+          keywords: "else if"
+        },
+        {
+          // closing block statement
+          className: "template-tag",
+          begin: /\{\{\//,
+          end: /\}\}/,
+          contains: [S]
+        },
+        {
+          // template variable or helper-call that is NOT html-escaped
+          className: "template-variable",
+          begin: /\{\{\{/,
+          end: /\}\}\}/,
+          contains: [l]
+        },
+        {
+          // template variable or helper-call that is html-escaped
+          className: "template-variable",
+          begin: /\{\{/,
+          end: /\}\}/,
+          contains: [l]
+        }
+      ]
+    };
+  }
+  return i = d, i;
+}
+export {
+  M as __require
+};
+//# sourceMappingURL=handlebars.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handlebars.mjs","sources":["../../../../../../node_modules/highlight.js/lib/languages/handlebars.js"],"sourcesContent":["/*\nLanguage: Handlebars\nRequires: xml.js\nAuthor: Robin Ward <robin.ward@gmail.com>\nDescription: Matcher for Handlebars as well as EmberJS additions.\nWebsite: https://handlebarsjs.com\nCategory: template\n*/\n\nfunction handlebars(hljs) {\n  const regex = hljs.regex;\n  const BUILT_INS = {\n    $pattern: /[\\w.\\/]+/,\n    built_in: [\n      'action',\n      'bindattr',\n      'collection',\n      'component',\n      'concat',\n      'debugger',\n      'each',\n      'each-in',\n      'get',\n      'hash',\n      'if',\n      'in',\n      'input',\n      'link-to',\n      'loc',\n      'log',\n      'lookup',\n      'mut',\n      'outlet',\n      'partial',\n      'query-params',\n      'render',\n      'template',\n      'textarea',\n      'unbound',\n      'unless',\n      'view',\n      'with',\n      'yield'\n    ]\n  };\n\n  const LITERALS = {\n    $pattern: /[\\w.\\/]+/,\n    literal: [\n      'true',\n      'false',\n      'undefined',\n      'null'\n    ]\n  };\n\n  // as defined in https://handlebarsjs.com/guide/expressions.html#literal-segments\n  // this regex matches literal segments like ' abc ' or [ abc ] as well as helpers and paths\n  // like a/b, ./abc/cde, and abc.bcd\n\n  const DOUBLE_QUOTED_ID_REGEX = /\"\"|\"[^\"]+\"/;\n  const SINGLE_QUOTED_ID_REGEX = /''|'[^']+'/;\n  const BRACKET_QUOTED_ID_REGEX = /\\[\\]|\\[[^\\]]+\\]/;\n  const PLAIN_ID_REGEX = /[^\\s!\"#%&'()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]+/;\n  const PATH_DELIMITER_REGEX = /(\\.|\\/)/;\n  const ANY_ID = regex.either(\n    DOUBLE_QUOTED_ID_REGEX,\n    SINGLE_QUOTED_ID_REGEX,\n    BRACKET_QUOTED_ID_REGEX,\n    PLAIN_ID_REGEX\n  );\n\n  const IDENTIFIER_REGEX = regex.concat(\n    regex.optional(/\\.|\\.\\/|\\//), // relative or absolute path\n    ANY_ID,\n    regex.anyNumberOfTimes(regex.concat(\n      PATH_DELIMITER_REGEX,\n      ANY_ID\n    ))\n  );\n\n  // identifier followed by a equal-sign (without the equal sign)\n  const HASH_PARAM_REGEX = regex.concat(\n    '(',\n    BRACKET_QUOTED_ID_REGEX, '|',\n    PLAIN_ID_REGEX,\n    ')(?==)'\n  );\n\n  const HELPER_NAME_OR_PATH_EXPRESSION = { begin: IDENTIFIER_REGEX };\n\n  const HELPER_PARAMETER = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, { keywords: LITERALS });\n\n  const SUB_EXPRESSION = {\n    begin: /\\(/,\n    end: /\\)/\n    // the \"contains\" is added below when all necessary sub-modes are defined\n  };\n\n  const HASH = {\n    // fka \"attribute-assignment\", parameters of the form 'key=value'\n    className: 'attr',\n    begin: HASH_PARAM_REGEX,\n    relevance: 0,\n    starts: {\n      begin: /=/,\n      end: /=/,\n      starts: { contains: [\n        hljs.NUMBER_MODE,\n        hljs.QUOTE_STRING_MODE,\n        hljs.APOS_STRING_MODE,\n        HELPER_PARAMETER,\n        SUB_EXPRESSION\n      ] }\n    }\n  };\n\n  const BLOCK_PARAMS = {\n    // parameters of the form '{{#with x as | y |}}...{{/with}}'\n    begin: /as\\s+\\|/,\n    keywords: { keyword: 'as' },\n    end: /\\|/,\n    contains: [\n      {\n        // define sub-mode in order to prevent highlighting of block-parameter named \"as\"\n        begin: /\\w+/ }\n    ]\n  };\n\n  const HELPER_PARAMETERS = {\n    contains: [\n      hljs.NUMBER_MODE,\n      hljs.QUOTE_STRING_MODE,\n      hljs.APOS_STRING_MODE,\n      BLOCK_PARAMS,\n      HASH,\n      HELPER_PARAMETER,\n      SUB_EXPRESSION\n    ],\n    returnEnd: true\n    // the property \"end\" is defined through inheritance when the mode is used. If depends\n    // on the surrounding mode, but \"endsWithParent\" does not work here (i.e. it includes the\n    // end-token of the surrounding mode)\n  };\n\n  const SUB_EXPRESSION_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {\n    className: 'name',\n    keywords: BUILT_INS,\n    starts: hljs.inherit(HELPER_PARAMETERS, { end: /\\)/ })\n  });\n\n  SUB_EXPRESSION.contains = [ SUB_EXPRESSION_CONTENTS ];\n\n  const OPENING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {\n    keywords: BUILT_INS,\n    className: 'name',\n    starts: hljs.inherit(HELPER_PARAMETERS, { end: /\\}\\}/ })\n  });\n\n  const CLOSING_BLOCK_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {\n    keywords: BUILT_INS,\n    className: 'name'\n  });\n\n  const BASIC_MUSTACHE_CONTENTS = hljs.inherit(HELPER_NAME_OR_PATH_EXPRESSION, {\n    className: 'name',\n    keywords: BUILT_INS,\n    starts: hljs.inherit(HELPER_PARAMETERS, { end: /\\}\\}/ })\n  });\n\n  const ESCAPE_MUSTACHE_WITH_PRECEEDING_BACKSLASH = {\n    begin: /\\\\\\{\\{/,\n    skip: true\n  };\n  const PREVENT_ESCAPE_WITH_ANOTHER_PRECEEDING_BACKSLASH = {\n    begin: /\\\\\\\\(?=\\{\\{)/,\n    skip: true\n  };\n\n  return {\n    name: 'Handlebars',\n    aliases: [\n      'hbs',\n      'html.hbs',\n      'html.handlebars',\n      'htmlbars'\n    ],\n    case_insensitive: true,\n    subLanguage: 'xml',\n    contains: [\n      ESCAPE_MUSTACHE_WITH_PRECEEDING_BACKSLASH,\n      PREVENT_ESCAPE_WITH_ANOTHER_PRECEEDING_BACKSLASH,\n      hljs.COMMENT(/\\{\\{!--/, /--\\}\\}/),\n      hljs.COMMENT(/\\{\\{!/, /\\}\\}/),\n      {\n        // open raw block \"{{{{raw}}}} content not evaluated {{{{/raw}}}}\"\n        className: 'template-tag',\n        begin: /\\{\\{\\{\\{(?!\\/)/,\n        end: /\\}\\}\\}\\}/,\n        contains: [ OPENING_BLOCK_MUSTACHE_CONTENTS ],\n        starts: {\n          end: /\\{\\{\\{\\{\\//,\n          returnEnd: true,\n          subLanguage: 'xml'\n        }\n      },\n      {\n        // close raw block\n        className: 'template-tag',\n        begin: /\\{\\{\\{\\{\\//,\n        end: /\\}\\}\\}\\}/,\n        contains: [ CLOSING_BLOCK_MUSTACHE_CONTENTS ]\n      },\n      {\n        // open block statement\n        className: 'template-tag',\n        begin: /\\{\\{#/,\n        end: /\\}\\}/,\n        contains: [ OPENING_BLOCK_MUSTACHE_CONTENTS ]\n      },\n      {\n        className: 'template-tag',\n        begin: /\\{\\{(?=else\\}\\})/,\n        end: /\\}\\}/,\n        keywords: 'else'\n      },\n      {\n        className: 'template-tag',\n        begin: /\\{\\{(?=else if)/,\n        end: /\\}\\}/,\n        keywords: 'else if'\n      },\n      {\n        // closing block statement\n        className: 'template-tag',\n        begin: /\\{\\{\\//,\n        end: /\\}\\}/,\n        contains: [ CLOSING_BLOCK_MUSTACHE_CONTENTS ]\n      },\n      {\n        // template variable or helper-call that is NOT html-escaped\n        className: 'template-variable',\n        begin: /\\{\\{\\{/,\n        end: /\\}\\}\\}/,\n        contains: [ BASIC_MUSTACHE_CONTENTS ]\n      },\n      {\n        // template variable or helper-call that is html-escaped\n        className: 'template-variable',\n        begin: /\\{\\{/,\n        end: /\\}\\}/,\n        contains: [ BASIC_MUSTACHE_CONTENTS ]\n      }\n    ]\n  };\n}\n\nmodule.exports = handlebars;\n"],"names":["handlebars","hljs","regex","BUILT_INS","LITERALS","DOUBLE_QUOTED_ID_REGEX","SINGLE_QUOTED_ID_REGEX","BRACKET_QUOTED_ID_REGEX","PLAIN_ID_REGEX","PATH_DELIMITER_REGEX","ANY_ID","IDENTIFIER_REGEX","HASH_PARAM_REGEX","HELPER_NAME_OR_PATH_EXPRESSION","HELPER_PARAMETER","SUB_EXPRESSION","HASH","BLOCK_PARAMS","HELPER_PARAMETERS","SUB_EXPRESSION_CONTENTS","OPENING_BLOCK_MUSTACHE_CONTENTS","CLOSING_BLOCK_MUSTACHE_CONTENTS","BASIC_MUSTACHE_CONTENTS","handlebars_1"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,184 @@
+var c, b;
+function $() {
+  if (b) return c;
+  b = 1;
+  function d(e) {
+    const s = "([0-9]_*)+", o = "([0-9a-fA-F]_*)+", m = "([01]_*)+", g = "([0-7]_*)+", l = "([!#$%&*+.\\/<=>?@\\\\^~-]|(?!([(),;\\[\\]`|{}]|[_:\"']))(\\p{S}|\\p{P}))", n = { variants: [
+      // Double dash forms a valid comment only if it's not part of legal lexeme.
+      // See: Haskell 98 report: https://www.haskell.org/onlinereport/lexemes.html
+      //
+      // The commented code does the job, but we can't use negative lookbehind,
+      // due to poor support by Safari browser.
+      // > hljs.COMMENT(`(?<!${symbol})--+(?!${symbol})`, '$'),
+      // So instead, we'll add a no-markup rule before the COMMENT rule in the rules list
+      // to match the problematic infix operators that contain double dash.
+      e.COMMENT("--+", "$"),
+      e.COMMENT(
+        /\{-/,
+        /-\}/,
+        { contains: ["self"] }
+      )
+    ] }, t = {
+      className: "meta",
+      begin: /\{-#/,
+      end: /#-\}/
+    }, r = {
+      className: "meta",
+      begin: "^#",
+      end: "$"
+    }, i = {
+      className: "type",
+      begin: "\\b[A-Z][\\w']*",
+      // TODO: other constructors (build-in, infix).
+      relevance: 0
+    }, a = {
+      begin: "\\(",
+      end: "\\)",
+      illegal: '"',
+      contains: [
+        t,
+        r,
+        {
+          className: "type",
+          begin: "\\b[A-Z][\\w]*(\\((\\.\\.|,|\\w+)\\))?"
+        },
+        e.inherit(e.TITLE_MODE, { begin: "[_a-z][\\w']*" }),
+        n
+      ]
+    }, f = {
+      begin: /\{/,
+      end: /\}/,
+      contains: a.contains
+    }, u = {
+      className: "number",
+      relevance: 0,
+      variants: [
+        // decimal floating-point-literal (subsumes decimal-literal)
+        { match: `\\b(${s})(\\.(${s}))?([eE][+-]?(${s}))?\\b` },
+        // hexadecimal floating-point-literal (subsumes hexadecimal-literal)
+        { match: `\\b0[xX]_*(${o})(\\.(${o}))?([pP][+-]?(${s}))?\\b` },
+        // octal-literal
+        { match: `\\b0[oO](${g})\\b` },
+        // binary-literal
+        { match: `\\b0[bB](${m})\\b` }
+      ]
+    };
+    return {
+      name: "Haskell",
+      aliases: ["hs"],
+      keywords: "let in if then else case of where do module import hiding qualified type data newtype deriving class instance as default infix infixl infixr foreign export ccall stdcall cplusplus jvm dotnet safe unsafe family forall mdo proc rec",
+      unicodeRegex: !0,
+      contains: [
+        // Top-level constructions.
+        {
+          beginKeywords: "module",
+          end: "where",
+          keywords: "module where",
+          contains: [
+            a,
+            n
+          ],
+          illegal: "\\W\\.|;"
+        },
+        {
+          begin: "\\bimport\\b",
+          end: "$",
+          keywords: "import qualified as hiding",
+          contains: [
+            a,
+            n
+          ],
+          illegal: "\\W\\.|;"
+        },
+        {
+          className: "class",
+          begin: "^(\\s*)?(class|instance)\\b",
+          end: "where",
+          keywords: "class family instance where",
+          contains: [
+            i,
+            a,
+            n
+          ]
+        },
+        {
+          className: "class",
+          begin: "\\b(data|(new)?type)\\b",
+          end: "$",
+          keywords: "data family type newtype deriving",
+          contains: [
+            t,
+            i,
+            a,
+            f,
+            n
+          ]
+        },
+        {
+          beginKeywords: "default",
+          end: "$",
+          contains: [
+            i,
+            a,
+            n
+          ]
+        },
+        {
+          beginKeywords: "infix infixl infixr",
+          end: "$",
+          contains: [
+            e.C_NUMBER_MODE,
+            n
+          ]
+        },
+        {
+          begin: "\\bforeign\\b",
+          end: "$",
+          keywords: "foreign import export ccall stdcall cplusplus jvm dotnet safe unsafe",
+          contains: [
+            i,
+            e.QUOTE_STRING_MODE,
+            n
+          ]
+        },
+        {
+          className: "meta",
+          begin: "#!\\/usr\\/bin\\/env runhaskell",
+          end: "$"
+        },
+        // "Whitespaces".
+        t,
+        r,
+        // Literals and names.
+        // Single characters.
+        {
+          scope: "string",
+          begin: /'(?=\\?.')/,
+          end: /'/,
+          contains: [
+            {
+              scope: "char.escape",
+              match: /\\./
+            }
+          ]
+        },
+        e.QUOTE_STRING_MODE,
+        u,
+        i,
+        e.inherit(e.TITLE_MODE, { begin: "^[_a-z][\\w']*" }),
+        // No markup, prevents infix operators from being recognized as comments.
+        { begin: `(?!-)${l}--+|--+(?!-)${l}` },
+        n,
+        {
+          // No markup, relevance booster
+          begin: "->|<-"
+        }
+      ]
+    };
+  }
+  return c = d, c;
+}
+export {
+  $ as __require
+};
+//# sourceMappingURL=haskell.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haskell.mjs","sources":["../../../../../../node_modules/highlight.js/lib/languages/haskell.js"],"sourcesContent":["/*\nLanguage: Haskell\nAuthor: Jeremy Hull <sourdrums@gmail.com>\nContributors: Zena Treep <zena.treep@gmail.com>\nWebsite: https://www.haskell.org\nCategory: functional\n*/\n\nfunction haskell(hljs) {\n\n  /* See:\n     - https://www.haskell.org/onlinereport/lexemes.html\n     - https://downloads.haskell.org/ghc/9.0.1/docs/html/users_guide/exts/binary_literals.html\n     - https://downloads.haskell.org/ghc/9.0.1/docs/html/users_guide/exts/numeric_underscores.html\n     - https://downloads.haskell.org/ghc/9.0.1/docs/html/users_guide/exts/hex_float_literals.html\n  */\n  const decimalDigits = '([0-9]_*)+';\n  const hexDigits = '([0-9a-fA-F]_*)+';\n  const binaryDigits = '([01]_*)+';\n  const octalDigits = '([0-7]_*)+';\n  const ascSymbol = '[!#$%&*+.\\\\/<=>?@\\\\\\\\^~-]';\n  const uniSymbol = '(\\\\p{S}|\\\\p{P})'; // Symbol or Punctuation\n  const special = '[(),;\\\\[\\\\]`|{}]';\n  const symbol = `(${ascSymbol}|(?!(${special}|[_:\"']))${uniSymbol})`;\n\n  const COMMENT = { variants: [\n    // Double dash forms a valid comment only if it's not part of legal lexeme.\n    // See: Haskell 98 report: https://www.haskell.org/onlinereport/lexemes.html\n    //\n    // The commented code does the job, but we can't use negative lookbehind,\n    // due to poor support by Safari browser.\n    // > hljs.COMMENT(`(?<!${symbol})--+(?!${symbol})`, '$'),\n    // So instead, we'll add a no-markup rule before the COMMENT rule in the rules list\n    // to match the problematic infix operators that contain double dash.\n    hljs.COMMENT('--+', '$'),\n    hljs.COMMENT(\n      /\\{-/,\n      /-\\}/,\n      { contains: [ 'self' ] }\n    )\n  ] };\n\n  const PRAGMA = {\n    className: 'meta',\n    begin: /\\{-#/,\n    end: /#-\\}/\n  };\n\n  const PREPROCESSOR = {\n    className: 'meta',\n    begin: '^#',\n    end: '$'\n  };\n\n  const CONSTRUCTOR = {\n    className: 'type',\n    begin: '\\\\b[A-Z][\\\\w\\']*', // TODO: other constructors (build-in, infix).\n    relevance: 0\n  };\n\n  const LIST = {\n    begin: '\\\\(',\n    end: '\\\\)',\n    illegal: '\"',\n    contains: [\n      PRAGMA,\n      PREPROCESSOR,\n      {\n        className: 'type',\n        begin: '\\\\b[A-Z][\\\\w]*(\\\\((\\\\.\\\\.|,|\\\\w+)\\\\))?'\n      },\n      hljs.inherit(hljs.TITLE_MODE, { begin: '[_a-z][\\\\w\\']*' }),\n      COMMENT\n    ]\n  };\n\n  const RECORD = {\n    begin: /\\{/,\n    end: /\\}/,\n    contains: LIST.contains\n  };\n\n  const NUMBER = {\n    className: 'number',\n    relevance: 0,\n    variants: [\n      // decimal floating-point-literal (subsumes decimal-literal)\n      { match: `\\\\b(${decimalDigits})(\\\\.(${decimalDigits}))?` + `([eE][+-]?(${decimalDigits}))?\\\\b` },\n      // hexadecimal floating-point-literal (subsumes hexadecimal-literal)\n      { match: `\\\\b0[xX]_*(${hexDigits})(\\\\.(${hexDigits}))?` + `([pP][+-]?(${decimalDigits}))?\\\\b` },\n      // octal-literal\n      { match: `\\\\b0[oO](${octalDigits})\\\\b` },\n      // binary-literal\n      { match: `\\\\b0[bB](${binaryDigits})\\\\b` }\n    ]\n  };\n\n  return {\n    name: 'Haskell',\n    aliases: [ 'hs' ],\n    keywords:\n      'let in if then else case of where do module import hiding '\n      + 'qualified type data newtype deriving class instance as default '\n      + 'infix infixl infixr foreign export ccall stdcall cplusplus '\n      + 'jvm dotnet safe unsafe family forall mdo proc rec',\n    unicodeRegex: true,\n    contains: [\n      // Top-level constructions.\n      {\n        beginKeywords: 'module',\n        end: 'where',\n        keywords: 'module where',\n        contains: [\n          LIST,\n          COMMENT\n        ],\n        illegal: '\\\\W\\\\.|;'\n      },\n      {\n        begin: '\\\\bimport\\\\b',\n        end: '$',\n        keywords: 'import qualified as hiding',\n        contains: [\n          LIST,\n          COMMENT\n        ],\n        illegal: '\\\\W\\\\.|;'\n      },\n      {\n        className: 'class',\n        begin: '^(\\\\s*)?(class|instance)\\\\b',\n        end: 'where',\n        keywords: 'class family instance where',\n        contains: [\n          CONSTRUCTOR,\n          LIST,\n          COMMENT\n        ]\n      },\n      {\n        className: 'class',\n        begin: '\\\\b(data|(new)?type)\\\\b',\n        end: '$',\n        keywords: 'data family type newtype deriving',\n        contains: [\n          PRAGMA,\n          CONSTRUCTOR,\n          LIST,\n          RECORD,\n          COMMENT\n        ]\n      },\n      {\n        beginKeywords: 'default',\n        end: '$',\n        contains: [\n          CONSTRUCTOR,\n          LIST,\n          COMMENT\n        ]\n      },\n      {\n        beginKeywords: 'infix infixl infixr',\n        end: '$',\n        contains: [\n          hljs.C_NUMBER_MODE,\n          COMMENT\n        ]\n      },\n      {\n        begin: '\\\\bforeign\\\\b',\n        end: '$',\n        keywords: 'foreign import export ccall stdcall cplusplus jvm '\n                  + 'dotnet safe unsafe',\n        contains: [\n          CONSTRUCTOR,\n          hljs.QUOTE_STRING_MODE,\n          COMMENT\n        ]\n      },\n      {\n        className: 'meta',\n        begin: '#!\\\\/usr\\\\/bin\\\\/env\\ runhaskell',\n        end: '$'\n      },\n      // \"Whitespaces\".\n      PRAGMA,\n      PREPROCESSOR,\n\n      // Literals and names.\n\n      // Single characters.\n      {\n        scope: 'string',\n        begin: /'(?=\\\\?.')/,\n        end: /'/,\n        contains: [\n          {\n            scope: 'char.escape',\n            match: /\\\\./,\n          },\n        ]\n      },\n      hljs.QUOTE_STRING_MODE,\n      NUMBER,\n      CONSTRUCTOR,\n      hljs.inherit(hljs.TITLE_MODE, { begin: '^[_a-z][\\\\w\\']*' }),\n      // No markup, prevents infix operators from being recognized as comments.\n      { begin: `(?!-)${symbol}--+|--+(?!-)${symbol}`},\n      COMMENT,\n      { // No markup, relevance booster\n        begin: '->|<-' }\n    ]\n  };\n}\n\nmodule.exports = haskell;\n"],"names":["haskell","hljs","decimalDigits","hexDigits","binaryDigits","octalDigits","symbol","COMMENT","PRAGMA","PREPROCESSOR","CONSTRUCTOR","LIST","RECORD","NUMBER","haskell_1"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,166 @@
+var n, a;
+function c() {
+  if (a) return n;
+  a = 1;
+  function t(e) {
+    const s = "[a-zA-Z_$][a-zA-Z0-9_$]*", i = /(-?)(\b0[xX][a-fA-F0-9_]+|(\b\d+(\.[\d_]*)?|\.[\d_]+)(([eE][-+]?\d+)|i32|u32|i64|f64)?)/;
+    return {
+      name: "Haxe",
+      aliases: ["hx"],
+      keywords: {
+        keyword: "abstract break case cast catch continue default do dynamic else enum extern final for function here if import in inline is macro never new override package private get set public return static super switch this throw trace try typedef untyped using var while " + "Int Float String Bool Dynamic Void Array ",
+        built_in: "trace this",
+        literal: "true false null _"
+      },
+      contains: [
+        {
+          className: "string",
+          // interpolate-able strings
+          begin: "'",
+          end: "'",
+          contains: [
+            e.BACKSLASH_ESCAPE,
+            {
+              className: "subst",
+              // interpolation
+              begin: /\$\{/,
+              end: /\}/
+            },
+            {
+              className: "subst",
+              // interpolation
+              begin: /\$/,
+              end: /\W\}/
+            }
+          ]
+        },
+        e.QUOTE_STRING_MODE,
+        e.C_LINE_COMMENT_MODE,
+        e.C_BLOCK_COMMENT_MODE,
+        {
+          className: "number",
+          begin: i,
+          relevance: 0
+        },
+        {
+          className: "variable",
+          begin: "\\$" + s
+        },
+        {
+          className: "meta",
+          // compiler meta
+          begin: /@:?/,
+          end: /\(|$/,
+          excludeEnd: !0
+        },
+        {
+          className: "meta",
+          // compiler conditionals
+          begin: "#",
+          end: "$",
+          keywords: { keyword: "if else elseif end error" }
+        },
+        {
+          className: "type",
+          // function types
+          begin: /:[ \t]*/,
+          end: /[^A-Za-z0-9_ \t\->]/,
+          excludeBegin: !0,
+          excludeEnd: !0,
+          relevance: 0
+        },
+        {
+          className: "type",
+          // types
+          begin: /:[ \t]*/,
+          end: /\W/,
+          excludeBegin: !0,
+          excludeEnd: !0
+        },
+        {
+          className: "type",
+          // instantiation
+          beginKeywords: "new",
+          end: /\W/,
+          excludeBegin: !0,
+          excludeEnd: !0
+        },
+        {
+          className: "title.class",
+          // enums
+          beginKeywords: "enum",
+          end: /\{/,
+          contains: [e.TITLE_MODE]
+        },
+        {
+          className: "title.class",
+          // abstracts
+          begin: "\\babstract\\b(?=\\s*" + e.IDENT_RE + "\\s*\\()",
+          end: /[\{$]/,
+          contains: [
+            {
+              className: "type",
+              begin: /\(/,
+              end: /\)/,
+              excludeBegin: !0,
+              excludeEnd: !0
+            },
+            {
+              className: "type",
+              begin: /from +/,
+              end: /\W/,
+              excludeBegin: !0,
+              excludeEnd: !0
+            },
+            {
+              className: "type",
+              begin: /to +/,
+              end: /\W/,
+              excludeBegin: !0,
+              excludeEnd: !0
+            },
+            e.TITLE_MODE
+          ],
+          keywords: { keyword: "abstract from to" }
+        },
+        {
+          className: "title.class",
+          // classes
+          begin: /\b(class|interface) +/,
+          end: /[\{$]/,
+          excludeEnd: !0,
+          keywords: "class interface",
+          contains: [
+            {
+              className: "keyword",
+              begin: /\b(extends|implements) +/,
+              keywords: "extends implements",
+              contains: [
+                {
+                  className: "type",
+                  begin: e.IDENT_RE,
+                  relevance: 0
+                }
+              ]
+            },
+            e.TITLE_MODE
+          ]
+        },
+        {
+          className: "title.function",
+          beginKeywords: "function",
+          end: /\(/,
+          excludeEnd: !0,
+          illegal: /\S/,
+          contains: [e.TITLE_MODE]
+        }
+      ],
+      illegal: /<\//
+    };
+  }
+  return n = t, n;
+}
+export {
+  c as __require
+};
+//# sourceMappingURL=haxe.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haxe.mjs","sources":["../../../../../../node_modules/highlight.js/lib/languages/haxe.js"],"sourcesContent":["/*\nLanguage: Haxe\nDescription: Haxe is an open source toolkit based on a modern, high level, strictly typed programming language.\nAuthor: Christopher Kaster <ikasoki@gmail.com> (Based on the actionscript.js language file by Alexander Myadzel)\nContributors: Kenton Hamaluik <kentonh@gmail.com>\nWebsite: https://haxe.org\nCategory: system\n*/\n\nfunction haxe(hljs) {\n  const IDENT_RE = '[a-zA-Z_$][a-zA-Z0-9_$]*';\n\n  // C_NUMBER_RE with underscores and literal suffixes\n  const HAXE_NUMBER_RE = /(-?)(\\b0[xX][a-fA-F0-9_]+|(\\b\\d+(\\.[\\d_]*)?|\\.[\\d_]+)(([eE][-+]?\\d+)|i32|u32|i64|f64)?)/;\n\n  const HAXE_BASIC_TYPES = 'Int Float String Bool Dynamic Void Array ';\n\n  return {\n    name: 'Haxe',\n    aliases: [ 'hx' ],\n    keywords: {\n      keyword: 'abstract break case cast catch continue default do dynamic else enum extern '\n               + 'final for function here if import in inline is macro never new override package private get set '\n               + 'public return static super switch this throw trace try typedef untyped using var while '\n               + HAXE_BASIC_TYPES,\n      built_in:\n        'trace this',\n      literal:\n        'true false null _'\n    },\n    contains: [\n      {\n        className: 'string', // interpolate-able strings\n        begin: '\\'',\n        end: '\\'',\n        contains: [\n          hljs.BACKSLASH_ESCAPE,\n          {\n            className: 'subst', // interpolation\n            begin: /\\$\\{/,\n            end: /\\}/\n          },\n          {\n            className: 'subst', // interpolation\n            begin: /\\$/,\n            end: /\\W\\}/\n          }\n        ]\n      },\n      hljs.QUOTE_STRING_MODE,\n      hljs.C_LINE_COMMENT_MODE,\n      hljs.C_BLOCK_COMMENT_MODE,\n      {\n        className: 'number',\n        begin: HAXE_NUMBER_RE,\n        relevance: 0\n      },\n      {\n        className: 'variable',\n        begin: \"\\\\$\" + IDENT_RE,\n      },\n      {\n        className: 'meta', // compiler meta\n        begin: /@:?/,\n        end: /\\(|$/,\n        excludeEnd: true,\n      },\n      {\n        className: 'meta', // compiler conditionals\n        begin: '#',\n        end: '$',\n        keywords: { keyword: 'if else elseif end error' }\n      },\n      {\n        className: 'type', // function types\n        begin: /:[ \\t]*/,\n        end: /[^A-Za-z0-9_ \\t\\->]/,\n        excludeBegin: true,\n        excludeEnd: true,\n        relevance: 0\n      },\n      {\n        className: 'type', // types\n        begin: /:[ \\t]*/,\n        end: /\\W/,\n        excludeBegin: true,\n        excludeEnd: true\n      },\n      {\n        className: 'type', // instantiation\n        beginKeywords: 'new',\n        end: /\\W/,\n        excludeBegin: true,\n        excludeEnd: true\n      },\n      {\n        className: 'title.class', // enums\n        beginKeywords: 'enum',\n        end: /\\{/,\n        contains: [ hljs.TITLE_MODE ]\n      },\n      {\n        className: 'title.class', // abstracts\n        begin: '\\\\babstract\\\\b(?=\\\\s*' + hljs.IDENT_RE + '\\\\s*\\\\()',\n        end: /[\\{$]/,\n        contains: [\n          {\n            className: 'type',\n            begin: /\\(/,\n            end: /\\)/,\n            excludeBegin: true,\n            excludeEnd: true\n          },\n          {\n            className: 'type',\n            begin: /from +/,\n            end: /\\W/,\n            excludeBegin: true,\n            excludeEnd: true\n          },\n          {\n            className: 'type',\n            begin: /to +/,\n            end: /\\W/,\n            excludeBegin: true,\n            excludeEnd: true\n          },\n          hljs.TITLE_MODE\n        ],\n        keywords: { keyword: 'abstract from to' }\n      },\n      {\n        className: 'title.class', // classes\n        begin: /\\b(class|interface) +/,\n        end: /[\\{$]/,\n        excludeEnd: true,\n        keywords: 'class interface',\n        contains: [\n          {\n            className: 'keyword',\n            begin: /\\b(extends|implements) +/,\n            keywords: 'extends implements',\n            contains: [\n              {\n                className: 'type',\n                begin: hljs.IDENT_RE,\n                relevance: 0\n              }\n            ]\n          },\n          hljs.TITLE_MODE\n        ]\n      },\n      {\n        className: 'title.function',\n        beginKeywords: 'function',\n        end: /\\(/,\n        excludeEnd: true,\n        illegal: /\\S/,\n        contains: [ hljs.TITLE_MODE ]\n      }\n    ],\n    illegal: /<\\//\n  };\n}\n\nmodule.exports = haxe;\n"],"names":["haxe","hljs","IDENT_RE","HAXE_NUMBER_RE","haxe_1"],"mappings":";;;;AASA,WAASA,EAAKC,GAAM;AAClB,UAAMC,IAAW,4BAGXC,IAAiB;AAIvB,WAAO;AAAA,MACL,MAAM;AAAA,MACN,SAAS,CAAE,IAAI;AAAA,MACf,UAAU;AAAA,QACR,SAAS,wQANY;AAAA,QAUrB,UACE;AAAA,QACF,SACE;AAAA;MAEJ,UAAU;AAAA,QACR;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO;AAAA,UACP,KAAK;AAAA,UACL,UAAU;AAAA,YACRF,EAAK;AAAA,YACL;AAAA,cACE,WAAW;AAAA;AAAA,cACX,OAAO;AAAA,cACP,KAAK;AAAA;YAEP;AAAA,cACE,WAAW;AAAA;AAAA,cACX,OAAO;AAAA,cACP,KAAK;AAAA;;;QAIXA,EAAK;AAAA,QACLA,EAAK;AAAA,QACLA,EAAK;AAAA,QACL;AAAA,UACE,WAAW;AAAA,UACX,OAAOE;AAAA,UACP,WAAW;AAAA;QAEb;AAAA,UACE,WAAW;AAAA,UACX,OAAO,QAAQD;AAAA;QAEjB;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO;AAAA,UACP,KAAK;AAAA,UACL,YAAY;AAAA;QAEd;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO;AAAA,UACP,KAAK;AAAA,UACL,UAAU,EAAE,SAAS,2BAA0B;AAAA;QAEjD;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO;AAAA,UACP,KAAK;AAAA,UACL,cAAc;AAAA,UACd,YAAY;AAAA,UACZ,WAAW;AAAA;QAEb;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO;AAAA,UACP,KAAK;AAAA,UACL,cAAc;AAAA,UACd,YAAY;AAAA;QAEd;AAAA,UACE,WAAW;AAAA;AAAA,UACX,eAAe;AAAA,UACf,KAAK;AAAA,UACL,cAAc;AAAA,UACd,YAAY;AAAA;QAEd;AAAA,UACE,WAAW;AAAA;AAAA,UACX,eAAe;AAAA,UACf,KAAK;AAAA,UACL,UAAU,CAAED,EAAK,UAAU;AAAA;QAE7B;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO,0BAA0BA,EAAK,WAAW;AAAA,UACjD,KAAK;AAAA,UACL,UAAU;AAAA,YACR;AAAA,cACE,WAAW;AAAA,cACX,OAAO;AAAA,cACP,KAAK;AAAA,cACL,cAAc;AAAA,cACd,YAAY;AAAA;YAEd;AAAA,cACE,WAAW;AAAA,cACX,OAAO;AAAA,cACP,KAAK;AAAA,cACL,cAAc;AAAA,cACd,YAAY;AAAA;YAEd;AAAA,cACE,WAAW;AAAA,cACX,OAAO;AAAA,cACP,KAAK;AAAA,cACL,cAAc;AAAA,cACd,YAAY;AAAA;YAEdA,EAAK;AAAA;UAEP,UAAU,EAAE,SAAS,mBAAkB;AAAA;QAEzC;AAAA,UACE,WAAW;AAAA;AAAA,UACX,OAAO;AAAA,UACP,KAAK;AAAA,UACL,YAAY;AAAA,UACZ,UAAU;AAAA,UACV,UAAU;AAAA,YACR;AAAA,cACE,WAAW;AAAA,cACX,OAAO;AAAA,cACP,UAAU;AAAA,cACV,UAAU;AAAA,gBACR;AAAA,kBACE,WAAW;AAAA,kBACX,OAAOA,EAAK;AAAA,kBACZ,WAAW;AAAA;;;YAIjBA,EAAK;AAAA;;QAGT;AAAA,UACE,WAAW;AAAA,UACX,eAAe;AAAA,UACf,KAAK;AAAA,UACL,YAAY;AAAA,UACZ,SAAS;AAAA,UACT,UAAU,CAAEA,EAAK,UAAU;AAAA;;MAG/B,SAAS;AAAA,IACb;AAAA,EACA;AAEA,SAAAG,IAAiBJ;;","x_google_ignoreList":[0]}