@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/bsl-ByW2HOhn.js

@@ -0,0 +1,111 @@
+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 bsl_1;
+var hasRequiredBsl;
+function requireBsl() {
+  if (hasRequiredBsl) return bsl_1;
+  hasRequiredBsl = 1;
+  bsl_1 = bsl2;
+  bsl2.displayName = "bsl";
+  bsl2.aliases = [];
+  function bsl2(Prism) {
+    Prism.languages.bsl = {
+      comment: /\/\/.*/,
+      string: [
+        // Строки
+        // Strings
+        {
+          pattern: /"(?:[^"]|"")*"(?!")/,
+          greedy: true
+        },
+        // Дата и время
+        // Date & time
+        {
+          pattern: /'(?:[^'\r\n\\]|\\.)*'/
+        }
+      ],
+      keyword: [
+        {
+          // RU
+          pattern: /(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:пока|для|новый|прервать|попытка|исключение|вызватьисключение|иначе|конецпопытки|неопределено|функция|перем|возврат|конецфункции|если|иначеесли|процедура|конецпроцедуры|тогда|знач|экспорт|конецесли|из|каждого|истина|ложь|по|цикл|конеццикла|выполнить)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
+          lookbehind: true
+        },
+        {
+          // EN
+          pattern: /\b(?:break|do|each|else|elseif|enddo|endfunction|endif|endprocedure|endtry|except|execute|export|false|for|function|if|in|new|null|procedure|raise|return|then|to|true|try|undefined|val|var|while)\b/i
+        }
+      ],
+      number: {
+        pattern: /(^(?=\d)|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?/i,
+        lookbehind: true
+      },
+      operator: [
+        /[<>+\-*/]=?|[%=]/,
+        // RU
+        {
+          pattern: /(^|[^\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])(?:и|или|не)(?![\w\u0400-\u0484\u0487-\u052f\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e\ufe2f])/i,
+          lookbehind: true
+        },
+        // EN
+        {
+          pattern: /\b(?:and|not|or)\b/i
+        }
+      ],
+      punctuation: /\(\.|\.\)|[()\[\]:;,.]/,
+      directive: [
+        // Теги препроцессора вида &Клиент, &Сервер, ...
+        // Preprocessor tags of the type &Client, &Server, ...
+        {
+          pattern: /^([ \t]*)&.*/m,
+          lookbehind: true,
+          greedy: true,
+          alias: "important"
+        },
+        // Инструкции препроцессора вида:
+        // #Если Сервер Тогда
+        // ...
+        // #КонецЕсли
+        // Preprocessor instructions of the form:
+        // #If Server Then
+        // ...
+        // #EndIf
+        {
+          pattern: /^([ \t]*)#.*/gm,
+          lookbehind: true,
+          greedy: true,
+          alias: "important"
+        }
+      ]
+    };
+    Prism.languages.oscript = Prism.languages["bsl"];
+  }
+  return bsl_1;
+}
+var bslExports = requireBsl();
+const bsl = /* @__PURE__ */ getDefaultExportFromCjs(bslExports);
+const bsl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: bsl
+}, [bslExports]);
+export {
+  bsl$1 as b
+};
+//# sourceMappingURL=bsl-ByW2HOhn.js.map

