markdown-codec 0.0.0 → 1.0.0

package/dist/block/line.cjs

@@ -0,0 +1,76 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_scan_scan = require("../scan/scan.cjs");
+//#region src/block/line.ts
+const CODE_INDENT_COLUMNS = 4;
+var LineCursor = class {
+	text;
+	cursor;
+	nextNonspaceMark;
+	nextNonspaceColumn = 0;
+	lineIsBlank = false;
+	constructor(text) {
+		this.text = text;
+		this.cursor = new require_scan_scan.MarkdownScanCursor(text);
+		this.nextNonspaceMark = this.cursor.mark();
+		this.findNextNonspace();
+	}
+	get column() {
+		return this.cursor.position.column;
+	}
+	get indent() {
+		return this.nextNonspaceColumn - this.cursor.position.column;
+	}
+	get indented() {
+		return this.indent >= 4;
+	}
+	get blank() {
+		return this.lineIsBlank;
+	}
+	get atEnd() {
+		return this.cursor.atEnd();
+	}
+	peek() {
+		return this.cursor.peek();
+	}
+	peekNextNonspace() {
+		const saved = this.cursor.mark();
+		this.cursor.reset(this.nextNonspaceMark);
+		const char = this.cursor.peek();
+		this.cursor.reset(saved);
+		return char;
+	}
+	findNextNonspace() {
+		const saved = this.cursor.mark();
+		while (this.cursor.peek() === " ") this.cursor.next();
+		this.nextNonspaceMark = this.cursor.mark();
+		this.nextNonspaceColumn = this.cursor.position.column;
+		this.lineIsBlank = this.cursor.peek() === void 0;
+		this.cursor.reset(saved);
+	}
+	advanceToNextNonspace() {
+		this.cursor.reset(this.nextNonspaceMark);
+	}
+	advance(columns) {
+		for (let remaining = columns; remaining > 0; remaining -= 1) if (this.cursor.next() === void 0) return;
+	}
+	advanceToEndOfLine() {
+		while (this.cursor.next() !== void 0);
+	}
+	rest() {
+		const mark = this.cursor.mark();
+		if (mark.pendingTabColumns > 0) return " ".repeat(mark.pendingTabColumns) + this.text.slice(mark.rawOffset + 1);
+		return this.text.slice(mark.rawOffset);
+	}
+	restFromNextNonspace() {
+		return this.text.slice(this.nextNonspaceMark.rawOffset);
+	}
+	mark() {
+		return this.cursor.mark();
+	}
+	reset(mark) {
+		this.cursor.reset(mark);
+	}
+};
+//#endregion
+exports.CODE_INDENT_COLUMNS = CODE_INDENT_COLUMNS;
+exports.LineCursor = LineCursor;

package/dist/block/line.d.cts

@@ -0,0 +1,28 @@
+import { r as MarkdownScanMark } from "../scan-DeBxgG-r.cjs";
+//#region src/block/line.d.ts
+declare const CODE_INDENT_COLUMNS = 4;
+declare class LineCursor {
+  readonly text: string;
+  private readonly cursor;
+  private nextNonspaceMark;
+  private nextNonspaceColumn;
+  private lineIsBlank;
+  constructor(text: string);
+  get column(): number;
+  get indent(): number;
+  get indented(): boolean;
+  get blank(): boolean;
+  get atEnd(): boolean;
+  peek(): string | undefined;
+  peekNextNonspace(): string | undefined;
+  findNextNonspace(): void;
+  advanceToNextNonspace(): void;
+  advance(columns: number): void;
+  advanceToEndOfLine(): void;
+  rest(): string;
+  restFromNextNonspace(): string;
+  mark(): MarkdownScanMark;
+  reset(mark: MarkdownScanMark): void;
+}
+//#endregion
+export { CODE_INDENT_COLUMNS, LineCursor };

package/dist/block/line.d.ts

