@likec4/core 1.46.4 → 1.48.0

package/dist/_chunks/libs/natural-compare-lite.mjs

@@ -0,0 +1,42 @@
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+
+//#region ../../node_modules/.pnpm/natural-compare-lite@1.4.0/node_modules/natural-compare-lite/index.js
+var require_natural_compare_lite = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/*
+	* @version    1.4.0
+	* @date       2015-10-26
+	* @stability  3 - Stable
+	* @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+	* @license    MIT License
+	*/
+	var naturalCompare = function(a, b) {
+		var i, codeA, codeB = 1, posA = 0, posB = 0, alphabet = String.alphabet;
+		function getCode(str, pos, code) {
+			if (code) {
+				for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
+				return +str.slice(pos - 1, i);
+			}
+			code = alphabet && alphabet.indexOf(str.charAt(pos));
+			return code > -1 ? code + 76 : (code = str.charCodeAt(pos) || 0, code < 45 || code > 127) ? code : code < 46 ? 65 : code < 48 ? code - 1 : code < 58 ? code + 18 : code < 65 ? code - 11 : code < 91 ? code + 11 : code < 97 ? code - 37 : code < 123 ? code + 5 : code - 63;
+		}
+		if ((a += "") != (b += "")) for (; codeB;) {
+			codeA = getCode(a, posA++);
+			codeB = getCode(b, posB++);
+			if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+				codeA = getCode(a, posA, posA);
+				codeB = getCode(b, posB, posA = i);
+				posB = i;
+			}
+			if (codeA != codeB) return codeA < codeB ? -1 : 1;
+		}
+		return 0;
+	};
+	try {
+		module.exports = naturalCompare;
+	} catch (e) {
+		String.naturalCompare = naturalCompare;
+	}
+}));
+
+//#endregion
+export { require_natural_compare_lite as t };

package/dist/_chunks/libs/rehype-sanitize.mjs

@@ -0,0 +1,29 @@
+import { t as sanitize } from "./hast-util-sanitize.mjs";
+
+//#region ../../node_modules/.pnpm/rehype-sanitize@6.0.0/node_modules/rehype-sanitize/lib/index.js
+/**
+* @typedef {import('hast').Root} Root
+* @typedef {import('hast-util-sanitize').Schema} Schema
+*/
+/**
+* Sanitize HTML.
+*
+* @param {Schema | null | undefined} [options]
+*   Configuration (optional).
+* @returns
+*   Transform.
+*/
+function rehypeSanitize(options) {
+	/**
+	* @param {Root} tree
+	*   Tree.
+	* @returns {Root}
+	*   New tree.
+	*/
+	return function(tree) {
+		return sanitize(tree, options);
+	};
+}
+
+//#endregion
+export { rehypeSanitize as t };

package/dist/_chunks/libs/rehype-stringify.mjs

@@ -0,0 +1,34 @@
+import { t as toHtml } from "./hast-util-to-html.mjs";
+
+//#region ../../node_modules/.pnpm/rehype-stringify@10.0.1/node_modules/rehype-stringify/lib/index.js
+/**
+* @import {Root} from 'hast'
+* @import {Options} from 'hast-util-to-html'
+* @import {Compiler, Processor} from 'unified'
+*/
+/**
+* Plugin to add support for serializing as HTML.
+*
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {undefined}
+*   Nothing.
+*/
+function rehypeStringify(options) {
+	/** @type {Processor<undefined, undefined, undefined, Root, string>} */
+	const self = this;
+	const settings = {
+		...self.data("settings"),
+		...options
+	};
+	self.compiler = compiler;
+	/**
+	* @type {Compiler<Root, string>}
+	*/
+	function compiler(tree) {
+		return toHtml(tree, settings);
+	}
+}
+
+//#endregion
+export { rehypeStringify as t };

package/dist/_chunks/libs/remark-gfm.mjs

@@ -0,0 +1,36 @@
+import { n as gfmToMarkdown, t as gfmFromMarkdown } from "./mdast-util-gfm.mjs";
+import { t as gfm } from "./micromark-extension-gfm.mjs";
+
+//#region ../../node_modules/.pnpm/remark-gfm@4.0.1/node_modules/remark-gfm/lib/index.js
+/**
+* @import {Root} from 'mdast'
+* @import {Options} from 'remark-gfm'
+* @import {} from 'remark-parse'
+* @import {} from 'remark-stringify'
+* @import {Processor} from 'unified'
+*/
+/** @type {Options} */
+const emptyOptions = {};
+/**
+* Add support GFM (autolink literals, footnotes, strikethrough, tables,
+* tasklists).
+*
+* @param {Options | null | undefined} [options]
+*   Configuration (optional).
+* @returns {undefined}
+*   Nothing.
+*/
+function remarkGfm(options) {
+	const self = this;
+	const settings = options || emptyOptions;
+	const data = self.data();
+	const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
+	const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+	const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+	micromarkExtensions.push(gfm(settings));
+	fromMarkdownExtensions.push(gfmFromMarkdown());
+	toMarkdownExtensions.push(gfmToMarkdown(settings));
+}
+
+//#endregion
+export { remarkGfm as t };

