@temelj/mdx 0.14.0 → 0.15.0

package/dist/html-lower.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-lower.d.mts","names":[],"sources":["../src/html-lower.ts"],"mappings":";;;;;iBAsCiB;WACN;WACA;WACA,+BAEH,wBAAwB;WACrB;WACA;;WAEA,SAAS;;;;;WAKT,gBACP,aACA,wBACA;;;;;;;iBASa;WACN,OAAO,QAAQ,SAAS;WACxB,OAAO,QAAQ,SAAS;;WAExB,OAAO,QAAQ,cAAc;;;UAI9B;WACC;WACA;WACA;WACA;WACA,UAAU;;wBAGL,2BAA2B;;;;;iBAQ1B;WACN,aAAa,uBAAuB;WACpC,WAAW,uBAAuB;WAClC,SAAS;;WAET,aAAa,MAAM,0BAA0B;;WAE7C;WACA,QAAQ;;WAER,WAAW,MAAM,qBAAqB;;KAU5C,cAAc,oBAAoB;wBAYvB,UAAU,UAAU,cAAc,UAAS,oBAAyB;;;;;wBAgCpE,WACd,gBAAgB,WAChB,OAAO,eACP,WAAW,UACV;;wBAKa,WAAW,gBAAgB,aAAa;;wBAKxC,mBAAmB,MAAM,UAAU;;wBA8TnC,qBACd,WAAW,mBACX,OAAO,gBACN;;UAwQO;WACC,oBAAoB;WACpB,eAAe;WACf;;wBAwQK,YACd,eACA,SAAS,mBACT"}

package/dist/html-lower.mjs

