@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/visual-basic-D5q0LX_r.js

@@ -0,0 +1,70 @@
+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 visualBasic_1;
+var hasRequiredVisualBasic;
+function requireVisualBasic() {
+  if (hasRequiredVisualBasic) return visualBasic_1;
+  hasRequiredVisualBasic = 1;
+  visualBasic_1 = visualBasic2;
+  visualBasic2.displayName = "visualBasic";
+  visualBasic2.aliases = [];
+  function visualBasic2(Prism) {
+    Prism.languages["visual-basic"] = {
+      comment: {
+        pattern: /(?:['‘’]|REM\b)(?:[^\r\n_]|_(?:\r\n?|\n)?)*/i,
+        inside: {
+          keyword: /^REM/i
+        }
+      },
+      directive: {
+        pattern: /#(?:Const|Else|ElseIf|End|ExternalChecksum|ExternalSource|If|Region)(?:\b_[ \t]*(?:\r\n?|\n)|.)+/i,
+        alias: "property",
+        greedy: true
+      },
+      string: {
+        pattern: /\$?["“”](?:["“”]{2}|[^"“”])*["“”]C?/i,
+        greedy: true
+      },
+      date: {
+        pattern: /#[ \t]*(?:\d+([/-])\d+\1\d+(?:[ \t]+(?:\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?))?|\d+[ \t]*(?:AM|PM)|\d+:\d+(?::\d+)?(?:[ \t]*(?:AM|PM))?)[ \t]*#/i,
+        alias: "number"
+      },
+      number: /(?:(?:\b\d+(?:\.\d+)?|\.\d+)(?:E[+-]?\d+)?|&[HO][\dA-F]+)(?:[FRD]|U?[ILS])?/i,
+      boolean: /\b(?:False|Nothing|True)\b/i,
+      keyword: /\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\b/i,
+      operator: /[+\-*/\\^<=>&#@$%!]|\b_(?=[ \t]*[\r\n])/,
+      punctuation: /[{}().,:?]/
+    };
+    Prism.languages.vb = Prism.languages["visual-basic"];
+    Prism.languages.vba = Prism.languages["visual-basic"];
+  }
+  return visualBasic_1;
+}
+var visualBasicExports = requireVisualBasic();
+const visualBasic = /* @__PURE__ */ getDefaultExportFromCjs(visualBasicExports);
+const visualBasic$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: visualBasic
+}, [visualBasicExports]);
+export {
+  visualBasic$1 as v
+};
+//# sourceMappingURL=visual-basic-D5q0LX_r.js.map

package/dist/visual-basic-D5q0LX_r.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-basic-D5q0LX_r.js","sources":["../node_modules/refractor/lang/visual-basic.js"],"sourcesContent":["'use strict'\n\nmodule.exports = visualBasic\nvisualBasic.displayName = 'visualBasic'\nvisualBasic.aliases = []\nfunction visualBasic(Prism) {\n  Prism.languages['visual-basic'] = {\n    comment: {\n      pattern: /(?:['‘’]|REM\\b)(?:[^\\r\\n_]|_(?:\\r\\n?|\\n)?)*/i,\n      inside: {\n        keyword: /^REM/i\n      }\n    },\n    directive: {\n      pattern:\n        /#(?:Const|Else|ElseIf|End|ExternalChecksum|ExternalSource|If|Region)(?:\\b_[ \\t]*(?:\\r\\n?|\\n)|.)+/i,\n      alias: 'property',\n      greedy: true\n    },\n    string: {\n      pattern: /\\$?[\"“”](?:[\"“”]{2}|[^\"“”])*[\"“”]C?/i,\n      greedy: true\n    },\n    date: {\n      pattern:\n        /#[ \\t]*(?:\\d+([/-])\\d+\\1\\d+(?:[ \\t]+(?:\\d+[ \\t]*(?:AM|PM)|\\d+:\\d+(?::\\d+)?(?:[ \\t]*(?:AM|PM))?))?|\\d+[ \\t]*(?:AM|PM)|\\d+:\\d+(?::\\d+)?(?:[ \\t]*(?:AM|PM))?)[ \\t]*#/i,\n      alias: 'number'\n    },\n    number:\n      /(?:(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)(?:E[+-]?\\d+)?|&[HO][\\dA-F]+)(?:[FRD]|U?[ILS])?/i,\n    boolean: /\\b(?:False|Nothing|True)\\b/i,\n    keyword:\n      /\\b(?:AddHandler|AddressOf|Alias|And(?:Also)?|As|Boolean|ByRef|Byte|ByVal|Call|Case|Catch|C(?:Bool|Byte|Char|Date|Dbl|Dec|Int|Lng|Obj|SByte|Short|Sng|Str|Type|UInt|ULng|UShort)|Char|Class|Const|Continue|Currency|Date|Decimal|Declare|Default|Delegate|Dim|DirectCast|Do|Double|Each|Else(?:If)?|End(?:If)?|Enum|Erase|Error|Event|Exit|Finally|For|Friend|Function|Get(?:Type|XMLNamespace)?|Global|GoSub|GoTo|Handles|If|Implements|Imports|In|Inherits|Integer|Interface|Is|IsNot|Let|Lib|Like|Long|Loop|Me|Mod|Module|Must(?:Inherit|Override)|My(?:Base|Class)|Namespace|Narrowing|New|Next|Not(?:Inheritable|Overridable)?|Object|Of|On|Operator|Option(?:al)?|Or(?:Else)?|Out|Overloads|Overridable|Overrides|ParamArray|Partial|Private|Property|Protected|Public|RaiseEvent|ReadOnly|ReDim|RemoveHandler|Resume|Return|SByte|Select|Set|Shadows|Shared|short|Single|Static|Step|Stop|String|Structure|Sub|SyncLock|Then|Throw|To|Try|TryCast|Type|TypeOf|U(?:Integer|Long|Short)|Until|Using|Variant|Wend|When|While|Widening|With(?:Events)?|WriteOnly|Xor)\\b/i,\n    operator: /[+\\-*/\\\\^<=>&#@$%!]|\\b_(?=[ \\t]*[\\r\\n])/,\n    punctuation: /[{}().,:?]/\n  }\n  Prism.languages.vb = Prism.languages['visual-basic']\n  Prism.languages.vba = Prism.languages['visual-basic']\n}\n"],"names":["visualBasic"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,kBAAiBA;AACjB,EAAAA,aAAY,cAAc;AAC1B,EAAAA,aAAY,UAAU,CAAA;AACtB,WAASA,aAAY,OAAO;AAC1B,UAAM,UAAU,cAAc,IAAI;AAAA,MAChC,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,SAAS;AAAA;;MAGb,WAAW;AAAA,QACT,SACE;AAAA,QACF,OAAO;AAAA,QACP,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,MAAM;AAAA,QACJ,SACE;AAAA,QACF,OAAO;AAAA;MAET,QACE;AAAA,MACF,SAAS;AAAA,MACT,SACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,KAAK,MAAM,UAAU,cAAc;AACnD,UAAM,UAAU,MAAM,MAAM,UAAU,cAAc;AAAA,EACtD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/warpscript-RxU40iJr.js

@@ -0,0 +1,63 @@
+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 warpscript_1;
+var hasRequiredWarpscript;
+function requireWarpscript() {
+  if (hasRequiredWarpscript) return warpscript_1;
+  hasRequiredWarpscript = 1;
+  warpscript_1 = warpscript2;
+  warpscript2.displayName = "warpscript";
+  warpscript2.aliases = [];
+  function warpscript2(Prism) {
+    Prism.languages.warpscript = {
+      comment: /#.*|\/\/.*|\/\*[\s\S]*?\*\//,
+      string: {
+        pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'|<'(?:[^\\']|'(?!>)|\\.)*'>/,
+        greedy: true
+      },
+      variable: /\$\S+/,
+      macro: {
+        pattern: /@\S+/,
+        alias: "property"
+      },
+      // WarpScript doesn't have any keywords, these are all functions under the control category
+      // https://www.warp10.io/tags/control
+      keyword: /\b(?:BREAK|CHECKMACRO|CONTINUE|CUDF|DEFINED|DEFINEDMACRO|EVAL|FAIL|FOR|FOREACH|FORSTEP|IFT|IFTE|MSGFAIL|NRETURN|RETHROW|RETURN|SWITCH|TRY|UDF|UNTIL|WHILE)\b/,
+      number: /[+-]?\b(?:NaN|Infinity|\d+(?:\.\d*)?(?:[Ee][+-]?\d+)?|0x[\da-fA-F]+|0b[01]+)\b/,
+      boolean: /\b(?:F|T|false|true)\b/,
+      punctuation: /<%|%>|[{}[\]()]/,
+      // Some operators from the "operators" category
+      // https://www.warp10.io/tags/operators
+      operator: /==|&&?|\|\|?|\*\*?|>>>?|<<|[<>!~]=?|[-/%^]|\+!?|\b(?:AND|NOT|OR)\b/
+    };
+  }
+  return warpscript_1;
+}
+var warpscriptExports = requireWarpscript();
+const warpscript = /* @__PURE__ */ getDefaultExportFromCjs(warpscriptExports);
+const warpscript$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: warpscript
+}, [warpscriptExports]);
+export {
+  warpscript$1 as w
+};
+//# sourceMappingURL=warpscript-RxU40iJr.js.map

package/dist/warpscript-RxU40iJr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warpscript-RxU40iJr.js","sources":["../node_modules/refractor/lang/warpscript.js"],"sourcesContent":["'use strict'\n\nmodule.exports = warpscript\nwarpscript.displayName = 'warpscript'\nwarpscript.aliases = []\nfunction warpscript(Prism) {\n  Prism.languages.warpscript = {\n    comment: /#.*|\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n    string: {\n      pattern:\n        /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'|<'(?:[^\\\\']|'(?!>)|\\\\.)*'>/,\n      greedy: true\n    },\n    variable: /\\$\\S+/,\n    macro: {\n      pattern: /@\\S+/,\n      alias: 'property'\n    },\n    // WarpScript doesn't have any keywords, these are all functions under the control category\n    // https://www.warp10.io/tags/control\n    keyword:\n      /\\b(?:BREAK|CHECKMACRO|CONTINUE|CUDF|DEFINED|DEFINEDMACRO|EVAL|FAIL|FOR|FOREACH|FORSTEP|IFT|IFTE|MSGFAIL|NRETURN|RETHROW|RETURN|SWITCH|TRY|UDF|UNTIL|WHILE)\\b/,\n    number:\n      /[+-]?\\b(?:NaN|Infinity|\\d+(?:\\.\\d*)?(?:[Ee][+-]?\\d+)?|0x[\\da-fA-F]+|0b[01]+)\\b/,\n    boolean: /\\b(?:F|T|false|true)\\b/,\n    punctuation: /<%|%>|[{}[\\]()]/,\n    // Some operators from the \"operators\" category\n    // https://www.warp10.io/tags/operators\n    operator:\n      /==|&&?|\\|\\|?|\\*\\*?|>>>?|<<|[<>!~]=?|[-/%^]|\\+!?|\\b(?:AND|NOT|OR)\\b/\n  }\n}\n"],"names":["warpscript"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;;;MAIT,SACE;AAAA,MACF,QACE;AAAA,MACF,SAAS;AAAA,MACT,aAAa;AAAA;AAAA;AAAA,MAGb,UACE;AAAA;EAEN;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/wasm-HbJer3Oi.js

@@ -0,0 +1,73 @@
+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 wasm_1;
+var hasRequiredWasm;
+function requireWasm() {
+  if (hasRequiredWasm) return wasm_1;
+  hasRequiredWasm = 1;
+  wasm_1 = wasm2;
+  wasm2.displayName = "wasm";
+  wasm2.aliases = [];
+  function wasm2(Prism) {
+    Prism.languages.wasm = {
+      comment: [
+        /\(;[\s\S]*?;\)/,
+        {
+          pattern: /;;.*/,
+          greedy: true
+        }
+      ],
+      string: {
+        pattern: /"(?:\\[\s\S]|[^"\\])*"/,
+        greedy: true
+      },
+      keyword: [
+        {
+          pattern: /\b(?:align|offset)=/,
+          inside: {
+            operator: /=/
+          }
+        },
+        {
+          pattern: /\b(?:(?:f32|f64|i32|i64)(?:\.(?:abs|add|and|ceil|clz|const|convert_[su]\/i(?:32|64)|copysign|ctz|demote\/f64|div(?:_[su])?|eqz?|extend_[su]\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\/f32|reinterpret\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\/f(?:32|64))?|wrap\/i64|xor))?|memory\.(?:grow|size))\b/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        /\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\b/
+      ],
+      variable: /\$[\w!#$%&'*+\-./:<=>?@\\^`|~]+/,
+      number: /[+-]?\b(?:\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?|0x[\da-fA-F](?:_?[\da-fA-F])*(?:\.[\da-fA-F](?:_?[\da-fA-D])*)?(?:[pP][+-]?\d(?:_?\d)*)?)\b|\binf\b|\bnan(?::0x[\da-fA-F](?:_?[\da-fA-D])*)?\b/,
+      punctuation: /[()]/
+    };
+  }
+  return wasm_1;
+}
+var wasmExports = requireWasm();
+const wasm = /* @__PURE__ */ getDefaultExportFromCjs(wasmExports);
+const wasm$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: wasm
+}, [wasmExports]);
+export {
+  wasm$1 as w
+};
+//# sourceMappingURL=wasm-HbJer3Oi.js.map

package/dist/wasm-HbJer3Oi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-HbJer3Oi.js","sources":["../node_modules/refractor/lang/wasm.js"],"sourcesContent":["'use strict'\n\nmodule.exports = wasm\nwasm.displayName = 'wasm'\nwasm.aliases = []\nfunction wasm(Prism) {\n  Prism.languages.wasm = {\n    comment: [\n      /\\(;[\\s\\S]*?;\\)/,\n      {\n        pattern: /;;.*/,\n        greedy: true\n      }\n    ],\n    string: {\n      pattern: /\"(?:\\\\[\\s\\S]|[^\"\\\\])*\"/,\n      greedy: true\n    },\n    keyword: [\n      {\n        pattern: /\\b(?:align|offset)=/,\n        inside: {\n          operator: /=/\n        }\n      },\n      {\n        pattern:\n          /\\b(?:(?:f32|f64|i32|i64)(?:\\.(?:abs|add|and|ceil|clz|const|convert_[su]\\/i(?:32|64)|copysign|ctz|demote\\/f64|div(?:_[su])?|eqz?|extend_[su]\\/i32|floor|ge(?:_[su])?|gt(?:_[su])?|le(?:_[su])?|load(?:(?:8|16|32)_[su])?|lt(?:_[su])?|max|min|mul|neg?|nearest|or|popcnt|promote\\/f32|reinterpret\\/[fi](?:32|64)|rem_[su]|rot[lr]|shl|shr_[su]|sqrt|store(?:8|16|32)?|sub|trunc(?:_[su]\\/f(?:32|64))?|wrap\\/i64|xor))?|memory\\.(?:grow|size))\\b/,\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      /\\b(?:anyfunc|block|br(?:_if|_table)?|call(?:_indirect)?|data|drop|elem|else|end|export|func|get_(?:global|local)|global|if|import|local|loop|memory|module|mut|nop|offset|param|result|return|select|set_(?:global|local)|start|table|tee_local|then|type|unreachable)\\b/\n    ],\n    variable: /\\$[\\w!#$%&'*+\\-./:<=>?@\\\\^`|~]+/,\n    number:\n      /[+-]?\\b(?:\\d(?:_?\\d)*(?:\\.\\d(?:_?\\d)*)?(?:[eE][+-]?\\d(?:_?\\d)*)?|0x[\\da-fA-F](?:_?[\\da-fA-F])*(?:\\.[\\da-fA-F](?:_?[\\da-fA-D])*)?(?:[pP][+-]?\\d(?:_?\\d)*)?)\\b|\\binf\\b|\\bnan(?::0x[\\da-fA-F](?:_?[\\da-fA-D])*)?\\b/,\n    punctuation: /[()]/\n  }\n}\n"],"names":["wasm"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,QACP;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SAAS;AAAA,QACP;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,UAAU;AAAA;;QAGd;AAAA,UACE,SACE;AAAA,UACF,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB;AAAA;MAEF,UAAU;AAAA,MACV,QACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/web-idl-CZbxRc4B.js

@@ -0,0 +1,132 @@
+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 webIdl_1;
+var hasRequiredWebIdl;
+function requireWebIdl() {
+  if (hasRequiredWebIdl) return webIdl_1;
+  hasRequiredWebIdl = 1;
+  webIdl_1 = webIdl2;
+  webIdl2.displayName = "webIdl";
+  webIdl2.aliases = [];
+  function webIdl2(Prism) {
+    (function(Prism2) {
+      var id = /(?:\B-|\b_|\b)[A-Za-z][\w-]*(?![\w-])/.source;
+      var type = "(?:" + /\b(?:unsigned\s+)?long\s+long(?![\w-])/.source + "|" + /\b(?:unrestricted|unsigned)\s+[a-z]+(?![\w-])/.source + "|" + /(?!(?:unrestricted|unsigned)\b)/.source + id + /(?:\s*<(?:[^<>]|<[^<>]*>)*>)?/.source + ")" + /(?:\s*\?)?/.source;
+      var typeInside = {};
+      Prism2.languages["web-idl"] = {
+        comment: {
+          pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+          greedy: true
+        },
+        string: {
+          pattern: /"[^"]*"/,
+          greedy: true
+        },
+        namespace: {
+          pattern: RegExp(/(\bnamespace\s+)/.source + id),
+          lookbehind: true
+        },
+        "class-name": [
+          {
+            pattern: /(^|[^\w-])(?:iterable|maplike|setlike)\s*<(?:[^<>]|<[^<>]*>)*>/,
+            lookbehind: true,
+            inside: typeInside
+          },
+          {
+            pattern: RegExp(
+              /(\b(?:attribute|const|deleter|getter|optional|setter)\s+)/.source + type
+            ),
+            lookbehind: true,
+            inside: typeInside
+          },
+          {
+            // callback return type
+            pattern: RegExp(
+              "(" + /\bcallback\s+/.source + id + /\s*=\s*/.source + ")" + type
+            ),
+            lookbehind: true,
+            inside: typeInside
+          },
+          {
+            // typedef
+            pattern: RegExp(/(\btypedef\b\s*)/.source + type),
+            lookbehind: true,
+            inside: typeInside
+          },
+          {
+            pattern: RegExp(
+              /(\b(?:callback|dictionary|enum|interface(?:\s+mixin)?)\s+)(?!(?:interface|mixin)\b)/.source + id
+            ),
+            lookbehind: true
+          },
+          {
+            // inheritance
+            pattern: RegExp(/(:\s*)/.source + id),
+            lookbehind: true
+          },
+          // includes and implements
+          RegExp(id + /(?=\s+(?:implements|includes)\b)/.source),
+          {
+            pattern: RegExp(/(\b(?:implements|includes)\s+)/.source + id),
+            lookbehind: true
+          },
+          {
+            // function return type, parameter types, and dictionary members
+            pattern: RegExp(
+              type + "(?=" + /\s*(?:\.{3}\s*)?/.source + id + /\s*[(),;=]/.source + ")"
+            ),
+            inside: typeInside
+          }
+        ],
+        builtin: /\b(?:ArrayBuffer|BigInt64Array|BigUint64Array|ByteString|DOMString|DataView|Float32Array|Float64Array|FrozenArray|Int16Array|Int32Array|Int8Array|ObservableArray|Promise|USVString|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray)\b/,
+        keyword: [
+          /\b(?:async|attribute|callback|const|constructor|deleter|dictionary|enum|getter|implements|includes|inherit|interface|mixin|namespace|null|optional|or|partial|readonly|required|setter|static|stringifier|typedef|unrestricted)\b/,
+          // type keywords
+          /\b(?:any|bigint|boolean|byte|double|float|iterable|long|maplike|object|octet|record|sequence|setlike|short|symbol|undefined|unsigned|void)\b/
+        ],
+        boolean: /\b(?:false|true)\b/,
+        number: {
+          pattern: /(^|[^\w-])-?(?:0x[0-9a-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|NaN|Infinity)(?![\w-])/i,
+          lookbehind: true
+        },
+        operator: /\.{3}|[=:?<>-]/,
+        punctuation: /[(){}[\].,;]/
+      };
+      for (var key in Prism2.languages["web-idl"]) {
+        if (key !== "class-name") {
+          typeInside[key] = Prism2.languages["web-idl"][key];
+        }
+      }
+      Prism2.languages["webidl"] = Prism2.languages["web-idl"];
+    })(Prism);
+  }
+  return webIdl_1;
+}
+var webIdlExports = requireWebIdl();
+const webIdl = /* @__PURE__ */ getDefaultExportFromCjs(webIdlExports);
+const webIdl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: webIdl
+}, [webIdlExports]);
+export {
+  webIdl$1 as w
+};
+//# sourceMappingURL=web-idl-CZbxRc4B.js.map

package/dist/web-idl-CZbxRc4B.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-idl-CZbxRc4B.js","sources":["../node_modules/refractor/lang/web-idl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = webIdl\nwebIdl.displayName = 'webIdl'\nwebIdl.aliases = []\nfunction webIdl(Prism) {\n  ;(function (Prism) {\n    var id = /(?:\\B-|\\b_|\\b)[A-Za-z][\\w-]*(?![\\w-])/.source\n    var type =\n      '(?:' +\n      /\\b(?:unsigned\\s+)?long\\s+long(?![\\w-])/.source +\n      '|' +\n      /\\b(?:unrestricted|unsigned)\\s+[a-z]+(?![\\w-])/.source +\n      '|' +\n      /(?!(?:unrestricted|unsigned)\\b)/.source +\n      id +\n      /(?:\\s*<(?:[^<>]|<[^<>]*>)*>)?/.source +\n      ')' +\n      /(?:\\s*\\?)?/.source\n    var typeInside = {}\n    Prism.languages['web-idl'] = {\n      comment: {\n        pattern: /\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//,\n        greedy: true\n      },\n      string: {\n        pattern: /\"[^\"]*\"/,\n        greedy: true\n      },\n      namespace: {\n        pattern: RegExp(/(\\bnamespace\\s+)/.source + id),\n        lookbehind: true\n      },\n      'class-name': [\n        {\n          pattern:\n            /(^|[^\\w-])(?:iterable|maplike|setlike)\\s*<(?:[^<>]|<[^<>]*>)*>/,\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          pattern: RegExp(\n            /(\\b(?:attribute|const|deleter|getter|optional|setter)\\s+)/.source +\n              type\n          ),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // callback return type\n          pattern: RegExp(\n            '(' + /\\bcallback\\s+/.source + id + /\\s*=\\s*/.source + ')' + type\n          ),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // typedef\n          pattern: RegExp(/(\\btypedef\\b\\s*)/.source + type),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          pattern: RegExp(\n            /(\\b(?:callback|dictionary|enum|interface(?:\\s+mixin)?)\\s+)(?!(?:interface|mixin)\\b)/\n              .source + id\n          ),\n          lookbehind: true\n        },\n        {\n          // inheritance\n          pattern: RegExp(/(:\\s*)/.source + id),\n          lookbehind: true\n        }, // includes and implements\n        RegExp(id + /(?=\\s+(?:implements|includes)\\b)/.source),\n        {\n          pattern: RegExp(/(\\b(?:implements|includes)\\s+)/.source + id),\n          lookbehind: true\n        },\n        {\n          // function return type, parameter types, and dictionary members\n          pattern: RegExp(\n            type +\n              '(?=' +\n              /\\s*(?:\\.{3}\\s*)?/.source +\n              id +\n              /\\s*[(),;=]/.source +\n              ')'\n          ),\n          inside: typeInside\n        }\n      ],\n      builtin:\n        /\\b(?:ArrayBuffer|BigInt64Array|BigUint64Array|ByteString|DOMString|DataView|Float32Array|Float64Array|FrozenArray|Int16Array|Int32Array|Int8Array|ObservableArray|Promise|USVString|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray)\\b/,\n      keyword: [\n        /\\b(?:async|attribute|callback|const|constructor|deleter|dictionary|enum|getter|implements|includes|inherit|interface|mixin|namespace|null|optional|or|partial|readonly|required|setter|static|stringifier|typedef|unrestricted)\\b/, // type keywords\n        /\\b(?:any|bigint|boolean|byte|double|float|iterable|long|maplike|object|octet|record|sequence|setlike|short|symbol|undefined|unsigned|void)\\b/\n      ],\n      boolean: /\\b(?:false|true)\\b/,\n      number: {\n        pattern:\n          /(^|[^\\w-])-?(?:0x[0-9a-f]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|NaN|Infinity)(?![\\w-])/i,\n        lookbehind: true\n      },\n      operator: /\\.{3}|[=:?<>-]/,\n      punctuation: /[(){}[\\].,;]/\n    }\n    for (var key in Prism.languages['web-idl']) {\n      if (key !== 'class-name') {\n        typeInside[key] = Prism.languages['web-idl'][key]\n      }\n    }\n    Prism.languages['webidl'] = Prism.languages['web-idl']\n  })(Prism)\n}\n"],"names":["webIdl","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AACjB,UAAI,KAAK,wCAAwC;AACjD,UAAI,OACF,QACA,yCAAyC,SACzC,MACA,gDAAgD,SAChD,MACA,kCAAkC,SAClC,KACA,gCAAgC,SAChC,MACA,aAAa;AACf,UAAI,aAAa,CAAA;AACjB,MAAAA,OAAM,UAAU,SAAS,IAAI;AAAA,QAC3B,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,WAAW;AAAA,UACT,SAAS,OAAO,mBAAmB,SAAS,EAAE;AAAA,UAC9C,YAAY;AAAA;QAEd,cAAc;AAAA,UACZ;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,cACP,4DAA4D,SAC1D;AAAA;YAEJ,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS;AAAA,cACP,MAAM,gBAAgB,SAAS,KAAK,UAAU,SAAS,MAAM;AAAA;YAE/D,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS,OAAO,mBAAmB,SAAS,IAAI;AAAA,YAChD,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,cACP,sFACG,SAAS;AAAA;YAEd,YAAY;AAAA;UAEd;AAAA;AAAA,YAEE,SAAS,OAAO,SAAS,SAAS,EAAE;AAAA,YACpC,YAAY;AAAA;;UAEd,OAAO,KAAK,mCAAmC,MAAM;AAAA,UACrD;AAAA,YACE,SAAS,OAAO,iCAAiC,SAAS,EAAE;AAAA,YAC5D,YAAY;AAAA;UAEd;AAAA;AAAA,YAEE,SAAS;AAAA,cACP,OACE,QACA,mBAAmB,SACnB,KACA,aAAa,SACb;AAAA;YAEJ,QAAQ;AAAA;;QAGZ,SACE;AAAA,QACF,SAAS;AAAA,UACP;AAAA;AAAA,UACA;AAAA;QAEF,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,SACE;AAAA,UACF,YAAY;AAAA;QAEd,UAAU;AAAA,QACV,aAAa;AAAA;AAEf,eAAS,OAAOA,OAAM,UAAU,SAAS,GAAG;AAC1C,YAAI,QAAQ,cAAc;AACxB,qBAAW,GAAG,IAAIA,OAAM,UAAU,SAAS,EAAE,GAAG;AAAA,QACxD;AAAA,MACA;AACI,MAAAA,OAAM,UAAU,QAAQ,IAAIA,OAAM,UAAU,SAAS;AAAA,IACzD,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/wiki-BhokOJ04.js

@@ -0,0 +1,120 @@
+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 wiki_1;
+var hasRequiredWiki;
+function requireWiki() {
+  if (hasRequiredWiki) return wiki_1;
+  hasRequiredWiki = 1;
+  wiki_1 = wiki2;
+  wiki2.displayName = "wiki";
+  wiki2.aliases = [];
+  function wiki2(Prism) {
+    Prism.languages.wiki = Prism.languages.extend("markup", {
+      "block-comment": {
+        pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+        lookbehind: true,
+        alias: "comment"
+      },
+      heading: {
+        pattern: /^(=+)[^=\r\n].*?\1/m,
+        inside: {
+          punctuation: /^=+|=+$/,
+          important: /.+/
+        }
+      },
+      emphasis: {
+        // TODO Multi-line
+        pattern: /('{2,5}).+?\1/,
+        inside: {
+          "bold-italic": {
+            pattern: /(''''').+?(?=\1)/,
+            lookbehind: true,
+            alias: ["bold", "italic"]
+          },
+          bold: {
+            pattern: /(''')[^'](?:.*?[^'])?(?=\1)/,
+            lookbehind: true
+          },
+          italic: {
+            pattern: /('')[^'](?:.*?[^'])?(?=\1)/,
+            lookbehind: true
+          },
+          punctuation: /^''+|''+$/
+        }
+      },
+      hr: {
+        pattern: /^-{4,}/m,
+        alias: "punctuation"
+      },
+      url: [
+        /ISBN +(?:97[89][ -]?)?(?:\d[ -]?){9}[\dx]\b|(?:PMID|RFC) +\d+/i,
+        /\[\[.+?\]\]|\[.+?\]/
+      ],
+      variable: [
+        /__[A-Z]+__/,
+        // FIXME Nested structures should be handled
+        // {{formatnum:{{#expr:{{{3}}}}}}}
+        /\{{3}.+?\}{3}/,
+        /\{\{.+?\}\}/
+      ],
+      symbol: [/^#redirect/im, /~{3,5}/],
+      // Handle table attrs:
+      // {|
+      // ! style="text-align:left;"| Item
+      // |}
+      "table-tag": {
+        pattern: /((?:^|[|!])[|!])[^|\r\n]+\|(?!\|)/m,
+        lookbehind: true,
+        inside: {
+          "table-bar": {
+            pattern: /\|$/,
+            alias: "punctuation"
+          },
+          rest: Prism.languages.markup["tag"].inside
+        }
+      },
+      punctuation: /^(?:\{\||\|\}|\|-|[*#:;!|])|\|\||!!/m
+    });
+    Prism.languages.insertBefore("wiki", "tag", {
+      // Prevent highlighting inside <nowiki>, <source> and <pre> tags
+      nowiki: {
+        pattern: /<(nowiki|pre|source)\b[^>]*>[\s\S]*?<\/\1>/i,
+        inside: {
+          tag: {
+            pattern: /<(?:nowiki|pre|source)\b[^>]*>|<\/(?:nowiki|pre|source)>/i,
+            inside: Prism.languages.markup["tag"].inside
+          }
+        }
+      }
+    });
+  }
+  return wiki_1;
+}
+var wikiExports = requireWiki();
+const wiki = /* @__PURE__ */ getDefaultExportFromCjs(wikiExports);
+const wiki$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: wiki
+}, [wikiExports]);
+export {
+  wiki$1 as w
+};
+//# sourceMappingURL=wiki-BhokOJ04.js.map

package/dist/wiki-BhokOJ04.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wiki-BhokOJ04.js","sources":["../node_modules/refractor/lang/wiki.js"],"sourcesContent":["'use strict'\n\nmodule.exports = wiki\nwiki.displayName = 'wiki'\nwiki.aliases = []\nfunction wiki(Prism) {\n  Prism.languages.wiki = Prism.languages.extend('markup', {\n    'block-comment': {\n      pattern: /(^|[^\\\\])\\/\\*[\\s\\S]*?\\*\\//,\n      lookbehind: true,\n      alias: 'comment'\n    },\n    heading: {\n      pattern: /^(=+)[^=\\r\\n].*?\\1/m,\n      inside: {\n        punctuation: /^=+|=+$/,\n        important: /.+/\n      }\n    },\n    emphasis: {\n      // TODO Multi-line\n      pattern: /('{2,5}).+?\\1/,\n      inside: {\n        'bold-italic': {\n          pattern: /(''''').+?(?=\\1)/,\n          lookbehind: true,\n          alias: ['bold', 'italic']\n        },\n        bold: {\n          pattern: /(''')[^'](?:.*?[^'])?(?=\\1)/,\n          lookbehind: true\n        },\n        italic: {\n          pattern: /('')[^'](?:.*?[^'])?(?=\\1)/,\n          lookbehind: true\n        },\n        punctuation: /^''+|''+$/\n      }\n    },\n    hr: {\n      pattern: /^-{4,}/m,\n      alias: 'punctuation'\n    },\n    url: [\n      /ISBN +(?:97[89][ -]?)?(?:\\d[ -]?){9}[\\dx]\\b|(?:PMID|RFC) +\\d+/i,\n      /\\[\\[.+?\\]\\]|\\[.+?\\]/\n    ],\n    variable: [\n      /__[A-Z]+__/, // FIXME Nested structures should be handled\n      // {{formatnum:{{#expr:{{{3}}}}}}}\n      /\\{{3}.+?\\}{3}/,\n      /\\{\\{.+?\\}\\}/\n    ],\n    symbol: [/^#redirect/im, /~{3,5}/],\n    // Handle table attrs:\n    // {|\n    // ! style=\"text-align:left;\"| Item\n    // |}\n    'table-tag': {\n      pattern: /((?:^|[|!])[|!])[^|\\r\\n]+\\|(?!\\|)/m,\n      lookbehind: true,\n      inside: {\n        'table-bar': {\n          pattern: /\\|$/,\n          alias: 'punctuation'\n        },\n        rest: Prism.languages.markup['tag'].inside\n      }\n    },\n    punctuation: /^(?:\\{\\||\\|\\}|\\|-|[*#:;!|])|\\|\\||!!/m\n  })\n  Prism.languages.insertBefore('wiki', 'tag', {\n    // Prevent highlighting inside <nowiki>, <source> and <pre> tags\n    nowiki: {\n      pattern: /<(nowiki|pre|source)\\b[^>]*>[\\s\\S]*?<\\/\\1>/i,\n      inside: {\n        tag: {\n          pattern: /<(?:nowiki|pre|source)\\b[^>]*>|<\\/(?:nowiki|pre|source)>/i,\n          inside: Prism.languages.markup['tag'].inside\n        }\n      }\n    }\n  })\n}\n"],"names":["wiki"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,UAAU;AAAA,MACtD,iBAAiB;AAAA,QACf,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,aAAa;AAAA,UACb,WAAW;AAAA;;MAGf,UAAU;AAAA;AAAA,QAER,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO,CAAC,QAAQ,QAAQ;AAAA;UAE1B,MAAM;AAAA,YACJ,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,QAAQ;AAAA,YACN,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,aAAa;AAAA;;MAGjB,IAAI;AAAA,QACF,SAAS;AAAA,QACT,OAAO;AAAA;MAET,KAAK;AAAA,QACH;AAAA,QACA;AAAA;MAEF,UAAU;AAAA,QACR;AAAA;AAAA;AAAA,QAEA;AAAA,QACA;AAAA;MAEF,QAAQ,CAAC,gBAAgB,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA,MAKjC,aAAa;AAAA,QACX,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,aAAa;AAAA,YACX,SAAS;AAAA,YACT,OAAO;AAAA;UAET,MAAM,MAAM,UAAU,OAAO,KAAK,EAAE;AAAA;;MAGxC,aAAa;AAAA,IACjB,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,OAAO;AAAA;AAAA,MAE1C,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,KAAK;AAAA,YACH,SAAS;AAAA,YACT,QAAQ,MAAM,UAAU,OAAO,KAAK,EAAE;AAAA;;;IAIhD,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/wolfram-CDSJLgDd.js

@@ -0,0 +1,70 @@
+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 wolfram_1;
+var hasRequiredWolfram;
+function requireWolfram() {
+  if (hasRequiredWolfram) return wolfram_1;
+  hasRequiredWolfram = 1;
+  wolfram_1 = wolfram2;
+  wolfram2.displayName = "wolfram";
+  wolfram2.aliases = ["mathematica", "wl", "nb"];
+  function wolfram2(Prism) {
+    Prism.languages.wolfram = {
+      // Allow one level of nesting - note: regex taken from applescipt
+      comment: /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
+      string: {
+        pattern: /"(?:\\.|[^"\\\r\n])*"/,
+        greedy: true
+      },
+      keyword: /\b(?:Abs|AbsArg|Accuracy|Block|Do|For|Function|If|Manipulate|Module|Nest|NestList|None|Return|Switch|Table|Which|While)\b/,
+      context: {
+        pattern: /\b\w+`+\w*/,
+        alias: "class-name"
+      },
+      blank: {
+        pattern: /\b\w+_\b/,
+        alias: "regex"
+      },
+      "global-variable": {
+        pattern: /\$\w+/,
+        alias: "variable"
+      },
+      boolean: /\b(?:False|True)\b/,
+      number: /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?j?\b/i,
+      operator: /\/\.|;|=\.|\^=|\^:=|:=|<<|>>|<\||\|>|:>|\|->|->|<-|@@@|@@|@|\/@|=!=|===|==|=|\+|-|\^|\[\/-+%=\]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+      punctuation: /[{}[\];(),.:]/
+    };
+    Prism.languages.mathematica = Prism.languages.wolfram;
+    Prism.languages.wl = Prism.languages.wolfram;
+    Prism.languages.nb = Prism.languages.wolfram;
+  }
+  return wolfram_1;
+}
+var wolframExports = requireWolfram();
+const wolfram = /* @__PURE__ */ getDefaultExportFromCjs(wolframExports);
+const wolfram$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: wolfram
+}, [wolframExports]);
+export {
+  wolfram$1 as w
+};
+//# sourceMappingURL=wolfram-CDSJLgDd.js.map

package/dist/wolfram-CDSJLgDd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wolfram-CDSJLgDd.js","sources":["../node_modules/refractor/lang/wolfram.js"],"sourcesContent":["'use strict'\n\nmodule.exports = wolfram\nwolfram.displayName = 'wolfram'\nwolfram.aliases = ['mathematica', 'wl', 'nb']\nfunction wolfram(Prism) {\n  Prism.languages.wolfram = {\n    // Allow one level of nesting - note: regex taken from applescipt\n    comment: /\\(\\*(?:\\(\\*(?:[^*]|\\*(?!\\)))*\\*\\)|(?!\\(\\*)[\\s\\S])*?\\*\\)/,\n    string: {\n      pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:Abs|AbsArg|Accuracy|Block|Do|For|Function|If|Manipulate|Module|Nest|NestList|None|Return|Switch|Table|Which|While)\\b/,\n    context: {\n      pattern: /\\b\\w+`+\\w*/,\n      alias: 'class-name'\n    },\n    blank: {\n      pattern: /\\b\\w+_\\b/,\n      alias: 'regex'\n    },\n    'global-variable': {\n      pattern: /\\$\\w+/,\n      alias: 'variable'\n    },\n    boolean: /\\b(?:False|True)\\b/,\n    number:\n      /(?:\\b(?=\\d)|\\B(?=\\.))(?:0[bo])?(?:(?:\\d|0x[\\da-f])[\\da-f]*(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?j?\\b/i,\n    operator:\n      /\\/\\.|;|=\\.|\\^=|\\^:=|:=|<<|>>|<\\||\\|>|:>|\\|->|->|<-|@@@|@@|@|\\/@|=!=|===|==|=|\\+|-|\\^|\\[\\/-+%=\\]=?|!=|\\*\\*?=?|\\/\\/?=?|<[<=>]?|>[=>]?|[&|^~]/,\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.mathematica = Prism.languages.wolfram\n  Prism.languages.wl = Prism.languages.wolfram\n  Prism.languages.nb = Prism.languages.wolfram\n}\n"],"names":["wolfram"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,cAAiBA;AACjB,EAAAA,SAAQ,cAAc;AACtB,EAAAA,SAAQ,UAAU,CAAC,eAAe,MAAM,IAAI;AAC5C,WAASA,SAAQ,OAAO;AACtB,UAAM,UAAU,UAAU;AAAA;AAAA,MAExB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,SAAS;AAAA,QACP,SAAS;AAAA,QACT,OAAO;AAAA;MAET,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;MAET,mBAAmB;AAAA,QACjB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SAAS;AAAA,MACT,QACE;AAAA,MACF,UACE;AAAA,MACF,aAAa;AAAA;AAEf,UAAM,UAAU,cAAc,MAAM,UAAU;AAC9C,UAAM,UAAU,KAAK,MAAM,UAAU;AACrC,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}