markdown-codec 0.0.0 → 1.0.0

package/dist/inline/delimiter.js

@@ -0,0 +1,132 @@
+import { codePointAt, codePointBefore, isUnicodePunctuation, isUnicodeWhitespace } from "./chars.js";
+//#region src/inline/delimiter.ts
+function isDelimiterChar(char) {
+	return char === "*" || char === "_" || char === "~";
+}
+const MAX_STRIKETHROUGH_RUN = 2;
+function scanDelimiterRun(text, start, char) {
+	let count = 0;
+	while (text.charAt(start + count) === char) count += 1;
+	if (count === 0) return;
+	if (char === "~" && count > MAX_STRIKETHROUGH_RUN) return;
+	const before = codePointBefore(text, start);
+	const after = codePointAt(text, start + count);
+	const beforeIsWhitespace = isUnicodeWhitespace(before);
+	const beforeIsPunctuation = isUnicodePunctuation(before);
+	const afterIsWhitespace = isUnicodeWhitespace(after);
+	const afterIsPunctuation = isUnicodePunctuation(after);
+	const leftFlanking = !afterIsWhitespace && (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+	const rightFlanking = !beforeIsWhitespace && (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+	if (char === "_") return {
+		count,
+		canOpen: leftFlanking && (!rightFlanking || beforeIsPunctuation),
+		canClose: rightFlanking && (!leftFlanking || afterIsPunctuation)
+	};
+	return {
+		count,
+		canOpen: leftFlanking,
+		canClose: rightFlanking
+	};
+}
+var DelimiterStack = class {
+	top;
+	push(char, run, node) {
+		const delimiter = {
+			char,
+			count: run.count,
+			origCount: run.count,
+			canOpen: run.canOpen,
+			canClose: run.canClose,
+			node,
+			previous: this.top,
+			next: void 0
+		};
+		if (this.top !== void 0) this.top.next = delimiter;
+		this.top = delimiter;
+	}
+	remove(delimiter) {
+		if (delimiter.previous !== void 0) delimiter.previous.next = delimiter.next;
+		if (delimiter.next === void 0) this.top = delimiter.previous;
+		else delimiter.next.previous = delimiter.previous;
+	}
+};
+function closerSignature(closer) {
+	return `${closer.char}${closer.canOpen ? "1" : "0"}${String(closer.origCount % 3)}`;
+}
+function isRuleOfThreeBlocked(opener, closer) {
+	return (closer.canOpen || opener.canClose) && closer.origCount % 3 !== 0 && (opener.origCount + closer.origCount) % 3 === 0;
+}
+function canMatch(opener, closer) {
+	if (opener.char !== closer.char || !opener.canOpen) return false;
+	if (closer.char === "~") return opener.count === closer.count;
+	return !isRuleOfThreeBlocked(opener, closer);
+}
+function delimitersConsumedByMatch(opener, closer) {
+	if (closer.char === "~") return closer.count;
+	return closer.count >= 2 && opener.count >= 2 ? 2 : 1;
+}
+function wrapperKindFor(closer, used) {
+	if (closer.char === "~") return "strikethrough";
+	return used === 1 ? "emphasis" : "strong";
+}
+function processEmphasis(stack, stackBottom, createWrapper) {
+	const openersFloor = /* @__PURE__ */ new Map();
+	let closer = stack.top;
+	while (closer !== void 0 && closer.previous !== stackBottom) closer = closer.previous;
+	while (closer !== void 0) {
+		if (!closer.canClose) {
+			closer = closer.next;
+			continue;
+		}
+		const signature = closerSignature(closer);
+		const floor = openersFloor.has(signature) ? openersFloor.get(signature) : stackBottom;
+		let opener = closer.previous;
+		let matchedOpener;
+		while (opener !== void 0 && opener !== stackBottom && opener !== floor) {
+			if (canMatch(opener, closer)) {
+				matchedOpener = opener;
+				break;
+			}
+			opener = opener.previous;
+		}
+		const failedCloser = closer;
+		if (matchedOpener === void 0) {
+			closer = closer.next;
+			openersFloor.set(signature, failedCloser.previous);
+			if (!failedCloser.canOpen) stack.remove(failedCloser);
+			continue;
+		}
+		const used = delimitersConsumedByMatch(matchedOpener, closer);
+		const openerNode = matchedOpener.node;
+		const closerNode = closer.node;
+		matchedOpener.count -= used;
+		closer.count -= used;
+		openerNode.literal = openerNode.literal.slice(0, openerNode.literal.length - used);
+		closerNode.literal = closerNode.literal.slice(0, closerNode.literal.length - used);
+		const wrapper = createWrapper(wrapperKindFor(closer, used), closer.char);
+		let moving = openerNode.next;
+		while (moving !== void 0 && moving !== closerNode) {
+			const following = moving.next;
+			wrapper.appendChild(moving);
+			moving = following;
+		}
+		openerNode.insertAfter(wrapper);
+		if (matchedOpener.next !== closer) {
+			matchedOpener.next = closer;
+			closer.previous = matchedOpener;
+		}
+		if (matchedOpener.count === 0) {
+			openerNode.unlink();
+			stack.remove(matchedOpener);
+		}
+		if (closer.count === 0) {
+			closerNode.unlink();
+			const following = closer.next;
+			stack.remove(closer);
+			closer = following;
+		}
+	}
+	while (stack.top !== void 0 && stack.top !== stackBottom) stack.remove(stack.top);
+}
+//#endregion
+export { DelimiterStack, isDelimiterChar, processEmphasis, scanDelimiterRun };

package/dist/inline/entity.cjs

@@ -0,0 +1,67 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_scan_entity_table = require("../scan/entity-table.cjs");
+const require_inline_chars = require("./chars.cjs");
+//#region src/inline/entity.ts
+const REPLACEMENT_CHARACTER = "�";
+const MAX_CODEPOINT = 1114111;
+const SURROGATE_FIRST = 55296;
+const SURROGATE_LAST = 57343;
+const ENTITY_PATTERN = /^&(?:#[Xx]([0-9A-Fa-f]{1,6})|#([0-9]{1,7})|([A-Za-z][A-Za-z0-9]{1,31}));/;
+function codepointToString(codepoint) {
+	if (codepoint === 0 || codepoint > MAX_CODEPOINT || codepoint >= SURROGATE_FIRST && codepoint <= SURROGATE_LAST) return REPLACEMENT_CHARACTER;
+	return String.fromCodePoint(codepoint);
+}
+function matchEntity(text, start) {
+	if (text.charAt(start) !== "&") return;
+	const match = ENTITY_PATTERN.exec(text.slice(start));
+	if (match === null) return;
+	const [raw, hex, decimal, name] = match;
+	if (hex !== void 0) return {
+		raw,
+		value: codepointToString(Number.parseInt(hex, 16))
+	};
+	if (decimal !== void 0) return {
+		raw,
+		value: codepointToString(Number.parseInt(decimal, 10))
+	};
+	if (name === void 0) return;
+	const resolved = require_scan_entity_table.HTML_ENTITY_TABLE[name];
+	if (resolved === void 0) return;
+	return {
+		raw,
+		value: resolved
+	};
+}
+function unescapeString(text) {
+	if (!text.includes("\\") && !text.includes("&")) return text;
+	let result = "";
+	let index = 0;
+	while (index < text.length) {
+		const char = text.charAt(index);
+		if (char === "\\") {
+			const next = text.charAt(index + 1);
+			if (require_inline_chars.isAsciiPunctuation(next)) {
+				result += next;
+				index += 2;
+				continue;
+			}
+			result += char;
+			index += 1;
+			continue;
+		}
+		if (char === "&") {
+			const entity = matchEntity(text, index);
+			if (entity !== void 0) {
+				result += entity.value;
+				index += entity.raw.length;
+				continue;
+			}
+		}
+		result += char;
+		index += 1;
+	}
+	return result;
+}
+//#endregion
+exports.matchEntity = matchEntity;
+exports.unescapeString = unescapeString;

package/dist/inline/entity.d.cts

@@ -0,0 +1,9 @@
+//#region src/inline/entity.d.ts
+interface EntityMatch {
+  readonly raw: string;
+  readonly value: string;
+}
+declare function matchEntity(text: string, start: number): EntityMatch | undefined;
+declare function unescapeString(text: string): string;
+//#endregion
+export { EntityMatch, matchEntity, unescapeString };

package/dist/inline/entity.d.ts

@@ -0,0 +1,9 @@
+//#region src/inline/entity.d.ts
+interface EntityMatch {
+  readonly raw: string;
+  readonly value: string;
+}
+declare function matchEntity(text: string, start: number): EntityMatch | undefined;
+declare function unescapeString(text: string): string;
+//#endregion
+export { EntityMatch, matchEntity, unescapeString };

package/dist/inline/entity.js

@@ -0,0 +1,65 @@
+import { HTML_ENTITY_TABLE } from "../scan/entity-table.js";
+import { isAsciiPunctuation } from "./chars.js";
+//#region src/inline/entity.ts
+const REPLACEMENT_CHARACTER = "�";
+const MAX_CODEPOINT = 1114111;
+const SURROGATE_FIRST = 55296;
+const SURROGATE_LAST = 57343;
+const ENTITY_PATTERN = /^&(?:#[Xx]([0-9A-Fa-f]{1,6})|#([0-9]{1,7})|([A-Za-z][A-Za-z0-9]{1,31}));/;
+function codepointToString(codepoint) {
+	if (codepoint === 0 || codepoint > MAX_CODEPOINT || codepoint >= SURROGATE_FIRST && codepoint <= SURROGATE_LAST) return REPLACEMENT_CHARACTER;
+	return String.fromCodePoint(codepoint);
+}
+function matchEntity(text, start) {
+	if (text.charAt(start) !== "&") return;
+	const match = ENTITY_PATTERN.exec(text.slice(start));
+	if (match === null) return;
+	const [raw, hex, decimal, name] = match;
+	if (hex !== void 0) return {
+		raw,
+		value: codepointToString(Number.parseInt(hex, 16))
+	};
+	if (decimal !== void 0) return {
+		raw,
+		value: codepointToString(Number.parseInt(decimal, 10))
+	};
+	if (name === void 0) return;
+	const resolved = HTML_ENTITY_TABLE[name];
+	if (resolved === void 0) return;
+	return {
+		raw,
+		value: resolved
+	};
+}
+function unescapeString(text) {
+	if (!text.includes("\\") && !text.includes("&")) return text;
+	let result = "";
+	let index = 0;
+	while (index < text.length) {
+		const char = text.charAt(index);
+		if (char === "\\") {
+			const next = text.charAt(index + 1);
+			if (isAsciiPunctuation(next)) {
+				result += next;
+				index += 2;
+				continue;
+			}
+			result += char;
+			index += 1;
+			continue;
+		}
+		if (char === "&") {
+			const entity = matchEntity(text, index);
+			if (entity !== void 0) {
+				result += entity.value;
+				index += entity.raw.length;
+				continue;
+			}
+		}
+		result += char;
+		index += 1;
+	}
+	return result;
+}
+//#endregion
+export { matchEntity, unescapeString };

package/dist/inline/gfm-autolink.cjs

@@ -0,0 +1,156 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_inline_node = require("./node.cjs");
+//#region src/inline/gfm-autolink.ts
+const DOMAIN_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
+const MIN_DOMAIN_SEGMENTS = 2;
+const VALID_PRECEDING_CHARACTERS = /* @__PURE__ */ new Set([
+	"*",
+	"_",
+	"~",
+	"("
+]);
+const TRAILING_PUNCTUATION = /* @__PURE__ */ new Set([
+	"?",
+	"!",
+	".",
+	",",
+	":",
+	"*",
+	"_",
+	"~"
+]);
+const EMAIL_LOCAL_PART_PATTERN = /[A-Za-z0-9._+-]/;
+const EMAIL_DOMAIN_PATTERN = /[A-Za-z0-9._-]/;
+const ENTITY_TAIL_PATTERN = /&[A-Za-z0-9]+;$/;
+const WWW_PREFIX = "www.";
+const URL_SCHEME_PREFIXES = [
+	"http://",
+	"https://",
+	"ftp://"
+];
+const PROTOCOL_PREFIXES = ["mailto:", "xmpp:"];
+const OPAQUE_KINDS = /* @__PURE__ */ new Set([
+	"link",
+	"image",
+	"codeSpan",
+	"rawHtml",
+	"autolink"
+]);
+function isWhitespace(char) {
+	return char === "" || char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+}
+function isValidStartBoundary(text, index) {
+	if (index === 0) return true;
+	const before = text.charAt(index - 1);
+	return isWhitespace(before) || VALID_PRECEDING_CHARACTERS.has(before);
+}
+function isValidDomain(domain) {
+	const segments = domain.split(".");
+	if (segments.length < MIN_DOMAIN_SEGMENTS) return false;
+	if (!segments.every((segment) => DOMAIN_SEGMENT_PATTERN.test(segment))) return false;
+	return segments.slice(-2).every((segment) => !segment.includes("_"));
+}
+function trimTrailingPunctuation(candidate) {
+	let end = candidate.length;
+	for (;;) {
+		const before = end;
+		while (end > 0 && TRAILING_PUNCTUATION.has(candidate.charAt(end - 1))) end -= 1;
+		if (end > 0 && candidate.charAt(end - 1) === ")") {
+			const slice = candidate.slice(0, end);
+			if (slice.split(")").length > slice.split("(").length) end -= 1;
+		}
+		if (end > 0 && candidate.charAt(end - 1) === ";") {
+			const entityTail = ENTITY_TAIL_PATTERN.exec(candidate.slice(0, end));
+			if (entityTail !== null) end -= entityTail[0].length;
+		}
+		if (end === before) return candidate.slice(0, end);
+	}
+}
+function scanRawCandidate(text, start) {
+	let end = start;
+	while (end < text.length && !isWhitespace(text.charAt(end)) && text.charAt(end) !== "<") end += 1;
+	return text.slice(start, end);
+}
+function matchPrefixed(text, index, prefixLength, destinationPrefix, requireValidDomain) {
+	const trimmed = trimTrailingPunctuation(scanRawCandidate(text, index));
+	if (trimmed.length <= prefixLength) return;
+	if (requireValidDomain) {
+		if (!isValidDomain(trimmed.slice(prefixLength).split(/[/?#]/)[0] ?? "")) return;
+	}
+	return {
+		text: trimmed,
+		destination: destinationPrefix + trimmed,
+		start: index
+	};
+}
+function scanEmailDomain(text, start) {
+	let end = start;
+	while (end < text.length && EMAIL_DOMAIN_PATTERN.test(text.charAt(end))) end += 1;
+	return text.slice(start, end);
+}
+function matchEmailAt(text, atIndex) {
+	let start = atIndex;
+	while (start > 0 && EMAIL_LOCAL_PART_PATTERN.test(text.charAt(start - 1))) start -= 1;
+	if (start === atIndex || !isValidStartBoundary(text, start)) return;
+	const local = text.slice(start, atIndex);
+	if (local.startsWith(".") || local.endsWith(".")) return;
+	const domain = scanEmailDomain(text, atIndex + 1).replace(/\.+$/, "");
+	if (domain.endsWith("-") || domain.endsWith("_") || !isValidDomain(domain)) return;
+	const address = `${local}@${domain}`;
+	return {
+		text: address,
+		destination: `mailto:${address}`,
+		start
+	};
+}
+function startsWithIgnoringCase(text, index, prefix) {
+	return text.slice(index, index + prefix.length).toLowerCase() === prefix;
+}
+function findAutolinkAt(text, index) {
+	if (text.charAt(index) === "@") return matchEmailAt(text, index);
+	if (!isValidStartBoundary(text, index)) return;
+	if (startsWithIgnoringCase(text, index, WWW_PREFIX)) return matchPrefixed(text, index, 4, "http://", true);
+	for (const prefix of URL_SCHEME_PREFIXES) if (startsWithIgnoringCase(text, index, prefix)) return matchPrefixed(text, index, prefix.length, "", true);
+	for (const prefix of PROTOCOL_PREFIXES) if (startsWithIgnoringCase(text, index, prefix)) return matchPrefixed(text, index, prefix.length, "", false);
+}
+function expandTextNode(node) {
+	const text = node.literal;
+	let cursor = 0;
+	let anchor = node;
+	let matches = 0;
+	let index = 0;
+	while (index < text.length) {
+		const found = findAutolinkAt(text, index);
+		if (found === void 0 || found.start < cursor) {
+			index += 1;
+			continue;
+		}
+		if (found.start > cursor) {
+			const before = require_inline_node.createTextNode(text.slice(cursor, found.start));
+			anchor.insertAfter(before);
+			anchor = before;
+		}
+		const link = new require_inline_node.InlineNode("link");
+		link.destination = found.destination;
+		link.appendChild(require_inline_node.createTextNode(found.text));
+		anchor.insertAfter(link);
+		anchor = link;
+		cursor = found.start + found.text.length;
+		matches += 1;
+		index = cursor;
+	}
+	if (matches === 0) return;
+	if (cursor < text.length) anchor.insertAfter(require_inline_node.createTextNode(text.slice(cursor)));
+	node.unlink();
+}
+function applyGfmAutolinks(root) {
+	let child = root.firstChild;
+	while (child !== void 0) {
+		const following = child.next;
+		if (child.kind === "text") expandTextNode(child);
+		else if (!OPAQUE_KINDS.has(child.kind)) applyGfmAutolinks(child);
+		child = following;
+	}
+}
+//#endregion
+exports.applyGfmAutolinks = applyGfmAutolinks;

package/dist/inline/gfm-autolink.d.cts

@@ -0,0 +1,5 @@
+import { InlineNode } from "./node.cjs";
+//#region src/inline/gfm-autolink.d.ts
+declare function applyGfmAutolinks(root: InlineNode): void;
+//#endregion
+export { applyGfmAutolinks };

package/dist/inline/gfm-autolink.d.ts

@@ -0,0 +1,5 @@
+import { InlineNode } from "./node.js";
+//#region src/inline/gfm-autolink.d.ts
+declare function applyGfmAutolinks(root: InlineNode): void;
+//#endregion
+export { applyGfmAutolinks };

package/dist/inline/gfm-autolink.js

@@ -0,0 +1,155 @@
+import { InlineNode, createTextNode } from "./node.js";
+//#region src/inline/gfm-autolink.ts
+const DOMAIN_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
+const MIN_DOMAIN_SEGMENTS = 2;
+const VALID_PRECEDING_CHARACTERS = /* @__PURE__ */ new Set([
+	"*",
+	"_",
+	"~",
+	"("
+]);
+const TRAILING_PUNCTUATION = /* @__PURE__ */ new Set([
+	"?",
+	"!",
+	".",
+	",",
+	":",
+	"*",
+	"_",
+	"~"
+]);
+const EMAIL_LOCAL_PART_PATTERN = /[A-Za-z0-9._+-]/;
+const EMAIL_DOMAIN_PATTERN = /[A-Za-z0-9._-]/;
+const ENTITY_TAIL_PATTERN = /&[A-Za-z0-9]+;$/;
+const WWW_PREFIX = "www.";
+const URL_SCHEME_PREFIXES = [
+	"http://",
+	"https://",
+	"ftp://"
+];
+const PROTOCOL_PREFIXES = ["mailto:", "xmpp:"];
+const OPAQUE_KINDS = /* @__PURE__ */ new Set([
+	"link",
+	"image",
+	"codeSpan",
+	"rawHtml",
+	"autolink"
+]);
+function isWhitespace(char) {
+	return char === "" || char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+}
+function isValidStartBoundary(text, index) {
+	if (index === 0) return true;
+	const before = text.charAt(index - 1);
+	return isWhitespace(before) || VALID_PRECEDING_CHARACTERS.has(before);
+}
+function isValidDomain(domain) {
+	const segments = domain.split(".");
+	if (segments.length < MIN_DOMAIN_SEGMENTS) return false;
+	if (!segments.every((segment) => DOMAIN_SEGMENT_PATTERN.test(segment))) return false;
+	return segments.slice(-2).every((segment) => !segment.includes("_"));
+}
+function trimTrailingPunctuation(candidate) {
+	let end = candidate.length;
+	for (;;) {
+		const before = end;
+		while (end > 0 && TRAILING_PUNCTUATION.has(candidate.charAt(end - 1))) end -= 1;
+		if (end > 0 && candidate.charAt(end - 1) === ")") {
+			const slice = candidate.slice(0, end);
+			if (slice.split(")").length > slice.split("(").length) end -= 1;
+		}
+		if (end > 0 && candidate.charAt(end - 1) === ";") {
+			const entityTail = ENTITY_TAIL_PATTERN.exec(candidate.slice(0, end));
+			if (entityTail !== null) end -= entityTail[0].length;
+		}
+		if (end === before) return candidate.slice(0, end);
+	}
+}
+function scanRawCandidate(text, start) {
+	let end = start;
+	while (end < text.length && !isWhitespace(text.charAt(end)) && text.charAt(end) !== "<") end += 1;
+	return text.slice(start, end);
+}
+function matchPrefixed(text, index, prefixLength, destinationPrefix, requireValidDomain) {
+	const trimmed = trimTrailingPunctuation(scanRawCandidate(text, index));
+	if (trimmed.length <= prefixLength) return;
+	if (requireValidDomain) {
+		if (!isValidDomain(trimmed.slice(prefixLength).split(/[/?#]/)[0] ?? "")) return;
+	}
+	return {
+		text: trimmed,
+		destination: destinationPrefix + trimmed,
+		start: index
+	};
+}
+function scanEmailDomain(text, start) {
+	let end = start;
+	while (end < text.length && EMAIL_DOMAIN_PATTERN.test(text.charAt(end))) end += 1;
+	return text.slice(start, end);
+}
+function matchEmailAt(text, atIndex) {
+	let start = atIndex;
+	while (start > 0 && EMAIL_LOCAL_PART_PATTERN.test(text.charAt(start - 1))) start -= 1;
+	if (start === atIndex || !isValidStartBoundary(text, start)) return;
+	const local = text.slice(start, atIndex);
+	if (local.startsWith(".") || local.endsWith(".")) return;
+	const domain = scanEmailDomain(text, atIndex + 1).replace(/\.+$/, "");
+	if (domain.endsWith("-") || domain.endsWith("_") || !isValidDomain(domain)) return;
+	const address = `${local}@${domain}`;
+	return {
+		text: address,
+		destination: `mailto:${address}`,
+		start
+	};
+}
+function startsWithIgnoringCase(text, index, prefix) {
+	return text.slice(index, index + prefix.length).toLowerCase() === prefix;
+}
+function findAutolinkAt(text, index) {
+	if (text.charAt(index) === "@") return matchEmailAt(text, index);
+	if (!isValidStartBoundary(text, index)) return;
+	if (startsWithIgnoringCase(text, index, WWW_PREFIX)) return matchPrefixed(text, index, 4, "http://", true);
+	for (const prefix of URL_SCHEME_PREFIXES) if (startsWithIgnoringCase(text, index, prefix)) return matchPrefixed(text, index, prefix.length, "", true);
+	for (const prefix of PROTOCOL_PREFIXES) if (startsWithIgnoringCase(text, index, prefix)) return matchPrefixed(text, index, prefix.length, "", false);
+}
+function expandTextNode(node) {
+	const text = node.literal;
+	let cursor = 0;
+	let anchor = node;
+	let matches = 0;
+	let index = 0;
+	while (index < text.length) {
+		const found = findAutolinkAt(text, index);
+		if (found === void 0 || found.start < cursor) {
+			index += 1;
+			continue;
+		}
+		if (found.start > cursor) {
+			const before = createTextNode(text.slice(cursor, found.start));
+			anchor.insertAfter(before);
+			anchor = before;
+		}
+		const link = new InlineNode("link");
+		link.destination = found.destination;
+		link.appendChild(createTextNode(found.text));
+		anchor.insertAfter(link);
+		anchor = link;
+		cursor = found.start + found.text.length;
+		matches += 1;
+		index = cursor;
+	}
+	if (matches === 0) return;
+	if (cursor < text.length) anchor.insertAfter(createTextNode(text.slice(cursor)));
+	node.unlink();
+}
+function applyGfmAutolinks(root) {
+	let child = root.firstChild;
+	while (child !== void 0) {
+		const following = child.next;
+		if (child.kind === "text") expandTextNode(child);
+		else if (!OPAQUE_KINDS.has(child.kind)) applyGfmAutolinks(child);
+		child = following;
+	}
+}
+//#endregion
+export { applyGfmAutolinks };