@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/inform7-YsL-LiaC.js

@@ -0,0 +1,90 @@
+import { g } from "./index-Sj89RFCY.js";
+function d(e, n) {
+  for (var r = 0; r < n.length; r++) {
+    const i = n[r];
+    if (typeof i != "string" && !Array.isArray(i)) {
+      for (const t in i)
+        if (t !== "default" && !(t in e)) {
+          const o = Object.getOwnPropertyDescriptor(i, t);
+          o && Object.defineProperty(e, t, o.get ? o : {
+            enumerable: !0,
+            get: () => i[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var s, a;
+function u() {
+  if (a) return s;
+  a = 1, s = e, e.displayName = "inform7", e.aliases = [];
+  function e(n) {
+    n.languages.inform7 = {
+      string: {
+        pattern: /"[^"]*"/,
+        inside: {
+          substitution: {
+            pattern: /\[[^\[\]]+\]/,
+            inside: {
+              delimiter: {
+                pattern: /\[|\]/,
+                alias: "punctuation"
+              }
+              // See rest below
+            }
+          }
+        }
+      },
+      comment: {
+        pattern: /\[[^\[\]]+\]/,
+        greedy: !0
+      },
+      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: !0
+      },
+      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: !0,
+        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: !0
+      },
+      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: !0,
+        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: !0,
+        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: !0,
+        alias: "variable"
+      },
+      punctuation: /[.,:;(){}]/
+    }, n.languages.inform7.string.inside.substitution.inside.rest = n.languages.inform7, n.languages.inform7.string.inside.substitution.inside.rest.text = {
+      pattern: /\S(?:\s*\S)*/,
+      alias: "comment"
+    };
+  }
+  return s;
+}
+var l = u();
+const p = /* @__PURE__ */ g(l), b = /* @__PURE__ */ d({
+  __proto__: null,
+  default: p
+}, [l]);
+export {
+  b as i
+};

package/dist/ini-ChNiYeuM.js

@@ -0,0 +1,73 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function l(t, r) {
+  for (var i = 0; i < r.length; i++) {
+    const e = r[i];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const n in e)
+        if (n !== "default" && !(n in t)) {
+          const a = Object.getOwnPropertyDescriptor(e, n);
+          a && Object.defineProperty(t, n, a.get ? a : {
+            enumerable: !0,
+            get: () => e[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, f;
+function v() {
+  if (f) return o;
+  f = 1, o = t, t.displayName = "ini", t.aliases = [];
+  function t(r) {
+    r.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: !0
+      },
+      section: {
+        pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m,
+        lookbehind: !0,
+        inside: {
+          "section-name": {
+            pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/,
+            lookbehind: !0,
+            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: !0,
+        alias: "attr-name"
+      },
+      value: {
+        pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/,
+        lookbehind: !0,
+        alias: "attr-value",
+        inside: {
+          "inner-value": {
+            pattern: /^("|').+(?=\1$)/,
+            lookbehind: !0
+          }
+        }
+      },
+      punctuation: /=/
+    };
+  }
+  return o;
+}
+var u = v();
+const c = /* @__PURE__ */ s(u), d = /* @__PURE__ */ l({
+  __proto__: null,
+  default: c
+}, [u]);
+export {
+  d as i
+};

package/dist/io-BzLClKN_.js

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

package/dist/j-BuLAn7Gf.js

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

package/dist/java-3PJ6FLyt.js

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

package/dist/java-DYIb7l3j.js

@@ -0,0 +1,98 @@
+var r, i;
+function u() {
+  if (i) return r;
+  i = 1, r = a, a.displayName = "java", a.aliases = [];
+  function a(o) {
+    (function(e) {
+      var t = /\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/, s = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, n = {
+        pattern: RegExp(s + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+        lookbehind: !0,
+        inside: {
+          namespace: {
+            pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+            inside: {
+              punctuation: /\./
+            }
+          },
+          punctuation: /\./
+        }
+      };
+      e.languages.java = e.languages.extend("clike", {
+        string: {
+          pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        "class-name": [
+          n,
+          {
+            // 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(
+              s + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+            ),
+            lookbehind: !0,
+            inside: n.inside
+          }
+        ],
+        keyword: t,
+        function: [
+          e.languages.clike.function,
+          {
+            pattern: /(::\s*)[a-z_]\w*/,
+            lookbehind: !0
+          }
+        ],
+        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: !0
+        }
+      }), e.languages.insertBefore("java", "string", {
+        "triple-quoted-string": {
+          // http://openjdk.java.net/jeps/355#Description
+          pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+          greedy: !0,
+          alias: "string"
+        },
+        char: {
+          pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+          greedy: !0
+        }
+      }), e.languages.insertBefore("java", "class-name", {
+        annotation: {
+          pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        generics: {
+          pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+          inside: {
+            "class-name": n,
+            keyword: t,
+            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 t.source;
+              }
+            )
+          ),
+          lookbehind: !0,
+          inside: {
+            punctuation: /\./
+          }
+        }
+      });
+    })(o);
+  }
+  return r;
+}
+export {
+  u as r
+};

package/dist/javadoc-BnSaiIyg.js

@@ -0,0 +1,118 @@
+import { g as l } from "./index-Sj89RFCY.js";
+import { r as g } from "./java-DYIb7l3j.js";
+import { r as p } from "./javadoclike-CHbTYI14.js";
+function v(n, o) {
+  for (var t = 0; t < o.length; t++) {
+    const a = o[t];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const e in a)
+        if (e !== "default" && !(e in n)) {
+          const r = Object.getOwnPropertyDescriptor(a, e);
+          r && Object.defineProperty(n, e, r.get ? r : {
+            enumerable: !0,
+            get: () => a[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var s, i;
+function f() {
+  if (i) return s;
+  i = 1;
+  var n = g(), o = p();
+  s = t, t.displayName = "javadoc", t.aliases = [];
+  function t(a) {
+    a.register(n), a.register(o), function(e) {
+      var r = /(^(?:[\t ]*(?:\*\s*)*))[^*\s].*$/m, c = /#\s*\w+(?:\s*\([^()]*\))?/.source, d = /(?:\b[a-zA-Z]\w+\s*\.\s*)*\b[A-Z]\w*(?:\s*<mem>)?|<mem>/.source.replace(
+        /<mem>/g,
+        function() {
+          return c;
+        }
+      );
+      e.languages.javadoc = e.languages.extend("javadoclike", {}), e.languages.insertBefore("javadoc", "keyword", {
+        reference: {
+          pattern: RegExp(
+            /(@(?:exception|link|linkplain|see|throws|value)\s+(?:\*\s*)?)/.source + "(?:" + d + ")"
+          ),
+          lookbehind: !0,
+          inside: {
+            function: {
+              pattern: /(#\s*)\w+(?=\s*\()/,
+              lookbehind: !0
+            },
+            field: {
+              pattern: /(#\s*)\w+/,
+              lookbehind: !0
+            },
+            namespace: {
+              pattern: /\b(?:[a-z]\w*\s*\.\s*)+/,
+              inside: {
+                punctuation: /\./
+              }
+            },
+            "class-name": /\b[A-Z]\w*/,
+            keyword: e.languages.java.keyword,
+            punctuation: /[#()[\],.]/
+          }
+        },
+        "class-name": {
+          // @param <T> the first generic type parameter
+          pattern: /(@param\s+)<[A-Z]\w*>/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[.<>]/
+          }
+        },
+        "code-section": [
+          {
+            pattern: /(\{@code\s+(?!\s))(?:[^\s{}]|\s+(?![\s}])|\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\})+(?=\s*\})/,
+            lookbehind: !0,
+            inside: {
+              code: {
+                // there can't be any HTML inside of {@code} tags
+                pattern: r,
+                lookbehind: !0,
+                inside: e.languages.java,
+                alias: "language-java"
+              }
+            }
+          },
+          {
+            pattern: /(<(code|pre|tt)>(?!<code>)\s*)\S(?:\S|\s+\S)*?(?=\s*<\/\2>)/,
+            lookbehind: !0,
+            inside: {
+              line: {
+                pattern: r,
+                lookbehind: !0,
+                inside: {
+                  // highlight HTML tags and entities
+                  tag: e.languages.markup.tag,
+                  entity: e.languages.markup.entity,
+                  code: {
+                    // everything else is Java code
+                    pattern: /.+/,
+                    inside: e.languages.java,
+                    alias: "language-java"
+                  }
+                }
+              }
+            }
+          }
+        ],
+        tag: e.languages.markup.tag,
+        entity: e.languages.markup.entity
+      }), e.languages.javadoclike.addSupport("java", e.languages.javadoc);
+    }(a);
+  }
+  return s;
+}
+var u = f();
+const j = /* @__PURE__ */ l(u), y = /* @__PURE__ */ v({
+  __proto__: null,
+  default: j
+}, [u]);
+export {
+  y as j
+};

package/dist/javadoclike-BSqXhy54.js

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

package/dist/javadoclike-CHbTYI14.js

@@ -0,0 +1,59 @@
+var p, f;
+function l() {
+  if (f) return p;
+  f = 1, p = i, i.displayName = "javadoclike", i.aliases = [];
+  function i(s) {
+    (function(c) {
+      var d = c.languages.javadoclike = {
+        parameter: {
+          pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*@(?:arg|arguments|param)\s+)\w+/m,
+          lookbehind: !0
+        },
+        keyword: {
+          // keywords are the first word in a line preceded be an `@` or surrounded by curly braces.
+          // @word, {@word}
+          pattern: /(^[\t ]*(?:\/{3}|\*|\/\*\*)\s*|\{)@[a-z][a-zA-Z-]+\b/m,
+          lookbehind: !0
+        },
+        punctuation: /[{}]/
+      };
+      function v(r, n) {
+        var t = "doc-comment", a = c.languages[r];
+        if (a) {
+          var e = a[t];
+          if (!e) {
+            var u = {};
+            u[t] = {
+              pattern: /(^|[^\\])\/\*\*[^/][\s\S]*?(?:\*\/|$)/,
+              lookbehind: !0,
+              alias: "comment"
+            }, a = c.languages.insertBefore(r, "comment", u), e = a[t];
+          }
+          if (e instanceof RegExp && (e = a[t] = {
+            pattern: e
+          }), Array.isArray(e))
+            for (var o = 0, k = e.length; o < k; o++)
+              e[o] instanceof RegExp && (e[o] = {
+                pattern: e[o]
+              }), n(e[o]);
+          else
+            n(e);
+        }
+      }
+      function m(r, n) {
+        typeof r == "string" && (r = [r]), r.forEach(function(t) {
+          v(t, function(a) {
+            a.inside || (a.inside = {}), a.inside.rest = n;
+          });
+        });
+      }
+      Object.defineProperty(d, "addSupport", {
+        value: m
+      }), d.addSupport(["java", "javascript", "php"], d);
+    })(s);
+  }
+  return p;
+}
+export {
+  l as r
+};