@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/inform7-Cv9KA6Zb.js

@@ -0,0 +1,101 @@
+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 inform7_1;
+var hasRequiredInform7;
+function requireInform7() {
+  if (hasRequiredInform7) return inform7_1;
+  hasRequiredInform7 = 1;
+  inform7_1 = inform72;
+  inform72.displayName = "inform7";
+  inform72.aliases = [];
+  function inform72(Prism) {
+    Prism.languages.inform7 = {
+      string: {
+        pattern: /"[^"]*"/,
+        inside: {
+          substitution: {
+            pattern: /\[[^\[\]]+\]/,
+            inside: {
+              delimiter: {
+                pattern: /\[|\]/,
+                alias: "punctuation"
+              }
+              // See rest below
+            }
+          }
+        }
+      },
+      comment: {
+        pattern: /\[[^\[\]]+\]/,
+        greedy: true
+      },
+      title: {
+        pattern: /^[ \t]*(?:book|chapter|part(?! of)|section|table|volume)\b.+/im,
+        alias: "important"
+      },
+      number: {
+        pattern: /(^|[^-])(?:\b\d+(?:\.\d+)?(?:\^\d+)?(?:(?!\d)\w+)?|\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\b(?!-)/i,
+        lookbehind: true
+      },
+      verb: {
+        pattern: /(^|[^-])\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\b(?!-)/i,
+        lookbehind: true,
+        alias: "operator"
+      },
+      keyword: {
+        pattern: /(^|[^-])\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\b(?!-)/i,
+        lookbehind: true
+      },
+      property: {
+        pattern: /(^|[^-])\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\b(?!-)/i,
+        lookbehind: true,
+        alias: "symbol"
+      },
+      position: {
+        pattern: /(^|[^-])\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\b(?!-)/i,
+        lookbehind: true,
+        alias: "keyword"
+      },
+      type: {
+        pattern: /(^|[^-])\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\b(?!-)/i,
+        lookbehind: true,
+        alias: "variable"
+      },
+      punctuation: /[.,:;(){}]/
+    };
+    Prism.languages.inform7["string"].inside["substitution"].inside.rest = Prism.languages.inform7;
+    Prism.languages.inform7["string"].inside["substitution"].inside.rest.text = {
+      pattern: /\S(?:\s*\S)*/,
+      alias: "comment"
+    };
+  }
+  return inform7_1;
+}
+var inform7Exports = requireInform7();
+const inform7 = /* @__PURE__ */ getDefaultExportFromCjs(inform7Exports);
+const inform7$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: inform7
+}, [inform7Exports]);
+export {
+  inform7$1 as i
+};
+//# sourceMappingURL=inform7-Cv9KA6Zb.js.map

