@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/liquid-Dkf7-nlZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"liquid-Dkf7-nlZ.js","sources":["../node_modules/refractor/lang/liquid.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = liquid\nliquid.displayName = 'liquid'\nliquid.aliases = []\nfunction liquid(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  Prism.languages.liquid = {\n    comment: {\n      pattern: /(^\\{%\\s*comment\\s*%\\})[\\s\\S]+(?=\\{%\\s*endcomment\\s*%\\}$)/,\n      lookbehind: true\n    },\n    delimiter: {\n      pattern: /^\\{(?:\\{\\{|[%\\{])-?|-?(?:\\}\\}|[%\\}])\\}$/,\n      alias: 'punctuation'\n    },\n    string: {\n      pattern: /\"[^\"]*\"|'[^']*'/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\\b/,\n    object:\n      /\\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\\b/,\n    function: [\n      {\n        pattern: /(\\|\\s*)\\w+/,\n        lookbehind: true,\n        alias: 'filter'\n      },\n      {\n        // array functions\n        pattern: /(\\.\\s*)(?:first|last|size)/,\n        lookbehind: true\n      }\n    ],\n    boolean: /\\b(?:false|nil|true)\\b/,\n    range: {\n      pattern: /\\.\\./,\n      alias: 'operator'\n    },\n    // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21\n    number: /\\b\\d+(?:\\.\\d+)?\\b/,\n    operator: /[!=]=|<>|[<>]=?|[|?:=-]|\\b(?:and|contains(?=\\s)|or)\\b/,\n    punctuation: /[.,\\[\\]()]/,\n    empty: {\n      pattern: /\\bempty\\b/,\n      alias: 'keyword'\n    }\n  }\n  Prism.hooks.add('before-tokenize', function (env) {\n    var liquidPattern =\n      /\\{%\\s*comment\\s*%\\}[\\s\\S]*?\\{%\\s*endcomment\\s*%\\}|\\{(?:%[\\s\\S]*?%|\\{\\{[\\s\\S]*?\\}\\}|\\{[\\s\\S]*?\\})\\}/g\n    var insideRaw = false\n    Prism.languages['markup-templating'].buildPlaceholders(\n      env,\n      'liquid',\n      liquidPattern,\n      function (match) {\n        var tagMatch = /^\\{%-?\\s*(\\w+)/.exec(match)\n        if (tagMatch) {\n          var tag = tagMatch[1]\n          if (tag === 'raw' && !insideRaw) {\n            insideRaw = true\n            return true\n          } else if (tag === 'endraw') {\n            insideRaw = false\n            return true\n          }\n        }\n        return !insideRaw\n      }\n    )\n  })\n  Prism.hooks.add('after-tokenize', function (env) {\n    Prism.languages['markup-templating'].tokenizePlaceholders(env, 'liquid')\n  })\n}\n"],"names":["require$$0","liquid"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,aAAiBC;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,SAAS,yBAAyB;AACxC,UAAM,UAAU,SAAS;AAAA,MACvB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,QACE;AAAA,MACF,UAAU;AAAA,QACR;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,SAAS;AAAA,MACT,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;;MAGT,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA,MACb,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;;AAGX,UAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,UAAI,gBACF;AACF,UAAI,YAAY;AAChB,YAAM,UAAU,mBAAmB,EAAE;AAAA,QACnC;AAAA,QACA;AAAA,QACA;AAAA,QACA,SAAU,OAAO;AACf,cAAI,WAAW,iBAAiB,KAAK,KAAK;AAC1C,cAAI,UAAU;AACZ,gBAAI,MAAM,SAAS,CAAC;AACpB,gBAAI,QAAQ,SAAS,CAAC,WAAW;AAC/B,0BAAY;AACZ,qBAAO;AAAA,YACnB,WAAqB,QAAQ,UAAU;AAC3B,0BAAY;AACZ,qBAAO;AAAA,YACnB;AAAA,UACA;AACQ,iBAAO,CAAC;AAAA,QAChB;AAAA;IAEA,CAAG;AACD,UAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,YAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,QAAQ;AAAA,IAC3E,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/lisp-6nO02uCM.js

@@ -0,0 +1,218 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var lisp_1;
+var hasRequiredLisp;
+function requireLisp() {
+  if (hasRequiredLisp) return lisp_1;
+  hasRequiredLisp = 1;
+  lisp_1 = lisp2;
+  lisp2.displayName = "lisp";
+  lisp2.aliases = [];
+  function lisp2(Prism) {
+    (function(Prism2) {
+      function simple_form(name) {
+        return RegExp(/(\()/.source + "(?:" + name + ")" + /(?=[\s\)])/.source);
+      }
+      function primitive(pattern) {
+        return RegExp(
+          /([\s([])/.source + "(?:" + pattern + ")" + /(?=[\s)])/.source
+        );
+      }
+      var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source;
+      var marker = "&" + symbol;
+      var par = "(\\()";
+      var endpar = "(?=\\))";
+      var space = "(?=\\s)";
+      var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source;
+      var language = {
+        // Three or four semicolons are considered a heading.
+        // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
+        heading: {
+          pattern: /;;;.*/,
+          alias: ["comment", "title"]
+        },
+        comment: /;.*/,
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: true,
+          inside: {
+            argument: /[-A-Z]+(?=[.,\s])/,
+            symbol: RegExp("`" + symbol + "'")
+          }
+        },
+        "quoted-symbol": {
+          pattern: RegExp("#?'" + symbol),
+          alias: ["variable", "symbol"]
+        },
+        "lisp-property": {
+          pattern: RegExp(":" + symbol),
+          alias: "property"
+        },
+        splice: {
+          pattern: RegExp(",@?" + symbol),
+          alias: ["symbol", "variable"]
+        },
+        keyword: [
+          {
+            pattern: RegExp(
+              par + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + space
+            ),
+            lookbehind: true
+          },
+          {
+            pattern: RegExp(
+              par + "(?:append|by|collect|concat|do|finally|for|in|return)" + space
+            ),
+            lookbehind: true
+          }
+        ],
+        declare: {
+          pattern: simple_form(/declare/.source),
+          lookbehind: true,
+          alias: "keyword"
+        },
+        interactive: {
+          pattern: simple_form(/interactive/.source),
+          lookbehind: true,
+          alias: "keyword"
+        },
+        boolean: {
+          pattern: primitive(/nil|t/.source),
+          lookbehind: true
+        },
+        number: {
+          pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source),
+          lookbehind: true
+        },
+        defvar: {
+          pattern: RegExp(par + "def(?:const|custom|group|var)\\s+" + symbol),
+          lookbehind: true,
+          inside: {
+            keyword: /^def[a-z]+/,
+            variable: RegExp(symbol)
+          }
+        },
+        defun: {
+          pattern: RegExp(
+            par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            keyword: /^(?:cl-)?def\S+/,
+            // See below, this property needs to be defined later so that it can
+            // reference the language object.
+            arguments: null,
+            function: {
+              pattern: RegExp("(^\\s)" + symbol),
+              lookbehind: true
+            },
+            punctuation: /[()]/
+          }
+        },
+        lambda: {
+          pattern: RegExp(
+            par + "lambda\\s+\\(\\s*(?:&?" + symbol + "(?:\\s+&?" + symbol + ")*\\s*)?\\)"
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            keyword: /^lambda/,
+            // See below, this property needs to be defined later so that it can
+            // reference the language object.
+            arguments: null,
+            punctuation: /[()]/
+          }
+        },
+        car: {
+          pattern: RegExp(par + symbol),
+          lookbehind: true
+        },
+        punctuation: [
+          // open paren, brackets, and close paren
+          /(?:['`,]?\(|[)\[\]])/,
+          // cons
+          {
+            pattern: /(\s)\.(?=\s)/,
+            lookbehind: true
+          }
+        ]
+      };
+      var arg = {
+        "lisp-marker": RegExp(marker),
+        varform: {
+          pattern: RegExp(
+            /\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source
+          ),
+          inside: language
+        },
+        argument: {
+          pattern: RegExp(/(^|[\s(])/.source + symbol),
+          lookbehind: true,
+          alias: "variable"
+        },
+        rest: language
+      };
+      var forms = "\\S+(?:\\s+\\S+)*";
+      var arglist = {
+        pattern: RegExp(par + nestedPar + endpar),
+        lookbehind: true,
+        inside: {
+          "rest-vars": {
+            pattern: RegExp("&(?:body|rest)\\s+" + forms),
+            inside: arg
+          },
+          "other-marker-vars": {
+            pattern: RegExp("&(?:aux|optional)\\s+" + forms),
+            inside: arg
+          },
+          keys: {
+            pattern: RegExp("&key\\s+" + forms + "(?:\\s+&allow-other-keys)?"),
+            inside: arg
+          },
+          argument: {
+            pattern: RegExp(symbol),
+            alias: "variable"
+          },
+          punctuation: /[()]/
+        }
+      };
+      language["lambda"].inside.arguments = arglist;
+      language["defun"].inside.arguments = Prism2.util.clone(arglist);
+      language["defun"].inside.arguments.inside.sublist = arglist;
+      Prism2.languages.lisp = language;
+      Prism2.languages.elisp = language;
+      Prism2.languages.emacs = language;
+      Prism2.languages["emacs-lisp"] = language;
+    })(Prism);
+  }
+  return lisp_1;
+}
+var lispExports = requireLisp();
+const lisp = /* @__PURE__ */ getDefaultExportFromCjs(lispExports);
+const lisp$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: lisp
+}, [lispExports]);
+export {
+  lisp$1 as l
+};
+//# sourceMappingURL=lisp-6nO02uCM.js.map

package/dist/lisp-6nO02uCM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lisp-6nO02uCM.js","sources":["../node_modules/refractor/lang/lisp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = lisp\nlisp.displayName = 'lisp'\nlisp.aliases = []\nfunction lisp(Prism) {\n  ;(function (Prism) {\n    /**\n     * Functions to construct regular expressions\n     * e.g. (interactive ... or (interactive)\n     *\n     * @param {string} name\n     * @returns {RegExp}\n     */\n    function simple_form(name) {\n      return RegExp(/(\\()/.source + '(?:' + name + ')' + /(?=[\\s\\)])/.source)\n    }\n    /**\n     * booleans and numbers\n     *\n     * @param {string} pattern\n     * @returns {RegExp}\n     */\n    function primitive(pattern) {\n      return RegExp(\n        /([\\s([])/.source + '(?:' + pattern + ')' + /(?=[\\s)])/.source\n      )\n    } // Patterns in regular expressions\n    // Symbol name. See https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html\n    // & and : are excluded as they are usually used for special purposes\n    var symbol = /(?!\\d)[-+*/~!@$%^=<>{}\\w]+/.source // symbol starting with & used in function arguments\n    var marker = '&' + symbol // Open parenthesis for look-behind\n    var par = '(\\\\()'\n    var endpar = '(?=\\\\))' // End the pattern with look-ahead space\n    var space = '(?=\\\\s)'\n    var nestedPar =\n      /(?:[^()]|\\((?:[^()]|\\((?:[^()]|\\((?:[^()]|\\((?:[^()]|\\([^()]*\\))*\\))*\\))*\\))*\\))*/\n        .source\n    var language = {\n      // Three or four semicolons are considered a heading.\n      // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html\n      heading: {\n        pattern: /;;;.*/,\n        alias: ['comment', 'title']\n      },\n      comment: /;.*/,\n      string: {\n        pattern: /\"(?:[^\"\\\\]|\\\\.)*\"/,\n        greedy: true,\n        inside: {\n          argument: /[-A-Z]+(?=[.,\\s])/,\n          symbol: RegExp('`' + symbol + \"'\")\n        }\n      },\n      'quoted-symbol': {\n        pattern: RegExp(\"#?'\" + symbol),\n        alias: ['variable', 'symbol']\n      },\n      'lisp-property': {\n        pattern: RegExp(':' + symbol),\n        alias: 'property'\n      },\n      splice: {\n        pattern: RegExp(',@?' + symbol),\n        alias: ['symbol', 'variable']\n      },\n      keyword: [\n        {\n          pattern: RegExp(\n            par +\n              '(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)' +\n              space\n          ),\n          lookbehind: true\n        },\n        {\n          pattern: RegExp(\n            par +\n              '(?:append|by|collect|concat|do|finally|for|in|return)' +\n              space\n          ),\n          lookbehind: true\n        }\n      ],\n      declare: {\n        pattern: simple_form(/declare/.source),\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      interactive: {\n        pattern: simple_form(/interactive/.source),\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      boolean: {\n        pattern: primitive(/nil|t/.source),\n        lookbehind: true\n      },\n      number: {\n        pattern: primitive(/[-+]?\\d+(?:\\.\\d*)?/.source),\n        lookbehind: true\n      },\n      defvar: {\n        pattern: RegExp(par + 'def(?:const|custom|group|var)\\\\s+' + symbol),\n        lookbehind: true,\n        inside: {\n          keyword: /^def[a-z]+/,\n          variable: RegExp(symbol)\n        }\n      },\n      defun: {\n        pattern: RegExp(\n          par +\n            /(?:cl-)?(?:defmacro|defun\\*?)\\s+/.source +\n            symbol +\n            /\\s+\\(/.source +\n            nestedPar +\n            /\\)/.source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          keyword: /^(?:cl-)?def\\S+/,\n          // See below, this property needs to be defined later so that it can\n          // reference the language object.\n          arguments: null,\n          function: {\n            pattern: RegExp('(^\\\\s)' + symbol),\n            lookbehind: true\n          },\n          punctuation: /[()]/\n        }\n      },\n      lambda: {\n        pattern: RegExp(\n          par +\n            'lambda\\\\s+\\\\(\\\\s*(?:&?' +\n            symbol +\n            '(?:\\\\s+&?' +\n            symbol +\n            ')*\\\\s*)?\\\\)'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          keyword: /^lambda/,\n          // See below, this property needs to be defined later so that it can\n          // reference the language object.\n          arguments: null,\n          punctuation: /[()]/\n        }\n      },\n      car: {\n        pattern: RegExp(par + symbol),\n        lookbehind: true\n      },\n      punctuation: [\n        // open paren, brackets, and close paren\n        /(?:['`,]?\\(|[)\\[\\]])/, // cons\n        {\n          pattern: /(\\s)\\.(?=\\s)/,\n          lookbehind: true\n        }\n      ]\n    }\n    var arg = {\n      'lisp-marker': RegExp(marker),\n      varform: {\n        pattern: RegExp(\n          /\\(/.source + symbol + /\\s+(?=\\S)/.source + nestedPar + /\\)/.source\n        ),\n        inside: language\n      },\n      argument: {\n        pattern: RegExp(/(^|[\\s(])/.source + symbol),\n        lookbehind: true,\n        alias: 'variable'\n      },\n      rest: language\n    }\n    var forms = '\\\\S+(?:\\\\s+\\\\S+)*'\n    var arglist = {\n      pattern: RegExp(par + nestedPar + endpar),\n      lookbehind: true,\n      inside: {\n        'rest-vars': {\n          pattern: RegExp('&(?:body|rest)\\\\s+' + forms),\n          inside: arg\n        },\n        'other-marker-vars': {\n          pattern: RegExp('&(?:aux|optional)\\\\s+' + forms),\n          inside: arg\n        },\n        keys: {\n          pattern: RegExp('&key\\\\s+' + forms + '(?:\\\\s+&allow-other-keys)?'),\n          inside: arg\n        },\n        argument: {\n          pattern: RegExp(symbol),\n          alias: 'variable'\n        },\n        punctuation: /[()]/\n      }\n    }\n    language['lambda'].inside.arguments = arglist\n    language['defun'].inside.arguments = Prism.util.clone(arglist)\n    language['defun'].inside.arguments.inside.sublist = arglist\n    Prism.languages.lisp = language\n    Prism.languages.elisp = language\n    Prism.languages.emacs = language\n    Prism.languages['emacs-lisp'] = language\n  })(Prism)\n}\n"],"names":["lisp","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/livescript-d9m7SG0F.js

@@ -0,0 +1,160 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var livescript_1;
+var hasRequiredLivescript;
+function requireLivescript() {
+  if (hasRequiredLivescript) return livescript_1;
+  hasRequiredLivescript = 1;
+  livescript_1 = livescript2;
+  livescript2.displayName = "livescript";
+  livescript2.aliases = [];
+  function livescript2(Prism) {
+    Prism.languages.livescript = {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+          lookbehind: true
+        },
+        {
+          pattern: /(^|[^\\])#.*/,
+          lookbehind: true
+        }
+      ],
+      "interpolated-string": {
+        /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern
+         * forcing it to match """-quoted string when it would otherwise match "-quoted first. */
+        pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          variable: {
+            pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,
+            lookbehind: true
+          },
+          interpolation: {
+            pattern: /(^|[^\\])#\{[^}]+\}/m,
+            lookbehind: true,
+            inside: {
+              "interpolation-punctuation": {
+                pattern: /^#\{|\}$/,
+                alias: "variable"
+              }
+              // See rest below
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      string: [
+        {
+          pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+          greedy: true
+        },
+        {
+          pattern: /<\[[\s\S]*?\]>/,
+          greedy: true
+        },
+        /\\[^\s,;\])}]+/
+      ],
+      regex: [
+        {
+          pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
+          greedy: true,
+          inside: {
+            comment: {
+              pattern: /(^|[^\\])#.*/,
+              lookbehind: true
+            }
+          }
+        },
+        {
+          pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
+          greedy: true
+        }
+      ],
+      keyword: {
+        pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,
+        lookbehind: true
+      },
+      "keyword-operator": {
+        pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
+        lookbehind: true,
+        alias: "operator"
+      },
+      boolean: {
+        pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,
+        lookbehind: true
+      },
+      argument: {
+        // Don't match .&. nor &&
+        pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m,
+        lookbehind: true,
+        alias: "variable"
+      },
+      number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,
+      identifier: /[a-z_](?:-?[a-z]|[\d_])*/i,
+      operator: [
+        // Spaced .
+        {
+          pattern: /( )\.(?= )/,
+          lookbehind: true
+        },
+        // Full list, in order:
+        // .= .~ .. ...
+        // .&. .^. .<<. .>>. .>>>.
+        // := :: ::=
+        // &&
+        // || |>
+        // < << <<< <<<<
+        // <- <-- <-! <--!
+        // <~ <~~ <~! <~~!
+        // <| <= <?
+        // > >> >= >?
+        // - -- -> -->
+        // + ++
+        // @ @@
+        // % %%
+        // * **
+        // ! != !~=
+        // !~> !~~>
+        // !-> !-->
+        // ~ ~> ~~> ~=
+        // = ==
+        // ^ ^^
+        // / ?
+        /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/
+      ],
+      punctuation: /[(){}\[\]|.,:;`]/
+    };
+    Prism.languages.livescript["interpolated-string"].inside["interpolation"].inside.rest = Prism.languages.livescript;
+  }
+  return livescript_1;
+}
+var livescriptExports = requireLivescript();
+const livescript = /* @__PURE__ */ getDefaultExportFromCjs(livescriptExports);
+const livescript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: livescript
+}, [livescriptExports]);
+export {
+  livescript$1 as l
+};
+//# sourceMappingURL=livescript-d9m7SG0F.js.map

package/dist/livescript-d9m7SG0F.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"livescript-d9m7SG0F.js","sources":["../node_modules/refractor/lang/livescript.js"],"sourcesContent":["'use strict'\n\nmodule.exports = livescript\nlivescript.displayName = 'livescript'\nlivescript.aliases = []\nfunction livescript(Prism) {\n  Prism.languages.livescript = {\n    comment: [\n      {\n        pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n        lookbehind: true\n      },\n      {\n        pattern: /(^|[^\\\\])#.*/,\n        lookbehind: true\n      }\n    ],\n    'interpolated-string': {\n      /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern\n       * forcing it to match \"\"\"-quoted string when it would otherwise match \"-quoted first. */\n      pattern: /(^|[^\"])(\"\"\"|\")(?:\\\\[\\s\\S]|(?!\\2)[^\\\\])*\\2(?!\")/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        variable: {\n          pattern: /(^|[^\\\\])#[a-z_](?:-?[a-z]|[\\d_])*/m,\n          lookbehind: true\n        },\n        interpolation: {\n          pattern: /(^|[^\\\\])#\\{[^}]+\\}/m,\n          lookbehind: true,\n          inside: {\n            'interpolation-punctuation': {\n              pattern: /^#\\{|\\}$/,\n              alias: 'variable'\n            } // See rest below\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    },\n    string: [\n      {\n        pattern: /('''|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n        greedy: true\n      },\n      {\n        pattern: /<\\[[\\s\\S]*?\\]>/,\n        greedy: true\n      },\n      /\\\\[^\\s,;\\])}]+/\n    ],\n    regex: [\n      {\n        pattern: /\\/\\/(?:\\[[^\\r\\n\\]]*\\]|\\\\.|(?!\\/\\/)[^\\\\\\[])+\\/\\/[gimyu]{0,5}/,\n        greedy: true,\n        inside: {\n          comment: {\n            pattern: /(^|[^\\\\])#.*/,\n            lookbehind: true\n          }\n        }\n      },\n      {\n        pattern: /\\/(?:\\[[^\\r\\n\\]]*\\]|\\\\.|[^/\\\\\\r\\n\\[])+\\/[gimyu]{0,5}/,\n        greedy: true\n      }\n    ],\n    keyword: {\n      pattern:\n        /(^|(?!-).)\\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\\b/m,\n      lookbehind: true\n    },\n    'keyword-operator': {\n      pattern:\n        /(^|[^-])\\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\\b)/m,\n      lookbehind: true,\n      alias: 'operator'\n    },\n    boolean: {\n      pattern: /(^|[^-])\\b(?:false|no|off|on|true|yes)(?!-)\\b/m,\n      lookbehind: true\n    },\n    argument: {\n      // Don't match .&. nor &&\n      pattern: /(^|(?!\\.&\\.)[^&])&(?!&)\\d*/m,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    number: /\\b(?:\\d+~[\\da-z]+|\\d[\\d_]*(?:\\.\\d[\\d_]*)?(?:[a-z]\\w*)?)/i,\n    identifier: /[a-z_](?:-?[a-z]|[\\d_])*/i,\n    operator: [\n      // Spaced .\n      {\n        pattern: /( )\\.(?= )/,\n        lookbehind: true\n      }, // Full list, in order:\n      // .= .~ .. ...\n      // .&. .^. .<<. .>>. .>>>.\n      // := :: ::=\n      // &&\n      // || |>\n      // < << <<< <<<<\n      // <- <-- <-! <--!\n      // <~ <~~ <~! <~~!\n      // <| <= <?\n      // > >> >= >?\n      // - -- -> -->\n      // + ++\n      // @ @@\n      // % %%\n      // * **\n      // ! != !~=\n      // !~> !~~>\n      // !-> !-->\n      // ~ ~> ~~> ~=\n      // = ==\n      // ^ ^^\n      // / ?\n      /\\.(?:[=~]|\\.\\.?)|\\.(?:[&|^]|<<|>>>?)\\.|:(?:=|:=?)|&&|\\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\\+\\+?|@@?|%%?|\\*\\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\\^\\^?|[\\/?]/\n    ],\n    punctuation: /[(){}\\[\\]|.,:;`]/\n  }\n  Prism.languages.livescript['interpolated-string'].inside[\n    'interpolation'\n  ].inside.rest = Prism.languages.livescript\n}\n"],"names":["livescript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,QACP;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,uBAAuB;AAAA;AAAA;AAAA,QAGrB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,eAAe;AAAA,YACb,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,6BAA6B;AAAA,gBAC3B,SAAS;AAAA,gBACT,OAAO;AAAA;;;;UAIb,QAAQ;AAAA;;MAGZ,QAAQ;AAAA,QACN;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA;MAEF,OAAO;AAAA,QACL;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,SAAS;AAAA,cACP,SAAS;AAAA,cACT,YAAY;AAAA;;;QAIlB;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA;MAEd,oBAAoB;AAAA,QAClB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,UAAU;AAAA;AAAA,QAER,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,QAAQ;AAAA,MACR,YAAY;AAAA,MACZ,UAAU;AAAA;AAAA,QAER;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;;;;;;;;;;;;;;;;;;;;;;;QAwBd;AAAA;MAEF,aAAa;AAAA;AAEf,UAAM,UAAU,WAAW,qBAAqB,EAAE,OAChD,iBACA,OAAO,OAAO,MAAM,UAAU;AAAA,EAClC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/llvm-CD37xxmR.js

@@ -0,0 +1,61 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var llvm_1;
+var hasRequiredLlvm;
+function requireLlvm() {
+  if (hasRequiredLlvm) return llvm_1;
+  hasRequiredLlvm = 1;
+  llvm_1 = llvm2;
+  llvm2.displayName = "llvm";
+  llvm2.aliases = [];
+  function llvm2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.llvm = {
+        comment: /;.*/,
+        string: {
+          pattern: /"[^"]*"/,
+          greedy: true
+        },
+        boolean: /\b(?:false|true)\b/,
+        variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i,
+        label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i,
+        type: {
+          pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/,
+          alias: "class-name"
+        },
+        keyword: /\b[a-z_][a-z_0-9]*\b/,
+        number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
+        punctuation: /[{}[\];(),.!*=<>]/
+      };
+    })(Prism);
+  }
+  return llvm_1;
+}
+var llvmExports = requireLlvm();
+const llvm = /* @__PURE__ */ getDefaultExportFromCjs(llvmExports);
+const llvm$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: llvm
+}, [llvmExports]);
+export {
+  llvm$1 as l
+};
+//# sourceMappingURL=llvm-CD37xxmR.js.map

package/dist/llvm-CD37xxmR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llvm-CD37xxmR.js","sources":["../node_modules/refractor/lang/llvm.js"],"sourcesContent":["'use strict'\n\nmodule.exports = llvm\nllvm.displayName = 'llvm'\nllvm.aliases = []\nfunction llvm(Prism) {\n  ;(function (Prism) {\n    Prism.languages.llvm = {\n      comment: /;.*/,\n      string: {\n        pattern: /\"[^\"]*\"/,\n        greedy: true\n      },\n      boolean: /\\b(?:false|true)\\b/,\n      variable: /[%@!#](?:(?!\\d)(?:[-$.\\w]|\\\\[a-f\\d]{2})+|\\d+)/i,\n      label: /(?!\\d)(?:[-$.\\w]|\\\\[a-f\\d]{2})+:/i,\n      type: {\n        pattern:\n          /\\b(?:double|float|fp128|half|i[1-9]\\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\\b/,\n        alias: 'class-name'\n      },\n      keyword: /\\b[a-z_][a-z_0-9]*\\b/,\n      number:\n        /[+-]?\\b\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?\\b|\\b0x[\\dA-Fa-f]+\\b|\\b0xK[\\dA-Fa-f]{20}\\b|\\b0x[ML][\\dA-Fa-f]{32}\\b|\\b0xH[\\dA-Fa-f]{4}\\b/,\n      punctuation: /[{}[\\];(),.!*=<>]/\n    }\n  })(Prism)\n}\n"],"names":["llvm","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,SAAS;AAAA,QACT,UAAU;AAAA,QACV,OAAO;AAAA,QACP,MAAM;AAAA,UACJ,SACE;AAAA,UACF,OAAO;AAAA;QAET,SAAS;AAAA,QACT,QACE;AAAA,QACF,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/log-VEfJitaY.js

@@ -0,0 +1,142 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var log_1;
+var hasRequiredLog;
+function requireLog() {
+  if (hasRequiredLog) return log_1;
+  hasRequiredLog = 1;
+  log_1 = log2;
+  log2.displayName = "log";
+  log2.aliases = [];
+  function log2(Prism) {
+    Prism.languages.log = {
+      string: {
+        // Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy
+        pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?![st] | \w)(?:[^'\\\r\n]|\\.)*'/,
+        greedy: true
+      },
+      exception: {
+        pattern: /(^|[^\w.])[a-z][\w.]*(?:Error|Exception):.*(?:(?:\r\n?|\n)[ \t]*(?:at[ \t].+|\.{3}.*|Caused by:.*))+(?:(?:\r\n?|\n)[ \t]*\.\.\. .*)?/,
+        lookbehind: true,
+        greedy: true,
+        alias: ["javastacktrace", "language-javastacktrace"],
+        inside: Prism.languages["javastacktrace"] || {
+          keyword: /\bat\b/,
+          function: /[a-z_][\w$]*(?=\()/,
+          punctuation: /[.:()]/
+        }
+      },
+      level: [
+        {
+          pattern: /\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\b/,
+          alias: ["error", "important"]
+        },
+        {
+          pattern: /\b(?:WARN|WARNING|WRN)\b/,
+          alias: ["warning", "important"]
+        },
+        {
+          pattern: /\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\b/,
+          alias: ["info", "keyword"]
+        },
+        {
+          pattern: /\b(?:DBG|DEBUG|FINE)\b/,
+          alias: ["debug", "keyword"]
+        },
+        {
+          pattern: /\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\b/,
+          alias: ["trace", "comment"]
+        }
+      ],
+      property: {
+        pattern: /((?:^|[\]|])[ \t]*)[a-z_](?:[\w-]|\b\/\b)*(?:[. ]\(?\w(?:[\w-]|\b\/\b)*\)?)*:(?=\s)/im,
+        lookbehind: true
+      },
+      separator: {
+        pattern: /(^|[^-+])-{3,}|={3,}|\*{3,}|- - /m,
+        lookbehind: true,
+        alias: "comment"
+      },
+      url: /\b(?:file|ftp|https?):\/\/[^\s|,;'"]*[^\s|,;'">.]/,
+      email: {
+        pattern: /(^|\s)[-\w+.]+@[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+(?=\s)/,
+        lookbehind: true,
+        alias: "url"
+      },
+      "ip-address": {
+        pattern: /\b(?:\d{1,3}(?:\.\d{1,3}){3})\b/,
+        alias: "constant"
+      },
+      "mac-address": {
+        pattern: /\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\b/i,
+        alias: "constant"
+      },
+      domain: {
+        pattern: /(^|\s)[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)*\.[a-z][a-z0-9-]+(?=\s)/,
+        lookbehind: true,
+        alias: "constant"
+      },
+      uuid: {
+        pattern: /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i,
+        alias: "constant"
+      },
+      hash: {
+        pattern: /\b(?:[a-f0-9]{32}){1,2}\b/i,
+        alias: "constant"
+      },
+      "file-path": {
+        pattern: /\b[a-z]:[\\/][^\s|,;:(){}\[\]"']+|(^|[\s:\[\](>|])\.{0,2}\/\w[^\s|,;:(){}\[\]"']*/i,
+        lookbehind: true,
+        greedy: true,
+        alias: "string"
+      },
+      date: {
+        pattern: RegExp(
+          /\b\d{4}[-/]\d{2}[-/]\d{2}(?:T(?=\d{1,2}:)|(?=\s\d{1,2}:))/.source + "|" + /\b\d{1,4}[-/ ](?:\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\d{2,4}T?\b/.source + "|" + /\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\s{1,2}\d{1,2}\b/.source,
+          "i"
+        ),
+        alias: "number"
+      },
+      time: {
+        pattern: /\b\d{1,2}:\d{1,2}:\d{1,2}(?:[.,:]\d+)?(?:\s?[+-]\d{2}:?\d{2}|Z)?\b/,
+        alias: "number"
+      },
+      boolean: /\b(?:false|null|true)\b/i,
+      number: {
+        pattern: /(^|[^.\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\d[\da-f]*(?:\.\d+)*(?:e[+-]?\d+)?[a-z]{0,3}\b)\b(?!\.\w)/i,
+        lookbehind: true
+      },
+      operator: /[;:?<=>~/@!$%&+\-|^(){}*#]/,
+      punctuation: /[\[\].,]/
+    };
+  }
+  return log_1;
+}
+var logExports = requireLog();
+const log = /* @__PURE__ */ getDefaultExportFromCjs(logExports);
+const log$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: log
+}, [logExports]);
+export {
+  log$1 as l
+};
+//# sourceMappingURL=log-VEfJitaY.js.map

package/dist/log-VEfJitaY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-VEfJitaY.js","sources":["../node_modules/refractor/lang/log.js"],"sourcesContent":["'use strict'\n\nmodule.exports = log\nlog.displayName = 'log'\nlog.aliases = []\nfunction log(Prism) {\n  // This is a language definition for generic log files.\n  // Since there is no one log format, this language definition has to support all formats to some degree.\n  //\n  // Based on https://github.com/MTDL9/vim-log-highlighting\n  Prism.languages.log = {\n    string: {\n      // Single-quoted strings must not be confused with plain text. E.g. Can't isn't Susan's Chris' toy\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?![st] | \\w)(?:[^'\\\\\\r\\n]|\\\\.)*'/,\n      greedy: true\n    },\n    exception: {\n      pattern:\n        /(^|[^\\w.])[a-z][\\w.]*(?:Error|Exception):.*(?:(?:\\r\\n?|\\n)[ \\t]*(?:at[ \\t].+|\\.{3}.*|Caused by:.*))+(?:(?:\\r\\n?|\\n)[ \\t]*\\.\\.\\. .*)?/,\n      lookbehind: true,\n      greedy: true,\n      alias: ['javastacktrace', 'language-javastacktrace'],\n      inside: Prism.languages['javastacktrace'] || {\n        keyword: /\\bat\\b/,\n        function: /[a-z_][\\w$]*(?=\\()/,\n        punctuation: /[.:()]/\n      }\n    },\n    level: [\n      {\n        pattern:\n          /\\b(?:ALERT|CRIT|CRITICAL|EMERG|EMERGENCY|ERR|ERROR|FAILURE|FATAL|SEVERE)\\b/,\n        alias: ['error', 'important']\n      },\n      {\n        pattern: /\\b(?:WARN|WARNING|WRN)\\b/,\n        alias: ['warning', 'important']\n      },\n      {\n        pattern: /\\b(?:DISPLAY|INF|INFO|NOTICE|STATUS)\\b/,\n        alias: ['info', 'keyword']\n      },\n      {\n        pattern: /\\b(?:DBG|DEBUG|FINE)\\b/,\n        alias: ['debug', 'keyword']\n      },\n      {\n        pattern: /\\b(?:FINER|FINEST|TRACE|TRC|VERBOSE|VRB)\\b/,\n        alias: ['trace', 'comment']\n      }\n    ],\n    property: {\n      pattern:\n        /((?:^|[\\]|])[ \\t]*)[a-z_](?:[\\w-]|\\b\\/\\b)*(?:[. ]\\(?\\w(?:[\\w-]|\\b\\/\\b)*\\)?)*:(?=\\s)/im,\n      lookbehind: true\n    },\n    separator: {\n      pattern: /(^|[^-+])-{3,}|={3,}|\\*{3,}|- - /m,\n      lookbehind: true,\n      alias: 'comment'\n    },\n    url: /\\b(?:file|ftp|https?):\\/\\/[^\\s|,;'\"]*[^\\s|,;'\">.]/,\n    email: {\n      pattern: /(^|\\s)[-\\w+.]+@[a-z][a-z0-9-]*(?:\\.[a-z][a-z0-9-]*)+(?=\\s)/,\n      lookbehind: true,\n      alias: 'url'\n    },\n    'ip-address': {\n      pattern: /\\b(?:\\d{1,3}(?:\\.\\d{1,3}){3})\\b/,\n      alias: 'constant'\n    },\n    'mac-address': {\n      pattern: /\\b[a-f0-9]{2}(?::[a-f0-9]{2}){5}\\b/i,\n      alias: 'constant'\n    },\n    domain: {\n      pattern:\n        /(^|\\s)[a-z][a-z0-9-]*(?:\\.[a-z][a-z0-9-]*)*\\.[a-z][a-z0-9-]+(?=\\s)/,\n      lookbehind: true,\n      alias: 'constant'\n    },\n    uuid: {\n      pattern:\n        /\\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\b/i,\n      alias: 'constant'\n    },\n    hash: {\n      pattern: /\\b(?:[a-f0-9]{32}){1,2}\\b/i,\n      alias: 'constant'\n    },\n    'file-path': {\n      pattern:\n        /\\b[a-z]:[\\\\/][^\\s|,;:(){}\\[\\]\"']+|(^|[\\s:\\[\\](>|])\\.{0,2}\\/\\w[^\\s|,;:(){}\\[\\]\"']*/i,\n      lookbehind: true,\n      greedy: true,\n      alias: 'string'\n    },\n    date: {\n      pattern: RegExp(\n        /\\b\\d{4}[-/]\\d{2}[-/]\\d{2}(?:T(?=\\d{1,2}:)|(?=\\s\\d{1,2}:))/.source +\n          '|' +\n          /\\b\\d{1,4}[-/ ](?:\\d{1,2}|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)[-/ ]\\d{2,4}T?\\b/\n            .source +\n          '|' +\n          /\\b(?:(?:Fri|Mon|Sat|Sun|Thu|Tue|Wed)(?:\\s{1,2}(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep))?|Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)\\s{1,2}\\d{1,2}\\b/\n            .source,\n        'i'\n      ),\n      alias: 'number'\n    },\n    time: {\n      pattern:\n        /\\b\\d{1,2}:\\d{1,2}:\\d{1,2}(?:[.,:]\\d+)?(?:\\s?[+-]\\d{2}:?\\d{2}|Z)?\\b/,\n      alias: 'number'\n    },\n    boolean: /\\b(?:false|null|true)\\b/i,\n    number: {\n      pattern:\n        /(^|[^.\\w])(?:0x[a-f0-9]+|0o[0-7]+|0b[01]+|v?\\d[\\da-f]*(?:\\.\\d+)*(?:e[+-]?\\d+)?[a-z]{0,3}\\b)\\b(?!\\.\\w)/i,\n      lookbehind: true\n    },\n    operator: /[;:?<=>~/@!$%&+\\-|^(){}*#]/,\n    punctuation: /[\\[\\].,]/\n  }\n}\n"],"names":["log"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAKlB,UAAM,UAAU,MAAM;AAAA,MACpB,QAAQ;AAAA;AAAA,QAEN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,WAAW;AAAA,QACT,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,OAAO,CAAC,kBAAkB,yBAAyB;AAAA,QACnD,QAAQ,MAAM,UAAU,gBAAgB,KAAK;AAAA,UAC3C,SAAS;AAAA,UACT,UAAU;AAAA,UACV,aAAa;AAAA;;MAGjB,OAAO;AAAA,QACL;AAAA,UACE,SACE;AAAA,UACF,OAAO,CAAC,SAAS,WAAW;AAAA;QAE9B;AAAA,UACE,SAAS;AAAA,UACT,OAAO,CAAC,WAAW,WAAW;AAAA;QAEhC;AAAA,UACE,SAAS;AAAA,UACT,OAAO,CAAC,QAAQ,SAAS;AAAA;QAE3B;AAAA,UACE,SAAS;AAAA,UACT,OAAO,CAAC,SAAS,SAAS;AAAA;QAE5B;AAAA,UACE,SAAS;AAAA,UACT,OAAO,CAAC,SAAS,SAAS;AAAA;;MAG9B,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA;MAEd,WAAW;AAAA,QACT,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,KAAK;AAAA,MACL,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,cAAc;AAAA,QACZ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,eAAe;AAAA,QACb,SAAS;AAAA,QACT,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SACE;AAAA,QACF,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,aAAa;AAAA,QACX,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SAAS;AAAA,UACP,4DAA4D,SAC1D,MACA,4FACG,SACH,MACA,uKACG;AAAA,UACL;AAAA;QAEF,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SACE;AAAA,QACF,OAAO;AAAA;MAET,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}