palettecn 0.1.0

package/dist/web/server/_libs/rehype-harden.mjs

@@ -0,0 +1,210 @@
+import { D as SKIP, E as visit } from "./@streamdown/math+[...].mjs";
+//#region ../../node_modules/.pnpm/rehype-harden@1.1.8/node_modules/rehype-harden/dist/index.js
+var BlockPolicy = {
+	indicator: "indicator",
+	textOnly: "text-only",
+	remove: "remove"
+};
+function harden({ defaultOrigin = "", allowedLinkPrefixes = [], allowedImagePrefixes = [], allowDataImages = false, allowedProtocols = [], blockedImageClass = "inline-block bg-gray-200 dark:bg-gray-700 text-gray-600 dark:text-gray-400 px-3 py-1 rounded text-sm", blockedLinkClass = "text-gray-500", linkBlockPolicy = BlockPolicy.indicator, imageBlockPolicy = BlockPolicy.indicator }) {
+	const hasSpecificLinkPrefixes = allowedLinkPrefixes.length && !allowedLinkPrefixes.every((p) => p === "*");
+	const hasSpecificImagePrefixes = allowedImagePrefixes.length && !allowedImagePrefixes.every((p) => p === "*");
+	if (!defaultOrigin && (hasSpecificLinkPrefixes || hasSpecificImagePrefixes)) throw new Error("defaultOrigin is required when allowedLinkPrefixes or allowedImagePrefixes are provided");
+	return (tree) => {
+		const visitor = createVisitor(defaultOrigin, allowedLinkPrefixes, allowedImagePrefixes, allowDataImages, allowedProtocols, blockedImageClass, blockedLinkClass, linkBlockPolicy, imageBlockPolicy);
+		stripNullChildren(tree);
+		visit(tree, visitor);
+	};
+}
+function parseUrl(url, defaultOrigin) {
+	if (typeof url !== "string") return null;
+	try {
+		return new URL(url);
+	} catch {
+		if (defaultOrigin) try {
+			return new URL(url, defaultOrigin);
+		} catch {
+			return null;
+		}
+		if (url.startsWith("/") || url.startsWith("./") || url.startsWith("../")) try {
+			return new URL(url, "http://example.com");
+		} catch {
+			return null;
+		}
+		return null;
+	}
+}
+function isPathRelativeUrl(url) {
+	if (typeof url !== "string") return false;
+	return url.startsWith("/") || url.startsWith("./") || url.startsWith("../");
+}
+var safeProtocols = new Set([
+	"https:",
+	"http:",
+	"irc:",
+	"ircs:",
+	"mailto:",
+	"xmpp:",
+	"blob:"
+]);
+var blockedProtocols = new Set([
+	"javascript:",
+	"data:",
+	"file:",
+	"vbscript:"
+]);
+function transformUrl(url, allowedPrefixes, defaultOrigin, allowDataImages = false, isImage = false, allowedProtocols = []) {
+	if (!url) return null;
+	if (typeof url === "string" && url.startsWith("#") && !isImage) try {
+		if (new URL(url, "http://example.com").hash === url) return url;
+	} catch {}
+	if (typeof url === "string" && url.startsWith("data:")) {
+		if (isImage && allowDataImages && url.startsWith("data:image/")) return url;
+		return null;
+	}
+	if (typeof url === "string" && url.startsWith("blob:")) {
+		try {
+			if (new URL(url).protocol === "blob:" && url.length > 5) {
+				const afterProtocol = url.substring(5);
+				if (afterProtocol && afterProtocol.length > 0 && afterProtocol !== "invalid") return url;
+			}
+		} catch {
+			return null;
+		}
+		return null;
+	}
+	const parsedUrl = parseUrl(url, defaultOrigin);
+	if (!parsedUrl) return null;
+	if (blockedProtocols.has(parsedUrl.protocol)) return null;
+	if (!(safeProtocols.has(parsedUrl.protocol) || allowedProtocols.includes(parsedUrl.protocol) || allowedProtocols.includes("*"))) return null;
+	if (parsedUrl.protocol === "mailto:" || !parsedUrl.protocol.match(/^https?:$/)) return parsedUrl.href;
+	const inputWasRelative = isPathRelativeUrl(url);
+	if (parsedUrl && allowedPrefixes.some((prefix) => {
+		const parsedPrefix = parseUrl(prefix, defaultOrigin);
+		if (!parsedPrefix) return false;
+		if (parsedPrefix.origin !== parsedUrl.origin) return false;
+		return parsedUrl.href.startsWith(parsedPrefix.href);
+	})) {
+		if (inputWasRelative) return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+		return parsedUrl.href;
+	}
+	if (allowedPrefixes.includes("*")) {
+		if (parsedUrl.protocol !== "https:" && parsedUrl.protocol !== "http:") return null;
+		if (inputWasRelative) return parsedUrl.pathname + parsedUrl.search + parsedUrl.hash;
+		return parsedUrl.href;
+	}
+	return null;
+}
+function stripNullChildren(node) {
+	if ("children" in node && Array.isArray(node.children)) {
+		node.children = node.children.filter((child) => child != null);
+		for (const child of node.children) stripNullChildren(child);
+	}
+}
+var SEEN = Symbol("node-seen");
+function resolveLinkBlockPolicy(node, policy, blockedLinkClass) {
+	if (policy === BlockPolicy.remove) return { type: "remove" };
+	if (policy === BlockPolicy.textOnly) return {
+		type: "replace",
+		element: {
+			type: "element",
+			tagName: "span",
+			properties: {},
+			children: [...node.children]
+		}
+	};
+	return {
+		type: "replace",
+		element: {
+			type: "element",
+			tagName: "span",
+			properties: {
+				title: "Blocked URL: " + String(node.properties.href),
+				class: blockedLinkClass
+			},
+			children: [...node.children, {
+				type: "text",
+				value: " [blocked]"
+			}]
+		}
+	};
+}
+function resolveImageBlockPolicy(node, policy, blockedImageClass) {
+	if (policy === BlockPolicy.remove) return { type: "remove" };
+	if (policy === BlockPolicy.textOnly) {
+		const altText = String(node.properties.alt || "");
+		if (!altText) return { type: "remove" };
+		return {
+			type: "replace",
+			element: {
+				type: "element",
+				tagName: "span",
+				properties: {},
+				children: [{
+					type: "text",
+					value: altText
+				}]
+			}
+		};
+	}
+	return {
+		type: "replace",
+		element: {
+			type: "element",
+			tagName: "span",
+			properties: { class: blockedImageClass },
+			children: [{
+				type: "text",
+				value: "[Image blocked: " + String(node.properties.alt || "No description") + "]"
+			}]
+		}
+	};
+}
+var createVisitor = (defaultOrigin, allowedLinkPrefixes, allowedImagePrefixes, allowDataImages, allowedProtocols, blockedImageClass, blockedLinkClass, linkBlockPolicy, imageBlockPolicy) => {
+	const visitor = (node, index, parent) => {
+		if (node.type !== "element" || node[SEEN]) return true;
+		if (node.tagName === "a") {
+			const transformedUrl = transformUrl(node.properties.href, allowedLinkPrefixes, defaultOrigin, false, false, allowedProtocols);
+			if (transformedUrl === null) {
+				node[SEEN] = true;
+				visit(node, visitor);
+				if (parent && typeof index === "number") {
+					const result = resolveLinkBlockPolicy(node, linkBlockPolicy, blockedLinkClass);
+					if (result.type === "remove") {
+						parent.children.splice(index, 1);
+						return [SKIP, index];
+					}
+					parent.children[index] = result.element;
+				}
+				return SKIP;
+			} else {
+				node.properties.href = transformedUrl;
+				node.properties.target = "_blank";
+				node.properties.rel = "noopener noreferrer";
+				return true;
+			}
+		}
+		if (node.tagName === "img") {
+			const transformedUrl = transformUrl(node.properties.src, allowedImagePrefixes, defaultOrigin, allowDataImages, true, allowedProtocols);
+			if (transformedUrl === null) {
+				node[SEEN] = true;
+				visit(node, visitor);
+				if (parent && typeof index === "number") {
+					const result = resolveImageBlockPolicy(node, imageBlockPolicy, blockedImageClass);
+					if (result.type === "remove") {
+						parent.children.splice(index, 1);
+						return [SKIP, index];
+					}
+					parent.children[index] = result.element;
+				}
+				return SKIP;
+			} else {
+				node.properties.src = transformedUrl;
+				return true;
+			}
+		}
+		return true;
+	};
+	return visitor;
+};
+//#endregion
+export { harden as t };

