@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/eiffel-BZwp--FL.js

@@ -0,0 +1,76 @@
+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 eiffel_1;
+var hasRequiredEiffel;
+function requireEiffel() {
+  if (hasRequiredEiffel) return eiffel_1;
+  hasRequiredEiffel = 1;
+  eiffel_1 = eiffel2;
+  eiffel2.displayName = "eiffel";
+  eiffel2.aliases = [];
+  function eiffel2(Prism) {
+    Prism.languages.eiffel = {
+      comment: /--.*/,
+      string: [
+        // Aligned-verbatim-strings
+        {
+          pattern: /"([^[]*)\[[\s\S]*?\]\1"/,
+          greedy: true
+        },
+        // Non-aligned-verbatim-strings
+        {
+          pattern: /"([^{]*)\{[\s\S]*?\}\1"/,
+          greedy: true
+        },
+        // Single-line string
+        {
+          pattern: /"(?:%(?:(?!\n)\s)*\n\s*%|%\S|[^%"\r\n])*"/,
+          greedy: true
+        }
+      ],
+      // normal char | special char | char code
+      char: /'(?:%.|[^%'\r\n])+'/,
+      keyword: /\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\b/i,
+      boolean: /\b(?:False|True)\b/i,
+      // Convention: class-names are always all upper-case characters
+      "class-name": /\b[A-Z][\dA-Z_]*\b/,
+      number: [
+        // hexa | octal | bin
+        /\b0[xcb][\da-f](?:_*[\da-f])*\b/i,
+        // Decimal
+        /(?:\b\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?e[+-]?)?\d(?:_*\d)*\b|\b\d(?:_*\d)*\b\.?/i
+      ],
+      punctuation: /:=|<<|>>|\(\||\|\)|->|\.(?=\w)|[{}[\];(),:?]/,
+      operator: /\\\\|\|\.\.\||\.\.|\/[~\/=]?|[><]=?|[-+*^=~]/
+    };
+  }
+  return eiffel_1;
+}
+var eiffelExports = requireEiffel();
+const eiffel = /* @__PURE__ */ getDefaultExportFromCjs(eiffelExports);
+const eiffel$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: eiffel
+}, [eiffelExports]);
+export {
+  eiffel$1 as e
+};
+//# sourceMappingURL=eiffel-BZwp--FL.js.map

