@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/markdown-6Q2QSFJe.js

@@ -0,0 +1,355 @@
+import { g as S } from "./index-Sj89RFCY.js";
+function E(l, b) {
+  for (var e = 0; e < b.length; e++) {
+    const s = b[e];
+    if (typeof s != "string" && !Array.isArray(s)) {
+      for (const o in s)
+        if (o !== "default" && !(o in l)) {
+          const d = Object.getOwnPropertyDescriptor(s, o);
+          d && Object.defineProperty(l, o, d.get ? d : {
+            enumerable: !0,
+            get: () => s[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(l, Symbol.toStringTag, { value: "Module" }));
+}
+var m, _;
+function C() {
+  if (_) return m;
+  _ = 1, m = l, l.displayName = "markdown", l.aliases = ["md"];
+  function l(b) {
+    (function(e) {
+      var s = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+      function o(t) {
+        return t = t.replace(/<inner>/g, function() {
+          return s;
+        }), RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + t + ")");
+      }
+      var d = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source, f = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
+        /__/g,
+        function() {
+          return d;
+        }
+      ), h = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+      e.languages.markdown = e.languages.extend("markup", {}), e.languages.insertBefore("markdown", "prolog", {
+        "front-matter-block": {
+          pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            punctuation: /^---|---$/,
+            "front-matter": {
+              pattern: /\S+(?:\s+\S+)*/,
+              alias: ["yaml", "language-yaml"],
+              inside: e.languages.yaml
+            }
+          }
+        },
+        blockquote: {
+          // > ...
+          pattern: /^>(?:[\t ]*>)*/m,
+          alias: "punctuation"
+        },
+        table: {
+          pattern: RegExp(
+            "^" + f + h + "(?:" + f + ")*",
+            "m"
+          ),
+          inside: {
+            "table-data-rows": {
+              pattern: RegExp(
+                "^(" + f + h + ")(?:" + f + ")*$"
+              ),
+              lookbehind: !0,
+              inside: {
+                "table-data": {
+                  pattern: RegExp(d),
+                  inside: e.languages.markdown
+                },
+                punctuation: /\|/
+              }
+            },
+            "table-line": {
+              pattern: RegExp("^(" + f + ")" + h + "$"),
+              lookbehind: !0,
+              inside: {
+                punctuation: /\||:?-{3,}:?/
+              }
+            },
+            "table-header-row": {
+              pattern: RegExp("^" + f + "$"),
+              inside: {
+                "table-header": {
+                  pattern: RegExp(d),
+                  alias: "important",
+                  inside: e.languages.markdown
+                },
+                punctuation: /\|/
+              }
+            }
+          }
+        },
+        code: [
+          {
+            // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+            pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+            lookbehind: !0,
+            alias: "keyword"
+          },
+          {
+            // ```optional language
+            // code block
+            // ```
+            pattern: /^```[\s\S]*?^```$/m,
+            greedy: !0,
+            inside: {
+              "code-block": {
+                pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+                lookbehind: !0
+              },
+              "code-language": {
+                pattern: /^(```).+/,
+                lookbehind: !0
+              },
+              punctuation: /```/
+            }
+          }
+        ],
+        title: [
+          {
+            // title 1
+            // =======
+            // title 2
+            // -------
+            pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+            alias: "important",
+            inside: {
+              punctuation: /==+$|--+$/
+            }
+          },
+          {
+            // # title 1
+            // ###### title 6
+            pattern: /(^\s*)#.+/m,
+            lookbehind: !0,
+            alias: "important",
+            inside: {
+              punctuation: /^#+|#+$/
+            }
+          }
+        ],
+        hr: {
+          // ***
+          // ---
+          // * * *
+          // -----------
+          pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        list: {
+          // * item
+          // + item
+          // - item
+          // 1. item
+          pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        "url-reference": {
+          // [id]: http://example.com "Optional title"
+          // [id]: http://example.com 'Optional title'
+          // [id]: http://example.com (Optional title)
+          // [id]: <http://example.com> "Optional title"
+          pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+          inside: {
+            variable: {
+              pattern: /^(!?\[)[^\]]+/,
+              lookbehind: !0
+            },
+            string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+            punctuation: /^[\[\]!:]|[<>]/
+          },
+          alias: "url"
+        },
+        bold: {
+          // **strong**
+          // __strong__
+          // allow one nested instance of italic text using the same delimiter
+          pattern: o(
+            /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /(^..)[\s\S]+(?=..$)/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            punctuation: /\*\*|__/
+          }
+        },
+        italic: {
+          // *em*
+          // _em_
+          // allow one nested instance of bold text using the same delimiter
+          pattern: o(
+            /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /(^.)[\s\S]+(?=.$)/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            punctuation: /[*_]/
+          }
+        },
+        strike: {
+          // ~~strike through~~
+          // ~strike~
+          // eslint-disable-next-line regexp/strict
+          pattern: o(/(~~?)(?:(?!~)<inner>)+\2/.source),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /(^~~?)[\s\S]+(?=\1$)/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            punctuation: /~~?/
+          }
+        },
+        "code-snippet": {
+          // `code`
+          // ``code``
+          pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+          lookbehind: !0,
+          greedy: !0,
+          alias: ["code", "keyword"]
+        },
+        url: {
+          // [example](http://example.com "Optional title")
+          // [example][id]
+          // [example] [id]
+          pattern: o(
+            /!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            operator: /^!/,
+            content: {
+              pattern: /(^\[)[^\]]+(?=\])/,
+              lookbehind: !0,
+              inside: {}
+              // see below
+            },
+            variable: {
+              pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+              lookbehind: !0
+            },
+            url: {
+              pattern: /(^\]\()[^\s)]+/,
+              lookbehind: !0
+            },
+            string: {
+              pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+              lookbehind: !0
+            }
+          }
+        }
+      }), ["url", "bold", "italic", "strike"].forEach(function(t) {
+        ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(n) {
+          t !== n && (e.languages.markdown[t].inside.content.inside[n] = e.languages.markdown[n]);
+        });
+      }), e.hooks.add("after-tokenize", function(t) {
+        if (t.language !== "markdown" && t.language !== "md")
+          return;
+        function n(i) {
+          if (!(!i || typeof i == "string"))
+            for (var r = 0, p = i.length; r < p; r++) {
+              var u = i[r];
+              if (u.type !== "code") {
+                n(u.content);
+                continue;
+              }
+              var g = u.content[1], a = u.content[3];
+              if (g && a && g.type === "code-language" && a.type === "code-block" && typeof g.content == "string") {
+                var c = g.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+                c = (/[a-z][\w-]*/i.exec(c) || [""])[0].toLowerCase();
+                var k = "language-" + c;
+                a.alias ? typeof a.alias == "string" ? a.alias = [a.alias, k] : a.alias.push(k) : a.alias = [k];
+              }
+            }
+        }
+        n(t.tokens);
+      }), e.hooks.add("wrap", function(t) {
+        if (t.type === "code-block") {
+          for (var n = "", i = 0, r = t.classes.length; i < r; i++) {
+            var p = t.classes[i], u = /language-(.+)/.exec(p);
+            if (u) {
+              n = u[1];
+              break;
+            }
+          }
+          var g = e.languages[n];
+          if (g)
+            t.content = e.highlight(
+              $(t.content.value),
+              g,
+              n
+            );
+          else if (n && n !== "none" && e.plugins.autoloader) {
+            var a = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
+            t.attributes.id = a, e.plugins.autoloader.loadLanguages(n, function() {
+              var c = document.getElementById(a);
+              c && (c.innerHTML = e.highlight(
+                c.textContent,
+                e.languages[n],
+                n
+              ));
+            });
+          }
+        }
+      });
+      var y = RegExp(e.languages.markup.tag.pattern.source, "gi"), v = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"'
+      }, x = String.fromCodePoint || String.fromCharCode;
+      function $(t) {
+        var n = t.replace(y, "");
+        return n = n.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(i, r) {
+          if (r = r.toLowerCase(), r[0] === "#") {
+            var p;
+            return r[1] === "x" ? p = parseInt(r.slice(2), 16) : p = Number(r.slice(1)), x(p);
+          } else {
+            var u = v[r];
+            return u || i;
+          }
+        }), n;
+      }
+      e.languages.md = e.languages.markdown;
+    })(b);
+  }
+  return m;
+}
+var w = C();
+const R = /* @__PURE__ */ S(w), N = /* @__PURE__ */ E({
+  __proto__: null,
+  default: R
+}, [w]);
+export {
+  N as m
+};

