@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/bash-0-vitIuH.js

@@ -0,0 +1,223 @@
+var i, p;
+function u() {
+  if (p) return i;
+  p = 1, i = r, r.displayName = "bash", r.aliases = ["shell"];
+  function r(l) {
+    (function(e) {
+      var n = "\\b(?:BASH|BASHOPTS|BASH_ALIASES|BASH_ARGC|BASH_ARGV|BASH_CMDS|BASH_COMPLETION_COMPAT_DIR|BASH_LINENO|BASH_REMATCH|BASH_SOURCE|BASH_VERSINFO|BASH_VERSION|COLORTERM|COLUMNS|COMP_WORDBREAKS|DBUS_SESSION_BUS_ADDRESS|DEFAULTS_PATH|DESKTOP_SESSION|DIRSTACK|DISPLAY|EUID|GDMSESSION|GDM_LANG|GNOME_KEYRING_CONTROL|GNOME_KEYRING_PID|GPG_AGENT_INFO|GROUPS|HISTCONTROL|HISTFILE|HISTFILESIZE|HISTSIZE|HOME|HOSTNAME|HOSTTYPE|IFS|INSTANCE|JOB|LANG|LANGUAGE|LC_ADDRESS|LC_ALL|LC_IDENTIFICATION|LC_MEASUREMENT|LC_MONETARY|LC_NAME|LC_NUMERIC|LC_PAPER|LC_TELEPHONE|LC_TIME|LESSCLOSE|LESSOPEN|LINES|LOGNAME|LS_COLORS|MACHTYPE|MAILCHECK|MANDATORY_PATH|NO_AT_BRIDGE|OLDPWD|OPTERR|OPTIND|ORBIT_SOCKETDIR|OSTYPE|PAPERSIZE|PATH|PIPESTATUS|PPID|PS1|PS2|PS3|PS4|PWD|RANDOM|REPLY|SECONDS|SELINUX_INIT|SESSION|SESSIONTYPE|SESSION_MANAGER|SHELL|SHELLOPTS|SHLVL|SSH_AUTH_SOCK|TERM|UID|UPSTART_EVENTS|UPSTART_INSTANCE|UPSTART_JOB|UPSTART_SESSION|USER|WINDOWID|XAUTHORITY|XDG_CONFIG_DIRS|XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XDG_GREETER_DATA_DIR|XDG_MENU_PREFIX|XDG_RUNTIME_DIR|XDG_SEAT|XDG_SEAT_PATH|XDG_SESSION_DESKTOP|XDG_SESSION_ID|XDG_SESSION_PATH|XDG_SESSION_TYPE|XDG_VTNR|XMODIFIERS)\\b", s = {
+        pattern: /(^(["']?)\w+\2)[ \t]+\S.*/,
+        lookbehind: !0,
+        alias: "punctuation",
+        // this looks reasonably well in all themes
+        inside: null
+        // see below
+      }, t = {
+        bash: s,
+        environment: {
+          pattern: RegExp("\\$" + n),
+          alias: "constant"
+        },
+        variable: [
+          // [0]: Arithmetic Environment
+          {
+            pattern: /\$?\(\([\s\S]+?\)\)/,
+            greedy: !0,
+            inside: {
+              // If there is a $ sign at the beginning highlight $(( and )) as variable
+              variable: [
+                {
+                  pattern: /(^\$\(\([\s\S]+)\)\)/,
+                  lookbehind: !0
+                },
+                /^\$\(\(/
+              ],
+              number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+              // Operators according to https://www.gnu.org/software/bash/manual/bashref.html#Shell-Arithmetic
+              operator: /--|\+\+|\*\*=?|<<=?|>>=?|&&|\|\||[=!+\-*/%<>^&|]=?|[?~:]/,
+              // If there is no $ sign at the beginning highlight (( and )) as punctuation
+              punctuation: /\(\(?|\)\)?|,|;/
+            }
+          },
+          // [1]: Command Substitution
+          {
+            pattern: /\$\((?:\([^)]+\)|[^()])+\)|`[^`]+`/,
+            greedy: !0,
+            inside: {
+              variable: /^\$\(|^`|\)$|`$/
+            }
+          },
+          // [2]: Brace expansion
+          {
+            pattern: /\$\{[^}]+\}/,
+            greedy: !0,
+            inside: {
+              operator: /:[-=?+]?|[!\/]|##?|%%?|\^\^?|,,?/,
+              punctuation: /[\[\]]/,
+              environment: {
+                pattern: RegExp("(\\{)" + n),
+                lookbehind: !0,
+                alias: "constant"
+              }
+            }
+          },
+          /\$(?:\w+|[#?*!@$])/
+        ],
+        // Escape sequences from echo and printf's manuals, and escaped quotes.
+        entity: /\\(?:[abceEfnrtv\\"]|O?[0-7]{1,3}|U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{1,2})/
+      };
+      e.languages.bash = {
+        shebang: {
+          pattern: /^#!\s*\/.*/,
+          alias: "important"
+        },
+        comment: {
+          pattern: /(^|[^"{\\$])#.*/,
+          lookbehind: !0
+        },
+        "function-name": [
+          // a) function foo {
+          // b) foo() {
+          // c) function foo() {
+          // but not “foo {”
+          {
+            // a) and c)
+            pattern: /(\bfunction\s+)[\w-]+(?=(?:\s*\(?:\s*\))?\s*\{)/,
+            lookbehind: !0,
+            alias: "function"
+          },
+          {
+            // b)
+            pattern: /\b[\w-]+(?=\s*\(\s*\)\s*\{)/,
+            alias: "function"
+          }
+        ],
+        // Highlight variable names as variables in for and select beginnings.
+        "for-or-select": {
+          pattern: /(\b(?:for|select)\s+)\w+(?=\s+in\s)/,
+          alias: "variable",
+          lookbehind: !0
+        },
+        // Highlight variable names as variables in the left-hand part
+        // of assignments (“=” and “+=”).
+        "assign-left": {
+          pattern: /(^|[\s;|&]|[<>]\()\w+(?=\+?=)/,
+          inside: {
+            environment: {
+              pattern: RegExp("(^|[\\s;|&]|[<>]\\()" + n),
+              lookbehind: !0,
+              alias: "constant"
+            }
+          },
+          alias: "variable",
+          lookbehind: !0
+        },
+        string: [
+          // Support for Here-documents https://en.wikipedia.org/wiki/Here_document
+          {
+            pattern: /((?:^|[^<])<<-?\s*)(\w+)\s[\s\S]*?(?:\r?\n|\r)\2/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: t
+          },
+          // Here-document with quotes around the tag
+          // → No expansion (so no “inside”).
+          {
+            pattern: /((?:^|[^<])<<-?\s*)(["'])(\w+)\2\s[\s\S]*?(?:\r?\n|\r)\3/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              bash: s
+            }
+          },
+          // “Normal” string
+          {
+            // https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html
+            pattern: /(^|[^\\](?:\\\\)*)"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: t
+          },
+          {
+            // https://www.gnu.org/software/bash/manual/html_node/Single-Quotes.html
+            pattern: /(^|[^$\\])'[^']*'/,
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            // https://www.gnu.org/software/bash/manual/html_node/ANSI_002dC-Quoting.html
+            pattern: /\$'(?:[^'\\]|\\[\s\S])*'/,
+            greedy: !0,
+            inside: {
+              entity: t.entity
+            }
+          }
+        ],
+        environment: {
+          pattern: RegExp("\\$?" + n),
+          alias: "constant"
+        },
+        variable: t.variable,
+        function: {
+          pattern: /(^|[\s;|&]|[<>]\()(?:add|apropos|apt|apt-cache|apt-get|aptitude|aspell|automysqlbackup|awk|basename|bash|bc|bconsole|bg|bzip2|cal|cat|cfdisk|chgrp|chkconfig|chmod|chown|chroot|cksum|clear|cmp|column|comm|composer|cp|cron|crontab|csplit|curl|cut|date|dc|dd|ddrescue|debootstrap|df|diff|diff3|dig|dir|dircolors|dirname|dirs|dmesg|docker|docker-compose|du|egrep|eject|env|ethtool|expand|expect|expr|fdformat|fdisk|fg|fgrep|file|find|fmt|fold|format|free|fsck|ftp|fuser|gawk|git|gparted|grep|groupadd|groupdel|groupmod|groups|grub-mkconfig|gzip|halt|head|hg|history|host|hostname|htop|iconv|id|ifconfig|ifdown|ifup|import|install|ip|jobs|join|kill|killall|less|link|ln|locate|logname|logrotate|look|lpc|lpr|lprint|lprintd|lprintq|lprm|ls|lsof|lynx|make|man|mc|mdadm|mkconfig|mkdir|mke2fs|mkfifo|mkfs|mkisofs|mknod|mkswap|mmv|more|most|mount|mtools|mtr|mutt|mv|nano|nc|netstat|nice|nl|node|nohup|notify-send|npm|nslookup|op|open|parted|passwd|paste|pathchk|ping|pkill|pnpm|podman|podman-compose|popd|pr|printcap|printenv|ps|pushd|pv|quota|quotacheck|quotactl|ram|rar|rcp|reboot|remsync|rename|renice|rev|rm|rmdir|rpm|rsync|scp|screen|sdiff|sed|sendmail|seq|service|sftp|sh|shellcheck|shuf|shutdown|sleep|slocate|sort|split|ssh|stat|strace|su|sudo|sum|suspend|swapon|sync|tac|tail|tar|tee|time|timeout|top|touch|tr|traceroute|tsort|tty|umount|uname|unexpand|uniq|units|unrar|unshar|unzip|update-grub|uptime|useradd|userdel|usermod|users|uudecode|uuencode|v|vcpkg|vdir|vi|vim|virsh|vmstat|wait|watch|wc|wget|whereis|which|who|whoami|write|xargs|xdg-open|yarn|yes|zenity|zip|zsh|zypper)(?=$|[)\s;|&])/,
+          lookbehind: !0
+        },
+        keyword: {
+          pattern: /(^|[\s;|&]|[<>]\()(?:case|do|done|elif|else|esac|fi|for|function|if|in|select|then|until|while)(?=$|[)\s;|&])/,
+          lookbehind: !0
+        },
+        // https://www.gnu.org/software/bash/manual/html_node/Shell-Builtin-Commands.html
+        builtin: {
+          pattern: /(^|[\s;|&]|[<>]\()(?:\.|:|alias|bind|break|builtin|caller|cd|command|continue|declare|echo|enable|eval|exec|exit|export|getopts|hash|help|let|local|logout|mapfile|printf|pwd|read|readarray|readonly|return|set|shift|shopt|source|test|times|trap|type|typeset|ulimit|umask|unalias|unset)(?=$|[)\s;|&])/,
+          lookbehind: !0,
+          // Alias added to make those easier to distinguish from strings.
+          alias: "class-name"
+        },
+        boolean: {
+          pattern: /(^|[\s;|&]|[<>]\()(?:false|true)(?=$|[)\s;|&])/,
+          lookbehind: !0
+        },
+        "file-descriptor": {
+          pattern: /\B&\d\b/,
+          alias: "important"
+        },
+        operator: {
+          // Lots of redirections here, but not just that.
+          pattern: /\d?<>|>\||\+=|=[=~]?|!=?|<<[<-]?|[&\d]?>>|\d[<>]&?|[<>][&=]?|&[>&]?|\|[&|]?/,
+          inside: {
+            "file-descriptor": {
+              pattern: /^\d/,
+              alias: "important"
+            }
+          }
+        },
+        punctuation: /\$?\(\(?|\)\)?|\.\.|[{}[\];\\]/,
+        number: {
+          pattern: /(^|\s)(?:[1-9]\d*|0)(?:[.,]\d+)?\b/,
+          lookbehind: !0
+        }
+      }, s.inside = e.languages.bash;
+      for (var o = [
+        "comment",
+        "function-name",
+        "for-or-select",
+        "assign-left",
+        "string",
+        "environment",
+        "function",
+        "keyword",
+        "builtin",
+        "boolean",
+        "file-descriptor",
+        "operator",
+        "punctuation",
+        "number"
+      ], d = t.variable[1].inside, a = 0; a < o.length; a++)
+        d[o[a]] = e.languages.bash[o[a]];
+      e.languages.shell = e.languages.bash;
+    })(l);
+  }
+  return i;
+}
+export {
+  u as r
+};

package/dist/bash-CmPTK8K6.js

@@ -0,0 +1,26 @@
+import { g as f } from "./index-Sj89RFCY.js";
+import { r as i } from "./bash-0-vitIuH.js";
+function c(t, s) {
+  for (var o = 0; o < s.length; o++) {
+    const e = s[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 n = i();
+const p = /* @__PURE__ */ f(n), g = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [n]);
+export {
+  g as b
+};

package/dist/basic-CBrKUqQp.js

@@ -0,0 +1,28 @@
+var T, R;
+function N() {
+  if (R) return T;
+  R = 1, T = E, E.displayName = "basic", E.aliases = [];
+  function E(I) {
+    I.languages.basic = {
+      comment: {
+        pattern: /(?:!|REM\b).+/i,
+        inside: {
+          keyword: /^REM/i
+        }
+      },
+      string: {
+        pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+        greedy: !0
+      },
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+      keyword: /\b(?:AS|BEEP|BLOAD|BSAVE|CALL(?: ABSOLUTE)?|CASE|CHAIN|CHDIR|CLEAR|CLOSE|CLS|COM|COMMON|CONST|DATA|DECLARE|DEF(?: FN| SEG|DBL|INT|LNG|SNG|STR)|DIM|DO|DOUBLE|ELSE|ELSEIF|END|ENVIRON|ERASE|ERROR|EXIT|FIELD|FILES|FOR|FUNCTION|GET|GOSUB|GOTO|IF|INPUT|INTEGER|IOCTL|KEY|KILL|LINE INPUT|LOCATE|LOCK|LONG|LOOP|LSET|MKDIR|NAME|NEXT|OFF|ON(?: COM| ERROR| KEY| TIMER)?|OPEN|OPTION BASE|OUT|POKE|PUT|READ|REDIM|REM|RESTORE|RESUME|RETURN|RMDIR|RSET|RUN|SELECT CASE|SHARED|SHELL|SINGLE|SLEEP|STATIC|STEP|STOP|STRING|SUB|SWAP|SYSTEM|THEN|TIMER|TO|TROFF|TRON|TYPE|UNLOCK|UNTIL|USING|VIEW PRINT|WAIT|WEND|WHILE|WRITE)(?:\$|\b)/i,
+      function: /\b(?:ABS|ACCESS|ACOS|ANGLE|AREA|ARITHMETIC|ARRAY|ASIN|ASK|AT|ATN|BASE|BEGIN|BREAK|CAUSE|CEIL|CHR|CLIP|COLLATE|COLOR|CON|COS|COSH|COT|CSC|DATE|DATUM|DEBUG|DECIMAL|DEF|DEG|DEGREES|DELETE|DET|DEVICE|DISPLAY|DOT|ELAPSED|EPS|ERASABLE|EXLINE|EXP|EXTERNAL|EXTYPE|FILETYPE|FIXED|FP|GO|GRAPH|HANDLER|IDN|IMAGE|IN|INT|INTERNAL|IP|IS|KEYED|LBOUND|LCASE|LEFT|LEN|LENGTH|LET|LINE|LINES|LOG|LOG10|LOG2|LTRIM|MARGIN|MAT|MAX|MAXNUM|MID|MIN|MISSING|MOD|NATIVE|NUL|NUMERIC|OF|OPTION|ORD|ORGANIZATION|OUTIN|OUTPUT|PI|POINT|POINTER|POINTS|POS|PRINT|PROGRAM|PROMPT|RAD|RADIANS|RANDOMIZE|RECORD|RECSIZE|RECTYPE|RELATIVE|REMAINDER|REPEAT|REST|RETRY|REWRITE|RIGHT|RND|ROUND|RTRIM|SAME|SEC|SELECT|SEQUENTIAL|SET|SETTER|SGN|SIN|SINH|SIZE|SKIP|SQR|STANDARD|STATUS|STR|STREAM|STYLE|TAB|TAN|TANH|TEMPLATE|TEXT|THERE|TIME|TIMEOUT|TRACE|TRANSFORM|TRUNCATE|UBOUND|UCASE|USE|VAL|VARIABLE|VIEWPORT|WHEN|WINDOW|WITH|ZER|ZONEWIDTH)(?:\$|\b)/i,
+      operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:AND|EQV|IMP|NOT|OR|XOR)\b/i,
+      punctuation: /[,;:()]/
+    };
+  }
+  return T;
+}
+export {
+  N as r
+};

package/dist/basic-CgjK_kM4.js

@@ -0,0 +1,26 @@
+import { g as c } from "./index-Sj89RFCY.js";
+import { r as n } from "./basic-CBrKUqQp.js";
+function f(t, s) {
+  for (var o = 0; o < s.length; o++) {
+    const e = s[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 i = n();
+const p = /* @__PURE__ */ c(i), g = /* @__PURE__ */ f({
+  __proto__: null,
+  default: p
+}, [i]);
+export {
+  g as b
+};

package/dist/batch-DDuJqYDJ.js

@@ -0,0 +1,125 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(a, i) {
+  for (var n = 0; n < i.length; n++) {
+    const e = i[n];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in a)) {
+          const t = Object.getOwnPropertyDescriptor(e, r);
+          t && Object.defineProperty(a, r, t.get ? t : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var s, b;
+function p() {
+  if (b) return s;
+  b = 1, s = a, a.displayName = "batch", a.aliases = [];
+  function a(i) {
+    (function(n) {
+      var e = /%%?[~:\w]+%?|!\S+!/, r = {
+        pattern: /\/[a-z?]+(?=[ :]|$):?|-[a-z]\b|--[a-z-]+\b/im,
+        alias: "attr-name",
+        inside: {
+          punctuation: /:/
+        }
+      }, t = /"(?:[\\"]"|[^"])*"(?!")/, o = /(?:\b|-)\d+\b/;
+      n.languages.batch = {
+        comment: [
+          /^::.*/m,
+          {
+            pattern: /((?:^|[&(])[ \t]*)rem\b(?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+            lookbehind: !0
+          }
+        ],
+        label: {
+          pattern: /^:.*/m,
+          alias: "property"
+        },
+        command: [
+          {
+            // FOR command
+            pattern: /((?:^|[&(])[ \t]*)for(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* \S+ in \([^)]+\) do/im,
+            lookbehind: !0,
+            inside: {
+              keyword: /\b(?:do|in)\b|^for\b/i,
+              string: t,
+              parameter: r,
+              variable: e,
+              number: o,
+              punctuation: /[()',]/
+            }
+          },
+          {
+            // IF command
+            pattern: /((?:^|[&(])[ \t]*)if(?: \/[a-z?](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:not )?(?:cmdextversion \d+|defined \w+|errorlevel \d+|exist \S+|(?:"[^"]*"|(?!")(?:(?!==)\S)+)?(?:==| (?:equ|geq|gtr|leq|lss|neq) )(?:"[^"]*"|[^\s"]\S*))/im,
+            lookbehind: !0,
+            inside: {
+              keyword: /\b(?:cmdextversion|defined|errorlevel|exist|not)\b|^if\b/i,
+              string: t,
+              parameter: r,
+              variable: e,
+              number: o,
+              operator: /\^|==|\b(?:equ|geq|gtr|leq|lss|neq)\b/i
+            }
+          },
+          {
+            // ELSE command
+            pattern: /((?:^|[&()])[ \t]*)else\b/im,
+            lookbehind: !0,
+            inside: {
+              keyword: /^else\b/i
+            }
+          },
+          {
+            // SET command
+            pattern: /((?:^|[&(])[ \t]*)set(?: \/[a-z](?:[ :](?:"[^"]*"|[^\s"/]\S*))?)* (?:[^^&)\r\n]|\^(?:\r\n|[\s\S]))*/im,
+            lookbehind: !0,
+            inside: {
+              keyword: /^set\b/i,
+              string: t,
+              parameter: r,
+              variable: [e, /\w+(?=(?:[*\/%+\-&^|]|<<|>>)?=)/],
+              number: o,
+              operator: /[*\/%+\-&^|]=?|<<=?|>>=?|[!~_=]/,
+              punctuation: /[()',]/
+            }
+          },
+          {
+            // Other commands
+            pattern: /((?:^|[&(])[ \t]*@?)\w+\b(?:"(?:[\\"]"|[^"])*"(?!")|[^"^&)\r\n]|\^(?:\r\n|[\s\S]))*/m,
+            lookbehind: !0,
+            inside: {
+              keyword: /^\w+\b/,
+              string: t,
+              parameter: r,
+              label: {
+                pattern: /(^\s*):\S+/m,
+                lookbehind: !0,
+                alias: "property"
+              },
+              variable: e,
+              number: o,
+              operator: /\^/
+            }
+          }
+        ],
+        operator: /[&@]/,
+        punctuation: /[()']/
+      };
+    })(i);
+  }
+  return s;
+}
+var l = p();
+const m = /* @__PURE__ */ u(l), f = /* @__PURE__ */ d({
+  __proto__: null,
+  default: m
+}, [l]);
+export {
+  f as b
+};

package/dist/bbcode-BBBJW4h9.js

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

package/dist/bicep-B7Vet2aR.js

@@ -0,0 +1,102 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function d(e, t) {
+  for (var i = 0; i < t.length; i++) {
+    const r = t[i];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, n);
+          o && Object.defineProperty(e, n, o.get ? o : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a, p;
+function b() {
+  if (p) return a;
+  p = 1, a = e, e.displayName = "bicep", e.aliases = [];
+  function e(t) {
+    t.languages.bicep = {
+      comment: [
+        {
+          // multiline comments eg /* ASDF */
+          pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          // singleline comments eg // ASDF
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      property: [
+        {
+          pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
+          lookbehind: !0
+        },
+        {
+          pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: [
+        {
+          pattern: /'''[^'][\s\S]*?'''/,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      "interpolated-string": {
+        pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /\$\{[^{}\r\n]*\}/,
+            inside: {
+              expression: {
+                pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                lookbehind: !0
+              },
+              punctuation: /^\$\{|\}$/
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      datatype: {
+        pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
+        lookbehind: !0,
+        alias: "class-name"
+      },
+      boolean: /\b(?:false|true)\b/,
+      // https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
+      keyword: /\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
+      decorator: /@\w+\b/,
+      function: /\b[a-z_]\w*(?=[ \t]*\()/i,
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+      operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+      punctuation: /[{}[\];(),.:]/
+    }, t.languages.bicep["interpolated-string"].inside.interpolation.inside.expression.inside = t.languages.bicep;
+  }
+  return a;
+}
+var u = b();
+const l = /* @__PURE__ */ s(u), g = /* @__PURE__ */ d({
+  __proto__: null,
+  default: l
+}, [u]);
+export {
+  g as b
+};

package/dist/birb-DPs12VRI.js

@@ -0,0 +1,53 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function u(e, r) {
+  for (var n = 0; n < r.length; n++) {
+    const t = r[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const a in t)
+        if (a !== "default" && !(a in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, a);
+          o && Object.defineProperty(e, a, o.get ? o : {
+            enumerable: !0,
+            get: () => t[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, b;
+function f() {
+  if (b) return i;
+  b = 1, i = e, e.displayName = "birb", e.aliases = [];
+  function e(r) {
+    r.languages.birb = r.languages.extend("clike", {
+      string: {
+        pattern: /r?("|')(?:\\.|(?!\1)[^\\])*\1/,
+        greedy: !0
+      },
+      "class-name": [
+        /\b[A-Z](?:[\d_]*[a-zA-Z]\w*)?\b/,
+        // matches variable and function return types (parameters as well).
+        /\b(?:[A-Z]\w*|(?!(?:var|void)\b)[a-z]\w*)(?=\s+\w+\s*[;,=()])/
+      ],
+      keyword: /\b(?:assert|break|case|class|const|default|else|enum|final|follows|for|grab|if|nest|new|next|noSeeb|return|static|switch|throw|var|void|while)\b/,
+      operator: /\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?|:/,
+      variable: /\b[a-z_]\w*\b/
+    }), r.languages.insertBefore("birb", "function", {
+      metadata: {
+        pattern: /<\w+>/,
+        greedy: !0,
+        alias: "symbol"
+      }
+    });
+  }
+  return i;
+}
+var s = f();
+const c = /* @__PURE__ */ l(s), d = /* @__PURE__ */ u({
+  __proto__: null,
+  default: c
+}, [s]);
+export {
+  d as b
+};