@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/markdown-BSMT-VS7.js

@@ -0,0 +1,403 @@
+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 markdown_1;
+var hasRequiredMarkdown;
+function requireMarkdown() {
+  if (hasRequiredMarkdown) return markdown_1;
+  hasRequiredMarkdown = 1;
+  markdown_1 = markdown2;
+  markdown2.displayName = "markdown";
+  markdown2.aliases = ["md"];
+  function markdown2(Prism) {
+    (function(Prism2) {
+      var inner = /(?:\\.|[^\\\n\r]|(?:\n|\r\n?)(?![\r\n]))/.source;
+      function createInline(pattern) {
+        pattern = pattern.replace(/<inner>/g, function() {
+          return inner;
+        });
+        return RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + "(?:" + pattern + ")");
+      }
+      var tableCell = /(?:\\.|``(?:[^`\r\n]|`(?!`))+``|`[^`\r\n]+`|[^\\|\r\n`])+/.source;
+      var tableRow = /\|?__(?:\|__)+\|?(?:(?:\n|\r\n?)|(?![\s\S]))/.source.replace(
+        /__/g,
+        function() {
+          return tableCell;
+        }
+      );
+      var tableLine = /\|?[ \t]*:?-{3,}:?[ \t]*(?:\|[ \t]*:?-{3,}:?[ \t]*)+\|?(?:\n|\r\n?)/.source;
+      Prism2.languages.markdown = Prism2.languages.extend("markup", {});
+      Prism2.languages.insertBefore("markdown", "prolog", {
+        "front-matter-block": {
+          pattern: /(^(?:\s*[\r\n])?)---(?!.)[\s\S]*?[\r\n]---(?!.)/,
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            punctuation: /^---|---$/,
+            "front-matter": {
+              pattern: /\S+(?:\s+\S+)*/,
+              alias: ["yaml", "language-yaml"],
+              inside: Prism2.languages.yaml
+            }
+          }
+        },
+        blockquote: {
+          // > ...
+          pattern: /^>(?:[\t ]*>)*/m,
+          alias: "punctuation"
+        },
+        table: {
+          pattern: RegExp(
+            "^" + tableRow + tableLine + "(?:" + tableRow + ")*",
+            "m"
+          ),
+          inside: {
+            "table-data-rows": {
+              pattern: RegExp(
+                "^(" + tableRow + tableLine + ")(?:" + tableRow + ")*$"
+              ),
+              lookbehind: true,
+              inside: {
+                "table-data": {
+                  pattern: RegExp(tableCell),
+                  inside: Prism2.languages.markdown
+                },
+                punctuation: /\|/
+              }
+            },
+            "table-line": {
+              pattern: RegExp("^(" + tableRow + ")" + tableLine + "$"),
+              lookbehind: true,
+              inside: {
+                punctuation: /\||:?-{3,}:?/
+              }
+            },
+            "table-header-row": {
+              pattern: RegExp("^" + tableRow + "$"),
+              inside: {
+                "table-header": {
+                  pattern: RegExp(tableCell),
+                  alias: "important",
+                  inside: Prism2.languages.markdown
+                },
+                punctuation: /\|/
+              }
+            }
+          }
+        },
+        code: [
+          {
+            // Prefixed by 4 spaces or 1 tab and preceded by an empty line
+            pattern: /((?:^|\n)[ \t]*\n|(?:^|\r\n?)[ \t]*\r\n?)(?: {4}|\t).+(?:(?:\n|\r\n?)(?: {4}|\t).+)*/,
+            lookbehind: true,
+            alias: "keyword"
+          },
+          {
+            // ```optional language
+            // code block
+            // ```
+            pattern: /^```[\s\S]*?^```$/m,
+            greedy: true,
+            inside: {
+              "code-block": {
+                pattern: /^(```.*(?:\n|\r\n?))[\s\S]+?(?=(?:\n|\r\n?)^```$)/m,
+                lookbehind: true
+              },
+              "code-language": {
+                pattern: /^(```).+/,
+                lookbehind: true
+              },
+              punctuation: /```/
+            }
+          }
+        ],
+        title: [
+          {
+            // title 1
+            // =======
+            // title 2
+            // -------
+            pattern: /\S.*(?:\n|\r\n?)(?:==+|--+)(?=[ \t]*$)/m,
+            alias: "important",
+            inside: {
+              punctuation: /==+$|--+$/
+            }
+          },
+          {
+            // # title 1
+            // ###### title 6
+            pattern: /(^\s*)#.+/m,
+            lookbehind: true,
+            alias: "important",
+            inside: {
+              punctuation: /^#+|#+$/
+            }
+          }
+        ],
+        hr: {
+          // ***
+          // ---
+          // * * *
+          // -----------
+          pattern: /(^\s*)([*-])(?:[\t ]*\2){2,}(?=\s*$)/m,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        list: {
+          // * item
+          // + item
+          // - item
+          // 1. item
+          pattern: /(^\s*)(?:[*+-]|\d+\.)(?=[\t ].)/m,
+          lookbehind: true,
+          alias: "punctuation"
+        },
+        "url-reference": {
+          // [id]: http://example.com "Optional title"
+          // [id]: http://example.com 'Optional title'
+          // [id]: http://example.com (Optional title)
+          // [id]: <http://example.com> "Optional title"
+          pattern: /!?\[[^\]]+\]:[\t ]+(?:\S+|<(?:\\.|[^>\\])+>)(?:[\t ]+(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\)))?/,
+          inside: {
+            variable: {
+              pattern: /^(!?\[)[^\]]+/,
+              lookbehind: true
+            },
+            string: /(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\((?:\\.|[^)\\])*\))$/,
+            punctuation: /^[\[\]!:]|[<>]/
+          },
+          alias: "url"
+        },
+        bold: {
+          // **strong**
+          // __strong__
+          // allow one nested instance of italic text using the same delimiter
+          pattern: createInline(
+            /\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\b|\*\*(?:(?!\*)<inner>|\*(?:(?!\*)<inner>)+\*)+\*\*/.source
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            content: {
+              pattern: /(^..)[\s\S]+(?=..$)/,
+              lookbehind: true,
+              inside: {}
+              // see below
+            },
+            punctuation: /\*\*|__/
+          }
+        },
+        italic: {
+          // *em*
+          // _em_
+          // allow one nested instance of bold text using the same delimiter
+          pattern: createInline(
+            /\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\b|\*(?:(?!\*)<inner>|\*\*(?:(?!\*)<inner>)+\*\*)+\*/.source
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            content: {
+              pattern: /(^.)[\s\S]+(?=.$)/,
+              lookbehind: true,
+              inside: {}
+              // see below
+            },
+            punctuation: /[*_]/
+          }
+        },
+        strike: {
+          // ~~strike through~~
+          // ~strike~
+          // eslint-disable-next-line regexp/strict
+          pattern: createInline(/(~~?)(?:(?!~)<inner>)+\2/.source),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            content: {
+              pattern: /(^~~?)[\s\S]+(?=\1$)/,
+              lookbehind: true,
+              inside: {}
+              // see below
+            },
+            punctuation: /~~?/
+          }
+        },
+        "code-snippet": {
+          // `code`
+          // ``code``
+          pattern: /(^|[^\\`])(?:``[^`\r\n]+(?:`[^`\r\n]+)*``(?!`)|`[^`\r\n]+`(?!`))/,
+          lookbehind: true,
+          greedy: true,
+          alias: ["code", "keyword"]
+        },
+        url: {
+          // [example](http://example.com "Optional title")
+          // [example][id]
+          // [example] [id]
+          pattern: createInline(
+            /!?\[(?:(?!\])<inner>)+\](?:\([^\s)]+(?:[\t ]+"(?:\\.|[^"\\])*")?\)|[ \t]?\[(?:(?!\])<inner>)+\])/.source
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            operator: /^!/,
+            content: {
+              pattern: /(^\[)[^\]]+(?=\])/,
+              lookbehind: true,
+              inside: {}
+              // see below
+            },
+            variable: {
+              pattern: /(^\][ \t]?\[)[^\]]+(?=\]$)/,
+              lookbehind: true
+            },
+            url: {
+              pattern: /(^\]\()[^\s)]+/,
+              lookbehind: true
+            },
+            string: {
+              pattern: /(^[ \t]+)"(?:\\.|[^"\\])*"(?=\)$)/,
+              lookbehind: true
+            }
+          }
+        }
+      });
+      ["url", "bold", "italic", "strike"].forEach(function(token) {
+        ["url", "bold", "italic", "strike", "code-snippet"].forEach(function(inside) {
+          if (token !== inside) {
+            Prism2.languages.markdown[token].inside.content.inside[inside] = Prism2.languages.markdown[inside];
+          }
+        });
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        if (env.language !== "markdown" && env.language !== "md") {
+          return;
+        }
+        function walkTokens(tokens) {
+          if (!tokens || typeof tokens === "string") {
+            return;
+          }
+          for (var i = 0, l = tokens.length; i < l; i++) {
+            var token = tokens[i];
+            if (token.type !== "code") {
+              walkTokens(token.content);
+              continue;
+            }
+            var codeLang = token.content[1];
+            var codeBlock = token.content[3];
+            if (codeLang && codeBlock && codeLang.type === "code-language" && codeBlock.type === "code-block" && typeof codeLang.content === "string") {
+              var lang = codeLang.content.replace(/\b#/g, "sharp").replace(/\b\+\+/g, "pp");
+              lang = (/[a-z][\w-]*/i.exec(lang) || [""])[0].toLowerCase();
+              var alias = "language-" + lang;
+              if (!codeBlock.alias) {
+                codeBlock.alias = [alias];
+              } else if (typeof codeBlock.alias === "string") {
+                codeBlock.alias = [codeBlock.alias, alias];
+              } else {
+                codeBlock.alias.push(alias);
+              }
+            }
+          }
+        }
+        walkTokens(env.tokens);
+      });
+      Prism2.hooks.add("wrap", function(env) {
+        if (env.type !== "code-block") {
+          return;
+        }
+        var codeLang = "";
+        for (var i = 0, l = env.classes.length; i < l; i++) {
+          var cls = env.classes[i];
+          var match = /language-(.+)/.exec(cls);
+          if (match) {
+            codeLang = match[1];
+            break;
+          }
+        }
+        var grammar = Prism2.languages[codeLang];
+        if (!grammar) {
+          if (codeLang && codeLang !== "none" && Prism2.plugins.autoloader) {
+            var id = "md-" + (/* @__PURE__ */ new Date()).valueOf() + "-" + Math.floor(Math.random() * 1e16);
+            env.attributes["id"] = id;
+            Prism2.plugins.autoloader.loadLanguages(codeLang, function() {
+              var ele = document.getElementById(id);
+              if (ele) {
+                ele.innerHTML = Prism2.highlight(
+                  ele.textContent,
+                  Prism2.languages[codeLang],
+                  codeLang
+                );
+              }
+            });
+          }
+        } else {
+          env.content = Prism2.highlight(
+            textContent(env.content.value),
+            grammar,
+            codeLang
+          );
+        }
+      });
+      var tagPattern = RegExp(Prism2.languages.markup.tag.pattern.source, "gi");
+      var KNOWN_ENTITY_NAMES = {
+        amp: "&",
+        lt: "<",
+        gt: ">",
+        quot: '"'
+      };
+      var fromCodePoint = String.fromCodePoint || String.fromCharCode;
+      function textContent(html) {
+        var text = html.replace(tagPattern, "");
+        text = text.replace(/&(\w{1,8}|#x?[\da-f]{1,8});/gi, function(m, code) {
+          code = code.toLowerCase();
+          if (code[0] === "#") {
+            var value;
+            if (code[1] === "x") {
+              value = parseInt(code.slice(2), 16);
+            } else {
+              value = Number(code.slice(1));
+            }
+            return fromCodePoint(value);
+          } else {
+            var known = KNOWN_ENTITY_NAMES[code];
+            if (known) {
+              return known;
+            }
+            return m;
+          }
+        });
+        return text;
+      }
+      Prism2.languages.md = Prism2.languages.markdown;
+    })(Prism);
+  }
+  return markdown_1;
+}
+var markdownExports = requireMarkdown();
+const markdown = /* @__PURE__ */ getDefaultExportFromCjs(markdownExports);
+const markdown$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: markdown
+}, [markdownExports]);
+export {
+  markdown$1 as m
+};
+//# sourceMappingURL=markdown-BSMT-VS7.js.map

package/dist/markdown-BSMT-VS7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-BSMT-VS7.js","sources":["../node_modules/refractor/lang/markdown.js"],"sourcesContent":["'use strict'\n\nmodule.exports = markdown\nmarkdown.displayName = 'markdown'\nmarkdown.aliases = ['md']\nfunction markdown(Prism) {\n  ;(function (Prism) {\n    // Allow only one line break\n    var inner = /(?:\\\\.|[^\\\\\\n\\r]|(?:\\n|\\r\\n?)(?![\\r\\n]))/.source\n    /**\n     * This function is intended for the creation of the bold or italic pattern.\n     *\n     * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.\n     *\n     * _Note:_ Keep in mind that this adds a capturing group.\n     *\n     * @param {string} pattern\n     * @returns {RegExp}\n     */\n    function createInline(pattern) {\n      pattern = pattern.replace(/<inner>/g, function () {\n        return inner\n      })\n      return RegExp(/((?:^|[^\\\\])(?:\\\\{2})*)/.source + '(?:' + pattern + ')')\n    }\n    var tableCell = /(?:\\\\.|``(?:[^`\\r\\n]|`(?!`))+``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+/\n      .source\n    var tableRow =\n      /\\|?__(?:\\|__)+\\|?(?:(?:\\n|\\r\\n?)|(?![\\s\\S]))/.source.replace(\n        /__/g,\n        function () {\n          return tableCell\n        }\n      )\n    var tableLine =\n      /\\|?[ \\t]*:?-{3,}:?[ \\t]*(?:\\|[ \\t]*:?-{3,}:?[ \\t]*)+\\|?(?:\\n|\\r\\n?)/\n        .source\n    Prism.languages.markdown = Prism.languages.extend('markup', {})\n    Prism.languages.insertBefore('markdown', 'prolog', {\n      'front-matter-block': {\n        pattern: /(^(?:\\s*[\\r\\n])?)---(?!.)[\\s\\S]*?[\\r\\n]---(?!.)/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          punctuation: /^---|---$/,\n          'front-matter': {\n            pattern: /\\S+(?:\\s+\\S+)*/,\n            alias: ['yaml', 'language-yaml'],\n            inside: Prism.languages.yaml\n          }\n        }\n      },\n      blockquote: {\n        // > ...\n        pattern: /^>(?:[\\t ]*>)*/m,\n        alias: 'punctuation'\n      },\n      table: {\n        pattern: RegExp(\n          '^' + tableRow + tableLine + '(?:' + tableRow + ')*',\n          'm'\n        ),\n        inside: {\n          'table-data-rows': {\n            pattern: RegExp(\n              '^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'\n            ),\n            lookbehind: true,\n            inside: {\n              'table-data': {\n                pattern: RegExp(tableCell),\n                inside: Prism.languages.markdown\n              },\n              punctuation: /\\|/\n            }\n          },\n          'table-line': {\n            pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'),\n            lookbehind: true,\n            inside: {\n              punctuation: /\\||:?-{3,}:?/\n            }\n          },\n          'table-header-row': {\n            pattern: RegExp('^' + tableRow + '$'),\n            inside: {\n              'table-header': {\n                pattern: RegExp(tableCell),\n                alias: 'important',\n                inside: Prism.languages.markdown\n              },\n              punctuation: /\\|/\n            }\n          }\n        }\n      },\n      code: [\n        {\n          // Prefixed by 4 spaces or 1 tab and preceded by an empty line\n          pattern:\n            /((?:^|\\n)[ \\t]*\\n|(?:^|\\r\\n?)[ \\t]*\\r\\n?)(?: {4}|\\t).+(?:(?:\\n|\\r\\n?)(?: {4}|\\t).+)*/,\n          lookbehind: true,\n          alias: 'keyword'\n        },\n        {\n          // ```optional language\n          // code block\n          // ```\n          pattern: /^```[\\s\\S]*?^```$/m,\n          greedy: true,\n          inside: {\n            'code-block': {\n              pattern: /^(```.*(?:\\n|\\r\\n?))[\\s\\S]+?(?=(?:\\n|\\r\\n?)^```$)/m,\n              lookbehind: true\n            },\n            'code-language': {\n              pattern: /^(```).+/,\n              lookbehind: true\n            },\n            punctuation: /```/\n          }\n        }\n      ],\n      title: [\n        {\n          // title 1\n          // =======\n          // title 2\n          // -------\n          pattern: /\\S.*(?:\\n|\\r\\n?)(?:==+|--+)(?=[ \\t]*$)/m,\n          alias: 'important',\n          inside: {\n            punctuation: /==+$|--+$/\n          }\n        },\n        {\n          // # title 1\n          // ###### title 6\n          pattern: /(^\\s*)#.+/m,\n          lookbehind: true,\n          alias: 'important',\n          inside: {\n            punctuation: /^#+|#+$/\n          }\n        }\n      ],\n      hr: {\n        // ***\n        // ---\n        // * * *\n        // -----------\n        pattern: /(^\\s*)([*-])(?:[\\t ]*\\2){2,}(?=\\s*$)/m,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      list: {\n        // * item\n        // + item\n        // - item\n        // 1. item\n        pattern: /(^\\s*)(?:[*+-]|\\d+\\.)(?=[\\t ].)/m,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      'url-reference': {\n        // [id]: http://example.com \"Optional title\"\n        // [id]: http://example.com 'Optional title'\n        // [id]: http://example.com (Optional title)\n        // [id]: <http://example.com> \"Optional title\"\n        pattern:\n          /!?\\[[^\\]]+\\]:[\\t ]+(?:\\S+|<(?:\\\\.|[^>\\\\])+>)(?:[\\t ]+(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\)))?/,\n        inside: {\n          variable: {\n            pattern: /^(!?\\[)[^\\]]+/,\n            lookbehind: true\n          },\n          string:\n            /(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\))$/,\n          punctuation: /^[\\[\\]!:]|[<>]/\n        },\n        alias: 'url'\n      },\n      bold: {\n        // **strong**\n        // __strong__\n        // allow one nested instance of italic text using the same delimiter\n        pattern: createInline(\n          /\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*/\n            .source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /(^..)[\\s\\S]+(?=..$)/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          punctuation: /\\*\\*|__/\n        }\n      },\n      italic: {\n        // *em*\n        // _em_\n        // allow one nested instance of bold text using the same delimiter\n        pattern: createInline(\n          /\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*/\n            .source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /(^.)[\\s\\S]+(?=.$)/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          punctuation: /[*_]/\n        }\n      },\n      strike: {\n        // ~~strike through~~\n        // ~strike~\n        // eslint-disable-next-line regexp/strict\n        pattern: createInline(/(~~?)(?:(?!~)<inner>)+\\2/.source),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /(^~~?)[\\s\\S]+(?=\\1$)/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          punctuation: /~~?/\n        }\n      },\n      'code-snippet': {\n        // `code`\n        // ``code``\n        pattern:\n          /(^|[^\\\\`])(?:``[^`\\r\\n]+(?:`[^`\\r\\n]+)*``(?!`)|`[^`\\r\\n]+`(?!`))/,\n        lookbehind: true,\n        greedy: true,\n        alias: ['code', 'keyword']\n      },\n      url: {\n        // [example](http://example.com \"Optional title\")\n        // [example][id]\n        // [example] [id]\n        pattern: createInline(\n          /!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)|[ \\t]?\\[(?:(?!\\])<inner>)+\\])/\n            .source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          operator: /^!/,\n          content: {\n            pattern: /(^\\[)[^\\]]+(?=\\])/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          variable: {\n            pattern: /(^\\][ \\t]?\\[)[^\\]]+(?=\\]$)/,\n            lookbehind: true\n          },\n          url: {\n            pattern: /(^\\]\\()[^\\s)]+/,\n            lookbehind: true\n          },\n          string: {\n            pattern: /(^[ \\t]+)\"(?:\\\\.|[^\"\\\\])*\"(?=\\)$)/,\n            lookbehind: true\n          }\n        }\n      }\n    })\n    ;['url', 'bold', 'italic', 'strike'].forEach(function (token) {\n      ;['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(function (\n        inside\n      ) {\n        if (token !== inside) {\n          Prism.languages.markdown[token].inside.content.inside[inside] =\n            Prism.languages.markdown[inside]\n        }\n      })\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      if (env.language !== 'markdown' && env.language !== 'md') {\n        return\n      }\n      function walkTokens(tokens) {\n        if (!tokens || typeof tokens === 'string') {\n          return\n        }\n        for (var i = 0, l = tokens.length; i < l; i++) {\n          var token = tokens[i]\n          if (token.type !== 'code') {\n            walkTokens(token.content)\n            continue\n          }\n          /*\n           * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token\n           * is optional. But the grammar is defined so that there is only one case we have to handle:\n           *\n           * token.content = [\n           *     <span class=\"punctuation\">```</span>,\n           *     <span class=\"code-language\">xxxx</span>,\n           *     '\\n', // exactly one new lines (\\r or \\n or \\r\\n)\n           *     <span class=\"code-block\">...</span>,\n           *     '\\n', // exactly one new lines again\n           *     <span class=\"punctuation\">```</span>\n           * ];\n           */\n          var codeLang = token.content[1]\n          var codeBlock = token.content[3]\n          if (\n            codeLang &&\n            codeBlock &&\n            codeLang.type === 'code-language' &&\n            codeBlock.type === 'code-block' &&\n            typeof codeLang.content === 'string'\n          ) {\n            // this might be a language that Prism does not support\n            // do some replacements to support C++, C#, and F#\n            var lang = codeLang.content\n              .replace(/\\b#/g, 'sharp')\n              .replace(/\\b\\+\\+/g, 'pp') // only use the first word\n            lang = (/[a-z][\\w-]*/i.exec(lang) || [''])[0].toLowerCase()\n            var alias = 'language-' + lang // add alias\n            if (!codeBlock.alias) {\n              codeBlock.alias = [alias]\n            } else if (typeof codeBlock.alias === 'string') {\n              codeBlock.alias = [codeBlock.alias, alias]\n            } else {\n              codeBlock.alias.push(alias)\n            }\n          }\n        }\n      }\n      walkTokens(env.tokens)\n    })\n    Prism.hooks.add('wrap', function (env) {\n      if (env.type !== 'code-block') {\n        return\n      }\n      var codeLang = ''\n      for (var i = 0, l = env.classes.length; i < l; i++) {\n        var cls = env.classes[i]\n        var match = /language-(.+)/.exec(cls)\n        if (match) {\n          codeLang = match[1]\n          break\n        }\n      }\n      var grammar = Prism.languages[codeLang]\n      if (!grammar) {\n        if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {\n          var id =\n            'md-' +\n            new Date().valueOf() +\n            '-' +\n            Math.floor(Math.random() * 1e16)\n          env.attributes['id'] = id\n          Prism.plugins.autoloader.loadLanguages(codeLang, function () {\n            var ele = document.getElementById(id)\n            if (ele) {\n              ele.innerHTML = Prism.highlight(\n                ele.textContent,\n                Prism.languages[codeLang],\n                codeLang\n              )\n            }\n          })\n        }\n      } else {\n        env.content = Prism.highlight(\n          textContent(env.content.value),\n          grammar,\n          codeLang\n        )\n      }\n    })\n    var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi')\n    /**\n     * A list of known entity names.\n     *\n     * This will always be incomplete to save space. The current list is the one used by lowdash's unescape function.\n     *\n     * @see {@link https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/unescape.js#L2}\n     */\n    var KNOWN_ENTITY_NAMES = {\n      amp: '&',\n      lt: '<',\n      gt: '>',\n      quot: '\"'\n    } // IE 11 doesn't support `String.fromCodePoint`\n    var fromCodePoint = String.fromCodePoint || String.fromCharCode\n    /**\n     * Returns the text content of a given HTML source code string.\n     *\n     * @param {string} html\n     * @returns {string}\n     */\n    function textContent(html) {\n      // remove all tags\n      var text = html.replace(tagPattern, '') // decode known entities\n      text = text.replace(/&(\\w{1,8}|#x?[\\da-f]{1,8});/gi, function (m, code) {\n        code = code.toLowerCase()\n        if (code[0] === '#') {\n          var value\n          if (code[1] === 'x') {\n            value = parseInt(code.slice(2), 16)\n          } else {\n            value = Number(code.slice(1))\n          }\n          return fromCodePoint(value)\n        } else {\n          var known = KNOWN_ENTITY_NAMES[code]\n          if (known) {\n            return known\n          } // unable to decode\n          return m\n        }\n      })\n      return text\n    }\n    Prism.languages.md = Prism.languages.markdown\n  })(Prism)\n}\n"],"names":["markdown","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/markup-Bqvqt98t.js

@@ -0,0 +1,215 @@
+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 markup_1 = markup;
+markup.displayName = "markup";
+markup.aliases = ["html", "mathml", "svg", "xml", "ssml", "atom", "rss"];
+function markup(Prism) {
+  Prism.languages.markup = {
+    comment: {
+      pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+      greedy: true
+    },
+    prolog: {
+      pattern: /<\?[\s\S]+?\?>/,
+      greedy: true
+    },
+    doctype: {
+      // https://www.w3.org/TR/xml/#NT-doctypedecl
+      pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+      greedy: true,
+      inside: {
+        "internal-subset": {
+          pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+          lookbehind: true,
+          greedy: true,
+          inside: null
+          // see below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: true
+        },
+        punctuation: /^<!|>$|[[\]]/,
+        "doctype-tag": /^DOCTYPE/i,
+        name: /[^\s<>'"]+/
+      }
+    },
+    cdata: {
+      pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+      greedy: true
+    },
+    tag: {
+      pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+      greedy: true,
+      inside: {
+        tag: {
+          pattern: /^<\/?[^\s>\/]+/,
+          inside: {
+            punctuation: /^<\/?/,
+            namespace: /^[^\s>\/:]+:/
+          }
+        },
+        "special-attr": [],
+        "attr-value": {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+          inside: {
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              /"|'/
+            ]
+          }
+        },
+        punctuation: /\/?>/,
+        "attr-name": {
+          pattern: /[^\s>\/]+/,
+          inside: {
+            namespace: /^[^\s>\/:]+:/
+          }
+        }
+      }
+    },
+    entity: [
+      {
+        pattern: /&[\da-z]{1,8};/i,
+        alias: "named-entity"
+      },
+      /&#x?[\da-f]{1,8};/i
+    ]
+  };
+  Prism.languages.markup["tag"].inside["attr-value"].inside["entity"] = Prism.languages.markup["entity"];
+  Prism.languages.markup["doctype"].inside["internal-subset"].inside = Prism.languages.markup;
+  Prism.hooks.add("wrap", function(env) {
+    if (env.type === "entity") {
+      env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
+    }
+  });
+  Object.defineProperty(Prism.languages.markup.tag, "addInlined", {
+    /**
+     * Adds an inlined language to markup.
+     *
+     * An example of an inlined language is CSS with `<style>` tags.
+     *
+     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addInlined('style', 'css');
+     */
+    value: function addInlined(tagName, lang) {
+      var includedCdataInside = {};
+      includedCdataInside["language-" + lang] = {
+        pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+        lookbehind: true,
+        inside: Prism.languages[lang]
+      };
+      includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
+      var inside = {
+        "included-cdata": {
+          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+          inside: includedCdataInside
+        }
+      };
+      inside["language-" + lang] = {
+        pattern: /[\s\S]+/,
+        inside: Prism.languages[lang]
+      };
+      var def = {};
+      def[tagName] = {
+        pattern: RegExp(
+          /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+            /__/g,
+            function() {
+              return tagName;
+            }
+          ),
+          "i"
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside
+      };
+      Prism.languages.insertBefore("markup", "cdata", def);
+    }
+  });
+  Object.defineProperty(Prism.languages.markup.tag, "addAttribute", {
+    /**
+     * Adds an pattern to highlight languages embedded in HTML attributes.
+     *
+     * An example of an inlined language is CSS with `style` attributes.
+     *
+     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addAttribute('style', 'css');
+     */
+    value: function(attrName, lang) {
+      Prism.languages.markup.tag.inside["special-attr"].push({
+        pattern: RegExp(
+          /(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+          "i"
+        ),
+        lookbehind: true,
+        inside: {
+          "attr-name": /^[^\s=]+/,
+          "attr-value": {
+            pattern: /=[\s\S]+/,
+            inside: {
+              value: {
+                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                lookbehind: true,
+                alias: [lang, "language-" + lang],
+                inside: Prism.languages[lang]
+              },
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                /"|'/
+              ]
+            }
+          }
+        }
+      });
+    }
+  });
+  Prism.languages.html = Prism.languages.markup;
+  Prism.languages.mathml = Prism.languages.markup;
+  Prism.languages.svg = Prism.languages.markup;
+  Prism.languages.xml = Prism.languages.extend("markup", {});
+  Prism.languages.ssml = Prism.languages.xml;
+  Prism.languages.atom = Prism.languages.xml;
+  Prism.languages.rss = Prism.languages.xml;
+}
+const markup_default = /* @__PURE__ */ getDefaultExportFromCjs(markup_1);
+const markup$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: markup_default
+}, [markup_1]);
+export {
+  markup_1 as a,
+  markup$1 as m
+};
+//# sourceMappingURL=markup-Bqvqt98t.js.map