package/dist/markup-Bwuswjib.js

@@ -0,0 +1,194 @@
+import { g as i } from "./index-Sj89RFCY.js";
+function p(e, n) {
+  for (var a = 0; a < n.length; a++) {
+    const t = n[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const u in t)
+        if (u !== "default" && !(u in e)) {
+          const s = Object.getOwnPropertyDescriptor(t, u);
+          s && Object.defineProperty(e, u, s.get ? s : {
+            enumerable: !0,
+            get: () => t[u]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var l = r;
+r.displayName = "markup";
+r.aliases = ["html", "mathml", "svg", "xml", "ssml", "atom", "rss"];
+function r(e) {
+  e.languages.markup = {
+    comment: {
+      pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+      greedy: !0
+    },
+    prolog: {
+      pattern: /<\?[\s\S]+?\?>/,
+      greedy: !0
+    },
+    doctype: {
+      // https://www.w3.org/TR/xml/#NT-doctypedecl
+      pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+      greedy: !0,
+      inside: {
+        "internal-subset": {
+          pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: null
+          // see below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: !0
+        },
+        punctuation: /^<!|>$|[[\]]/,
+        "doctype-tag": /^DOCTYPE/i,
+        name: /[^\s<>'"]+/
+      }
+    },
+    cdata: {
+      pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+      greedy: !0
+    },
+    tag: {
+      pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+      greedy: !0,
+      inside: {
+        tag: {
+          pattern: /^<\/?[^\s>\/]+/,
+          inside: {
+            punctuation: /^<\/?/,
+            namespace: /^[^\s>\/:]+:/
+          }
+        },
+        "special-attr": [],
+        "attr-value": {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+          inside: {
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              /"|'/
+            ]
+          }
+        },
+        punctuation: /\/?>/,
+        "attr-name": {
+          pattern: /[^\s>\/]+/,
+          inside: {
+            namespace: /^[^\s>\/:]+:/
+          }
+        }
+      }
+    },
+    entity: [
+      {
+        pattern: /&[\da-z]{1,8};/i,
+        alias: "named-entity"
+      },
+      /&#x?[\da-f]{1,8};/i
+    ]
+  }, e.languages.markup.tag.inside["attr-value"].inside.entity = e.languages.markup.entity, e.languages.markup.doctype.inside["internal-subset"].inside = e.languages.markup, e.hooks.add("wrap", function(n) {
+    n.type === "entity" && (n.attributes.title = n.content.value.replace(/&amp;/, "&"));
+  }), Object.defineProperty(e.languages.markup.tag, "addInlined", {
+    /**
+     * Adds an inlined language to markup.
+     *
+     * An example of an inlined language is CSS with `<style>` tags.
+     *
+     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addInlined('style', 'css');
+     */
+    value: function(a, t) {
+      var u = {};
+      u["language-" + t] = {
+        pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+        lookbehind: !0,
+        inside: e.languages[t]
+      }, u.cdata = /^<!\[CDATA\[|\]\]>$/i;
+      var s = {
+        "included-cdata": {
+          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+          inside: u
+        }
+      };
+      s["language-" + t] = {
+        pattern: /[\s\S]+/,
+        inside: e.languages[t]
+      };
+      var g = {};
+      g[a] = {
+        pattern: RegExp(
+          /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+            /__/g,
+            function() {
+              return a;
+            }
+          ),
+          "i"
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: s
+      }, e.languages.insertBefore("markup", "cdata", g);
+    }
+  }), Object.defineProperty(e.languages.markup.tag, "addAttribute", {
+    /**
+     * Adds an pattern to highlight languages embedded in HTML attributes.
+     *
+     * An example of an inlined language is CSS with `style` attributes.
+     *
+     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addAttribute('style', 'css');
+     */
+    value: function(n, a) {
+      e.languages.markup.tag.inside["special-attr"].push({
+        pattern: RegExp(
+          /(^|["'\s])/.source + "(?:" + n + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+          "i"
+        ),
+        lookbehind: !0,
+        inside: {
+          "attr-name": /^[^\s=]+/,
+          "attr-value": {
+            pattern: /=[\s\S]+/,
+            inside: {
+              value: {
+                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                lookbehind: !0,
+                alias: [a, "language-" + a],
+                inside: e.languages[a]
+              },
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                /"|'/
+              ]
+            }
+          }
+        }
+      });
+    }
+  }), e.languages.html = e.languages.markup, e.languages.mathml = e.languages.markup, e.languages.svg = e.languages.markup, e.languages.xml = e.languages.extend("markup", {}), e.languages.ssml = e.languages.xml, e.languages.atom = e.languages.xml, e.languages.rss = e.languages.xml;
+}
+const d = /* @__PURE__ */ i(l), c = /* @__PURE__ */ p({
+  __proto__: null,
+  default: d
+}, [l]);
+export {
+  l as a,
+  c as m
+};

package/dist/markup-templating-BLspI5oq.js

@@ -0,0 +1,26 @@
+import { g as i } from "./index-Sj89RFCY.js";
+import { r as m } from "./markup-templating-CVTxtFGH.js";
+function f(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 p = m();
+const s = /* @__PURE__ */ i(p), l = /* @__PURE__ */ f({
+  __proto__: null,
+  default: s
+}, [p]);
+export {
+  l as m
+};

package/dist/markup-templating-CVTxtFGH.js

@@ -0,0 +1,77 @@
+var s, _;
+function S() {
+  if (_) return s;
+  _ = 1, s = c, c.displayName = "markupTemplating", c.aliases = [];
+  function c(m) {
+    (function(f) {
+      function k(a, t) {
+        return "___" + a.toUpperCase() + t + "___";
+      }
+      Object.defineProperties(f.languages["markup-templating"] = {}, {
+        buildPlaceholders: {
+          /**
+           * Tokenize all inline templating expressions matching `placeholderPattern`.
+           *
+           * If `replaceFilter` is provided, only matches of `placeholderPattern` for which `replaceFilter` returns
+           * `true` will be replaced.
+           *
+           * @param {object} env The environment of the `before-tokenize` hook.
+           * @param {string} language The language id.
+           * @param {RegExp} placeholderPattern The matches of this pattern will be replaced by placeholders.
+           * @param {(match: string) => boolean} [replaceFilter]
+           */
+          value: function(a, t, o, p) {
+            if (a.language === t) {
+              var u = a.tokenStack = [];
+              a.code = a.code.replace(o, function(n) {
+                if (typeof p == "function" && !p(n))
+                  return n;
+                for (var i = u.length, r; a.code.indexOf(r = k(t, i)) !== -1; )
+                  ++i;
+                return u[i] = n, r;
+              }), a.grammar = f.languages.markup;
+            }
+          }
+        },
+        tokenizePlaceholders: {
+          /**
+           * Replace placeholders with proper tokens after tokenizing.
+           *
+           * @param {object} env The environment of the `after-tokenize` hook.
+           * @param {string} language The language id.
+           */
+          value: function(a, t) {
+            if (a.language !== t || !a.tokenStack)
+              return;
+            a.grammar = f.languages[t];
+            var o = 0, p = Object.keys(a.tokenStack);
+            function u(n) {
+              for (var i = 0; i < n.length && !(o >= p.length); i++) {
+                var r = n[i];
+                if (typeof r == "string" || r.content && typeof r.content == "string") {
+                  var y = p[o], d = a.tokenStack[y], l = typeof r == "string" ? r : r.content, h = k(t, y), g = l.indexOf(h);
+                  if (g > -1) {
+                    ++o;
+                    var v = l.substring(0, g), b = new f.Token(
+                      t,
+                      f.tokenize(d, a.grammar),
+                      "language-" + t,
+                      d
+                    ), T = l.substring(g + h.length), e = [];
+                    v && e.push.apply(e, u([v])), e.push(b), T && e.push.apply(e, u([T])), typeof r == "string" ? n.splice.apply(n, [i, 1].concat(e)) : r.content = e;
+                  }
+                } else r.content && u(r.content);
+              }
+              return n;
+            }
+            u(a.tokens);
+          }
+        }
+      });
+    })(m);
+  }
+  return s;
+}
+export {
+  S as r
+};

package/dist/matlab-Bim6HLuO.js

@@ -0,0 +1,46 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function f(e, a) {
+  for (var n = 0; n < a.length; n++) {
+    const t = a[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, r);
+          o && Object.defineProperty(e, r, o.get ? o : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function b() {
+  if (s) return i;
+  s = 1, i = e, e.displayName = "matlab", e.aliases = [];
+  function e(a) {
+    a.languages.matlab = {
+      comment: [/%\{[\s\S]*?\}%/, /%.+/],
+      string: {
+        pattern: /\B'(?:''|[^'\r\n])*'/,
+        greedy: !0
+      },
+      // FIXME We could handle imaginary numbers as a whole
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[eE][+-]?\d+)?(?:[ij])?|\b[ij]\b/,
+      keyword: /\b(?:NaN|break|case|catch|continue|else|elseif|end|for|function|if|inf|otherwise|parfor|pause|pi|return|switch|try|while)\b/,
+      function: /\b(?!\d)\w+(?=\s*\()/,
+      operator: /\.?[*^\/\\']|[+\-:@]|[<>=~]=?|&&?|\|\|?/,
+      punctuation: /\.{3}|[.,;\[\](){}!]/
+    };
+  }
+  return i;
+}
+var u = b();
+const c = /* @__PURE__ */ l(u), p = /* @__PURE__ */ f({
+  __proto__: null,
+  default: c
+}, [u]);
+export {
+  p as m
+};