@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/pure-CSevquAM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure-CSevquAM.js","sources":["../node_modules/refractor/lang/pure.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pure\npure.displayName = 'pure'\npure.aliases = []\nfunction pure(Prism) {\n  ;(function (Prism) {\n    // https://agraef.github.io/pure-docs/pure.html#lexical-matters\n    Prism.languages.pure = {\n      comment: [\n        {\n          pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n          lookbehind: true\n        },\n        {\n          pattern: /(^|[^\\\\:])\\/\\/.*/,\n          lookbehind: true\n        },\n        /#!.+/\n      ],\n      'inline-lang': {\n        pattern: /%<[\\s\\S]+?%>/,\n        greedy: true,\n        inside: {\n          lang: {\n            pattern: /(^%< *)-\\*-.+?-\\*-/,\n            lookbehind: true,\n            alias: 'comment'\n          },\n          delimiter: {\n            pattern: /^%<.*|%>$/,\n            alias: 'punctuation'\n          }\n        }\n      },\n      string: {\n        pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n        greedy: true\n      },\n      number: {\n        // The look-behind prevents wrong highlighting of the .. operator\n        pattern:\n          /((?:\\.\\.)?)(?:\\b(?:inf|nan)\\b|\\b0x[\\da-f]+|(?:\\b(?:0b)?\\d+(?:\\.\\d+)?|\\B\\.\\d+)(?:e[+-]?\\d+)?L?)/i,\n        lookbehind: true\n      },\n      keyword:\n        /\\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\\b/,\n      function:\n        /\\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\\b/,\n      special: {\n        pattern: /\\b__[a-z]+__\\b/i,\n        alias: 'builtin'\n      },\n      // Any combination of operator chars can be an operator\n      // eslint-disable-next-line no-misleading-character-class\n      operator:\n        /(?:[!\"#$%&'*+,\\-.\\/:<=>?@\\\\^`|~\\u00a1-\\u00bf\\u00d7-\\u00f7\\u20d0-\\u2bff]|\\b_+\\b)+|\\b(?:and|div|mod|not|or)\\b/,\n      // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?\n      punctuation: /[(){}\\[\\];,|]/\n    }\n    var inlineLanguages = [\n      'c',\n      {\n        lang: 'c++',\n        alias: 'cpp'\n      },\n      'fortran'\n    ]\n    var inlineLanguageRe = /%< *-\\*- *<lang>\\d* *-\\*-[\\s\\S]+?%>/.source\n    inlineLanguages.forEach(function (lang) {\n      var alias = lang\n      if (typeof lang !== 'string') {\n        alias = lang.alias\n        lang = lang.lang\n      }\n      if (Prism.languages[alias]) {\n        var o = {}\n        o['inline-lang-' + alias] = {\n          pattern: RegExp(\n            inlineLanguageRe.replace(\n              '<lang>',\n              lang.replace(/([.+*?\\/\\\\(){}\\[\\]])/g, '\\\\$1')\n            ),\n            'i'\n          ),\n          inside: Prism.util.clone(Prism.languages.pure['inline-lang'].inside)\n        }\n        o['inline-lang-' + alias].inside.rest = Prism.util.clone(\n          Prism.languages[alias]\n        )\n        Prism.languages.insertBefore('pure', 'inline-lang', o)\n      }\n    }) // C is the default inline language\n    if (Prism.languages.c) {\n      Prism.languages.pure['inline-lang'].inside.rest = Prism.util.clone(\n        Prism.languages.c\n      )\n    }\n  })(Prism)\n}\n"],"names":["pure","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AAEjB,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,UACP;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA;QAEF,eAAe;AAAA,UACb,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,MAAM;AAAA,cACJ,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA;YAET,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA;;;QAIb,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,QAAQ;AAAA;AAAA,UAEN,SACE;AAAA,UACF,YAAY;AAAA;QAEd,SACE;AAAA,QACF,UACE;AAAA,QACF,SAAS;AAAA,UACP,SAAS;AAAA,UACT,OAAO;AAAA;;;QAIT,UACE;AAAA;AAAA,QAEF,aAAa;AAAA;AAEf,UAAI,kBAAkB;AAAA,QACpB;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,OAAO;AAAA;QAET;AAAA;AAEF,UAAI,mBAAmB,sCAAsC;AAC7D,sBAAgB,QAAQ,SAAU,MAAM;AACtC,YAAI,QAAQ;AACZ,YAAI,OAAO,SAAS,UAAU;AAC5B,kBAAQ,KAAK;AACb,iBAAO,KAAK;AAAA,QACpB;AACM,YAAIA,OAAM,UAAU,KAAK,GAAG;AAC1B,cAAI,IAAI,CAAA;AACR,YAAE,iBAAiB,KAAK,IAAI;AAAA,YAC1B,SAAS;AAAA,cACP,iBAAiB;AAAA,gBACf;AAAA,gBACA,KAAK,QAAQ,yBAAyB,MAAM;AAAA;cAE9C;AAAA;YAEF,QAAQA,OAAM,KAAK,MAAMA,OAAM,UAAU,KAAK,aAAa,EAAE,MAAM;AAAA;AAErE,YAAE,iBAAiB,KAAK,EAAE,OAAO,OAAOA,OAAM,KAAK;AAAA,YACjDA,OAAM,UAAU,KAAK;AAAA;AAEvB,UAAAA,OAAM,UAAU,aAAa,QAAQ,eAAe,CAAC;AAAA,QAC7D;AAAA,MACA,CAAK;AACD,UAAIA,OAAM,UAAU,GAAG;AACrB,QAAAA,OAAM,UAAU,KAAK,aAAa,EAAE,OAAO,OAAOA,OAAM,KAAK;AAAA,UAC3DA,OAAM,UAAU;AAAA;MAExB;AAAA,IACA,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/purebasic-DlD9-uDd.js

@@ -0,0 +1,100 @@
+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 purebasic_1;
+var hasRequiredPurebasic;
+function requirePurebasic() {
+  if (hasRequiredPurebasic) return purebasic_1;
+  hasRequiredPurebasic = 1;
+  purebasic_1 = purebasic2;
+  purebasic2.displayName = "purebasic";
+  purebasic2.aliases = [];
+  function purebasic2(Prism) {
+    Prism.languages.purebasic = Prism.languages.extend("clike", {
+      comment: /;.*/,
+      keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
+      function: /\b\w+(?:\.\w+)?\s*(?=\()/,
+      number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
+      operator: /(?:@\*?|\?|\*)\w+|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
+    });
+    Prism.languages.insertBefore("purebasic", "keyword", {
+      tag: /#\w+\$?/,
+      asm: {
+        pattern: /(^[\t ]*)!.*/m,
+        lookbehind: true,
+        alias: "tag",
+        inside: {
+          comment: /;.*/,
+          string: {
+            pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+            greedy: true
+          },
+          // Anonymous label references, i.e.: jmp @b
+          "label-reference-anonymous": {
+            pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
+            lookbehind: true,
+            alias: "fasm-label"
+          },
+          // Named label reference, i.e.: jne label1
+          "label-reference-addressed": {
+            pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
+            lookbehind: true,
+            alias: "fasm-label"
+          },
+          keyword: [
+            /\b(?:extern|global)\b[^;\r\n]*/i,
+            /\b(?:CPU|DEFAULT|FLOAT)\b.*/
+          ],
+          function: {
+            pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
+            lookbehind: true
+          },
+          "function-inline": {
+            pattern: /(:\s*)[\da-z]+(?=\s)/i,
+            lookbehind: true,
+            alias: "function"
+          },
+          label: {
+            pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
+            lookbehind: true,
+            alias: "fasm-label"
+          },
+          register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
+          number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+          operator: /[\[\]*+\-/%<>=&|$!,.:]/
+        }
+      }
+    });
+    delete Prism.languages.purebasic["class-name"];
+    delete Prism.languages.purebasic["boolean"];
+    Prism.languages.pbfasm = Prism.languages["purebasic"];
+  }
+  return purebasic_1;
+}
+var purebasicExports = requirePurebasic();
+const purebasic = /* @__PURE__ */ getDefaultExportFromCjs(purebasicExports);
+const purebasic$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: purebasic
+}, [purebasicExports]);
+export {
+  purebasic$1 as p
+};
+//# sourceMappingURL=purebasic-DlD9-uDd.js.map

package/dist/purebasic-DlD9-uDd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"purebasic-DlD9-uDd.js","sources":["../node_modules/refractor/lang/purebasic.js"],"sourcesContent":["'use strict'\n\nmodule.exports = purebasic\npurebasic.displayName = 'purebasic'\npurebasic.aliases = []\nfunction purebasic(Prism) {\n  /*\nOriginal Code by Bas Groothedde\n!!MANY THANKS!! I never would have made this, regex and me will never be best friends ;)\n==> https://codepen.io/ImagineProgramming/details/JYydBy/\nslightly changed to pass all tests\n*/\n  // PureBasic support, steal stuff from ansi-c\n  Prism.languages.purebasic = Prism.languages.extend('clike', {\n    comment: /;.*/,\n    keyword:\n      /\\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\\b/i,\n    function: /\\b\\w+(?:\\.\\w+)?\\s*(?=\\()/,\n    number: /(?:\\$[\\da-f]+|\\b-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e[+-]?\\d+)?)\\b/i,\n    operator:\n      /(?:@\\*?|\\?|\\*)\\w+|-[>-]?|\\+\\+?|!=?|<<?=?|>>?=?|==?|&&?|\\|?\\||[~^%?*/@]/\n  })\n  Prism.languages.insertBefore('purebasic', 'keyword', {\n    tag: /#\\w+\\$?/,\n    asm: {\n      pattern: /(^[\\t ]*)!.*/m,\n      lookbehind: true,\n      alias: 'tag',\n      inside: {\n        comment: /;.*/,\n        string: {\n          pattern: /([\"'`])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n          greedy: true\n        },\n        // Anonymous label references, i.e.: jmp @b\n        'label-reference-anonymous': {\n          pattern: /(!\\s*j[a-z]+\\s+)@[fb]/i,\n          lookbehind: true,\n          alias: 'fasm-label'\n        },\n        // Named label reference, i.e.: jne label1\n        'label-reference-addressed': {\n          pattern: /(!\\s*j[a-z]+\\s+)[A-Z._?$@][\\w.?$@~#]*/i,\n          lookbehind: true,\n          alias: 'fasm-label'\n        },\n        keyword: [\n          /\\b(?:extern|global)\\b[^;\\r\\n]*/i,\n          /\\b(?:CPU|DEFAULT|FLOAT)\\b.*/\n        ],\n        function: {\n          pattern: /^([\\t ]*!\\s*)[\\da-z]+(?=\\s|$)/im,\n          lookbehind: true\n        },\n        'function-inline': {\n          pattern: /(:\\s*)[\\da-z]+(?=\\s)/i,\n          lookbehind: true,\n          alias: 'function'\n        },\n        label: {\n          pattern: /^([\\t ]*!\\s*)[A-Za-z._?$@][\\w.?$@~#]*(?=:)/m,\n          lookbehind: true,\n          alias: 'fasm-label'\n        },\n        register:\n          /\\b(?:st\\d|[xyz]mm\\d\\d?|[cdt]r\\d|r\\d\\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\\d+)\\b/i,\n        number:\n          /(?:\\b|-|(?=\\$))(?:0[hx](?:[\\da-f]*\\.)?[\\da-f]+(?:p[+-]?\\d+)?|\\d[\\da-f]+[hx]|\\$\\d[\\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\\d+|(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:\\.?e[+-]?\\d+)?[dt]?)\\b/i,\n        operator: /[\\[\\]*+\\-/%<>=&|$!,.:]/\n      }\n    }\n  })\n  delete Prism.languages.purebasic['class-name']\n  delete Prism.languages.purebasic['boolean']\n  Prism.languages.pbfasm = Prism.languages['purebasic']\n}\n"],"names":["purebasic"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gBAAiBA;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AAQxB,UAAM,UAAU,YAAY,MAAM,UAAU,OAAO,SAAS;AAAA,MAC1D,SAAS;AAAA,MACT,SACE;AAAA,MACF,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,aAAa,WAAW;AAAA,MACnD,KAAK;AAAA,MACL,KAAK;AAAA,QACH,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,SAAS;AAAA,YACT,QAAQ;AAAA;;UAGV,6BAA6B;AAAA,YAC3B,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;;UAGT,6BAA6B;AAAA,YAC3B,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,SAAS;AAAA,YACP;AAAA,YACA;AAAA;UAEF,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,mBAAmB;AAAA,YACjB,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,OAAO;AAAA,YACL,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,UACE;AAAA,UACF,QACE;AAAA,UACF,UAAU;AAAA;;IAGlB,CAAG;AACD,WAAO,MAAM,UAAU,UAAU,YAAY;AAC7C,WAAO,MAAM,UAAU,UAAU,SAAS;AAC1C,UAAM,UAAU,SAAS,MAAM,UAAU,WAAW;AAAA,EACtD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/purescript-Bb15-_Rv.js

@@ -0,0 +1,72 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireHaskell } from "./haskell-JxV6F6a2.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 purescript_1;
+var hasRequiredPurescript;
+function requirePurescript() {
+  if (hasRequiredPurescript) return purescript_1;
+  hasRequiredPurescript = 1;
+  var refractorHaskell = requireHaskell();
+  purescript_1 = purescript2;
+  purescript2.displayName = "purescript";
+  purescript2.aliases = ["purs"];
+  function purescript2(Prism) {
+    Prism.register(refractorHaskell);
+    Prism.languages.purescript = Prism.languages.extend("haskell", {
+      keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
+      "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+hiding\b)?/m,
+        lookbehind: true,
+        inside: {
+          keyword: /\b(?:as|hiding|import)\b/,
+          punctuation: /\./
+        }
+      },
+      // These are builtin functions only. Constructors are highlighted later as a constant.
+      builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
+      operator: [
+        // Infix operators
+        Prism.languages.haskell.operator[0],
+        // ASCII operators
+        Prism.languages.haskell.operator[2],
+        // All UTF16 Unicode operator symbols
+        // This regex is equivalent to /(?=[\x80-\uFFFF])[\p{gc=Math_Symbol}\p{gc=Currency_Symbol}\p{Modifier_Symbol}\p{Other_Symbol}]/u
+        // See https://github.com/PrismJS/prism/issues/3006 for more details.
+        /[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
+      ]
+    });
+    Prism.languages.purs = Prism.languages.purescript;
+  }
+  return purescript_1;
+}
+var purescriptExports = requirePurescript();
+const purescript = /* @__PURE__ */ getDefaultExportFromCjs(purescriptExports);
+const purescript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: purescript
+}, [purescriptExports]);
+export {
+  purescript$1 as p
+};
+//# sourceMappingURL=purescript-Bb15-_Rv.js.map

