markdown-codec 0.0.0 → 1.0.0

package/dist/image/image.js

@@ -0,0 +1,125 @@
+//#region src/image/image.ts
+const BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_DECODE = (() => {
+	const map = (/* @__PURE__ */ new Uint8Array(256)).fill(255);
+	for (let index = 0; index < 64; index += 1) map[BASE64_TABLE.charCodeAt(index)] = index;
+	return map;
+})();
+const BASE64_PADDING_CODE = 61;
+function bytesToBase64(bytes) {
+	let out = "";
+	const { length } = bytes;
+	for (let index = 0; index < length; index += 3) {
+		const b0 = bytes[index];
+		const b1 = index + 1 < length ? bytes[index + 1] : 0;
+		const b2 = index + 2 < length ? bytes[index + 2] : 0;
+		out += BASE64_TABLE[b0 >> 2];
+		out += BASE64_TABLE[(b0 & 3) << 4 | b1 >> 4];
+		out += index + 1 < length ? BASE64_TABLE[(b1 & 15) << 2 | b2 >> 6] : "=";
+		out += index + 2 < length ? BASE64_TABLE[b2 & 63] : "=";
+	}
+	return out;
+}
+function base64ToBytes(base64) {
+	const clean = base64.replace(/[^A-Za-z0-9+/=]/g, "");
+	const { length } = clean;
+	const out = new Uint8Array(Math.floor(length * 3 / 4));
+	let position = 0;
+	for (let index = 0; index < length; index += 4) {
+		const c0 = BASE64_DECODE[clean.charCodeAt(index)];
+		const c1 = BASE64_DECODE[clean.charCodeAt(index + 1)];
+		const code2 = clean.charCodeAt(index + 2);
+		const code3 = clean.charCodeAt(index + 3);
+		if (c0 === 255 || c1 === 255) throw new Error("invalid base64 input");
+		out[position] = c0 << 2 | c1 >> 4;
+		position += 1;
+		if (code2 !== BASE64_PADDING_CODE) {
+			const d2 = BASE64_DECODE[code2];
+			out[position] = (c1 & 15) << 4 | d2 >> 2;
+			position += 1;
+			if (code3 !== BASE64_PADDING_CODE) {
+				const d3 = BASE64_DECODE[code3];
+				out[position] = (d2 & 3) << 6 | d3;
+				position += 1;
+			}
+		}
+	}
+	return out.subarray(0, position);
+}
+function readUint16BE(bytes, offset) {
+	return (bytes[offset] << 8 | bytes[offset + 1]) & 65535;
+}
+function readUint32BE(bytes, offset) {
+	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const PNG_HEADER_BYTES = 24;
+function isPng(bytes) {
+	if (bytes.length < PNG_SIGNATURE.length) return false;
+	return PNG_SIGNATURE.every((byte, index) => bytes[index] === byte);
+}
+function readPngDimensions(bytes) {
+	if (bytes.length < PNG_HEADER_BYTES) return;
+	if (bytes[12] !== 73 || bytes[13] !== 72 || bytes[14] !== 68 || bytes[15] !== 82) return;
+	return {
+		widthPx: readUint32BE(bytes, 16),
+		heightPx: readUint32BE(bytes, 20)
+	};
+}
+function isStartOfFrameMarker(marker) {
+	if (marker < 192 || marker > 207) return false;
+	return marker !== 196 && marker !== 200 && marker !== 204;
+}
+function hasNoLengthField(marker) {
+	return marker === 216 || marker === 217 || marker === 1 || marker >= 208 && marker <= 215;
+}
+function readJpegDimensions(bytes) {
+	if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) return;
+	let offset = 2;
+	while (offset < bytes.length) {
+		if (bytes[offset] !== 255) {
+			offset += 1;
+			continue;
+		}
+		let markerOffset = offset + 1;
+		while (bytes[markerOffset] === 255) markerOffset += 1;
+		const marker = bytes[markerOffset];
+		if (marker === void 0) return;
+		offset = markerOffset + 1;
+		if (hasNoLengthField(marker)) continue;
+		if (offset + 2 > bytes.length) return;
+		const length = readUint16BE(bytes, offset);
+		if (isStartOfFrameMarker(marker)) {
+			if (offset + 7 > bytes.length) return;
+			const heightPx = readUint16BE(bytes, offset + 3);
+			return {
+				widthPx: readUint16BE(bytes, offset + 5),
+				heightPx
+			};
+		}
+		if (marker === 218) return;
+		offset += length;
+	}
+}
+function isJpeg(bytes) {
+	return bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216;
+}
+function detectImageFormat(bytes) {
+	if (isPng(bytes)) return "png";
+	return isJpeg(bytes) ? "jpeg" : void 0;
+}
+function readImageDimensions(bytes) {
+	if (isPng(bytes)) return readPngDimensions(bytes);
+	return readJpegDimensions(bytes);
+}
+//#endregion
+export { base64ToBytes, bytesToBase64, detectImageFormat, readImageDimensions };

