@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/icu-message-format-CJA9loKb.js

@@ -0,0 +1,165 @@
+import { g as m } from "./index-Sj89RFCY.js";
+function f(s, n) {
+  for (var t = 0; t < n.length; t++) {
+    const e = n[t];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const r in e)
+        if (r !== "default" && !(r in s)) {
+          const a = Object.getOwnPropertyDescriptor(e, r);
+          a && Object.defineProperty(s, r, a.get ? a : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(s, Symbol.toStringTag, { value: "Module" }));
+}
+var i, g;
+function y() {
+  if (g) return i;
+  g = 1, i = s, s.displayName = "icuMessageFormat", s.aliases = [];
+  function s(n) {
+    (function(t) {
+      function e(l, c) {
+        return c <= 0 ? /[]/.source : l.replace(/<SELF>/g, function() {
+          return e(l, c - 1);
+        });
+      }
+      var r = /'[{}:=,](?:[^']|'')*'(?!')/, a = {
+        pattern: /''/,
+        greedy: !0,
+        alias: "operator"
+      }, p = {
+        pattern: r,
+        greedy: !0,
+        inside: {
+          escape: a
+        }
+      }, u = e(
+        /\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(
+          /<STR>/g,
+          function() {
+            return r.source;
+          }
+        ),
+        8
+      ), o = {
+        pattern: RegExp(u),
+        inside: {
+          message: {
+            pattern: /^(\{)[\s\S]+(?=\}$)/,
+            lookbehind: !0,
+            inside: null
+            // see below
+          },
+          "message-delimiter": {
+            pattern: /./,
+            alias: "punctuation"
+          }
+        }
+      };
+      t.languages["icu-message-format"] = {
+        argument: {
+          pattern: RegExp(u),
+          greedy: !0,
+          inside: {
+            content: {
+              pattern: /^(\{)[\s\S]+(?=\}$)/,
+              lookbehind: !0,
+              inside: {
+                "argument-name": {
+                  pattern: /^(\s*)[^{}:=,\s]+/,
+                  lookbehind: !0
+                },
+                "choice-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details
+                  pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: !0,
+                  inside: {
+                    punctuation: /\|/,
+                    range: {
+                      pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
+                      lookbehind: !0,
+                      inside: {
+                        operator: /[<#\u2264]/,
+                        number: /\S+/
+                      }
+                    },
+                    rest: null
+                    // see below
+                  }
+                },
+                "plural-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                  pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: !0,
+                  inside: {
+                    offset: /^offset:\s*\d+/,
+                    "nested-message": o,
+                    selector: {
+                      pattern: /=\d+|[^{}:=,\s]+/,
+                      inside: {
+                        keyword: /^(?:few|many|one|other|two|zero)$/
+                      }
+                    }
+                  }
+                },
+                "select-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                  pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: !0,
+                  inside: {
+                    "nested-message": o,
+                    selector: {
+                      pattern: /[^{}:=,\s]+/,
+                      inside: {
+                        keyword: /^other$/
+                      }
+                    }
+                  }
+                },
+                keyword: /\b(?:choice|plural|select|selectordinal)\b/,
+                "arg-type": {
+                  pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
+                  alias: "keyword"
+                },
+                "arg-skeleton": {
+                  pattern: /(,\s*)::[^{}:=,\s]+/,
+                  lookbehind: !0
+                },
+                "arg-style": {
+                  pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
+                  lookbehind: !0
+                },
+                "arg-style-text": {
+                  pattern: RegExp(
+                    /(^\s*,\s*(?=\S))/.source + e(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + "$"
+                  ),
+                  lookbehind: !0,
+                  alias: "string"
+                },
+                punctuation: /,/
+              }
+            },
+            "argument-delimiter": {
+              pattern: /./,
+              alias: "operator"
+            }
+          }
+        },
+        escape: a,
+        string: p
+      }, o.inside.message.inside = t.languages["icu-message-format"], t.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = t.languages["icu-message-format"];
+    })(n);
+  }
+  return i;
+}
+var d = y();
+const b = /* @__PURE__ */ m(d), h = /* @__PURE__ */ f({
+  __proto__: null,
+  default: b
+}, [d]);
+export {
+  h as i
+};