package/dist/eiffel-BZwp--FL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eiffel-BZwp--FL.js","sources":["../node_modules/refractor/lang/eiffel.js"],"sourcesContent":["'use strict'\n\nmodule.exports = eiffel\neiffel.displayName = 'eiffel'\neiffel.aliases = []\nfunction eiffel(Prism) {\n  Prism.languages.eiffel = {\n    comment: /--.*/,\n    string: [\n      // Aligned-verbatim-strings\n      {\n        pattern: /\"([^[]*)\\[[\\s\\S]*?\\]\\1\"/,\n        greedy: true\n      }, // Non-aligned-verbatim-strings\n      {\n        pattern: /\"([^{]*)\\{[\\s\\S]*?\\}\\1\"/,\n        greedy: true\n      }, // Single-line string\n      {\n        pattern: /\"(?:%(?:(?!\\n)\\s)*\\n\\s*%|%\\S|[^%\"\\r\\n])*\"/,\n        greedy: true\n      }\n    ],\n    // normal char | special char | char code\n    char: /'(?:%.|[^%'\\r\\n])+'/,\n    keyword:\n      /\\b(?:across|agent|alias|all|and|as|assign|attached|attribute|check|class|convert|create|Current|debug|deferred|detachable|do|else|elseif|end|ensure|expanded|export|external|feature|from|frozen|if|implies|inherit|inspect|invariant|like|local|loop|not|note|obsolete|old|once|or|Precursor|redefine|rename|require|rescue|Result|retry|select|separate|some|then|undefine|until|variant|Void|when|xor)\\b/i,\n    boolean: /\\b(?:False|True)\\b/i,\n    // Convention: class-names are always all upper-case characters\n    'class-name': /\\b[A-Z][\\dA-Z_]*\\b/,\n    number: [\n      // hexa | octal | bin\n      /\\b0[xcb][\\da-f](?:_*[\\da-f])*\\b/i, // Decimal\n      /(?:\\b\\d(?:_*\\d)*)?\\.(?:(?:\\d(?:_*\\d)*)?e[+-]?)?\\d(?:_*\\d)*\\b|\\b\\d(?:_*\\d)*\\b\\.?/i\n    ],\n    punctuation: /:=|<<|>>|\\(\\||\\|\\)|->|\\.(?=\\w)|[{}[\\];(),:?]/,\n    operator: /\\\\\\\\|\\|\\.\\.\\||\\.\\.|\\/[~\\/=]?|[><]=?|[-+*^=~]/\n  }\n}\n"],"names":["eiffel"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,SAAS;AAAA,MACT,QAAQ;AAAA;AAAA,QAEN;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;;MAIZ,MAAM;AAAA,MACN,SACE;AAAA,MACF,SAAS;AAAA;AAAA,MAET,cAAc;AAAA,MACd,QAAQ;AAAA;AAAA,QAEN;AAAA;AAAA,QACA;AAAA;MAEF,aAAa;AAAA,MACb,UAAU;AAAA;EAEd;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/ejs-C0LfHd6n.js

@@ -0,0 +1,70 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireMarkupTemplating } from "./markup-templating-hY-QSL53.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 ejs_1;
+var hasRequiredEjs;
+function requireEjs() {
+  if (hasRequiredEjs) return ejs_1;
+  hasRequiredEjs = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  ejs_1 = ejs2;
+  ejs2.displayName = "ejs";
+  ejs2.aliases = ["eta"];
+  function ejs2(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      Prism2.languages.ejs = {
+        delimiter: {
+          pattern: /^<%[-_=]?|[-_]?%>$/,
+          alias: "punctuation"
+        },
+        comment: /^#[\s\S]*/,
+        "language-javascript": {
+          pattern: /[\s\S]+/,
+          inside: Prism2.languages.javascript
+        }
+      };
+      Prism2.hooks.add("before-tokenize", function(env) {
+        var ejsPattern = /<%(?!%)[\s\S]+?%>/g;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "ejs",
+          ejsPattern
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "ejs");
+      });
+      Prism2.languages.eta = Prism2.languages.ejs;
+    })(Prism);
+  }
+  return ejs_1;
+}
+var ejsExports = requireEjs();
+const ejs = /* @__PURE__ */ getDefaultExportFromCjs(ejsExports);
+const ejs$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: ejs
+}, [ejsExports]);
+export {
+  ejs$1 as e
+};
+//# sourceMappingURL=ejs-C0LfHd6n.js.map

