@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/latte-CFxOlcdj.js

@@ -0,0 +1,101 @@
+import { g } from "./index-Sj89RFCY.js";
+import { r as f } from "./markup-templating-CVTxtFGH.js";
+import { r as c } from "./php-C_FrOCG4.js";
+function d(n, l) {
+  for (var a = 0; a < l.length; a++) {
+    const e = l[a];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in n)) {
+          const r = Object.getOwnPropertyDescriptor(e, t);
+          r && Object.defineProperty(n, t, r.get ? r : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var i, p;
+function m() {
+  if (p) return i;
+  p = 1;
+  var n = f(), l = c();
+  i = a, a.displayName = "latte", a.aliases = [];
+  function a(e) {
+    e.register(n), e.register(l), function(t) {
+      t.languages.latte = {
+        comment: /^\{\*[\s\S]*/,
+        "latte-tag": {
+          // https://latte.nette.org/en/tags
+          pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i,
+          lookbehind: !0,
+          alias: "important"
+        },
+        delimiter: {
+          pattern: /^\{\/?|\}$/,
+          alias: "punctuation"
+        },
+        php: {
+          pattern: /\S(?:[\s\S]*\S)?/,
+          alias: "language-php",
+          inside: t.languages.php
+        }
+      };
+      var r = t.languages.extend("markup", {});
+      t.languages.insertBefore(
+        "inside",
+        "attr-value",
+        {
+          "n-attr": {
+            pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/,
+            inside: {
+              "attr-name": {
+                pattern: /^[^\s=]+/,
+                alias: "important"
+              },
+              "attr-value": {
+                pattern: /=[\s\S]+/,
+                inside: {
+                  punctuation: [
+                    /^=/,
+                    {
+                      pattern: /^(\s*)["']|["']$/,
+                      lookbehind: !0
+                    }
+                  ],
+                  php: {
+                    pattern: /\S(?:[\s\S]*\S)?/,
+                    inside: t.languages.php
+                  }
+                }
+              }
+            }
+          }
+        },
+        r.tag
+      ), t.hooks.add("before-tokenize", function(o) {
+        if (o.language === "latte") {
+          var s = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g;
+          t.languages["markup-templating"].buildPlaceholders(
+            o,
+            "latte",
+            s
+          ), o.grammar = r;
+        }
+      }), t.hooks.add("after-tokenize", function(o) {
+        t.languages["markup-templating"].tokenizePlaceholders(o, "latte");
+      });
+    }(e);
+  }
+  return i;
+}
+var u = m();
+const h = /* @__PURE__ */ g(u), v = /* @__PURE__ */ d({
+  __proto__: null,
+  default: h
+}, [u]);
+export {
+  v as l
+};

package/dist/less-DwfFB3qp.js

@@ -0,0 +1,75 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function p(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const s = t[n];
+    if (typeof s != "string" && !Array.isArray(s)) {
+      for (const r in s)
+        if (r !== "default" && !(r in e)) {
+          const a = Object.getOwnPropertyDescriptor(s, r);
+          a && Object.defineProperty(e, r, a.get ? a : {
+            enumerable: !0,
+            get: () => s[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, i;
+function c() {
+  if (i) return o;
+  i = 1, o = e, e.displayName = "less", e.aliases = [];
+  function e(t) {
+    t.languages.less = t.languages.extend("css", {
+      comment: [
+        /\/\*[\s\S]*?\*\//,
+        {
+          pattern: /(^|[^\\])\/\/.*/,
+          lookbehind: !0
+        }
+      ],
+      atrule: {
+        pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+        inside: {
+          punctuation: /[:()]/
+        }
+      },
+      // selectors and mixins are considered the same
+      selector: {
+        pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+        inside: {
+          // mixin parameters
+          variable: /@+[\w-]+/
+        }
+      },
+      property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+      operator: /[+\-*\/]/
+    }), t.languages.insertBefore("less", "property", {
+      variable: [
+        // Variable declaration (the colon must be consumed!)
+        {
+          pattern: /@[\w-]+\s*:/,
+          inside: {
+            punctuation: /:/
+          }
+        },
+        // Variable usage
+        /@@?[\w-]+/
+      ],
+      "mixin-usage": {
+        pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+        lookbehind: !0,
+        alias: "function"
+      }
+    });
+  }
+  return o;
+}
+var l = c();
+const f = /* @__PURE__ */ u(l), d = /* @__PURE__ */ p({
+  __proto__: null,
+  default: f
+}, [l]);
+export {
+  d as l
+};

package/dist/lilypond-DaH_baew.js

@@ -0,0 +1,104 @@
+import { g as u } from "./index-Sj89RFCY.js";
+import { r as c } from "./scheme-B-TWMKN_.js";
+function g(o, n) {
+  for (var t = 0; t < n.length; t++) {
+    const r = n[t];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const e in r)
+        if (e !== "default" && !(e in o)) {
+          const i = Object.getOwnPropertyDescriptor(r, e);
+          i && Object.defineProperty(o, e, i.get ? i : {
+            enumerable: !0,
+            get: () => r[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
+}
+var s, d;
+function y() {
+  if (d) return s;
+  d = 1;
+  var o = c();
+  s = n, n.displayName = "lilypond", n.aliases = [];
+  function n(t) {
+    t.register(o), function(r) {
+      for (var e = /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source, i = 5, l = 0; l < i; l++)
+        e = e.replace(/<expr>/g, function() {
+          return e;
+        });
+      e = e.replace(/<expr>/g, /[^\s\S]/.source);
+      var a = r.languages.lilypond = {
+        comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/,
+        "embedded-scheme": {
+          pattern: RegExp(
+            /(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(
+              /<expr>/g,
+              function() {
+                return e;
+              }
+            ),
+            "m"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            scheme: {
+              pattern: /^(#)[\s\S]+$/,
+              lookbehind: !0,
+              alias: "language-scheme",
+              inside: {
+                "embedded-lilypond": {
+                  pattern: /#\{[\s\S]*?#\}/,
+                  greedy: !0,
+                  inside: {
+                    punctuation: /^#\{|#\}$/,
+                    lilypond: {
+                      pattern: /[\s\S]+/,
+                      alias: "language-lilypond",
+                      inside: null
+                      // see below
+                    }
+                  }
+                },
+                rest: r.languages.scheme
+              }
+            },
+            punctuation: /#/
+          }
+        },
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: !0
+        },
+        "class-name": {
+          pattern: /(\\new\s+)[\w-]+/,
+          lookbehind: !0
+        },
+        keyword: {
+          pattern: /\\[a-z][-\w]*/i,
+          inside: {
+            punctuation: /^\\/
+          }
+        },
+        operator: /[=|]|<<|>>/,
+        punctuation: {
+          pattern: /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,
+          lookbehind: !0
+        },
+        number: /\b\d+(?:\/\d+)?\b/
+      };
+      a["embedded-scheme"].inside.scheme.inside["embedded-lilypond"].inside.lilypond.inside = a, r.languages.ly = a;
+    }(t);
+  }
+  return s;
+}
+var p = y();
+const m = /* @__PURE__ */ u(p), h = /* @__PURE__ */ g({
+  __proto__: null,
+  default: m
+}, [p]);
+export {
+  h as l
+};

package/dist/liquid-5rAVI9Ad.js

@@ -0,0 +1,97 @@
+import { g as p } from "./index-Sj89RFCY.js";
+import { r as m } from "./markup-templating-CVTxtFGH.js";
+function f(n, i) {
+  for (var e = 0; e < i.length; e++) {
+    const t = i[e];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const a in t)
+        if (a !== "default" && !(a in n)) {
+          const r = Object.getOwnPropertyDescriptor(t, a);
+          r && Object.defineProperty(n, a, r.get ? r : {
+            enumerable: !0,
+            get: () => t[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var o, u;
+function g() {
+  if (u) return o;
+  u = 1;
+  var n = m();
+  o = i, i.displayName = "liquid", i.aliases = [];
+  function i(e) {
+    e.register(n), e.languages.liquid = {
+      comment: {
+        pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
+        lookbehind: !0
+      },
+      delimiter: {
+        pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+        alias: "punctuation"
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: !0
+      },
+      keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+      object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+      function: [
+        {
+          pattern: /(\|\s*)\w+/,
+          lookbehind: !0,
+          alias: "filter"
+        },
+        {
+          // array functions
+          pattern: /(\.\s*)(?:first|last|size)/,
+          lookbehind: !0
+        }
+      ],
+      boolean: /\b(?:false|nil|true)\b/,
+      range: {
+        pattern: /\.\./,
+        alias: "operator"
+      },
+      // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+      number: /\b\d+(?:\.\d+)?\b/,
+      operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+      punctuation: /[.,\[\]()]/,
+      empty: {
+        pattern: /\bempty\b/,
+        alias: "keyword"
+      }
+    }, e.hooks.add("before-tokenize", function(t) {
+      var a = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g, r = !1;
+      e.languages["markup-templating"].buildPlaceholders(
+        t,
+        "liquid",
+        a,
+        function(d) {
+          var l = /^\{%-?\s*(\w+)/.exec(d);
+          if (l) {
+            var s = l[1];
+            if (s === "raw" && !r)
+              return r = !0, !0;
+            if (s === "endraw")
+              return r = !1, !0;
+          }
+          return !r;
+        }
+      );
+    }), e.hooks.add("after-tokenize", function(t) {
+      e.languages["markup-templating"].tokenizePlaceholders(t, "liquid");
+    });
+  }
+  return o;
+}
+var c = g();
+const _ = /* @__PURE__ */ p(c), y = /* @__PURE__ */ f({
+  __proto__: null,
+  default: _
+}, [c]);
+export {
+  y as l
+};

package/dist/lisp-Btc3xid7.js

@@ -0,0 +1,194 @@
+import { g as k } from "./index-Sj89RFCY.js";
+function x(s, i) {
+  for (var r = 0; r < i.length; r++) {
+    const a = i[r];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const n in a)
+        if (n !== "default" && !(n in s)) {
+          const e = Object.getOwnPropertyDescriptor(a, n);
+          e && Object.defineProperty(s, n, e.get ? e : {
+            enumerable: !0,
+            get: () => a[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(s, Symbol.toStringTag, { value: "Module" }));
+}
+var g, m;
+function E() {
+  if (m) return g;
+  m = 1, g = s, s.displayName = "lisp", s.aliases = [];
+  function s(i) {
+    (function(r) {
+      function a(c) {
+        return RegExp(/(\()/.source + "(?:" + c + ")" + /(?=[\s\)])/.source);
+      }
+      function n(c) {
+        return RegExp(
+          /([\s([])/.source + "(?:" + c + ")" + /(?=[\s)])/.source
+        );
+      }
+      var e = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source, y = "&" + e, o = "(\\()", v = "(?=\\))", b = "(?=\\s)", l = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/.source, t = {
+        // Three or four semicolons are considered a heading.
+        // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html
+        heading: {
+          pattern: /;;;.*/,
+          alias: ["comment", "title"]
+        },
+        comment: /;.*/,
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: !0,
+          inside: {
+            argument: /[-A-Z]+(?=[.,\s])/,
+            symbol: RegExp("`" + e + "'")
+          }
+        },
+        "quoted-symbol": {
+          pattern: RegExp("#?'" + e),
+          alias: ["variable", "symbol"]
+        },
+        "lisp-property": {
+          pattern: RegExp(":" + e),
+          alias: "property"
+        },
+        splice: {
+          pattern: RegExp(",@?" + e),
+          alias: ["symbol", "variable"]
+        },
+        keyword: [
+          {
+            pattern: RegExp(
+              o + "(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)" + b
+            ),
+            lookbehind: !0
+          },
+          {
+            pattern: RegExp(
+              o + "(?:append|by|collect|concat|do|finally|for|in|return)" + b
+            ),
+            lookbehind: !0
+          }
+        ],
+        declare: {
+          pattern: a(/declare/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        interactive: {
+          pattern: a(/interactive/.source),
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        boolean: {
+          pattern: n(/nil|t/.source),
+          lookbehind: !0
+        },
+        number: {
+          pattern: n(/[-+]?\d+(?:\.\d*)?/.source),
+          lookbehind: !0
+        },
+        defvar: {
+          pattern: RegExp(o + "def(?:const|custom|group|var)\\s+" + e),
+          lookbehind: !0,
+          inside: {
+            keyword: /^def[a-z]+/,
+            variable: RegExp(e)
+          }
+        },
+        defun: {
+          pattern: RegExp(
+            o + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + e + /\s+\(/.source + l + /\)/.source
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            keyword: /^(?:cl-)?def\S+/,
+            // See below, this property needs to be defined later so that it can
+            // reference the language object.
+            arguments: null,
+            function: {
+              pattern: RegExp("(^\\s)" + e),
+              lookbehind: !0
+            },
+            punctuation: /[()]/
+          }
+        },
+        lambda: {
+          pattern: RegExp(
+            o + "lambda\\s+\\(\\s*(?:&?" + e + "(?:\\s+&?" + e + ")*\\s*)?\\)"
+          ),
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            keyword: /^lambda/,
+            // See below, this property needs to be defined later so that it can
+            // reference the language object.
+            arguments: null,
+            punctuation: /[()]/
+          }
+        },
+        car: {
+          pattern: RegExp(o + e),
+          lookbehind: !0
+        },
+        punctuation: [
+          // open paren, brackets, and close paren
+          /(?:['`,]?\(|[)\[\]])/,
+          // cons
+          {
+            pattern: /(\s)\.(?=\s)/,
+            lookbehind: !0
+          }
+        ]
+      }, u = {
+        "lisp-marker": RegExp(y),
+        varform: {
+          pattern: RegExp(
+            /\(/.source + e + /\s+(?=\S)/.source + l + /\)/.source
+          ),
+          inside: t
+        },
+        argument: {
+          pattern: RegExp(/(^|[\s(])/.source + e),
+          lookbehind: !0,
+          alias: "variable"
+        },
+        rest: t
+      }, p = "\\S+(?:\\s+\\S+)*", d = {
+        pattern: RegExp(o + l + v),
+        lookbehind: !0,
+        inside: {
+          "rest-vars": {
+            pattern: RegExp("&(?:body|rest)\\s+" + p),
+            inside: u
+          },
+          "other-marker-vars": {
+            pattern: RegExp("&(?:aux|optional)\\s+" + p),
+            inside: u
+          },
+          keys: {
+            pattern: RegExp("&key\\s+" + p + "(?:\\s+&allow-other-keys)?"),
+            inside: u
+          },
+          argument: {
+            pattern: RegExp(e),
+            alias: "variable"
+          },
+          punctuation: /[()]/
+        }
+      };
+      t.lambda.inside.arguments = d, t.defun.inside.arguments = r.util.clone(d), t.defun.inside.arguments.inside.sublist = d, r.languages.lisp = t, r.languages.elisp = t, r.languages.emacs = t, r.languages["emacs-lisp"] = t;
+    })(i);
+  }
+  return g;
+}
+var f = E();
+const R = /* @__PURE__ */ k(f), w = /* @__PURE__ */ x({
+  __proto__: null,
+  default: R
+}, [f]);
+export {
+  w as l
+};