package/dist/idris-KG9ztadM.js

@@ -0,0 +1,51 @@
+import { g as d } from "./index-Sj89RFCY.js";
+import { r as u } from "./haskell-DR6jYji5.js";
+function p(t, r) {
+  for (var e = 0; e < r.length; e++) {
+    const i = r[e];
+    if (typeof i != "string" && !Array.isArray(i)) {
+      for (const a in i)
+        if (a !== "default" && !(a in t)) {
+          const o = Object.getOwnPropertyDescriptor(i, a);
+          o && Object.defineProperty(t, a, o.get ? o : {
+            enumerable: !0,
+            get: () => i[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var n, s;
+function c() {
+  if (s) return n;
+  s = 1;
+  var t = u();
+  n = r, r.displayName = "idris", r.aliases = ["idr"];
+  function r(e) {
+    e.register(t), e.languages.idris = e.languages.extend("haskell", {
+      comment: {
+        pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m
+      },
+      keyword: /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
+      builtin: void 0
+    }), e.languages.insertBefore("idris", "keyword", {
+      "import-statement": {
+        pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    }), e.languages.idr = e.languages.idris;
+  }
+  return n;
+}
+var l = c();
+const f = /* @__PURE__ */ d(l), b = /* @__PURE__ */ p({
+  __proto__: null,
+  default: f
+}, [l]);
+export {
+  b as i
+};

package/dist/iecst-wFMMjMpf.js

@@ -0,0 +1,65 @@
+import { g as o } from "./index-Sj89RFCY.js";
+function a(e, r) {
+  for (var E = 0; E < r.length; E++) {
+    const t = r[E];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const T in t)
+        if (T !== "default" && !(T in e)) {
+          const N = Object.getOwnPropertyDescriptor(t, T);
+          N && Object.defineProperty(e, T, N.get ? N : {
+            enumerable: !0,
+            get: () => t[T]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var O, s;
+function I() {
+  if (s) return O;
+  s = 1, O = e, e.displayName = "iecst", e.aliases = [];
+  function e(r) {
+    r.languages.iecst = {
+      comment: [
+        {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: !0,
+          greedy: !0
+        }
+      ],
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: !0
+      },
+      keyword: [
+        /\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,
+        /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/
+      ],
+      "class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+      address: {
+        pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+        alias: "symbol"
+      },
+      number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+      operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      punctuation: /[()[\].,;]/
+    };
+  }
+  return O;
+}
+var n = I();
+const R = /* @__PURE__ */ o(n), i = /* @__PURE__ */ a({
+  __proto__: null,
+  default: R
+}, [n]);
+export {
+  i
+};

package/dist/ignore-Byv4NN_B.js

@@ -0,0 +1,51 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function l(n, t) {
+  for (var e = 0; e < t.length; e++) {
+    const r = t[e];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const o in r)
+        if (o !== "default" && !(o in n)) {
+          const g = Object.getOwnPropertyDescriptor(r, o);
+          g && Object.defineProperty(n, o, g.get ? g : {
+            enumerable: !0,
+            get: () => r[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var a, i;
+function f() {
+  if (i) return a;
+  i = 1, a = n, n.displayName = "ignore", n.aliases = ["gitignore", "hgignore", "npmignore"];
+  function n(t) {
+    (function(e) {
+      e.languages.ignore = {
+        // https://git-scm.com/docs/gitignore
+        comment: /^#.*/m,
+        entry: {
+          pattern: /\S(?:.*(?:(?:\\ )|\S))?/,
+          alias: "string",
+          inside: {
+            operator: /^!|\*\*?|\?/,
+            regex: {
+              pattern: /(^|[^\\])\[[^\[\]]*\]/,
+              lookbehind: !0
+            },
+            punctuation: /\//
+          }
+        }
+      }, e.languages.gitignore = e.languages.ignore, e.languages.hgignore = e.languages.ignore, e.languages.npmignore = e.languages.ignore;
+    })(t);
+  }
+  return a;
+}
+var u = f();
+const p = /* @__PURE__ */ s(u), d = /* @__PURE__ */ l({
+  __proto__: null,
+  default: p
+}, [u]);
+export {
+  d as i
+};