@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/pascal-Dwf-aqDs.js

@@ -0,0 +1,95 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function d(r, e) {
+  for (var n = 0; n < e.length; n++) {
+    const a = e[n];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const t in a)
+        if (t !== "default" && !(t in r)) {
+          const i = Object.getOwnPropertyDescriptor(a, t);
+          i && Object.defineProperty(r, t, i.get ? i : {
+            enumerable: !0,
+            get: () => a[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var o, s;
+function p() {
+  if (s) return o;
+  s = 1, o = r, r.displayName = "pascal", r.aliases = ["objectpascal"];
+  function r(e) {
+    e.languages.pascal = {
+      directive: {
+        pattern: /\{\$[\s\S]*?\}/,
+        greedy: !0,
+        alias: ["marco", "property"]
+      },
+      comment: {
+        pattern: /\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/,
+        greedy: !0
+      },
+      string: {
+        pattern: /(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
+        greedy: !0
+      },
+      asm: {
+        pattern: /(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,
+        lookbehind: !0,
+        greedy: !0,
+        inside: null
+        // see below
+      },
+      keyword: [
+        {
+          // Turbo Pascal
+          pattern: /(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
+          lookbehind: !0
+        },
+        {
+          // Free Pascal
+          pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
+          lookbehind: !0
+        },
+        {
+          // Object Pascal
+          pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
+          lookbehind: !0
+        },
+        {
+          // Modifiers
+          pattern: /(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
+          lookbehind: !0
+        }
+      ],
+      number: [
+        // Hexadecimal, octal and binary
+        /(?:[&%]\d+|\$[a-f\d]+)/i,
+        // Decimal
+        /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i
+      ],
+      operator: [
+        /\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/,
+        {
+          pattern: /(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
+          lookbehind: !0
+        }
+      ],
+      punctuation: /\(\.|\.\)|[()\[\]:;,.]/
+    }, e.languages.pascal.asm.inside = e.languages.extend("pascal", {
+      asm: void 0,
+      keyword: void 0,
+      operator: void 0
+    }), e.languages.objectpascal = e.languages.pascal;
+  }
+  return o;
+}
+var l = p();
+const u = /* @__PURE__ */ c(l), b = /* @__PURE__ */ d({
+  __proto__: null,
+  default: u
+}, [l]);
+export {
+  b as p
+};

package/dist/pascaligo-DWTvG1fw.js

@@ -0,0 +1,115 @@
+import { g as b } from "./index-Sj89RFCY.js";
+function f(r, a) {
+  for (var o = 0; o < a.length; o++) {
+    const t = a[o];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const e in t)
+        if (e !== "default" && !(e in r)) {
+          const n = Object.getOwnPropertyDescriptor(t, e);
+          n && Object.defineProperty(r, e, n.get ? n : {
+            enumerable: !0,
+            get: () => t[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var s, u;
+function g() {
+  if (u) return s;
+  u = 1, s = r, r.displayName = "pascaligo", r.aliases = [];
+  function r(a) {
+    (function(o) {
+      var t = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source, e = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(
+        /<braces>/g,
+        function() {
+          return t;
+        }
+      ), n = o.languages.pascaligo = {
+        comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
+        string: {
+          pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
+          greedy: !0
+        },
+        "class-name": [
+          {
+            pattern: RegExp(
+              /(\btype\s+\w+\s+is\s+)<type>/.source.replace(
+                /<type>/g,
+                function() {
+                  return e;
+                }
+              ),
+              "i"
+            ),
+            lookbehind: !0,
+            inside: null
+            // see below
+          },
+          {
+            pattern: RegExp(
+              /<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
+                return e;
+              }),
+              "i"
+            ),
+            inside: null
+            // see below
+          },
+          {
+            pattern: RegExp(
+              /(:\s*)<type>/.source.replace(/<type>/g, function() {
+                return e;
+              })
+            ),
+            lookbehind: !0,
+            inside: null
+            // see below
+          }
+        ],
+        keyword: {
+          pattern: /(^|[^&])\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\b/i,
+          lookbehind: !0
+        },
+        boolean: {
+          pattern: /(^|[^&])\b(?:False|True)\b/i,
+          lookbehind: !0
+        },
+        builtin: {
+          pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
+          lookbehind: !0
+        },
+        function: /\b\w+(?=\s*\()/,
+        number: [
+          // Hexadecimal, octal and binary
+          /%[01]+|&[0-7]+|\$[a-f\d]+/i,
+          // Decimal
+          /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i
+        ],
+        operator: /->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,
+        punctuation: /\(\.|\.\)|[()\[\]:;,.{}]/
+      }, p = [
+        "comment",
+        "keyword",
+        "builtin",
+        "operator",
+        "punctuation"
+      ].reduce(function(i, c) {
+        return i[c] = n[c], i;
+      }, {});
+      n["class-name"].forEach(function(i) {
+        i.inside = p;
+      });
+    })(a);
+  }
+  return s;
+}
+var l = g();
+const d = /* @__PURE__ */ b(l), y = /* @__PURE__ */ f({
+  __proto__: null,
+  default: d
+}, [l]);
+export {
+  y as p
+};

package/dist/pcaxis-BUnNg5h_.js

@@ -0,0 +1,84 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function c(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const r = t[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const a in r)
+        if (a !== "default" && !(a in e)) {
+          const s = Object.getOwnPropertyDescriptor(r, a);
+          s && Object.defineProperty(e, a, s.get ? s : {
+            enumerable: !0,
+            get: () => r[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, i;
+function d() {
+  if (i) return o;
+  i = 1, o = e, e.displayName = "pcaxis", e.aliases = ["px"];
+  function e(t) {
+    t.languages.pcaxis = {
+      string: /"[^"]*"/,
+      keyword: {
+        pattern: /((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: {
+          keyword: /^[-A-Z\d]+/,
+          language: {
+            pattern: /^(\s*)\[[-\w]+\]/,
+            lookbehind: !0,
+            inside: {
+              punctuation: /^\[|\]$/,
+              property: /[-\w]+/
+            }
+          },
+          "sub-key": {
+            pattern: /^(\s*)\S[\s\S]*/,
+            lookbehind: !0,
+            inside: {
+              parameter: {
+                pattern: /"[^"]*"/,
+                alias: "property"
+              },
+              punctuation: /^\(|\)$|,/
+            }
+          }
+        }
+      },
+      operator: /=/,
+      tlist: {
+        pattern: /TLIST\s*\(\s*\w+(?:(?:\s*,\s*"[^"]*")+|\s*,\s*"[^"]*"-"[^"]*")?\s*\)/,
+        greedy: !0,
+        inside: {
+          function: /^TLIST/,
+          property: {
+            pattern: /^(\s*\(\s*)\w+/,
+            lookbehind: !0
+          },
+          string: /"[^"]*"/,
+          punctuation: /[(),]/,
+          operator: /-/
+        }
+      },
+      punctuation: /[;,]/,
+      number: {
+        pattern: /(^|\s)\d+(?:\.\d+)?(?!\S)/,
+        lookbehind: !0
+      },
+      boolean: /NO|YES/
+    }, t.languages.px = t.languages.pcaxis;
+  }
+  return o;
+}
+var p = d();
+const l = /* @__PURE__ */ u(p), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: l
+}, [p]);
+export {
+  f as p
+};

package/dist/peoplecode-CewkQs1u.js

@@ -0,0 +1,74 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function i(e, t) {
+  for (var n = 0; n < t.length; n++) {
+    const o = t[n];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const r in o)
+        if (r !== "default" && !(r in e)) {
+          const a = Object.getOwnPropertyDescriptor(o, r);
+          a && Object.defineProperty(e, r, a.get ? a : {
+            enumerable: !0,
+            get: () => o[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var l, c;
+function u() {
+  if (c) return l;
+  c = 1, l = e, e.displayName = "peoplecode", e.aliases = ["pcode"];
+  function e(t) {
+    t.languages.peoplecode = {
+      comment: RegExp(
+        [
+          // C-style multiline comments
+          /\/\*[\s\S]*?\*\//.source,
+          // REM comments
+          /\bREM[^;]*;/.source,
+          // Nested <* *> comments
+          /<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,
+          // /+ +/ comments
+          /\/\+[\s\S]*?\+\//.source
+        ].join("|")
+      ),
+      string: {
+        pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+        greedy: !0
+      },
+      variable: /%\w+/,
+      "function-definition": {
+        pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
+        lookbehind: !0,
+        alias: "function"
+      },
+      "class-name": {
+        pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
+        lookbehind: !0,
+        inside: {
+          punctuation: /:/
+        }
+      },
+      keyword: /\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\b/i,
+      "operator-keyword": {
+        pattern: /\b(?:and|not|or)\b/i,
+        alias: "operator"
+      },
+      function: /[_a-z]\w*(?=\s*\()/i,
+      boolean: /\b(?:false|true)\b/i,
+      number: /\b\d+(?:\.\d+)?\b/,
+      operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
+      punctuation: /[:.;,()[\]]/
+    }, t.languages.pcode = t.languages.peoplecode;
+  }
+  return l;
+}
+var p = u();
+const d = /* @__PURE__ */ s(p), b = /* @__PURE__ */ i({
+  __proto__: null,
+  default: d
+}, [p]);
+export {
+  b as p
+};

package/dist/perl-CmRi-uRU.js

@@ -0,0 +1,164 @@
+import { g as i } from "./index-Sj89RFCY.js";
+function d(r, o) {
+  for (var t = 0; t < o.length; t++) {
+    const e = o[t];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const s in e)
+        if (s !== "default" && !(s in r)) {
+          const n = Object.getOwnPropertyDescriptor(e, s);
+          n && Object.defineProperty(r, s, n.get ? n : {
+            enumerable: !0,
+            get: () => e[s]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var a, u;
+function c() {
+  if (u) return a;
+  u = 1, a = r, r.displayName = "perl", r.aliases = [];
+  function r(o) {
+    (function(t) {
+      var e = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
+      t.languages.perl = {
+        comment: [
+          {
+            // POD
+            pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            pattern: /(^|[^\\$])#.*/,
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        // TODO Could be nice to handle Heredoc too.
+        string: [
+          {
+            pattern: RegExp(
+              /\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+                // q/.../
+                /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+                // q a...a
+                // eslint-disable-next-line regexp/strict
+                /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+                // q(...)
+                // q{...}
+                // q[...]
+                // q<...>
+                e
+              ].join("|") + ")"
+            ),
+            greedy: !0
+          },
+          // "...", `...`
+          {
+            pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+            greedy: !0
+          },
+          // '...'
+          // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
+          {
+            pattern: /'(?:[^'\\\r\n]|\\.)*'/,
+            greedy: !0
+          }
+        ],
+        regex: [
+          {
+            pattern: RegExp(
+              /\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+                // m/.../
+                /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+                // m a...a
+                // eslint-disable-next-line regexp/strict
+                /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+                // m(...)
+                // m{...}
+                // m[...]
+                // m<...>
+                e
+              ].join("|") + ")" + /[msixpodualngc]*/.source
+            ),
+            greedy: !0
+          },
+          // The lookbehinds prevent -s from breaking
+          {
+            pattern: RegExp(
+              /(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+                // s/.../.../
+                // eslint-disable-next-line regexp/strict
+                /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+                // s a...a...a
+                // eslint-disable-next-line regexp/strict
+                /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
+                // s(...)(...)
+                // s{...}{...}
+                // s[...][...]
+                // s<...><...>
+                // s(...)[...]
+                e + /\s*/.source + e
+              ].join("|") + ")" + /[msixpodualngcer]*/.source
+            ),
+            lookbehind: !0,
+            greedy: !0
+          },
+          // /.../
+          // The look-ahead tries to prevent two divisions on
+          // the same line from being highlighted as regex.
+          // This does not support multi-line regex.
+          {
+            pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
+            greedy: !0
+          }
+        ],
+        // FIXME Not sure about the handling of ::, ', and #
+        variable: [
+          // ${^POSTMATCH}
+          /[&*$@%]\{\^[A-Z]+\}/,
+          // $^V
+          /[&*$@%]\^[A-Z_]/,
+          // ${...}
+          /[&*$@%]#?(?=\{)/,
+          // $foo
+          /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
+          // $1
+          /[&*$@%]\d+/,
+          // $_, @_, %!
+          // The negative lookahead prevents from breaking the %= operator
+          /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
+        ],
+        filehandle: {
+          // <>, <FOO>, _
+          pattern: /<(?![<=])\S*?>|\b_\b/,
+          alias: "symbol"
+        },
+        "v-string": {
+          // v1.2, 1.2.3
+          pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+          alias: "string"
+        },
+        function: {
+          pattern: /(\bsub[ \t]+)\w+/,
+          lookbehind: !0
+        },
+        keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+        number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+        operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
+        punctuation: /[{}[\];(),:]/
+      };
+    })(o);
+  }
+  return a;
+}
+var l = c();
+const p = /* @__PURE__ */ i(l), b = /* @__PURE__ */ d({
+  __proto__: null,
+  default: p
+}, [l]);
+export {
+  b as p
+};