@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/powerquery-BgH699y4.js

@@ -0,0 +1,94 @@
+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 powerquery_1;
+var hasRequiredPowerquery;
+function requirePowerquery() {
+  if (hasRequiredPowerquery) return powerquery_1;
+  hasRequiredPowerquery = 1;
+  powerquery_1 = powerquery2;
+  powerquery2.displayName = "powerquery";
+  powerquery2.aliases = [];
+  function powerquery2(Prism) {
+    Prism.languages.powerquery = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: true,
+        greedy: true
+      },
+      "quoted-identifier": {
+        pattern: /#"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: true
+      },
+      string: {
+        pattern: /(?:#!)?"(?:[^"\r\n]|"")*"(?!")/,
+        greedy: true
+      },
+      constant: [
+        /\bDay\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\b/,
+        /\bTraceLevel\.(?:Critical|Error|Information|Verbose|Warning)\b/,
+        /\bOccurrence\.(?:All|First|Last)\b/,
+        /\bOrder\.(?:Ascending|Descending)\b/,
+        /\bRoundingMode\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\b/,
+        /\bMissingField\.(?:Error|Ignore|UseNull)\b/,
+        /\bQuoteStyle\.(?:Csv|None)\b/,
+        /\bJoinKind\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\b/,
+        /\bGroupKind\.(?:Global|Local)\b/,
+        /\bExtraValues\.(?:Error|Ignore|List)\b/,
+        /\bJoinAlgorithm\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\b/,
+        /\bJoinSide\.(?:Left|Right)\b/,
+        /\bPrecision\.(?:Decimal|Double)\b/,
+        /\bRelativePosition\.From(?:End|Start)\b/,
+        /\bTextEncoding\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\b/,
+        /\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\.Type\b/,
+        /\bnull\b/
+      ],
+      boolean: /\b(?:false|true)\b/,
+      keyword: /\b(?:and|as|each|else|error|if|in|is|let|meta|not|nullable|optional|or|otherwise|section|shared|then|try|type)\b|#(?:binary|date|datetime|datetimezone|duration|infinity|nan|sections|shared|table|time)\b/,
+      function: {
+        pattern: /(^|[^#\w.])[a-z_][\w.]*(?=\s*\()/i,
+        lookbehind: true
+      },
+      "data-type": {
+        pattern: /\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\b/,
+        alias: "class-name"
+      },
+      number: {
+        pattern: /\b0x[\da-f]+\b|(?:[+-]?(?:\b\d+\.)?\b\d+|[+-]\.\d+|(^|[^.])\B\.\d+)(?:e[+-]?\d+)?\b/i,
+        lookbehind: true
+      },
+      operator: /[-+*\/&?@^]|<(?:=>?|>)?|>=?|=>?|\.\.\.?/,
+      punctuation: /[,;\[\](){}]/
+    };
+    Prism.languages.pq = Prism.languages["powerquery"];
+    Prism.languages.mscript = Prism.languages["powerquery"];
+  }
+  return powerquery_1;
+}
+var powerqueryExports = requirePowerquery();
+const powerquery = /* @__PURE__ */ getDefaultExportFromCjs(powerqueryExports);
+const powerquery$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: powerquery
+}, [powerqueryExports]);
+export {
+  powerquery$1 as p
+};
+//# sourceMappingURL=powerquery-BgH699y4.js.map