@@ -0,0 +1,28 @@
+import { r as MarkdownScanMark } from "../scan-DeBxgG-r.js";
+//#region src/block/line.d.ts
+declare const CODE_INDENT_COLUMNS = 4;
+declare class LineCursor {
+  readonly text: string;
+  private readonly cursor;
+  private nextNonspaceMark;
+  private nextNonspaceColumn;
+  private lineIsBlank;
+  constructor(text: string);
+  get column(): number;
+  get indent(): number;
+  get indented(): boolean;
+  get blank(): boolean;
+  get atEnd(): boolean;
+  peek(): string | undefined;
+  peekNextNonspace(): string | undefined;
+  findNextNonspace(): void;
+  advanceToNextNonspace(): void;
+  advance(columns: number): void;
+  advanceToEndOfLine(): void;
+  rest(): string;
+  restFromNextNonspace(): string;
+  mark(): MarkdownScanMark;
+  reset(mark: MarkdownScanMark): void;
+}
+//#endregion
+export { CODE_INDENT_COLUMNS, LineCursor };

package/dist/block/line.js

@@ -0,0 +1,74 @@
+import { MarkdownScanCursor } from "../scan/scan.js";
+//#region src/block/line.ts
+const CODE_INDENT_COLUMNS = 4;
+var LineCursor = class {
+	text;
+	cursor;
+	nextNonspaceMark;
+	nextNonspaceColumn = 0;
+	lineIsBlank = false;
+	constructor(text) {
+		this.text = text;
+		this.cursor = new MarkdownScanCursor(text);
+		this.nextNonspaceMark = this.cursor.mark();
+		this.findNextNonspace();
+	}
+	get column() {
+		return this.cursor.position.column;
+	}
+	get indent() {
+		return this.nextNonspaceColumn - this.cursor.position.column;
+	}
+	get indented() {
+		return this.indent >= 4;
+	}
+	get blank() {
+		return this.lineIsBlank;
+	}
+	get atEnd() {
+		return this.cursor.atEnd();
+	}
+	peek() {
+		return this.cursor.peek();
+	}
+	peekNextNonspace() {
+		const saved = this.cursor.mark();
+		this.cursor.reset(this.nextNonspaceMark);
+		const char = this.cursor.peek();
+		this.cursor.reset(saved);
+		return char;
+	}
+	findNextNonspace() {
+		const saved = this.cursor.mark();
+		while (this.cursor.peek() === " ") this.cursor.next();
+		this.nextNonspaceMark = this.cursor.mark();
+		this.nextNonspaceColumn = this.cursor.position.column;
+		this.lineIsBlank = this.cursor.peek() === void 0;
+		this.cursor.reset(saved);
+	}
+	advanceToNextNonspace() {
+		this.cursor.reset(this.nextNonspaceMark);
+	}
+	advance(columns) {
+		for (let remaining = columns; remaining > 0; remaining -= 1) if (this.cursor.next() === void 0) return;
+	}
+	advanceToEndOfLine() {
+		while (this.cursor.next() !== void 0);
+	}
+	rest() {
+		const mark = this.cursor.mark();
+		if (mark.pendingTabColumns > 0) return " ".repeat(mark.pendingTabColumns) + this.text.slice(mark.rawOffset + 1);
+		return this.text.slice(mark.rawOffset);
+	}
+	restFromNextNonspace() {
+		return this.text.slice(this.nextNonspaceMark.rawOffset);
+	}
+	mark() {
+		return this.cursor.mark();
+	}
+	reset(mark) {
+		this.cursor.reset(mark);
+	}
+};
+//#endregion
+export { CODE_INDENT_COLUMNS, LineCursor };

package/dist/block/list.cjs