package/dist/ejs-C0LfHd6n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ejs-C0LfHd6n.js","sources":["../node_modules/refractor/lang/ejs.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = ejs\nejs.displayName = 'ejs'\nejs.aliases = ['eta']\nfunction ejs(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.ejs = {\n      delimiter: {\n        pattern: /^<%[-_=]?|[-_]?%>$/,\n        alias: 'punctuation'\n      },\n      comment: /^#[\\s\\S]*/,\n      'language-javascript': {\n        pattern: /[\\s\\S]+/,\n        inside: Prism.languages.javascript\n      }\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var ejsPattern = /<%(?!%)[\\s\\S]+?%>/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'ejs',\n        ejsPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'ejs')\n    })\n    Prism.languages.eta = Prism.languages.ejs\n  })(Prism)\n}\n"],"names":["require$$0","ejs","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,UAAiBC;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAC,KAAK;AACpB,WAASA,KAAI,OAAO;AAClB,UAAM,SAAS,yBAAyB;AACvC,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,WAAW;AAAA,UACT,SAAS;AAAA,UACT,OAAO;AAAA;QAET,SAAS;AAAA,QACT,uBAAuB;AAAA,UACrB,SAAS;AAAA,UACT,QAAQA,OAAM,UAAU;AAAA;;AAG5B,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,aAAa;AACjB,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA;MAER,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,KAAK;AAAA,MAC1E,CAAK;AACD,MAAAA,OAAM,UAAU,MAAMA,OAAM,UAAU;AAAA,IAC1C,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/elixir-UYcL6AXW.js

@@ -0,0 +1,139 @@
+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 elixir_1;
+var hasRequiredElixir;
+function requireElixir() {
+  if (hasRequiredElixir) return elixir_1;
+  hasRequiredElixir = 1;
+  elixir_1 = elixir2;
+  elixir2.displayName = "elixir";
+  elixir2.aliases = [];
+  function elixir2(Prism) {
+    Prism.languages.elixir = {
+      doc: {
+        pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
+        inside: {
+          attribute: /^@\w+/,
+          string: /['"][\s\S]+/
+        }
+      },
+      comment: {
+        pattern: /#.*/,
+        greedy: true
+      },
+      // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
+      regex: {
+        pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
+        greedy: true
+      },
+      string: [
+        {
+          // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
+          pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
+          greedy: true,
+          inside: {
+            // See interpolation below
+          }
+        },
+        {
+          pattern: /("""|''')[\s\S]*?\1/,
+          greedy: true,
+          inside: {
+            // See interpolation below
+          }
+        },
+        {
+          // Multi-line strings are allowed
+          pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+          greedy: true,
+          inside: {
+            // See interpolation below
+          }
+        }
+      ],
+      atom: {
+        // Look-behind prevents bad highlighting of the :: operator
+        pattern: /(^|[^:]):\w+/,
+        lookbehind: true,
+        alias: "symbol"
+      },
+      module: {
+        pattern: /\b[A-Z]\w*\b/,
+        alias: "class-name"
+      },
+      // Look-ahead prevents bad highlighting of the :: operator
+      "attr-name": /\b\w+\??:(?!:)/,
+      argument: {
+        // Look-behind prevents bad highlighting of the && operator
+        pattern: /(^|[^&])&\d+/,
+        lookbehind: true,
+        alias: "variable"
+      },
+      attribute: {
+        pattern: /@\w+/,
+        alias: "variable"
+      },
+      function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
+      number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
+      keyword: /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
+      boolean: /\b(?:false|nil|true)\b/,
+      operator: [
+        /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
+        {
+          // We don't want to match <<
+          pattern: /([^<])<(?!<)/,
+          lookbehind: true
+        },
+        {
+          // We don't want to match >>
+          pattern: /([^>])>(?!>)/,
+          lookbehind: true
+        }
+      ],
+      punctuation: /<<|>>|[.,%\[\]{}()]/
+    };
+    Prism.languages.elixir.string.forEach(function(o) {
+      o.inside = {
+        interpolation: {
+          pattern: /#\{[^}]+\}/,
+          inside: {
+            delimiter: {
+              pattern: /^#\{|\}$/,
+              alias: "punctuation"
+            },
+            rest: Prism.languages.elixir
+          }
+        }
+      };
+    });
+  }
+  return elixir_1;
+}
+var elixirExports = requireElixir();
+const elixir = /* @__PURE__ */ getDefaultExportFromCjs(elixirExports);
+const elixir$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: elixir
+}, [elixirExports]);
+export {
+  elixir$1 as e
+};
+//# sourceMappingURL=elixir-UYcL6AXW.js.map

package/dist/elixir-UYcL6AXW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elixir-UYcL6AXW.js","sources":["../node_modules/refractor/lang/elixir.js"],"sourcesContent":["'use strict'\n\nmodule.exports = elixir\nelixir.displayName = 'elixir'\nelixir.aliases = []\nfunction elixir(Prism) {\n  Prism.languages.elixir = {\n    doc: {\n      pattern:\n        /@(?:doc|moduledoc)\\s+(?:(\"\"\"|''')[\\s\\S]*?\\1|(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\2)[^\\\\\\r\\n])*\\2)/,\n      inside: {\n        attribute: /^@\\w+/,\n        string: /['\"][\\s\\S]+/\n      }\n    },\n    comment: {\n      pattern: /#.*/,\n      greedy: true\n    },\n    // ~r\"\"\"foo\"\"\" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r\"foo\", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>\n    regex: {\n      pattern:\n        /~[rR](?:(\"\"\"|''')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1|([\\/|\"'])(?:\\\\.|(?!\\2)[^\\\\\\r\\n])+\\2|\\((?:\\\\.|[^\\\\)\\r\\n])+\\)|\\[(?:\\\\.|[^\\\\\\]\\r\\n])+\\]|\\{(?:\\\\.|[^\\\\}\\r\\n])+\\}|<(?:\\\\.|[^\\\\>\\r\\n])+>)[uismxfr]*/,\n      greedy: true\n    },\n    string: [\n      {\n        // ~s\"\"\"foo\"\"\" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s\"foo\", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>\n        pattern:\n          /~[cCsSwW](?:(\"\"\"|''')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])+\\1|([\\/|\"'])(?:\\\\.|(?!\\2)[^\\\\\\r\\n])+\\2|\\((?:\\\\.|[^\\\\)\\r\\n])+\\)|\\[(?:\\\\.|[^\\\\\\]\\r\\n])+\\]|\\{(?:\\\\.|#\\{[^}]+\\}|#(?!\\{)|[^#\\\\}\\r\\n])+\\}|<(?:\\\\.|[^\\\\>\\r\\n])+>)[csa]?/,\n        greedy: true,\n        inside: {\n          // See interpolation below\n        }\n      },\n      {\n        pattern: /(\"\"\"|''')[\\s\\S]*?\\1/,\n        greedy: true,\n        inside: {\n          // See interpolation below\n        }\n      },\n      {\n        // Multi-line strings are allowed\n        pattern: /(\"|')(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n        greedy: true,\n        inside: {\n          // See interpolation below\n        }\n      }\n    ],\n    atom: {\n      // Look-behind prevents bad highlighting of the :: operator\n      pattern: /(^|[^:]):\\w+/,\n      lookbehind: true,\n      alias: 'symbol'\n    },\n    module: {\n      pattern: /\\b[A-Z]\\w*\\b/,\n      alias: 'class-name'\n    },\n    // Look-ahead prevents bad highlighting of the :: operator\n    'attr-name': /\\b\\w+\\??:(?!:)/,\n    argument: {\n      // Look-behind prevents bad highlighting of the && operator\n      pattern: /(^|[^&])&\\d+/,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    attribute: {\n      pattern: /@\\w+/,\n      alias: 'variable'\n    },\n    function: /\\b[_a-zA-Z]\\w*[?!]?(?:(?=\\s*(?:\\.\\s*)?\\()|(?=\\/\\d))/,\n    number: /\\b(?:0[box][a-f\\d_]+|\\d[\\d_]*)(?:\\.[\\d_]+)?(?:e[+-]?[\\d_]+)?\\b/i,\n    keyword:\n      /\\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\\b/,\n    boolean: /\\b(?:false|nil|true)\\b/,\n    operator: [\n      /\\bin\\b|&&?|\\|[|>]?|\\\\\\\\|::|\\.\\.\\.?|\\+\\+?|-[->]?|<[-=>]|>=|!==?|\\B!|=(?:==?|[>~])?|[*\\/^]/,\n      {\n        // We don't want to match <<\n        pattern: /([^<])<(?!<)/,\n        lookbehind: true\n      },\n      {\n        // We don't want to match >>\n        pattern: /([^>])>(?!>)/,\n        lookbehind: true\n      }\n    ],\n    punctuation: /<<|>>|[.,%\\[\\]{}()]/\n  }\n  Prism.languages.elixir.string.forEach(function (o) {\n    o.inside = {\n      interpolation: {\n        pattern: /#\\{[^}]+\\}/,\n        inside: {\n          delimiter: {\n            pattern: /^#\\{|\\}$/,\n            alias: 'punctuation'\n          },\n          rest: Prism.languages.elixir\n        }\n      }\n    }\n  })\n}\n"],"names":["elixir"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,KAAK;AAAA,QACH,SACE;AAAA,QACF,QAAQ;AAAA,UACN,WAAW;AAAA,UACX,QAAQ;AAAA;;MAGZ,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,OAAO;AAAA,QACL,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN;AAAA;AAAA,UAEE,SACE;AAAA,UACF,QAAQ;AAAA,UACR,QAAQ;AAAA;AAAA;;QAIV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA;AAAA;;QAIV;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA;AAAA;;;MAKZ,MAAM;AAAA;AAAA,QAEJ,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA;;MAGT,aAAa;AAAA,MACb,UAAU;AAAA;AAAA,QAER,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,SACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,QACR;AAAA,QACA;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,aAAa;AAAA;AAEf,UAAM,UAAU,OAAO,OAAO,QAAQ,SAAU,GAAG;AACjD,QAAE,SAAS;AAAA,QACT,eAAe;AAAA,UACb,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA;YAET,MAAM,MAAM,UAAU;AAAA;;;IAIhC,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/elm-C9_r2OCV.js

@@ -0,0 +1,87 @@
+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 elm_1;
+var hasRequiredElm;
+function requireElm() {
+  if (hasRequiredElm) return elm_1;
+  hasRequiredElm = 1;
+  elm_1 = elm2;
+  elm2.displayName = "elm";
+  elm2.aliases = [];
+  function elm2(Prism) {
+    Prism.languages.elm = {
+      comment: /--.*|\{-[\s\S]*?-\}/,
+      char: {
+        pattern: /'(?:[^\\'\r\n]|\\(?:[abfnrtv\\']|\d+|x[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}))'/,
+        greedy: true
+      },
+      string: [
+        {
+          // Multiline strings are wrapped in triple ". Quotes may appear unescaped.
+          pattern: /"""[\s\S]*?"""/,
+          greedy: true
+        },
+        {
+          pattern: /"(?:[^\\"\r\n]|\\.)*"/,
+          greedy: true
+        }
+      ],
+      "import-statement": {
+        // The imported or hidden names are not included in this import
+        // statement. This is because we want to highlight those exactly like
+        // we do for the names in the program.
+        pattern: /(^[\t ]*)import\s+[A-Z]\w*(?:\.[A-Z]\w*)*(?:\s+as\s+(?:[A-Z]\w*)(?:\.[A-Z]\w*)*)?(?:\s+exposing\s+)?/m,
+        lookbehind: true,
+        inside: {
+          keyword: /\b(?:as|exposing|import)\b/
+        }
+      },
+      keyword: /\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\b/,
+      // These are builtin variables only. Constructors are highlighted later as a constant.
+      builtin: /\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\b/,
+      // decimal integers and floating point numbers | hexadecimal integers
+      number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[0-9a-f]+)\b/i,
+      // Most of this is needed because of the meaning of a single '.'.
+      // If it stands alone freely, it is the function composition.
+      // It may also be a separator between a module name and an identifier => no
+      // operator. If it comes together with other special characters it is an
+      // operator too.
+      // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!
+      // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ
+      operator: /\s\.\s|[+\-/*=.$<>:&|^?%#@~!]{2,}|[+\-/*=$<>:&|^?%#@~!]/,
+      // In Elm, nearly everything is a variable, do not highlight these.
+      hvariable: /\b(?:[A-Z]\w*\.)*[a-z]\w*\b/,
+      constant: /\b(?:[A-Z]\w*\.)*[A-Z]\w*\b/,
+      punctuation: /[{}[\]|(),.:]/
+    };
+  }
+  return elm_1;
+}
+var elmExports = requireElm();
+const elm = /* @__PURE__ */ getDefaultExportFromCjs(elmExports);
+const elm$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: elm
+}, [elmExports]);
+export {
+  elm$1 as e
+};
+//# sourceMappingURL=elm-C9_r2OCV.js.map

package/dist/elm-C9_r2OCV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elm-C9_r2OCV.js","sources":["../node_modules/refractor/lang/elm.js"],"sourcesContent":["'use strict'\n\nmodule.exports = elm\nelm.displayName = 'elm'\nelm.aliases = []\nfunction elm(Prism) {\n  Prism.languages.elm = {\n    comment: /--.*|\\{-[\\s\\S]*?-\\}/,\n    char: {\n      pattern:\n        /'(?:[^\\\\'\\r\\n]|\\\\(?:[abfnrtv\\\\']|\\d+|x[0-9a-fA-F]+|u\\{[0-9a-fA-F]+\\}))'/,\n      greedy: true\n    },\n    string: [\n      {\n        // Multiline strings are wrapped in triple \". Quotes may appear unescaped.\n        pattern: /\"\"\"[\\s\\S]*?\"\"\"/,\n        greedy: true\n      },\n      {\n        pattern: /\"(?:[^\\\\\"\\r\\n]|\\\\.)*\"/,\n        greedy: true\n      }\n    ],\n    'import-statement': {\n      // The imported or hidden names are not included in this import\n      // statement. This is because we want to highlight those exactly like\n      // we do for the names in the program.\n      pattern:\n        /(^[\\t ]*)import\\s+[A-Z]\\w*(?:\\.[A-Z]\\w*)*(?:\\s+as\\s+(?:[A-Z]\\w*)(?:\\.[A-Z]\\w*)*)?(?:\\s+exposing\\s+)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|exposing|import)\\b/\n      }\n    },\n    keyword:\n      /\\b(?:alias|as|case|else|exposing|if|in|infixl|infixr|let|module|of|then|type)\\b/,\n    // These are builtin variables only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:abs|acos|always|asin|atan|atan2|ceiling|clamp|compare|cos|curry|degrees|e|flip|floor|fromPolar|identity|isInfinite|isNaN|logBase|max|min|negate|never|not|pi|radians|rem|round|sin|sqrt|tan|toFloat|toPolar|toString|truncate|turns|uncurry|xor)\\b/,\n    // decimal integers and floating point numbers | hexadecimal integers\n    number: /\\b(?:\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?|0x[0-9a-f]+)\\b/i,\n    // Most of this is needed because of the meaning of a single '.'.\n    // If it stands alone freely, it is the function composition.\n    // It may also be a separator between a module name and an identifier => no\n    // operator. If it comes together with other special characters it is an\n    // operator too.\n    // Valid operator characters in 0.18: +-/*=.$<>:&|^?%#@~!\n    // Ref: https://groups.google.com/forum/#!msg/elm-dev/0AHSnDdkSkQ/E0SVU70JEQAJ\n    operator: /\\s\\.\\s|[+\\-/*=.$<>:&|^?%#@~!]{2,}|[+\\-/*=$<>:&|^?%#@~!]/,\n    // In Elm, nearly everything is a variable, do not highlight these.\n    hvariable: /\\b(?:[A-Z]\\w*\\.)*[a-z]\\w*\\b/,\n    constant: /\\b(?:[A-Z]\\w*\\.)*[A-Z]\\w*\\b/,\n    punctuation: /[{}[\\]|(),.:]/\n  }\n}\n"],"names":["elm"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA,MACT,MAAM;AAAA,QACJ,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,oBAAoB;AAAA;AAAA;AAAA;AAAA,QAIlB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA;;MAGb,SACE;AAAA;AAAA,MAEF,SACE;AAAA;AAAA,MAEF,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQR,UAAU;AAAA;AAAA,MAEV,WAAW;AAAA,MACX,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/erb-D5FMQg7S.js

@@ -0,0 +1,73 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireRuby } from "./ruby-BhyE9auN.js";
+import { r as requireMarkupTemplating } from "./markup-templating-hY-QSL53.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 erb_1;
+var hasRequiredErb;
+function requireErb() {
+  if (hasRequiredErb) return erb_1;
+  hasRequiredErb = 1;
+  var refractorRuby = requireRuby();
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  erb_1 = erb2;
+  erb2.displayName = "erb";
+  erb2.aliases = [];
+  function erb2(Prism) {
+    Prism.register(refractorRuby);
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      Prism2.languages.erb = {
+        delimiter: {
+          pattern: /^(\s*)<%=?|%>(?=\s*$)/,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        ruby: {
+          pattern: /\s*\S[\s\S]*/,
+          alias: "language-ruby",
+          inside: Prism2.languages.ruby
+        }
+      };
+      Prism2.hooks.add("before-tokenize", function(env) {
+        var erbPattern = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "erb",
+          erbPattern
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "erb");
+      });
+    })(Prism);
+  }
+  return erb_1;
+}
+var erbExports = requireErb();
+const erb = /* @__PURE__ */ getDefaultExportFromCjs(erbExports);
+const erb$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: erb
+}, [erbExports]);
+export {
+  erb$1 as e
+};
+//# sourceMappingURL=erb-D5FMQg7S.js.map

package/dist/erb-D5FMQg7S.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"erb-D5FMQg7S.js","sources":["../node_modules/refractor/lang/erb.js"],"sourcesContent":["'use strict'\nvar refractorRuby = require('./ruby.js')\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = erb\nerb.displayName = 'erb'\nerb.aliases = []\nfunction erb(Prism) {\n  Prism.register(refractorRuby)\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.erb = {\n      delimiter: {\n        pattern: /^(\\s*)<%=?|%>(?=\\s*$)/,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      ruby: {\n        pattern: /\\s*\\S[\\s\\S]*/,\n        alias: 'language-ruby',\n        inside: Prism.languages.ruby\n      }\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var erbPattern =\n        /<%=?(?:[^\\r\\n]|[\\r\\n](?!=begin)|[\\r\\n]=begin\\s(?:[^\\r\\n]|[\\r\\n](?!=end))*[\\r\\n]=end)+?%>/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'erb',\n        erbPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'erb')\n    })\n  })(Prism)\n}\n"],"names":["require$$0","require$$1","erb","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,gBAAgBA,YAAA;AACpB,MAAI,4BAA4BC,wBAAA;AAChC,UAAiBC;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,SAAS,aAAa;AAC5B,UAAM,SAAS,yBAAyB;AACvC,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,WAAW;AAAA,UACT,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,MAAM;AAAA,UACJ,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQA,OAAM,UAAU;AAAA;;AAG5B,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,aACF;AACF,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA;MAER,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,KAAK;AAAA,MAC1E,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/erlang-CblSVls5.js

@@ -0,0 +1,85 @@
+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 erlang_1;
+var hasRequiredErlang;
+function requireErlang() {
+  if (hasRequiredErlang) return erlang_1;
+  hasRequiredErlang = 1;
+  erlang_1 = erlang2;
+  erlang2.displayName = "erlang";
+  erlang2.aliases = [];
+  function erlang2(Prism) {
+    Prism.languages.erlang = {
+      comment: /%.+/,
+      string: {
+        pattern: /"(?:\\.|[^\\"\r\n])*"/,
+        greedy: true
+      },
+      "quoted-function": {
+        pattern: /'(?:\\.|[^\\'\r\n])+'(?=\()/,
+        alias: "function"
+      },
+      "quoted-atom": {
+        pattern: /'(?:\\.|[^\\'\r\n])+'/,
+        alias: "atom"
+      },
+      boolean: /\b(?:false|true)\b/,
+      keyword: /\b(?:after|case|catch|end|fun|if|of|receive|try|when)\b/,
+      number: [
+        /\$\\?./,
+        /\b\d+#[a-z0-9]+/i,
+        /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i
+      ],
+      function: /\b[a-z][\w@]*(?=\()/,
+      variable: {
+        // Look-behind is used to prevent wrong highlighting of atoms containing "@"
+        pattern: /(^|[^@])(?:\b|\?)[A-Z_][\w@]*/,
+        lookbehind: true
+      },
+      operator: [
+        /[=\/<>:]=|=[:\/]=|\+\+?|--?|[=*\/!]|\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\b/,
+        {
+          // We don't want to match <<
+          pattern: /(^|[^<])<(?!<)/,
+          lookbehind: true
+        },
+        {
+          // We don't want to match >>
+          pattern: /(^|[^>])>(?!>)/,
+          lookbehind: true
+        }
+      ],
+      atom: /\b[a-z][\w@]*/,
+      punctuation: /[()[\]{}:;,.#|]|<<|>>/
+    };
+  }
+  return erlang_1;
+}
+var erlangExports = requireErlang();
+const erlang = /* @__PURE__ */ getDefaultExportFromCjs(erlangExports);
+const erlang$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: erlang
+}, [erlangExports]);
+export {
+  erlang$1 as e
+};
+//# sourceMappingURL=erlang-CblSVls5.js.map

package/dist/erlang-CblSVls5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"erlang-CblSVls5.js","sources":["../node_modules/refractor/lang/erlang.js"],"sourcesContent":["'use strict'\n\nmodule.exports = erlang\nerlang.displayName = 'erlang'\nerlang.aliases = []\nfunction erlang(Prism) {\n  Prism.languages.erlang = {\n    comment: /%.+/,\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n      greedy: true\n    },\n    'quoted-function': {\n      pattern: /'(?:\\\\.|[^\\\\'\\r\\n])+'(?=\\()/,\n      alias: 'function'\n    },\n    'quoted-atom': {\n      pattern: /'(?:\\\\.|[^\\\\'\\r\\n])+'/,\n      alias: 'atom'\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    keyword: /\\b(?:after|case|catch|end|fun|if|of|receive|try|when)\\b/,\n    number: [\n      /\\$\\\\?./,\n      /\\b\\d+#[a-z0-9]+/i,\n      /(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i\n    ],\n    function: /\\b[a-z][\\w@]*(?=\\()/,\n    variable: {\n      // Look-behind is used to prevent wrong highlighting of atoms containing \"@\"\n      pattern: /(^|[^@])(?:\\b|\\?)[A-Z_][\\w@]*/,\n      lookbehind: true\n    },\n    operator: [\n      /[=\\/<>:]=|=[:\\/]=|\\+\\+?|--?|[=*\\/!]|\\b(?:and|andalso|band|bnot|bor|bsl|bsr|bxor|div|not|or|orelse|rem|xor)\\b/,\n      {\n        // We don't want to match <<\n        pattern: /(^|[^<])<(?!<)/,\n        lookbehind: true\n      },\n      {\n        // We don't want to match >>\n        pattern: /(^|[^>])>(?!>)/,\n        lookbehind: true\n      }\n    ],\n    atom: /\\b[a-z][\\w@]*/,\n    punctuation: /[()[\\]{}:;,.#|]|<<|>>/\n  }\n}\n"],"names":["erlang"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,mBAAmB;AAAA,QACjB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,eAAe;AAAA,QACb,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SAAS;AAAA,MACT,SAAS;AAAA,MACT,QAAQ;AAAA,QACN;AAAA,QACA;AAAA,QACA;AAAA;MAEF,UAAU;AAAA,MACV,UAAU;AAAA;AAAA,QAER,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,UAAU;AAAA,QACR;AAAA,QACA;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,MAAM;AAAA,MACN,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/etlua-Cao9i-Hl.js

@@ -0,0 +1,71 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireLua } from "./lua-RL-GTNsS.js";
+import { r as requireMarkupTemplating } from "./markup-templating-hY-QSL53.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 etlua_1;
+var hasRequiredEtlua;
+function requireEtlua() {
+  if (hasRequiredEtlua) return etlua_1;
+  hasRequiredEtlua = 1;
+  var refractorLua = requireLua();
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  etlua_1 = etlua2;
+  etlua2.displayName = "etlua";
+  etlua2.aliases = [];
+  function etlua2(Prism) {
+    Prism.register(refractorLua);
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      Prism2.languages.etlua = {
+        delimiter: {
+          pattern: /^<%[-=]?|-?%>$/,
+          alias: "punctuation"
+        },
+        "language-lua": {
+          pattern: /[\s\S]+/,
+          inside: Prism2.languages.lua
+        }
+      };
+      Prism2.hooks.add("before-tokenize", function(env) {
+        var pattern = /<%[\s\S]+?%>/g;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "etlua",
+          pattern
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "etlua");
+      });
+    })(Prism);
+  }
+  return etlua_1;
+}
+var etluaExports = requireEtlua();
+const etlua = /* @__PURE__ */ getDefaultExportFromCjs(etluaExports);
+const etlua$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: etlua
+}, [etluaExports]);
+export {
+  etlua$1 as e
+};
+//# sourceMappingURL=etlua-Cao9i-Hl.js.map

package/dist/etlua-Cao9i-Hl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"etlua-Cao9i-Hl.js","sources":["../node_modules/refractor/lang/etlua.js"],"sourcesContent":["'use strict'\nvar refractorLua = require('./lua.js')\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = etlua\netlua.displayName = 'etlua'\netlua.aliases = []\nfunction etlua(Prism) {\n  Prism.register(refractorLua)\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.etlua = {\n      delimiter: {\n        pattern: /^<%[-=]?|-?%>$/,\n        alias: 'punctuation'\n      },\n      'language-lua': {\n        pattern: /[\\s\\S]+/,\n        inside: Prism.languages.lua\n      }\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var pattern = /<%[\\s\\S]+?%>/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'etlua',\n        pattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'etlua')\n    })\n  })(Prism)\n}\n"],"names":["require$$0","require$$1","etlua","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,eAAeA,WAAA;AACnB,MAAI,4BAA4BC,wBAAA;AAChC,YAAiBC;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,SAAS,YAAY;AAC3B,UAAM,SAAS,yBAAyB;AACvC,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,QAAQ;AAAA,QACtB,WAAW;AAAA,UACT,SAAS;AAAA,UACT,OAAO;AAAA;QAET,gBAAgB;AAAA,UACd,SAAS;AAAA,UACT,QAAQA,OAAM,UAAU;AAAA;;AAG5B,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,UAAU;AACd,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA;MAER,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,OAAO;AAAA,MAC5E,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}