@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/yaml-DsQF0ll0.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireYaml } from "./yaml-hSvfQRm2.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var yamlExports = requireYaml();
+const yaml = /* @__PURE__ */ getDefaultExportFromCjs(yamlExports);
+const yaml$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: yaml
+}, [yamlExports]);
+export {
+  yaml$1 as y
+};
+//# sourceMappingURL=yaml-DsQF0ll0.js.map

package/dist/yaml-DsQF0ll0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-DsQF0ll0.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/yaml-hSvfQRm2.js

@@ -0,0 +1,102 @@
+var yaml_1;
+var hasRequiredYaml;
+function requireYaml() {
+  if (hasRequiredYaml) return yaml_1;
+  hasRequiredYaml = 1;
+  yaml_1 = yaml;
+  yaml.displayName = "yaml";
+  yaml.aliases = ["yml"];
+  function yaml(Prism) {
+    (function(Prism2) {
+      var anchorOrAlias = /[*&][^\s[\]{},]+/;
+      var tag = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/;
+      var properties = "(?:" + tag.source + "(?:[ 	]+" + anchorOrAlias.source + ")?|" + anchorOrAlias.source + "(?:[ 	]+" + tag.source + ")?)";
+      var plainKey = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+        /<PLAIN>/g,
+        function() {
+          return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+        }
+      );
+      var string = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+      function createValuePattern(value, flags) {
+        flags = (flags || "").replace(/m/g, "") + "m";
+        var pattern = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+          return properties;
+        }).replace(/<<value>>/g, function() {
+          return value;
+        });
+        return RegExp(pattern, flags);
+      }
+      Prism2.languages.yaml = {
+        scalar: {
+          pattern: RegExp(
+            /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+              /<<prop>>/g,
+              function() {
+                return properties;
+              }
+            )
+          ),
+          lookbehind: true,
+          alias: "string"
+        },
+        comment: /#.*/,
+        key: {
+          pattern: RegExp(
+            /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+              return properties;
+            }).replace(/<<key>>/g, function() {
+              return "(?:" + plainKey + "|" + string + ")";
+            })
+          ),
+          lookbehind: true,
+          greedy: true,
+          alias: "atrule"
+        },
+        directive: {
+          pattern: /(^[ \t]*)%.+/m,
+          lookbehind: true,
+          alias: "important"
+        },
+        datetime: {
+          pattern: createValuePattern(
+            /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source
+          ),
+          lookbehind: true,
+          alias: "number"
+        },
+        boolean: {
+          pattern: createValuePattern(/false|true/.source, "i"),
+          lookbehind: true,
+          alias: "important"
+        },
+        null: {
+          pattern: createValuePattern(/null|~/.source, "i"),
+          lookbehind: true,
+          alias: "important"
+        },
+        string: {
+          pattern: createValuePattern(string),
+          lookbehind: true,
+          greedy: true
+        },
+        number: {
+          pattern: createValuePattern(
+            /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
+            "i"
+          ),
+          lookbehind: true
+        },
+        tag,
+        important: anchorOrAlias,
+        punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+      };
+      Prism2.languages.yml = Prism2.languages.yaml;
+    })(Prism);
+  }
+  return yaml_1;
+}
+export {
+  requireYaml as r
+};
+//# sourceMappingURL=yaml-hSvfQRm2.js.map

