@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/bison-BKvEoKEG.js

@@ -0,0 +1,73 @@
+import { g as c } from "./index-Sj89RFCY.js";
+import { r as g } from "./c-b2c4WJSm.js";
+function l(n, t) {
+  for (var e = 0; e < t.length; e++) {
+    const r = t[e];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const a in r)
+        if (a !== "default" && !(a in n)) {
+          const o = Object.getOwnPropertyDescriptor(r, a);
+          o && Object.defineProperty(n, a, o.get ? o : {
+            enumerable: !0,
+            get: () => r[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function p() {
+  if (s) return i;
+  s = 1;
+  var n = g();
+  i = t, t.displayName = "bison", t.aliases = [];
+  function t(e) {
+    e.register(n), e.languages.bison = e.languages.extend("c", {}), e.languages.insertBefore("bison", "comment", {
+      bison: {
+        // This should match all the beginning of the file
+        // including the prologue(s), the bison declarations and
+        // the grammar rules.
+        pattern: /^(?:[^%]|%(?!%))*%%[\s\S]*?%%/,
+        inside: {
+          c: {
+            // Allow for one level of nested braces
+            pattern: /%\{[\s\S]*?%\}|\{(?:\{[^}]*\}|[^{}])*\}/,
+            inside: {
+              delimiter: {
+                pattern: /^%?\{|%?\}$/,
+                alias: "punctuation"
+              },
+              "bison-variable": {
+                pattern: /[$@](?:<[^\s>]+>)?[\w$]+/,
+                alias: "variable",
+                inside: {
+                  punctuation: /<|>/
+                }
+              },
+              rest: e.languages.c
+            }
+          },
+          comment: e.languages.c.comment,
+          string: e.languages.c.string,
+          property: /\S+(?=:)/,
+          keyword: /%\w+/,
+          number: {
+            pattern: /(^|[^@])\b(?:0x[\da-f]+|\d+)/i,
+            lookbehind: !0
+          },
+          punctuation: /%[%?]|[|:;\[\]<>]/
+        }
+      }
+    });
+  }
+  return i;
+}
+var u = p();
+const b = /* @__PURE__ */ c(u), m = /* @__PURE__ */ l({
+  __proto__: null,
+  default: b
+}, [u]);
+export {
+  m as b
+};

package/dist/bnf-CaE0Bt3T.js

@@ -0,0 +1,52 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function l(e, n) {
+  for (var a = 0; a < n.length; a++) {
+    const r = n[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, t);
+          o && Object.defineProperty(e, t, o.get ? o : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var f, i;
+function p() {
+  if (i) return f;
+  i = 1, f = e, e.displayName = "bnf", e.aliases = ["rbnf"];
+  function e(n) {
+    n.languages.bnf = {
+      string: {
+        pattern: /"[^\r\n"]*"|'[^\r\n']*'/
+      },
+      definition: {
+        pattern: /<[^<>\r\n\t]+>(?=\s*::=)/,
+        alias: ["rule", "keyword"],
+        inside: {
+          punctuation: /^<|>$/
+        }
+      },
+      rule: {
+        pattern: /<[^<>\r\n\t]+>/,
+        inside: {
+          punctuation: /^<|>$/
+        }
+      },
+      operator: /::=|[|()[\]{}*+?]|\.{3}/
+    }, n.languages.rbnf = n.languages.bnf;
+  }
+  return f;
+}
+var u = p();
+const b = /* @__PURE__ */ s(u), c = /* @__PURE__ */ l({
+  __proto__: null,
+  default: b
+}, [u]);
+export {
+  c as b
+};

package/dist/brainfuck-GdsepcND.js

@@ -0,0 +1,53 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function s(e, a) {
+  for (var n = 0; n < a.length; n++) {
+    const r = a[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const i = Object.getOwnPropertyDescriptor(r, t);
+          i && Object.defineProperty(e, t, i.get ? i : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, c;
+function p() {
+  if (c) return o;
+  c = 1, o = e, e.displayName = "brainfuck", e.aliases = [];
+  function e(a) {
+    a.languages.brainfuck = {
+      pointer: {
+        pattern: /<|>/,
+        alias: "keyword"
+      },
+      increment: {
+        pattern: /\+/,
+        alias: "inserted"
+      },
+      decrement: {
+        pattern: /-/,
+        alias: "deleted"
+      },
+      branching: {
+        pattern: /\[|\]/,
+        alias: "important"
+      },
+      operator: /[.,]/,
+      comment: /\S+/
+    };
+  }
+  return o;
+}
+var f = p();
+const l = /* @__PURE__ */ u(f), d = /* @__PURE__ */ s({
+  __proto__: null,
+  default: l
+}, [f]);
+export {
+  d as b
+};

package/dist/brightscript-CaQ-B4pE.js

@@ -0,0 +1,76 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function b(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const i in r)
+        if (i !== "default" && !(i in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, i);
+          o && Object.defineProperty(e, i, o.get ? o : {
+            enumerable: !0,
+            get: () => r[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, a;
+function d() {
+  if (a) return s;
+  a = 1, s = e, e.displayName = "brightscript", e.aliases = [];
+  function e(t) {
+    t.languages.brightscript = {
+      comment: /(?:\brem|').*/i,
+      "directive-statement": {
+        pattern: /(^[\t ]*)#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if).*/im,
+        lookbehind: !0,
+        alias: "property",
+        inside: {
+          "error-message": {
+            pattern: /(^#error).+/,
+            lookbehind: !0
+          },
+          directive: {
+            pattern: /^#(?:const|else(?:[\t ]+if)?|end[\t ]+if|error|if)/,
+            alias: "keyword"
+          },
+          expression: {
+            pattern: /[\s\S]+/,
+            inside: null
+            // see below
+          }
+        }
+      },
+      property: {
+        pattern: /([\r\n{,][\t ]*)(?:(?!\d)\w+|"(?:[^"\r\n]|"")*"(?!"))(?=[ \t]*:)/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      string: {
+        pattern: /"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\bAs[\t ]+)\w+/i,
+        lookbehind: !0
+      },
+      keyword: /\b(?:As|Dim|Each|Else|Elseif|End|Exit|For|Function|Goto|If|In|Print|Return|Step|Stop|Sub|Then|To|While)\b/i,
+      boolean: /\b(?:false|true)\b/i,
+      function: /\b(?!\d)\w+(?=[\t ]*\()/,
+      number: /(?:\b\d+(?:\.\d+)?(?:[ed][+-]\d+)?|&h[a-f\d]+)\b[%&!#]?/i,
+      operator: /--|\+\+|>>=?|<<=?|<>|[-+*/\\<>]=?|[:^=?]|\b(?:and|mod|not|or)\b/i,
+      punctuation: /[.,;()[\]{}]/,
+      constant: /\b(?:LINE_NUM)\b/i
+    }, t.languages.brightscript["directive-statement"].inside.expression.inside = t.languages.brightscript;
+  }
+  return s;
+}
+var p = d();
+const u = /* @__PURE__ */ c(p), l = /* @__PURE__ */ b({
+  __proto__: null,
+  default: u
+}, [p]);
+export {
+  l as b
+};

package/dist/bro-C_rmjGgn.js

@@ -0,0 +1,60 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function s(e, o) {
+  for (var n = 0; n < o.length; n++) {
+    const r = o[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const i = Object.getOwnPropertyDescriptor(r, t);
+          i && Object.defineProperty(e, t, i.get ? i : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a, u;
+function b() {
+  if (u) return a;
+  u = 1, a = e, e.displayName = "bro", e.aliases = [];
+  function e(o) {
+    o.languages.bro = {
+      comment: {
+        pattern: /(^|[^\\$])#.*/,
+        lookbehind: !0,
+        inside: {
+          italic: /\b(?:FIXME|TODO|XXX)\b/
+        }
+      },
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      boolean: /\b[TF]\b/,
+      function: {
+        pattern: /(\b(?:event|function|hook)[ \t]+)\w+(?:::\w+)?/,
+        lookbehind: !0
+      },
+      builtin: /(?:@(?:load(?:-(?:plugin|sigs))?|unload|prefixes|ifn?def|else|(?:end)?if|DIR|FILENAME))|(?:&?(?:add_func|create_expire|default|delete_func|encrypt|error_handler|expire_func|group|log|mergeable|optional|persistent|priority|raw_output|read_expire|redef|rotate_interval|rotate_size|synchronized|type_column|write_expire))/,
+      constant: {
+        pattern: /(\bconst[ \t]+)\w+/i,
+        lookbehind: !0
+      },
+      keyword: /\b(?:add|addr|alarm|any|bool|break|const|continue|count|delete|double|else|enum|event|export|file|for|function|global|hook|if|in|int|interval|local|module|next|of|opaque|pattern|port|print|record|return|schedule|set|string|subnet|table|time|timeout|using|vector|when)\b/,
+      operator: /--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&|\|\|?|\?|\*|\/|~|\^|%/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      punctuation: /[{}[\];(),.:]/
+    };
+  }
+  return a;
+}
+var l = b();
+const c = /* @__PURE__ */ d(l), f = /* @__PURE__ */ s({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  f as b
+};

package/dist/bsl-DQhyt9j4.js

@@ -0,0 +1,101 @@
+import { g as i } from "./index-Sj89RFCY.js";
+function l(e, u) {
+  for (var n = 0; n < u.length; n++) {
+    const t = u[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const a = Object.getOwnPropertyDescriptor(t, r);
+          a && Object.defineProperty(e, r, a.get ? a : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var f, d;
+function s() {
+  if (d) return f;
+  d = 1, f = e, e.displayName = "bsl", e.aliases = [];
+  function e(u) {
+    u.languages.bsl = {
+      comment: /\/\/.*/,
+      string: [
+        // Строки
+        // Strings
+        {
+          pattern: /"(?:[^"]|"")*"(?!")/,
+          greedy: !0
+        },
+        // Дата и время
+        // 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: !0
+        },
+        {
+          // 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: !0
+      },
+      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: !0
+        },
+        // EN
+        {
+          pattern: /\b(?:and|not|or)\b/i
+        }
+      ],
+      punctuation: /\(\.|\.\)|[()\[\]:;,.]/,
+      directive: [
+        // Теги препроцессора вида &Клиент, &Сервер, ...
+        // Preprocessor tags of the type &Client, &Server, ...
+        {
+          pattern: /^([ \t]*)&.*/m,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "important"
+        },
+        // Инструкции препроцессора вида:
+        // #Если Сервер Тогда
+        // ...
+        // #КонецЕсли
+        // Preprocessor instructions of the form:
+        // #If Server Then
+        // ...
+        // #EndIf
+        {
+          pattern: /^([ \t]*)#.*/gm,
+          lookbehind: !0,
+          greedy: !0,
+          alias: "important"
+        }
+      ]
+    }, u.languages.oscript = u.languages.bsl;
+  }
+  return f;
+}
+var o = s();
+const b = /* @__PURE__ */ i(o), c = /* @__PURE__ */ l({
+  __proto__: null,
+  default: b
+}, [o]);
+export {
+  c as b
+};

package/dist/c-D8-laUL_.js

@@ -0,0 +1,26 @@
+import { g as f } from "./index-Sj89RFCY.js";
+import { r as s } from "./c-b2c4WJSm.js";
+function i(t, n) {
+  for (var o = 0; o < n.length; o++) {
+    const e = n[o];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in t)) {
+          const c = Object.getOwnPropertyDescriptor(e, r);
+          c && Object.defineProperty(t, r, c.get ? c : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var a = s();
+const p = /* @__PURE__ */ f(a), l = /* @__PURE__ */ i({
+  __proto__: null,
+  default: p
+}, [a]);
+export {
+  l as c
+};

package/dist/c-b2c4WJSm.js

@@ -0,0 +1,83 @@
+var t, r;
+function a() {
+  if (r) return t;
+  r = 1, t = n, n.displayName = "c", n.aliases = [];
+  function n(e) {
+    e.languages.c = e.languages.extend("clike", {
+      comment: {
+        pattern: /\/\/(?:[^\r\n\\]|\\(?:\r\n?|\n|(?![\r\n])))*|\/\*[\s\S]*?(?:\*\/|$)/,
+        greedy: !0
+      },
+      string: {
+        // https://en.cppreference.com/w/c/language/string_literal
+        pattern: /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/,
+        greedy: !0
+      },
+      "class-name": {
+        pattern: /(\b(?:enum|struct)\s+(?:__attribute__\s*\(\([\s\S]*?\)\)\s*)?)\w+|\b[a-z]\w*_t\b/,
+        lookbehind: !0
+      },
+      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|[?:~]|[-+*/%&|^!=<>]=?/
+    }), e.languages.insertBefore("c", "string", {
+      char: {
+        // https://en.cppreference.com/w/c/language/character_constant
+        pattern: /'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n]){0,32}'/,
+        greedy: !0
+      }
+    }), e.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: !0,
+        greedy: !0,
+        alias: "property",
+        inside: {
+          string: [
+            {
+              // highlight the path of the include statement as a string
+              pattern: /^(#\s*include\s*)<[^>]+>/,
+              lookbehind: !0
+            },
+            e.languages.c.string
+          ],
+          char: e.languages.c.char,
+          comment: e.languages.c.comment,
+          "macro-name": [
+            {
+              pattern: /(^#\s*define\s+)\w+\b(?!\()/i,
+              lookbehind: !0
+            },
+            {
+              pattern: /(^#\s*define\s+)\w+\b(?=\()/i,
+              lookbehind: !0,
+              alias: "function"
+            }
+          ],
+          // highlight macro directives as keywords
+          directive: {
+            pattern: /^(#\s*)[a-z]+/,
+            lookbehind: !0,
+            alias: "keyword"
+          },
+          "directive-hash": /^#/,
+          punctuation: /##|\\(?=[\r\n])/,
+          expression: {
+            pattern: /\S[\s\S]*/,
+            inside: e.languages.c
+          }
+        }
+      }
+    }), e.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 e.languages.c.boolean;
+  }
+  return t;
+}
+export {
+  a as r
+};

package/dist/cfscript-DcwVkFDX.js

@@ -0,0 +1,71 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function l(t, e) {
+  for (var n = 0; n < e.length; n++) {
+    const r = e[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const a in r)
+        if (a !== "default" && !(a in t)) {
+          const i = Object.getOwnPropertyDescriptor(r, a);
+          i && Object.defineProperty(t, a, i.get ? i : {
+            enumerable: !0,
+            get: () => r[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, c;
+function p() {
+  if (c) return o;
+  c = 1, o = t, t.displayName = "cfscript", t.aliases = [];
+  function t(e) {
+    e.languages.cfscript = e.languages.extend("clike", {
+      comment: [
+        {
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0,
+          inside: {
+            annotation: {
+              pattern: /(?:^|[^.])@[\w\.]+/,
+              alias: "punctuation"
+            }
+          }
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      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"
+      }
+    }), e.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 e.languages.cfscript["class-name"], e.languages.cfc = e.languages.cfscript;
+  }
+  return o;
+}
+var s = p();
+const f = /* @__PURE__ */ u(s), b = /* @__PURE__ */ l({
+  __proto__: null,
+  default: f
+}, [s]);
+export {
+  b as c
+};

package/dist/chaiscript-C1jdPAs0.js

@@ -0,0 +1,89 @@
+import { g as p } from "./index-Sj89RFCY.js";
+import { r as l } from "./cpp-C0j-5811.js";
+function u(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    const a = t[e];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const i in a)
+        if (i !== "default" && !(i in r)) {
+          const n = Object.getOwnPropertyDescriptor(a, i);
+          n && Object.defineProperty(r, i, n.get ? n : {
+            enumerable: !0,
+            get: () => a[i]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var s, o;
+function g() {
+  if (o) return s;
+  o = 1;
+  var r = l();
+  s = t, t.displayName = "chaiscript", t.aliases = [];
+  function t(e) {
+    e.register(r), e.languages.chaiscript = e.languages.extend("clike", {
+      string: {
+        pattern: /(^|[^\\])'(?:[^'\\]|\\[\s\S])*'/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      "class-name": [
+        {
+          // e.g. class Rectangle { ... }
+          pattern: /(\bclass\s+)\w+/,
+          lookbehind: !0
+        },
+        {
+          // e.g. attr Rectangle::height, def Rectangle::area() { ... }
+          pattern: /(\b(?:attr|def)\s+)\w+(?=\s*::)/,
+          lookbehind: !0
+        }
+      ],
+      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: [e.languages.cpp.number, /\b(?:Infinity|NaN)\b/],
+      operator: />>=?|<<=?|\|\||&&|:[:=]?|--|\+\+|[=!<>+\-*/%|&^]=?|[?~]|`[^`\r\n]{1,4}`/
+    }), e.languages.insertBefore("chaiscript", "operator", {
+      "parameter-type": {
+        // e.g. def foo(int x, Vector y) {...}
+        pattern: /([,(]\s*)\w+(?=\s+\w)/,
+        lookbehind: !0,
+        alias: "class-name"
+      }
+    }), e.languages.insertBefore("chaiscript", "string", {
+      "string-interpolation": {
+        pattern: /(^|[^\\])"(?:[^"$\\]|\\[\s\S]|\$(?!\{)|\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*"/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}/,
+            lookbehind: !0,
+            inside: {
+              "interpolation-expression": {
+                pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                lookbehind: !0,
+                inside: e.languages.chaiscript
+              },
+              "interpolation-punctuation": {
+                pattern: /^\$\{|\}$/,
+                alias: "punctuation"
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      }
+    });
+  }
+  return s;
+}
+var c = g();
+const f = /* @__PURE__ */ p(c), b = /* @__PURE__ */ u({
+  __proto__: null,
+  default: f
+}, [c]);
+export {
+  b as c
+};