@@ -0,0 +1,110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./line.cjs");
+//#region src/block/list.ts
+const BULLET_MARKER_PATTERN = /^[*+-]/;
+const ORDERED_MARKER_PATTERN = /^(\d{1,9})([.)])/;
+const NON_SPACE_PATTERN = /[^ \t\f\v\r\n]/;
+const INTERRUPTING_ORDERED_START = 1;
+function isBulletMarker(char) {
+	return char === "-" || char === "*" || char === "+";
+}
+function isOrderedDelimiter(char) {
+	return char === "." || char === ")";
+}
+function matchMarker(rest, indent, containerIsParagraph) {
+	const bullet = BULLET_MARKER_PATTERN.exec(rest);
+	if (bullet !== null) {
+		const char = bullet[0];
+		if (!isBulletMarker(char)) return;
+		return {
+			length: bullet[0].length,
+			data: {
+				type: "bullet",
+				bulletChar: char,
+				markerOffset: indent
+			}
+		};
+	}
+	const ordered = ORDERED_MARKER_PATTERN.exec(rest);
+	const digits = ordered?.[1];
+	const delimiter = ordered?.[2];
+	if (ordered === null || digits === void 0 || delimiter === void 0 || !isOrderedDelimiter(delimiter)) return;
+	const start = Number.parseInt(digits, 10);
+	if (containerIsParagraph && start !== INTERRUPTING_ORDERED_START) return;
+	return {
+		length: ordered[0].length,
+		data: {
+			type: "ordered",
+			delimiter,
+			start,
+			markerOffset: indent
+		}
+	};
+}
+function parseListMarker(line, containerIsParagraph) {
+	if (line.indented) return;
+	const rest = line.restFromNextNonspace();
+	const match = matchMarker(rest, line.indent, containerIsParagraph);
+	if (match === void 0) return;
+	const afterMarker = rest.charAt(match.length);
+	if (afterMarker !== "" && afterMarker !== " " && afterMarker !== "	") return;
+	if (containerIsParagraph && !NON_SPACE_PATTERN.test(rest.slice(match.length))) return;
+	line.advanceToNextNonspace();
+	line.advance(match.length);
+	const afterMarkerMark = line.mark();
+	const afterMarkerColumn = line.column;
+	do
+		line.advance(1);
+	while (line.column - afterMarkerColumn <= 4 && line.peek() === " ");
+	const followingSpaces = line.column - afterMarkerColumn;
+	const startsBlank = line.atEnd;
+	if (followingSpaces > 4 || followingSpaces < 1 || startsBlank) {
+		line.reset(afterMarkerMark);
+		if (line.peek() === " ") line.advance(1);
+		return {
+			...match.data,
+			padding: match.length + 1
+		};
+	}
+	return {
+		...match.data,
+		padding: match.length + followingSpaces
+	};
+}
+function listsMatch(a, b) {
+	return a.type === b.type && a.delimiter === b.delimiter && a.bulletChar === b.bulletChar;
+}
+function endsWithBlankLine(block) {
+	let current = block;
+	while (current !== void 0) {
+		if (current.lastLineBlank) return true;
+		if (!current.lastLineChecked && (current.kind === "list" || current.kind === "listItem")) {
+			current.lastLineChecked = true;
+			current = current.lastChild;
+			continue;
+		}
+		current.lastLineChecked = true;
+		return false;
+	}
+	return false;
+}
+function finalizeListTightness(list) {
+	for (const [index, item] of list.children.entries()) {
+		const hasFollowingItem = index < list.children.length - 1;
+		if (hasFollowingItem && endsWithBlankLine(item)) {
+			list.tight = false;
+			return;
+		}
+		for (const [childIndex, child] of item.children.entries()) {
+			const hasFollowingBlock = childIndex < item.children.length - 1;
+			if ((hasFollowingItem || hasFollowingBlock) && endsWithBlankLine(child)) {
+				list.tight = false;
+				return;
+			}
+		}
+	}
+}
+//#endregion
+exports.finalizeListTightness = finalizeListTightness;
+exports.listsMatch = listsMatch;
+exports.parseListMarker = parseListMarker;

package/dist/block/list.d.cts

@@ -0,0 +1,8 @@
+import { LineCursor } from "./line.cjs";
+import { BlockNode, ListMarkerData } from "./node.cjs";
+//#region src/block/list.d.ts
+declare function parseListMarker(line: LineCursor, containerIsParagraph: boolean): ListMarkerData | undefined;
+declare function listsMatch(a: ListMarkerData, b: ListMarkerData): boolean;
+declare function finalizeListTightness(list: BlockNode): void;
+//#endregion
+export { finalizeListTightness, listsMatch, parseListMarker };

package/dist/block/list.d.ts