@@ -0,0 +1,583 @@
+import { FootnoteNumbering } from "./footnote-numbering.mjs";
+import { indexDocument, mdxChildren } from "./model.mjs";
+import { formatMdx } from "./format.mjs";
+import { isUrlControlCharacter, normalizeUri } from "./uri.mjs";
+import { isFunction } from "@temelj/value";
+//#region src/html-lower.ts
+function createHtmlLoweringCache() {
+	return {
+		loose: /* @__PURE__ */ new WeakMap(),
+		tight: /* @__PURE__ */ new WeakMap(),
+		lists: /* @__PURE__ */ new WeakMap()
+	};
+}
+const percentEncodedByteLength = 2;
+const hexadecimalRadix = 16;
+const percentEncodedByte = /^[0-9A-Fa-f]{2}$/u;
+const linkSchemes = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"irc",
+	"ircs",
+	"mailto",
+	"xmpp"
+]);
+const imageSchemes = /* @__PURE__ */ new Set(["http", "https"]);
+function lowerHtml(document, options = {}) {
+	const index = indexDocument(document);
+	const numbering = new FootnoteNumbering();
+	const occurrences = /* @__PURE__ */ new Map();
+	for (const reference of footnoteReferences(document)) if (index.footnotes.has(reference.identifier)) occurrences.set(reference, numbering.reference(reference.identifier));
+	const scope = {
+		definition: (identifier) => index.definitions.get(identifier),
+		footnote: (identifier) => index.footnotes.get(identifier),
+		options,
+		occurrence: (node) => occurrences.get(node)
+	};
+	const children = lowerNodes(document.children, scope);
+	const footnotes = lowerFootnoteSection(numbering, scope);
+	if (footnotes !== void 0) children.push(footnotes);
+	return {
+		kind: "root",
+		children: joinBlocks(children),
+		origin: document.origin
+	};
+}
+/**
+* Lowers sibling nodes in one scope. `previous` is the sibling before them,
+* because text after a hard break drops its leading spaces.
+*/
+function lowerNodes(nodes, scope, previous) {
+	return lowerChildren(nodes, {
+		scope,
+		listLoose: false,
+		volatile: { count: 0 }
+	}, previous);
+}
+/** Separates top-level blocks with line endings, like a document root. */
+function joinBlocks(nodes) {
+	return wrap(nodes, false);
+}
+/** Footnote reference nodes in document order. */
+function footnoteReferences(node) {
+	const result = [];
+	const visit = (current) => {
+		if (current.kind === "footnoteReference") result.push(current);
+		mdxChildren(current).forEach(visit);
+	};
+	visit(node);
+	return result;
+}
+function lowerHtmlNode(node, context) {
+	const replaced = context.scope.replace?.(node);
+	if (replaced !== void 0) {
+		context.volatile.count++;
+		return replaced;
+	}
+	const cache = context.listLoose ? context.scope.cache?.loose : context.scope.cache?.tight;
+	if (cache?.has(node) === true) return cache.get(node);
+	const volatile = context.volatile.count;
+	const lowered = lowerHtmlNodeCore(node, context);
+	const result = lowered === void 0 || node.origin === void 0 ? lowered : isHtmlNodeArray(lowered) ? lowered.map((item) => withOrigin(item, node.origin)) : withOrigin(lowered, node.origin);
+	if (context.volatile.count === volatile) cache?.set(node, result);
+	return result;
+}
+function isHtmlNodeArray(value) {
+	return Array.isArray(value);
+}
+function withOrigin(node, origin) {
+	return origin === void 0 || node.origin !== void 0 ? node : {
+		...node,
+		origin
+	};
+}
+/** Authored source when the file is known, otherwise canonical MDX. */
+function authored(node, context) {
+	const source = context.scope.options.source;
+	return source !== void 0 && node.origin !== void 0 ? source.slice(node.origin) : formatMdx(node);
+}
+function lowerHtmlNodeCore(node, context) {
+	switch (node.kind) {
+		case "text": return text(node.value);
+		case "emphasis": return htmlElement("em", node.children, context);
+		case "strong": return htmlElement("strong", node.children, context);
+		case "delete": return htmlElement("del", node.children, context);
+		case "directiveLabel": return lowerChildren(node.children, context);
+		case "textDirective": return lowerTextDirective(node, context);
+		case "inlineCode": return element("code", {}, [text(node.value.replace(/\r\n?|\n/gu, " "))]);
+		case "inlineMath": return {
+			kind: "math",
+			source: node.value.replace(/\r\n?|\n/gu, " "),
+			style: "inline"
+		};
+		case "hardBreak": return [element("br"), text("\n")];
+		case "link": return lowerLink(node.url, node.title, node.children, context);
+		case "linkReference": {
+			const definition = context.scope.definition(node.identifier);
+			if (definition !== void 0) return lowerLink(definition.url, definition.title, node.children, context);
+			return context.scope.provisional === true ? unresolvedReference("link", node, lowerChildren(node.children, context), context) : revertReference(node, context);
+		}
+		case "image": return lowerImage(node.url, node.alt, node.title, context);
+		case "imageReference": {
+			const definition = context.scope.definition(node.identifier);
+			if (definition !== void 0) return lowerImage(definition.url, node.alt, definition.title, context);
+			return context.scope.provisional === true ? unresolvedReference("image", node, [text(node.alt)], context) : text(formatMdx(node));
+		}
+		case "footnoteReference": {
+			context.volatile.count++;
+			const occurrence = context.scope.occurrence(node);
+			if (occurrence !== void 0) return lowerFootnoteReference(node, occurrence, context.scope.options);
+			return context.scope.provisional === true ? unresolvedReference("footnote", node, [], context) : text(formatMdx(node));
+		}
+		case "definition":
+		case "footnoteDefinition":
+		case "frontmatter":
+		case "esm": return;
+		case "leafDirective": return lowerLeafDirective(node, context);
+		case "containerDirective": return lowerContainerDirective(node, context);
+		case "rawHtmlBlock":
+		case "rawHtmlInline": return {
+			kind: "raw",
+			value: node.value
+		};
+		case "inlineExpression":
+		case "blockExpression": return {
+			kind: "expression",
+			code: node.code,
+			fallback: authored(node, context)
+		};
+		case "jsxTextElement":
+		case "jsxFlowElement": return {
+			kind: "jsx",
+			state: "complete",
+			element: node.kind === "jsxFlowElement" ? "flow" : "text",
+			name: node.name,
+			attributes: node.attributes,
+			fallback: authored(node, context),
+			children: lowerChildren(node.children, context)
+		};
+		case "paragraph": return node.children.every(isEmbeddedPhrasing) && node.children.some((child) => child.kind !== "text") ? lowerChildren(node.children, context) : htmlElement("p", node.children, context);
+		case "heading": return htmlElement(`h${node.depth}`, node.children, context);
+		case "codeBlock": {
+			const language = node.language?.trim().split(/\s+/u)[0];
+			return language === void 0 || language.length === 0 ? element("pre", {}, [element("code", {}, [text(node.value.length === 0 ? "" : `${node.value}\n`)])]) : {
+				kind: "codeBlock",
+				code: node.value,
+				language,
+				meta: node.meta
+			};
+		}
+		case "displayMath": return {
+			kind: "math",
+			source: node.value,
+			style: "display",
+			meta: node.meta
+		};
+		case "thematicBreak": return element("hr");
+		case "list": return lowerList(node, context);
+		case "listItem": return lowerListItem(node, context);
+		case "table": return lowerTable(node, context);
+		case "tableRow": return lowerTableRow(node, void 0, false, context);
+		case "tableCell": return htmlElement("td", node.children, context);
+		case "blockquote": return element("blockquote", {}, wrap(lowerChildren(node.children, context), true));
+		case "document": return wrap(lowerChildren(node.children, context), false);
+		default: return node;
+	}
+}
+function isEmbeddedPhrasing(node) {
+	return node.kind === "jsxTextElement" || node.kind === "inlineExpression" || node.kind === "text" && node.value.trim() === "";
+}
+function lowerTextDirective(node, context) {
+	return element("span", directiveHtmlAttributes(node.name, "text", node.attributes), node.label === void 0 ? [] : lowerChildren(node.label.children, context));
+}
+function lowerLeafDirective(node, context) {
+	return element("div", directiveHtmlAttributes(node.name, "leaf", node.attributes), node.label === void 0 ? [] : [directiveLabel(node, context)]);
+}
+function lowerContainerDirective(node, context) {
+	const children = [];
+	if (node.label !== void 0) children.push(directiveLabel(node, context));
+	children.push(...lowerChildren(node.children, context));
+	return element("div", directiveHtmlAttributes(node.name, "container", node.attributes), wrap(children, true));
+}
+function directiveLabel(node, context) {
+	return element("span", { "data-directive-label": "" }, lowerChildren(node.label?.children ?? [], context));
+}
+function directiveHtmlAttributes(name, kind, entries) {
+	const attributes = {
+		"data-directive": name,
+		"data-directive-kind": kind
+	};
+	return entries.length === 0 ? attributes : {
+		...attributes,
+		"data-directive-attributes": JSON.stringify(entries.map((entry) => [entry.name, entry.value]))
+	};
+}
+function unresolvedReference(reference, node, children, context) {
+	return {
+		kind: "unresolvedReference",
+		reference,
+		identifier: node.identifier,
+		source: authored(node, context),
+		children
+	};
+}
+function lowerFootnoteReference(node, occurrence, options) {
+	const prefix = options.clobberPrefix ?? "user-content-";
+	const identifier = normalizeUri(node.identifier.toLowerCase());
+	const suffix = occurrence.occurrence > 1 ? `-${occurrence.occurrence}` : "";
+	return {
+		kind: "footnoteReference",
+		identifier: node.identifier,
+		occurrence: occurrence.occurrence,
+		ordinal: occurrence.ordinal,
+		children: [element("a", {
+			href: `#${prefix}fn-${identifier}`,
+			id: `${prefix}fnref-${identifier}${suffix}`,
+			"data-footnote-ref": "",
+			"aria-describedby": "footnote-label"
+		}, [text(String(occurrence.ordinal))])]
+	};
+}
+/** The generated section for the numbered footnotes, or `undefined` when none is referenced. */
+function lowerFootnoteSection(numbering, scope) {
+	const order = numbering.order;
+	if (order.length === 0) return;
+	const context = {
+		scope,
+		listLoose: false,
+		volatile: { count: 0 }
+	};
+	const prefix = scope.options.clobberPrefix ?? "user-content-";
+	const items = [];
+	for (let index = 0; index < order.length; index++) {
+		const identifier = order[index];
+		const definition = scope.footnote(identifier);
+		if (definition === void 0) continue;
+		const safeIdentifier = normalizeUri(identifier.toLowerCase());
+		const blocks = lowerChildren(definition.children, context);
+		const backreferences = footnoteBackreferences(safeIdentifier, index, numbering.count(identifier), prefix, scope.options);
+		const tail = blocks.at(-1);
+		if (tail?.kind === "element" && tail.tagName === "p") blocks[blocks.length - 1] = {
+			...tail,
+			children: [
+				...tail.children,
+				...tail.children.length === 0 ? [] : [text(" ")],
+				...backreferences
+			]
+		};
+		else {
+			if (blocks.length > 0) blocks.push(text("\n"));
+			blocks.push(...backreferences);
+		}
+		items.push(element("li", { id: `${prefix}fn-${safeIdentifier}` }, wrap(blocks, true)));
+	}
+	const heading = element(scope.options.footnoteLabelTagName ?? "h2", {
+		id: "footnote-label",
+		class: ["sr-only"]
+	}, [text(scope.options.footnoteLabel ?? "Footnotes")]);
+	return {
+		kind: "footnoteSection",
+		identifiers: [...order],
+		children: wrap([heading, element("ol", {}, wrap(items, true))], true)
+	};
+}
+function footnoteBackreferences(identifier, referenceIndex, count, prefix, options) {
+	const values = [];
+	for (let reuse = 1; reuse <= count; reuse++) {
+		if (values.length > 0) values.push(text(" "));
+		const configured = options.footnoteBackLabel;
+		const label = isFunction(configured) ? configured(referenceIndex, reuse) : configured ?? defaultFootnoteBackLabel(referenceIndex, reuse);
+		values.push(element("a", {
+			href: `#${prefix}fnref-${identifier}${reuse > 1 ? `-${reuse}` : ""}`,
+			"data-footnote-backref": "",
+			"aria-label": label,
+			class: ["data-footnote-backref"]
+		}, [text("↩"), ...reuse > 1 ? [element("sup", {}, [text(String(reuse))])] : []]));
+	}
+	return values;
+}
+function defaultFootnoteBackLabel(referenceIndex, reuse) {
+	return `Back to reference ${referenceIndex + 1}${reuse > 1 ? `-${reuse}` : ""}`;
+}
+function lowerTable(node, context) {
+	const head = node.children[0];
+	const children = [];
+	if (head !== void 0) children.push(element("thead", {}, [lowerTableRow(head, node.alignments, true, context)]));
+	if (node.children.length > 1) children.push(element("tbody", {}, node.children.slice(1).map((row) => lowerTableRow(row, node.alignments, false, context))));
+	return element("table", {}, children);
+}
+function lowerTableRow(node, alignments, heading, context) {
+	const length = alignments?.length ?? node.children.length;
+	const cells = [];
+	for (let index = 0; index < length; index++) {
+		const cell = node.children.at(index);
+		const alignment = alignments?.[index];
+		cells.push(element(heading ? "th" : "td", alignment === void 0 || alignment === "none" ? {} : { align: alignment }, cell === void 0 ? [] : lowerChildren(cell.children, context)));
+	}
+	return element("tr", {}, cells);
+}
+function lowerLink(url, title, children, context) {
+	const href = resolveUrl(url, "link", context.scope.options);
+	return element("a", href === void 0 ? {} : title === void 0 ? { href } : {
+		href,
+		title
+	}, lowerChildren(children, context));
+}
+function lowerImage(source, alt, title, context) {
+	const src = resolveUrl(source, "image", context.scope.options);
+	if (src === void 0) return text(alt);
+	return element("img", title === void 0 ? {
+		src,
+		alt
+	} : {
+		src,
+		alt,
+		title
+	});
+}
+/**
+* A list wraps its items in line endings. A growing list reuses the wrapped
+* children of its unchanged leading items, so an append lowers only new items.
+* Stream previews build long children from fixed fragments, so extending them
+* copies only the fragment list; strict output stays flat.
+*/
+function lowerList(node, context) {
+	const items = node.children;
+	const prefix = listPrefix(items, context.scope.cache);
+	const rest = items.slice((prefix?.index ?? -1) + 1);
+	const spread = (prefix?.spread ?? false) || rest.some((item) => item.spread);
+	const loose = node.spread || spread;
+	const tasks = (prefix?.tasks ?? false) || rest.some((item) => item.checked !== void 0);
+	const reused = prefix !== void 0 && prefix.loose === loose ? prefix : void 0;
+	const itemContext = {
+		...context,
+		listLoose: loose
+	};
+	const children = new ChildSequence(context.scope.provisional === true, reused?.children);
+	if (reused === void 0) children.push(newline);
+	let stable = true;
+	let spreadSoFar = reused?.spread ?? false;
+	let tasksSoFar = reused?.tasks ?? false;
+	for (let index = (reused?.index ?? -1) + 1; index < items.length; index++) {
+		spreadSoFar ||= items[index].spread;
+		tasksSoFar ||= items[index].checked !== void 0;
+		const volatile = context.volatile.count;
+		const lowered = lowerHtmlNode(items[index], itemContext);
+		for (const item of lowered === void 0 ? [] : isHtmlNodeArray(lowered) ? lowered : [lowered]) {
+			if (children.size > 1) children.push(newline);
+			children.push(item);
+		}
+		stable &&= context.volatile.count === volatile;
+		if (stable && index >= items.length - prefixWindow) context.scope.cache?.lists.set(items[index], {
+			index,
+			loose,
+			spread: spreadSoFar,
+			tasks: tasksSoFar,
+			children: children.prefix()
+		});
+	}
+	const attributes = {};
+	if (node.ordered && node.start !== 1) attributes.start = node.start;
+	if (tasks) attributes.class = ["contains-task-list"];
+	if (children.size > 1) children.push(newline);
+	return element(node.ordered ? "ol" : "ul", attributes, children.toArray());
+}
+/**
+* How far back a list prefix can end. The parser closes an item only when the
+* next line completes, so the last two items are rebuilt by each tail draft.
+*/
+const prefixWindow = 8;
+/** Children of a long sequence in fragments of this many nodes. */
+const fragmentSize = 64;
+/**
+* Children that grow at the end. With fragments, full groups of nodes become
+* frozen fragments that later prefixes share, so copying a prefix costs only
+* the fragment list and the partial group.
+*/
+var ChildSequence = class {
+	#fragmented;
+	#fragments;
+	#rest;
+	#size;
+	constructor(fragmented, prefix) {
+		this.#fragmented = fragmented;
+		this.#fragments = prefix === void 0 ? [] : [...prefix.fragments];
+		this.#rest = prefix === void 0 ? [] : [...prefix.rest];
+		this.#size = prefix?.size ?? 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	push(node) {
+		this.#rest.push(node);
+		this.#size++;
+		if (this.#fragmented && this.#rest.length === fragmentSize) {
+			this.#fragments.push(Object.freeze({
+				kind: "root",
+				children: this.#rest
+			}));
+			this.#rest = [];
+		}
+	}
+	prefix() {
+		return {
+			fragments: [...this.#fragments],
+			rest: [...this.#rest],
+			size: this.#size
+		};
+	}
+	/** A short sequence stays flat, so fragments appear only where they save copying. */
+	toArray() {
+		if (this.#fragments.length < 2) return [...this.#fragments.flatMap((fragment) => fragment.children), ...this.#rest];
+		return [...this.#fragments, ...this.#rest];
+	}
+};
+/** The longest cached prefix of `items`, found from the end. */
+function listPrefix(items, cache) {
+	for (let index = items.length - 1; index >= Math.max(0, items.length - prefixWindow); index--) {
+		const item = items[index];
+		const prefix = item === void 0 ? void 0 : cache?.lists.get(item);
+		if (prefix?.index === index) return prefix;
+	}
+}
+function lowerListItem(node, context) {
+	const blocks = [...lowerChildren(node.children, context)];
+	if (node.checked !== void 0) {
+		const checkbox = element("input", node.checked ? {
+			type: "checkbox",
+			disabled: true,
+			checked: true
+		} : {
+			type: "checkbox",
+			disabled: true
+		});
+		const first = blocks[0];
+		if (first?.kind === "element" && first.tagName === "p") blocks[0] = {
+			...first,
+			children: [
+				checkbox,
+				...first.children.length === 0 ? [] : [text(" ")],
+				...first.children
+			]
+		};
+		else blocks.unshift(element("p", {}, [checkbox]));
+	}
+	const children = [];
+	for (let index = 0; index < blocks.length; index++) {
+		const child = blocks[index];
+		const paragraph = child.kind === "element" && child.tagName === "p";
+		if (context.listLoose || index !== 0 || !paragraph) children.push(text("\n"));
+		if (paragraph && !context.listLoose) children.push(...child.children);
+		else children.push(child);
+	}
+	const tail = blocks.at(-1);
+	if (tail !== void 0 && (context.listLoose || tail.kind !== "element" || tail.tagName !== "p")) children.push(text("\n"));
+	return element("li", node.checked === void 0 ? {} : { class: ["task-list-item"] }, children);
+}
+function revertReference(node, context) {
+	const children = lowerChildren(node.children, context);
+	const suffix = node.referenceKind === "shortcut" ? "]" : node.referenceKind === "collapsed" ? "][]" : `][${node.identifier}]`;
+	if (children.length === 0) return [text(`[${suffix}`)];
+	const first = children[0];
+	const result = first.kind === "text" ? [text(`[${first.value}`), ...children.slice(1)] : [text("["), ...children];
+	const last = result[result.length - 1];
+	if (last.kind === "text") result[result.length - 1] = text(last.value + suffix);
+	else result.push(text(suffix));
+	return result;
+}
+function lowerChildren(children, context, previous) {
+	const values = [];
+	for (let index = 0; index < children.length; index++) {
+		const child = children[index];
+		const lowered = lowerHtmlNode(child, context);
+		if (lowered === void 0) continue;
+		const additions = isHtmlNodeArray(lowered) ? [...lowered] : [lowered];
+		if ((index === 0 ? previous : children[index - 1])?.kind === "hardBreak" && additions.length > 0) additions[0] = trimSpaceStart(additions[0]);
+		values.push(...additions);
+	}
+	return values;
+}
+function htmlElement(tagName, children, context) {
+	return element(tagName, {}, lowerChildren(children, context));
+}
+function element(tagName, attributes = {}, children = []) {
+	return {
+		kind: "element",
+		tagName,
+		attributes,
+		children
+	};
+}
+function text(value) {
+	return {
+		kind: "text",
+		value
+	};
+}
+function trimSpaceStart(node) {
+	if (node.kind === "text") return {
+		...node,
+		value: node.value.replace(/^[\t ]+/u, "")
+	};
+	if (node.kind === "element") {
+		const first = node.children[0];
+		if (first?.kind === "text") return {
+			...node,
+			children: [{
+				...first,
+				value: first.value.replace(/^[\t ]+/u, "")
+			}, ...node.children.slice(1)]
+		};
+	}
+	return node;
+}
+/** Line endings between blocks. Trees are immutable, so every separator shares one node. */
+const newline = Object.freeze({
+	kind: "text",
+	value: "\n"
+});
+function wrap(nodes, loose) {
+	const result = [];
+	if (loose) result.push(newline);
+	nodes.forEach((node, index) => {
+		if (index > 0) result.push(newline);
+		result.push(node);
+	});
+	if (loose && nodes.length > 0) result.push(newline);
+	return result;
+}
+function resolveUrl(url, kind, options) {
+	const sanitized = sanitizeUrl(url, options, kind);
+	return options.urlTransform === void 0 ? sanitized : options.urlTransform(url, kind, sanitized);
+}
+function sanitizeUrl(value, options, use) {
+	const decoded = decodeUrlForSchemeCheck(value);
+	const colon = decoded.indexOf(":");
+	const slash = decoded.indexOf("/");
+	const query = decoded.indexOf("?");
+	const hash = decoded.indexOf("#");
+	if (colon >= 0 && (slash < 0 || colon < slash) && (query < 0 || colon < query) && (hash < 0 || colon < hash) && options.allowUnsafeUrls !== true) {
+		const scheme = decoded.slice(0, colon).toLowerCase();
+		if (use === "image" ? !imageSchemes.has(scheme) : !linkSchemes.has(scheme)) return;
+	}
+	return normalizeUri(value);
+}
+function decodeUrlForSchemeCheck(value) {
+	const result = [];
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		const hexadecimal = value.slice(index + 1, index + 1 + percentEncodedByteLength);
+		if (character === "%" && percentEncodedByte.test(hexadecimal)) {
+			const decoded = String.fromCodePoint(Number.parseInt(hexadecimal, hexadecimalRadix));
+			if (!isUrlControlCharacter(decoded)) result.push(decoded);
+			index += hexadecimal.length;
+			continue;
+		}
+		if (!isUrlControlCharacter(character)) result.push(character);
+	}
+	return result.join("");
+}
+//#endregion
+export { createHtmlLoweringCache, footnoteReferences, joinBlocks, lowerFootnoteSection, lowerHtml, lowerNodes, sanitizeUrl };
+
+//# sourceMappingURL=html-lower.mjs.map