@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/systemd-DWsV0AtP.js

@@ -0,0 +1,88 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function d(r, s) {
+  for (var n = 0; n < s.length; n++) {
+    const t = s[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const e in t)
+        if (e !== "default" && !(e in r)) {
+          const o = Object.getOwnPropertyDescriptor(t, e);
+          o && Object.defineProperty(r, e, o.get ? o : {
+            enumerable: !0,
+            get: () => t[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var a, u;
+function m() {
+  if (u) return a;
+  u = 1, a = r, r.displayName = "systemd", r.aliases = [];
+  function r(s) {
+    (function(n) {
+      var t = {
+        pattern: /^[;#].*/m,
+        greedy: !0
+      }, e = /"(?:[^\r\n"\\]|\\(?:[^\r]|\r\n?))*"(?!\S)/.source;
+      n.languages.systemd = {
+        comment: t,
+        section: {
+          pattern: /^\[[^\n\r\[\]]*\](?=[ \t]*$)/m,
+          greedy: !0,
+          inside: {
+            punctuation: /^\[|\]$/,
+            "section-name": {
+              pattern: /[\s\S]+/,
+              alias: "selector"
+            }
+          }
+        },
+        key: {
+          pattern: /^[^\s=]+(?=[ \t]*=)/m,
+          greedy: !0,
+          alias: "attr-name"
+        },
+        value: {
+          // This pattern is quite complex because of two properties:
+          //  1) Quotes (strings) must be preceded by a space. Since we can't use lookbehinds, we have to "resolve"
+          //     the lookbehind. You will see this in the main loop where spaces are handled separately.
+          //  2) Line continuations.
+          //     After line continuations, empty lines and comments are ignored so we have to consume them.
+          pattern: RegExp(
+            /(=[ \t]*(?!\s))/.source + // the value either starts with quotes or not
+            "(?:" + e + `|(?=[^"\r
+]))(?:` + (/[^\s\\]/.source + // handle spaces separately because of quotes
+            '|[ 	]+(?:(?![ 	"])|' + e + ")|" + /\\[\r\n]+(?:[#;].*[\r\n]+)*(?![#;])/.source) + ")*"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          alias: "attr-value",
+          inside: {
+            comment: t,
+            quoted: {
+              pattern: RegExp(/(^|\s)/.source + e),
+              lookbehind: !0,
+              greedy: !0
+            },
+            punctuation: /\\$/m,
+            boolean: {
+              pattern: /^(?:false|no|off|on|true|yes)$/,
+              greedy: !0
+            }
+          }
+        },
+        punctuation: /=/
+      };
+    })(s);
+  }
+  return a;
+}
+var i = m();
+const y = /* @__PURE__ */ c(i), l = /* @__PURE__ */ d({
+  __proto__: null,
+  default: y
+}, [i]);
+export {
+  l as s
+};

package/dist/t4-cs-D7NmzTCB.js

@@ -0,0 +1,38 @@
+import { g } from "./index-Sj89RFCY.js";
+import { r as u } from "./t4-templating-yxm91MEk.js";
+import { r as p } from "./csharp-BmDeN1AH.js";
+function c(t, s) {
+  for (var r = 0; r < s.length; r++) {
+    const e = s[r];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const a in e)
+        if (a !== "default" && !(a in t)) {
+          const o = Object.getOwnPropertyDescriptor(e, a);
+          o && Object.defineProperty(t, a, o.get ? o : {
+            enumerable: !0,
+            get: () => e[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var n, i;
+function l() {
+  if (i) return n;
+  i = 1;
+  var t = u(), s = p();
+  n = r, r.displayName = "t4Cs", r.aliases = [];
+  function r(e) {
+    e.register(t), e.register(s), e.languages.t4 = e.languages["t4-cs"] = e.languages["t4-templating"].createT4("csharp");
+  }
+  return n;
+}
+var f = l();
+const C = /* @__PURE__ */ g(f), T = /* @__PURE__ */ c({
+  __proto__: null,
+  default: C
+}, [f]);
+export {
+  T as t
+};

package/dist/t4-templating-Bc9GyRcs.js

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

package/dist/t4-templating-yxm91MEk.js

@@ -0,0 +1,56 @@
+var i, l;
+function c() {
+  if (l) return i;
+  l = 1, i = r, r.displayName = "t4Templating", r.aliases = [];
+  function r(u) {
+    (function(s) {
+      function n(e, a, t) {
+        return {
+          pattern: RegExp("<#" + e + "[\\s\\S]*?#>"),
+          alias: "block",
+          inside: {
+            delimiter: {
+              pattern: RegExp("^<#" + e + "|#>$"),
+              alias: "important"
+            },
+            content: {
+              pattern: /[\s\S]+/,
+              inside: a,
+              alias: t
+            }
+          }
+        };
+      }
+      function p(e) {
+        var a = s.languages[e], t = "language-" + e;
+        return {
+          block: {
+            pattern: /<#[\s\S]+?#>/,
+            inside: {
+              directive: n("@", {
+                "attr-value": {
+                  pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/,
+                  inside: {
+                    punctuation: /^=|^["']|["']$/
+                  }
+                },
+                keyword: /\b\w+(?=\s)/,
+                "attr-name": /\b\w+/
+              }),
+              expression: n("=", a, t),
+              "class-feature": n("\\+", a, t),
+              standard: n("", a, t)
+            }
+          }
+        };
+      }
+      s.languages["t4-templating"] = Object.defineProperty({}, "createT4", {
+        value: p
+      });
+    })(u);
+  }
+  return i;
+}
+export {
+  c as r
+};

package/dist/t4-vb-Df3tMe1Q.js

@@ -0,0 +1,38 @@
+import { g as u } from "./index-Sj89RFCY.js";
+import { r as g } from "./t4-templating-yxm91MEk.js";
+import { r as b } from "./vbnet-ClfmYufs.js";
+function c(t, o) {
+  for (var r = 0; r < o.length; r++) {
+    const e = o[r];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const a in e)
+        if (a !== "default" && !(a in t)) {
+          const n = Object.getOwnPropertyDescriptor(e, a);
+          n && Object.defineProperty(t, a, n.get ? n : {
+            enumerable: !0,
+            get: () => e[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var i, f;
+function l() {
+  if (f) return i;
+  f = 1;
+  var t = g(), o = b();
+  i = r, r.displayName = "t4Vb", r.aliases = [];
+  function r(e) {
+    e.register(t), e.register(o), e.languages["t4-vb"] = e.languages["t4-templating"].createT4("vbnet");
+  }
+  return i;
+}
+var s = l();
+const p = /* @__PURE__ */ u(s), d = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [s]);
+export {
+  d as t
+};

package/dist/tap-wFXvu_No.js

@@ -0,0 +1,56 @@
+import { g as u } from "./index-Sj89RFCY.js";
+import { r as l } from "./yaml-hxc7aP7n.js";
+function f(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    const a = t[e];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const o in a)
+        if (o !== "default" && !(o in r)) {
+          const n = Object.getOwnPropertyDescriptor(a, o);
+          n && Object.defineProperty(r, o, n.get ? n : {
+            enumerable: !0,
+            get: () => a[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var i, s;
+function g() {
+  if (s) return i;
+  s = 1;
+  var r = l();
+  i = t, t.displayName = "tap", t.aliases = [];
+  function t(e) {
+    e.register(r), e.languages.tap = {
+      fail: /not ok[^#{\n\r]*/,
+      pass: /ok[^#{\n\r]*/,
+      pragma: /pragma [+-][a-z]+/,
+      bailout: /bail out!.*/i,
+      version: /TAP version \d+/i,
+      plan: /\b\d+\.\.\d+(?: +#.*)?/,
+      subtest: {
+        pattern: /# Subtest(?:: .*)?/,
+        greedy: !0
+      },
+      punctuation: /[{}]/,
+      directive: /#.*/,
+      yamlish: {
+        pattern: /(^[ \t]*)---[\s\S]*?[\r\n][ \t]*\.\.\.$/m,
+        lookbehind: !0,
+        inside: e.languages.yaml,
+        alias: "language-yaml"
+      }
+    };
+  }
+  return i;
+}
+var p = g();
+const c = /* @__PURE__ */ u(p), b = /* @__PURE__ */ f({
+  __proto__: null,
+  default: c
+}, [p]);
+export {
+  b as t
+};

package/dist/tcl-BZqzhUcQ.js

@@ -0,0 +1,79 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function p(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 l, i;
+function u() {
+  if (i) return l;
+  i = 1, l = e, e.displayName = "tcl", e.aliases = [];
+  function e(a) {
+    a.languages.tcl = {
+      comment: {
+        pattern: /(^|[^\\])#.*/,
+        lookbehind: !0
+      },
+      string: {
+        pattern: /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
+        greedy: !0
+      },
+      variable: [
+        {
+          pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(\$)\{[^}]+\}/,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
+          lookbehind: !0
+        }
+      ],
+      function: {
+        pattern: /(^[\t ]*proc[ \t]+)\S+/m,
+        lookbehind: !0
+      },
+      builtin: [
+        {
+          pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
+          lookbehind: !0
+        },
+        /\b(?:else|elseif)\b/
+      ],
+      scope: {
+        pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
+        lookbehind: !0,
+        alias: "constant"
+      },
+      keyword: {
+        pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
+        lookbehind: !0
+      },
+      operator: /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
+      punctuation: /[{}()\[\]]/
+    };
+  }
+  return l;
+}
+var c = u();
+const d = /* @__PURE__ */ s(c), b = /* @__PURE__ */ p({
+  __proto__: null,
+  default: d
+}, [c]);
+export {
+  b as t
+};

package/dist/textile-DrTKyn7T.js

@@ -0,0 +1,289 @@
+import { g as h } from "./index-Sj89RFCY.js";
+function g(r, l) {
+  for (var i = 0; i < l.length; i++) {
+    const o = l[i];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const a in o)
+        if (a !== "default" && !(a in r)) {
+          const e = Object.getOwnPropertyDescriptor(o, a);
+          e && Object.defineProperty(r, a, e.get ? e : {
+            enumerable: !0,
+            get: () => o[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var c, k;
+function O() {
+  if (k) return c;
+  k = 1, c = r, r.displayName = "textile", r.aliases = [];
+  function r(l) {
+    (function(i) {
+      var o = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source, a = /\)|\((?![^|()\n]+\))/.source;
+      function e(m, f) {
+        return RegExp(
+          m.replace(/<MOD>/g, function() {
+            return "(?:" + o + ")";
+          }).replace(/<PAR>/g, function() {
+            return "(?:" + a + ")";
+          }),
+          f || ""
+        );
+      }
+      var s = {
+        css: {
+          pattern: /\{[^{}]+\}/,
+          inside: {
+            rest: i.languages.css
+          }
+        },
+        "class-id": {
+          pattern: /(\()[^()]+(?=\))/,
+          lookbehind: !0,
+          alias: "attr-value"
+        },
+        lang: {
+          pattern: /(\[)[^\[\]]+(?=\])/,
+          lookbehind: !0,
+          alias: "attr-value"
+        },
+        // Anything else is punctuation (the first pattern is for row/col spans inside tables)
+        punctuation: /[\\\/]\d+|\S/
+      }, p = i.languages.textile = i.languages.extend("markup", {
+        phrase: {
+          pattern: /(^|\r|\n)\S[\s\S]*?(?=$|\r?\n\r?\n|\r\r)/,
+          lookbehind: !0,
+          inside: {
+            // h1. Header 1
+            "block-tag": {
+              pattern: e(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
+              inside: {
+                modifier: {
+                  pattern: e(
+                    /(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source
+                  ),
+                  lookbehind: !0,
+                  inside: s
+                },
+                tag: /^[a-z]\w*/,
+                punctuation: /\.$/
+              }
+            },
+            // # List item
+            // * List item
+            list: {
+              pattern: e(/^[*#]+<MOD>*\s+\S.*/.source, "m"),
+              inside: {
+                modifier: {
+                  pattern: e(/(^[*#]+)<MOD>+/.source),
+                  lookbehind: !0,
+                  inside: s
+                },
+                punctuation: /^[*#]+/
+              }
+            },
+            // | cell | cell | cell |
+            table: {
+              // Modifiers can be applied to the row: {color:red}.|1|2|3|
+              // or the cell: |{color:red}.1|2|3|
+              pattern: e(
+                /^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source,
+                "m"
+              ),
+              inside: {
+                modifier: {
+                  // Modifiers for rows after the first one are
+                  // preceded by a pipe and a line feed
+                  pattern: e(
+                    /(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source
+                  ),
+                  lookbehind: !0,
+                  inside: s
+                },
+                punctuation: /\||^\./
+              }
+            },
+            inline: {
+              // eslint-disable-next-line regexp/no-super-linear-backtracking
+              pattern: e(
+                /(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source
+              ),
+              lookbehind: !0,
+              inside: {
+                // Note: superscripts and subscripts are not handled specifically
+                // *bold*, **bold**
+                bold: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
+                  lookbehind: !0
+                },
+                // _italic_, __italic__
+                italic: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^(__?)<MOD>*).+?(?=\2)/.source),
+                  lookbehind: !0
+                },
+                // ??cite??
+                cite: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
+                  lookbehind: !0,
+                  alias: "string"
+                },
+                // @code@
+                code: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^@<MOD>*).+?(?=@)/.source),
+                  lookbehind: !0,
+                  alias: "keyword"
+                },
+                // +inserted+
+                inserted: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^\+<MOD>*).+?(?=\+)/.source),
+                  lookbehind: !0
+                },
+                // -deleted-
+                deleted: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^-<MOD>*).+?(?=-)/.source),
+                  lookbehind: !0
+                },
+                // %span%
+                span: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^%<MOD>*).+?(?=%)/.source),
+                  lookbehind: !0
+                },
+                modifier: {
+                  pattern: e(
+                    /(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source
+                  ),
+                  lookbehind: !0,
+                  inside: s
+                },
+                punctuation: /[*_%?@+\-^~]+/
+              }
+            },
+            // [alias]http://example.com
+            "link-ref": {
+              pattern: /^\[[^\]]+\]\S+$/m,
+              inside: {
+                string: {
+                  pattern: /(^\[)[^\]]+(?=\])/,
+                  lookbehind: !0
+                },
+                url: {
+                  pattern: /(^\])\S+$/,
+                  lookbehind: !0
+                },
+                punctuation: /[\[\]]/
+              }
+            },
+            // "text":http://example.com
+            // "text":link-ref
+            link: {
+              // eslint-disable-next-line regexp/no-super-linear-backtracking
+              pattern: e(
+                /"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source
+              ),
+              inside: {
+                text: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: e(/(^"<MOD>*)[^"]+(?=")/.source),
+                  lookbehind: !0
+                },
+                modifier: {
+                  pattern: e(/(^")<MOD>+/.source),
+                  lookbehind: !0,
+                  inside: s
+                },
+                url: {
+                  pattern: /(:).+/,
+                  lookbehind: !0
+                },
+                punctuation: /[":]/
+              }
+            },
+            // !image.jpg!
+            // !image.jpg(Title)!:http://example.com
+            image: {
+              pattern: e(
+                /!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source
+              ),
+              inside: {
+                source: {
+                  pattern: e(
+                    /(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source
+                  ),
+                  lookbehind: !0,
+                  alias: "url"
+                },
+                modifier: {
+                  pattern: e(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
+                  lookbehind: !0,
+                  inside: s
+                },
+                url: {
+                  pattern: /(:).+/,
+                  lookbehind: !0
+                },
+                punctuation: /[!:]/
+              }
+            },
+            // Footnote[1]
+            footnote: {
+              pattern: /\b\[\d+\]/,
+              alias: "comment",
+              inside: {
+                punctuation: /\[|\]/
+              }
+            },
+            // CSS(Cascading Style Sheet)
+            acronym: {
+              pattern: /\b[A-Z\d]+\([^)]+\)/,
+              inside: {
+                comment: {
+                  pattern: /(\()[^()]+(?=\))/,
+                  lookbehind: !0
+                },
+                punctuation: /[()]/
+              }
+            },
+            // Prism(C)
+            mark: {
+              pattern: /\b\((?:C|R|TM)\)/,
+              alias: "comment",
+              inside: {
+                punctuation: /[()]/
+              }
+            }
+          }
+        }
+      }), n = p.phrase.inside, t = {
+        inline: n.inline,
+        link: n.link,
+        image: n.image,
+        footnote: n.footnote,
+        acronym: n.acronym,
+        mark: n.mark
+      };
+      p.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
+      var d = n.inline.inside;
+      d.bold.inside = t, d.italic.inside = t, d.inserted.inside = t, d.deleted.inside = t, d.span.inside = t;
+      var u = n.table.inside;
+      u.inline = t.inline, u.link = t.link, u.image = t.image, u.footnote = t.footnote, u.acronym = t.acronym, u.mark = t.mark;
+    })(l);
+  }
+  return c;
+}
+var b = O();
+const M = /* @__PURE__ */ h(b), x = /* @__PURE__ */ g({
+  __proto__: null,
+  default: M
+}, [b]);
+export {
+  x as t
+};