package/dist/_chunks/libs/remark-github-blockquote-alert.mjs

@@ -0,0 +1,100 @@
+import { r as visit } from "./mdast-util-gfm.mjs";
+
+//#region ../../node_modules/.pnpm/remark-github-blockquote-alert@2.0.1/node_modules/remark-github-blockquote-alert/lib/index.js
+const alertRegex = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]/i;
+const alertLegacyRegex = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)(\/.*)?\]/i;
+/**
+* Alerts are a Markdown extension based on the blockquote syntax that you can use to emphasize critical information.
+* On GitHub, they are displayed with distinctive colors and icons to indicate the significance of the content.
+* https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#alerts
+*/
+const remarkAlert = ({ legacyTitle = false, tagName = "div" } = {}) => {
+	return (tree) => {
+		visit(tree, "blockquote", (node, index, parent) => {
+			let alertType = "";
+			let title = "";
+			let isNext = true;
+			let child = node.children.map((item) => {
+				if (isNext && item.type === "paragraph") {
+					const firstNode = item.children[0];
+					const text = firstNode.type === "text" ? firstNode.value : "";
+					const reg = legacyTitle ? alertLegacyRegex : alertRegex;
+					const match = text.match(reg);
+					if (match) {
+						isNext = false;
+						alertType = match[1].toLocaleLowerCase();
+						title = legacyTitle ? match[2] || alertType.toLocaleUpperCase() : alertType.toLocaleUpperCase();
+						if (text.includes("\n")) item.children[0] = {
+							type: "text",
+							value: text.replace(reg, "").replace(/^\n+/, "")
+						};
+						if (!text.includes("\n")) {
+							const itemChild = [];
+							item.children.forEach((item, idx) => {
+								if (idx == 0) return;
+								if (idx == 1 && item.type === "break") return;
+								itemChild.push(item);
+							});
+							item.children = [...itemChild];
+						}
+					}
+				}
+				return item;
+			});
+			if (!!alertType) {
+				node.data = {
+					hName: tagName,
+					hProperties: {
+						className: ["markdown-alert", `markdown-alert-${alertType}`],
+						dir: "auto"
+					}
+				};
+				child.unshift({
+					type: "paragraph",
+					children: [getAlertIcon(alertType), {
+						type: "text",
+						value: title.replace(/^\//, "")
+					}],
+					data: { hProperties: {
+						className: "markdown-alert-title",
+						dir: "auto"
+					} }
+				});
+			}
+			node.children = [...child];
+		});
+	};
+};
+function getAlertIcon(type) {
+	return {
+		type: "emphasis",
+		data: {
+			hName: "svg",
+			hProperties: {
+				className: ["octicon"],
+				viewBox: "0 0 16 16",
+				width: "16",
+				height: "16",
+				ariaHidden: "true"
+			}
+		},
+		children: [{
+			type: "emphasis",
+			data: {
+				hName: "path",
+				hProperties: { d: pathData[type] ?? "" }
+			},
+			children: []
+		}]
+	};
+}
+const pathData = {
+	note: "M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z",
+	tip: "M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z",
+	important: "M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z",
+	warning: "M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z",
+	caution: "M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"
+};
+
+//#endregion
+export { remarkAlert as t };

package/dist/_chunks/libs/remark-parse.mjs

@@ -0,0 +1,39 @@
+import { t as fromMarkdown } from "./mdast-util-from-markdown.mjs";
+
+//#region ../../node_modules/.pnpm/remark-parse@11.0.0/node_modules/remark-parse/lib/index.js
+/**
+* @typedef {import('mdast').Root} Root
+* @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions
+* @typedef {import('unified').Parser<Root>} Parser
+* @typedef {import('unified').Processor<Root>} Processor
+*/
+/**
+* @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options
+*/
+/**
+* Aadd support for parsing from markdown.
+*
+* @param {Readonly<Options> | null | undefined} [options]
+*   Configuration (optional).
+* @returns {undefined}
+*   Nothing.
+*/
+function remarkParse(options) {
+	/** @type {Processor} */
+	const self = this;
+	self.parser = parser;
+	/**
+	* @type {Parser}
+	*/
+	function parser(doc) {
+		return fromMarkdown(doc, {
+			...self.data("settings"),
+			...options,
+			extensions: self.data("micromarkExtensions") || [],
+			mdastExtensions: self.data("fromMarkdownExtensions") || []
+		});
+	}
+}
+
+//#endregion
+export { remarkParse as t };

package/dist/_chunks/libs/remark-rehype.mjs

@@ -0,0 +1,171 @@
+import { t as toHast } from "./mdast-util-to-hast.mjs";
+
+//#region ../../node_modules/.pnpm/remark-rehype@11.1.2/node_modules/remark-rehype/lib/index.js
+/**
+* @import {Root as HastRoot} from 'hast'
+* @import {Root as MdastRoot} from 'mdast'
+* @import {Options as ToHastOptions} from 'mdast-util-to-hast'
+* @import {Processor} from 'unified'
+* @import {VFile} from 'vfile'
+*/
+/**
+* @typedef {Omit<ToHastOptions, 'file'>} Options
+*
+* @callback TransformBridge
+*   Bridge-mode.
+*
+*   Runs the destination with the new hast tree.
+*   Discards result.
+* @param {MdastRoot} tree
+*   Tree.
+* @param {VFile} file
+*   File.
+* @returns {Promise<undefined>}
+*   Nothing.
+*
+* @callback TransformMutate
+*  Mutate-mode.
+*
+*  Further transformers run on the hast tree.
+* @param {MdastRoot} tree
+*   Tree.
+* @param {VFile} file
+*   File.
+* @returns {HastRoot}
+*   Tree (hast).
+*/
+/**
+* Turn markdown into HTML.
+*
+* ##### Notes
+*
+* ###### Signature
+*
+* * if a processor is given,
+*   runs the (rehype) plugins used on it with a hast tree,
+*   then discards the result (*bridge mode*)
+* * otherwise,
+*   returns a hast tree,
+*   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)
+*
+* > 👉 **Note**:
+* > It’s highly unlikely that you want to pass a `processor`.
+*
+* ###### HTML
+*
+* Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+* as semistandard `raw` nodes.
+* Most plugins ignore `raw` nodes but two notable ones don’t:
+*
+* * `rehype-stringify` also has an option `allowDangerousHtml` which will
+*   output the raw HTML.
+*   This is typically discouraged as noted by the option name but is useful if
+*   you completely trust authors
+* * `rehype-raw` can handle the raw embedded HTML strings by parsing them
+*   into standard hast nodes (`element`, `text`, etc);
+*   this is a heavy task as it needs a full HTML parser,
+*   but it is the only way to support untrusted content
+*
+* ###### Footnotes
+*
+* Many options supported here relate to footnotes.
+* Footnotes are not specified by CommonMark,
+* which we follow by default.
+* They are supported by GitHub,
+* so footnotes can be enabled in markdown with `remark-gfm`.
+*
+* The options `footnoteBackLabel` and `footnoteLabel` define natural language
+* that explains footnotes,
+* which is hidden for sighted users but shown to assistive technology.
+* When your page is not in English,
+* you must define translated values.
+*
+* Back references use ARIA attributes,
+* but the section label itself uses a heading that is hidden with an
+* `sr-only` class.
+* To show it to sighted users,
+* define different attributes in `footnoteLabelProperties`.
+*
+* ###### Clobbering
+*
+* Footnotes introduces a problem,
+* as it links footnote calls to footnote definitions on the page through `id`
+* attributes generated from user content,
+* which results in DOM clobbering.
+*
+* DOM clobbering is this:
+*
+* ```html
+* <p id=x></p>
+* <script>alert(x) // `x` now refers to the DOM `p#x` element<\/script>
+* ```
+*
+* Elements by their ID are made available by browsers on the `window` object,
+* which is a security risk.
+* Using a prefix solves this problem.
+*
+* More information on how to handle clobbering and the prefix is explained in
+* *Example: headings (DOM clobbering)* in `rehype-sanitize`.
+*
+* ###### Unknown nodes
+*
+* Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+* The default behavior for unknown nodes is:
+*
+* * when the node has a `value`
+*   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,
+*   see later),
+*   create a hast `text` node
+* * otherwise,
+*   create a `<div>` element (which could be changed with `data.hName`),
+*   with its children mapped from mdast to hast as well
+*
+* This behavior can be changed by passing an `unknownHandler`.
+*
+* @overload
+* @param {Processor} processor
+* @param {Readonly<Options> | null | undefined} [options]
+* @returns {TransformBridge}
+*
+* @overload
+* @param {Readonly<Options> | null | undefined} [options]
+* @returns {TransformMutate}
+*
+* @overload
+* @param {Readonly<Options> | Processor | null | undefined} [destination]
+* @param {Readonly<Options> | null | undefined} [options]
+* @returns {TransformBridge | TransformMutate}
+*
+* @param {Readonly<Options> | Processor | null | undefined} [destination]
+*   Processor or configuration (optional).
+* @param {Readonly<Options> | null | undefined} [options]
+*   When a processor was given,
+*   configuration (optional).
+* @returns {TransformBridge | TransformMutate}
+*   Transform.
+*/
+function remarkRehype(destination, options) {
+	if (destination && "run" in destination)
+ /**
+	* @type {TransformBridge}
+	*/
+	return async function(tree, file) {
+		const hastTree = toHast(tree, {
+			file,
+			...options
+		});
+		await destination.run(hastTree, file);
+	};
+	/**
+	* @type {TransformMutate}
+	*/
+	return function(tree, file) {
+		return toHast(tree, {
+			file,
+			...destination || options
+		});
+	};
+}
+
+//#endregion
+export { remarkRehype as t };