package/dist/powerquery-BgH699y4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"powerquery-BgH699y4.js","sources":["../node_modules/refractor/lang/powerquery.js"],"sourcesContent":["'use strict'\n\nmodule.exports = powerquery\npowerquery.displayName = 'powerquery'\npowerquery.aliases = []\nfunction powerquery(Prism) {\n  // https://docs.microsoft.com/en-us/powerquery-m/power-query-m-language-specification\n  Prism.languages.powerquery = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'quoted-identifier': {\n      pattern: /#\"(?:[^\"\\r\\n]|\"\")*\"(?!\")/,\n      greedy: true\n    },\n    string: {\n      pattern: /(?:#!)?\"(?:[^\"\\r\\n]|\"\")*\"(?!\")/,\n      greedy: true\n    },\n    constant: [\n      /\\bDay\\.(?:Friday|Monday|Saturday|Sunday|Thursday|Tuesday|Wednesday)\\b/,\n      /\\bTraceLevel\\.(?:Critical|Error|Information|Verbose|Warning)\\b/,\n      /\\bOccurrence\\.(?:All|First|Last)\\b/,\n      /\\bOrder\\.(?:Ascending|Descending)\\b/,\n      /\\bRoundingMode\\.(?:AwayFromZero|Down|ToEven|TowardZero|Up)\\b/,\n      /\\bMissingField\\.(?:Error|Ignore|UseNull)\\b/,\n      /\\bQuoteStyle\\.(?:Csv|None)\\b/,\n      /\\bJoinKind\\.(?:FullOuter|Inner|LeftAnti|LeftOuter|RightAnti|RightOuter)\\b/,\n      /\\bGroupKind\\.(?:Global|Local)\\b/,\n      /\\bExtraValues\\.(?:Error|Ignore|List)\\b/,\n      /\\bJoinAlgorithm\\.(?:Dynamic|LeftHash|LeftIndex|PairwiseHash|RightHash|RightIndex|SortMerge)\\b/,\n      /\\bJoinSide\\.(?:Left|Right)\\b/,\n      /\\bPrecision\\.(?:Decimal|Double)\\b/,\n      /\\bRelativePosition\\.From(?:End|Start)\\b/,\n      /\\bTextEncoding\\.(?:Ascii|BigEndianUnicode|Unicode|Utf16|Utf8|Windows)\\b/,\n      /\\b(?:Any|Binary|Date|DateTime|DateTimeZone|Duration|Function|Int16|Int32|Int64|Int8|List|Logical|None|Number|Record|Table|Text|Time)\\.Type\\b/,\n      /\\bnull\\b/\n    ],\n    boolean: /\\b(?:false|true)\\b/,\n    keyword:\n      /\\b(?:and|as|each|else|error|if|in|is|let|meta|not|nullable|optional|or|otherwise|section|shared|then|try|type)\\b|#(?:binary|date|datetime|datetimezone|duration|infinity|nan|sections|shared|table|time)\\b/,\n    function: {\n      pattern: /(^|[^#\\w.])[a-z_][\\w.]*(?=\\s*\\()/i,\n      lookbehind: true\n    },\n    'data-type': {\n      pattern:\n        /\\b(?:any|anynonnull|binary|date|datetime|datetimezone|duration|function|list|logical|none|number|record|table|text|time)\\b/,\n      alias: 'class-name'\n    },\n    number: {\n      pattern:\n        /\\b0x[\\da-f]+\\b|(?:[+-]?(?:\\b\\d+\\.)?\\b\\d+|[+-]\\.\\d+|(^|[^.])\\B\\.\\d+)(?:e[+-]?\\d+)?\\b/i,\n      lookbehind: true\n    },\n    operator: /[-+*\\/&?@^]|<(?:=>?|>)?|>=?|=>?|\\.\\.\\.?/,\n    punctuation: /[,;\\[\\](){}]/\n  }\n  Prism.languages.pq = Prism.languages['powerquery']\n  Prism.languages.mscript = Prism.languages['powerquery']\n}\n"],"names":["powerquery"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AAEzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,qBAAqB;AAAA,QACnB,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,QACR;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;MAEF,SAAS;AAAA,MACT,SACE;AAAA,MACF,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,aAAa;AAAA,QACX,SACE;AAAA,QACF,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,KAAK,MAAM,UAAU,YAAY;AACjD,UAAM,UAAU,UAAU,MAAM,UAAU,YAAY;AAAA,EACxD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/powershell-D4c11US9.js

@@ -0,0 +1,97 @@
+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 powershell_1;
+var hasRequiredPowershell;
+function requirePowershell() {
+  if (hasRequiredPowershell) return powershell_1;
+  hasRequiredPowershell = 1;
+  powershell_1 = powershell2;
+  powershell2.displayName = "powershell";
+  powershell2.aliases = [];
+  function powershell2(Prism) {
+    (function(Prism2) {
+      var powershell3 = Prism2.languages.powershell = {
+        comment: [
+          {
+            pattern: /(^|[^`])<#[\s\S]*?#>/,
+            lookbehind: true
+          },
+          {
+            pattern: /(^|[^`])#.*/,
+            lookbehind: true
+          }
+        ],
+        string: [
+          {
+            pattern: /"(?:`[\s\S]|[^`"])*"/,
+            greedy: true,
+            inside: null
+            // see below
+          },
+          {
+            pattern: /'(?:[^']|'')*'/,
+            greedy: true
+          }
+        ],
+        // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices
+        // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)
+        namespace: /\[[a-z](?:\[(?:\[[^\]]*\]|[^\[\]])*\]|[^\[\]])*\]/i,
+        boolean: /\$(?:false|true)\b/i,
+        variable: /\$\w+\b/,
+        // Cmdlets and aliases. Aliases should come last, otherwise "write" gets preferred over "write-host" for example
+        // Get-Command | ?{ $_.ModuleName -match "Microsoft.PowerShell.(Util|Core|Management)" }
+        // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match "Microsoft.PowerShell.(Util|Core|Management)" }
+        function: [
+          /\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\b/i,
+          /\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\b/i
+        ],
+        // per http://technet.microsoft.com/en-us/library/hh847744.aspx
+        keyword: /\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\b/i,
+        operator: {
+          pattern: /(^|\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\b|-[-=]?|\+[+=]?|[*\/%]=?)/i,
+          lookbehind: true
+        },
+        punctuation: /[|{}[\];(),.]/
+      };
+      powershell3.string[0].inside = {
+        function: {
+          // Allow for one level of nesting
+          pattern: /(^|[^`])\$\((?:\$\([^\r\n()]*\)|(?!\$\()[^\r\n)])*\)/,
+          lookbehind: true,
+          inside: powershell3
+        },
+        boolean: powershell3.boolean,
+        variable: powershell3.variable
+      };
+    })(Prism);
+  }
+  return powershell_1;
+}
+var powershellExports = requirePowershell();
+const powershell = /* @__PURE__ */ getDefaultExportFromCjs(powershellExports);
+const powershell$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: powershell
+}, [powershellExports]);
+export {
+  powershell$1 as p
+};
+//# sourceMappingURL=powershell-D4c11US9.js.map

package/dist/powershell-D4c11US9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"powershell-D4c11US9.js","sources":["../node_modules/refractor/lang/powershell.js"],"sourcesContent":["'use strict'\n\nmodule.exports = powershell\npowershell.displayName = 'powershell'\npowershell.aliases = []\nfunction powershell(Prism) {\n  ;(function (Prism) {\n    var powershell = (Prism.languages.powershell = {\n      comment: [\n        {\n          pattern: /(^|[^`])<#[\\s\\S]*?#>/,\n          lookbehind: true\n        },\n        {\n          pattern: /(^|[^`])#.*/,\n          lookbehind: true\n        }\n      ],\n      string: [\n        {\n          pattern: /\"(?:`[\\s\\S]|[^`\"])*\"/,\n          greedy: true,\n          inside: null // see below\n        },\n        {\n          pattern: /'(?:[^']|'')*'/,\n          greedy: true\n        }\n      ],\n      // Matches name spaces as well as casts, attribute decorators. Force starting with letter to avoid matching array indices\n      // Supports two levels of nested brackets (e.g. `[OutputType([System.Collections.Generic.List[int]])]`)\n      namespace: /\\[[a-z](?:\\[(?:\\[[^\\]]*\\]|[^\\[\\]])*\\]|[^\\[\\]])*\\]/i,\n      boolean: /\\$(?:false|true)\\b/i,\n      variable: /\\$\\w+\\b/,\n      // Cmdlets and aliases. Aliases should come last, otherwise \"write\" gets preferred over \"write-host\" for example\n      // Get-Command | ?{ $_.ModuleName -match \"Microsoft.PowerShell.(Util|Core|Management)\" }\n      // Get-Alias | ?{ $_.ReferencedCommand.Module.Name -match \"Microsoft.PowerShell.(Util|Core|Management)\" }\n      function: [\n        /\\b(?:Add|Approve|Assert|Backup|Block|Checkpoint|Clear|Close|Compare|Complete|Compress|Confirm|Connect|Convert|ConvertFrom|ConvertTo|Copy|Debug|Deny|Disable|Disconnect|Dismount|Edit|Enable|Enter|Exit|Expand|Export|Find|ForEach|Format|Get|Grant|Group|Hide|Import|Initialize|Install|Invoke|Join|Limit|Lock|Measure|Merge|Move|New|Open|Optimize|Out|Ping|Pop|Protect|Publish|Push|Read|Receive|Redo|Register|Remove|Rename|Repair|Request|Reset|Resize|Resolve|Restart|Restore|Resume|Revoke|Save|Search|Select|Send|Set|Show|Skip|Sort|Split|Start|Step|Stop|Submit|Suspend|Switch|Sync|Tee|Test|Trace|Unblock|Undo|Uninstall|Unlock|Unprotect|Unpublish|Unregister|Update|Use|Wait|Watch|Where|Write)-[a-z]+\\b/i,\n        /\\b(?:ac|cat|chdir|clc|cli|clp|clv|compare|copy|cp|cpi|cpp|cvpa|dbp|del|diff|dir|ebp|echo|epal|epcsv|epsn|erase|fc|fl|ft|fw|gal|gbp|gc|gci|gcs|gdr|gi|gl|gm|gp|gps|group|gsv|gu|gv|gwmi|iex|ii|ipal|ipcsv|ipsn|irm|iwmi|iwr|kill|lp|ls|measure|mi|mount|move|mp|mv|nal|ndr|ni|nv|ogv|popd|ps|pushd|pwd|rbp|rd|rdr|ren|ri|rm|rmdir|rni|rnp|rp|rv|rvpa|rwmi|sal|saps|sasv|sbp|sc|select|set|shcm|si|sl|sleep|sls|sort|sp|spps|spsv|start|sv|swmi|tee|trcm|type|write)\\b/i\n      ],\n      // per http://technet.microsoft.com/en-us/library/hh847744.aspx\n      keyword:\n        /\\b(?:Begin|Break|Catch|Class|Continue|Data|Define|Do|DynamicParam|Else|ElseIf|End|Exit|Filter|Finally|For|ForEach|From|Function|If|InlineScript|Parallel|Param|Process|Return|Sequence|Switch|Throw|Trap|Try|Until|Using|Var|While|Workflow)\\b/i,\n      operator: {\n        pattern:\n          /(^|\\W)(?:!|-(?:b?(?:and|x?or)|as|(?:Not)?(?:Contains|In|Like|Match)|eq|ge|gt|is(?:Not)?|Join|le|lt|ne|not|Replace|sh[lr])\\b|-[-=]?|\\+[+=]?|[*\\/%]=?)/i,\n        lookbehind: true\n      },\n      punctuation: /[|{}[\\];(),.]/\n    }) // Variable interpolation inside strings, and nested expressions\n    powershell.string[0].inside = {\n      function: {\n        // Allow for one level of nesting\n        pattern: /(^|[^`])\\$\\((?:\\$\\([^\\r\\n()]*\\)|(?!\\$\\()[^\\r\\n)])*\\)/,\n        lookbehind: true,\n        inside: powershell\n      },\n      boolean: powershell.boolean,\n      variable: powershell.variable\n    }\n  })(Prism)\n}\n"],"names":["powershell","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACxB,KAAC,SAAUC,QAAO;AACjB,UAAID,cAAcC,OAAM,UAAU,aAAa;AAAA,QAC7C,SAAS;AAAA,UACP;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;;QAGhB,QAAQ;AAAA,UACN;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA,YACR,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;;;QAKZ,WAAW;AAAA,QACX,SAAS;AAAA,QACT,UAAU;AAAA;AAAA;AAAA;AAAA,QAIV,UAAU;AAAA,UACR;AAAA,UACA;AAAA;;QAGF,SACE;AAAA,QACF,UAAU;AAAA,UACR,SACE;AAAA,UACF,YAAY;AAAA;QAEd,aAAa;AAAA,MACnB;AACI,MAAAD,YAAW,OAAO,CAAC,EAAE,SAAS;AAAA,QAC5B,UAAU;AAAA;AAAA,UAER,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQA;AAAA;QAEV,SAASA,YAAW;AAAA,QACpB,UAAUA,YAAW;AAAA;IAE3B,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/processing-Dxz0m36k.js

@@ -0,0 +1,56 @@
+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 processing_1;
+var hasRequiredProcessing;
+function requireProcessing() {
+  if (hasRequiredProcessing) return processing_1;
+  hasRequiredProcessing = 1;
+  processing_1 = processing2;
+  processing2.displayName = "processing";
+  processing2.aliases = [];
+  function processing2(Prism) {
+    Prism.languages.processing = Prism.languages.extend("clike", {
+      keyword: /\b(?:break|case|catch|class|continue|default|else|extends|final|for|if|implements|import|new|null|private|public|return|static|super|switch|this|try|void|while)\b/,
+      // Spaces are allowed between function name and parenthesis
+      function: /\b\w+(?=\s*\()/,
+      operator: /<[<=]?|>[>=]?|&&?|\|\|?|[%?]|[!=+\-*\/]=?/
+    });
+    Prism.languages.insertBefore("processing", "number", {
+      // Special case: XML is a type
+      constant: /\b(?!XML\b)[A-Z][A-Z\d_]+\b/,
+      type: {
+        pattern: /\b(?:boolean|byte|char|color|double|float|int|[A-Z]\w*)\b/,
+        alias: "class-name"
+      }
+    });
+  }
+  return processing_1;
+}
+var processingExports = requireProcessing();
+const processing = /* @__PURE__ */ getDefaultExportFromCjs(processingExports);
+const processing$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: processing
+}, [processingExports]);
+export {
+  processing$1 as p
+};
+//# sourceMappingURL=processing-Dxz0m36k.js.map

package/dist/processing-Dxz0m36k.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processing-Dxz0m36k.js","sources":["../node_modules/refractor/lang/processing.js"],"sourcesContent":["'use strict'\n\nmodule.exports = processing\nprocessing.displayName = 'processing'\nprocessing.aliases = []\nfunction processing(Prism) {\n  Prism.languages.processing = Prism.languages.extend('clike', {\n    keyword:\n      /\\b(?:break|case|catch|class|continue|default|else|extends|final|for|if|implements|import|new|null|private|public|return|static|super|switch|this|try|void|while)\\b/,\n    // Spaces are allowed between function name and parenthesis\n    function: /\\b\\w+(?=\\s*\\()/,\n    operator: /<[<=]?|>[>=]?|&&?|\\|\\|?|[%?]|[!=+\\-*\\/]=?/\n  })\n  Prism.languages.insertBefore('processing', 'number', {\n    // Special case: XML is a type\n    constant: /\\b(?!XML\\b)[A-Z][A-Z\\d_]+\\b/,\n    type: {\n      pattern: /\\b(?:boolean|byte|char|color|double|float|int|[A-Z]\\w*)\\b/,\n      alias: 'class-name'\n    }\n  })\n}\n"],"names":["processing"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAA;AACrB,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa,MAAM,UAAU,OAAO,SAAS;AAAA,MAC3D,SACE;AAAA;AAAA,MAEF,UAAU;AAAA,MACV,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,cAAc,UAAU;AAAA;AAAA,MAEnD,UAAU;AAAA,MACV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/prolog-B6WRUPN0.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 prolog_1;
+var hasRequiredProlog;
+function requireProlog() {
+  if (hasRequiredProlog) return prolog_1;
+  hasRequiredProlog = 1;
+  prolog_1 = prolog2;
+  prolog2.displayName = "prolog";
+  prolog2.aliases = [];
+  function prolog2(Prism) {
+    Prism.languages.prolog = {
+      // Syntax depends on the implementation
+      comment: {
+        pattern: /\/\*[\s\S]*?\*\/|%.*/,
+        greedy: true
+      },
+      // Depending on the implementation, strings may allow escaped newlines and quote-escape
+      string: {
+        pattern: /(["'])(?:\1\1|\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1(?!\1)/,
+        greedy: true
+      },
+      builtin: /\b(?:fx|fy|xf[xy]?|yfx?)\b/,
+      // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?
+      function: /\b[a-z]\w*(?:(?=\()|\/\d+)/,
+      number: /\b\d+(?:\.\d*)?/,
+      // Custom operators are allowed
+      operator: /[:\\=><\-?*@\/;+^|!$.]+|\b(?:is|mod|not|xor)\b/,
+      punctuation: /[(){}\[\],]/
+    };
+  }
+  return prolog_1;
+}
+var prologExports = requireProlog();
+const prolog = /* @__PURE__ */ getDefaultExportFromCjs(prologExports);
+const prolog$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: prolog
+}, [prologExports]);
+export {
+  prolog$1 as p
+};
+//# sourceMappingURL=prolog-B6WRUPN0.js.map

package/dist/prolog-B6WRUPN0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prolog-B6WRUPN0.js","sources":["../node_modules/refractor/lang/prolog.js"],"sourcesContent":["'use strict'\n\nmodule.exports = prolog\nprolog.displayName = 'prolog'\nprolog.aliases = []\nfunction prolog(Prism) {\n  Prism.languages.prolog = {\n    // Syntax depends on the implementation\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?\\*\\/|%.*/,\n      greedy: true\n    },\n    // Depending on the implementation, strings may allow escaped newlines and quote-escape\n    string: {\n      pattern: /([\"'])(?:\\1\\1|\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1(?!\\1)/,\n      greedy: true\n    },\n    builtin: /\\b(?:fx|fy|xf[xy]?|yfx?)\\b/,\n    // FIXME: Should we list all null-ary predicates (not followed by a parenthesis) like halt, trace, etc.?\n    function: /\\b[a-z]\\w*(?:(?=\\()|\\/\\d+)/,\n    number: /\\b\\d+(?:\\.\\d*)?/,\n    // Custom operators are allowed\n    operator: /[:\\\\=><\\-?*@\\/;+^|!$.]+|\\b(?:is|mod|not|xor)\\b/,\n    punctuation: /[(){}\\[\\],]/\n  }\n}\n"],"names":["prolog"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA;AAAA,MAEvB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SAAS;AAAA;AAAA,MAET,UAAU;AAAA,MACV,QAAQ;AAAA;AAAA,MAER,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/promql-F9ca9EAm.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 promql_1;
+var hasRequiredPromql;
+function requirePromql() {
+  if (hasRequiredPromql) return promql_1;
+  hasRequiredPromql = 1;
+  promql_1 = promql2;
+  promql2.displayName = "promql";
+  promql2.aliases = [];
+  function promql2(Prism) {
+    (function(Prism2) {
+      var aggregations = [
+        "sum",
+        "min",
+        "max",
+        "avg",
+        "group",
+        "stddev",
+        "stdvar",
+        "count",
+        "count_values",
+        "bottomk",
+        "topk",
+        "quantile"
+      ];
+      var vectorMatching = [
+        "on",
+        "ignoring",
+        "group_right",
+        "group_left",
+        "by",
+        "without"
+      ];
+      var offsetModifier = ["offset"];
+      var keywords = aggregations.concat(vectorMatching, offsetModifier);
+      Prism2.languages.promql = {
+        comment: {
+          pattern: /(^[ \t]*)#.*/m,
+          lookbehind: true
+        },
+        "vector-match": {
+          // Match the comma-separated label lists inside vector matching:
+          pattern: new RegExp(
+            "((?:" + vectorMatching.join("|") + ")\\s*)\\([^)]*\\)"
+          ),
+          lookbehind: true,
+          inside: {
+            "label-key": {
+              pattern: /\b[^,]+\b/,
+              alias: "attr-name"
+            },
+            punctuation: /[(),]/
+          }
+        },
+        "context-labels": {
+          pattern: /\{[^{}]*\}/,
+          inside: {
+            "label-key": {
+              pattern: /\b[a-z_]\w*(?=\s*(?:=|![=~]))/,
+              alias: "attr-name"
+            },
+            "label-value": {
+              pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+              greedy: true,
+              alias: "attr-value"
+            },
+            punctuation: /\{|\}|=~?|![=~]|,/
+          }
+        },
+        "context-range": [
+          {
+            pattern: /\[[\w\s:]+\]/,
+            // [1m]
+            inside: {
+              punctuation: /\[|\]|:/,
+              "range-duration": {
+                pattern: /\b(?:\d+(?:[smhdwy]|ms))+\b/i,
+                alias: "number"
+              }
+            }
+          },
+          {
+            pattern: /(\boffset\s+)\w+/,
+            // offset 1m
+            lookbehind: true,
+            inside: {
+              "range-duration": {
+                pattern: /\b(?:\d+(?:[smhdwy]|ms))+\b/i,
+                alias: "number"
+              }
+            }
+          }
+        ],
+        keyword: new RegExp("\\b(?:" + keywords.join("|") + ")\\b", "i"),
+        function: /\b[a-z_]\w*(?=\s*\()/i,
+        number: /[-+]?(?:(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[-+]?\d+)?\b|\b(?:0x[0-9a-f]+|nan|inf)\b)/i,
+        operator: /[\^*/%+-]|==|!=|<=|<|>=|>|\b(?:and|or|unless)\b/i,
+        punctuation: /[{};()`,.[\]]/
+      };
+    })(Prism);
+  }
+  return promql_1;
+}
+var promqlExports = requirePromql();
+const promql = /* @__PURE__ */ getDefaultExportFromCjs(promqlExports);
+const promql$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: promql
+}, [promqlExports]);
+export {
+  promql$1 as p
+};
+//# sourceMappingURL=promql-F9ca9EAm.js.map

package/dist/promql-F9ca9EAm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"promql-F9ca9EAm.js","sources":["../node_modules/refractor/lang/promql.js"],"sourcesContent":["'use strict'\n\nmodule.exports = promql\npromql.displayName = 'promql'\npromql.aliases = []\nfunction promql(Prism) {\n  // Thanks to: https://github.com/prometheus-community/monaco-promql/blob/master/src/promql/promql.ts\n  // As well as: https://kausal.co/blog/slate-prism-add-new-syntax-promql/\n  ;(function (Prism) {\n    // PromQL Aggregation Operators\n    // (https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators)\n    var aggregations = [\n      'sum',\n      'min',\n      'max',\n      'avg',\n      'group',\n      'stddev',\n      'stdvar',\n      'count',\n      'count_values',\n      'bottomk',\n      'topk',\n      'quantile'\n    ] // PromQL vector matching + the by and without clauses\n    // (https://prometheus.io/docs/prometheus/latest/querying/operators/#vector-matching)\n    var vectorMatching = [\n      'on',\n      'ignoring',\n      'group_right',\n      'group_left',\n      'by',\n      'without'\n    ] // PromQL offset modifier\n    // (https://prometheus.io/docs/prometheus/latest/querying/basics/#offset-modifier)\n    var offsetModifier = ['offset']\n    var keywords = aggregations.concat(vectorMatching, offsetModifier)\n    Prism.languages.promql = {\n      comment: {\n        pattern: /(^[ \\t]*)#.*/m,\n        lookbehind: true\n      },\n      'vector-match': {\n        // Match the comma-separated label lists inside vector matching:\n        pattern: new RegExp(\n          '((?:' + vectorMatching.join('|') + ')\\\\s*)\\\\([^)]*\\\\)'\n        ),\n        lookbehind: true,\n        inside: {\n          'label-key': {\n            pattern: /\\b[^,]+\\b/,\n            alias: 'attr-name'\n          },\n          punctuation: /[(),]/\n        }\n      },\n      'context-labels': {\n        pattern: /\\{[^{}]*\\}/,\n        inside: {\n          'label-key': {\n            pattern: /\\b[a-z_]\\w*(?=\\s*(?:=|![=~]))/,\n            alias: 'attr-name'\n          },\n          'label-value': {\n            pattern: /([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1/,\n            greedy: true,\n            alias: 'attr-value'\n          },\n          punctuation: /\\{|\\}|=~?|![=~]|,/\n        }\n      },\n      'context-range': [\n        {\n          pattern: /\\[[\\w\\s:]+\\]/,\n          // [1m]\n          inside: {\n            punctuation: /\\[|\\]|:/,\n            'range-duration': {\n              pattern: /\\b(?:\\d+(?:[smhdwy]|ms))+\\b/i,\n              alias: 'number'\n            }\n          }\n        },\n        {\n          pattern: /(\\boffset\\s+)\\w+/,\n          // offset 1m\n          lookbehind: true,\n          inside: {\n            'range-duration': {\n              pattern: /\\b(?:\\d+(?:[smhdwy]|ms))+\\b/i,\n              alias: 'number'\n            }\n          }\n        }\n      ],\n      keyword: new RegExp('\\\\b(?:' + keywords.join('|') + ')\\\\b', 'i'),\n      function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n      number:\n        /[-+]?(?:(?:\\b\\d+(?:\\.\\d+)?|\\B\\.\\d+)(?:e[-+]?\\d+)?\\b|\\b(?:0x[0-9a-f]+|nan|inf)\\b)/i,\n      operator: /[\\^*/%+-]|==|!=|<=|<|>=|>|\\b(?:and|or|unless)\\b/i,\n      punctuation: /[{};()`,.[\\]]/\n    }\n  })(Prism)\n}\n"],"names":["promql","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AAGpB,KAAC,SAAUC,QAAO;AAGjB,UAAI,eAAe;AAAA,QACjB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAGF,UAAI,iBAAiB;AAAA,QACnB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA;AAGF,UAAI,iBAAiB,CAAC,QAAQ;AAC9B,UAAI,WAAW,aAAa,OAAO,gBAAgB,cAAc;AACjE,MAAAA,OAAM,UAAU,SAAS;AAAA,QACvB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,gBAAgB;AAAA;AAAA,UAEd,SAAS,IAAI;AAAA,YACX,SAAS,eAAe,KAAK,GAAG,IAAI;AAAA;UAEtC,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA,cACT,OAAO;AAAA;YAET,aAAa;AAAA;;QAGjB,kBAAkB;AAAA,UAChB,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,cACX,SAAS;AAAA,cACT,OAAO;AAAA;YAET,eAAe;AAAA,cACb,SAAS;AAAA,cACT,QAAQ;AAAA,cACR,OAAO;AAAA;YAET,aAAa;AAAA;;QAGjB,iBAAiB;AAAA,UACf;AAAA,YACE,SAAS;AAAA;AAAA,YAET,QAAQ;AAAA,cACN,aAAa;AAAA,cACb,kBAAkB;AAAA,gBAChB,SAAS;AAAA,gBACT,OAAO;AAAA;;;UAIb;AAAA,YACE,SAAS;AAAA;AAAA,YAET,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,kBAAkB;AAAA,gBAChB,SAAS;AAAA,gBACT,OAAO;AAAA;;;;QAKf,SAAS,IAAI,OAAO,WAAW,SAAS,KAAK,GAAG,IAAI,QAAQ,GAAG;AAAA,QAC/D,UAAU;AAAA,QACV,QACE;AAAA,QACF,UAAU;AAAA,QACV,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/properties-CRZCME4s.js

@@ -0,0 +1,51 @@
+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 properties_1;
+var hasRequiredProperties;
+function requireProperties() {
+  if (hasRequiredProperties) return properties_1;
+  hasRequiredProperties = 1;
+  properties_1 = properties2;
+  properties2.displayName = "properties";
+  properties2.aliases = [];
+  function properties2(Prism) {
+    Prism.languages.properties = {
+      comment: /^[ \t]*[#!].*$/m,
+      "attr-value": {
+        pattern: /(^[ \t]*(?:\\(?:\r\n|[\s\S])|[^\\\s:=])+(?: *[=:] *(?! )| ))(?:\\(?:\r\n|[\s\S])|[^\\\r\n])+/m,
+        lookbehind: true
+      },
+      "attr-name": /^[ \t]*(?:\\(?:\r\n|[\s\S])|[^\\\s:=])+(?= *[=:]| )/m,
+      punctuation: /[=:]/
+    };
+  }
+  return properties_1;
+}
+var propertiesExports = requireProperties();
+const properties = /* @__PURE__ */ getDefaultExportFromCjs(propertiesExports);
+const properties$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: properties
+}, [propertiesExports]);
+export {
+  properties$1 as p
+};
+//# sourceMappingURL=properties-CRZCME4s.js.map

package/dist/properties-CRZCME4s.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"properties-CRZCME4s.js","sources":["../node_modules/refractor/lang/properties.js"],"sourcesContent":["'use strict'\n\nmodule.exports = properties\nproperties.displayName = 'properties'\nproperties.aliases = []\nfunction properties(Prism) {\n  Prism.languages.properties = {\n    comment: /^[ \\t]*[#!].*$/m,\n    'attr-value': {\n      pattern:\n        /(^[ \\t]*(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\s:=])+(?: *[=:] *(?! )| ))(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n])+/m,\n      lookbehind: true\n    },\n    'attr-name': /^[ \\t]*(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\s:=])+(?= *[=:]| )/m,\n    punctuation: /[=:]/\n  }\n}\n"],"names":["properties"],"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,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA;MAEd,aAAa;AAAA,MACb,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/protobuf-C2f7QC99.js

@@ -0,0 +1,81 @@
+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 protobuf_1;
+var hasRequiredProtobuf;
+function requireProtobuf() {
+  if (hasRequiredProtobuf) return protobuf_1;
+  hasRequiredProtobuf = 1;
+  protobuf_1 = protobuf2;
+  protobuf2.displayName = "protobuf";
+  protobuf2.aliases = [];
+  function protobuf2(Prism) {
+    (function(Prism2) {
+      var builtinTypes = /\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\b/;
+      Prism2.languages.protobuf = Prism2.languages.extend("clike", {
+        "class-name": [
+          {
+            pattern: /(\b(?:enum|extend|message|service)\s+)[A-Za-z_]\w*(?=\s*\{)/,
+            lookbehind: true
+          },
+          {
+            pattern: /(\b(?:rpc\s+\w+|returns)\s*\(\s*(?:stream\s+)?)\.?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?=\s*\))/,
+            lookbehind: true
+          }
+        ],
+        keyword: /\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\s+\w)|service|stream|syntax|to)\b(?!\s*=\s*\d)/,
+        function: /\b[a-z_]\w*(?=\s*\()/i
+      });
+      Prism2.languages.insertBefore("protobuf", "operator", {
+        map: {
+          pattern: /\bmap<\s*[\w.]+\s*,\s*[\w.]+\s*>(?=\s+[a-z_]\w*\s*[=;])/i,
+          alias: "class-name",
+          inside: {
+            punctuation: /[<>.,]/,
+            builtin: builtinTypes
+          }
+        },
+        builtin: builtinTypes,
+        "positional-class-name": {
+          pattern: /(?:\b|\B\.)[a-z_]\w*(?:\.[a-z_]\w*)*(?=\s+[a-z_]\w*\s*[=;])/i,
+          alias: "class-name",
+          inside: {
+            punctuation: /\./
+          }
+        },
+        annotation: {
+          pattern: /(\[\s*)[a-z_]\w*(?=\s*=)/i,
+          lookbehind: true
+        }
+      });
+    })(Prism);
+  }
+  return protobuf_1;
+}
+var protobufExports = requireProtobuf();
+const protobuf = /* @__PURE__ */ getDefaultExportFromCjs(protobufExports);
+const protobuf$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: protobuf
+}, [protobufExports]);
+export {
+  protobuf$1 as p
+};
+//# sourceMappingURL=protobuf-C2f7QC99.js.map

package/dist/protobuf-C2f7QC99.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protobuf-C2f7QC99.js","sources":["../node_modules/refractor/lang/protobuf.js"],"sourcesContent":["'use strict'\n\nmodule.exports = protobuf\nprotobuf.displayName = 'protobuf'\nprotobuf.aliases = []\nfunction protobuf(Prism) {\n  ;(function (Prism) {\n    var builtinTypes =\n      /\\b(?:bool|bytes|double|s?fixed(?:32|64)|float|[su]?int(?:32|64)|string)\\b/\n    Prism.languages.protobuf = Prism.languages.extend('clike', {\n      'class-name': [\n        {\n          pattern:\n            /(\\b(?:enum|extend|message|service)\\s+)[A-Za-z_]\\w*(?=\\s*\\{)/,\n          lookbehind: true\n        },\n        {\n          pattern:\n            /(\\b(?:rpc\\s+\\w+|returns)\\s*\\(\\s*(?:stream\\s+)?)\\.?[A-Za-z_]\\w*(?:\\.[A-Za-z_]\\w*)*(?=\\s*\\))/,\n          lookbehind: true\n        }\n      ],\n      keyword:\n        /\\b(?:enum|extend|extensions|import|message|oneof|option|optional|package|public|repeated|required|reserved|returns|rpc(?=\\s+\\w)|service|stream|syntax|to)\\b(?!\\s*=\\s*\\d)/,\n      function: /\\b[a-z_]\\w*(?=\\s*\\()/i\n    })\n    Prism.languages.insertBefore('protobuf', 'operator', {\n      map: {\n        pattern: /\\bmap<\\s*[\\w.]+\\s*,\\s*[\\w.]+\\s*>(?=\\s+[a-z_]\\w*\\s*[=;])/i,\n        alias: 'class-name',\n        inside: {\n          punctuation: /[<>.,]/,\n          builtin: builtinTypes\n        }\n      },\n      builtin: builtinTypes,\n      'positional-class-name': {\n        pattern: /(?:\\b|\\B\\.)[a-z_]\\w*(?:\\.[a-z_]\\w*)*(?=\\s+[a-z_]\\w*\\s*[=;])/i,\n        alias: 'class-name',\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      annotation: {\n        pattern: /(\\[\\s*)[a-z_]\\w*(?=\\s*=)/i,\n        lookbehind: true\n      }\n    })\n  })(Prism)\n}\n"],"names":["protobuf","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,eAAiBA;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAA;AACnB,WAASA,UAAS,OAAO;AACtB,KAAC,SAAUC,QAAO;AACjB,UAAI,eACF;AACF,MAAAA,OAAM,UAAU,WAAWA,OAAM,UAAU,OAAO,SAAS;AAAA,QACzD,cAAc;AAAA,UACZ;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;UAEd;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;;QAGhB,SACE;AAAA,QACF,UAAU;AAAA,MAChB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,YAAY,YAAY;AAAA,QACnD,KAAK;AAAA,UACH,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA,YACb,SAAS;AAAA;;QAGb,SAAS;AAAA,QACT,yBAAyB;AAAA,UACvB,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,YAAY;AAAA,UACV,SAAS;AAAA,UACT,YAAY;AAAA;MAEpB,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}