@@ -0,0 +1,8 @@
+import { LineCursor } from "./line.js";
+import { BlockNode, ListMarkerData } from "./node.js";
+//#region src/block/list.d.ts
+declare function parseListMarker(line: LineCursor, containerIsParagraph: boolean): ListMarkerData | undefined;
+declare function listsMatch(a: ListMarkerData, b: ListMarkerData): boolean;
+declare function finalizeListTightness(list: BlockNode): void;
+//#endregion
+export { finalizeListTightness, listsMatch, parseListMarker };

package/dist/block/list.js

@@ -0,0 +1,107 @@
+import "./line.js";
+//#region src/block/list.ts
+const BULLET_MARKER_PATTERN = /^[*+-]/;
+const ORDERED_MARKER_PATTERN = /^(\d{1,9})([.)])/;
+const NON_SPACE_PATTERN = /[^ \t\f\v\r\n]/;
+const INTERRUPTING_ORDERED_START = 1;
+function isBulletMarker(char) {
+	return char === "-" || char === "*" || char === "+";
+}
+function isOrderedDelimiter(char) {
+	return char === "." || char === ")";
+}
+function matchMarker(rest, indent, containerIsParagraph) {
+	const bullet = BULLET_MARKER_PATTERN.exec(rest);
+	if (bullet !== null) {
+		const char = bullet[0];
+		if (!isBulletMarker(char)) return;
+		return {
+			length: bullet[0].length,
+			data: {
+				type: "bullet",
+				bulletChar: char,
+				markerOffset: indent
+			}
+		};
+	}
+	const ordered = ORDERED_MARKER_PATTERN.exec(rest);
+	const digits = ordered?.[1];
+	const delimiter = ordered?.[2];
+	if (ordered === null || digits === void 0 || delimiter === void 0 || !isOrderedDelimiter(delimiter)) return;
+	const start = Number.parseInt(digits, 10);
+	if (containerIsParagraph && start !== INTERRUPTING_ORDERED_START) return;
+	return {
+		length: ordered[0].length,
+		data: {
+			type: "ordered",
+			delimiter,
+			start,
+			markerOffset: indent
+		}
+	};
+}
+function parseListMarker(line, containerIsParagraph) {
+	if (line.indented) return;
+	const rest = line.restFromNextNonspace();
+	const match = matchMarker(rest, line.indent, containerIsParagraph);
+	if (match === void 0) return;
+	const afterMarker = rest.charAt(match.length);
+	if (afterMarker !== "" && afterMarker !== " " && afterMarker !== "	") return;
+	if (containerIsParagraph && !NON_SPACE_PATTERN.test(rest.slice(match.length))) return;
+	line.advanceToNextNonspace();
+	line.advance(match.length);
+	const afterMarkerMark = line.mark();
+	const afterMarkerColumn = line.column;
+	do
+		line.advance(1);
+	while (line.column - afterMarkerColumn <= 4 && line.peek() === " ");
+	const followingSpaces = line.column - afterMarkerColumn;
+	const startsBlank = line.atEnd;
+	if (followingSpaces > 4 || followingSpaces < 1 || startsBlank) {
+		line.reset(afterMarkerMark);
+		if (line.peek() === " ") line.advance(1);
+		return {
+			...match.data,
+			padding: match.length + 1
+		};
+	}
+	return {
+		...match.data,
+		padding: match.length + followingSpaces
+	};
+}
+function listsMatch(a, b) {
+	return a.type === b.type && a.delimiter === b.delimiter && a.bulletChar === b.bulletChar;
+}
+function endsWithBlankLine(block) {
+	let current = block;
+	while (current !== void 0) {
+		if (current.lastLineBlank) return true;
+		if (!current.lastLineChecked && (current.kind === "list" || current.kind === "listItem")) {
+			current.lastLineChecked = true;
+			current = current.lastChild;
+			continue;
+		}
+		current.lastLineChecked = true;
+		return false;
+	}
+	return false;
+}
+function finalizeListTightness(list) {
+	for (const [index, item] of list.children.entries()) {
+		const hasFollowingItem = index < list.children.length - 1;
+		if (hasFollowingItem && endsWithBlankLine(item)) {
+			list.tight = false;
+			return;
+		}
+		for (const [childIndex, child] of item.children.entries()) {
+			const hasFollowingBlock = childIndex < item.children.length - 1;
+			if ((hasFollowingItem || hasFollowingBlock) && endsWithBlankLine(child)) {
+				list.tight = false;
+				return;
+			}
+		}
+	}
+}
+//#endregion
+export { finalizeListTightness, listsMatch, parseListMarker };