package/dist/bsl-ByW2HOhn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bsl-ByW2HOhn.js","sources":["../node_modules/refractor/lang/bsl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = bsl\nbsl.displayName = 'bsl'\nbsl.aliases = []\nfunction bsl(Prism) {\n  /* eslint-disable no-misleading-character-class */\n  // 1C:Enterprise\n  // https://github.com/Diversus23/\n  //\n  Prism.languages.bsl = {\n    comment: /\\/\\/.*/,\n    string: [\n      // Строки\n      // Strings\n      {\n        pattern: /\"(?:[^\"]|\"\")*\"(?!\")/,\n        greedy: true\n      }, // Дата и время\n      // Date & time\n      {\n        pattern: /'(?:[^'\\r\\n\\\\]|\\\\.)*'/\n      }\n    ],\n    keyword: [\n      {\n        // RU\n        pattern:\n          /(^|[^\\w\\u0400-\\u0484\\u0487-\\u052f\\u1d2b\\u1d78\\u2de0-\\u2dff\\ua640-\\ua69f\\ufe2e\\ufe2f])(?:пока|для|новый|прервать|попытка|исключение|вызватьисключение|иначе|конецпопытки|неопределено|функция|перем|возврат|конецфункции|если|иначеесли|процедура|конецпроцедуры|тогда|знач|экспорт|конецесли|из|каждого|истина|ложь|по|цикл|конеццикла|выполнить)(?![\\w\\u0400-\\u0484\\u0487-\\u052f\\u1d2b\\u1d78\\u2de0-\\u2dff\\ua640-\\ua69f\\ufe2e\\ufe2f])/i,\n        lookbehind: true\n      },\n      {\n        // EN\n        pattern:\n          /\\b(?:break|do|each|else|elseif|enddo|endfunction|endif|endprocedure|endtry|except|execute|export|false|for|function|if|in|new|null|procedure|raise|return|then|to|true|try|undefined|val|var|while)\\b/i\n      }\n    ],\n    number: {\n      pattern:\n        /(^(?=\\d)|[^\\w\\u0400-\\u0484\\u0487-\\u052f\\u1d2b\\u1d78\\u2de0-\\u2dff\\ua640-\\ua69f\\ufe2e\\ufe2f])(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:E[+-]?\\d+)?/i,\n      lookbehind: true\n    },\n    operator: [\n      /[<>+\\-*/]=?|[%=]/, // RU\n      {\n        pattern:\n          /(^|[^\\w\\u0400-\\u0484\\u0487-\\u052f\\u1d2b\\u1d78\\u2de0-\\u2dff\\ua640-\\ua69f\\ufe2e\\ufe2f])(?:и|или|не)(?![\\w\\u0400-\\u0484\\u0487-\\u052f\\u1d2b\\u1d78\\u2de0-\\u2dff\\ua640-\\ua69f\\ufe2e\\ufe2f])/i,\n        lookbehind: true\n      }, // EN\n      {\n        pattern: /\\b(?:and|not|or)\\b/i\n      }\n    ],\n    punctuation: /\\(\\.|\\.\\)|[()\\[\\]:;,.]/,\n    directive: [\n      // Теги препроцессора вида &Клиент, &Сервер, ...\n      // Preprocessor tags of the type &Client, &Server, ...\n      {\n        pattern: /^([ \\t]*)&.*/m,\n        lookbehind: true,\n        greedy: true,\n        alias: 'important'\n      }, // Инструкции препроцессора вида:\n      // #Если Сервер Тогда\n      // ...\n      // #КонецЕсли\n      // Preprocessor instructions of the form:\n      // #If Server Then\n      // ...\n      // #EndIf\n      {\n        pattern: /^([ \\t]*)#.*/gm,\n        lookbehind: true,\n        greedy: true,\n        alias: 'important'\n      }\n    ]\n  }\n  Prism.languages.oscript = Prism.languages['bsl']\n}\n"],"names":["bsl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAKlB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA,MACT,QAAQ;AAAA;AAAA;AAAA,QAGN;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;;QAGV;AAAA,UACE,SAAS;AAAA;;MAGb,SAAS;AAAA,QACP;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SACE;AAAA;;MAGN,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,QACR;AAAA;AAAA,QACA;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;;QAEd;AAAA,UACE,SAAS;AAAA;;MAGb,aAAa;AAAA,MACb,WAAW;AAAA;AAAA;AAAA,QAGT;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;;;;;;;;;QAST;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;;;AAIb,UAAM,UAAU,UAAU,MAAM,UAAU,KAAK;AAAA,EACjD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/c-BM9zQzkN.js

@@ -0,0 +1,92 @@
+var c_1;
+var hasRequiredC;
+function requireC() {
+  if (hasRequiredC) return c_1;
+  hasRequiredC = 1;
+  c_1 = c;
+  c.displayName = "c";
+  c.aliases = [];
+  function c(Prism) {
+    Prism.languages.c = Prism.languages.extend("clike", {
+      comment: {
+        pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+        greedy: true
+      },
+      string: {
+        // https://en.cppreference.com/w/c/language/string_literal
+        pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+        greedy: true
+      },
+      "class-name": {
+        pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+        lookbehind: true
+      },
+      keyword: /\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      number: /(?:\b0x(?:[\da-f]+(?:\.[\da-f]*)?|\.[\da-f]+)(?:p[+-]?\d+)?|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)[ful]{0,4}/i,
+      operator: />>=?|<<=?|->|([-+&|:])\1|[?:~]|[-+*/%&|^!=<>]=?/
+    });
+    Prism.languages.insertBefore("c", "string", {
+      char: {
+        // https://en.cppreference.com/w/c/language/character_constant
+        pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+        greedy: true
+      }
+    });
+    Prism.languages.insertBefore("c", "string", {
+      macro: {
+        // allow for multiline macro definitions
+        // spaces after the # character compile fine with gcc
+        pattern: /(^[\t ]*)#\s*[a-z](?:[^\r\n\\/]|\/(?!\*)|\/\*(?:[^*]|\*(?!\/))*\*\/|\\(?:\r\n|[\s\S]))*/im,
+        lookbehind: true,
+        greedy: true,
+        alias: "property",
+        inside: {
+          string: [
+            {
+              // highlight the path of the include statement as a string
+              pattern: /^(#\s*include\s*)<[^>]+>/,
+              lookbehind: true
+            },
+            Prism.languages.c["string"]
+          ],
+          char: Prism.languages.c["char"],
+          comment: Prism.languages.c["comment"],
+          "macro-name": [
+            {
+              pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+              lookbehind: true
+            },
+            {
+              pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+              lookbehind: true,
+              alias: "function"
+            }
+          ],
+          // highlight macro directives as keywords
+          directive: {
+            pattern: /^(#\s*)[a-z]+/,
+            lookbehind: true,
+            alias: "keyword"
+          },
+          "directive-hash": /^#/,
+          punctuation: /##|\\(?=[\r\n])/,
+          expression: {
+            pattern: /\S[\s\S]*/,
+            inside: Prism.languages.c
+          }
+        }
+      }
+    });
+    Prism.languages.insertBefore("c", "function", {
+      // highlight predefined macros as constants
+      constant: /\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\b/
+    });
+    delete Prism.languages.c["boolean"];
+  }
+  return c_1;
+}
+export {
+  requireC as r
+};
+//# sourceMappingURL=c-BM9zQzkN.js.map

package/dist/c-BM9zQzkN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"c-BM9zQzkN.js","sources":["../node_modules/refractor/lang/c.js"],"sourcesContent":["'use strict'\n\nmodule.exports = c\nc.displayName = 'c'\nc.aliases = []\nfunction c(Prism) {\n  Prism.languages.c = Prism.languages.extend('clike', {\n    comment: {\n      pattern:\n        /\\/\\/(?:[^\\r\\n\\\\]|\\\\(?:\\r\\n?|\\n|(?![\\r\\n])))*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n      greedy: true\n    },\n    string: {\n      // https://en.cppreference.com/w/c/language/string_literal\n      pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\"\\\\\\r\\n])*\"/,\n      greedy: true\n    },\n    'class-name': {\n      pattern:\n        /(\\b(?:enum|struct)\\s+(?:__attribute__\\s*\\(\\([\\s\\S]*?\\)\\)\\s*)?)\\w+|\\b[a-z]\\w*_t\\b/,\n      lookbehind: true\n    },\n    keyword:\n      /\\b(?:_Alignas|_Alignof|_Atomic|_Bool|_Complex|_Generic|_Imaginary|_Noreturn|_Static_assert|_Thread_local|__attribute__|asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|inline|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|typeof|union|unsigned|void|volatile|while)\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    number:\n      /(?:\\b0x(?:[\\da-f]+(?:\\.[\\da-f]*)?|\\.[\\da-f]+)(?:p[+-]?\\d+)?|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?)[ful]{0,4}/i,\n    operator: />>=?|<<=?|->|([-+&|:])\\1|[?:~]|[-+*/%&|^!=<>]=?/\n  })\n  Prism.languages.insertBefore('c', 'string', {\n    char: {\n      // https://en.cppreference.com/w/c/language/character_constant\n      pattern: /'(?:\\\\(?:\\r\\n|[\\s\\S])|[^'\\\\\\r\\n]){0,32}'/,\n      greedy: true\n    }\n  })\n  Prism.languages.insertBefore('c', 'string', {\n    macro: {\n      // allow for multiline macro definitions\n      // spaces after the # character compile fine with gcc\n      pattern:\n        /(^[\\t ]*)#\\s*[a-z](?:[^\\r\\n\\\\/]|\\/(?!\\*)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/|\\\\(?:\\r\\n|[\\s\\S]))*/im,\n      lookbehind: true,\n      greedy: true,\n      alias: 'property',\n      inside: {\n        string: [\n          {\n            // highlight the path of the include statement as a string\n            pattern: /^(#\\s*include\\s*)<[^>]+>/,\n            lookbehind: true\n          },\n          Prism.languages.c['string']\n        ],\n        char: Prism.languages.c['char'],\n        comment: Prism.languages.c['comment'],\n        'macro-name': [\n          {\n            pattern: /(^#\\s*define\\s+)\\w+\\b(?!\\()/i,\n            lookbehind: true\n          },\n          {\n            pattern: /(^#\\s*define\\s+)\\w+\\b(?=\\()/i,\n            lookbehind: true,\n            alias: 'function'\n          }\n        ],\n        // highlight macro directives as keywords\n        directive: {\n          pattern: /^(#\\s*)[a-z]+/,\n          lookbehind: true,\n          alias: 'keyword'\n        },\n        'directive-hash': /^#/,\n        punctuation: /##|\\\\(?=[\\r\\n])/,\n        expression: {\n          pattern: /\\S[\\s\\S]*/,\n          inside: Prism.languages.c\n        }\n      }\n    }\n  })\n  Prism.languages.insertBefore('c', 'function', {\n    // highlight predefined macros as constants\n    constant:\n      /\\b(?:EOF|NULL|SEEK_CUR|SEEK_END|SEEK_SET|__DATE__|__FILE__|__LINE__|__TIMESTAMP__|__TIME__|__func__|stderr|stdin|stdout)\\b/\n  })\n  delete Prism.languages.c['boolean']\n}\n"],"names":[],"mappings":";;;;;AAEA,QAAiB;AACjB,IAAE,cAAc;AAChB,IAAE,UAAU,CAAA;AACZ,WAAS,EAAE,OAAO;AAChB,UAAM,UAAU,IAAI,MAAM,UAAU,OAAO,SAAS;AAAA,MAClD,SAAS;AAAA,QACP,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,QAAQ;AAAA;AAAA,QAEN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA;MAEd,SACE;AAAA,MACF,UAAU;AAAA,MACV,QACE;AAAA,MACF,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,KAAK,UAAU;AAAA,MAC1C,MAAM;AAAA;AAAA,QAEJ,SAAS;AAAA,QACT,QAAQ;AAAA;IAEd,CAAG;AACD,UAAM,UAAU,aAAa,KAAK,UAAU;AAAA,MAC1C,OAAO;AAAA;AAAA;AAAA,QAGL,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,QAAQ;AAAA,YACN;AAAA;AAAA,cAEE,SAAS;AAAA,cACT,YAAY;AAAA;YAEd,MAAM,UAAU,EAAE,QAAQ;AAAA;UAE5B,MAAM,MAAM,UAAU,EAAE,MAAM;AAAA,UAC9B,SAAS,MAAM,UAAU,EAAE,SAAS;AAAA,UACpC,cAAc;AAAA,YACZ;AAAA,cACE,SAAS;AAAA,cACT,YAAY;AAAA;YAEd;AAAA,cACE,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA;;;UAIX,WAAW;AAAA,YACT,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,kBAAkB;AAAA,UAClB,aAAa;AAAA,UACb,YAAY;AAAA,YACV,SAAS;AAAA,YACT,QAAQ,MAAM,UAAU;AAAA;;;IAIlC,CAAG;AACD,UAAM,UAAU,aAAa,KAAK,YAAY;AAAA;AAAA,MAE5C,UACE;AAAA,IACN,CAAG;AACD,WAAO,MAAM,UAAU,EAAE,SAAS;AAAA,EACpC;;;","x_google_ignoreList":[0]}

package/dist/c-cAp-Ncnf.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireC } from "./c-BM9zQzkN.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 cExports = requireC();
+const c = /* @__PURE__ */ getDefaultExportFromCjs(cExports);
+const c$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: c
+}, [cExports]);
+export {
+  c$1 as c
+};
+//# sourceMappingURL=c-cAp-Ncnf.js.map

