@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/wren-CkhJWcmB.js

@@ -0,0 +1,121 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function p(e, t) {
+  for (var a = 0; a < t.length; a++) {
+    const r = t[a];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in e)) {
+          const i = Object.getOwnPropertyDescriptor(r, n);
+          i && Object.defineProperty(e, n, i.get ? i : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, s;
+function d() {
+  if (s) return o;
+  s = 1, o = e, e.displayName = "wren", e.aliases = [];
+  function e(t) {
+    t.languages.wren = {
+      // Multiline comments in Wren can have nested multiline comments
+      // Comments: // and /* */
+      comment: [
+        {
+          // support 3 levels of nesting
+          // regex: \/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\/
+          pattern: /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*))*\*\/)*\*\/)*\*\//,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      // Triple quoted strings are multiline but cannot have interpolation (raw strings)
+      // Based on prism-python.js
+      "triple-quoted-string": {
+        pattern: /"""[\s\S]*?"""/,
+        greedy: !0,
+        alias: "string"
+      },
+      // see below
+      "string-literal": null,
+      // #!/usr/bin/env wren on the first line
+      hashbang: {
+        pattern: /^#!\/.+/,
+        greedy: !0,
+        alias: "comment"
+      },
+      // Attributes are special keywords to add meta data to classes
+      attribute: {
+        // #! attributes are stored in class properties
+        // #!myvar = true
+        // #attributes are not stored and dismissed at compilation
+        pattern: /#!?[ \t\u3000]*\w+/,
+        alias: "keyword"
+      },
+      "class-name": [
+        {
+          // class definition
+          // class Meta {}
+          pattern: /(\bclass\s+)\w+/,
+          lookbehind: !0
+        },
+        // A class must always start with an uppercase.
+        // File.read
+        /\b[A-Z][a-z\d_]*\b/
+      ],
+      // A constant can be a variable, class, property or method. Just named in all uppercase letters
+      constant: /\b[A-Z][A-Z\d_]*\b/,
+      null: {
+        pattern: /\bnull\b/,
+        alias: "keyword"
+      },
+      keyword: /\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+      // Functions can be Class.method()
+      function: /\b[a-z_]\w*(?=\s*[({])/i,
+      operator: /<<|>>|[=!<>]=?|&&|\|\||[-+*/%~^&|?:]|\.{2,3}/,
+      punctuation: /[\[\](){}.,;]/
+    }, t.languages.wren["string-literal"] = {
+      // A single quote string is multiline and can have interpolation (similar to JS backticks ``)
+      pattern: /(^|[^\\"])"(?:[^\\"%]|\\[\s\S]|%(?!\()|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\))*"/,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          // "%(interpolation)"
+          pattern: /((?:^|[^\\])(?:\\{2})*)%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\)/,
+          lookbehind: !0,
+          inside: {
+            expression: {
+              pattern: /^(%\()[\s\S]+(?=\)$)/,
+              lookbehind: !0,
+              inside: t.languages.wren
+            },
+            "interpolation-punctuation": {
+              pattern: /^%\(|\)$/,
+              alias: "punctuation"
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    };
+  }
+  return o;
+}
+var u = d();
+const b = /* @__PURE__ */ l(u), g = /* @__PURE__ */ p({
+  __proto__: null,
+  default: b
+}, [u]);
+export {
+  g as w
+};

package/dist/xeora-Cg3OrGlT.js

@@ -0,0 +1,147 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function s(t, r) {
+  for (var e = 0; e < r.length; e++) {
+    const n = r[e];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const a in n)
+        if (a !== "default" && !(a in t)) {
+          const i = Object.getOwnPropertyDescriptor(n, a);
+          i && Object.defineProperty(t, a, i.get ? i : {
+            enumerable: !0,
+            get: () => n[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, u;
+function l() {
+  if (u) return o;
+  u = 1, o = t, t.displayName = "xeora", t.aliases = ["xeoracube"];
+  function t(r) {
+    (function(e) {
+      e.languages.xeora = e.languages.extend("markup", {
+        constant: {
+          pattern: /\$(?:DomainContents|PageRenderDuration)\$/,
+          inside: {
+            punctuation: {
+              pattern: /\$/
+            }
+          }
+        },
+        variable: {
+          pattern: /\$@?(?:#+|[-+*~=^])?[\w.]+\$/,
+          inside: {
+            punctuation: {
+              pattern: /[$.]/
+            },
+            operator: {
+              pattern: /#+|[-+*~=^@]/
+            }
+          }
+        },
+        "function-inline": {
+          pattern: /\$F:[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\$/,
+          inside: {
+            variable: {
+              pattern: /(?:[,|])@?(?:#+|[-+*~=^])?[\w.]+/,
+              inside: {
+                punctuation: {
+                  pattern: /[,.|]/
+                },
+                operator: {
+                  pattern: /#+|[-+*~=^@]/
+                }
+              }
+            },
+            punctuation: {
+              pattern: /\$\w:|[$:?.,|]/
+            }
+          },
+          alias: "function"
+        },
+        "function-block": {
+          pattern: /\$XF:\{[-\w.]+\?[-\w.]+(?:,(?:(?:@[-#]*\w+\.[\w+.]\.*)*\|)*(?:(?:[\w+]|[-#*.~^]+[\w+]|=\S)(?:[^$=]|=+[^=])*=*|(?:@[-#]*\w+\.[\w+.]\.*)+(?:(?:[\w+]|[-#*~^][-#*.~^]*[\w+]|=\S)(?:[^$=]|=+[^=])*=*)?)?)?\}:XF\$/,
+          inside: {
+            punctuation: {
+              pattern: /[$:{}?.,|]/
+            }
+          },
+          alias: "function"
+        },
+        "directive-inline": {
+          pattern: /\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\/\w.]+\$/,
+          inside: {
+            punctuation: {
+              pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
+              inside: {
+                tag: {
+                  pattern: /#\d/
+                }
+              }
+            }
+          },
+          alias: "function"
+        },
+        "directive-block-open": {
+          pattern: /\$\w+:\{|\$\w(?:#\d+\+?)?(?:\[[-\w.]+\])?:[-\w.]+:\{(?:![A-Z]+)?/,
+          inside: {
+            punctuation: {
+              pattern: /\$(?:\w:|C(?:\[|#\d))?|[:{[\]]/,
+              inside: {
+                tag: {
+                  pattern: /#\d/
+                }
+              }
+            },
+            attribute: {
+              pattern: /![A-Z]+$/,
+              inside: {
+                punctuation: {
+                  pattern: /!/
+                }
+              },
+              alias: "keyword"
+            }
+          },
+          alias: "function"
+        },
+        "directive-block-separator": {
+          pattern: /\}:[-\w.]+:\{/,
+          inside: {
+            punctuation: {
+              pattern: /[:{}]/
+            }
+          },
+          alias: "function"
+        },
+        "directive-block-close": {
+          pattern: /\}:[-\w.]+\$/,
+          inside: {
+            punctuation: {
+              pattern: /[:{}$]/
+            }
+          },
+          alias: "function"
+        }
+      }), e.languages.insertBefore(
+        "inside",
+        "punctuation",
+        {
+          variable: e.languages.xeora["function-inline"].inside.variable
+        },
+        e.languages.xeora["function-block"]
+      ), e.languages.xeoracube = e.languages.xeora;
+    })(r);
+  }
+  return o;
+}
+var p = l();
+const w = /* @__PURE__ */ c(p), f = /* @__PURE__ */ s({
+  __proto__: null,
+  default: w
+}, [p]);
+export {
+  f as x
+};

package/dist/xml-doc-C0mFvWUS.js

@@ -0,0 +1,56 @@
+import { g as f } from "./index-Sj89RFCY.js";
+function g(r, n) {
+  for (var o = 0; o < n.length; o++) {
+    const e = n[o];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in r)) {
+          const a = Object.getOwnPropertyDescriptor(e, t);
+          a && Object.defineProperty(r, t, a.get ? a : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var c, i;
+function p() {
+  if (i) return c;
+  i = 1, c = r, r.displayName = "xmlDoc", r.aliases = [];
+  function r(n) {
+    (function(o) {
+      function e(s, u) {
+        o.languages[s] && o.languages.insertBefore(s, "comment", {
+          "doc-comment": u
+        });
+      }
+      var t = o.languages.markup.tag, a = {
+        pattern: /\/\/\/.*/,
+        greedy: !0,
+        alias: "comment",
+        inside: {
+          tag: t
+        }
+      }, l = {
+        pattern: /'''.*/,
+        greedy: !0,
+        alias: "comment",
+        inside: {
+          tag: t
+        }
+      };
+      e("csharp", a), e("fsharp", a), e("vbnet", l);
+    })(n);
+  }
+  return c;
+}
+var m = p();
+const d = /* @__PURE__ */ f(m), x = /* @__PURE__ */ g({
+  __proto__: null,
+  default: d
+}, [m]);
+export {
+  x
+};

package/dist/xojo-CW6K9MHL.js

@@ -0,0 +1,51 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function u(e, o) {
+  for (var n = 0; n < o.length; n++) {
+    const t = o[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const a = Object.getOwnPropertyDescriptor(t, r);
+          a && Object.defineProperty(e, r, a.get ? a : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, l;
+function p() {
+  if (l) return i;
+  l = 1, i = e, e.displayName = "xojo", e.aliases = [];
+  function e(o) {
+    o.languages.xojo = {
+      comment: {
+        pattern: /(?:'|\/\/|Rem\b).+/i,
+        greedy: !0
+      },
+      string: {
+        pattern: /"(?:""|[^"])*"/,
+        greedy: !0
+      },
+      number: [/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i, /&[bchou][a-z\d]+/i],
+      directive: {
+        pattern: /#(?:Else|ElseIf|Endif|If|Pragma)\b/i,
+        alias: "property"
+      },
+      keyword: /\b(?:AddHandler|App|Array|As(?:signs)?|Auto|Boolean|Break|By(?:Ref|Val)|Byte|Call|Case|Catch|CFStringRef|CGFloat|Class|Color|Const|Continue|CString|Currency|CurrentMethodName|Declare|Delegate|Dim|Do(?:uble|wnTo)?|Each|Else(?:If)?|End|Enumeration|Event|Exception|Exit|Extends|False|Finally|For|Function|Get|GetTypeInfo|Global|GOTO|If|Implements|In|Inherits|Int(?:8|16|32|64|eger|erface)?|Lib|Loop|Me|Module|Next|Nil|Object|Optional|OSType|ParamArray|Private|Property|Protected|PString|Ptr|Raise(?:Event)?|ReDim|RemoveHandler|Return|Select(?:or)?|Self|Set|Shared|Short|Single|Soft|Static|Step|String|Sub|Super|Text|Then|To|True|Try|Ubound|UInt(?:8|16|32|64|eger)?|Until|Using|Var(?:iant)?|Wend|While|WindowPtr|WString)\b/i,
+      operator: /<[=>]?|>=?|[+\-*\/\\^=]|\b(?:AddressOf|And|Ctype|IsA?|Mod|New|Not|Or|WeakAddressOf|Xor)\b/i,
+      punctuation: /[.,;:()]/
+    };
+  }
+  return i;
+}
+var s = p();
+const f = /* @__PURE__ */ d(s), g = /* @__PURE__ */ u({
+  __proto__: null,
+  default: f
+}, [s]);
+export {
+  g as x
+};

package/dist/xquery-B0ssbj_m.js

@@ -0,0 +1,118 @@
+import { g as d } from "./index-Sj89RFCY.js";
+function f(s, l) {
+  for (var r = 0; r < l.length; r++) {
+    const i = l[r];
+    if (typeof i != "string" && !Array.isArray(i)) {
+      for (const o in i)
+        if (o !== "default" && !(o in s)) {
+          const e = Object.getOwnPropertyDescriptor(i, o);
+          e && Object.defineProperty(s, o, e.get ? e : {
+            enumerable: !0,
+            get: () => i[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(s, Symbol.toStringTag, { value: "Module" }));
+}
+var g, p;
+function b() {
+  if (p) return g;
+  p = 1, g = s, s.displayName = "xquery", s.aliases = [];
+  function s(l) {
+    (function(r) {
+      r.languages.xquery = r.languages.extend("markup", {
+        "xquery-comment": {
+          pattern: /\(:[\s\S]*?:\)/,
+          greedy: !0,
+          alias: "comment"
+        },
+        string: {
+          pattern: /(["'])(?:\1\1|(?!\1)[\s\S])*\1/,
+          greedy: !0
+        },
+        extension: {
+          pattern: /\(#.+?#\)/,
+          alias: "symbol"
+        },
+        variable: /\$[-\w:]+/,
+        axis: {
+          pattern: /(^|[^-])(?:ancestor(?:-or-self)?|attribute|child|descendant(?:-or-self)?|following(?:-sibling)?|parent|preceding(?:-sibling)?|self)(?=::)/,
+          lookbehind: !0,
+          alias: "operator"
+        },
+        "keyword-operator": {
+          pattern: /(^|[^:-])\b(?:and|castable as|div|eq|except|ge|gt|idiv|instance of|intersect|is|le|lt|mod|ne|or|union)\b(?=$|[^:-])/,
+          lookbehind: !0,
+          alias: "operator"
+        },
+        keyword: {
+          pattern: /(^|[^:-])\b(?:as|ascending|at|base-uri|boundary-space|case|cast as|collation|construction|copy-namespaces|declare|default|descending|else|empty (?:greatest|least)|encoding|every|external|for|function|if|import|in|inherit|lax|let|map|module|namespace|no-inherit|no-preserve|option|order(?: by|ed|ing)?|preserve|return|satisfies|schema|some|stable|strict|strip|then|to|treat as|typeswitch|unordered|validate|variable|version|where|xquery)\b(?=$|[^:-])/,
+          lookbehind: !0
+        },
+        function: /[\w-]+(?::[\w-]+)*(?=\s*\()/,
+        "xquery-element": {
+          pattern: /(element\s+)[\w-]+(?::[\w-]+)*/,
+          lookbehind: !0,
+          alias: "tag"
+        },
+        "xquery-attribute": {
+          pattern: /(attribute\s+)[\w-]+(?::[\w-]+)*/,
+          lookbehind: !0,
+          alias: "attr-name"
+        },
+        builtin: {
+          pattern: /(^|[^:-])\b(?:attribute|comment|document|element|processing-instruction|text|xs:(?:ENTITIES|ENTITY|ID|IDREFS?|NCName|NMTOKENS?|NOTATION|Name|QName|anyAtomicType|anyType|anyURI|base64Binary|boolean|byte|date|dateTime|dayTimeDuration|decimal|double|duration|float|gDay|gMonth|gMonthDay|gYear|gYearMonth|hexBinary|int|integer|language|long|negativeInteger|nonNegativeInteger|nonPositiveInteger|normalizedString|positiveInteger|short|string|time|token|unsigned(?:Byte|Int|Long|Short)|untyped(?:Atomic)?|yearMonthDuration))\b(?=$|[^:-])/,
+          lookbehind: !0
+        },
+        number: /\b\d+(?:\.\d+)?(?:E[+-]?\d+)?/,
+        operator: [
+          /[+*=?|@]|\.\.?|:=|!=|<[=<]?|>[=>]?/,
+          {
+            pattern: /(\s)-(?=\s)/,
+            lookbehind: !0
+          }
+        ],
+        punctuation: /[[\](){},;:/]/
+      }), r.languages.xquery.tag.pattern = /<\/?(?!\d)[^\s>\/=$<%]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/, r.languages.xquery.tag.inside["attr-value"].pattern = /=(?:("|')(?:\\[\s\S]|\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}|(?!\1)[^\\])*\1|[^\s'">=]+)/, r.languages.xquery.tag.inside["attr-value"].inside.punctuation = /^="|"$/, r.languages.xquery.tag.inside["attr-value"].inside.expression = {
+        // Allow for two levels of nesting
+        pattern: /\{(?!\{)(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])+\}/,
+        inside: r.languages.xquery,
+        alias: "language-xquery"
+      };
+      var i = function(e) {
+        return typeof e == "string" ? e : typeof e.content == "string" ? e.content : e.content.map(i).join("");
+      }, o = function(e) {
+        for (var a = [], t = 0; t < e.length; t++) {
+          var n = e[t], c = !1;
+          if (typeof n != "string" && (n.type === "tag" && n.content[0] && n.content[0].type === "tag" ? n.content[0].content[0].content === "</" ? a.length > 0 && a[a.length - 1].tagName === i(n.content[0].content[1]) && a.pop() : n.content[n.content.length - 1].content === "/>" || a.push({
+            tagName: i(n.content[0].content[1]),
+            openedBraces: 0
+          }) : a.length > 0 && n.type === "punctuation" && n.content === "{" && // Ignore `{{`
+          (!e[t + 1] || e[t + 1].type !== "punctuation" || e[t + 1].content !== "{") && (!e[t - 1] || e[t - 1].type !== "plain-text" || e[t - 1].content !== "{") ? a[a.length - 1].openedBraces++ : a.length > 0 && a[a.length - 1].openedBraces > 0 && n.type === "punctuation" && n.content === "}" ? a[a.length - 1].openedBraces-- : n.type !== "comment" && (c = !0)), (c || typeof n == "string") && a.length > 0 && a[a.length - 1].openedBraces === 0) {
+            var u = i(n);
+            t < e.length - 1 && (typeof e[t + 1] == "string" || e[t + 1].type === "plain-text") && (u += i(e[t + 1]), e.splice(t + 1, 1)), t > 0 && (typeof e[t - 1] == "string" || e[t - 1].type === "plain-text") && (u = i(e[t - 1]) + u, e.splice(t - 1, 1), t--), /^\s+$/.test(u) ? e[t] = u : e[t] = new r.Token(
+              "plain-text",
+              u,
+              null,
+              u
+            );
+          }
+          n.content && typeof n.content != "string" && o(n.content);
+        }
+      };
+      r.hooks.add("after-tokenize", function(e) {
+        e.language === "xquery" && o(e.tokens);
+      });
+    })(l);
+  }
+  return g;
+}
+var y = b();
+const h = /* @__PURE__ */ d(y), x = /* @__PURE__ */ f({
+  __proto__: null,
+  default: h
+}, [y]);
+export {
+  x
+};

package/dist/yaml-S0xfBtlT.js

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

package/dist/yaml-hxc7aP7n.js

@@ -0,0 +1,92 @@
+var l, i;
+function g() {
+  if (i) return l;
+  i = 1, l = r, r.displayName = "yaml", r.aliases = ["yml"];
+  function r(p) {
+    (function(t) {
+      var a = /[*&][^\s[\]{},]+/, n = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, u = "(?:" + n.source + "(?:[ 	]+" + a.source + ")?|" + a.source + "(?:[ 	]+" + n.source + ")?)", s = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+        /<PLAIN>/g,
+        function() {
+          return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+        }
+      ), d = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+      function e(f, o) {
+        o = (o || "").replace(/m/g, "") + "m";
+        var c = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+          return u;
+        }).replace(/<<value>>/g, function() {
+          return f;
+        });
+        return RegExp(c, o);
+      }
+      t.languages.yaml = {
+        scalar: {
+          pattern: RegExp(
+            /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+              /<<prop>>/g,
+              function() {
+                return u;
+              }
+            )
+          ),
+          lookbehind: !0,
+          alias: "string"
+        },
+        comment: /#.*/,
+        key: {
+          pattern: RegExp(
+            /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+              return u;
+            }).replace(/<<key>>/g, function() {
+              return "(?:" + s + "|" + d + ")";
+            })
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "atrule"
+        },
+        directive: {
+          pattern: /(^[ \t]*)%.+/m,
+          lookbehind: !0,
+          alias: "important"
+        },
+        datetime: {
+          pattern: e(
+            /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source
+          ),
+          lookbehind: !0,
+          alias: "number"
+        },
+        boolean: {
+          pattern: e(/false|true/.source, "i"),
+          lookbehind: !0,
+          alias: "important"
+        },
+        null: {
+          pattern: e(/null|~/.source, "i"),
+          lookbehind: !0,
+          alias: "important"
+        },
+        string: {
+          pattern: e(d),
+          lookbehind: !0,
+          greedy: !0
+        },
+        number: {
+          pattern: e(
+            /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
+            "i"
+          ),
+          lookbehind: !0
+        },
+        tag: n,
+        important: a,
+        punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+      }, t.languages.yml = t.languages.yaml;
+    })(p);
+  }
+  return l;
+}
+export {
+  g as r
+};

package/dist/yang-Dg6OSQ6Y.js

@@ -0,0 +1,53 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function f(e, n) {
+  for (var a = 0; a < n.length; a++) {
+    const r = n[a];
+    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, s;
+function p() {
+  if (s) return i;
+  s = 1, i = e, e.displayName = "yang", e.aliases = [];
+  function e(n) {
+    n.languages.yang = {
+      // https://tools.ietf.org/html/rfc6020#page-34
+      // http://www.yang-central.org/twiki/bin/view/Main/YangExamples
+      comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
+      string: {
+        pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
+        greedy: !0
+      },
+      keyword: {
+        pattern: /(^|[{};\r\n][ \t]*)[a-z_][\w.-]*/i,
+        lookbehind: !0
+      },
+      namespace: {
+        pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
+        lookbehind: !0
+      },
+      boolean: /\b(?:false|true)\b/,
+      operator: /\+/,
+      punctuation: /[{};:]/
+    };
+  }
+  return i;
+}
+var g = p();
+const y = /* @__PURE__ */ u(g), l = /* @__PURE__ */ f({
+  __proto__: null,
+  default: y
+}, [g]);
+export {
+  l as y
+};