package/dist/image-C4KYmz_L.d.cts

@@ -0,0 +1,19 @@
+import { n as ImageFormat } from "./image-DescdRgq.cjs";
+//#region src/lower/image.d.ts
+interface MarkdownImageResolveContext {
+  readonly alt: string;
+  readonly title?: string;
+}
+interface MarkdownResolvedImageBytes {
+  readonly bytes: Uint8Array;
+}
+type MarkdownImageResolver = (destination: string, context: MarkdownImageResolveContext) => MarkdownResolvedImageBytes | undefined;
+interface ResolvedMarkdownImage {
+  readonly format: ImageFormat;
+  readonly base64: string;
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+declare function resolveMarkdownImage(destination: string, context: MarkdownImageResolveContext, resolver: MarkdownImageResolver | undefined): ResolvedMarkdownImage | undefined;
+//#endregion
+export { resolveMarkdownImage as a, ResolvedMarkdownImage as i, MarkdownImageResolver as n, MarkdownResolvedImageBytes as r, MarkdownImageResolveContext as t };

package/dist/image-Cm3hT5PS.d.ts

@@ -0,0 +1,19 @@
+import { n as ImageFormat } from "./image-DescdRgq.js";
+//#region src/lower/image.d.ts
+interface MarkdownImageResolveContext {
+  readonly alt: string;
+  readonly title?: string;
+}
+interface MarkdownResolvedImageBytes {
+  readonly bytes: Uint8Array;
+}
+type MarkdownImageResolver = (destination: string, context: MarkdownImageResolveContext) => MarkdownResolvedImageBytes | undefined;
+interface ResolvedMarkdownImage {
+  readonly format: ImageFormat;
+  readonly base64: string;
+  readonly widthPt: number;
+  readonly heightPt: number;
+}
+declare function resolveMarkdownImage(destination: string, context: MarkdownImageResolveContext, resolver: MarkdownImageResolver | undefined): ResolvedMarkdownImage | undefined;
+//#endregion
+export { resolveMarkdownImage as a, ResolvedMarkdownImage as i, MarkdownImageResolver as n, MarkdownResolvedImageBytes as r, MarkdownImageResolveContext as t };

package/dist/image-DescdRgq.d.cts

@@ -0,0 +1,12 @@
+//#region src/image/image.d.ts
+interface ImageDimensions {
+  readonly widthPx: number;
+  readonly heightPx: number;
+}
+type ImageFormat = 'png' | 'jpeg';
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(base64: string): Uint8Array;
+declare function detectImageFormat(bytes: Uint8Array): ImageFormat | undefined;
+declare function readImageDimensions(bytes: Uint8Array): ImageDimensions | undefined;
+//#endregion
+export { detectImageFormat as a, bytesToBase64 as i, ImageFormat as n, readImageDimensions as o, base64ToBytes as r, ImageDimensions as t };

package/dist/image-DescdRgq.d.ts

@@ -0,0 +1,12 @@
+//#region src/image/image.d.ts
+interface ImageDimensions {
+  readonly widthPx: number;
+  readonly heightPx: number;
+}
+type ImageFormat = 'png' | 'jpeg';
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(base64: string): Uint8Array;
+declare function detectImageFormat(bytes: Uint8Array): ImageFormat | undefined;
+declare function readImageDimensions(bytes: Uint8Array): ImageDimensions | undefined;
+//#endregion
+export { detectImageFormat as a, bytesToBase64 as i, ImageFormat as n, readImageDimensions as o, base64ToBytes as r, ImageDimensions as t };

package/dist/index.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_diagnostics_diagnostics = require("./diagnostics/diagnostics.cjs");
+const require_read = require("./read.cjs");
+const require_write = require("./write.cjs");
+const require_codec = require("./codec.cjs");
+exports.MarkdownBytesSchema = require_codec.MarkdownBytesSchema;
+exports.MarkdownDiagnosticCodes = require_diagnostics_diagnostics.MarkdownDiagnosticCodes;
+exports.MarkdownInputTooLargeError = require_diagnostics_diagnostics.MarkdownInputTooLargeError;
+exports.MarkdownInvalidUtf8Error = require_diagnostics_diagnostics.MarkdownInvalidUtf8Error;
+exports.MarkdownNestingLimitExceededError = require_diagnostics_diagnostics.MarkdownNestingLimitExceededError;
+exports.MarkdownParseError = require_diagnostics_diagnostics.MarkdownParseError;
+exports.MarkdownUnsupportedDocumentKindError = require_diagnostics_diagnostics.MarkdownUnsupportedDocumentKindError;
+exports.MarkdownWriteError = require_diagnostics_diagnostics.MarkdownWriteError;
+exports.NOOP_MARKDOWN_DIAGNOSTIC_SINK = require_diagnostics_diagnostics.NOOP_MARKDOWN_DIAGNOSTIC_SINK;
+exports.markdownCodec = require_codec.markdownCodec;
+exports.readMarkdown = require_read.readMarkdown;
+exports.writeMarkdown = require_write.writeMarkdown;

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+import { a as MarkdownInputTooLargeError, c as MarkdownParseError, d as NOOP_MARKDOWN_DIAGNOSTIC_SINK, i as MarkdownDiagnosticSink, l as MarkdownUnsupportedDocumentKindError, n as MarkdownDiagnosticCodes, o as MarkdownInvalidUtf8Error, r as MarkdownDiagnosticSeverity, s as MarkdownNestingLimitExceededError, t as MarkdownDiagnostic, u as MarkdownWriteError } from "./diagnostics-DmuWc7d8.cjs";
+import { MarkdownBytesSchema, markdownCodec } from "./codec.cjs";
+import { n as MarkdownImageResolver, r as MarkdownResolvedImageBytes, t as MarkdownImageResolveContext } from "./image-C4KYmz_L.cjs";
+import { MarkdownBulletListMarker, MarkdownCodeFenceChar, MarkdownEmphasisMarker, MarkdownHeadingStyle, MarkdownLineEnding, MarkdownOrderedListDelimiter, MarkdownThematicBreakChar, ReadMarkdownOptions, WriteMarkdownOptions, WriteMarkdownStyleOptions } from "./options/options.cjs";
+import { ReadMarkdownResult, readMarkdown } from "./read.cjs";
+import { writeMarkdown } from "./write.cjs";
+export { type MarkdownBulletListMarker, MarkdownBytesSchema, type MarkdownCodeFenceChar, type MarkdownDiagnostic, MarkdownDiagnosticCodes, type MarkdownDiagnosticSeverity, type MarkdownDiagnosticSink, type MarkdownEmphasisMarker, type MarkdownHeadingStyle, type MarkdownImageResolveContext, type MarkdownImageResolver, MarkdownInputTooLargeError, MarkdownInvalidUtf8Error, type MarkdownLineEnding, MarkdownNestingLimitExceededError, type MarkdownOrderedListDelimiter, MarkdownParseError, type MarkdownResolvedImageBytes, type MarkdownThematicBreakChar, MarkdownUnsupportedDocumentKindError, MarkdownWriteError, NOOP_MARKDOWN_DIAGNOSTIC_SINK, type ReadMarkdownOptions, type ReadMarkdownResult, type WriteMarkdownOptions, type WriteMarkdownStyleOptions, markdownCodec, readMarkdown, writeMarkdown };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { a as MarkdownInputTooLargeError, c as MarkdownParseError, d as NOOP_MARKDOWN_DIAGNOSTIC_SINK, i as MarkdownDiagnosticSink, l as MarkdownUnsupportedDocumentKindError, n as MarkdownDiagnosticCodes, o as MarkdownInvalidUtf8Error, r as MarkdownDiagnosticSeverity, s as MarkdownNestingLimitExceededError, t as MarkdownDiagnostic, u as MarkdownWriteError } from "./diagnostics-DmuWc7d8.js";
+import { MarkdownBytesSchema, markdownCodec } from "./codec.js";
+import { n as MarkdownImageResolver, r as MarkdownResolvedImageBytes, t as MarkdownImageResolveContext } from "./image-Cm3hT5PS.js";
+import { MarkdownBulletListMarker, MarkdownCodeFenceChar, MarkdownEmphasisMarker, MarkdownHeadingStyle, MarkdownLineEnding, MarkdownOrderedListDelimiter, MarkdownThematicBreakChar, ReadMarkdownOptions, WriteMarkdownOptions, WriteMarkdownStyleOptions } from "./options/options.js";
+import { ReadMarkdownResult, readMarkdown } from "./read.js";
+import { writeMarkdown } from "./write.js";
+export { type MarkdownBulletListMarker, MarkdownBytesSchema, type MarkdownCodeFenceChar, type MarkdownDiagnostic, MarkdownDiagnosticCodes, type MarkdownDiagnosticSeverity, type MarkdownDiagnosticSink, type MarkdownEmphasisMarker, type MarkdownHeadingStyle, type MarkdownImageResolveContext, type MarkdownImageResolver, MarkdownInputTooLargeError, MarkdownInvalidUtf8Error, type MarkdownLineEnding, MarkdownNestingLimitExceededError, type MarkdownOrderedListDelimiter, MarkdownParseError, type MarkdownResolvedImageBytes, type MarkdownThematicBreakChar, MarkdownUnsupportedDocumentKindError, MarkdownWriteError, NOOP_MARKDOWN_DIAGNOSTIC_SINK, type ReadMarkdownOptions, type ReadMarkdownResult, type WriteMarkdownOptions, type WriteMarkdownStyleOptions, markdownCodec, readMarkdown, writeMarkdown };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { MarkdownDiagnosticCodes, MarkdownInputTooLargeError, MarkdownInvalidUtf8Error, MarkdownNestingLimitExceededError, MarkdownParseError, MarkdownUnsupportedDocumentKindError, MarkdownWriteError, NOOP_MARKDOWN_DIAGNOSTIC_SINK } from "./diagnostics/diagnostics.js";
+import { readMarkdown } from "./read.js";
+import { writeMarkdown } from "./write.js";
+import { MarkdownBytesSchema, markdownCodec } from "./codec.js";
+export { MarkdownBytesSchema, MarkdownDiagnosticCodes, MarkdownInputTooLargeError, MarkdownInvalidUtf8Error, MarkdownNestingLimitExceededError, MarkdownParseError, MarkdownUnsupportedDocumentKindError, MarkdownWriteError, NOOP_MARKDOWN_DIAGNOSTIC_SINK, markdownCodec, readMarkdown, writeMarkdown };

package/dist/inline/chars.cjs

@@ -0,0 +1,50 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/inline/chars.ts
+const ASCII_PUNCTUATION = new Set("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".split(""));
+function isAsciiPunctuation(char) {
+	return ASCII_PUNCTUATION.has(char);
+}
+const UNICODE_WHITESPACE_PATTERN = /^[\p{Zs}\t\n\f\r]$/u;
+function isUnicodeWhitespace(char) {
+	return UNICODE_WHITESPACE_PATTERN.test(char);
+}
+const UNICODE_PUNCTUATION_PATTERN = /^[\p{P}\p{S}]$/u;
+function isUnicodePunctuation(char) {
+	return UNICODE_PUNCTUATION_PATTERN.test(char);
+}
+function isAsciiControl(char) {
+	const code = char.codePointAt(0);
+	if (code === void 0) return false;
+	return code <= 31 || code === 127;
+}
+function containsAsciiControlOrSpace(text) {
+	for (let index = 0; index < text.length; index += 1) if (isAsciiControl(text.charAt(index)) || text.charAt(index) === " ") return true;
+	return false;
+}
+function isMarkdownSpace(char) {
+	return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+function codePointBefore(text, index) {
+	if (index <= 0) return "\n";
+	const low = text.charCodeAt(index - 1);
+	if (index >= 2 && low >= 56320 && low <= 57343) {
+		const high = text.charCodeAt(index - 2);
+		if (high >= 55296 && high <= 56319) return text.slice(index - 2, index);
+	}
+	return text.slice(index - 1, index);
+}
+function codePointAt(text, index) {
+	if (index >= text.length) return "\n";
+	const code = text.codePointAt(index);
+	if (code === void 0) return "\n";
+	return String.fromCodePoint(code);
+}
+//#endregion
+exports.codePointAt = codePointAt;
+exports.codePointBefore = codePointBefore;
+exports.containsAsciiControlOrSpace = containsAsciiControlOrSpace;
+exports.isAsciiControl = isAsciiControl;
+exports.isAsciiPunctuation = isAsciiPunctuation;
+exports.isMarkdownSpace = isMarkdownSpace;
+exports.isUnicodePunctuation = isUnicodePunctuation;
+exports.isUnicodeWhitespace = isUnicodeWhitespace;

package/dist/inline/chars.d.cts

@@ -0,0 +1,11 @@
+//#region src/inline/chars.d.ts
+declare function isAsciiPunctuation(char: string): boolean;
+declare function isUnicodeWhitespace(char: string): boolean;
+declare function isUnicodePunctuation(char: string): boolean;
+declare function isAsciiControl(char: string): boolean;
+declare function containsAsciiControlOrSpace(text: string): boolean;
+declare function isMarkdownSpace(char: string): boolean;
+declare function codePointBefore(text: string, index: number): string;
+declare function codePointAt(text: string, index: number): string;
+//#endregion
+export { codePointAt, codePointBefore, containsAsciiControlOrSpace, isAsciiControl, isAsciiPunctuation, isMarkdownSpace, isUnicodePunctuation, isUnicodeWhitespace };

package/dist/inline/chars.d.ts

@@ -0,0 +1,11 @@
+//#region src/inline/chars.d.ts
+declare function isAsciiPunctuation(char: string): boolean;
+declare function isUnicodeWhitespace(char: string): boolean;
+declare function isUnicodePunctuation(char: string): boolean;
+declare function isAsciiControl(char: string): boolean;
+declare function containsAsciiControlOrSpace(text: string): boolean;
+declare function isMarkdownSpace(char: string): boolean;
+declare function codePointBefore(text: string, index: number): string;
+declare function codePointAt(text: string, index: number): string;
+//#endregion
+export { codePointAt, codePointBefore, containsAsciiControlOrSpace, isAsciiControl, isAsciiPunctuation, isMarkdownSpace, isUnicodePunctuation, isUnicodeWhitespace };

package/dist/inline/chars.js

@@ -0,0 +1,42 @@
+//#region src/inline/chars.ts
+const ASCII_PUNCTUATION = new Set("!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~".split(""));
+function isAsciiPunctuation(char) {
+	return ASCII_PUNCTUATION.has(char);
+}
+const UNICODE_WHITESPACE_PATTERN = /^[\p{Zs}\t\n\f\r]$/u;
+function isUnicodeWhitespace(char) {
+	return UNICODE_WHITESPACE_PATTERN.test(char);
+}
+const UNICODE_PUNCTUATION_PATTERN = /^[\p{P}\p{S}]$/u;
+function isUnicodePunctuation(char) {
+	return UNICODE_PUNCTUATION_PATTERN.test(char);
+}
+function isAsciiControl(char) {
+	const code = char.codePointAt(0);
+	if (code === void 0) return false;
+	return code <= 31 || code === 127;
+}
+function containsAsciiControlOrSpace(text) {
+	for (let index = 0; index < text.length; index += 1) if (isAsciiControl(text.charAt(index)) || text.charAt(index) === " ") return true;
+	return false;
+}
+function isMarkdownSpace(char) {
+	return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+function codePointBefore(text, index) {
+	if (index <= 0) return "\n";
+	const low = text.charCodeAt(index - 1);
+	if (index >= 2 && low >= 56320 && low <= 57343) {
+		const high = text.charCodeAt(index - 2);
+		if (high >= 55296 && high <= 56319) return text.slice(index - 2, index);
+	}
+	return text.slice(index - 1, index);
+}
+function codePointAt(text, index) {
+	if (index >= text.length) return "\n";
+	const code = text.codePointAt(index);
+	if (code === void 0) return "\n";
+	return String.fromCodePoint(code);
+}
+//#endregion
+export { codePointAt, codePointBefore, containsAsciiControlOrSpace, isAsciiControl, isAsciiPunctuation, isMarkdownSpace, isUnicodePunctuation, isUnicodeWhitespace };

package/dist/inline/delimiter.cjs

@@ -0,0 +1,136 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_inline_chars = require("./chars.cjs");
+//#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 = require_inline_chars.codePointBefore(text, start);
+	const after = require_inline_chars.codePointAt(text, start + count);
+	const beforeIsWhitespace = require_inline_chars.isUnicodeWhitespace(before);
+	const beforeIsPunctuation = require_inline_chars.isUnicodePunctuation(before);
+	const afterIsWhitespace = require_inline_chars.isUnicodeWhitespace(after);
+	const afterIsPunctuation = require_inline_chars.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
+exports.DelimiterStack = DelimiterStack;
+exports.isDelimiterChar = isDelimiterChar;
+exports.processEmphasis = processEmphasis;
+exports.scanDelimiterRun = scanDelimiterRun;

package/dist/inline/delimiter.d.cts

@@ -0,0 +1,29 @@
+import { InlineNode } from "./node.cjs";
+//#region src/inline/delimiter.d.ts
+type DelimiterChar = '*' | '_' | '~';
+declare function isDelimiterChar(char: string): char is DelimiterChar;
+interface Delimiter {
+  readonly char: DelimiterChar;
+  count: number;
+  readonly origCount: number;
+  readonly canOpen: boolean;
+  readonly canClose: boolean;
+  readonly node: InlineNode;
+  previous: Delimiter | undefined;
+  next: Delimiter | undefined;
+}
+interface DelimiterRun {
+  readonly count: number;
+  readonly canOpen: boolean;
+  readonly canClose: boolean;
+}
+declare function scanDelimiterRun(text: string, start: number, char: DelimiterChar): DelimiterRun | undefined;
+declare class DelimiterStack {
+  top: Delimiter | undefined;
+  push(char: DelimiterChar, run: DelimiterRun, node: InlineNode): void;
+  remove(delimiter: Delimiter): void;
+}
+type EmphasisWrapperFactory = (kind: 'emphasis' | 'strong' | 'strikethrough', marker: DelimiterChar) => InlineNode;
+declare function processEmphasis(stack: DelimiterStack, stackBottom: Delimiter | undefined, createWrapper: EmphasisWrapperFactory): void;
+//#endregion
+export { Delimiter, DelimiterChar, DelimiterRun, DelimiterStack, EmphasisWrapperFactory, isDelimiterChar, processEmphasis, scanDelimiterRun };

package/dist/inline/delimiter.d.ts

@@ -0,0 +1,29 @@
+import { InlineNode } from "./node.js";
+//#region src/inline/delimiter.d.ts
+type DelimiterChar = '*' | '_' | '~';
+declare function isDelimiterChar(char: string): char is DelimiterChar;
+interface Delimiter {
+  readonly char: DelimiterChar;
+  count: number;
+  readonly origCount: number;
+  readonly canOpen: boolean;
+  readonly canClose: boolean;
+  readonly node: InlineNode;
+  previous: Delimiter | undefined;
+  next: Delimiter | undefined;
+}
+interface DelimiterRun {
+  readonly count: number;
+  readonly canOpen: boolean;
+  readonly canClose: boolean;
+}
+declare function scanDelimiterRun(text: string, start: number, char: DelimiterChar): DelimiterRun | undefined;
+declare class DelimiterStack {
+  top: Delimiter | undefined;
+  push(char: DelimiterChar, run: DelimiterRun, node: InlineNode): void;
+  remove(delimiter: Delimiter): void;
+}
+type EmphasisWrapperFactory = (kind: 'emphasis' | 'strong' | 'strikethrough', marker: DelimiterChar) => InlineNode;
+declare function processEmphasis(stack: DelimiterStack, stackBottom: Delimiter | undefined, createWrapper: EmphasisWrapperFactory): void;
+//#endregion
+export { Delimiter, DelimiterChar, DelimiterRun, DelimiterStack, EmphasisWrapperFactory, isDelimiterChar, processEmphasis, scanDelimiterRun };