@simple-mark/model 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 one-prime
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @simple-mark/model
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Markdown model behind [SimpleMark](https://github.com/one-prime/simple-mark): Markdown
+that never hides its syntax. Pure TypeScript, no DOM — usable in a browser, a worker, Node
+or a canvas renderer.
+
+- Parses CommonMark + GFM + `$math$` (Lezer) into **styled ranges**: line styles (headings,
+  quotes, code blocks, tables, …) and non-overlapping inline spans (strong, em, code, link,
+  and `mark` for the syntax characters, which stay visible and dimmed).
+- A **theme** as plain data, and `resolveLook` to turn styles into font/color properties.
+- **Tables**: display width (Korean, Chinese, Japanese count as two columns), row splitting,
+  and re-aligning a table by padding its cells.
+
+```ts
+import { markdownParser, markdownStyles, resolveLook, defaultTheme, parseTable, renderTable } from '@simple-mark/model';
+
+const { blocks, spans } = markdownStyles(markdownParser.parse('# Hi **there**'));
+const look = resolveLook(['h1'], ['strong'], defaultTheme);
+const aligned = renderTable(parseTable(['|a|b|', '|-|-:|', '|한글|2|'])).lines;
+```
+
+MIT

package/index.d.ts

@@ -0,0 +1,116 @@
+import { MarkdownExtension } from "@lezer/markdown";
+import { Tree } from "@lezer/common";
+//#region packages/model/src/parser.d.ts
+/** The Markdown flavor every SimpleMark renderer parses: CommonMark + GFM + $math$. */
+export declare const markdownExtensions: MarkdownExtension[];
+/** A Lezer parser for that flavor, for hosts without CodeMirror (e.g. a canvas renderer). */
+export declare const markdownParser: import("@lezer/markdown").MarkdownParser;
+//#endregion
+//#region packages/model/src/styles.d.ts
+/** Styles of whole lines, in precedence order (later wins when two set the same property). */
+export declare const BLOCK_STYLES: readonly ['quote', 'codeblock', 'mathblock', 'table', 'tableHeader', 'tableRowAlt', 'hr', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+type BlockStyle = (typeof BLOCK_STYLES)[number];
+/** Styles of text ranges, in precedence order ("mark" last, so markers stay dimmed everywhere). */
+export declare const INLINE_STYLES: readonly ['link', 'strong', 'em', 'strike', 'code', 'math', 'url', 'mark'];
+type InlineStyle = (typeof INLINE_STYLES)[number];
+/** A block construct; every line it touches gets `style`. Blocks may nest (a heading in a quote). */
+interface BlockRange {
+  from: number;
+  to: number;
+  style: BlockStyle;
+}
+/** A run of text with the same inline styles. Spans never overlap and are sorted by position. */
+interface Span {
+  from: number;
+  to: number;
+  /** In `INLINE_STYLES` order. */
+  styles: InlineStyle[];
+}
+interface MarkdownStyles {
+  blocks: BlockRange[];
+  spans: Span[];
+}
+/**
+ * Styles for the part of `tree` between `from` and `to` (a viewport). The range grows to whole
+ * top-level blocks, so constructs that cross its edges keep both their markers.
+ */
+export declare function markdownStyles(tree: Tree, from?: number, to?: number): MarkdownStyles;
+/** Overlapping styled ranges as sorted, non-overlapping spans; equal neighbours are merged. */
+export declare function flattenSpans(ranges: readonly {
+  from: number;
+  to: number;
+  style: InlineStyle;
+}[]): Span[];
+//#endregion
+//#region packages/model/src/table.d.ts
+/** Columns a character takes in a monospace font: 0, 1 or 2. */
+export declare function charWidth(codePoint: number): 0 | 1 | 2;
+/** Columns `text` takes in a monospace font ("지민" → 4). */
+export declare function displayWidth(text: string): number;
+type ColumnAlign = 'none' | 'left' | 'center' | 'right';
+/** A cell of a row: the raw text between two pipes (spaces included). */
+interface RowCell {
+  from: number;
+  to: number;
+}
+/**
+ * The cells of a table row. Pipes split cells unless escaped (`\|`); outer pipes are
+ * optional, as in GFM.
+ */
+export declare function splitRow(row: string): RowCell[];
+/** The index of the cell containing `offset` in `row` (outer pipes count toward their cell). */
+export declare function cellAt(row: string, offset: number): number;
+/** A table's content: the delimiter row becomes `aligns`; `rows[0]` is the header. */
+interface Table {
+  aligns: ColumnAlign[];
+  /** Trimmed cell texts. Rows may hold more cells than columns; the extra text is kept. */
+  rows: string[][];
+}
+/** Reads table lines (header, delimiter, body rows) without any line prefix such as "> ". */
+export declare function parseTable(lines: readonly string[]): Table;
+/** The line of `lines` that holds table row `row` (the delimiter line sits between rows 0 and 1). */
+export declare function rowLine(row: number): number;
+interface RenderedTable {
+  lines: string[];
+  /** Where each cell's text lies in its line: `cells[row][col]`, row as in `Table.rows`. */
+  cells: RowCell[][];
+}
+/** The table as aligned lines: `| cell | cell |`, columns padded to their widest cell. */
+export declare function renderTable(table: Table): RenderedTable;
+//#endregion
+//#region packages/model/src/theme.d.ts
+/** Text properties. Unset properties are inherited (from the line, then the base text). */
+interface Look {
+  /** Font size relative to the base size (1 = unchanged). Meant for block styles. */
+  fontScale?: number;
+  /** 100–900, as in CSS. */
+  fontWeight?: number;
+  italic?: boolean;
+  monospace?: boolean;
+  color?: string;
+  /** Behind the styled text only (e.g. inline code). */
+  background?: string;
+  strike?: boolean;
+  underline?: boolean;
+}
+/** Properties of whole lines. */
+interface LineLook extends Look {
+  /** Behind the full width of the line (e.g. code blocks). */
+  lineBackground?: string;
+  /** A bar along the left edge of the line (e.g. quotes). */
+  borderLeft?: string;
+}
+interface Theme {
+  fontFamily: string;
+  monospaceFamily: string;
+  color: string;
+  block: Record<BlockStyle, LineLook>;
+  inline: Record<InlineStyle, Look>;
+}
+export declare const defaultTheme: Theme;
+/** The look of a line with these block styles (any order). */
+export declare function resolveLineLook(blocks: Iterable<BlockStyle>, theme?: Theme): LineLook;
+/** The look of text with these block and inline styles (any order). */
+export declare function resolveLook(blocks: Iterable<BlockStyle>, inline: Iterable<InlineStyle>, theme?: Theme): Look;
+//#endregion
+export type { BlockRange, BlockStyle, ColumnAlign, InlineStyle, LineLook, Look, MarkdownStyles, RenderedTable, RowCell, Span, Table, Theme };

package/index.js

@@ -0,0 +1,508 @@
+import { GFM, parser } from "@lezer/markdown";
+//#region packages/model/src/math-syntax.ts
+const DOLLAR = 36;
+const BACKSLASH = 92;
+const isSpace = (ch) => ch === 32 || ch === 9 || ch === 10 || ch === 13;
+const isDigit = (ch) => ch >= 48 && ch <= 57;
+/**
+* Inline math: an opening `$` not followed by a space, a closing `$` not preceded by a space
+* nor followed by a digit ("$5 and $10" stays text). `$$...$$` works the same way.
+*/
+const inlineMath = {
+	name: "InlineMath",
+	before: "InlineCode",
+	parse(cx, next, start) {
+		if (next !== DOLLAR) return -1;
+		const size = cx.char(start + 1) === DOLLAR ? 2 : 1;
+		const contentStart = start + size;
+		if (contentStart >= cx.end || isSpace(cx.char(contentStart)) || cx.char(contentStart) === DOLLAR) return -1;
+		for (let pos = contentStart; pos < cx.end; pos++) {
+			const ch = cx.char(pos);
+			if (ch === BACKSLASH) {
+				pos++;
+				continue;
+			}
+			if (ch !== DOLLAR) continue;
+			if (!(size === 1 || cx.char(pos + 1) === DOLLAR) || isSpace(cx.char(pos - 1))) {
+				if (size === 2) pos++;
+				continue;
+			}
+			const end = pos + size;
+			if (size === 1 && isDigit(cx.char(end))) continue;
+			return cx.addElement(cx.elt("InlineMath", start, end, [cx.elt("MathMark", start, contentStart), cx.elt("MathMark", pos, end)]));
+		}
+		return -1;
+	}
+};
+/** Where `$$` opens a block: at the line's content start, not indented as code. */
+function opensBlock(line) {
+	return line.next === DOLLAR && line.text.charCodeAt(line.pos + 1) === DOLLAR && line.indent - line.baseIndent < 4;
+}
+/**
+* Whether `line` still belongs to every container (quote, list item) around the block. Lezer
+* sets `depth` on each line but leaves it out of its types; its own fenced code checks it the
+* same way. A quote ending ends the math block, as it ends a code block.
+*/
+function inContainers(cx, line) {
+	const depth = line.depth;
+	return depth === void 0 || depth >= cx.depth;
+}
+//#endregion
+//#region packages/model/src/parser.ts
+/** The Markdown flavor every SimpleMark renderer parses: CommonMark + GFM + $math$. */
+const markdownExtensions = [GFM, {
+	defineNodes: [
+		{
+			name: "BlockMath",
+			block: true
+		},
+		{ name: "InlineMath" },
+		{ name: "MathMark" },
+		{ name: "MathText" }
+	],
+	parseBlock: [{
+		name: "BlockMath",
+		before: "FencedCode",
+		parse(cx, line) {
+			if (!opensBlock(line)) return false;
+			const start = cx.lineStart + line.pos;
+			const children = [cx.elt("MathMark", start, start + 2)];
+			const first = line.text.slice(line.pos + 2);
+			const sameLine = /^(.*\S.*?)\$\$\s*$/.exec(first);
+			if (sameLine) {
+				const close = start + 2 + sameLine[1].length;
+				children.push(cx.elt("MathText", start + 2, close), cx.elt("MathMark", close, close + 2));
+				cx.nextLine();
+				cx.addElement(cx.elt("BlockMath", start, close + 2, children));
+				return true;
+			}
+			if (first.trim()) children.push(cx.elt("MathText", start + 2, cx.lineStart + line.text.length));
+			let end = cx.lineStart + line.text.length;
+			while (cx.nextLine() && inContainers(cx, line)) {
+				children.push(...line.markers);
+				const text = line.text.slice(line.pos);
+				const textStart = cx.lineStart + line.pos;
+				const close = text.indexOf("$$");
+				if (close >= 0 && !text.slice(close + 2).trim()) {
+					if (close > 0) children.push(cx.elt("MathText", textStart, textStart + close));
+					children.push(cx.elt("MathMark", textStart + close, textStart + close + 2));
+					end = textStart + close + 2;
+					cx.nextLine();
+					break;
+				}
+				if (text) children.push(cx.elt("MathText", textStart, cx.lineStart + line.text.length));
+				end = cx.lineStart + line.text.length;
+			}
+			cx.addElement(cx.elt("BlockMath", start, end, children));
+			return true;
+		},
+		endLeaf: (_cx, line) => opensBlock(line)
+	}],
+	parseInline: [inlineMath]
+}];
+/** A Lezer parser for that flavor, for hosts without CodeMirror (e.g. a canvas renderer). */
+const markdownParser = parser.configure(markdownExtensions);
+//#endregion
+//#region packages/model/src/styles.ts
+/** Styles of whole lines, in precedence order (later wins when two set the same property). */
+const BLOCK_STYLES = [
+	"quote",
+	"codeblock",
+	"mathblock",
+	"table",
+	"tableHeader",
+	"tableRowAlt",
+	"hr",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+];
+/** Styles of text ranges, in precedence order ("mark" last, so markers stay dimmed everywhere). */
+const INLINE_STYLES = [
+	"link",
+	"strong",
+	"em",
+	"strike",
+	"code",
+	"math",
+	"url",
+	"mark"
+];
+const BLOCK_NODES = {
+	ATXHeading1: "h1",
+	ATXHeading2: "h2",
+	ATXHeading3: "h3",
+	ATXHeading4: "h4",
+	ATXHeading5: "h5",
+	ATXHeading6: "h6",
+	SetextHeading1: "h1",
+	SetextHeading2: "h2",
+	FencedCode: "codeblock",
+	CodeBlock: "codeblock",
+	BlockMath: "mathblock",
+	Blockquote: "quote",
+	HorizontalRule: "hr",
+	Table: "table",
+	TableHeader: "tableHeader"
+};
+const INLINE_NODES = {
+	StrongEmphasis: "strong",
+	Emphasis: "em",
+	Strikethrough: "strike",
+	InlineCode: "code",
+	InlineMath: "math",
+	Link: "link",
+	Image: "link",
+	Autolink: "link",
+	HeaderMark: "mark",
+	EmphasisMark: "mark",
+	StrikethroughMark: "mark",
+	CodeMark: "mark",
+	CodeInfo: "mark",
+	LinkMark: "mark",
+	LinkLabel: "mark",
+	LinkTitle: "mark",
+	QuoteMark: "mark",
+	ListMark: "mark",
+	TaskMarker: "mark",
+	TableDelimiter: "mark",
+	HorizontalRule: "mark",
+	MathMark: "mark"
+};
+/** Where a URL is the target of a link (dimmed) rather than the visible text (a bare autolink). */
+const LINK_TARGET_PARENTS = /* @__PURE__ */ new Set([
+	"Link",
+	"Image",
+	"LinkReference"
+]);
+function inlineStyle(node) {
+	if (node.name === "URL") return LINK_TARGET_PARENTS.has(node.node.parent?.name ?? "") ? "url" : "link";
+	return INLINE_NODES[node.name];
+}
+/**
+* The top-level block (a child of the document) at `pos`, or null between blocks. `side`
+* picks the block starting (1) or ending (-1) at `pos`.
+*/
+function topLevelBlock(tree, pos, side) {
+	let node = tree.resolve(pos, side);
+	while (node?.parent?.parent) node = node.parent;
+	return node?.parent ? node : null;
+}
+/**
+* Styles for the part of `tree` between `from` and `to` (a viewport). The range grows to whole
+* top-level blocks, so constructs that cross its edges keep both their markers.
+*/
+function markdownStyles(tree, from = 0, to = tree.length) {
+	from = Math.min(from, topLevelBlock(tree, from, 1)?.from ?? from);
+	to = Math.max(to, topLevelBlock(tree, to, -1)?.to ?? to);
+	const blocks = [];
+	const inline = [];
+	let tableRows = 0;
+	tree.iterate({
+		from,
+		to,
+		enter(node) {
+			const block = BLOCK_NODES[node.name];
+			if (block) blocks.push({
+				from: node.from,
+				to: node.to,
+				style: block
+			});
+			if (node.name === "Table") tableRows = 0;
+			if (node.name === "TableRow" && ++tableRows % 2 === 0) blocks.push({
+				from: node.from,
+				to: node.to,
+				style: "tableRowAlt"
+			});
+			if (node.name === "Escape") {
+				inline.push({
+					from: node.from,
+					to: node.from + 1,
+					style: "mark"
+				});
+				return;
+			}
+			const style = inlineStyle(node);
+			if (style && node.to > node.from) inline.push({
+				from: node.from,
+				to: node.to,
+				style
+			});
+		}
+	});
+	return {
+		blocks,
+		spans: flattenSpans(inline)
+	};
+}
+/** Overlapping styled ranges as sorted, non-overlapping spans; equal neighbours are merged. */
+function flattenSpans(ranges) {
+	const events = [];
+	for (const r of ranges) {
+		if (r.to <= r.from) continue;
+		const index = INLINE_STYLES.indexOf(r.style);
+		events.push({
+			pos: r.from,
+			index,
+			delta: 1
+		}, {
+			pos: r.to,
+			index,
+			delta: -1
+		});
+	}
+	events.sort((a, b) => a.pos - b.pos);
+	const counts = new Array(INLINE_STYLES.length).fill(0);
+	const spans = [];
+	let i = 0;
+	while (i < events.length) {
+		const pos = events[i].pos;
+		for (; i < events.length && events[i].pos === pos; i++) counts[events[i].index] += events[i].delta;
+		if (i === events.length) break;
+		const styles = INLINE_STYLES.filter((_, k) => counts[k] > 0);
+		if (!styles.length) continue;
+		const end = events[i].pos;
+		const last = spans.at(-1);
+		if (last && last.to === pos && sameStyles(last.styles, styles)) last.to = end;
+		else spans.push({
+			from: pos,
+			to: end,
+			styles
+		});
+	}
+	return spans;
+}
+function sameStyles(a, b) {
+	return a.length === b.length && a.every((s, k) => s === b[k]);
+}
+//#endregion
+//#region packages/model/src/table.ts
+/** Characters drawn two columns wide in a monospace font (East Asian Wide and Fullwidth). */
+const WIDE = [
+	[4352, 4447],
+	[11904, 12350],
+	[12353, 13311],
+	[13312, 19903],
+	[19968, 40959],
+	[40960, 42191],
+	[43360, 43391],
+	[44032, 55203],
+	[63744, 64255],
+	[65040, 65049],
+	[65072, 65135],
+	[65280, 65376],
+	[65504, 65510],
+	[127744, 128591],
+	[129280, 129535],
+	[131072, 262141]
+];
+/** Characters that take no column of their own (combining marks, joiners, variation selectors). */
+const ZERO = [
+	[768, 879],
+	[4448, 4607],
+	[6832, 6911],
+	[7616, 7679],
+	[8203, 8207],
+	[8400, 8447],
+	[55216, 55295],
+	[65024, 65039],
+	[65056, 65071]
+];
+const inRanges = (ranges, cp) => ranges.some(([lo, hi]) => cp >= lo && cp <= hi);
+/** Columns a character takes in a monospace font: 0, 1 or 2. */
+function charWidth(codePoint) {
+	if (codePoint < 768) return 1;
+	if (inRanges(ZERO, codePoint)) return 0;
+	return inRanges(WIDE, codePoint) ? 2 : 1;
+}
+/** Columns `text` takes in a monospace font ("지민" → 4). */
+function displayWidth(text) {
+	let width = 0;
+	for (const ch of text) width += charWidth(ch.codePointAt(0));
+	return width;
+}
+/**
+* The cells of a table row. Pipes split cells unless escaped (`\|`); outer pipes are
+* optional, as in GFM.
+*/
+function splitRow(row) {
+	const pipes = [];
+	for (let i = 0; i < row.length; i++) if (row[i] === "\\") i++;
+	else if (row[i] === "|") pipes.push(i);
+	const cells = [];
+	let start = 0;
+	for (const pipe of pipes) {
+		cells.push({
+			from: start,
+			to: pipe
+		});
+		start = pipe + 1;
+	}
+	cells.push({
+		from: start,
+		to: row.length
+	});
+	const blank = (c) => !row.slice(c.from, c.to).trim();
+	if (pipes.length && blank(cells.at(-1))) cells.pop();
+	if (pipes.length && cells.length && blank(cells[0])) cells.shift();
+	return cells;
+}
+/** The index of the cell containing `offset` in `row` (outer pipes count toward their cell). */
+function cellAt(row, offset) {
+	const cells = splitRow(row);
+	const index = cells.findIndex((c) => offset <= c.to);
+	return index === -1 ? Math.max(0, cells.length - 1) : index;
+}
+function parseAlign(cell) {
+	const left = cell.startsWith(":");
+	const right = cell.endsWith(":");
+	return left && right ? "center" : right ? "right" : left ? "left" : "none";
+}
+/** Reads table lines (header, delimiter, body rows) without any line prefix such as "> ". */
+function parseTable(lines) {
+	const cellTexts = (line) => splitRow(line).map((c) => line.slice(c.from, c.to).trim());
+	const aligns = cellTexts(lines[1] ?? "").map(parseAlign);
+	const rows = [lines[0] ?? "", ...lines.slice(2)].map(cellTexts);
+	for (const row of rows) while (row.length < aligns.length) row.push("");
+	return {
+		aligns,
+		rows
+	};
+}
+/** The line of `lines` that holds table row `row` (the delimiter line sits between rows 0 and 1). */
+function rowLine(row) {
+	return row === 0 ? 0 : row + 1;
+}
+function pad(text, width, align) {
+	const extra = Math.max(0, width - displayWidth(text));
+	const left = align === "right" ? extra : align === "center" ? Math.floor(extra / 2) : 0;
+	return {
+		text: " ".repeat(left) + text + " ".repeat(extra - left),
+		left
+	};
+}
+/** The table as aligned lines: `| cell | cell |`, columns padded to their widest cell. */
+function renderTable(table) {
+	const columns = Math.max(table.aligns.length, ...table.rows.map((r) => r.length));
+	const widths = Array.from({ length: columns }, (_, c) => Math.max(3, ...table.rows.map((r) => displayWidth(r[c] ?? ""))));
+	const cells = [];
+	const rowText = (row) => {
+		let line = "|";
+		const positions = [];
+		row.forEach((text, c) => {
+			const padded = pad(text, widths[c], table.aligns[c] ?? "none");
+			const from = line.length + 1 + (text ? padded.left : 0);
+			positions.push({
+				from,
+				to: from + text.length
+			});
+			line += ` ${padded.text} |`;
+		});
+		cells.push(positions);
+		return line;
+	};
+	const delimiter = "|" + table.aligns.map((align, c) => {
+		const left = align === "left" || align === "center" ? ":" : "-";
+		const right = align === "right" || align === "center" ? ":" : "-";
+		return `${left}${"-".repeat(widths[c])}${right}`;
+	}).join("|") + "|";
+	const [header = [], ...body] = table.rows;
+	return {
+		lines: [
+			rowText(header),
+			delimiter,
+			...body.map(rowText)
+		],
+		cells
+	};
+}
+//#endregion
+//#region packages/model/src/theme.ts
+const defaultTheme = {
+	fontFamily: "system-ui, -apple-system, \"Segoe UI\", \"Noto Sans KR\", sans-serif",
+	monospaceFamily: "\"D2Coding\", \"Noto Sans Mono CJK KR\", ui-monospace, \"SFMono-Regular\", Menlo, Consolas, monospace",
+	color: "#1f2328",
+	block: {
+		quote: {
+			color: "#59636e",
+			borderLeft: "#d1d9e0"
+		},
+		codeblock: {
+			monospace: true,
+			lineBackground: "#f6f8fa"
+		},
+		mathblock: {
+			monospace: true,
+			color: "#6639ba"
+		},
+		table: { monospace: true },
+		tableHeader: { fontWeight: 700 },
+		tableRowAlt: { lineBackground: "#f6f8fa" },
+		hr: {},
+		h1: {
+			fontScale: 1.6,
+			fontWeight: 700
+		},
+		h2: {
+			fontScale: 1.4,
+			fontWeight: 700
+		},
+		h3: {
+			fontScale: 1.2,
+			fontWeight: 700
+		},
+		h4: {
+			fontScale: 1.1,
+			fontWeight: 700
+		},
+		h5: { fontWeight: 700 },
+		h6: {
+			fontWeight: 700,
+			color: "#59636e"
+		}
+	},
+	inline: {
+		link: { color: "#0969da" },
+		strong: { fontWeight: 700 },
+		em: { italic: true },
+		strike: { strike: true },
+		code: {
+			monospace: true,
+			background: "rgba(129, 139, 152, 0.15)"
+		},
+		math: {
+			monospace: true,
+			color: "#6639ba"
+		},
+		url: {
+			color: "#8c959f",
+			underline: true
+		},
+		mark: {
+			color: "#8c959f",
+			fontWeight: 400,
+			italic: false,
+			strike: false,
+			underline: false
+		}
+	}
+};
+/** The look of a line with these block styles (any order). */
+function resolveLineLook(blocks, theme = defaultTheme) {
+	const present = new Set(blocks);
+	const look = {};
+	for (const style of BLOCK_STYLES) if (present.has(style)) Object.assign(look, theme.block[style]);
+	return look;
+}
+/** The look of text with these block and inline styles (any order). */
+function resolveLook(blocks, inline, theme = defaultTheme) {
+	const { lineBackground: _bg, borderLeft: _border, ...look } = resolveLineLook(blocks, theme);
+	const present = new Set(inline);
+	for (const style of INLINE_STYLES) if (present.has(style)) Object.assign(look, theme.inline[style]);
+	return look;
+}
+//#endregion
+export { BLOCK_STYLES, INLINE_STYLES, cellAt, charWidth, defaultTheme, displayWidth, flattenSpans, markdownExtensions, markdownParser, markdownStyles, parseTable, renderTable, resolveLineLook, resolveLook, rowLine, splitRow };

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "@simple-mark/model",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Markdown parsing and styling model shared by every renderer. Pure TypeScript, no DOM.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/one-prime/simple-mark.git",
+    "directory": "packages/model"
+  },
+  "keywords": [
+    "markdown",
+    "wysiwyg",
+    "editor",
+    "gfm"
+  ],
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "dependencies": {
+    "@lezer/common": "^1.5.3",
+    "@lezer/markdown": "^1.8.1"
+  }
+}