@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/robotframework-fBSrPGHK.js

@@ -0,0 +1,122 @@
+import { g as k } from "./index-Sj89RFCY.js";
+function g(o, i) {
+  for (var n = 0; n < i.length; n++) {
+    const r = i[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const e in r)
+        if (e !== "default" && !(e in o)) {
+          const t = Object.getOwnPropertyDescriptor(r, e);
+          t && Object.defineProperty(o, e, t.get ? t : {
+            enumerable: !0,
+            get: () => r[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
+}
+var l, d;
+function y() {
+  if (d) return l;
+  d = 1, l = o, o.displayName = "robotframework", o.aliases = [];
+  function o(i) {
+    (function(n) {
+      var r = {
+        pattern: /(^[ \t]*| {2}|\t)#.*/m,
+        lookbehind: !0,
+        greedy: !0
+      }, e = {
+        pattern: /((?:^|[^\\])(?:\\{2})*)[$@&%]\{(?:[^{}\r\n]|\{[^{}\r\n]*\})*\}/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /^[$@&%]\{|\}$/
+        }
+      };
+      function t(b, m) {
+        var a = {};
+        a["section-header"] = {
+          pattern: /^ ?\*{3}.+?\*{3}/,
+          alias: "keyword"
+        };
+        for (var p in m)
+          a[p] = m[p];
+        return a.tag = {
+          pattern: /([\r\n](?: {2}|\t)[ \t]*)\[[-\w]+\]/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /\[|\]/
+          }
+        }, a.variable = e, a.comment = r, {
+          pattern: RegExp(
+            /^ ?\*{3}[ \t]*<name>[ \t]*\*{3}(?:.|[\r\n](?!\*{3}))*/.source.replace(
+              /<name>/g,
+              function() {
+                return b;
+              }
+            ),
+            "im"
+          ),
+          alias: "section",
+          inside: a
+        };
+      }
+      var s = {
+        pattern: /(\[Documentation\](?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
+        lookbehind: !0,
+        alias: "string"
+      }, u = {
+        pattern: /([\r\n] ?)(?!#)(?:\S(?:[ \t]\S)*)+/,
+        lookbehind: !0,
+        alias: "function",
+        inside: {
+          variable: e
+        }
+      }, c = {
+        pattern: /([\r\n](?: {2}|\t)[ \t]*)(?!\[|\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
+        lookbehind: !0,
+        inside: {
+          variable: e
+        }
+      };
+      n.languages.robotframework = {
+        settings: t("Settings", {
+          documentation: {
+            pattern: /([\r\n] ?Documentation(?: {2}|\t)[ \t]*)(?![ \t]|#)(?:.|(?:\r\n?|\n)[ \t]*\.{3})+/,
+            lookbehind: !0,
+            alias: "string"
+          },
+          property: {
+            pattern: /([\r\n] ?)(?!\.{3}|#)(?:\S(?:[ \t]\S)*)+/,
+            lookbehind: !0
+          }
+        }),
+        variables: t("Variables"),
+        "test-cases": t("Test Cases", {
+          "test-name": u,
+          documentation: s,
+          property: c
+        }),
+        keywords: t("Keywords", {
+          "keyword-name": u,
+          documentation: s,
+          property: c
+        }),
+        tasks: t("Tasks", {
+          "task-name": u,
+          documentation: s,
+          property: c
+        }),
+        comment: r
+      }, n.languages.robot = n.languages.robotframework;
+    })(i);
+  }
+  return l;
+}
+var f = y();
+const v = /* @__PURE__ */ k(f), h = /* @__PURE__ */ g({
+  __proto__: null,
+  default: v
+}, [f]);
+export {
+  h as r
+};

package/dist/ruby-BQlisu6i.js

@@ -0,0 +1,182 @@
+var i, s;
+function u() {
+  if (s) return i;
+  s = 1, i = r, r.displayName = "ruby", r.aliases = ["rb"];
+  function r(o) {
+    (function(e) {
+      e.languages.ruby = e.languages.extend("clike", {
+        comment: {
+          pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
+          greedy: !0
+        },
+        "class-name": {
+          pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /[.\\]/
+          }
+        },
+        keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
+        operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
+        punctuation: /[(){}[\].,;]/
+      }), e.languages.insertBefore("ruby", "operator", {
+        "double-colon": {
+          pattern: /::/,
+          alias: "punctuation"
+        }
+      });
+      var n = {
+        pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
+        lookbehind: !0,
+        inside: {
+          content: {
+            pattern: /^(#\{)[\s\S]+(?=\}$)/,
+            lookbehind: !0,
+            inside: e.languages.ruby
+          },
+          delimiter: {
+            pattern: /^#\{|\}$/,
+            alias: "punctuation"
+          }
+        }
+      };
+      delete e.languages.ruby.function;
+      var t = "(?:" + [
+        /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+        /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
+        /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
+        /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
+        /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
+      ].join("|") + ")", a = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
+      e.languages.insertBefore("ruby", "keyword", {
+        "regex-literal": [
+          {
+            pattern: RegExp(
+              /%r/.source + t + /[egimnosux]{0,6}/.source
+            ),
+            greedy: !0,
+            inside: {
+              interpolation: n,
+              regex: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
+            lookbehind: !0,
+            greedy: !0,
+            inside: {
+              interpolation: n,
+              regex: /[\s\S]+/
+            }
+          }
+        ],
+        variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
+        symbol: [
+          {
+            pattern: RegExp(/(^|[^:]):/.source + a),
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            pattern: RegExp(
+              /([\r\n{(,][ \t]*)/.source + a + /(?=:(?!:))/.source
+            ),
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        "method-definition": {
+          pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
+          lookbehind: !0,
+          inside: {
+            function: /\b\w+$/,
+            keyword: /^self\b/,
+            "class-name": /^\w+/,
+            punctuation: /\./
+          }
+        }
+      }), e.languages.insertBefore("ruby", "string", {
+        "string-literal": [
+          {
+            pattern: RegExp(/%[qQiIwWs]?/.source + t),
+            greedy: !0,
+            inside: {
+              interpolation: n,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
+            greedy: !0,
+            inside: {
+              interpolation: n,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+            alias: "heredoc-string",
+            greedy: !0,
+            inside: {
+              delimiter: {
+                pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
+                inside: {
+                  symbol: /\b\w+/,
+                  punctuation: /^<<[-~]?/
+                }
+              },
+              interpolation: n,
+              string: /[\s\S]+/
+            }
+          },
+          {
+            pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
+            alias: "heredoc-string",
+            greedy: !0,
+            inside: {
+              delimiter: {
+                pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
+                inside: {
+                  symbol: /\b\w+/,
+                  punctuation: /^<<[-~]?'|'$/
+                }
+              },
+              string: /[\s\S]+/
+            }
+          }
+        ],
+        "command-literal": [
+          {
+            pattern: RegExp(/%x/.source + t),
+            greedy: !0,
+            inside: {
+              interpolation: n,
+              command: {
+                pattern: /[\s\S]+/,
+                alias: "string"
+              }
+            }
+          },
+          {
+            pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
+            greedy: !0,
+            inside: {
+              interpolation: n,
+              command: {
+                pattern: /[\s\S]+/,
+                alias: "string"
+              }
+            }
+          }
+        ]
+      }), delete e.languages.ruby.string, e.languages.insertBefore("ruby", "number", {
+        builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
+        constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
+      }), e.languages.rb = e.languages.ruby;
+    })(o);
+  }
+  return i;
+}
+export {
+  u as r
+};

package/dist/ruby-DRrUXRqW.js

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

package/dist/rust-DhUR7ICB.js

@@ -0,0 +1,149 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function c(a, 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 a)) {
+          const s = Object.getOwnPropertyDescriptor(e, r);
+          s && Object.defineProperty(a, r, s.get ? s : {
+            enumerable: !0,
+            get: () => e[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var u, o;
+function d() {
+  if (o) return u;
+  o = 1, u = a, a.displayName = "rust", a.aliases = [];
+  function a(n) {
+    (function(t) {
+      for (var e = /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\//.source, r = 0; r < 2; r++)
+        e = e.replace(/<self>/g, function() {
+          return e;
+        });
+      e = e.replace(/<self>/g, function() {
+        return /[^\s\S]/.source;
+      }), t.languages.rust = {
+        comment: [
+          {
+            pattern: RegExp(/(^|[^\\])/.source + e),
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        string: {
+          pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
+          greedy: !0
+        },
+        char: {
+          pattern: /b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
+          greedy: !0
+        },
+        attribute: {
+          pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
+          greedy: !0,
+          alias: "attr-name",
+          inside: {
+            string: null
+            // see below
+          }
+        },
+        // Closure params should not be confused with bitwise OR |
+        "closure-params": {
+          pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            "closure-punctuation": {
+              pattern: /^\||\|$/,
+              alias: "punctuation"
+            },
+            rest: null
+            // see below
+          }
+        },
+        "lifetime-annotation": {
+          pattern: /'\w+/,
+          alias: "symbol"
+        },
+        "fragment-specifier": {
+          pattern: /(\$\w+:)[a-z]+/,
+          lookbehind: !0,
+          alias: "punctuation"
+        },
+        variable: /\$\w+/,
+        "function-definition": {
+          pattern: /(\bfn\s+)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        "type-definition": {
+          pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
+          lookbehind: !0,
+          alias: "class-name"
+        },
+        "module-declaration": [
+          {
+            pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
+            lookbehind: !0,
+            alias: "namespace"
+          },
+          {
+            pattern: /(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
+            lookbehind: !0,
+            alias: "namespace",
+            inside: {
+              punctuation: /::/
+            }
+          }
+        ],
+        keyword: [
+          // https://github.com/rust-lang/reference/blob/master/src/keywords.md
+          /\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
+          // primitives and str
+          // https://doc.rust-lang.org/stable/rust-by-example/primitives.html
+          /\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/
+        ],
+        // functions can technically start with an upper-case letter, but this will introduce a lot of false positives
+        // and Rust's naming conventions recommend snake_case anyway.
+        // https://doc.rust-lang.org/1.0.0/style/style/naming/README.html
+        function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
+        macro: {
+          pattern: /\b\w+!/,
+          alias: "property"
+        },
+        constant: /\b[A-Z_][A-Z_\d]+\b/,
+        "class-name": /\b[A-Z]\w*\b/,
+        namespace: {
+          pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
+          inside: {
+            punctuation: /::/
+          }
+        },
+        // Hex, oct, bin, dec numbers with visual separators and type suffix
+        number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
+        boolean: /\b(?:false|true)\b/,
+        punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
+        operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/
+      }, t.languages.rust["closure-params"].inside.rest = t.languages.rust, t.languages.rust.attribute.inside.string = t.languages.rust.string;
+    })(n);
+  }
+  return u;
+}
+var i = d();
+const p = /* @__PURE__ */ l(i), f = /* @__PURE__ */ c({
+  __proto__: null,
+  default: p
+}, [i]);
+export {
+  f as r
+};