package/dist/c-cAp-Ncnf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"c-cAp-Ncnf.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cfscript-ClYSy-ov.js

@@ -0,0 +1,83 @@
+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 cfscript_1;
+var hasRequiredCfscript;
+function requireCfscript() {
+  if (hasRequiredCfscript) return cfscript_1;
+  hasRequiredCfscript = 1;
+  cfscript_1 = cfscript2;
+  cfscript2.displayName = "cfscript";
+  cfscript2.aliases = [];
+  function cfscript2(Prism) {
+    Prism.languages.cfscript = Prism.languages.extend("clike", {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: true,
+          inside: {
+            annotation: {
+              pattern: /(?:^|[^.])@[\w\.]+/,
+              alias: "punctuation"
+            }
+          }
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      keyword: /\b(?:abstract|break|catch|component|continue|default|do|else|extends|final|finally|for|function|if|in|include|package|private|property|public|remote|required|rethrow|return|static|switch|throw|try|var|while|xml)\b(?!\s*=)/,
+      operator: [
+        /\+\+|--|&&|\|\||::|=>|[!=]==|<=?|>=?|[-+*/%&|^!=<>]=?|\?(?:\.|:)?|[?:]/,
+        /\b(?:and|contains|eq|equal|eqv|gt|gte|imp|is|lt|lte|mod|not|or|xor)\b/
+      ],
+      scope: {
+        pattern: /\b(?:application|arguments|cgi|client|cookie|local|session|super|this|variables)\b/,
+        alias: "global"
+      },
+      type: {
+        pattern: /\b(?:any|array|binary|boolean|date|guid|numeric|query|string|struct|uuid|void|xml)\b/,
+        alias: "builtin"
+      }
+    });
+    Prism.languages.insertBefore("cfscript", "keyword", {
+      // This must be declared before keyword because we use "function" inside the lookahead
+      "function-variable": {
+        pattern: /[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+        alias: "function"
+      }
+    });
+    delete Prism.languages.cfscript["class-name"];
+    Prism.languages.cfc = Prism.languages["cfscript"];
+  }
+  return cfscript_1;
+}
+var cfscriptExports = requireCfscript();
+const cfscript = /* @__PURE__ */ getDefaultExportFromCjs(cfscriptExports);
+const cfscript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: cfscript
+}, [cfscriptExports]);
+export {
+  cfscript$1 as c
+};
+//# sourceMappingURL=cfscript-ClYSy-ov.js.map