package/dist/purescript-Bb15-_Rv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"purescript-Bb15-_Rv.js","sources":["../node_modules/refractor/lang/purescript.js"],"sourcesContent":["'use strict'\nvar refractorHaskell = require('./haskell.js')\nmodule.exports = purescript\npurescript.displayName = 'purescript'\npurescript.aliases = ['purs']\nfunction purescript(Prism) {\n  Prism.register(refractorHaskell)\n  Prism.languages.purescript = Prism.languages.extend('haskell', {\n    keyword:\n      /\\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\\b|∀/,\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+hiding\\b)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|hiding|import)\\b/,\n        punctuation: /\\./\n      }\n    },\n    // These are builtin functions only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\\b/,\n    operator: [\n      // Infix operators\n      Prism.languages.haskell.operator[0], // ASCII operators\n      Prism.languages.haskell.operator[2], // All UTF16 Unicode operator symbols\n      // This regex is equivalent to /(?=[\\x80-\\uFFFF])[\\p{gc=Math_Symbol}\\p{gc=Currency_Symbol}\\p{Modifier_Symbol}\\p{Other_Symbol}]/u\n      // See https://github.com/PrismJS/prism/issues/3006 for more details.\n      /[\\xa2-\\xa6\\xa8\\xa9\\xac\\xae-\\xb1\\xb4\\xb8\\xd7\\xf7\\u02c2-\\u02c5\\u02d2-\\u02df\\u02e5-\\u02eb\\u02ed\\u02ef-\\u02ff\\u0375\\u0384\\u0385\\u03f6\\u0482\\u058d-\\u058f\\u0606-\\u0608\\u060b\\u060e\\u060f\\u06de\\u06e9\\u06fd\\u06fe\\u07f6\\u07fe\\u07ff\\u09f2\\u09f3\\u09fa\\u09fb\\u0af1\\u0b70\\u0bf3-\\u0bfa\\u0c7f\\u0d4f\\u0d79\\u0e3f\\u0f01-\\u0f03\\u0f13\\u0f15-\\u0f17\\u0f1a-\\u0f1f\\u0f34\\u0f36\\u0f38\\u0fbe-\\u0fc5\\u0fc7-\\u0fcc\\u0fce\\u0fcf\\u0fd5-\\u0fd8\\u109e\\u109f\\u1390-\\u1399\\u166d\\u17db\\u1940\\u19de-\\u19ff\\u1b61-\\u1b6a\\u1b74-\\u1b7c\\u1fbd\\u1fbf-\\u1fc1\\u1fcd-\\u1fcf\\u1fdd-\\u1fdf\\u1fed-\\u1fef\\u1ffd\\u1ffe\\u2044\\u2052\\u207a-\\u207c\\u208a-\\u208c\\u20a0-\\u20bf\\u2100\\u2101\\u2103-\\u2106\\u2108\\u2109\\u2114\\u2116-\\u2118\\u211e-\\u2123\\u2125\\u2127\\u2129\\u212e\\u213a\\u213b\\u2140-\\u2144\\u214a-\\u214d\\u214f\\u218a\\u218b\\u2190-\\u2307\\u230c-\\u2328\\u232b-\\u2426\\u2440-\\u244a\\u249c-\\u24e9\\u2500-\\u2767\\u2794-\\u27c4\\u27c7-\\u27e5\\u27f0-\\u2982\\u2999-\\u29d7\\u29dc-\\u29fb\\u29fe-\\u2b73\\u2b76-\\u2b95\\u2b97-\\u2bff\\u2ce5-\\u2cea\\u2e50\\u2e51\\u2e80-\\u2e99\\u2e9b-\\u2ef3\\u2f00-\\u2fd5\\u2ff0-\\u2ffb\\u3004\\u3012\\u3013\\u3020\\u3036\\u3037\\u303e\\u303f\\u309b\\u309c\\u3190\\u3191\\u3196-\\u319f\\u31c0-\\u31e3\\u3200-\\u321e\\u322a-\\u3247\\u3250\\u3260-\\u327f\\u328a-\\u32b0\\u32c0-\\u33ff\\u4dc0-\\u4dff\\ua490-\\ua4c6\\ua700-\\ua716\\ua720\\ua721\\ua789\\ua78a\\ua828-\\ua82b\\ua836-\\ua839\\uaa77-\\uaa79\\uab5b\\uab6a\\uab6b\\ufb29\\ufbb2-\\ufbc1\\ufdfc\\ufdfd\\ufe62\\ufe64-\\ufe66\\ufe69\\uff04\\uff0b\\uff1c-\\uff1e\\uff3e\\uff40\\uff5c\\uff5e\\uffe0-\\uffe6\\uffe8-\\uffee\\ufffc\\ufffd]/\n    ]\n  })\n  Prism.languages.purs = Prism.languages.purescript\n}\n"],"names":["require$$0","purescript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,mBAAmBA,eAAA;AACvB,iBAAiBC;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,MAAM;AAC5B,WAASA,YAAW,OAAO;AACzB,UAAM,SAAS,gBAAgB;AAC/B,UAAM,UAAU,aAAa,MAAM,UAAU,OAAO,WAAW;AAAA,MAC7D,SACE;AAAA,MACF,oBAAoB;AAAA;AAAA;AAAA;AAAA,QAIlB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,aAAa;AAAA;;;MAIjB,SACE;AAAA,MACF,UAAU;AAAA;AAAA,QAER,MAAM,UAAU,QAAQ,SAAS,CAAC;AAAA;AAAA,QAClC,MAAM,UAAU,QAAQ,SAAS,CAAC;AAAA;AAAA;AAAA;AAAA,QAGlC;AAAA;IAEN,CAAG;AACD,UAAM,UAAU,OAAO,MAAM,UAAU;AAAA,EACzC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/python-Bg8LtX77.js

@@ -0,0 +1,105 @@
+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 python_1;
+var hasRequiredPython;
+function requirePython() {
+  if (hasRequiredPython) return python_1;
+  hasRequiredPython = 1;
+  python_1 = python2;
+  python2.displayName = "python";
+  python2.aliases = ["py"];
+  function python2(Prism) {
+    Prism.languages.python = {
+      comment: {
+        pattern: /(^|[^\\])#.*/,
+        lookbehind: true,
+        greedy: true
+      },
+      "string-interpolation": {
+        pattern: /(?:f|fr|rf)(?:("""|''')[\s\S]*?\1|("|')(?:\\.|(?!\2)[^\\\r\n])*\2)/i,
+        greedy: true,
+        inside: {
+          interpolation: {
+            // "{" <expression> <optional "!s", "!r", or "!a"> <optional ":" format specifier> "}"
+            pattern: /((?:^|[^{])(?:\{\{)*)\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}]|\{(?!\{)(?:[^{}])+\})+\})+\}/,
+            lookbehind: true,
+            inside: {
+              "format-spec": {
+                pattern: /(:)[^:(){}]+(?=\}$)/,
+                lookbehind: true
+              },
+              "conversion-option": {
+                pattern: /![sra](?=[:}]$)/,
+                alias: "punctuation"
+              },
+              rest: null
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      "triple-quoted-string": {
+        pattern: /(?:[rub]|br|rb)?("""|''')[\s\S]*?\1/i,
+        greedy: true,
+        alias: "string"
+      },
+      string: {
+        pattern: /(?:[rub]|br|rb)?("|')(?:\\.|(?!\1)[^\\\r\n])*\1/i,
+        greedy: true
+      },
+      function: {
+        pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/g,
+        lookbehind: true
+      },
+      "class-name": {
+        pattern: /(\bclass\s+)\w+/i,
+        lookbehind: true
+      },
+      decorator: {
+        pattern: /(^[\t ]*)@\w+(?:\.\w+)*/m,
+        lookbehind: true,
+        alias: ["annotation", "punctuation"],
+        inside: {
+          punctuation: /\./
+        }
+      },
+      keyword: /\b(?:_(?=\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\b/,
+      builtin: /\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\b/,
+      boolean: /\b(?:False|None|True)\b/,
+      number: /\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\b|(?:\b\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\B\.\d+(?:_\d+)*)(?:e[+-]?\d+(?:_\d+)*)?j?(?!\w)/i,
+      operator: /[-+%=]=?|!=|:=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+      punctuation: /[{}[\];(),.:]/
+    };
+    Prism.languages.python["string-interpolation"].inside["interpolation"].inside.rest = Prism.languages.python;
+    Prism.languages.py = Prism.languages.python;
+  }
+  return python_1;
+}
+var pythonExports = requirePython();
+const python = /* @__PURE__ */ getDefaultExportFromCjs(pythonExports);
+const python$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: python
+}, [pythonExports]);
+export {
+  python$1 as p
+};
+//# sourceMappingURL=python-Bg8LtX77.js.map

package/dist/python-Bg8LtX77.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-Bg8LtX77.js","sources":["../node_modules/refractor/lang/python.js"],"sourcesContent":["'use strict'\n\nmodule.exports = python\npython.displayName = 'python'\npython.aliases = ['py']\nfunction python(Prism) {\n  Prism.languages.python = {\n    comment: {\n      pattern: /(^|[^\\\\])#.*/,\n      lookbehind: true,\n      greedy: true\n    },\n    'string-interpolation': {\n      pattern:\n        /(?:f|fr|rf)(?:(\"\"\"|''')[\\s\\S]*?\\1|(\"|')(?:\\\\.|(?!\\2)[^\\\\\\r\\n])*\\2)/i,\n      greedy: true,\n      inside: {\n        interpolation: {\n          // \"{\" <expression> <optional \"!s\", \"!r\", or \"!a\"> <optional \":\" format specifier> \"}\"\n          pattern:\n            /((?:^|[^{])(?:\\{\\{)*)\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}]|\\{(?!\\{)(?:[^{}])+\\})+\\})+\\}/,\n          lookbehind: true,\n          inside: {\n            'format-spec': {\n              pattern: /(:)[^:(){}]+(?=\\}$)/,\n              lookbehind: true\n            },\n            'conversion-option': {\n              pattern: /![sra](?=[:}]$)/,\n              alias: 'punctuation'\n            },\n            rest: null\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    },\n    'triple-quoted-string': {\n      pattern: /(?:[rub]|br|rb)?(\"\"\"|''')[\\s\\S]*?\\1/i,\n      greedy: true,\n      alias: 'string'\n    },\n    string: {\n      pattern: /(?:[rub]|br|rb)?(\"|')(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/i,\n      greedy: true\n    },\n    function: {\n      pattern: /((?:^|\\s)def[ \\t]+)[a-zA-Z_]\\w*(?=\\s*\\()/g,\n      lookbehind: true\n    },\n    'class-name': {\n      pattern: /(\\bclass\\s+)\\w+/i,\n      lookbehind: true\n    },\n    decorator: {\n      pattern: /(^[\\t ]*)@\\w+(?:\\.\\w+)*/m,\n      lookbehind: true,\n      alias: ['annotation', 'punctuation'],\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    keyword:\n      /\\b(?:_(?=\\s*:)|and|as|assert|async|await|break|case|class|continue|def|del|elif|else|except|exec|finally|for|from|global|if|import|in|is|lambda|match|nonlocal|not|or|pass|print|raise|return|try|while|with|yield)\\b/,\n    builtin:\n      /\\b(?:__import__|abs|all|any|apply|ascii|basestring|bin|bool|buffer|bytearray|bytes|callable|chr|classmethod|cmp|coerce|compile|complex|delattr|dict|dir|divmod|enumerate|eval|execfile|file|filter|float|format|frozenset|getattr|globals|hasattr|hash|help|hex|id|input|int|intern|isinstance|issubclass|iter|len|list|locals|long|map|max|memoryview|min|next|object|oct|open|ord|pow|property|range|raw_input|reduce|reload|repr|reversed|round|set|setattr|slice|sorted|staticmethod|str|sum|super|tuple|type|unichr|unicode|vars|xrange|zip)\\b/,\n    boolean: /\\b(?:False|None|True)\\b/,\n    number:\n      /\\b0(?:b(?:_?[01])+|o(?:_?[0-7])+|x(?:_?[a-f0-9])+)\\b|(?:\\b\\d+(?:_\\d+)*(?:\\.(?:\\d+(?:_\\d+)*)?)?|\\B\\.\\d+(?:_\\d+)*)(?:e[+-]?\\d+(?:_\\d+)*)?j?(?!\\w)/i,\n    operator: /[-+%=]=?|!=|:=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.python['string-interpolation'].inside[\n    'interpolation'\n  ].inside.rest = Prism.languages.python\n  Prism.languages.py = Prism.languages.python\n}\n"],"names":["python"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,IAAI;AACtB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,wBAAwB;AAAA,QACtB,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA;AAAA,YAEb,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,eAAe;AAAA,gBACb,SAAS;AAAA,gBACT,YAAY;AAAA;cAEd,qBAAqB;AAAA,gBACnB,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,MAAM;AAAA;;UAGV,QAAQ;AAAA;;MAGZ,wBAAwB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,cAAc;AAAA,QACZ,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,WAAW;AAAA,QACT,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO,CAAC,cAAc,aAAa;AAAA,QACnC,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,SACE;AAAA,MACF,SACE;AAAA,MACF,SAAS;AAAA,MACT,QACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,OAAO,sBAAsB,EAAE,OAC7C,iBACA,OAAO,OAAO,MAAM,UAAU;AAChC,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/q-DF7uK_-J.js

@@ -0,0 +1,92 @@
+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 q_1;
+var hasRequiredQ;
+function requireQ() {
+  if (hasRequiredQ) return q_1;
+  hasRequiredQ = 1;
+  q_1 = q2;
+  q2.displayName = "q";
+  q2.aliases = [];
+  function q2(Prism) {
+    Prism.languages.q = {
+      string: /"(?:\\.|[^"\\\r\n])*"/,
+      comment: [
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.
+        {
+          pattern: /([\t )\]}])\/.*/,
+          lookbehind: true,
+          greedy: true
+        },
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.
+        // A / on a line by itself begins a multiline comment which is terminated by the next \ on a line by itself.
+        // If a / is not matched by a \, the multiline comment is unterminated and continues to end of file.
+        // The / and \ must be the first char on the line, but may be followed by any amount of whitespace.
+        {
+          pattern: /(^|\r?\n|\r)\/[\t ]*(?:(?:\r?\n|\r)(?:.*(?:\r?\n|\r(?!\n)))*?(?:\\(?=[\t ]*(?:\r?\n|\r))|$)|\S.*)/,
+          lookbehind: true,
+          greedy: true
+        },
+        // From http://code.kx.com/wiki/Reference/Slash:
+        // A \ on a line by itself with no preceding matching / will comment to end of file.
+        {
+          pattern: /^\\[\t ]*(?:\r?\n|\r)[\s\S]+/m,
+          greedy: true
+        },
+        {
+          pattern: /^#!.+/m,
+          greedy: true
+        }
+      ],
+      symbol: /`(?::\S+|[\w.]*)/,
+      datetime: {
+        pattern: /0N[mdzuvt]|0W[dtz]|\d{4}\.\d\d(?:m|\.\d\d(?:T(?:\d\d(?::\d\d(?::\d\d(?:[.:]\d\d\d)?)?)?)?)?[dz]?)|\d\d:\d\d(?::\d\d(?:[.:]\d\d\d)?)?[uvt]?/,
+        alias: "number"
+      },
+      // The negative look-ahead prevents bad highlighting
+      // of verbs 0: and 1:
+      number: /\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\da-fA-F]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?[hjfeb]?)/,
+      keyword: /\\\w+\b|\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\b/,
+      adverb: {
+        pattern: /['\/\\]:?|\beach\b/,
+        alias: "function"
+      },
+      verb: {
+        pattern: /(?:\B\.\B|\b[01]:|<[=>]?|>=?|[:+\-*%,!?~=|$&#@^]):?|\b_\b:?/,
+        alias: "operator"
+      },
+      punctuation: /[(){}\[\];.]/
+    };
+  }
+  return q_1;
+}
+var qExports = requireQ();
+const q = /* @__PURE__ */ getDefaultExportFromCjs(qExports);
+const q$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: q
+}, [qExports]);
+export {
+  q$1 as q
+};
+//# sourceMappingURL=q-DF7uK_-J.js.map

package/dist/q-DF7uK_-J.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"q-DF7uK_-J.js","sources":["../node_modules/refractor/lang/q.js"],"sourcesContent":["'use strict'\n\nmodule.exports = q\nq.displayName = 'q'\nq.aliases = []\nfunction q(Prism) {\n  Prism.languages.q = {\n    string: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n    comment: [\n      // From http://code.kx.com/wiki/Reference/Slash:\n      // When / is following a space (or a right parenthesis, bracket, or brace), it is ignored with the rest of the line.\n      {\n        pattern: /([\\t )\\]}])\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }, // From http://code.kx.com/wiki/Reference/Slash:\n      // A line which has / as its first character and contains at least one other non-whitespace character is a whole-line comment and is ignored entirely.\n      // A / on a line by itself begins a multiline comment which is terminated by the next \\ on a line by itself.\n      // If a / is not matched by a \\, the multiline comment is unterminated and continues to end of file.\n      // The / and \\ must be the first char on the line, but may be followed by any amount of whitespace.\n      {\n        pattern:\n          /(^|\\r?\\n|\\r)\\/[\\t ]*(?:(?:\\r?\\n|\\r)(?:.*(?:\\r?\\n|\\r(?!\\n)))*?(?:\\\\(?=[\\t ]*(?:\\r?\\n|\\r))|$)|\\S.*)/,\n        lookbehind: true,\n        greedy: true\n      }, // From http://code.kx.com/wiki/Reference/Slash:\n      // A \\ on a line by itself with no preceding matching / will comment to end of file.\n      {\n        pattern: /^\\\\[\\t ]*(?:\\r?\\n|\\r)[\\s\\S]+/m,\n        greedy: true\n      },\n      {\n        pattern: /^#!.+/m,\n        greedy: true\n      }\n    ],\n    symbol: /`(?::\\S+|[\\w.]*)/,\n    datetime: {\n      pattern:\n        /0N[mdzuvt]|0W[dtz]|\\d{4}\\.\\d\\d(?:m|\\.\\d\\d(?:T(?:\\d\\d(?::\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?)?)?)?[dz]?)|\\d\\d:\\d\\d(?::\\d\\d(?:[.:]\\d\\d\\d)?)?[uvt]?/,\n      alias: 'number'\n    },\n    // The negative look-ahead prevents bad highlighting\n    // of verbs 0: and 1:\n    number:\n      /\\b(?![01]:)(?:0N[hje]?|0W[hj]?|0[wn]|0x[\\da-fA-F]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?[hjfeb]?)/,\n    keyword:\n      /\\\\\\w+\\b|\\b(?:abs|acos|aj0?|all|and|any|asc|asin|asof|atan|attr|avgs?|binr?|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|ej|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|identity|idesc|if|ij|in|insert|inter|inv|keys?|last|like|list|ljf?|load|log|lower|lsq|ltime|ltrim|mavg|maxs?|mcount|md5|mdev|med|meta|mins?|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|plist|prds?|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ssr?|string|sublist|sums?|sv|svar|system|tables|tan|til|trim|txf|type|uj|ungroup|union|update|upper|upsert|value|var|views?|vs|wavg|where|while|within|wj1?|wsum|ww|xasc|xbar|xcols?|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)\\b/,\n    adverb: {\n      pattern: /['\\/\\\\]:?|\\beach\\b/,\n      alias: 'function'\n    },\n    verb: {\n      pattern: /(?:\\B\\.\\B|\\b[01]:|<[=>]?|>=?|[:+\\-*%,!?~=|$&#@^]):?|\\b_\\b:?/,\n      alias: 'operator'\n    },\n    punctuation: /[(){}\\[\\];.]/\n  }\n}\n"],"names":["q"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,QAAiBA;AACjB,EAAAA,GAAE,cAAc;AAChB,EAAAA,GAAE,UAAU,CAAA;AACZ,WAASA,GAAE,OAAO;AAChB,UAAM,UAAU,IAAI;AAAA,MAClB,QAAQ;AAAA,MACR,SAAS;AAAA;AAAA;AAAA,QAGP;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;;;;;;QAMV;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA;;;QAGV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,QAAQ;AAAA,MACR,UAAU;AAAA,QACR,SACE;AAAA,QACF,OAAO;AAAA;;;MAIT,QACE;AAAA,MACF,SACE;AAAA,MACF,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/qml-x1CtwKwT.js

@@ -0,0 +1,117 @@
+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 qml_1;
+var hasRequiredQml;
+function requireQml() {
+  if (hasRequiredQml) return qml_1;
+  hasRequiredQml = 1;
+  qml_1 = qml2;
+  qml2.displayName = "qml";
+  qml2.aliases = [];
+  function qml2(Prism) {
+    (function(Prism2) {
+      var jsString = /"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*'/.source;
+      var jsComment = /\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))*\*\//.source;
+      var jsExpr = /(?:[^\\()[\]{}"'/]|<string>|\/(?![*/])|<comment>|\(<expr>*\)|\[<expr>*\]|\{<expr>*\}|\\[\s\S])/.source.replace(/<string>/g, function() {
+        return jsString;
+      }).replace(/<comment>/g, function() {
+        return jsComment;
+      });
+      for (var i = 0; i < 2; i++) {
+        jsExpr = jsExpr.replace(/<expr>/g, function() {
+          return jsExpr;
+        });
+      }
+      jsExpr = jsExpr.replace(/<expr>/g, "[^\\s\\S]");
+      Prism2.languages.qml = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: true
+        },
+        "javascript-function": {
+          pattern: RegExp(
+            /((?:^|;)[ \t]*)function\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*\(<js>*\)\s*\{<js>*\}/.source.replace(
+              /<js>/g,
+              function() {
+                return jsExpr;
+              }
+            ),
+            "m"
+          ),
+          lookbehind: true,
+          greedy: true,
+          alias: "language-javascript",
+          inside: Prism2.languages.javascript
+        },
+        "class-name": {
+          pattern: /((?:^|[:;])[ \t]*)(?!\d)\w+(?=[ \t]*\{|[ \t]+on\b)/m,
+          lookbehind: true
+        },
+        property: [
+          {
+            pattern: /((?:^|[;{])[ \t]*)(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+            lookbehind: true
+          },
+          {
+            pattern: /((?:^|[;{])[ \t]*)property[ \t]+(?!\d)\w+(?:\.\w+)*[ \t]+(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+            lookbehind: true,
+            inside: {
+              keyword: /^property/,
+              property: /\w+(?:\.\w+)*/
+            }
+          }
+        ],
+        "javascript-expression": {
+          pattern: RegExp(
+            /(:[ \t]*)(?![\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(
+              /<js>/g,
+              function() {
+                return jsExpr;
+              }
+            ),
+            "m"
+          ),
+          lookbehind: true,
+          greedy: true,
+          alias: "language-javascript",
+          inside: Prism2.languages.javascript
+        },
+        string: {
+          pattern: /"(?:\\.|[^\\"\r\n])*"/,
+          greedy: true
+        },
+        keyword: /\b(?:as|import|on)\b/,
+        punctuation: /[{}[\]:;,]/
+      };
+    })(Prism);
+  }
+  return qml_1;
+}
+var qmlExports = requireQml();
+const qml = /* @__PURE__ */ getDefaultExportFromCjs(qmlExports);
+const qml$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: qml
+}, [qmlExports]);
+export {
+  qml$1 as q
+};
+//# sourceMappingURL=qml-x1CtwKwT.js.map

package/dist/qml-x1CtwKwT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qml-x1CtwKwT.js","sources":["../node_modules/refractor/lang/qml.js"],"sourcesContent":["'use strict'\n\nmodule.exports = qml\nqml.displayName = 'qml'\nqml.aliases = []\nfunction qml(Prism) {\n  ;(function (Prism) {\n    var jsString = /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|'(?:\\\\.|[^\\\\'\\r\\n])*'/.source\n    var jsComment = /\\/\\/.*(?!.)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\//.source\n    var jsExpr =\n      /(?:[^\\\\()[\\]{}\"'/]|<string>|\\/(?![*/])|<comment>|\\(<expr>*\\)|\\[<expr>*\\]|\\{<expr>*\\}|\\\\[\\s\\S])/.source\n        .replace(/<string>/g, function () {\n          return jsString\n        })\n        .replace(/<comment>/g, function () {\n          return jsComment\n        }) // the pattern will blow up, so only a few iterations\n    for (var i = 0; i < 2; i++) {\n      jsExpr = jsExpr.replace(/<expr>/g, function () {\n        return jsExpr\n      })\n    }\n    jsExpr = jsExpr.replace(/<expr>/g, '[^\\\\s\\\\S]')\n    Prism.languages.qml = {\n      comment: {\n        pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n        greedy: true\n      },\n      'javascript-function': {\n        pattern: RegExp(\n          /((?:^|;)[ \\t]*)function\\s+(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*\\(<js>*\\)\\s*\\{<js>*\\}/.source.replace(\n            /<js>/g,\n            function () {\n              return jsExpr\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'language-javascript',\n        inside: Prism.languages.javascript\n      },\n      'class-name': {\n        pattern: /((?:^|[:;])[ \\t]*)(?!\\d)\\w+(?=[ \\t]*\\{|[ \\t]+on\\b)/m,\n        lookbehind: true\n      },\n      property: [\n        {\n          pattern: /((?:^|[;{])[ \\t]*)(?!\\d)\\w+(?:\\.\\w+)*(?=[ \\t]*:)/m,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /((?:^|[;{])[ \\t]*)property[ \\t]+(?!\\d)\\w+(?:\\.\\w+)*[ \\t]+(?!\\d)\\w+(?:\\.\\w+)*(?=[ \\t]*:)/m,\n          lookbehind: true,\n          inside: {\n            keyword: /^property/,\n            property: /\\w+(?:\\.\\w+)*/\n          }\n        }\n      ],\n      'javascript-expression': {\n        pattern: RegExp(\n          /(:[ \\t]*)(?![\\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(\n            /<js>/g,\n            function () {\n              return jsExpr\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'language-javascript',\n        inside: Prism.languages.javascript\n      },\n      string: {\n        pattern: /\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n        greedy: true\n      },\n      keyword: /\\b(?:as|import|on)\\b/,\n      punctuation: /[{}[\\]:;,]/\n    }\n  })(Prism)\n}\n"],"names":["qml","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AACjB,KAAC,SAAUC,QAAO;AACjB,UAAI,WAAW,8CAA8C;AAC7D,UAAI,YAAY,yCAAyC;AACzD,UAAI,SACF,iGAAiG,OAC9F,QAAQ,aAAa,WAAY;AAChC,eAAO;AAAA,MACjB,CAAS,EACA,QAAQ,cAAc,WAAY;AACjC,eAAO;AAAA,MACjB,CAAS;AACL,eAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,iBAAS,OAAO,QAAQ,WAAW,WAAY;AAC7C,iBAAO;AAAA,QACf,CAAO;AAAA,MACP;AACI,eAAS,OAAO,QAAQ,WAAW,WAAW;AAC9C,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,uBAAuB;AAAA,UACrB,SAAS;AAAA,YACP,2GAA2G,OAAO;AAAA,cAChH;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACrB;AAAA;YAEU;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA,UACP,QAAQA,OAAM,UAAU;AAAA;QAE1B,cAAc;AAAA,UACZ,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,UAAU;AAAA,UACR;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,UAAU;AAAA;;;QAIhB,yBAAyB;AAAA,UACvB,SAAS;AAAA,YACP,0CAA0C,OAAO;AAAA,cAC/C;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACrB;AAAA;YAEU;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA,UACP,QAAQA,OAAM,UAAU;AAAA;QAE1B,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,SAAS;AAAA,QACT,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/qore-HS8qEv8g.js

@@ -0,0 +1,62 @@
+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 qore_1;
+var hasRequiredQore;
+function requireQore() {
+  if (hasRequiredQore) return qore_1;
+  hasRequiredQore = 1;
+  qore_1 = qore2;
+  qore2.displayName = "qore";
+  qore2.aliases = [];
+  function qore2(Prism) {
+    Prism.languages.qore = Prism.languages.extend("clike", {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:\/\/|#).*)/,
+        lookbehind: true
+      },
+      // Overridden to allow unescaped multi-line strings
+      string: {
+        pattern: /("|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+        greedy: true
+      },
+      keyword: /\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\b/,
+      boolean: /\b(?:false|true)\b/i,
+      function: /\$?\b(?!\d)\w+(?=\()/,
+      number: /\b(?:0b[01]+|0x(?:[\da-f]*\.)?[\da-fp\-]+|(?:\d+(?:\.\d+)?|\.\d+)(?:e\d+)?[df]|(?:\d+(?:\.\d+)?|\.\d+))\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\|[|=]?|[*\/%^]=?|[~?])/,
+        lookbehind: true
+      },
+      variable: /\$(?!\d)\w+\b/
+    });
+  }
+  return qore_1;
+}
+var qoreExports = requireQore();
+const qore = /* @__PURE__ */ getDefaultExportFromCjs(qoreExports);
+const qore$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: qore
+}, [qoreExports]);
+export {
+  qore$1 as q
+};
+//# sourceMappingURL=qore-HS8qEv8g.js.map