package/dist/inform7-Cv9KA6Zb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inform7-Cv9KA6Zb.js","sources":["../node_modules/refractor/lang/inform7.js"],"sourcesContent":["'use strict'\n\nmodule.exports = inform7\ninform7.displayName = 'inform7'\ninform7.aliases = []\nfunction inform7(Prism) {\n  Prism.languages.inform7 = {\n    string: {\n      pattern: /\"[^\"]*\"/,\n      inside: {\n        substitution: {\n          pattern: /\\[[^\\[\\]]+\\]/,\n          inside: {\n            delimiter: {\n              pattern: /\\[|\\]/,\n              alias: 'punctuation'\n            } // See rest below\n          }\n        }\n      }\n    },\n    comment: {\n      pattern: /\\[[^\\[\\]]+\\]/,\n      greedy: true\n    },\n    title: {\n      pattern: /^[ \\t]*(?:book|chapter|part(?! of)|section|table|volume)\\b.+/im,\n      alias: 'important'\n    },\n    number: {\n      pattern:\n        /(^|[^-])(?:\\b\\d+(?:\\.\\d+)?(?:\\^\\d+)?(?:(?!\\d)\\w+)?|\\b(?:eight|eleven|five|four|nine|one|seven|six|ten|three|twelve|two))\\b(?!-)/i,\n      lookbehind: true\n    },\n    verb: {\n      pattern:\n        /(^|[^-])\\b(?:answering|applying to|are|asking|attacking|be(?:ing)?|burning|buying|called|carries|carry(?! out)|carrying|climbing|closing|conceal(?:ing|s)?|consulting|contain(?:ing|s)?|cutting|drinking|dropping|eating|enclos(?:es?|ing)|entering|examining|exiting|getting|giving|going|ha(?:s|ve|ving)|hold(?:ing|s)?|impl(?:ies|y)|incorporat(?:es?|ing)|inserting|is|jumping|kissing|listening|locking|looking|mean(?:ing|s)?|opening|provid(?:es?|ing)|pulling|pushing|putting|relat(?:es?|ing)|removing|searching|see(?:ing|s)?|setting|showing|singing|sleeping|smelling|squeezing|support(?:ing|s)?|swearing|switching|taking|tasting|telling|thinking|throwing|touching|turning|tying|unlock(?:ing|s)?|var(?:ies|y|ying)|waiting|waking|waving|wear(?:ing|s)?)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'operator'\n    },\n    keyword: {\n      pattern:\n        /(^|[^-])\\b(?:after|before|carry out|check|continue the action|definition(?= *:)|do nothing|else|end (?:if|the story|unless)|every turn|if|include|instead(?: of)?|let|move|no|now|otherwise|repeat|report|resume the story|rule for|running through|say(?:ing)?|stop the action|test|try(?:ing)?|understand|unless|use|when|while|yes)\\b(?!-)/i,\n      lookbehind: true\n    },\n    property: {\n      pattern:\n        /(^|[^-])\\b(?:adjacent(?! to)|carried|closed|concealed|contained|dark|described|edible|empty|enclosed|enterable|even|female|fixed in place|full|handled|held|improper-named|incorporated|inedible|invisible|lighted|lit|lock(?:able|ed)|male|marked for listing|mentioned|negative|neuter|non-(?:empty|full|recurring)|odd|opaque|open(?:able)?|plural-named|portable|positive|privately-named|proper-named|provided|publically-named|pushable between rooms|recurring|related|rubbing|scenery|seen|singular-named|supported|swinging|switch(?:able|ed(?: off| on)?)|touch(?:able|ed)|transparent|unconcealed|undescribed|unlit|unlocked|unmarked for listing|unmentioned|unopenable|untouchable|unvisited|variable|visible|visited|wearable|worn)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'symbol'\n    },\n    position: {\n      pattern:\n        /(^|[^-])\\b(?:above|adjacent to|back side of|below|between|down|east|everywhere|front side|here|in|inside(?: from)?|north(?:east|west)?|nowhere|on(?: top of)?|other side|outside(?: from)?|parts? of|regionally in|south(?:east|west)?|through|up|west|within)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    type: {\n      pattern:\n        /(^|[^-])\\b(?:actions?|activit(?:ies|y)|actors?|animals?|backdrops?|containers?|devices?|directions?|doors?|holders?|kinds?|lists?|m[ae]n|nobody|nothing|nouns?|numbers?|objects?|people|persons?|player(?:'s holdall)?|regions?|relations?|rooms?|rule(?:book)?s?|scenes?|someone|something|supporters?|tables?|texts?|things?|time|vehicles?|wom[ae]n)\\b(?!-)/i,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    punctuation: /[.,:;(){}]/\n  }\n  Prism.languages.inform7['string'].inside['substitution'].inside.rest =\n    Prism.languages.inform7 // We don't want the remaining text in the substitution to be highlighted as the string.\n  Prism.languages.inform7['string'].inside['substitution'].inside.rest.text = {\n    pattern: /\\S(?:\\s*\\S)*/,\n    alias: 'comment'\n  }\n}\n"],"names":["inform7"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,cAAiBA;AACjB,EAAAA,SAAQ,cAAc;AACtB,EAAAA,SAAQ,UAAU,CAAA;AAClB,WAASA,SAAQ,OAAO;AACtB,UAAM,UAAU,UAAU;AAAA,MACxB,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,cAAc;AAAA,YACZ,SAAS;AAAA,YACT,QAAQ;AAAA,cACN,WAAW;AAAA,gBACT,SAAS;AAAA,gBACT,OAAO;AAAA;;;;;;MAMjB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,MAAM;AAAA,QACJ,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,MAAM;AAAA,QACJ,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,aAAa;AAAA;AAEf,UAAM,UAAU,QAAQ,QAAQ,EAAE,OAAO,cAAc,EAAE,OAAO,OAC9D,MAAM,UAAU;AAClB,UAAM,UAAU,QAAQ,QAAQ,EAAE,OAAO,cAAc,EAAE,OAAO,KAAK,OAAO;AAAA,MAC1E,SAAS;AAAA,MACT,OAAO;AAAA;EAEX;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/ini-DuHoOm8Y.js

@@ -0,0 +1,82 @@
+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 ini_1;
+var hasRequiredIni;
+function requireIni() {
+  if (hasRequiredIni) return ini_1;
+  hasRequiredIni = 1;
+  ini_1 = ini2;
+  ini2.displayName = "ini";
+  ini2.aliases = [];
+  function ini2(Prism) {
+    Prism.languages.ini = {
+      /**
+       * The component mimics the behavior of the Win32 API parser.
+       *
+       * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
+       */
+      comment: {
+        pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m,
+        lookbehind: true
+      },
+      section: {
+        pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m,
+        lookbehind: true,
+        inside: {
+          "section-name": {
+            pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/,
+            lookbehind: true,
+            alias: "selector"
+          },
+          punctuation: /\[|\]/
+        }
+      },
+      key: {
+        pattern: /(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m,
+        lookbehind: true,
+        alias: "attr-name"
+      },
+      value: {
+        pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/,
+        lookbehind: true,
+        alias: "attr-value",
+        inside: {
+          "inner-value": {
+            pattern: /^("|').+(?=\1$)/,
+            lookbehind: true
+          }
+        }
+      },
+      punctuation: /=/
+    };
+  }
+  return ini_1;
+}
+var iniExports = requireIni();
+const ini = /* @__PURE__ */ getDefaultExportFromCjs(iniExports);
+const ini$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: ini
+}, [iniExports]);
+export {
+  ini$1 as i
+};
+//# sourceMappingURL=ini-DuHoOm8Y.js.map

package/dist/ini-DuHoOm8Y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ini-DuHoOm8Y.js","sources":["../node_modules/refractor/lang/ini.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ini\nini.displayName = 'ini'\nini.aliases = []\nfunction ini(Prism) {\n  Prism.languages.ini = {\n    /**\n     * The component mimics the behavior of the Win32 API parser.\n     *\n     * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}\n     */\n    comment: {\n      pattern: /(^[ \\f\\t\\v]*)[#;][^\\n\\r]*/m,\n      lookbehind: true\n    },\n    section: {\n      pattern: /(^[ \\f\\t\\v]*)\\[[^\\n\\r\\]]*\\]?/m,\n      lookbehind: true,\n      inside: {\n        'section-name': {\n          pattern: /(^\\[[ \\f\\t\\v]*)[^ \\f\\t\\v\\]]+(?:[ \\f\\t\\v]+[^ \\f\\t\\v\\]]+)*/,\n          lookbehind: true,\n          alias: 'selector'\n        },\n        punctuation: /\\[|\\]/\n      }\n    },\n    key: {\n      pattern:\n        /(^[ \\f\\t\\v]*)[^ \\f\\n\\r\\t\\v=]+(?:[ \\f\\t\\v]+[^ \\f\\n\\r\\t\\v=]+)*(?=[ \\f\\t\\v]*=)/m,\n      lookbehind: true,\n      alias: 'attr-name'\n    },\n    value: {\n      pattern: /(=[ \\f\\t\\v]*)[^ \\f\\n\\r\\t\\v]+(?:[ \\f\\t\\v]+[^ \\f\\n\\r\\t\\v]+)*/,\n      lookbehind: true,\n      alias: 'attr-value',\n      inside: {\n        'inner-value': {\n          pattern: /^(\"|').+(?=\\1$)/,\n          lookbehind: true\n        }\n      }\n    },\n    punctuation: /=/\n  }\n}\n"],"names":["ini"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAMpB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,gBAAgB;AAAA,YACd,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,OAAO;AAAA;UAET,aAAa;AAAA;;MAGjB,KAAK;AAAA,QACH,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS;AAAA,YACT,YAAY;AAAA;;;MAIlB,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/io-BH3DxprO.js

@@ -0,0 +1,64 @@
+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 io_1;
+var hasRequiredIo;
+function requireIo() {
+  if (hasRequiredIo) return io_1;
+  hasRequiredIo = 1;
+  io_1 = io2;
+  io2.displayName = "io";
+  io2.aliases = [];
+  function io2(Prism) {
+    Prism.languages.io = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*|#.*)/,
+        lookbehind: true,
+        greedy: true
+      },
+      "triple-quoted-string": {
+        pattern: /"""(?:\\[\s\S]|(?!""")[^\\])*"""/,
+        greedy: true,
+        alias: "string"
+      },
+      string: {
+        pattern: /"(?:\\.|[^\\\r\n"])*"/,
+        greedy: true
+      },
+      keyword: /\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\b/,
+      builtin: /\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\b/,
+      boolean: /\b(?:false|nil|true)\b/,
+      number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?/i,
+      operator: /[=!*/%+\-^&|]=|>>?=?|<<?=?|:?:?=|\+\+?|--?|\*\*?|\/\/?|%|\|\|?|&&?|\b(?:and|not|or|return)\b|@@?|\?\??|\.\./,
+      punctuation: /[{}[\];(),.:]/
+    };
+  }
+  return io_1;
+}
+var ioExports = requireIo();
+const io = /* @__PURE__ */ getDefaultExportFromCjs(ioExports);
+const io$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: io
+}, [ioExports]);
+export {
+  io$1 as i
+};
+//# sourceMappingURL=io-BH3DxprO.js.map

package/dist/io-BH3DxprO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"io-BH3DxprO.js","sources":["../node_modules/refractor/lang/io.js"],"sourcesContent":["'use strict'\n\nmodule.exports = io\nio.displayName = 'io'\nio.aliases = []\nfunction io(Prism) {\n  Prism.languages.io = {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?(?:\\*\\/|$)|\\/\\/.*|#.*)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'triple-quoted-string': {\n      pattern: /\"\"\"(?:\\\\[\\s\\S]|(?!\"\"\")[^\\\\])*\"\"\"/,\n      greedy: true,\n      alias: 'string'\n    },\n    string: {\n      pattern: /\"(?:\\\\.|[^\\\\\\r\\n\"])*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:activate|activeCoroCount|asString|block|break|call|catch|clone|collectGarbage|compileString|continue|do|doFile|doMessage|doString|else|elseif|exit|for|foreach|forward|getEnvironmentVariable|getSlot|hasSlot|if|ifFalse|ifNil|ifNilEval|ifTrue|isActive|isNil|isResumable|list|message|method|parent|pass|pause|perform|performWithArgList|print|println|proto|raise|raiseResumable|removeSlot|resend|resume|schedulerSleepSeconds|self|sender|setSchedulerSleepSeconds|setSlot|shallowCopy|slotNames|super|system|then|thisBlock|thisContext|try|type|uniqueId|updateSlot|wait|while|write|yield)\\b/,\n    builtin:\n      /\\b(?:Array|AudioDevice|AudioMixer|BigNum|Block|Box|Buffer|CFunction|CGI|Color|Curses|DBM|DNSResolver|DOConnection|DOProxy|DOServer|Date|Directory|Duration|DynLib|Error|Exception|FFT|File|Fnmatch|Font|Future|GL|GLE|GLScissor|GLU|GLUCylinder|GLUQuadric|GLUSphere|GLUT|Host|Image|Importer|LinkList|List|Lobby|Locals|MD5|MP3Decoder|MP3Encoder|Map|Message|Movie|Notification|Number|Object|OpenGL|Point|Protos|Random|Regex|SGML|SGMLElement|SGMLParser|SQLite|Sequence|Server|ShowMessage|SleepyCat|SleepyCatCursor|Socket|SocketManager|Sound|Soup|Store|String|Tree|UDPSender|UPDReceiver|URL|User|Warning|WeakLink)\\b/,\n    boolean: /\\b(?:false|nil|true)\\b/,\n    number: /\\b0x[\\da-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e-?\\d+)?/i,\n    operator:\n      /[=!*/%+\\-^&|]=|>>?=?|<<?=?|:?:?=|\\+\\+?|--?|\\*\\*?|\\/\\/?|%|\\|\\|?|&&?|\\b(?:and|not|or|return)\\b|@@?|\\?\\??|\\.\\./,\n    punctuation: /[{}[\\];(),.:]/\n  }\n}\n"],"names":["io"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAiBA;AACjB,EAAAA,IAAG,cAAc;AACjB,EAAAA,IAAG,UAAU,CAAA;AACb,WAASA,IAAG,OAAO;AACjB,UAAM,UAAU,KAAK;AAAA,MACnB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,wBAAwB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;MAET,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,SACE;AAAA,MACF,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/j-DbaWHNVB.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 j_1;
+var hasRequiredJ;
+function requireJ() {
+  if (hasRequiredJ) return j_1;
+  hasRequiredJ = 1;
+  j_1 = j2;
+  j2.displayName = "j";
+  j2.aliases = [];
+  function j2(Prism) {
+    Prism.languages.j = {
+      comment: {
+        pattern: /\bNB\..*/,
+        greedy: true
+      },
+      string: {
+        pattern: /'(?:''|[^'\r\n])*'/,
+        greedy: true
+      },
+      keyword: /\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\w+|goto_\w+|if|label_\w+|return|select|throw|try|while|whilst)\.)/,
+      verb: {
+        // Negative look-ahead prevents bad highlighting
+        // of ^: ;. =. =: !. !:
+        pattern: /(?!\^:|;\.|[=!][.:])(?:\{(?:\.|::?)?|p(?:\.\.?|:)|[=!\]]|[<>+*\-%$|,#][.:]?|[?^]\.?|[;\[]:?|[~}"i][.:]|[ACeEIjLor]\.|(?:[_\/\\qsux]|_?\d):)/,
+        alias: "keyword"
+      },
+      number: /\b_?(?:(?!\d:)\d+(?:\.\d+)?(?:(?:ad|ar|[ejpx])_?\d+(?:\.\d+)?)*(?:b_?[\da-z]+(?:\.[\da-z]+)?)?|_\b(?!\.))/,
+      adverb: {
+        pattern: /[~}]|[\/\\]\.?|[bfM]\.|t[.:]/,
+        alias: "builtin"
+      },
+      operator: /[=a][.:]|_\./,
+      conjunction: {
+        pattern: /&(?:\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\.|`:?|[\^LS]:|"/,
+        alias: "variable"
+      },
+      punctuation: /[()]/
+    };
+  }
+  return j_1;
+}
+var jExports = requireJ();
+const j = /* @__PURE__ */ getDefaultExportFromCjs(jExports);
+const j$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: j
+}, [jExports]);
+export {
+  j$1 as j
+};
+//# sourceMappingURL=j-DbaWHNVB.js.map

package/dist/j-DbaWHNVB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"j-DbaWHNVB.js","sources":["../node_modules/refractor/lang/j.js"],"sourcesContent":["'use strict'\n\nmodule.exports = j\nj.displayName = 'j'\nj.aliases = []\nfunction j(Prism) {\n  Prism.languages.j = {\n    comment: {\n      pattern: /\\bNB\\..*/,\n      greedy: true\n    },\n    string: {\n      pattern: /'(?:''|[^'\\r\\n])*'/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\\w+|goto_\\w+|if|label_\\w+|return|select|throw|try|while|whilst)\\.)/,\n    verb: {\n      // Negative look-ahead prevents bad highlighting\n      // of ^: ;. =. =: !. !:\n      pattern:\n        /(?!\\^:|;\\.|[=!][.:])(?:\\{(?:\\.|::?)?|p(?:\\.\\.?|:)|[=!\\]]|[<>+*\\-%$|,#][.:]?|[?^]\\.?|[;\\[]:?|[~}\"i][.:]|[ACeEIjLor]\\.|(?:[_\\/\\\\qsux]|_?\\d):)/,\n      alias: 'keyword'\n    },\n    number:\n      /\\b_?(?:(?!\\d:)\\d+(?:\\.\\d+)?(?:(?:ad|ar|[ejpx])_?\\d+(?:\\.\\d+)?)*(?:b_?[\\da-z]+(?:\\.[\\da-z]+)?)?|_\\b(?!\\.))/,\n    adverb: {\n      pattern: /[~}]|[\\/\\\\]\\.?|[bfM]\\.|t[.:]/,\n      alias: 'builtin'\n    },\n    operator: /[=a][.:]|_\\./,\n    conjunction: {\n      pattern: /&(?:\\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\\.|`:?|[\\^LS]:|\"/,\n      alias: 'variable'\n    },\n    punctuation: /[()]/\n  }\n}\n"],"names":["j"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,QAAiBA;AACjB,EAAAA,GAAE,cAAc;AAChB,EAAAA,GAAE,UAAU,CAAA;AACZ,WAASA,GAAE,OAAO;AAChB,UAAM,UAAU,IAAI;AAAA,MAClB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,MAAM;AAAA;AAAA;AAAA,QAGJ,SACE;AAAA,QACF,OAAO;AAAA;MAET,QACE;AAAA,MACF,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,MACV,aAAa;AAAA,QACX,SAAS;AAAA,QACT,OAAO;AAAA;MAET,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/java-5aEEoeSl.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireJava } from "./java-M3oaxAC_.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 javaExports = requireJava();
+const java = /* @__PURE__ */ getDefaultExportFromCjs(javaExports);
+const java$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: java
+}, [javaExports]);
+export {
+  java$1 as j
+};
+//# sourceMappingURL=java-5aEEoeSl.js.map

package/dist/java-5aEEoeSl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"java-5aEEoeSl.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/java-M3oaxAC_.js

@@ -0,0 +1,107 @@
+var java_1;
+var hasRequiredJava;
+function requireJava() {
+  if (hasRequiredJava) return java_1;
+  hasRequiredJava = 1;
+  java_1 = java;
+  java.displayName = "java";
+  java.aliases = [];
+  function java(Prism) {
+    (function(Prism2) {
+      var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
+      var classNamePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
+      var className = {
+        pattern: RegExp(classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+        lookbehind: true,
+        inside: {
+          namespace: {
+            pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          punctuation: /\./
+        }
+      };
+      Prism2.languages.java = Prism2.languages.extend("clike", {
+        string: {
+          pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+          lookbehind: true,
+          greedy: true
+        },
+        "class-name": [
+          className,
+          {
+            // variables and parameters
+            // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+            pattern: RegExp(
+              classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+            ),
+            lookbehind: true,
+            inside: className.inside
+          }
+        ],
+        keyword: keywords,
+        function: [
+          Prism2.languages.clike.function,
+          {
+            pattern: /(::\s*)[a-z_]\w*/,
+            lookbehind: true
+          }
+        ],
+        number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+        operator: {
+          pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+          lookbehind: true
+        }
+      });
+      Prism2.languages.insertBefore("java", "string", {
+        "triple-quoted-string": {
+          // http://openjdk.java.net/jeps/355#Description
+          pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+          greedy: true,
+          alias: "string"
+        },
+        char: {
+          pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+          greedy: true
+        }
+      });
+      Prism2.languages.insertBefore("java", "class-name", {
+        annotation: {
+          pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        generics: {
+          pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+          inside: {
+            "class-name": className,
+            keyword: keywords,
+            punctuation: /[<>(),.:]/,
+            operator: /[?&|]/
+          }
+        },
+        namespace: {
+          pattern: RegExp(
+            /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(
+              /<keyword>/g,
+              function() {
+                return keywords.source;
+              }
+            )
+          ),
+          lookbehind: true,
+          inside: {
+            punctuation: /\./
+          }
+        }
+      });
+    })(Prism);
+  }
+  return java_1;
+}
+export {
+  requireJava as r
+};
+//# sourceMappingURL=java-M3oaxAC_.js.map

package/dist/java-M3oaxAC_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"java-M3oaxAC_.js","sources":["../node_modules/refractor/lang/java.js"],"sourcesContent":["'use strict'\n\nmodule.exports = java\njava.displayName = 'java'\njava.aliases = []\nfunction java(Prism) {\n  ;(function (Prism) {\n    var keywords =\n      /\\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\\b/ // full package (optional) + parent classes (optional)\n    var classNamePrefix = /(^|[^\\w.])(?:[a-z]\\w*\\s*\\.\\s*)*(?:[A-Z]\\w*\\s*\\.\\s*)*/\n      .source // based on the java naming conventions\n    var className = {\n      pattern: RegExp(classNamePrefix + /[A-Z](?:[\\d_A-Z]*[a-z]\\w*)?\\b/.source),\n      lookbehind: true,\n      inside: {\n        namespace: {\n          pattern: /^[a-z]\\w*(?:\\s*\\.\\s*[a-z]\\w*)*(?:\\s*\\.)?/,\n          inside: {\n            punctuation: /\\./\n          }\n        },\n        punctuation: /\\./\n      }\n    }\n    Prism.languages.java = Prism.languages.extend('clike', {\n      string: {\n        pattern: /(^|[^\\\\])\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n        lookbehind: true,\n        greedy: true\n      },\n      'class-name': [\n        className,\n        {\n          // variables and parameters\n          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)\n          pattern: RegExp(\n            classNamePrefix + /[A-Z]\\w*(?=\\s+\\w+\\s*[;,=()])/.source\n          ),\n          lookbehind: true,\n          inside: className.inside\n        }\n      ],\n      keyword: keywords,\n      function: [\n        Prism.languages.clike.function,\n        {\n          pattern: /(::\\s*)[a-z_]\\w*/,\n          lookbehind: true\n        }\n      ],\n      number:\n        /\\b0b[01][01_]*L?\\b|\\b0x(?:\\.[\\da-f_p+-]+|[\\da-f_]+(?:\\.[\\da-f_p+-]+)?)\\b|(?:\\b\\d[\\d_]*(?:\\.[\\d_]*)?|\\B\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[dfl]?/i,\n      operator: {\n        pattern:\n          /(^|[^.])(?:<<=?|>>>?=?|->|--|\\+\\+|&&|\\|\\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,\n        lookbehind: true\n      }\n    })\n    Prism.languages.insertBefore('java', 'string', {\n      'triple-quoted-string': {\n        // http://openjdk.java.net/jeps/355#Description\n        pattern: /\"\"\"[ \\t]*[\\r\\n](?:(?:\"|\"\")?(?:\\\\.|[^\"\\\\]))*\"\"\"/,\n        greedy: true,\n        alias: 'string'\n      },\n      char: {\n        pattern: /'(?:\\\\.|[^'\\\\\\r\\n]){1,6}'/,\n        greedy: true\n      }\n    })\n    Prism.languages.insertBefore('java', 'class-name', {\n      annotation: {\n        pattern: /(^|[^.])@\\w+(?:\\s*\\.\\s*\\w+)*/,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      generics: {\n        pattern:\n          /<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&)|<(?:[\\w\\s,.?]|&(?!&))*>)*>)*>)*>/,\n        inside: {\n          'class-name': className,\n          keyword: keywords,\n          punctuation: /[<>(),.:]/,\n          operator: /[?&|]/\n        }\n      },\n      namespace: {\n        pattern: RegExp(\n          /(\\b(?:exports|import(?:\\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\\s+)(?!<keyword>)[a-z]\\w*(?:\\.[a-z]\\w*)*\\.?/.source.replace(\n            /<keyword>/g,\n            function () {\n              return keywords.source\n            }\n          )\n        ),\n        lookbehind: true,\n        inside: {\n          punctuation: /\\./\n        }\n      }\n    })\n  })(Prism)\n}\n"],"names":["Prism"],"mappings":";;;;;AAEA,WAAiB;AACjB,OAAK,cAAc;AACnB,OAAK,UAAU,CAAA;AACf,WAAS,KAAK,OAAO;AAClB,KAAC,SAAUA,QAAO;AACjB,UAAI,WACF;AACF,UAAI,kBAAkB,uDACnB;AACH,UAAI,YAAY;AAAA,QACd,SAAS,OAAO,kBAAkB,gCAAgC,MAAM;AAAA,QACxE,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,WAAW;AAAA,YACT,SAAS;AAAA,YACT,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB,aAAa;AAAA;;AAGjB,MAAAA,OAAM,UAAU,OAAOA,OAAM,UAAU,OAAO,SAAS;AAAA,QACrD,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,cAAc;AAAA,UACZ;AAAA,UACA;AAAA;AAAA;AAAA,YAGE,SAAS;AAAA,cACP,kBAAkB,+BAA+B;AAAA;YAEnD,YAAY;AAAA,YACZ,QAAQ,UAAU;AAAA;;QAGtB,SAAS;AAAA,QACT,UAAU;AAAA,UACRA,OAAM,UAAU,MAAM;AAAA,UACtB;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;;QAGhB,QACE;AAAA,QACF,UAAU;AAAA,UACR,SACE;AAAA,UACF,YAAY;AAAA;MAEpB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,QAAQ,UAAU;AAAA,QAC7C,wBAAwB;AAAA;AAAA,UAEtB,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,MAAM;AAAA,UACJ,SAAS;AAAA,UACT,QAAQ;AAAA;MAEhB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,QAAQ,cAAc;AAAA,QACjD,YAAY;AAAA,UACV,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SACE;AAAA,UACF,QAAQ;AAAA,YACN,cAAc;AAAA,YACd,SAAS;AAAA,YACT,aAAa;AAAA,YACb,UAAU;AAAA;;QAGd,WAAW;AAAA,UACT,SAAS;AAAA,YACP,qJAAqJ,OAAO;AAAA,cAC1J;AAAA,cACA,WAAY;AACV,uBAAO,SAAS;AAAA,cAC9B;AAAA;;UAGQ,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA;;MAGvB,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;","x_google_ignoreList":[0]}

package/dist/javadoc-D2aGgPp2.js

@@ -0,0 +1,133 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireJava } from "./java-M3oaxAC_.js";
+import { r as requireJavadoclike } from "./javadoclike-BdPr_VnG.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 javadoc_1;
+var hasRequiredJavadoc;
+function requireJavadoc() {
+  if (hasRequiredJavadoc) return javadoc_1;
+  hasRequiredJavadoc = 1;
+  var refractorJava = requireJava();
+  var refractorJavadoclike = requireJavadoclike();
+  javadoc_1 = javadoc2;
+  javadoc2.displayName = "javadoc";
+  javadoc2.aliases = [];
+  function javadoc2(Prism) {
+    Prism.register(refractorJava);
+    Prism.register(refractorJavadoclike);
+    (function(Prism2) {
+      var codeLinePattern = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m;
+      var memberReference = /#\s*\w+(?:\s*\([^()]*\))?/.source;
+      var reference = /(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*<mem>)?|<mem>/.source.replace(
+        /<mem>/g,
+        function() {
+          return memberReference;
+        }
+      );
+      Prism2.languages.javadoc = Prism2.languages.extend("javadoclike", {});
+      Prism2.languages.insertBefore("javadoc", "keyword", {
+        reference: {
+          pattern: RegExp(
+            /(@(?:exception|link|linkplain|see|throws|value)\s+(?:\*\s*)?)/.source + "(?:" + reference + ")"
+          ),
+          lookbehind: true,
+          inside: {
+            function: {
+              pattern: /(#\s*)\w+(?=\s*\()/,
+              lookbehind: true
+            },
+            field: {
+              pattern: /(#\s*)\w+/,
+              lookbehind: true
+            },
+            namespace: {
+              pattern: /\b(?:[a-z]\w*\s*\.\s*)+/,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            "class-name": /\b[A-Z]\w*/,
+            keyword: Prism2.languages.java.keyword,
+            punctuation: /[#()[\],.]/
+          }
+        },
+        "class-name": {
+          // @param <T> the first generic type parameter
+          pattern: /(@param\s+)<[A-Z]\w*>/,
+          lookbehind: true,
+          inside: {
+            punctuation: /[.<>]/
+          }
+        },
+        "code-section": [
+          {
+            pattern: /(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,
+            lookbehind: true,
+            inside: {
+              code: {
+                // there can't be any HTML inside of {@code} tags
+                pattern: codeLinePattern,
+                lookbehind: true,
+                inside: Prism2.languages.java,
+                alias: "language-java"
+              }
+            }
+          },
+          {
+            pattern: /(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,
+            lookbehind: true,
+            inside: {
+              line: {
+                pattern: codeLinePattern,
+                lookbehind: true,
+                inside: {
+                  // highlight HTML tags and entities
+                  tag: Prism2.languages.markup.tag,
+                  entity: Prism2.languages.markup.entity,
+                  code: {
+                    // everything else is Java code
+                    pattern: /.+/,
+                    inside: Prism2.languages.java,
+                    alias: "language-java"
+                  }
+                }
+              }
+            }
+          }
+        ],
+        tag: Prism2.languages.markup.tag,
+        entity: Prism2.languages.markup.entity
+      });
+      Prism2.languages.javadoclike.addSupport("java", Prism2.languages.javadoc);
+    })(Prism);
+  }
+  return javadoc_1;
+}
+var javadocExports = requireJavadoc();
+const javadoc = /* @__PURE__ */ getDefaultExportFromCjs(javadocExports);
+const javadoc$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: javadoc
+}, [javadocExports]);
+export {
+  javadoc$1 as j
+};
+//# sourceMappingURL=javadoc-D2aGgPp2.js.map

package/dist/javadoc-D2aGgPp2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"javadoc-D2aGgPp2.js","sources":["../node_modules/refractor/lang/javadoc.js"],"sourcesContent":["'use strict'\nvar refractorJava = require('./java.js')\nvar refractorJavadoclike = require('./javadoclike.js')\nmodule.exports = javadoc\njavadoc.displayName = 'javadoc'\njavadoc.aliases = []\nfunction javadoc(Prism) {\n  Prism.register(refractorJava)\n  Prism.register(refractorJavadoclike)\n  ;(function (Prism) {\n    var codeLinePattern = /(^(?:[\\t ]*(?:\\*\\s*)*))[^*\\s].*$/m\n    var memberReference = /#\\s*\\w+(?:\\s*\\([^()]*\\))?/.source\n    var reference =\n      /(?:\\b[a-zA-Z]\\w+\\s*\\.\\s*)*\\b[A-Z]\\w*(?:\\s*<mem>)?|<mem>/.source.replace(\n        /<mem>/g,\n        function () {\n          return memberReference\n        }\n      )\n    Prism.languages.javadoc = Prism.languages.extend('javadoclike', {})\n    Prism.languages.insertBefore('javadoc', 'keyword', {\n      reference: {\n        pattern: RegExp(\n          /(@(?:exception|link|linkplain|see|throws|value)\\s+(?:\\*\\s*)?)/\n            .source +\n            '(?:' +\n            reference +\n            ')'\n        ),\n        lookbehind: true,\n        inside: {\n          function: {\n            pattern: /(#\\s*)\\w+(?=\\s*\\()/,\n            lookbehind: true\n          },\n          field: {\n            pattern: /(#\\s*)\\w+/,\n            lookbehind: true\n          },\n          namespace: {\n            pattern: /\\b(?:[a-z]\\w*\\s*\\.\\s*)+/,\n            inside: {\n              punctuation: /\\./\n            }\n          },\n          'class-name': /\\b[A-Z]\\w*/,\n          keyword: Prism.languages.java.keyword,\n          punctuation: /[#()[\\],.]/\n        }\n      },\n      'class-name': {\n        // @param <T> the first generic type parameter\n        pattern: /(@param\\s+)<[A-Z]\\w*>/,\n        lookbehind: true,\n        inside: {\n          punctuation: /[.<>]/\n        }\n      },\n      'code-section': [\n        {\n          pattern:\n            /(\\{@code\\s+(?!\\s))(?:[^\\s{}]|\\s+(?![\\s}])|\\{(?:[^{}]|\\{(?:[^{}]|\\{(?:[^{}]|\\{[^{}]*\\})*\\})*\\})*\\})+(?=\\s*\\})/,\n          lookbehind: true,\n          inside: {\n            code: {\n              // there can't be any HTML inside of {@code} tags\n              pattern: codeLinePattern,\n              lookbehind: true,\n              inside: Prism.languages.java,\n              alias: 'language-java'\n            }\n          }\n        },\n        {\n          pattern:\n            /(<(code|pre|tt)>(?!<code>)\\s*)\\S(?:\\S|\\s+\\S)*?(?=\\s*<\\/\\2>)/,\n          lookbehind: true,\n          inside: {\n            line: {\n              pattern: codeLinePattern,\n              lookbehind: true,\n              inside: {\n                // highlight HTML tags and entities\n                tag: Prism.languages.markup.tag,\n                entity: Prism.languages.markup.entity,\n                code: {\n                  // everything else is Java code\n                  pattern: /.+/,\n                  inside: Prism.languages.java,\n                  alias: 'language-java'\n                }\n              }\n            }\n          }\n        }\n      ],\n      tag: Prism.languages.markup.tag,\n      entity: Prism.languages.markup.entity\n    })\n    Prism.languages.javadoclike.addSupport('java', Prism.languages.javadoc)\n  })(Prism)\n}\n"],"names":["require$$0","require$$1","javadoc","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,gBAAgBA,YAAA;AACpB,MAAI,uBAAuBC,mBAAA;AAC3B,cAAiBC;AACjB,EAAAA,SAAQ,cAAc;AACtB,EAAAA,SAAQ,UAAU,CAAA;AAClB,WAASA,SAAQ,OAAO;AACtB,UAAM,SAAS,aAAa;AAC5B,UAAM,SAAS,oBAAoB;AAClC,KAAC,SAAUC,QAAO;AACjB,UAAI,kBAAkB;AACtB,UAAI,kBAAkB,4BAA4B;AAClD,UAAI,YACF,0DAA0D,OAAO;AAAA,QAC/D;AAAA,QACA,WAAY;AACV,iBAAO;AAAA,QACjB;AAAA;AAEI,MAAAA,OAAM,UAAU,UAAUA,OAAM,UAAU,OAAO,eAAe,CAAA,CAAE;AAClE,MAAAA,OAAM,UAAU,aAAa,WAAW,WAAW;AAAA,QACjD,WAAW;AAAA,UACT,SAAS;AAAA,YACP,gEACG,SACD,QACA,YACA;AAAA;UAEJ,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,UAAU;AAAA,cACR,SAAS;AAAA,cACT,YAAY;AAAA;YAEd,OAAO;AAAA,cACL,SAAS;AAAA,cACT,YAAY;AAAA;YAEd,WAAW;AAAA,cACT,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,aAAa;AAAA;;YAGjB,cAAc;AAAA,YACd,SAASA,OAAM,UAAU,KAAK;AAAA,YAC9B,aAAa;AAAA;;QAGjB,cAAc;AAAA;AAAA,UAEZ,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,gBAAgB;AAAA,UACd;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,MAAM;AAAA;AAAA,gBAEJ,SAAS;AAAA,gBACT,YAAY;AAAA,gBACZ,QAAQA,OAAM,UAAU;AAAA,gBACxB,OAAO;AAAA;;;UAIb;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,MAAM;AAAA,gBACJ,SAAS;AAAA,gBACT,YAAY;AAAA,gBACZ,QAAQ;AAAA;AAAA,kBAEN,KAAKA,OAAM,UAAU,OAAO;AAAA,kBAC5B,QAAQA,OAAM,UAAU,OAAO;AAAA,kBAC/B,MAAM;AAAA;AAAA,oBAEJ,SAAS;AAAA,oBACT,QAAQA,OAAM,UAAU;AAAA,oBACxB,OAAO;AAAA;;;;;;QAOnB,KAAKA,OAAM,UAAU,OAAO;AAAA,QAC5B,QAAQA,OAAM,UAAU,OAAO;AAAA,MACrC,CAAK;AACD,MAAAA,OAAM,UAAU,YAAY,WAAW,QAAQA,OAAM,UAAU,OAAO;AAAA,IAC1E,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}