package/dist/web/server/_libs/rehype-raw.mjs

@@ -0,0 +1,37 @@
+import { t as raw } from "./hast-util-raw+[...].mjs";
+//#region ../../node_modules/.pnpm/rehype-raw@7.0.0/node_modules/rehype-raw/lib/index.js
+/**
+* @typedef {import('hast').Root} Root
+* @typedef {import('hast-util-raw').Options} RawOptions
+* @typedef {import('vfile').VFile} VFile
+*/
+/**
+* @typedef {Omit<RawOptions, 'file'>} Options
+*   Configuration.
+*/
+/**
+* Parse the tree (and raw nodes) again, keeping positional info okay.
+*
+* @param {Options | null | undefined}  [options]
+*   Configuration (optional).
+* @returns
+*   Transform.
+*/
+function rehypeRaw(options) {
+	/**
+	* @param {Root} tree
+	*   Tree.
+	* @param {VFile} file
+	*   File.
+	* @returns {Root}
+	*   New tree.
+	*/
+	return function(tree, file) {
+		return raw(tree, {
+			...options,
+			file
+		});
+	};
+}
+//#endregion
+export { rehypeRaw as t };

package/dist/web/server/_libs/rehype-sanitize.mjs

@@ -0,0 +1,27 @@
+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/web/server/_libs/remark-gfm.mjs

@@ -0,0 +1,34 @@
+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} */
+var 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/web/server/_libs/remark-parse.mjs

@@ -0,0 +1,37 @@
+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/web/server/_libs/remark-rehype.mjs

@@ -0,0 +1,169 @@
+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 };