package/dist/block/node.cjs

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/block/node.ts
+var BlockNode = class {
+	kind;
+	parent;
+	children = [];
+	open = true;
+	startLine = 0;
+	content = "";
+	lastLineBlank = false;
+	lastLineChecked = false;
+	level = 1;
+	setext = false;
+	fenced = false;
+	fenceChar = "`";
+	fenceLength = 0;
+	fenceOffset = 0;
+	infoString = "";
+	literal = "";
+	htmlBlockType = 1;
+	listData;
+	tight = true;
+	alignments = [];
+	headerLine = "";
+	constructor(kind, startLine) {
+		this.kind = kind;
+		this.startLine = startLine;
+	}
+	get lastChild() {
+		return this.children.at(-1);
+	}
+	appendChild(child) {
+		child.parent = this;
+		this.children.push(child);
+	}
+	replaceWith(replacement) {
+		const parent = this.parent;
+		if (parent === void 0) return;
+		const index = parent.children.indexOf(this);
+		if (index === -1) return;
+		parent.children[index] = replacement;
+		replacement.parent = parent;
+		this.parent = void 0;
+	}
+	unlink() {
+		const parent = this.parent;
+		if (parent === void 0) return;
+		const index = parent.children.indexOf(this);
+		if (index !== -1) parent.children.splice(index, 1);
+		this.parent = void 0;
+	}
+};
+function canContain(parent, child) {
+	switch (parent) {
+		case "document":
+		case "blockquote":
+		case "listItem": return child !== "listItem";
+		case "list": return child === "listItem";
+		default: return false;
+	}
+}
+function acceptsLines(kind) {
+	return kind === "paragraph" || kind === "codeBlock" || kind === "htmlBlock" || kind === "table";
+}
+//#endregion
+exports.BlockNode = BlockNode;
+exports.acceptsLines = acceptsLines;
+exports.canContain = canContain;

package/dist/block/node.d.cts

@@ -0,0 +1,45 @@
+import { S as MarkdownOrderedListDelimiter, i as MarkdownBulletMarker, k as MarkdownTableAlignment } from "../ast-BXYwy08e.cjs";
+import { t as HtmlBlockType } from "../html-bkz2QTuq.cjs";
+//#region src/block/node.d.ts
+type BlockNodeKind = 'document' | 'paragraph' | 'heading' | 'blockquote' | 'list' | 'listItem' | 'codeBlock' | 'htmlBlock' | 'thematicBreak' | 'table';
+type BlockHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+interface ListMarkerData {
+  readonly type: 'bullet' | 'ordered';
+  readonly bulletChar?: MarkdownBulletMarker;
+  readonly delimiter?: MarkdownOrderedListDelimiter;
+  readonly start?: number;
+  readonly padding: number;
+  readonly markerOffset: number;
+}
+declare class BlockNode {
+  readonly kind: BlockNodeKind;
+  parent: BlockNode | undefined;
+  readonly children: BlockNode[];
+  open: boolean;
+  startLine: number;
+  content: string;
+  lastLineBlank: boolean;
+  lastLineChecked: boolean;
+  level: BlockHeadingLevel;
+  setext: boolean;
+  fenced: boolean;
+  fenceChar: '`' | '~';
+  fenceLength: number;
+  fenceOffset: number;
+  infoString: string;
+  literal: string;
+  htmlBlockType: HtmlBlockType;
+  listData: ListMarkerData | undefined;
+  tight: boolean;
+  alignments: MarkdownTableAlignment[];
+  headerLine: string;
+  constructor(kind: BlockNodeKind, startLine: number);
+  get lastChild(): BlockNode | undefined;
+  appendChild(child: BlockNode): void;
+  replaceWith(replacement: BlockNode): void;
+  unlink(): void;
+}
+declare function canContain(parent: BlockNodeKind, child: BlockNodeKind): boolean;
+declare function acceptsLines(kind: BlockNodeKind): boolean;
+//#endregion
+export { BlockHeadingLevel, BlockNode, BlockNodeKind, ListMarkerData, acceptsLines, canContain };