package/dist/yaml-hSvfQRm2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-hSvfQRm2.js","sources":["../node_modules/refractor/lang/yaml.js"],"sourcesContent":["'use strict'\n\nmodule.exports = yaml\nyaml.displayName = 'yaml'\nyaml.aliases = ['yml']\nfunction yaml(Prism) {\n  ;(function (Prism) {\n    // https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property\n    // https://yaml.org/spec/1.2/spec.html#c-ns-alias-node\n    var anchorOrAlias = /[*&][^\\s[\\]{},]+/ // https://yaml.org/spec/1.2/spec.html#c-ns-tag-property\n    var tag =\n      /!(?:<[\\w\\-%#;/?:@&=+$,.!~*'()[\\]]+>|(?:[a-zA-Z\\d-]*!)?[\\w\\-%#;/?:@&=+$.~*'()]+)?/ // https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)\n    var properties =\n      '(?:' +\n      tag.source +\n      '(?:[ \\t]+' +\n      anchorOrAlias.source +\n      ')?|' +\n      anchorOrAlias.source +\n      '(?:[ \\t]+' +\n      tag.source +\n      ')?)' // https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)\n    // This is a simplified version that doesn't support \"#\" and multiline keys\n    // All these long scarry character classes are simplified versions of YAML's characters\n    var plainKey =\n      /(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(\n        /<PLAIN>/g,\n        function () {\n          return /[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]/\n            .source\n        }\n      )\n    var string = /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'/.source\n    /**\n     *\n     * @param {string} value\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function createValuePattern(value, flags) {\n      flags = (flags || '').replace(/m/g, '') + 'm' // add m flag\n      var pattern =\n        /([:\\-,[{]\\s*(?:\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|\\]|\\}|(?:[\\r\\n]\\s*)?#))/.source\n          .replace(/<<prop>>/g, function () {\n            return properties\n          })\n          .replace(/<<value>>/g, function () {\n            return value\n          })\n      return RegExp(pattern, flags)\n    }\n    Prism.languages.yaml = {\n      scalar: {\n        pattern: RegExp(\n          /([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\S[^\\r\\n]*(?:\\2[^\\r\\n]+)*)/.source.replace(\n            /<<prop>>/g,\n            function () {\n              return properties\n            }\n          )\n        ),\n        lookbehind: true,\n        alias: 'string'\n      },\n      comment: /#.*/,\n      key: {\n        pattern: RegExp(\n          /((?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\s*:\\s)/.source\n            .replace(/<<prop>>/g, function () {\n              return properties\n            })\n            .replace(/<<key>>/g, function () {\n              return '(?:' + plainKey + '|' + string + ')'\n            })\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'atrule'\n      },\n      directive: {\n        pattern: /(^[ \\t]*)%.+/m,\n        lookbehind: true,\n        alias: 'important'\n      },\n      datetime: {\n        pattern: createValuePattern(\n          /\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?/\n            .source\n        ),\n        lookbehind: true,\n        alias: 'number'\n      },\n      boolean: {\n        pattern: createValuePattern(/false|true/.source, 'i'),\n        lookbehind: true,\n        alias: 'important'\n      },\n      null: {\n        pattern: createValuePattern(/null|~/.source, 'i'),\n        lookbehind: true,\n        alias: 'important'\n      },\n      string: {\n        pattern: createValuePattern(string),\n        lookbehind: true,\n        greedy: true\n      },\n      number: {\n        pattern: createValuePattern(\n          /[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)/\n            .source,\n          'i'\n        ),\n        lookbehind: true\n      },\n      tag: tag,\n      important: anchorOrAlias,\n      punctuation: /---|[:[\\]{}\\-,|>?]|\\.\\.\\./\n    }\n    Prism.languages.yml = Prism.languages.yaml\n  })(Prism)\n}\n"],"names":["Prism"],"mappings":";;;;;AAEA,WAAiB;AACjB,OAAK,cAAc;AACnB,OAAK,UAAU,CAAC,KAAK;AACrB,WAAS,KAAK,OAAO;AAClB,KAAC,SAAUA,QAAO;AAGjB,UAAI,gBAAgB;AACpB,UAAI,MACF;AACF,UAAI,aACF,QACA,IAAI,SACJ,aACA,cAAc,SACd,QACA,cAAc,SACd,aACA,IAAI,SACJ;AAGF,UAAI,WACF,kJAAkJ,OAAO;AAAA,QACvJ;AAAA,QACA,WAAY;AACV,iBAAO,2EACJ;AAAA,QACb;AAAA;AAEI,UAAI,SAAS,8CAA8C;AAO3D,eAAS,mBAAmB,OAAO,OAAO;AACxC,iBAAS,SAAS,IAAI,QAAQ,MAAM,EAAE,IAAI;AAC1C,YAAI,UACF,yFAAyF,OACtF,QAAQ,aAAa,WAAY;AAChC,iBAAO;AAAA,QACnB,CAAW,EACA,QAAQ,cAAc,WAAY;AACjC,iBAAO;AAAA,QACnB,CAAW;AACL,eAAO,OAAO,SAAS,KAAK;AAAA,MAClC;AACI,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,QAAQ;AAAA,UACN,SAAS;AAAA,YACP,6FAA6F,OAAO;AAAA,cAClG;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACrB;AAAA;;UAGQ,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,SAAS;AAAA,QACT,KAAK;AAAA,UACH,SAAS;AAAA,YACP,kEAAkE,OAC/D,QAAQ,aAAa,WAAY;AAChC,qBAAO;AAAA,YACrB,CAAa,EACA,QAAQ,YAAY,WAAY;AAC/B,qBAAO,QAAQ,WAAW,MAAM,SAAS;AAAA,YACvD,CAAa;AAAA;UAEL,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,WAAW;AAAA,UACT,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SAAS;AAAA,YACP,sJACG;AAAA;UAEL,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,SAAS;AAAA,UACP,SAAS,mBAAmB,aAAa,QAAQ,GAAG;AAAA,UACpD,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,MAAM;AAAA,UACJ,SAAS,mBAAmB,SAAS,QAAQ,GAAG;AAAA,UAChD,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,QAAQ;AAAA,UACN,SAAS,mBAAmB,MAAM;AAAA,UAClC,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,QAAQ;AAAA,UACN,SAAS;AAAA,YACP,iFACG;AAAA,YACH;AAAA;UAEF,YAAY;AAAA;QAEd;AAAA,QACA,WAAW;AAAA,QACX,aAAa;AAAA;AAEf,MAAAA,OAAM,UAAU,MAAMA,OAAM,UAAU;AAAA,IAC1C,GAAK,KAAK;AAAA,EACV;;;","x_google_ignoreList":[0]}

package/dist/yang-1vvc-BiB.js

@@ -0,0 +1,62 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var yang_1;
+var hasRequiredYang;
+function requireYang() {
+  if (hasRequiredYang) return yang_1;
+  hasRequiredYang = 1;
+  yang_1 = yang2;
+  yang2.displayName = "yang";
+  yang2.aliases = [];
+  function yang2(Prism) {
+    Prism.languages.yang = {
+      // https://tools.ietf.org/html/rfc6020#page-34
+      // http://www.yang-central.org/twiki/bin/view/Main/YangExamples
+      comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
+      string: {
+        pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
+        greedy: true
+      },
+      keyword: {
+        pattern: /(^|[{};\r\n][ \t]*)[a-z_][\w.-]*/i,
+        lookbehind: true
+      },
+      namespace: {
+        pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
+        lookbehind: true
+      },
+      boolean: /\b(?:false|true)\b/,
+      operator: /\+/,
+      punctuation: /[{};:]/
+    };
+  }
+  return yang_1;
+}
+var yangExports = requireYang();
+const yang = /* @__PURE__ */ getDefaultExportFromCjs(yangExports);
+const yang$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: yang
+}, [yangExports]);
+export {
+  yang$1 as y
+};
+//# sourceMappingURL=yang-1vvc-BiB.js.map

package/dist/yang-1vvc-BiB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yang-1vvc-BiB.js","sources":["../node_modules/refractor/lang/yang.js"],"sourcesContent":["'use strict'\n\nmodule.exports = yang\nyang.displayName = 'yang'\nyang.aliases = []\nfunction yang(Prism) {\n  Prism.languages.yang = {\n    // https://tools.ietf.org/html/rfc6020#page-34\n    // http://www.yang-central.org/twiki/bin/view/Main/YangExamples\n    comment: /\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*/,\n    string: {\n      pattern: /\"(?:[^\\\\\"]|\\\\.)*\"|'[^']*'/,\n      greedy: true\n    },\n    keyword: {\n      pattern: /(^|[{};\\r\\n][ \\t]*)[a-z_][\\w.-]*/i,\n      lookbehind: true\n    },\n    namespace: {\n      pattern: /(\\s)[a-z_][\\w.-]*(?=:)/i,\n      lookbehind: true\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    operator: /\\+/,\n    punctuation: /[{};:]/\n  }\n}\n"],"names":["yang"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO;AAAA;AAAA;AAAA,MAGrB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,WAAW;AAAA,QACT,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,SAAS;AAAA,MACT,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/zig-CpLbdj14.js

@@ -0,0 +1,134 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var zig_1;
+var hasRequiredZig;
+function requireZig() {
+  if (hasRequiredZig) return zig_1;
+  hasRequiredZig = 1;
+  zig_1 = zig2;
+  zig2.displayName = "zig";
+  zig2.aliases = [];
+  function zig2(Prism) {
+    (function(Prism2) {
+      function literal(str) {
+        return function() {
+          return str;
+        };
+      }
+      var keyword = /\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\b/;
+      var IDENTIFIER = "\\b(?!" + keyword.source + ")(?!\\d)\\w+\\b";
+      var ALIGN = /align\s*\((?:[^()]|\([^()]*\))*\)/.source;
+      var PREFIX_TYPE_OP = /(?:\?|\bpromise->|(?:\[[^[\]]*\]|\*(?!\*)|\*\*)(?:\s*<ALIGN>|\s*const\b|\s*volatile\b|\s*allowzero\b)*)/.source.replace(
+        /<ALIGN>/g,
+        literal(ALIGN)
+      );
+      var SUFFIX_EXPR = /(?:\bpromise\b|(?:\berror\.)?<ID>(?:\.<ID>)*(?!\s+<ID>))/.source.replace(
+        /<ID>/g,
+        literal(IDENTIFIER)
+      );
+      var TYPE = "(?!\\s)(?:!?\\s*(?:" + PREFIX_TYPE_OP + "\\s*)*" + SUFFIX_EXPR + ")+";
+      Prism2.languages.zig = {
+        comment: [
+          {
+            pattern: /\/\/[/!].*/,
+            alias: "doc-comment"
+          },
+          /\/{2}.*/
+        ],
+        string: [
+          {
+            // "string" and c"string"
+            pattern: /(^|[^\\@])c?"(?:[^"\\\r\n]|\\.)*"/,
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            // multiline strings and c-strings
+            pattern: /([\r\n])([ \t]+c?\\{2}).*(?:(?:\r\n?|\n)\2.*)*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        char: {
+          // characters 'a', '\n', '\xFF', '\u{10FFFF}'
+          pattern: /(^|[^\\])'(?:[^'\\\r\n]|[\uD800-\uDFFF]{2}|\\(?:.|x[a-fA-F\d]{2}|u\{[a-fA-F\d]{1,6}\}))'/,
+          lookbehind: true,
+          greedy: true
+        },
+        builtin: /\B@(?!\d)\w+(?=\s*\()/,
+        label: {
+          pattern: /(\b(?:break|continue)\s*:\s*)\w+\b|\b(?!\d)\w+\b(?=\s*:\s*(?:\{|while\b))/,
+          lookbehind: true
+        },
+        "class-name": [
+          // const Foo = struct {};
+          /\b(?!\d)\w+(?=\s*=\s*(?:(?:extern|packed)\s+)?(?:enum|struct|union)\s*[({])/,
+          {
+            // const x: i32 = 9;
+            // var x: Bar;
+            // fn foo(x: bool, y: f32) void {}
+            pattern: RegExp(
+              /(:\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?[=;,)])|<TYPE>(?=\s*(?:<ALIGN>\s*)?\{)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))
+            ),
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          {
+            // extern fn foo(x: f64) f64; (optional alignment)
+            pattern: RegExp(
+              /(\)\s*)<TYPE>(?=\s*(?:<ALIGN>\s*)?;)/.source.replace(/<TYPE>/g, literal(TYPE)).replace(/<ALIGN>/g, literal(ALIGN))
+            ),
+            lookbehind: true,
+            inside: null
+            // see below
+          }
+        ],
+        "builtin-type": {
+          pattern: /\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\b/,
+          alias: "keyword"
+        },
+        keyword,
+        function: /\b(?!\d)\w+(?=\s*\()/,
+        number: /\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\d]+(?:\.[a-fA-F\d]*)?(?:[pP][+-]?[a-fA-F\d]+)?|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)\b/,
+        boolean: /\b(?:false|true)\b/,
+        operator: /\.[*?]|\.{2,3}|[-=]>|\*\*|\+\+|\|\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,
+        punctuation: /[.:,;(){}[\]]/
+      };
+      Prism2.languages.zig["class-name"].forEach(function(obj) {
+        if (obj.inside === null) {
+          obj.inside = Prism2.languages.zig;
+        }
+      });
+    })(Prism);
+  }
+  return zig_1;
+}
+var zigExports = requireZig();
+const zig = /* @__PURE__ */ getDefaultExportFromCjs(zigExports);
+const zig$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: zig
+}, [zigExports]);
+export {
+  zig$1 as z
+};
+//# sourceMappingURL=zig-CpLbdj14.js.map