package/dist/qore-HS8qEv8g.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qore-HS8qEv8g.js","sources":["../node_modules/refractor/lang/qore.js"],"sourcesContent":["'use strict'\n\nmodule.exports = qore\nqore.displayName = 'qore'\nqore.aliases = []\nfunction qore(Prism) {\n  Prism.languages.qore = Prism.languages.extend('clike', {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:\\/\\/|#).*)/,\n      lookbehind: true\n    },\n    // Overridden to allow unescaped multi-line strings\n    string: {\n      pattern: /(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:abstract|any|assert|binary|bool|boolean|break|byte|case|catch|char|class|code|const|continue|data|default|do|double|else|enum|extends|final|finally|float|for|goto|hash|if|implements|import|inherits|instanceof|int|interface|long|my|native|new|nothing|null|object|our|own|private|reference|rethrow|return|short|soft(?:bool|date|float|int|list|number|string)|static|strictfp|string|sub|super|switch|synchronized|this|throw|throws|transient|try|void|volatile|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/i,\n    function: /\\$?\\b(?!\\d)\\w+(?=\\()/,\n    number:\n      /\\b(?:0b[01]+|0x(?:[\\da-f]*\\.)?[\\da-fp\\-]+|(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e\\d+)?[df]|(?:\\d+(?:\\.\\d+)?|\\.\\d+))\\b/i,\n    operator: {\n      pattern:\n        /(^|[^.])(?:\\+[+=]?|-[-=]?|[!=](?:==?|~)?|>>?=?|<(?:=>?|<=?)?|&[&=]?|\\|[|=]?|[*\\/%^]=?|[~?])/,\n      lookbehind: true\n    },\n    variable: /\\$(?!\\d)\\w+\\b/\n  })\n}\n"],"names":["qore"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,SAAS;AAAA,MACrD,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;;MAGd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,MACV,QACE;AAAA,MACF,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,IACd,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}