package/dist/block/node.d.ts

@@ -0,0 +1,45 @@
+import { S as MarkdownOrderedListDelimiter, i as MarkdownBulletMarker, k as MarkdownTableAlignment } from "../ast-BXYwy08e.js";
+import { t as HtmlBlockType } from "../html-bkz2QTuq.js";
+//#region src/block/node.d.ts
+type BlockNodeKind = 'document' | 'paragraph' | 'heading' | 'blockquote' | 'list' | 'listItem' | 'codeBlock' | 'htmlBlock' | 'thematicBreak' | 'table';
+type BlockHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+interface ListMarkerData {
+  readonly type: 'bullet' | 'ordered';
+  readonly bulletChar?: MarkdownBulletMarker;
+  readonly delimiter?: MarkdownOrderedListDelimiter;
+  readonly start?: number;
+  readonly padding: number;
+  readonly markerOffset: number;
+}
+declare class BlockNode {
+  readonly kind: BlockNodeKind;
+  parent: BlockNode | undefined;
+  readonly children: BlockNode[];
+  open: boolean;
+  startLine: number;
+  content: string;
+  lastLineBlank: boolean;
+  lastLineChecked: boolean;
+  level: BlockHeadingLevel;
+  setext: boolean;
+  fenced: boolean;
+  fenceChar: '`' | '~';
+  fenceLength: number;
+  fenceOffset: number;
+  infoString: string;
+  literal: string;
+  htmlBlockType: HtmlBlockType;
+  listData: ListMarkerData | undefined;
+  tight: boolean;
+  alignments: MarkdownTableAlignment[];
+  headerLine: string;
+  constructor(kind: BlockNodeKind, startLine: number);
+  get lastChild(): BlockNode | undefined;
+  appendChild(child: BlockNode): void;
+  replaceWith(replacement: BlockNode): void;
+  unlink(): void;
+}
+declare function canContain(parent: BlockNodeKind, child: BlockNodeKind): boolean;
+declare function acceptsLines(kind: BlockNodeKind): boolean;
+//#endregion
+export { BlockHeadingLevel, BlockNode, BlockNodeKind, ListMarkerData, acceptsLines, canContain };

package/dist/block/node.js

@@ -0,0 +1,65 @@
+//#region src/block/node.ts
+var BlockNode = class {
+	kind;
+	parent;
+	children = [];
+	open = true;
+	startLine = 0;
+	content = "";
+	lastLineBlank = false;
+	lastLineChecked = false;
+	level = 1;
+	setext = false;
+	fenced = false;
+	fenceChar = "`";
+	fenceLength = 0;
+	fenceOffset = 0;
+	infoString = "";
+	literal = "";
+	htmlBlockType = 1;
+	listData;
+	tight = true;
+	alignments = [];
+	headerLine = "";
+	constructor(kind, startLine) {
+		this.kind = kind;
+		this.startLine = startLine;
+	}
+	get lastChild() {
+		return this.children.at(-1);
+	}
+	appendChild(child) {
+		child.parent = this;
+		this.children.push(child);
+	}
+	replaceWith(replacement) {
+		const parent = this.parent;
+		if (parent === void 0) return;
+		const index = parent.children.indexOf(this);
+		if (index === -1) return;
+		parent.children[index] = replacement;
+		replacement.parent = parent;
+		this.parent = void 0;
+	}
+	unlink() {
+		const parent = this.parent;
+		if (parent === void 0) return;
+		const index = parent.children.indexOf(this);
+		if (index !== -1) parent.children.splice(index, 1);
+		this.parent = void 0;
+	}
+};
+function canContain(parent, child) {
+	switch (parent) {
+		case "document":
+		case "blockquote":
+		case "listItem": return child !== "listItem";
+		case "list": return child === "listItem";
+		default: return false;
+	}
+}
+function acceptsLines(kind) {
+	return kind === "paragraph" || kind === "codeBlock" || kind === "htmlBlock" || kind === "table";
+}
+//#endregion
+export { BlockNode, acceptsLines, canContain };