package/dist/cfscript-ClYSy-ov.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cfscript-ClYSy-ov.js","sources":["../node_modules/refractor/lang/cfscript.js"],"sourcesContent":["'use strict'\n\nmodule.exports = cfscript\ncfscript.displayName = 'cfscript'\ncfscript.aliases = []\nfunction cfscript(Prism) {\n  // https://cfdocs.org/script\n  Prism.languages.cfscript = Prism.languages.extend('clike', {\n    comment: [\n      {\n        pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n        lookbehind: true,\n        inside: {\n          annotation: {\n            pattern: /(?:^|[^.])@[\\w\\.]+/,\n            alias: 'punctuation'\n          }\n        }\n      },\n      {\n        pattern: /(^|[^\\\\:])\\/\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    keyword:\n      /\\b(?:abstract|break|catch|component|continue|default|do|else|extends|final|finally|for|function|if|in|include|package|private|property|public|remote|required|rethrow|return|static|switch|throw|try|var|while|xml)\\b(?!\\s*=)/,\n    operator: [\n      /\\+\\+|--|&&|\\|\\||::|=>|[!=]==|<=?|>=?|[-+*/%&|^!=<>]=?|\\?(?:\\.|:)?|[?:]/,\n      /\\b(?:and|contains|eq|equal|eqv|gt|gte|imp|is|lt|lte|mod|not|or|xor)\\b/\n    ],\n    scope: {\n      pattern:\n        /\\b(?:application|arguments|cgi|client|cookie|local|session|super|this|variables)\\b/,\n      alias: 'global'\n    },\n    type: {\n      pattern:\n        /\\b(?:any|array|binary|boolean|date|guid|numeric|query|string|struct|uuid|void|xml)\\b/,\n      alias: 'builtin'\n    }\n  })\n  Prism.languages.insertBefore('cfscript', 'keyword', {\n    // This must be declared before keyword because we use \"function\" inside the lookahead\n    'function-variable': {\n      pattern:\n        /[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?=\\s*[=:]\\s*(?:\\bfunction\\b|(?:\\((?:[^()]|\\([^()]*\\))*\\)|(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*)\\s*=>))/,\n      alias: 'function'\n    }\n  })\n  delete Prism.languages.cfscript['class-name']\n  Prism.languages.cfc = Prism.languages['cfscript']\n}\n"],"names":["cfscript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,eAAiBA;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAA;AACnB,WAASA,UAAS,OAAO;AAEvB,UAAM,UAAU,WAAW,MAAM,UAAU,OAAO,SAAS;AAAA,MACzD,SAAS;AAAA,QACP;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,YAAY;AAAA,cACV,SAAS;AAAA,cACT,OAAO;AAAA;;;QAIb;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;;MAGZ,SACE;AAAA,MACF,UAAU;AAAA,QACR;AAAA,QACA;AAAA;MAEF,OAAO;AAAA,QACL,SACE;AAAA,QACF,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SACE;AAAA,QACF,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,aAAa,YAAY,WAAW;AAAA;AAAA,MAElD,qBAAqB;AAAA,QACnB,SACE;AAAA,QACF,OAAO;AAAA;IAEb,CAAG;AACD,WAAO,MAAM,UAAU,SAAS,YAAY;AAC5C,UAAM,UAAU,MAAM,MAAM,UAAU,UAAU;AAAA,EAClD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/chaiscript-CgvIxGxT.js

@@ -0,0 +1,100 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireCpp } from "./cpp-B7WH6XXz.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 chaiscript_1;
+var hasRequiredChaiscript;
+function requireChaiscript() {
+  if (hasRequiredChaiscript) return chaiscript_1;
+  hasRequiredChaiscript = 1;
+  var refractorCpp = requireCpp();
+  chaiscript_1 = chaiscript2;
+  chaiscript2.displayName = "chaiscript";
+  chaiscript2.aliases = [];
+  function chaiscript2(Prism) {
+    Prism.register(refractorCpp);
+    Prism.languages.chaiscript = Prism.languages.extend("clike", {
+      string: {
+        pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
+        lookbehind: true,
+        greedy: true
+      },
+      "class-name": [
+        {
+          // e.g. class Rectangle { ... }
+          pattern: /(\bclass\s+)\w+/,
+          lookbehind: true
+        },
+        {
+          // e.g. attr Rectangle::height, def Rectangle::area() { ... }
+          pattern: /(\b(?:attr|def)\s+)\w+(?=\s*::)/,
+          lookbehind: true
+        }
+      ],
+      keyword: /\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\b/,
+      number: [Prism.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
+      operator: />>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
+    });
+    Prism.languages.insertBefore("chaiscript", "operator", {
+      "parameter-type": {
+        // e.g. def foo(int x, Vector y) {...}
+        pattern: /([,(]\s*)\w+(?=\s+\w)/,
+        lookbehind: true,
+        alias: "class-name"
+      }
+    });
+    Prism.languages.insertBefore("chaiscript", "string", {
+      "string-interpolation": {
+        pattern: /(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
+            lookbehind: true,
+            inside: {
+              "interpolation-expression": {
+                pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                lookbehind: true,
+                inside: Prism.languages.chaiscript
+              },
+              "interpolation-punctuation": {
+                pattern: /^\$\{|\}$/,
+                alias: "punctuation"
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    });
+  }
+  return chaiscript_1;
+}
+var chaiscriptExports = requireChaiscript();
+const chaiscript = /* @__PURE__ */ getDefaultExportFromCjs(chaiscriptExports);
+const chaiscript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: chaiscript
+}, [chaiscriptExports]);
+export {
+  chaiscript$1 as c
+};
+//# sourceMappingURL=chaiscript-CgvIxGxT.js.map

package/dist/chaiscript-CgvIxGxT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chaiscript-CgvIxGxT.js","sources":["../node_modules/refractor/lang/chaiscript.js"],"sourcesContent":["'use strict'\nvar refractorCpp = require('./cpp.js')\nmodule.exports = chaiscript\nchaiscript.displayName = 'chaiscript'\nchaiscript.aliases = []\nfunction chaiscript(Prism) {\n  Prism.register(refractorCpp)\n  Prism.languages.chaiscript = Prism.languages.extend('clike', {\n    string: {\n      pattern: /(^|[^\\\\])'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      lookbehind: true,\n      greedy: true\n    },\n    'class-name': [\n      {\n        // e.g. class Rectangle { ... }\n        pattern: /(\\bclass\\s+)\\w+/,\n        lookbehind: true\n      },\n      {\n        // e.g. attr Rectangle::height, def Rectangle::area() { ... }\n        pattern: /(\\b(?:attr|def)\\s+)\\w+(?=\\s*::)/,\n        lookbehind: true\n      }\n    ],\n    keyword:\n      /\\b(?:attr|auto|break|case|catch|class|continue|def|default|else|finally|for|fun|global|if|return|switch|this|try|var|while)\\b/,\n    number: [Prism.languages.cpp.number, /\\b(?:Infinity|NaN)\\b/],\n    operator:\n      />>=?|<<=?|\\|\\||&&|:[:=]?|--|\\+\\+|[=!<>+\\-*/%|&^]=?|[?~]|`[^`\\r\\n]{1,4}`/\n  })\n  Prism.languages.insertBefore('chaiscript', 'operator', {\n    'parameter-type': {\n      // e.g. def foo(int x, Vector y) {...}\n      pattern: /([,(]\\s*)\\w+(?=\\s+\\w)/,\n      lookbehind: true,\n      alias: 'class-name'\n    }\n  })\n  Prism.languages.insertBefore('chaiscript', 'string', {\n    'string-interpolation': {\n      pattern:\n        /(^|[^\\\\])\"(?:[^\"$\\\\]|\\\\[\\s\\S]|\\$(?!\\{)|\\$\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})*\\})*\"/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern:\n            /((?:^|[^\\\\])(?:\\\\{2})*)\\$\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})*\\}/,\n          lookbehind: true,\n          inside: {\n            'interpolation-expression': {\n              pattern: /(^\\$\\{)[\\s\\S]+(?=\\}$)/,\n              lookbehind: true,\n              inside: Prism.languages.chaiscript\n            },\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{|\\}$/,\n              alias: 'punctuation'\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n}\n"],"names":["require$$0","chaiscript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,eAAeA,WAAA;AACnB,iBAAiBC;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACzB,UAAM,SAAS,YAAY;AAC3B,UAAM,UAAU,aAAa,MAAM,UAAU,OAAO,SAAS;AAAA,MAC3D,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,cAAc;AAAA,QACZ;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,SACE;AAAA,MACF,QAAQ,CAAC,MAAM,UAAU,IAAI,QAAQ,sBAAsB;AAAA,MAC3D,UACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,cAAc,YAAY;AAAA,MACrD,kBAAkB;AAAA;AAAA,QAEhB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,aAAa,cAAc,UAAU;AAAA,MACnD,wBAAwB;AAAA,QACtB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,4BAA4B;AAAA,gBAC1B,SAAS;AAAA,gBACT,YAAY;AAAA,gBACZ,QAAQ,MAAM,UAAU;AAAA;cAE1B,6BAA6B;AAAA,gBAC3B,SAAS;AAAA,gBACT,OAAO;AAAA;;;UAIb,QAAQ;AAAA;;IAGhB,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/cil-e0ortwSX.js

@@ -0,0 +1,61 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var cil_1;
+var hasRequiredCil;
+function requireCil() {
+  if (hasRequiredCil) return cil_1;
+  hasRequiredCil = 1;
+  cil_1 = cil2;
+  cil2.displayName = "cil";
+  cil2.aliases = [];
+  function cil2(Prism) {
+    Prism.languages.cil = {
+      comment: /\/\/.*/,
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      },
+      directive: {
+        pattern: /(^|\W)\.[a-z]+(?=\s)/,
+        lookbehind: true,
+        alias: "class-name"
+      },
+      // Actually an assembly reference
+      variable: /\[[\w\.]+\]/,
+      keyword: /\b(?:abstract|ansi|assembly|auto|autochar|beforefieldinit|bool|bstr|byvalstr|catch|char|cil|class|currency|date|decimal|default|enum|error|explicit|extends|extern|famandassem|family|famorassem|final(?:ly)?|float32|float64|hidebysig|u?int(?:8|16|32|64)?|iant|idispatch|implements|import|initonly|instance|interface|iunknown|literal|lpstr|lpstruct|lptstr|lpwstr|managed|method|native(?:Type)?|nested|newslot|object(?:ref)?|pinvokeimpl|private|privatescope|public|reqsecobj|rtspecialname|runtime|sealed|sequential|serializable|specialname|static|string|struct|syschar|tbstr|unicode|unmanagedexp|unsigned|value(?:type)?|variant|virtual|void)\b/,
+      function: /\b(?:(?:constrained|no|readonly|tail|unaligned|volatile)\.)?(?:conv\.(?:[iu][1248]?|ovf\.[iu][1248]?(?:\.un)?|r\.un|r4|r8)|ldc\.(?:i4(?:\.\d+|\.[mM]1|\.s)?|i8|r4|r8)|ldelem(?:\.[iu][1248]?|\.r[48]|\.ref|a)?|ldind\.(?:[iu][1248]?|r[48]|ref)|stelem\.?(?:i[1248]?|r[48]|ref)?|stind\.(?:i[1248]?|r[48]|ref)?|end(?:fault|filter|finally)|ldarg(?:\.[0-3s]|a(?:\.s)?)?|ldloc(?:\.\d+|\.s)?|sub(?:\.ovf(?:\.un)?)?|mul(?:\.ovf(?:\.un)?)?|add(?:\.ovf(?:\.un)?)?|stloc(?:\.[0-3s])?|refany(?:type|val)|blt(?:\.un)?(?:\.s)?|ble(?:\.un)?(?:\.s)?|bgt(?:\.un)?(?:\.s)?|bge(?:\.un)?(?:\.s)?|unbox(?:\.any)?|init(?:blk|obj)|call(?:i|virt)?|brfalse(?:\.s)?|bne\.un(?:\.s)?|ldloca(?:\.s)?|brzero(?:\.s)?|brtrue(?:\.s)?|brnull(?:\.s)?|brinst(?:\.s)?|starg(?:\.s)?|leave(?:\.s)?|shr(?:\.un)?|rem(?:\.un)?|div(?:\.un)?|clt(?:\.un)?|alignment|castclass|ldvirtftn|beq(?:\.s)?|ckfinite|ldsflda|ldtoken|localloc|mkrefany|rethrow|cgt\.un|arglist|switch|stsfld|sizeof|newobj|newarr|ldsfld|ldnull|ldflda|isinst|throw|stobj|stfld|ldstr|ldobj|ldlen|ldftn|ldfld|cpobj|cpblk|break|br\.s|xor|shl|ret|pop|not|nop|neg|jmp|dup|cgt|ceq|box|and|or|br)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: /\b-?(?:0x[0-9a-f]+|\d+)(?:\.[0-9a-f]+)?\b/i,
+      punctuation: /[{}[\];(),:=]|IL_[0-9A-Za-z]+/
+    };
+  }
+  return cil_1;
+}
+var cilExports = requireCil();
+const cil = /* @__PURE__ */ getDefaultExportFromCjs(cilExports);
+const cil$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: cil
+}, [cilExports]);
+export {
+  cil$1 as c
+};
+//# sourceMappingURL=cil-e0ortwSX.js.map

package/dist/cil-e0ortwSX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cil-e0ortwSX.js","sources":["../node_modules/refractor/lang/cil.js"],"sourcesContent":["'use strict'\n\nmodule.exports = cil\ncil.displayName = 'cil'\ncil.aliases = []\nfunction cil(Prism) {\n  Prism.languages.cil = {\n    comment: /\\/\\/.*/,\n    string: {\n      pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    directive: {\n      pattern: /(^|\\W)\\.[a-z]+(?=\\s)/,\n      lookbehind: true,\n      alias: 'class-name'\n    },\n    // Actually an assembly reference\n    variable: /\\[[\\w\\.]+\\]/,\n    keyword:\n      /\\b(?:abstract|ansi|assembly|auto|autochar|beforefieldinit|bool|bstr|byvalstr|catch|char|cil|class|currency|date|decimal|default|enum|error|explicit|extends|extern|famandassem|family|famorassem|final(?:ly)?|float32|float64|hidebysig|u?int(?:8|16|32|64)?|iant|idispatch|implements|import|initonly|instance|interface|iunknown|literal|lpstr|lpstruct|lptstr|lpwstr|managed|method|native(?:Type)?|nested|newslot|object(?:ref)?|pinvokeimpl|private|privatescope|public|reqsecobj|rtspecialname|runtime|sealed|sequential|serializable|specialname|static|string|struct|syschar|tbstr|unicode|unmanagedexp|unsigned|value(?:type)?|variant|virtual|void)\\b/,\n    function:\n      /\\b(?:(?:constrained|no|readonly|tail|unaligned|volatile)\\.)?(?:conv\\.(?:[iu][1248]?|ovf\\.[iu][1248]?(?:\\.un)?|r\\.un|r4|r8)|ldc\\.(?:i4(?:\\.\\d+|\\.[mM]1|\\.s)?|i8|r4|r8)|ldelem(?:\\.[iu][1248]?|\\.r[48]|\\.ref|a)?|ldind\\.(?:[iu][1248]?|r[48]|ref)|stelem\\.?(?:i[1248]?|r[48]|ref)?|stind\\.(?:i[1248]?|r[48]|ref)?|end(?:fault|filter|finally)|ldarg(?:\\.[0-3s]|a(?:\\.s)?)?|ldloc(?:\\.\\d+|\\.s)?|sub(?:\\.ovf(?:\\.un)?)?|mul(?:\\.ovf(?:\\.un)?)?|add(?:\\.ovf(?:\\.un)?)?|stloc(?:\\.[0-3s])?|refany(?:type|val)|blt(?:\\.un)?(?:\\.s)?|ble(?:\\.un)?(?:\\.s)?|bgt(?:\\.un)?(?:\\.s)?|bge(?:\\.un)?(?:\\.s)?|unbox(?:\\.any)?|init(?:blk|obj)|call(?:i|virt)?|brfalse(?:\\.s)?|bne\\.un(?:\\.s)?|ldloca(?:\\.s)?|brzero(?:\\.s)?|brtrue(?:\\.s)?|brnull(?:\\.s)?|brinst(?:\\.s)?|starg(?:\\.s)?|leave(?:\\.s)?|shr(?:\\.un)?|rem(?:\\.un)?|div(?:\\.un)?|clt(?:\\.un)?|alignment|castclass|ldvirtftn|beq(?:\\.s)?|ckfinite|ldsflda|ldtoken|localloc|mkrefany|rethrow|cgt\\.un|arglist|switch|stsfld|sizeof|newobj|newarr|ldsfld|ldnull|ldflda|isinst|throw|stobj|stfld|ldstr|ldobj|ldlen|ldftn|ldfld|cpobj|cpblk|break|br\\.s|xor|shl|ret|pop|not|nop|neg|jmp|dup|cgt|ceq|box|and|or|br)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    number: /\\b-?(?:0x[0-9a-f]+|\\d+)(?:\\.[0-9a-f]+)?\\b/i,\n    punctuation: /[{}[\\];(),:=]|IL_[0-9A-Za-z]+/\n  }\n}\n"],"names":["cil"],"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,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,WAAW;AAAA,QACT,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;;MAGT,UAAU;AAAA,MACV,SACE;AAAA,MACF,UACE;AAAA,MACF,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/clike-Dqh9Naar.js

@@ -0,0 +1,66 @@
+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 clike_1 = clike;
+clike.displayName = "clike";
+clike.aliases = [];
+function clike(Prism) {
+  Prism.languages.clike = {
+    comment: [
+      {
+        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+        lookbehind: true,
+        greedy: true
+      },
+      {
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    "class-name": {
+      pattern: /(\b(?:class|extends|implements|instanceof|interface|new|trait)\s+|\bcatch\s+\()[\w.\\]+/i,
+      lookbehind: true,
+      inside: {
+        punctuation: /[.\\]/
+      }
+    },
+    keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+    boolean: /\b(?:false|true)\b/,
+    function: /\b\w+(?=\()/,
+    number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+    operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+    punctuation: /[{}[\];(),.:]/
+  };
+}
+const clike_default = /* @__PURE__ */ getDefaultExportFromCjs(clike_1);
+const clike$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: clike_default
+}, [clike_1]);
+export {
+  clike_1 as a,
+  clike$1 as c
+};
+//# sourceMappingURL=clike-Dqh9Naar.js.map

package/dist/clike-Dqh9Naar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clike-Dqh9Naar.js","sources":["../node_modules/refractor/lang/clike.js"],"sourcesContent":["'use strict'\n\nmodule.exports = clike\nclike.displayName = 'clike'\nclike.aliases = []\nfunction clike(Prism) {\n  Prism.languages.clike = {\n    comment: [\n      {\n        pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n        lookbehind: true,\n        greedy: true\n      },\n      {\n        pattern: /(^|[^\\\\:])\\/\\/.*/,\n        lookbehind: true,\n        greedy: true\n      }\n    ],\n    string: {\n      pattern: /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    'class-name': {\n      pattern:\n        /(\\b(?:class|extends|implements|instanceof|interface|new|trait)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+/i,\n      lookbehind: true,\n      inside: {\n        punctuation: /[.\\\\]/\n      }\n    },\n    keyword:\n      /\\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    function: /\\b\\w+(?=\\()/,\n    number: /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?/i,\n    operator: /[<>]=?|[!=]=?=?|--?|\\+\\+?|&&?|\\|\\|?|[?*/~^%]/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAEA,IAAA,UAAiB;AACjB,MAAM,cAAc;AACpB,MAAM,UAAU,CAAA;AAChB,SAAS,MAAM,OAAO;AACpB,QAAM,UAAU,QAAQ;AAAA,IACtB,SAAS;AAAA,MACP;AAAA,QACE,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,MAChB;AAAA,MACM;AAAA,QACE,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,MAChB;AAAA,IACA;AAAA,IACI,QAAQ;AAAA,MACN,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,cAAc;AAAA,MACZ,SACE;AAAA,MACF,YAAY;AAAA,MACZ,QAAQ;AAAA,QACN,aAAa;AAAA,MACrB;AAAA,IACA;AAAA,IACI,SACE;AAAA,IACF,SAAS;AAAA,IACT,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,aAAa;AAAA,EACjB;AACA;;;;;;","x_google_ignoreList":[0]}