package/dist/zig-CpLbdj14.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zig-CpLbdj14.js","sources":["../node_modules/refractor/lang/zig.js"],"sourcesContent":["'use strict'\n\nmodule.exports = zig\nzig.displayName = 'zig'\nzig.aliases = []\nfunction zig(Prism) {\n  ;(function (Prism) {\n    function literal(str) {\n      return function () {\n        return str\n      }\n    }\n    var keyword =\n      /\\b(?:align|allowzero|and|anyframe|anytype|asm|async|await|break|cancel|catch|comptime|const|continue|defer|else|enum|errdefer|error|export|extern|fn|for|if|inline|linksection|nakedcc|noalias|nosuspend|null|or|orelse|packed|promise|pub|resume|return|stdcallcc|struct|suspend|switch|test|threadlocal|try|undefined|union|unreachable|usingnamespace|var|volatile|while)\\b/\n    var IDENTIFIER = '\\\\b(?!' + keyword.source + ')(?!\\\\d)\\\\w+\\\\b'\n    var ALIGN = /align\\s*\\((?:[^()]|\\([^()]*\\))*\\)/.source\n    var PREFIX_TYPE_OP =\n      /(?:\\?|\\bpromise->|(?:\\[[^[\\]]*\\]|\\*(?!\\*)|\\*\\*)(?:\\s*<ALIGN>|\\s*const\\b|\\s*volatile\\b|\\s*allowzero\\b)*)/.source.replace(\n        /<ALIGN>/g,\n        literal(ALIGN)\n      )\n    var SUFFIX_EXPR =\n      /(?:\\bpromise\\b|(?:\\berror\\.)?<ID>(?:\\.<ID>)*(?!\\s+<ID>))/.source.replace(\n        /<ID>/g,\n        literal(IDENTIFIER)\n      )\n    var TYPE =\n      '(?!\\\\s)(?:!?\\\\s*(?:' + PREFIX_TYPE_OP + '\\\\s*)*' + SUFFIX_EXPR + ')+'\n    /*\n     * A simplified grammar for Zig compile time type literals:\n     *\n     * TypeExpr = ( \"!\"? PREFIX_TYPE_OP* SUFFIX_EXPR )+\n     *\n     * SUFFIX_EXPR = ( \\b \"promise\" \\b | ( \\b \"error\" \".\" )? IDENTIFIER ( \".\" IDENTIFIER )* (?! \\s+ IDENTIFIER ) )\n     *\n     * PREFIX_TYPE_OP = \"?\"\n     *                | \\b \"promise\" \"->\"\n     *                | ( \"[\" [^\\[\\]]* \"]\" | \"*\" | \"**\" ) ( ALIGN | \"const\" \\b | \"volatile\" \\b | \"allowzero\" \\b )*\n     *\n     * ALIGN = \"align\" \"(\" ( [^()] | \"(\" [^()]* \")\" )* \")\"\n     *\n     * IDENTIFIER = \\b (?! KEYWORD ) [a-zA-Z_] \\w* \\b\n     *\n     */\n    Prism.languages.zig = {\n      comment: [\n        {\n          pattern: /\\/\\/[/!].*/,\n          alias: 'doc-comment'\n        },\n        /\\/{2}.*/\n      ],\n      string: [\n        {\n          // \"string\" and c\"string\"\n          pattern: /(^|[^\\\\@])c?\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"/,\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          // multiline strings and c-strings\n          pattern: /([\\r\\n])([ \\t]+c?\\\\{2}).*(?:(?:\\r\\n?|\\n)\\2.*)*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      char: {\n        // characters 'a', '\\n', '\\xFF', '\\u{10FFFF}'\n        pattern:\n          /(^|[^\\\\])'(?:[^'\\\\\\r\\n]|[\\uD800-\\uDFFF]{2}|\\\\(?:.|x[a-fA-F\\d]{2}|u\\{[a-fA-F\\d]{1,6}\\}))'/,\n        lookbehind: true,\n        greedy: true\n      },\n      builtin: /\\B@(?!\\d)\\w+(?=\\s*\\()/,\n      label: {\n        pattern:\n          /(\\b(?:break|continue)\\s*:\\s*)\\w+\\b|\\b(?!\\d)\\w+\\b(?=\\s*:\\s*(?:\\{|while\\b))/,\n        lookbehind: true\n      },\n      'class-name': [\n        // const Foo = struct {};\n        /\\b(?!\\d)\\w+(?=\\s*=\\s*(?:(?:extern|packed)\\s+)?(?:enum|struct|union)\\s*[({])/,\n        {\n          // const x: i32 = 9;\n          // var x: Bar;\n          // fn foo(x: bool, y: f32) void {}\n          pattern: RegExp(\n            /(:\\s*)<TYPE>(?=\\s*(?:<ALIGN>\\s*)?[=;,)])|<TYPE>(?=\\s*(?:<ALIGN>\\s*)?\\{)/.source\n              .replace(/<TYPE>/g, literal(TYPE))\n              .replace(/<ALIGN>/g, literal(ALIGN))\n          ),\n          lookbehind: true,\n          inside: null // see below\n        },\n        {\n          // extern fn foo(x: f64) f64; (optional alignment)\n          pattern: RegExp(\n            /(\\)\\s*)<TYPE>(?=\\s*(?:<ALIGN>\\s*)?;)/.source\n              .replace(/<TYPE>/g, literal(TYPE))\n              .replace(/<ALIGN>/g, literal(ALIGN))\n          ),\n          lookbehind: true,\n          inside: null // see below\n        }\n      ],\n      'builtin-type': {\n        pattern:\n          /\\b(?:anyerror|bool|c_u?(?:int|long|longlong|short)|c_longdouble|c_void|comptime_(?:float|int)|f(?:16|32|64|128)|[iu](?:8|16|32|64|128|size)|noreturn|type|void)\\b/,\n        alias: 'keyword'\n      },\n      keyword: keyword,\n      function: /\\b(?!\\d)\\w+(?=\\s*\\()/,\n      number:\n        /\\b(?:0b[01]+|0o[0-7]+|0x[a-fA-F\\d]+(?:\\.[a-fA-F\\d]*)?(?:[pP][+-]?[a-fA-F\\d]+)?|\\d+(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      operator:\n        /\\.[*?]|\\.{2,3}|[-=]>|\\*\\*|\\+\\+|\\|\\||(?:<<|>>|[-+*]%|[-+*/%^&|<>!=])=?|[?~]/,\n      punctuation: /[.:,;(){}[\\]]/\n    }\n    Prism.languages.zig['class-name'].forEach(function (obj) {\n      if (obj.inside === null) {\n        obj.inside = Prism.languages.zig\n      }\n    })\n  })(Prism)\n}\n"],"names":["zig","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AACjB,KAAC,SAAUC,QAAO;AACjB,eAAS,QAAQ,KAAK;AACpB,eAAO,WAAY;AACjB,iBAAO;AAAA,QACf;AAAA,MACA;AACI,UAAI,UACF;AACF,UAAI,aAAa,WAAW,QAAQ,SAAS;AAC7C,UAAI,QAAQ,oCAAoC;AAChD,UAAI,iBACF,0GAA0G,OAAO;AAAA,QAC/G;AAAA,QACA,QAAQ,KAAK;AAAA;AAEjB,UAAI,cACF,2DAA2D,OAAO;AAAA,QAChE;AAAA,QACA,QAAQ,UAAU;AAAA;AAEtB,UAAI,OACF,wBAAwB,iBAAiB,WAAW,cAAc;AAiBpE,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,SAAS;AAAA,UACP;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA;UAET;AAAA;QAEF,QAAQ;AAAA,UACN;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,MAAM;AAAA;AAAA,UAEJ,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,SAAS;AAAA,QACT,OAAO;AAAA,UACL,SACE;AAAA,UACF,YAAY;AAAA;QAEd,cAAc;AAAA;AAAA,UAEZ;AAAA,UACA;AAAA;AAAA;AAAA;AAAA,YAIE,SAAS;AAAA,cACP,0EAA0E,OACvE,QAAQ,WAAW,QAAQ,IAAI,CAAC,EAChC,QAAQ,YAAY,QAAQ,KAAK,CAAC;AAAA;YAEvC,YAAY;AAAA,YACZ,QAAQ;AAAA;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS;AAAA,cACP,uCAAuC,OACpC,QAAQ,WAAW,QAAQ,IAAI,CAAC,EAChC,QAAQ,YAAY,QAAQ,KAAK,CAAC;AAAA;YAEvC,YAAY;AAAA,YACZ,QAAQ;AAAA;AAAA;;QAGZ,gBAAgB;AAAA,UACd,SACE;AAAA,UACF,OAAO;AAAA;QAET;AAAA,QACA,UAAU;AAAA,QACV,QACE;AAAA,QACF,SAAS;AAAA,QACT,UACE;AAAA,QACF,aAAa;AAAA;AAEf,MAAAA,OAAM,UAAU,IAAI,YAAY,EAAE,QAAQ,SAAU,KAAK;AACvD,YAAI,IAAI,WAAW,MAAM;AACvB,cAAI,SAASA,OAAM,UAAU;AAAA,QACrC;AAAA,MACA,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@oscloudlab/knowledge-card",
-  "version": "0.0.1",
+  "type": "module",
+  "version": "0.0.3",
   "description": "A beautiful and customizable knowledge card component for React",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -13,7 +14,6 @@
     "build": "tsc && vite build",
     "build:lib": "vite build --mode lib",
     "preview": "vite preview",
-    "prepublishOnly": "npm run build:lib",
     "publish:npm": "npm publish"
   },
   "keywords": [
@@ -39,12 +39,39 @@
     "@types/react-dom": "^18.2.17",
     "@vitejs/plugin-react": "^4.2.1",
     "less": "^4.2.0",
+    "postcss": "^8.4.0",
+    "tailwindcss": "^3.3.0",
     "typescript": "^5.2.2",
     "vite": "^5.0.8",
     "vite-plugin-dts": "^3.6.4"
   },
   "dependencies": {
+    "@antv/x6": "^2.18.1",
+    "@antv/x6-plugin-clipboard": "^2.1.6",
+    "@antv/x6-plugin-dnd": "^2.1.1",
+    "@antv/x6-plugin-export": "^2.1.6",
+    "@antv/x6-plugin-history": "^2.2.4",
+    "@antv/x6-plugin-keyboard": "^2.2.3",
+    "@antv/x6-plugin-selection": "^2.2.2",
+    "@antv/x6-plugin-snapline": "^2.1.7",
+    "@antv/x6-plugin-transform": "^2.1.8",
+    "@monaco-editor/react": "^4.7.0",
+    "@tailwindcss/postcss": "^4.1.18",
+    "@wangeditor/editor": "^5.1.23",
+    "@wangeditor/editor-for-react": "^1.0.6",
+    "@wangeditor/plugin-md": "^1.0.0",
+    "aliyun-aliplayer": "^2.35.5",
+    "antd": "^6.1.4",
+    "autoprefixer": "^10.4.23",
+    "classnames": "^2.5.1",
+    "lucide-react": "^0.562.0",
+    "post-robot": "^10.0.46",
     "react": ">=16.8.0",
-    "react-dom": ">=16.8.0"
+    "react-code-blocks": "^0.1.6",
+    "react-dom": ">=16.8.0",
+    "react-markdown": "^10.1.0",
+    "uuid": "^13.0.0",
+    "vite-plugin-clean": "^2.0.1",
+    "vite-plugin-compression": "^0.5.1"
   }
 }