From d523a5a310fafed978a292a4962309e8666f64c4 Mon Sep 17 00:00:00 2001 From: onmax Date: Tue, 17 Nov 2026 10:21:53 +0100 Subject: [PATCH 1/2] perf(auto-close): add comark/auto-close/core without Comark syntax Move the two-pass scanner to internal/auto-close.ts and layer components, attribute scopes, math, frontmatter and table completion on it through a Syntax object that only comark/auto-close constructs. comark/auto-close/core exports a CommonMark/GFM autoCloseMarkdown and dropTrailingOpeners, so a bundle that imports it leaves the Comark layer out (3.7 KB vs 6.0 KB gzip). Its output matches comark/auto-close with syntax, attributes, math, frontmatter and tables off; a new test checks that on every SPEC case, every SPEC prefix and a generated corpus. --- docs/content/5.reference/1.parse.md | 3 +- docs/content/5.reference/2.auto-close.md | 19 + packages/comark/SPEC/auto-close.md | 2 + packages/comark/package.json | 1 + packages/comark/src/auto-close.ts | 1150 ++---------------- packages/comark/src/auto-close/core.ts | 36 + packages/comark/src/internal/auto-close.ts | 1019 ++++++++++++++++ packages/comark/test/auto-close-core.test.ts | 105 ++ test/bundle.test.ts | 2 +- 9 files changed, 1301 insertions(+), 1036 deletions(-) create mode 100644 packages/comark/src/auto-close/core.ts create mode 100644 packages/comark/src/internal/auto-close.ts create mode 100644 packages/comark/test/auto-close-core.test.ts diff --git a/docs/content/5.reference/1.parse.md b/docs/content/5.reference/1.parse.md index e99b9c6d..f46c5ef8 100644 --- a/docs/content/5.reference/1.parse.md +++ b/docs/content/5.reference/1.parse.md @@ -360,6 +360,7 @@ console.timeEnd('createMarkdownParser x1000') | `comark` | `parseMarkdown()`, `createMarkdownParser()`, `createSerializedMarkdownParser()` with the default plugins and auto-close, plus `autoCloseMarkdown()`, `createComarkContext()`, `defineComarkPlugin()`, `parseFrontmatter()` | | `comark/core` | The same three parser functions with no default plugins and no built-in auto-closer | | `comark/auto-close` | `autoCloseMarkdown()` and its placeholders, without the parser | +| `comark/auto-close/core` | A CommonMark/GFM-only `autoCloseMarkdown()` and `dropTrailingOpeners()`, without Comark syntax or table completion | | `comark/context` | `createComarkContext()` and the live-update types, without the parser | | `comark/parse` | **Deprecated.** Alias of `comark`. Import from `comark` instead | @@ -368,7 +369,7 @@ console.timeEnd('createMarkdownParser x1000') Use `comark/core` when you want to choose every plugin yourself and keep the default plugins out of your bundle. It accepts the same options as `comark`, with two differences: - Only the plugins in `plugins` run. `registerDefaultPlugins` is not accepted; add [`linkify()`](/plugins/defaults/linkify) to link bare URLs. -- `autoClose` is a function or `undefined` (the default, which skips auto-closing). Pass `autoCloseMarkdown` from `comark/auto-close` to opt in. +- `autoClose` is a function or `undefined` (the default, which skips auto-closing). Pass `autoCloseMarkdown` from `comark/auto-close` to opt in, or from `comark/auto-close/core` when you register none of the components, attributes, math or frontmatter plugins and do not need incomplete tables completed. ```typescript [core.ts] import { createMarkdownParser } from 'comark/core' diff --git a/docs/content/5.reference/2.auto-close.md b/docs/content/5.reference/2.auto-close.md index c663aa2a..3575e0c7 100644 --- a/docs/content/5.reference/2.auto-close.md +++ b/docs/content/5.reference/2.auto-close.md @@ -107,6 +107,25 @@ During incremental parsing with `{ streaming: true }`, the custom function recei To heal text without loading the parser, import from `comark/auto-close` instead of `comark`. :: +### CommonMark/GFM only + +`comark/auto-close/core` exports an `autoCloseMarkdown()` that heals CommonMark and GFM inline syntax and leaves components, `{...}` attributes, math, frontmatter and tables as text. Its result matches `comark/auto-close` with `syntax`, `attributes`, `math`, `frontmatter` and `tables` set to `false`, and it is about a third smaller. Use it with a parser that has none of those plugins, or with a renderer that completes tables itself. + +It accepts the inline and link options above. `dropTrailingOpeners` is a separate function: run it first, with the same `inlineCode` option. + +```typescript [core.ts] +import { autoCloseMarkdown, dropTrailingOpeners } from 'comark/auto-close/core' + +autoCloseMarkdown('Some **bold and `code') +// 'Some **bold and `code`**' + +autoCloseMarkdown('::alert\nSome **bold') +// '::alert\nSome **bold**' (the component stays open) + +autoCloseMarkdown(dropTrailingOpeners('hello *')) +// 'hello' +``` + ### Supported syntax #### Inline Markdown diff --git a/packages/comark/SPEC/auto-close.md b/packages/comark/SPEC/auto-close.md index 156e0254..227dbecd 100644 --- a/packages/comark/SPEC/auto-close.md +++ b/packages/comark/SPEC/auto-close.md @@ -45,6 +45,8 @@ Self-healing markdown for streaming. Completes incomplete syntax so partial AI o Legacy aliases accepted for one release: `katex` → `blockMath`, `math` and `inlineKatex` → `inlineMath`. +An implementation may leave out `blockMath`, `inlineMath` and `tables`, treating them as `false`. Comark's `comark/auto-close/core` does, and matches `comark/auto-close` with those options off. + ## Case format Each case is a `diff` fence with one `-` line (input) and one `+` line (expected output). `\n`, `\r`, `\t` are literal escape sequences for the corresponding characters; every other character is verbatim (so trailing spaces on the `+` line are part of the expected output). Options for a single case go in the fence info string, never in the `+` line: diff --git a/packages/comark/package.json b/packages/comark/package.json index 93663ac0..d1e6401f 100644 --- a/packages/comark/package.json +++ b/packages/comark/package.json @@ -54,6 +54,7 @@ "./parse": "./dist/index.js", "./core": "./dist/core.js", "./auto-close": "./dist/auto-close.js", + "./auto-close/core": "./dist/auto-close/core.js", "./context": "./dist/context.js", "./render": "./dist/render/index.js", "./render/html": "./dist/render/html.js" diff --git a/packages/comark/src/auto-close.ts b/packages/comark/src/auto-close.ts index c4cd74f5..a463591c 100644 --- a/packages/comark/src/auto-close.ts +++ b/packages/comark/src/auto-close.ts @@ -1,36 +1,24 @@ /** - * Auto-closes unclosed markdown and Comark component syntax. - * - * Two O(n) passes, no backtracking: - * - * 1. `scanBlocks` — one walk over the document on offsets only (no per-line - * strings): fences, raw HTML, frontmatter, block math, component stack, - * trailing table, and the range eligible for inline healing (the last - * soft-wrapped paragraph). - * 2. `healRegion` — one walk over that range with a single delimiter stack. - * Unclosed frames are closed LIFO at EOF; edits (tilde escapes, dropped - * brackets) are collected as positions and applied once at the end, so the - * common "nothing to escape" path never copies the string. + * Auto-closes unclosed markdown and Comark syntax: the CommonMark/GFM closer of + * `comark/auto-close/core`, plus component fences, attribute scopes, math, + * frontmatter and GFM tables, layered on it as a `Syntax`. * * Behavioral contract: `packages/comark/SPEC/auto-close.md`. */ +import type { AutoCloseCoreOptions, Frame, Syntax } from './internal/auto-close.ts' +import { autoClose, dropTrailingOpeners, F_MATH, LINE_DROP, LINE_SKIP, resolveOptions } from './internal/auto-close.ts' import { findBracketClose, isBracketMath } from './internal/bracket-math.ts' -export const INCOMPLETE_LINK_PLACEHOLDER = 'comark:incomplete-link' -export const INCOMPLETE_IMAGE_PLACEHOLDER = 'comark:incomplete-image' +export { INCOMPLETE_IMAGE_PLACEHOLDER, INCOMPLETE_LINK_PLACEHOLDER } from './internal/auto-close.ts' +export type { AutoCloseCoreOptions, LinkMode } from './internal/auto-close.ts' -export type LinkMode = 'protocol' | 'text-only' - -export interface AutoCloseOptions { +export interface AutoCloseOptions extends AutoCloseCoreOptions { frontmatter?: boolean /** Component fences (`::`). Default true. */ syntax?: boolean /** Attached `{...}` attribute scopes. Defaults to `syntax`. */ attributes?: boolean - linkMode?: LinkMode - incompleteLinkPlaceholder?: string - incompleteImagePlaceholder?: string /** * Auto-close math. When set, enables both block and inline unless the more * specific flags override. Enabled automatically when the math plugin is used @@ -50,251 +38,93 @@ export interface AutoCloseOptions { * Enabled automatically when `parseMarkdown(..., { streaming: true })`. */ dropTrailingOpeners?: boolean - /** Auto-close incomplete links (`[text`). Default true. */ - links?: boolean - /** Auto-close incomplete images (`![alt`). Default true. */ - images?: boolean - /** Auto-close `**bold**`. Default true. */ - bold?: boolean - /** Auto-close `*italic*` / `_italic_`. Default true. */ - italic?: boolean - /** Auto-close `~~strikethrough~~`. Default true. */ - strikethrough?: boolean - /** Auto-close inline `` `code` ``. Default true. */ - inlineCode?: boolean - /** Auto-close `***bold-italic***`. Default true. */ - boldItalic?: boolean - /** Escape mid-word single `~` (`20~25` → `20\~25`). Default true. */ - singleTilde?: boolean - /** - * Escape list-item comparison openers (`- > 25` → `- \> 25`) so they are not - * parsed as blockquotes. Default true. - */ - comparisonOperators?: boolean - /** Strip incomplete HTML tags at EOF (`Hello = 0) - - return result + return autoClose(source, o, new ComarkSyntax(options, syntax)) } -// --------------------------------------------------------------------------- -// Block pass -// --------------------------------------------------------------------------- - interface Component { depth: number indent: string yaml: boolean } -interface DocState { - /** Offsets of the region to heal, or `start < 0` for "nothing to heal". */ - start: number - end: number - /** Effective document end — a trailing bare `::` is dropped. */ - docEnd: number - fmOpen: boolean - fmContent: boolean - mathOpen: boolean - /** The document ends inside a table block. */ - table: boolean - comps: Component[] -} - -const RAW_TEXT_OPEN_RE = /^<(script|pre|style|textarea)(\s|>|$)/i -const RAW_TEXT_CLOSE_RE = { - script: /<\/script\s*>/i, - pre: /<\/pre\s*>/i, - style: /<\/style\s*>/i, - textarea: /<\/textarea\s*>/i, -} as const - -type RawTag = keyof typeof RAW_TEXT_CLOSE_RE - /** - * One walk over the document, on offsets only: no per-line strings, so a long - * streaming document costs a single scan plus one slice of the healed region. - * - * Every line is examined as three offsets: `ls` (start), `st`…`en` (the trimmed - * content) and `le` (end, before the newline). + * The Comark syntax of one call and the state it keeps across both passes. A + * class rather than closures, so a call allocates one object and the hot + * methods stay shared. */ -function scanBlocks(src: string, o: Opts): DocState { - const len = src.length - const starts: number[] = [0] - for (let i = src.indexOf('\n'); i !== -1; i = src.indexOf('\n', i + 1)) starts.push(i + 1) - let n = starts.length - let docEnd = len - - const comps: Component[] = [] - let fenceLen = 0 - let fenceCh = 0 - let raw: RawTag | null = null - let fmOpen = false - let fmContent = false - let mathOpen = false - let table = false - let shielded = -1 // last line that structurally shields what precedes it. - - for (let i = 0; i < n; i++) { - const ls = starts[i] - const le = i + 1 < n ? starts[i + 1] - 1 : len - let st = ls - while (st < le && isIndentCode(src.charCodeAt(st))) st++ - let en = le - while (en > st && isSpaceCode(src.charCodeAt(en - 1))) en-- - const c0 = st < en ? src.charCodeAt(st) : -1 - - if (raw !== null) { - if (RAW_TEXT_CLOSE_RE[raw].test(src.slice(ls, le))) raw = null - continue - } - if (c0 === 60 /* < */) { - const m = RAW_TEXT_OPEN_RE.exec(src.slice(st, en)) - if (m !== null) { - const tag = m[1].toLowerCase() as RawTag - if (!RAW_TEXT_CLOSE_RE[tag].test(src.slice(ls, le))) raw = tag - continue - } - } +class ComarkSyntax implements Syntax { + open = false + #components: boolean + #frontmatter: boolean + #blockMath: boolean + #inlineMath: boolean + #bracketMath: boolean + #tables: boolean + #comps: Component[] = [] + #fmOpen = false + #fmContent = false + #mathOpen = false + // Line end up to which no `\)` / `\]` was found (bracket math), or -1. + #noParenClose = -1 + #noBracketClose = -1 - if (c0 === 96 /* ` */ || c0 === 126 /* ~ */) { - let run = 1 - while (st + run < en && src.charCodeAt(st + run) === c0) run++ - if (run >= 3) { - if (fenceLen === 0) { - // `` ```code`` `` is an incomplete inline code span, not a fence opener. - if (!(c0 === 96 && isIncompleteInlineFence(src, st, en))) { - fenceLen = run - fenceCh = c0 - shielded = i - continue - } - } else if (c0 === fenceCh && run >= fenceLen && st + run === en) { - // A closer is the same character, at least as long, and followed only by - // whitespace. `` ```js `` inside an open block is code content, not a closer. - fenceLen = 0 - shielded = i - continue - } else { - shielded = i - continue - } - } - } - if (fenceLen !== 0) continue + constructor(options: AutoCloseOptions, components: boolean) { + const math = options.math === true + this.#components = components + this.#frontmatter = options.frontmatter === true + this.#blockMath = options.blockMath ?? math + this.#inlineMath = options.inlineMath ?? math + this.#bracketMath = options.bracketMath === true + this.#tables = options.tables !== false + } + line(src: string, i: number, ls: number, st: number, en: number, c0: number, last: boolean): number { + // The closer shields a `$$` line itself; only the open block is tracked here. if (c0 === 36 /* $ */ && en - st === 2 && src.charCodeAt(st + 1) === 36) { - if (o.blockMath) mathOpen = !mathOpen - shielded = i - continue + if (this.#blockMath) { + this.#mathOpen = !this.#mathOpen + this.open = this.#fmOpen || this.#mathOpen + } + return 0 } const dashes = c0 === 45 /* - */ && en - st === 3 && src.charCodeAt(st + 1) === 45 && src.charCodeAt(st + 2) === 45 - if (i === 0 && o.frontmatter && dashes) { - fmOpen = true - continue + if (i === 0 && this.#frontmatter && dashes) { + this.#fmOpen = this.open = true + return LINE_SKIP } - if (fmOpen) { - if (dashes) fmOpen = false - else if (c0 !== -1) fmContent = true - continue + if (this.#fmOpen) { + if (dashes) { + this.#fmOpen = false + this.open = this.#mathOpen + } else if (c0 !== -1) this.#fmContent = true + return LINE_SKIP } + const comps = this.#comps if (dashes && comps.length > 0) { const top = comps[comps.length - 1] top.yaml = !top.yaml - continue + return LINE_SKIP } - table = c0 === 124 /* | */ - - if (o.syntax && c0 === 58 /* : */) { + if (this.#components && c0 === 58 /* : */) { let colons = 1 while (st + colons < en && src.charCodeAt(st + colons) === 58) colons++ const bare = st + colons === en - if (bare && i === n - 1 && comps.length === 0) { - // Trailing bare `::` — drop it so it does not flash as text. - docEnd = ls - n-- - break - } + // Trailing bare `::` — drop it so it does not flash as text. + if (bare && last && comps.length === 0) return LINE_DROP if (colons >= 2) { if (!bare && isNameStart(src.charCodeAt(st + colons))) { comps.push({ depth: colons, indent: src.slice(ls, st), yaml: false }) @@ -303,478 +133,71 @@ function scanBlocks(src: string, o: Opts): DocState { } } } - } - - const doc: DocState = { start: -1, end: -1, docEnd, fmOpen, fmContent, mathOpen, table, comps } - - // Nothing is healed while a shielded region is still open at EOF. - if (fenceLen !== 0 || raw !== null || fmOpen || mathOpen) return doc - - const lineEnd = (i: number) => (i + 1 < n ? starts[i + 1] - 1 : docEnd) - - let e = n - 1 - while (e > 0 && lineEnd(e) === starts[e]) e-- - - // A half-typed list item at the end of a list is a marker with no content yet - // (`- item\n- ` → `- item`). Only inside a list — under a paragraph the same line - // is a setext candidate and gets the U+200B guard instead. - while ( - e > shielded + 1 && - isEmptyListItem(src, starts[e], lineEnd(e)) && - isListItem(src, starts[e - 1], lineEnd(e - 1)) - ) { - docEnd = starts[e] - 1 // drop the line and the newline before it - n = e - e-- - while (e > 0 && lineEnd(e) === starts[e]) e-- - } - doc.docEnd = docEnd - - if (lineEnd(e) === starts[e] || e <= shielded) return doc - - // Widen to the soft-wrapped paragraph: stop at a blank line or a new block. - let s = e - while (s > shielded + 1 && lineEnd(s - 1) !== starts[s - 1] && !isBlockStart(src, starts[s], lineEnd(s))) s-- - if (s !== e) { - let join = !isBlockStart(src, starts[s], lineEnd(s)) || isListItem(src, starts[s], lineEnd(s)) - for (let i = s + 1; join && i <= e; i++) if (isBlockStart(src, starts[i], lineEnd(i))) join = false - if (!join) s = e - } - - // Indented code is literal. - if (s === e && isIndentedCode(src, starts[e], lineEnd(e)) && !isListItem(src, starts[e], lineEnd(e))) return doc - - doc.start = starts[s] - doc.end = lineEnd(e) - return doc -} - -/** `` ```python code`` `` — a code span that merely looks like a fence. */ -function isIncompleteInlineFence(src: string, st: number, en: number): boolean { - if (en - st < 5) return false - if (src.charCodeAt(en - 1) !== 96 || src.charCodeAt(en - 2) !== 96 || src.charCodeAt(en - 3) === 96) return false - return !src.slice(st + 3, en).includes('```') -} - -const ATX_HEADING_RE = /^#{1,6}(\s|$)/ -const THEMATIC_BREAK_RE = /^(\*{3,}|_{3,}|-{3,})\s*$/ -const ORDERED_LIST_RE = /^\d{1,9}[.)](\s|$)/ - -function isIndentCode(c: number): boolean { - return c === 32 || c === 9 -} - -/** True when a line opens a new block, so paragraph joining must not cross it. */ -function isBlockStart(src: string, ls: number, le: number): boolean { - if (ls >= le) return false - if (isIndentedCode(src, ls, le)) return true - let st = ls - while (st < le && isIndentCode(src.charCodeAt(st))) st++ - if (st >= le) return false - const c = src.charCodeAt(st) - if (c === 96 || c === 126) { - let run = 1 - while (st + run < le && src.charCodeAt(st + run) === c) run++ - if (run >= 3) return true - } - if (c === 35 /* # */) return ATX_HEADING_RE.test(src.slice(st, le)) - if (c === 62 /* > */ || c === 124 /* | */) return true - if ((c === 42 || c === 95 || c === 45) && THEMATIC_BREAK_RE.test(src.slice(st, le))) return true - return isListItem(src, st, le) -} - -/** CommonMark indented code: ≥ 4 leading spaces (or a tab) plus content. */ -function isIndentedCode(src: string, ls: number, le: number): boolean { - if (ls >= le) return false - if (src.charCodeAt(ls) === 9) return true - let i = ls - while (i < le && src.charCodeAt(i) === 32) i++ - return i - ls >= 4 && i < le -} - -function isListItem(src: string, ls: number, le: number): boolean { - let st = ls - while (st < le && isIndentCode(src.charCodeAt(st))) st++ - if (st >= le) return false - const c = src.charCodeAt(st) - if (c === 45 || c === 43 || c === 42) { - const c1 = st + 1 < le ? src.charCodeAt(st + 1) : -1 - return c1 === 32 || c1 === 9 - } - return c >= 48 && c <= 57 && ORDERED_LIST_RE.test(src.slice(st, le)) -} - -/** A list marker with nothing after it: `-`, `- `, `1.`, `2) ` — but not `- x` or `---`. */ -function isEmptyListItem(src: string, ls: number, le: number): boolean { - let st = ls - while (st < le && isIndentCode(src.charCodeAt(st))) st++ - let en = le - while (en > st && isSpaceCode(src.charCodeAt(en - 1))) en-- - if (st >= en) return false - const c = src.charCodeAt(st) - if (c === 45 || c === 43 || c === 42) return st + 1 === en - let i = st - while (i < en && src.charCodeAt(i) >= 48 && src.charCodeAt(i) <= 57) i++ - if (i === st || i === en) return false - const mark = src.charCodeAt(i) - return (mark === 46 /* . */ || mark === 41) /* ) */ && i + 1 === en -} - -function isNameStart(c: number): boolean { - return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c === 36 /* $ */ -} - -// --------------------------------------------------------------------------- -// Inline pass -// --------------------------------------------------------------------------- - -const F_STAR = 1 -const F_UNDER = 2 -const F_TILDE = 3 -const F_CODE = 4 -const F_MATH = 5 -const F_LINK = 6 - -/** An open construct. `len` is the delimiter run still to be closed. */ -interface Frame { - k: number - len: number - pos: number -} - -type Edit = [pos: number, replacement: string] - -const LIST_COMPARE_PREFIX_RE = /^\s*(?:[-*+]|\d+[.)]) +$/ -const LIST_COMPARE_VALUE_RE = /^=?\s*\$?\d/ - -/** - * Heals one paragraph-sized region: closes every construct still open at EOF, - * escapes mid-word tildes and list comparison operators, drops an incomplete - * HTML tag, and completes an incomplete link or image. - */ -function healRegion(text: string, o: Opts): string { - let len = text.length - // One trailing space is streaming noise; two are a hard line break. - if (text.charCodeAt(len - 1) === 32 && text.charCodeAt(len - 2) !== 32) len-- - if (len === 0) return '' - - const frames: Frame[] = [] - let edits: Edit[] | null = null - - let lineStart = 0 - let escEnd = -1 // index just past the last escape sequence - let attr = 0 - let htmlLt = -1 - let starInWord = false - let starDisabled = false - // The last word-internal `*` run left literal, as its length and the frame - // depth it was seen at. Until the next whitespace or the next `*` frame - // opened or closed, a same-length run that would open pairs with it - // instead, so `这是**中文。**后续` gets no closer. - let starSkippedLen = 0 - let starSkippedDepth = -1 - // Line end up to which no `\)` / `\]` was found (bracket math), or -1. - let noParenClose = -1 - let noBracketClose = -1 - - for (let i = 0; i < len; i++) { - const c = text.charCodeAt(i) - const top = frames.length === 0 ? null : frames[frames.length - 1] - - if (c === 10 /* \n */) { - lineStart = i + 1 - starInWord = false - starSkippedLen = 0 - htmlLt = -1 - continue - } - - // A code span shields everything but its own closer. - if (top !== null && top.k === F_CODE) { - if (c === 96) { - let n = 1 - while (text.charCodeAt(i + n) === 96) n++ - if (n >= top.len) frames.pop() - else if (i + n === len) top.len -= n - i += n - 1 - } - continue - } - - if (c === 32 || c === 9 || c === 13) { - starInWord = false - starSkippedLen = 0 - continue - } - if (c === 92 /* \ */) { - // A closed `\(…\)` or `\[…\]` is math under `math({ brackets: true })`, so it - // isn't healed. Mirrors the parser: `\(` and inline `\[` close on the same - // line, `\[` after only indentation may span lines (no blank line, nothing - // after `\]`), and citations or `\[text\](url)` stay text. - if (o.bracketMath) { - const next = text.charCodeAt(i + 1) - if (next === 40 /* ( */ || next === 91 /* [ */) { - const block = next === 91 && isBlankRange(text, lineStart, i) - let end = len - if (!block) { - const nl = text.indexOf('\n', i + 2) - if (nl !== -1 && nl < len) end = nl - } - // A search that failed up to `end` fails from any later opener too. - const failed = next === 40 ? noParenClose : noBracketClose - const close = failed === end ? -1 : findBracketClose(text, i + 2, next === 40 ? 41 : 93, end) - if (close === -1) { - if (next === 40) noParenClose = end - else noBracketClose = end - } - if ( - close !== -1 && - isBracketMath(text.slice(i + 2, close)) && - !(next === 91 && text.charCodeAt(close + 2) === 40 /* ( */) && - (!block || isBracketBlock(text, i + 2, close, len)) - ) { - i = close + 1 - escEnd = i + 1 - continue - } - } - } - i++ - escEnd = i + 1 - continue - } - if (attr > 0) { - if (c === 125 /* } */) attr-- - continue - } - if (htmlLt >= 0) { - if (c === 62 /* > */) htmlLt = -1 - continue - } - - if (c === 96 /* ` */) { - let n = 1 - while (text.charCodeAt(i + n) === 96) n++ + return 0 + } + + // A closed `\(…\)` or `\[…\]` is math under `math({ brackets: true })`, so it + // isn't healed. Mirrors the parser: `\(` and inline `\[` close on the same + // line, `\[` after only indentation may span lines (no blank line, nothing + // after `\]`), and citations or `\[text\](url)` stay text. + bracket(text: string, i: number, lineStart: number, len: number): number { + const next = text.charCodeAt(i + 1) + if (!this.#bracketMath || (next !== 40 /* ( */ && next !== 91) /* [ */) return -1 + const block = next === 91 && isBlankRange(text, lineStart, i) + let end = len + if (!block) { + const nl = text.indexOf('\n', i + 2) + if (nl !== -1 && nl < len) end = nl + } + // A search that failed up to `end` fails from any later opener too. + const failed = next === 40 ? this.#noParenClose : this.#noBracketClose + const close = failed === end ? -1 : findBracketClose(text, i + 2, next === 40 ? 41 : 93, end) + if (close === -1) { + if (next === 40) this.#noParenClose = end + else this.#noBracketClose = end + return -1 + } + if ( + isBracketMath(text.slice(i + 2, close)) && + !(next === 91 && text.charCodeAt(close + 2) === 40 /* ( */) && + (!block || isBracketBlock(text, i + 2, close, len)) + ) + return close + return -1 + } + + dollar(text: string, i: number, len: number, frames: Frame[], top: Frame | null): number { + let n = 1 + while (text.charCodeAt(i + n) === 36) n++ + if (top !== null && top.k === F_MATH) { + if (n >= top.len) frames.pop() + else if (i + n === len) top.len -= n + } else { const after = i + n < len ? text.charCodeAt(i + n) : -1 - if (o.inlineCode && after !== -1 && after !== 10) frames.push({ k: F_CODE, len: n, pos: i }) - i += n - 1 - continue - } - - if (c === 36 /* $ */) { - let n = 1 - while (text.charCodeAt(i + n) === 36) n++ - if (top !== null && top.k === F_MATH) { - if (n >= top.len) frames.pop() - else if (i + n === len) top.len -= n - } else { - const after = i + n < len ? text.charCodeAt(i + n) : -1 - if (n === 1) { - // `$50` is currency and `::$name` is a component name, not math. - const attached = after > 13 && after !== 32 - if (o.inlineMath && attached && !(after >= 48 && after <= 57) && text.charCodeAt(i - 1) !== 58) - frames.push({ k: F_MATH, len: 1, pos: i }) - } else if (n === 2 && o.blockMath) { - // `$$` may be padded (`$$ x + y $$`); only EOL/EOF means "not an opener". - if (after !== -1 && after !== 10 && after !== 13) frames.push({ k: F_MATH, len: 2, pos: i }) - } - } - i += n - 1 - continue - } - - // Inside math only code spans and the math closer are syntax. - if (top !== null && top.k === F_MATH) continue - - if (c === 42 /* * */ || c === 95 /* _ */) { - let n = 1 - while (text.charCodeAt(i + n) === c) n++ - const prev = codePointBefore(text, i) - const next = i + n < len ? codePointAt(text, i + n) : '' - const attachedLeft = prev !== '' && !isSpaceCode(prev.charCodeAt(0)) && i !== escEnd - // `_` only opens at a boundary: whitespace, an escape or another marker. - // That keeps `func(_arg` literal while `**_text` and `\___bold` still open. - const openLeft = !attachedLeft || (c === 95 && (prev === '*' || prev === '_' || prev === '~')) - const openRight = next !== '' && !isSpaceCode(next.charCodeAt(0)) - const enabled = n === 1 ? o.italic : n === 2 ? o.bold : o.boldItalic - - if (c === 42) { - // Word-internal `*` only counts once the word already holds a delimiter - // (`*foo*bar*baz` pairs up, `abc*123` stays literal). - const inWord = attachedLeft && isAlnum(prev) && isAlnum(next) - if (inWord && !starInWord) { - starSkippedLen = n - starSkippedDepth = frames.length - } else { - if (attachedLeft && top !== null && top.k === F_STAR && (!inWord || top.len === n)) { - closeRun(frames, F_STAR, n) - starSkippedLen = 0 - starInWord = true - i += n - 1 - continue - } - // An attached run after punctuation (`中文。**后续`) that would open - // instead pairs with a word-internal run left literal earlier in the - // same whitespace-free stretch, with no frame opened or closed in - // between. CommonMark cannot pair the two, and the second run is a - // would-be closer far more often than an opener (CJK bold that ends - // in punctuation), so it is left literal instead of being closed. - // After opening punctuation (`bar(**baz`) it is an opener, as usual. - if ( - attachedLeft && - !inWord && - starSkippedLen === n && - starSkippedDepth === frames.length && - !isOpeningPunct(prev) - ) { - starSkippedLen = 0 - i += n - 1 - continue - } - if (openRight && enabled) { - frames.push({ k: F_STAR, len: n, pos: i }) - starSkippedLen = 0 - starInWord = true - i += n - 1 - continue - } - if (openRight && n === 1) starDisabled = true - } - } else { - // `_` closes only against a non-word on the right, so `snake_case` and - // `some__field` stay literal mid-word. - if (attachedLeft && !isAlnum(next) && top !== null && top.k === F_UNDER) { - closeRun(frames, F_UNDER, n) - i += n - 1 - continue - } - // A `_` run after punctuation and followed by a word char (`__下線、__次`, - // `__a.__b`, `_a(__b`) can only open in CommonMark, so any `_` closer - // appended at EOF would pair with this run instead of the open frames. - if (attachedLeft && isAlnum(next) && isPunct(prev) && top !== null && top.k === F_UNDER) { - while (frames.length > 0 && frames[frames.length - 1].k === F_UNDER) frames.pop() - // The scope a skipped `*` run was recorded in is gone with the frame. - starSkippedLen = 0 - i += n - 1 - continue - } - if (openLeft && openRight && enabled) frames.push({ k: F_UNDER, len: n, pos: i }) + if (n === 1) { + // `$50` is currency and `::$name` is a component name, not math. + const attached = after > 13 && after !== 32 + if (this.#inlineMath && attached && !(after >= 48 && after <= 57) && text.charCodeAt(i - 1) !== 58) + frames.push({ k: F_MATH, len: 1, pos: i }) + } else if (n === 2 && this.#blockMath) { + // `$$` may be padded (`$$ x + y $$`); only EOL/EOF means "not an opener". + if (after !== -1 && after !== 10 && after !== 13) frames.push({ k: F_MATH, len: 2, pos: i }) } - i += n - 1 - continue - } - - if (c === 126 /* ~ */) { - let n = 1 - while (text.charCodeAt(i + n) === 126) n++ - const prev = codePointBefore(text, i) - const next = i + n < len ? codePointAt(text, i + n) : '' - const attachedLeft = prev !== '' && !isSpaceCode(prev.charCodeAt(0)) - if (top !== null && top.k === F_TILDE && attachedLeft) { - closeRun(frames, F_TILDE, n) - } else if (n === 2 && o.strikethrough && next !== '' && !isSpaceCode(next.charCodeAt(0))) { - frames.push({ k: F_TILDE, len: 2, pos: i }) - } else if (n === 1 && o.singleTilde && isAlnum(prev) && isAlnum(next) && !isSubscriptTilde(text, i)) { - // A lone mid-word `~` would become GFM strikethrough — keep it literal. - edits = push(edits, [i, '\\~']) - } - i += n - 1 - continue - } - - if (c === 91 /* [ */) { - const image = text.charCodeAt(i - 1) === 33 /* ! */ - if (image ? o.images : o.links) frames.push({ k: F_LINK, len: image ? 2 : 1, pos: image ? i - 1 : i }) - continue - } - - if (c === 93 /* ] */) { - let b = frames.length - 1 - while (b >= 0 && frames[b].k !== F_LINK) b-- - if (b < 0) continue - const label = frames[b] - frames.length = b // the label closed: markers opened inside it stay literal - const after = i + 1 < len ? text.charCodeAt(i + 1) : -1 - - if (after === 40 /* ( */) { - const end = scanDestination(text, i + 2, len) - if (end > 0) { - i = end // complete `[text](url)` - continue - } - if (end < 0) continue // spaces inside: not a destination, keep scanning - } else if (after === 91 /* [ */) { - let j = i + 2 - while (j < len && text.charCodeAt(j) !== 93) j++ - if (j < len) { - i = j // complete `[text][ref]` - continue - } - } else if (!(label.len === 2 && i + 1 === len && hasContent(text, label.pos + 2, i))) { - continue // `[text]` may be a shortcut reference; only images are healed - } - - // Incomplete destination / reference: the link wins over everything inside. - if (label.len === 2 || o.linkMode === 'protocol') { - return apply(text, edits, i + 1, '(' + (label.len === 2 ? o.imagePh : o.linkPh) + ')') - } - return apply(text, push(edits, [label.pos, '']), i, '') - } - - if (c === 60 /* < */) { - const next = text.charCodeAt(i + 1) - if (next === 47 /* / */ || isAsciiAlpha(next)) htmlLt = i - continue - } - - if (c === 62 /* > */) { - if ( - o.comparisonOperators && - LIST_COMPARE_PREFIX_RE.test(text.slice(lineStart, i)) && - LIST_COMPARE_VALUE_RE.test(text.slice(i + 1)) - ) { - edits = push(edits, [i, '\\>']) - } - continue - } - - if (c === 123 /* { */ && o.attributes) { - // Only an attached `{` is an attribute scope (`text{.cls`), never a bare line. - const prev = text.charCodeAt(i - 1) - if (i > 0 && prev !== 32 && prev !== 9 && prev !== 10) attr++ - continue } + return n } - let end = len - - // Incomplete HTML tag at EOF, plus the whitespace in front of it. - if (htmlLt >= 0 && o.htmlTags) { - end = htmlLt - while (end > 0 && (text.charCodeAt(end - 1) === 32 || text.charCodeAt(end - 1) === 9)) end-- - while (frames.length > 0 && frames[frames.length - 1].pos >= htmlLt) frames.pop() - } - - // Unclosed `[` / `![` at EOF. An empty label is a half-typed marker, not a link: - // there is nothing to wrap, so `hello [` stays literal. - let b = frames.length - 1 - while (b >= 0 && frames[b].k !== F_LINK) b-- - if (b >= 0 && hasContent(text, frames[b].pos + frames[b].len, end)) { - const label = frames[b] - if (label.len === 2 || o.linkMode === 'protocol') { - return apply(text, edits, end, '](' + (label.len === 2 ? o.imagePh : o.linkPh) + ')') - } - // text-only: unwrap link labels from the inside out, stop at an image. - for (let k = frames.length - 1; k >= 0; k--) { - const f = frames[k] - if (f.k !== F_LINK) continue - frames.length = k - if (f.len === 2) return apply(text, edits, end, '](' + o.imagePh + ')') - edits = push(edits, [f.pos, '']) - } + finish(result: string, source: string, healed: boolean, table: boolean): string { + if (this.#tables && table) result = closeTables(result) + if (this.#blockMath && this.#mathOpen) result += result.endsWith('\n') ? '$$' : '\n$$' + if (this.#fmOpen && this.#fmContent) result = closeDelimiterLine(result, '-', 3) + if (this.#components) result = closeComponents(result, source, this.#comps, healed) + return result } +} - return apply(text, edits, end, closers(frames, text, o, starDisabled)) +function isNameStart(c: number): boolean { + return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) || c === 36 /* $ */ } function isBlankRange(text: string, from: number, to: number): boolean { @@ -799,121 +222,6 @@ function isBracketBlock(text: string, from: number, close: number, len: number): return text.slice(close + 2, le).trim() === '' } -/** Consume `n` delimiters against the open frames of `kind`, innermost first. */ -function closeRun(frames: Frame[], kind: number, n: number): void { - let m = n - while (m > 0 && frames.length > 0) { - const f = frames[frames.length - 1] - if (f.k !== kind) break - if (m >= f.len) { - m -= f.len - frames.pop() - } else { - // Partial closer: `**bold*` leaves one `*` to complete. - f.len -= m - m = 0 - } - } -} - -/** - * End of an inline link destination: index of the closing `)`, `0` when the - * destination is unterminated, `-1` when it holds whitespace (so it is not a - * destination at all and the text must keep flowing). - */ -function scanDestination(text: string, from: number, len: number): number { - let depth = 1 - for (let i = from; i < len; i++) { - const c = text.charCodeAt(i) - if (c === 92) i++ - else if (c === 40) depth++ - else if (c === 41) { - if (--depth === 0) return i - } else if (c === 32 || c === 9 || c === 10) return -1 - } - return 0 -} - -/** LIFO closers for everything still open. */ -function closers(frames: Frame[], text: string, o: Opts, starDisabled: boolean): string { - const skipStar = starDisabled && !o.italic - let starSum = 0 - let starCount = 0 - let innerStar = -1 - for (let i = frames.length - 1; i >= 0; i--) { - if (frames[i].k !== F_STAR) continue - starSum += frames[i].len - starCount++ - if (innerStar < 0) innerStar = i - } - // A cross-family construct outside the innermost `*` cannot be nested through: - // `~~strike **bold *italic` closes only the `*` (SPEC), never `***~~`. - let crossOutside = false - for (let i = innerStar - 1; i >= 0; i--) { - const k = frames[i].k - if (k === F_TILDE || k === F_UNDER || k === F_MATH) { - crossOutside = true - break - } - } - - let out = '' - let starDone = false - for (let i = frames.length - 1; i >= 0; i--) { - const f = frames[i] - switch (f.k) { - case F_STAR: - if (starDone || skipStar) break - starDone = true - out += '*'.repeat(starCount >= 2 && crossOutside ? f.len : starSum) - break - case F_UNDER: - out += '_'.repeat(f.len) - break - case F_TILDE: - out += '~'.repeat(f.len) - break - case F_CODE: - out += '`'.repeat(f.len) - break - case F_MATH: - // A `$$` block opened on an earlier line closes on its own line. - out += f.len === 2 && text.lastIndexOf('\n') > f.pos ? '\n$$' : '$'.repeat(f.len) - break - } - } - return out -} - -function push(edits: Edit[] | null, edit: Edit): Edit[] { - if (edits === null) return [edit] - edits.push(edit) - return edits -} - -/** `text[0, end)` with every edit applied, then `suffix`. */ -function apply(text: string, edits: Edit[] | null, end: number, suffix: string): string { - if (edits === null) return end === text.length ? (suffix === '' ? text : text + suffix) : text.slice(0, end) + suffix - if (edits.length > 1) edits.sort(byPos) - let out = '' - let copied = 0 - for (let i = 0; i < edits.length; i++) { - const [pos, replacement] = edits[i] - if (pos >= end) break - out += text.slice(copied, pos) + replacement - copied = pos + 1 - } - return out + text.slice(copied, end) + suffix -} - -function byPos(a: Edit, b: Edit): number { - return a[0] - b[0] -} - -// --------------------------------------------------------------------------- -// Document-level closers -// --------------------------------------------------------------------------- - /** * Appends a `---` delimiter line, completing a half-typed one in place * (`title: x\n-` → `title: x\n---`). @@ -981,232 +289,6 @@ function closeComponents(result: string, source: string, comps: Component[], hea const ZWSP_RE = /\u200B/g const TRAILING_ZWSP_RE = /\u200B+$/ -const SETEXT_RE = /^(?:-{1,2}|={1,2})$/ -const YAML_KEY_RE = /^[A-Za-z_][\w.-]*\s*:/ - -/** - * A 1–2 char `-`/`=` line under a paragraph would flash as a setext heading - * while the list marker or rule is still being typed — park it behind U+200B. - */ -function applySetextGuard(text: string): string { - const lastNl = text.lastIndexOf('\n') - if (lastNl === -1) return text - const last = text.slice(lastNl + 1) - const t = last.trim() - if (!SETEXT_RE.test(t)) return text - // Trailing whitespace other than a stripped single space means "still typing". - if (last !== t && /\s$/.test(last)) return text - const head = text.slice(0, lastNl) - const prev = head.slice(head.lastIndexOf('\n') + 1).trim() - if (prev === '' || prev === '---' || YAML_KEY_RE.test(prev)) return text - return text + '\u200B' -} - -// --------------------------------------------------------------------------- -// Trailing openers (streaming) -// --------------------------------------------------------------------------- - -function isTrailingOpener(c: number): boolean { - // * _ $ : ` ~ [ { ! - return c === 42 || c === 95 || c === 36 || c === 58 || c === 96 || c === 126 || c === 91 || c === 123 || c === 33 -} - -/** - * Drops a trailing opener run at EOF unless it is attached to a word - * (`hello *` → `hello`), so a half-typed marker never flashes. Markers with content - * after them (`**bold`) are not trailing runs and stay for the heal; a bare `$` - * after a word (`text123$`) is dropped anyway, being only a math opener. - */ -function dropTrailingOpeners(text: string, inlineCode: boolean): string { - let ws = text.length - while (ws > 0 && isSpaceCode(text.charCodeAt(ws - 1))) ws-- - if (ws === 0) return text - - let i = ws - while (i > 0 && isTrailingOpener(text.charCodeAt(i - 1))) { - if (text.charCodeAt(i - 2) === 92 /* \ */) break - i-- - } - if (i === ws) return text - - let allDollar = true - let allTick = true - for (let k = i; k < ws; k++) { - const c = text.charCodeAt(k) - if (c !== 36) allDollar = false - if (c !== 96) allTick = false - } - if (allDollar && isAlnum(codePointBefore(text, i))) return text.slice(0, i) + text.slice(ws) - - // A trailing backtick run may belong to an open code span rather than start a - // new one. Then it is the heal pass's job, not ours: it either closes the span - // (`space `` ``) or completes a short closer (`spaces `` ` ` → `spaces `` ``). - // Only a span with no content yet is dropped, opener and all. - if (allTick && inlineCode) { - const span = openCodeSpan(text, i) - if (span !== null) { - if (ws - i >= span.len) return text // a closer — leave it to the heal - const gap = i - span.end - const pad = gap === 1 ? text.charCodeAt(span.end) : -1 - if (gap > 1 || (gap === 1 && pad !== 32 && pad !== 9)) return text // real content - return text.slice(0, trimBack(text, span.start)) + text.slice(ws) - } - } - - // Attached to a word the run is prose or a closer (`text**`, `word_`, `20~`), so it - // stays. After whitespace or punctuation it can only be a half-typed opener - // (`hello *`, ``escape lone `~` (` ``) and would flash. - if (isAlnum(codePointBefore(text, i))) return text - - return text.slice(0, trimBack(text, i)) + text.slice(ws) -} - -/** True when `text[from, to)` holds anything other than whitespace. */ -function hasContent(text: string, from: number, to: number): boolean { - for (let i = from; i < to; i++) if (!isSpaceCode(text.charCodeAt(i))) return true - return false -} - -/** `from`, minus one space or tab of padding before it. */ -function trimBack(text: string, from: number): number { - const prev = text.charCodeAt(from - 1) - return prev === 32 || prev === 9 ? from - 1 : from -} - -/** - * The inline code span still open at `limit` on its line, or null. Mirrors the - * heal pass's matching rule: a run closes the span when it is at least as long - * as the opener, otherwise it is content. - */ -function openCodeSpan(text: string, limit: number): { start: number; len: number; end: number } | null { - let start = -1 - let len = 0 - let end = -1 - let i = text.lastIndexOf('\n', limit - 1) + 1 - while (i < limit) { - const c = text.charCodeAt(i) - if (c === 92 /* \ */) { - i += 2 - continue - } - if (c !== 96) { - i++ - continue - } - let n = 1 - while (i + n < limit && text.charCodeAt(i + n) === 96) n++ - if (len === 0) { - len = n - start = i - end = i + n - } else if (n >= len) { - len = 0 - start = -1 - end = -1 - } - i += n - } - return len === 0 ? null : { start, len, end } -} - -// --------------------------------------------------------------------------- -// Characters -// --------------------------------------------------------------------------- - -const ALNUM_CP_RE = /\p{L}|\p{N}/u - -/** Letter or digit. Everything else (including `_`) is CommonMark punctuation. */ -function isAlnum(cp: string): boolean { - if (cp === '') return false - const c = cp.charCodeAt(0) - // ASCII fast path covers nearly all markdown without a Unicode test. - if (c <= 127) return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) - return ALNUM_CP_RE.test(cp) -} - -const PUNCT_CP_RE = /\p{P}|\p{S}/u - -/** CommonMark punctuation. A combining mark is neither this nor alphanumeric. */ -function isPunct(cp: string): boolean { - if (cp === '') return false - const c = cp.charCodeAt(0) - if (c <= 127) return c > 32 && c < 127 && !isAlnum(cp) - return PUNCT_CP_RE.test(cp) -} - -const OPENING_PUNCT_RE = /\p{Ps}|\p{Pi}/u - -/** Opening bracket or initial quote: `(`, `[`, `{`, `「`, `“`, ... */ -function isOpeningPunct(cp: string): boolean { - if (cp === '') return false - const c = cp.charCodeAt(0) - if (c <= 127) return c === 40 || c === 91 || c === 123 - return OPENING_PUNCT_RE.test(cp) -} - -function isAsciiAlpha(c: number): boolean { - return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) -} - -/** Space, tab, line feed, form feed or carriage return. */ -function isSpaceCode(c: number): boolean { - return c === 32 || c === 9 || c === 10 || c === 12 || c === 13 -} - -/** Full code point before `i` (surrogate aware), `''` at the start. */ -function codePointBefore(text: string, i: number): string { - if (i <= 0) return '' - const c = text.charCodeAt(i - 1) - if (c >= 0xdc00 && c <= 0xdfff && i >= 2) { - const hi = text.charCodeAt(i - 2) - if (hi >= 0xd800 && hi <= 0xdbff) return text.slice(i - 2, i) - } - return text[i - 1] -} - -/** Full code point at `i` (surrogate aware). */ -function codePointAt(text: string, i: number): string { - const c = text.charCodeAt(i) - if (c >= 0xd800 && c <= 0xdbff) { - const lo = text.charCodeAt(i + 1) - if (lo >= 0xdc00 && lo <= 0xdfff) return text.slice(i, i + 2) - } - return text[i] -} - -/** - * True when the `~` at `i` closes or opens a subscript pair (`markdown-it-sub`), - * the one paired use of single tildes that must stay unescaped. - */ -function isSubscriptTilde(text: string, i: number): boolean { - for (let j = i - 1; j >= 0 && text.charCodeAt(j) !== 10; j--) { - if (text.charCodeAt(j) === 126) { - if (isSubscriptPair(text, j, i)) return true - break - } - } - for (let j = i + 1; j < text.length && text.charCodeAt(j) !== 10; j++) { - if (text.charCodeAt(j) === 126) return isSubscriptPair(text, i, j) - } - return false -} - -/** - * `word~text~` with no whitespace inside (`a~note~`, `x~ab~.`). A word right - * after the closer is only allowed for digits (`H~2~O`), so `foo~bar~baz` and - * `20~25°C。20~25°C` stay prose. - */ -function isSubscriptPair(text: string, open: number, close: number): boolean { - if (close - open < 2) return false - if (text.charCodeAt(open - 1) === 126 || text.charCodeAt(open + 1) === 126) return false - if (text.charCodeAt(close + 1) === 126) return false - const wordAfter = close + 1 < text.length && isAlnum(codePointAt(text, close + 1)) - for (let k = open + 1; k < close; k++) { - const c = text.charCodeAt(k) - if (isSpaceCode(c) || (wordAfter && (c < 48 || c > 57))) return false - } - return isAlnum(codePointBefore(text, open)) -} // region -- table auto close /** diff --git a/packages/comark/src/auto-close/core.ts b/packages/comark/src/auto-close/core.ts new file mode 100644 index 00000000..29896035 --- /dev/null +++ b/packages/comark/src/auto-close/core.ts @@ -0,0 +1,36 @@ +/** + * The CommonMark/GFM auto-closer, without Comark syntax: inline markers, links, + * images, incomplete HTML tags, list comparison escapes and the setext guard, + * with fences and raw HTML left alone. Use it with a parser that has no + * components, attributes, math or frontmatter plugins (such as `comark/core` + * without them), or a renderer that completes tables itself; `comark/auto-close` + * handles all of those. + * + * Behavioral contract: `packages/comark/SPEC/auto-close.md`. + */ + +import type { AutoCloseCoreOptions } from '../internal/auto-close.ts' +import { autoClose, dropTrailingOpeners as dropOpeners, resolveOptions } from '../internal/auto-close.ts' + +export { INCOMPLETE_IMAGE_PLACEHOLDER, INCOMPLETE_LINK_PLACEHOLDER } from '../internal/auto-close.ts' +export type { AutoCloseCoreOptions, LinkMode } from '../internal/auto-close.ts' + +/** + * Closes the CommonMark/GFM syntax still open at the end of `markdown`. Same + * result as `autoCloseMarkdown` from `comark/auto-close` with `syntax`, + * `attributes`, `math`, `frontmatter` and `tables` off. + */ +export function autoCloseMarkdown(markdown: string, options: AutoCloseCoreOptions = {}): string { + if (!markdown) return markdown + return autoClose(markdown, resolveOptions(options, false), null) +} + +/** + * Drops a trailing opener (`* _ $ : [ { !`) after whitespace at EOF so a + * half-typed marker does not flash while streaming (`hello *` → `hello`). Run + * it before `autoCloseMarkdown`, with the same `inlineCode` option; together + * they match `comark/auto-close` with `dropTrailingOpeners: true`. + */ +export function dropTrailingOpeners(markdown: string, options: Pick = {}): string { + return dropOpeners(markdown, options.inlineCode !== false) +} diff --git a/packages/comark/src/internal/auto-close.ts b/packages/comark/src/internal/auto-close.ts new file mode 100644 index 00000000..af7e0d68 --- /dev/null +++ b/packages/comark/src/internal/auto-close.ts @@ -0,0 +1,1019 @@ +/** + * The CommonMark/GFM auto-closer that `comark/auto-close` and + * `comark/auto-close/core` share. Comark syntax (components, attributes, math, + * frontmatter) and table completion plug in through a `Syntax`, so a bundle + * that only imports the core entry never contains them. + * + * Two O(n) passes, no backtracking: + * + * 1. `scanBlocks` — one walk over the document on offsets only (no per-line + * strings): fences, raw HTML, trailing table, and the range eligible for + * inline healing (the last soft-wrapped paragraph). `Syntax.line` sees + * every line outside fences and raw HTML. + * 2. `healRegion` — one walk over that range with a single delimiter stack. + * Unclosed frames are closed LIFO at EOF; edits (tilde escapes, dropped + * brackets) are collected as positions and applied once at the end, so the + * common "nothing to escape" path never copies the string. + * + * Behavioral contract: `packages/comark/SPEC/auto-close.md`. + */ + +export const INCOMPLETE_LINK_PLACEHOLDER = 'comark:incomplete-link' +export const INCOMPLETE_IMAGE_PLACEHOLDER = 'comark:incomplete-image' + +export type LinkMode = 'protocol' | 'text-only' + +export interface AutoCloseCoreOptions { + linkMode?: LinkMode + incompleteLinkPlaceholder?: string + incompleteImagePlaceholder?: string + /** Auto-close incomplete links (`[text`). Default true. */ + links?: boolean + /** Auto-close incomplete images (`![alt`). Default true. */ + images?: boolean + /** Auto-close `**bold**`. Default true. */ + bold?: boolean + /** Auto-close `*italic*` / `_italic_`. Default true. */ + italic?: boolean + /** Auto-close `~~strikethrough~~`. Default true. */ + strikethrough?: boolean + /** Auto-close inline `` `code` ``. Default true. */ + inlineCode?: boolean + /** Auto-close `***bold-italic***`. Default true. */ + boldItalic?: boolean + /** Escape mid-word single `~` (`20~25` → `20\~25`). Default true. */ + singleTilde?: boolean + /** + * Escape list-item comparison openers (`- > 25` → `- \> 25`) so they are not + * parsed as blockquotes. Default true. + */ + comparisonOperators?: boolean + /** Strip incomplete HTML tags at EOF (`Hello = 0, doc.table) +} + +// --------------------------------------------------------------------------- +// Block pass +// --------------------------------------------------------------------------- + +interface DocState { + /** Offsets of the region to heal, or `start < 0` for "nothing to heal". */ + start: number + end: number + /** Effective document end — `LINE_DROP` cuts the document short. */ + docEnd: number + /** The document ends inside a table block. */ + table: boolean +} + +const RAW_TEXT_OPEN_RE = /^<(script|pre|style|textarea)(\s|>|$)/i +const RAW_TEXT_CLOSE_RE = { + script: /<\/script\s*>/i, + pre: /<\/pre\s*>/i, + style: /<\/style\s*>/i, + textarea: /<\/textarea\s*>/i, +} as const + +type RawTag = keyof typeof RAW_TEXT_CLOSE_RE + +/** + * One walk over the document, on offsets only: no per-line strings, so a long + * streaming document costs a single scan plus one slice of the healed region. + * + * Every line is examined as three offsets: `ls` (start), `st`…`en` (the trimmed + * content) and `le` (end, before the newline). + */ +function scanBlocks(src: string, syntax: Syntax | null): DocState { + const len = src.length + const starts: number[] = [0] + for (let i = src.indexOf('\n'); i !== -1; i = src.indexOf('\n', i + 1)) starts.push(i + 1) + let n = starts.length + let docEnd = len + + let fenceLen = 0 + let fenceCh = 0 + let raw: RawTag | null = null + let table = false + let shielded = -1 // last line that structurally shields what precedes it. + + for (let i = 0; i < n; i++) { + const ls = starts[i] + const le = i + 1 < n ? starts[i + 1] - 1 : len + let st = ls + while (st < le && isIndentCode(src.charCodeAt(st))) st++ + let en = le + while (en > st && isSpaceCode(src.charCodeAt(en - 1))) en-- + const c0 = st < en ? src.charCodeAt(st) : -1 + + if (raw !== null) { + if (RAW_TEXT_CLOSE_RE[raw].test(src.slice(ls, le))) raw = null + continue + } + if (c0 === 60 /* < */) { + const m = RAW_TEXT_OPEN_RE.exec(src.slice(st, en)) + if (m !== null) { + const tag = m[1].toLowerCase() as RawTag + if (!RAW_TEXT_CLOSE_RE[tag].test(src.slice(ls, le))) raw = tag + continue + } + } + + if (c0 === 96 /* ` */ || c0 === 126 /* ~ */) { + let run = 1 + while (st + run < en && src.charCodeAt(st + run) === c0) run++ + if (run >= 3) { + if (fenceLen === 0) { + // `` ```code`` `` is an incomplete inline code span, not a fence opener. + if (!(c0 === 96 && isIncompleteInlineFence(src, st, en))) { + fenceLen = run + fenceCh = c0 + shielded = i + continue + } + } else if (c0 === fenceCh && run >= fenceLen && st + run === en) { + // A closer is the same character, at least as long, and followed only by + // whitespace. `` ```js `` inside an open block is code content, not a closer. + fenceLen = 0 + shielded = i + continue + } else { + shielded = i + continue + } + } + } + if (fenceLen !== 0) continue + + const r = + syntax !== null && (c0 === 36 /* $ */ || c0 === 45 /* - */ || c0 === 58 /* : */ || syntax.open) + ? syntax.line(src, i, ls, st, en, c0, i === n - 1) + : 0 + if (r === LINE_SKIP) continue + + if (c0 === 36 /* $ */ && en - st === 2 && src.charCodeAt(st + 1) === 36) { + shielded = i + continue + } + + table = c0 === 124 /* | */ + + if (r === LINE_DROP) { + docEnd = ls + n-- + break + } + } + + const doc: DocState = { start: -1, end: -1, docEnd, table } + + // Nothing is healed while a shielded region is still open at EOF. + if (fenceLen !== 0 || raw !== null || (syntax !== null && syntax.open)) return doc + + const lineEnd = (i: number) => (i + 1 < n ? starts[i + 1] - 1 : docEnd) + + let e = n - 1 + while (e > 0 && lineEnd(e) === starts[e]) e-- + + // A half-typed list item at the end of a list is a marker with no content yet + // (`- item\n- ` → `- item`). Only inside a list — under a paragraph the same line + // is a setext candidate and gets the U+200B guard instead. + while ( + e > shielded + 1 && + isEmptyListItem(src, starts[e], lineEnd(e)) && + isListItem(src, starts[e - 1], lineEnd(e - 1)) + ) { + docEnd = starts[e] - 1 // drop the line and the newline before it + n = e + e-- + while (e > 0 && lineEnd(e) === starts[e]) e-- + } + doc.docEnd = docEnd + + if (lineEnd(e) === starts[e] || e <= shielded) return doc + + // Widen to the soft-wrapped paragraph: stop at a blank line or a new block. + let s = e + while (s > shielded + 1 && lineEnd(s - 1) !== starts[s - 1] && !isBlockStart(src, starts[s], lineEnd(s))) s-- + if (s !== e) { + let join = !isBlockStart(src, starts[s], lineEnd(s)) || isListItem(src, starts[s], lineEnd(s)) + for (let i = s + 1; join && i <= e; i++) if (isBlockStart(src, starts[i], lineEnd(i))) join = false + if (!join) s = e + } + + // Indented code is literal. + if (s === e && isIndentedCode(src, starts[e], lineEnd(e)) && !isListItem(src, starts[e], lineEnd(e))) return doc + + doc.start = starts[s] + doc.end = lineEnd(e) + return doc +} + +/** `` ```python code`` `` — a code span that merely looks like a fence. */ +function isIncompleteInlineFence(src: string, st: number, en: number): boolean { + if (en - st < 5) return false + if (src.charCodeAt(en - 1) !== 96 || src.charCodeAt(en - 2) !== 96 || src.charCodeAt(en - 3) === 96) return false + return !src.slice(st + 3, en).includes('```') +} + +const ATX_HEADING_RE = /^#{1,6}(\s|$)/ +const THEMATIC_BREAK_RE = /^(\*{3,}|_{3,}|-{3,})\s*$/ +const ORDERED_LIST_RE = /^\d{1,9}[.)](\s|$)/ + +function isIndentCode(c: number): boolean { + return c === 32 || c === 9 +} + +/** True when a line opens a new block, so paragraph joining must not cross it. */ +function isBlockStart(src: string, ls: number, le: number): boolean { + if (ls >= le) return false + if (isIndentedCode(src, ls, le)) return true + let st = ls + while (st < le && isIndentCode(src.charCodeAt(st))) st++ + if (st >= le) return false + const c = src.charCodeAt(st) + if (c === 96 || c === 126) { + let run = 1 + while (st + run < le && src.charCodeAt(st + run) === c) run++ + if (run >= 3) return true + } + if (c === 35 /* # */) return ATX_HEADING_RE.test(src.slice(st, le)) + if (c === 62 /* > */ || c === 124 /* | */) return true + if ((c === 42 || c === 95 || c === 45) && THEMATIC_BREAK_RE.test(src.slice(st, le))) return true + return isListItem(src, st, le) +} + +/** CommonMark indented code: ≥ 4 leading spaces (or a tab) plus content. */ +function isIndentedCode(src: string, ls: number, le: number): boolean { + if (ls >= le) return false + if (src.charCodeAt(ls) === 9) return true + let i = ls + while (i < le && src.charCodeAt(i) === 32) i++ + return i - ls >= 4 && i < le +} + +function isListItem(src: string, ls: number, le: number): boolean { + let st = ls + while (st < le && isIndentCode(src.charCodeAt(st))) st++ + if (st >= le) return false + const c = src.charCodeAt(st) + if (c === 45 || c === 43 || c === 42) { + const c1 = st + 1 < le ? src.charCodeAt(st + 1) : -1 + return c1 === 32 || c1 === 9 + } + return c >= 48 && c <= 57 && ORDERED_LIST_RE.test(src.slice(st, le)) +} + +/** A list marker with nothing after it: `-`, `- `, `1.`, `2) ` — but not `- x` or `---`. */ +function isEmptyListItem(src: string, ls: number, le: number): boolean { + let st = ls + while (st < le && isIndentCode(src.charCodeAt(st))) st++ + let en = le + while (en > st && isSpaceCode(src.charCodeAt(en - 1))) en-- + if (st >= en) return false + const c = src.charCodeAt(st) + if (c === 45 || c === 43 || c === 42) return st + 1 === en + let i = st + while (i < en && src.charCodeAt(i) >= 48 && src.charCodeAt(i) <= 57) i++ + if (i === st || i === en) return false + const mark = src.charCodeAt(i) + return (mark === 46 /* . */ || mark === 41) /* ) */ && i + 1 === en +} + +// --------------------------------------------------------------------------- +// Inline pass +// --------------------------------------------------------------------------- + +const F_STAR = 1 +const F_UNDER = 2 +const F_TILDE = 3 +const F_CODE = 4 +export const F_MATH = 5 +const F_LINK = 6 + +/** An open construct. `len` is the delimiter run still to be closed. */ +export interface Frame { + k: number + len: number + pos: number +} + +type Edit = [pos: number, replacement: string] + +const LIST_COMPARE_PREFIX_RE = /^\s*(?:[-*+]|\d+[.)]) +$/ +const LIST_COMPARE_VALUE_RE = /^=?\s*\$?\d/ + +/** + * Heals one paragraph-sized region: closes every construct still open at EOF, + * escapes mid-word tildes and list comparison operators, drops an incomplete + * HTML tag, and completes an incomplete link or image. + */ +function healRegion(text: string, o: Opts, syntax: Syntax | null): string { + let len = text.length + // One trailing space is streaming noise; two are a hard line break. + if (text.charCodeAt(len - 1) === 32 && text.charCodeAt(len - 2) !== 32) len-- + if (len === 0) return '' + + const frames: Frame[] = [] + let edits: Edit[] | null = null + + let lineStart = 0 + let escEnd = -1 // index just past the last escape sequence + let attr = 0 + let htmlLt = -1 + let starInWord = false + let starDisabled = false + // The last word-internal `*` run left literal, as its length and the frame + // depth it was seen at. Until the next whitespace or the next `*` frame + // opened or closed, a same-length run that would open pairs with it + // instead, so `这是**中文。**后续` gets no closer. + let starSkippedLen = 0 + let starSkippedDepth = -1 + + for (let i = 0; i < len; i++) { + const c = text.charCodeAt(i) + const top = frames.length === 0 ? null : frames[frames.length - 1] + + if (c === 10 /* \n */) { + lineStart = i + 1 + starInWord = false + starSkippedLen = 0 + htmlLt = -1 + continue + } + + // A code span shields everything but its own closer. + if (top !== null && top.k === F_CODE) { + if (c === 96) { + let n = 1 + while (text.charCodeAt(i + n) === 96) n++ + if (n >= top.len) frames.pop() + else if (i + n === len) top.len -= n + i += n - 1 + } + continue + } + + if (c === 32 || c === 9 || c === 13) { + starInWord = false + starSkippedLen = 0 + continue + } + if (c === 92 /* \ */) { + const close = syntax === null ? -1 : syntax.bracket(text, i, lineStart, len) + if (close !== -1) { + i = close + 1 + escEnd = i + 1 + continue + } + i++ + escEnd = i + 1 + continue + } + if (attr > 0) { + if (c === 125 /* } */) attr-- + continue + } + if (htmlLt >= 0) { + if (c === 62 /* > */) htmlLt = -1 + continue + } + + if (c === 96 /* ` */) { + let n = 1 + while (text.charCodeAt(i + n) === 96) n++ + const after = i + n < len ? text.charCodeAt(i + n) : -1 + if (o.inlineCode && after !== -1 && after !== 10) frames.push({ k: F_CODE, len: n, pos: i }) + i += n - 1 + continue + } + + if (c === 36 /* $ */ && syntax !== null) { + i += syntax.dollar(text, i, len, frames, top) - 1 + continue + } + + // Inside math only code spans and the math closer are syntax. + if (top !== null && top.k === F_MATH) continue + + if (c === 42 /* * */ || c === 95 /* _ */) { + let n = 1 + while (text.charCodeAt(i + n) === c) n++ + const prev = codePointBefore(text, i) + const next = i + n < len ? codePointAt(text, i + n) : '' + const attachedLeft = prev !== '' && !isSpaceCode(prev.charCodeAt(0)) && i !== escEnd + // `_` only opens at a boundary: whitespace, an escape or another marker. + // That keeps `func(_arg` literal while `**_text` and `\___bold` still open. + const openLeft = !attachedLeft || (c === 95 && (prev === '*' || prev === '_' || prev === '~')) + const openRight = next !== '' && !isSpaceCode(next.charCodeAt(0)) + const enabled = n === 1 ? o.italic : n === 2 ? o.bold : o.boldItalic + + if (c === 42) { + // Word-internal `*` only counts once the word already holds a delimiter + // (`*foo*bar*baz` pairs up, `abc*123` stays literal). + const inWord = attachedLeft && isAlnum(prev) && isAlnum(next) + if (inWord && !starInWord) { + starSkippedLen = n + starSkippedDepth = frames.length + } else { + if (attachedLeft && top !== null && top.k === F_STAR && (!inWord || top.len === n)) { + closeRun(frames, F_STAR, n) + starSkippedLen = 0 + starInWord = true + i += n - 1 + continue + } + // An attached run after punctuation (`中文。**后续`) that would open + // instead pairs with a word-internal run left literal earlier in the + // same whitespace-free stretch, with no frame opened or closed in + // between. CommonMark cannot pair the two, and the second run is a + // would-be closer far more often than an opener (CJK bold that ends + // in punctuation), so it is left literal instead of being closed. + // After opening punctuation (`bar(**baz`) it is an opener, as usual. + if ( + attachedLeft && + !inWord && + starSkippedLen === n && + starSkippedDepth === frames.length && + !isOpeningPunct(prev) + ) { + starSkippedLen = 0 + i += n - 1 + continue + } + if (openRight && enabled) { + frames.push({ k: F_STAR, len: n, pos: i }) + starSkippedLen = 0 + starInWord = true + i += n - 1 + continue + } + if (openRight && n === 1) starDisabled = true + } + } else { + // `_` closes only against a non-word on the right, so `snake_case` and + // `some__field` stay literal mid-word. + if (attachedLeft && !isAlnum(next) && top !== null && top.k === F_UNDER) { + closeRun(frames, F_UNDER, n) + i += n - 1 + continue + } + // A `_` run after punctuation and followed by a word char (`__下線、__次`, + // `__a.__b`, `_a(__b`) can only open in CommonMark, so any `_` closer + // appended at EOF would pair with this run instead of the open frames. + if (attachedLeft && isAlnum(next) && isPunct(prev) && top !== null && top.k === F_UNDER) { + while (frames.length > 0 && frames[frames.length - 1].k === F_UNDER) frames.pop() + // The scope a skipped `*` run was recorded in is gone with the frame. + starSkippedLen = 0 + i += n - 1 + continue + } + if (openLeft && openRight && enabled) frames.push({ k: F_UNDER, len: n, pos: i }) + } + i += n - 1 + continue + } + + if (c === 126 /* ~ */) { + let n = 1 + while (text.charCodeAt(i + n) === 126) n++ + const prev = codePointBefore(text, i) + const next = i + n < len ? codePointAt(text, i + n) : '' + const attachedLeft = prev !== '' && !isSpaceCode(prev.charCodeAt(0)) + if (top !== null && top.k === F_TILDE && attachedLeft) { + closeRun(frames, F_TILDE, n) + } else if (n === 2 && o.strikethrough && next !== '' && !isSpaceCode(next.charCodeAt(0))) { + frames.push({ k: F_TILDE, len: 2, pos: i }) + } else if (n === 1 && o.singleTilde && isAlnum(prev) && isAlnum(next) && !isSubscriptTilde(text, i)) { + // A lone mid-word `~` would become GFM strikethrough — keep it literal. + edits = push(edits, [i, '\\~']) + } + i += n - 1 + continue + } + + if (c === 91 /* [ */) { + const image = text.charCodeAt(i - 1) === 33 /* ! */ + if (image ? o.images : o.links) frames.push({ k: F_LINK, len: image ? 2 : 1, pos: image ? i - 1 : i }) + continue + } + + if (c === 93 /* ] */) { + let b = frames.length - 1 + while (b >= 0 && frames[b].k !== F_LINK) b-- + if (b < 0) continue + const label = frames[b] + frames.length = b // the label closed: markers opened inside it stay literal + const after = i + 1 < len ? text.charCodeAt(i + 1) : -1 + + if (after === 40 /* ( */) { + const end = scanDestination(text, i + 2, len) + if (end > 0) { + i = end // complete `[text](url)` + continue + } + if (end < 0) continue // spaces inside: not a destination, keep scanning + } else if (after === 91 /* [ */) { + let j = i + 2 + while (j < len && text.charCodeAt(j) !== 93) j++ + if (j < len) { + i = j // complete `[text][ref]` + continue + } + } else if (!(label.len === 2 && i + 1 === len && hasContent(text, label.pos + 2, i))) { + continue // `[text]` may be a shortcut reference; only images are healed + } + + // Incomplete destination / reference: the link wins over everything inside. + if (label.len === 2 || o.linkMode === 'protocol') { + return apply(text, edits, i + 1, '(' + (label.len === 2 ? o.imagePh : o.linkPh) + ')') + } + return apply(text, push(edits, [label.pos, '']), i, '') + } + + if (c === 60 /* < */) { + const next = text.charCodeAt(i + 1) + if (next === 47 /* / */ || isAsciiAlpha(next)) htmlLt = i + continue + } + + if (c === 62 /* > */) { + if ( + o.comparisonOperators && + LIST_COMPARE_PREFIX_RE.test(text.slice(lineStart, i)) && + LIST_COMPARE_VALUE_RE.test(text.slice(i + 1)) + ) { + edits = push(edits, [i, '\\>']) + } + continue + } + + if (c === 123 /* { */ && o.attributes) { + // Only an attached `{` is an attribute scope (`text{.cls`), never a bare line. + const prev = text.charCodeAt(i - 1) + if (i > 0 && prev !== 32 && prev !== 9 && prev !== 10) attr++ + continue + } + } + + let end = len + + // Incomplete HTML tag at EOF, plus the whitespace in front of it. + if (htmlLt >= 0 && o.htmlTags) { + end = htmlLt + while (end > 0 && (text.charCodeAt(end - 1) === 32 || text.charCodeAt(end - 1) === 9)) end-- + while (frames.length > 0 && frames[frames.length - 1].pos >= htmlLt) frames.pop() + } + + // Unclosed `[` / `![` at EOF. An empty label is a half-typed marker, not a link: + // there is nothing to wrap, so `hello [` stays literal. + let b = frames.length - 1 + while (b >= 0 && frames[b].k !== F_LINK) b-- + if (b >= 0 && hasContent(text, frames[b].pos + frames[b].len, end)) { + const label = frames[b] + if (label.len === 2 || o.linkMode === 'protocol') { + return apply(text, edits, end, '](' + (label.len === 2 ? o.imagePh : o.linkPh) + ')') + } + // text-only: unwrap link labels from the inside out, stop at an image. + for (let k = frames.length - 1; k >= 0; k--) { + const f = frames[k] + if (f.k !== F_LINK) continue + frames.length = k + if (f.len === 2) return apply(text, edits, end, '](' + o.imagePh + ')') + edits = push(edits, [f.pos, '']) + } + } + + return apply(text, edits, end, closers(frames, text, o, starDisabled)) +} + +/** Consume `n` delimiters against the open frames of `kind`, innermost first. */ +function closeRun(frames: Frame[], kind: number, n: number): void { + let m = n + while (m > 0 && frames.length > 0) { + const f = frames[frames.length - 1] + if (f.k !== kind) break + if (m >= f.len) { + m -= f.len + frames.pop() + } else { + // Partial closer: `**bold*` leaves one `*` to complete. + f.len -= m + m = 0 + } + } +} + +/** + * End of an inline link destination: index of the closing `)`, `0` when the + * destination is unterminated, `-1` when it holds whitespace (so it is not a + * destination at all and the text must keep flowing). + */ +function scanDestination(text: string, from: number, len: number): number { + let depth = 1 + for (let i = from; i < len; i++) { + const c = text.charCodeAt(i) + if (c === 92) i++ + else if (c === 40) depth++ + else if (c === 41) { + if (--depth === 0) return i + } else if (c === 32 || c === 9 || c === 10) return -1 + } + return 0 +} + +/** LIFO closers for everything still open. */ +function closers(frames: Frame[], text: string, o: Opts, starDisabled: boolean): string { + const skipStar = starDisabled && !o.italic + let starSum = 0 + let starCount = 0 + let innerStar = -1 + for (let i = frames.length - 1; i >= 0; i--) { + if (frames[i].k !== F_STAR) continue + starSum += frames[i].len + starCount++ + if (innerStar < 0) innerStar = i + } + // A cross-family construct outside the innermost `*` cannot be nested through: + // `~~strike **bold *italic` closes only the `*` (SPEC), never `***~~`. + let crossOutside = false + for (let i = innerStar - 1; i >= 0; i--) { + const k = frames[i].k + if (k === F_TILDE || k === F_UNDER || k === F_MATH) { + crossOutside = true + break + } + } + + let out = '' + let starDone = false + for (let i = frames.length - 1; i >= 0; i--) { + const f = frames[i] + switch (f.k) { + case F_STAR: + if (starDone || skipStar) break + starDone = true + out += '*'.repeat(starCount >= 2 && crossOutside ? f.len : starSum) + break + case F_UNDER: + out += '_'.repeat(f.len) + break + case F_TILDE: + out += '~'.repeat(f.len) + break + case F_CODE: + out += '`'.repeat(f.len) + break + case F_MATH: + // A `$$` block opened on an earlier line closes on its own line. + out += f.len === 2 && text.lastIndexOf('\n') > f.pos ? '\n$$' : '$'.repeat(f.len) + break + } + } + return out +} + +function push(edits: Edit[] | null, edit: Edit): Edit[] { + if (edits === null) return [edit] + edits.push(edit) + return edits +} + +/** `text[0, end)` with every edit applied, then `suffix`. */ +function apply(text: string, edits: Edit[] | null, end: number, suffix: string): string { + if (edits === null) return end === text.length ? (suffix === '' ? text : text + suffix) : text.slice(0, end) + suffix + if (edits.length > 1) edits.sort(byPos) + let out = '' + let copied = 0 + for (let i = 0; i < edits.length; i++) { + const [pos, replacement] = edits[i] + if (pos >= end) break + out += text.slice(copied, pos) + replacement + copied = pos + 1 + } + return out + text.slice(copied, end) + suffix +} + +function byPos(a: Edit, b: Edit): number { + return a[0] - b[0] +} + +// --------------------------------------------------------------------------- +// Setext guard +// --------------------------------------------------------------------------- + +const SETEXT_RE = /^(?:-{1,2}|={1,2})$/ +const YAML_KEY_RE = /^[A-Za-z_][\w.-]*\s*:/ + +/** + * A 1–2 char `-`/`=` line under a paragraph would flash as a setext heading + * while the list marker or rule is still being typed — park it behind U+200B. + */ +function applySetextGuard(text: string): string { + const lastNl = text.lastIndexOf('\n') + if (lastNl === -1) return text + const last = text.slice(lastNl + 1) + const t = last.trim() + if (!SETEXT_RE.test(t)) return text + // Trailing whitespace other than a stripped single space means "still typing". + if (last !== t && /\s$/.test(last)) return text + const head = text.slice(0, lastNl) + const prev = head.slice(head.lastIndexOf('\n') + 1).trim() + if (prev === '' || prev === '---' || YAML_KEY_RE.test(prev)) return text + return text + '\u200B' +} + +// --------------------------------------------------------------------------- +// Trailing openers (streaming) +// --------------------------------------------------------------------------- + +function isTrailingOpener(c: number): boolean { + // * _ $ : ` ~ [ { ! + return c === 42 || c === 95 || c === 36 || c === 58 || c === 96 || c === 126 || c === 91 || c === 123 || c === 33 +} + +/** + * Drops a trailing opener run at EOF unless it is attached to a word + * (`hello *` → `hello`), so a half-typed marker never flashes. Markers with content + * after them (`**bold`) are not trailing runs and stay for the heal; a bare `$` + * after a word (`text123$`) is dropped anyway, being only a math opener. + */ +export function dropTrailingOpeners(text: string, inlineCode: boolean): string { + let ws = text.length + while (ws > 0 && isSpaceCode(text.charCodeAt(ws - 1))) ws-- + if (ws === 0) return text + + let i = ws + while (i > 0 && isTrailingOpener(text.charCodeAt(i - 1))) { + if (text.charCodeAt(i - 2) === 92 /* \ */) break + i-- + } + if (i === ws) return text + + let allDollar = true + let allTick = true + for (let k = i; k < ws; k++) { + const c = text.charCodeAt(k) + if (c !== 36) allDollar = false + if (c !== 96) allTick = false + } + if (allDollar && isAlnum(codePointBefore(text, i))) return text.slice(0, i) + text.slice(ws) + + // A trailing backtick run may belong to an open code span rather than start a + // new one. Then it is the heal pass's job, not ours: it either closes the span + // (`space `` ``) or completes a short closer (`spaces `` ` ` → `spaces `` ``). + // Only a span with no content yet is dropped, opener and all. + if (allTick && inlineCode) { + const span = openCodeSpan(text, i) + if (span !== null) { + if (ws - i >= span.len) return text // a closer — leave it to the heal + const gap = i - span.end + const pad = gap === 1 ? text.charCodeAt(span.end) : -1 + if (gap > 1 || (gap === 1 && pad !== 32 && pad !== 9)) return text // real content + return text.slice(0, trimBack(text, span.start)) + text.slice(ws) + } + } + + // Attached to a word the run is prose or a closer (`text**`, `word_`, `20~`), so it + // stays. After whitespace or punctuation it can only be a half-typed opener + // (`hello *`, ``escape lone `~` (` ``) and would flash. + if (isAlnum(codePointBefore(text, i))) return text + + return text.slice(0, trimBack(text, i)) + text.slice(ws) +} + +/** True when `text[from, to)` holds anything other than whitespace. */ +function hasContent(text: string, from: number, to: number): boolean { + for (let i = from; i < to; i++) if (!isSpaceCode(text.charCodeAt(i))) return true + return false +} + +/** `from`, minus one space or tab of padding before it. */ +function trimBack(text: string, from: number): number { + const prev = text.charCodeAt(from - 1) + return prev === 32 || prev === 9 ? from - 1 : from +} + +/** + * The inline code span still open at `limit` on its line, or null. Mirrors the + * heal pass's matching rule: a run closes the span when it is at least as long + * as the opener, otherwise it is content. + */ +function openCodeSpan(text: string, limit: number): { start: number; len: number; end: number } | null { + let start = -1 + let len = 0 + let end = -1 + let i = text.lastIndexOf('\n', limit - 1) + 1 + while (i < limit) { + const c = text.charCodeAt(i) + if (c === 92 /* \ */) { + i += 2 + continue + } + if (c !== 96) { + i++ + continue + } + let n = 1 + while (i + n < limit && text.charCodeAt(i + n) === 96) n++ + if (len === 0) { + len = n + start = i + end = i + n + } else if (n >= len) { + len = 0 + start = -1 + end = -1 + } + i += n + } + return len === 0 ? null : { start, len, end } +} + +// --------------------------------------------------------------------------- +// Characters +// --------------------------------------------------------------------------- + +const ALNUM_CP_RE = /\p{L}|\p{N}/u + +/** Letter or digit. Everything else (including `_`) is CommonMark punctuation. */ +function isAlnum(cp: string): boolean { + if (cp === '') return false + const c = cp.charCodeAt(0) + // ASCII fast path covers nearly all markdown without a Unicode test. + if (c <= 127) return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) + return ALNUM_CP_RE.test(cp) +} + +const PUNCT_CP_RE = /\p{P}|\p{S}/u + +/** CommonMark punctuation. A combining mark is neither this nor alphanumeric. */ +function isPunct(cp: string): boolean { + if (cp === '') return false + const c = cp.charCodeAt(0) + if (c <= 127) return c > 32 && c < 127 && !isAlnum(cp) + return PUNCT_CP_RE.test(cp) +} + +const OPENING_PUNCT_RE = /\p{Ps}|\p{Pi}/u + +/** Opening bracket or initial quote: `(`, `[`, `{`, `「`, `“`, ... */ +function isOpeningPunct(cp: string): boolean { + if (cp === '') return false + const c = cp.charCodeAt(0) + if (c <= 127) return c === 40 || c === 91 || c === 123 + return OPENING_PUNCT_RE.test(cp) +} + +function isAsciiAlpha(c: number): boolean { + return (c >= 97 && c <= 122) || (c >= 65 && c <= 90) +} + +/** Space, tab, line feed, form feed or carriage return. */ +function isSpaceCode(c: number): boolean { + return c === 32 || c === 9 || c === 10 || c === 12 || c === 13 +} + +/** Full code point before `i` (surrogate aware), `''` at the start. */ +function codePointBefore(text: string, i: number): string { + if (i <= 0) return '' + const c = text.charCodeAt(i - 1) + if (c >= 0xdc00 && c <= 0xdfff && i >= 2) { + const hi = text.charCodeAt(i - 2) + if (hi >= 0xd800 && hi <= 0xdbff) return text.slice(i - 2, i) + } + return text[i - 1] +} + +/** Full code point at `i` (surrogate aware). */ +function codePointAt(text: string, i: number): string { + const c = text.charCodeAt(i) + if (c >= 0xd800 && c <= 0xdbff) { + const lo = text.charCodeAt(i + 1) + if (lo >= 0xdc00 && lo <= 0xdfff) return text.slice(i, i + 2) + } + return text[i] +} + +/** + * True when the `~` at `i` closes or opens a subscript pair (`markdown-it-sub`), + * the one paired use of single tildes that must stay unescaped. + */ +function isSubscriptTilde(text: string, i: number): boolean { + for (let j = i - 1; j >= 0 && text.charCodeAt(j) !== 10; j--) { + if (text.charCodeAt(j) === 126) { + if (isSubscriptPair(text, j, i)) return true + break + } + } + for (let j = i + 1; j < text.length && text.charCodeAt(j) !== 10; j++) { + if (text.charCodeAt(j) === 126) return isSubscriptPair(text, i, j) + } + return false +} + +/** + * `word~text~` with no whitespace inside (`a~note~`, `x~ab~.`). A word right + * after the closer is only allowed for digits (`H~2~O`), so `foo~bar~baz` and + * `20~25°C。20~25°C` stay prose. + */ +function isSubscriptPair(text: string, open: number, close: number): boolean { + if (close - open < 2) return false + if (text.charCodeAt(open - 1) === 126 || text.charCodeAt(open + 1) === 126) return false + if (text.charCodeAt(close + 1) === 126) return false + const wordAfter = close + 1 < text.length && isAlnum(codePointAt(text, close + 1)) + for (let k = open + 1; k < close; k++) { + const c = text.charCodeAt(k) + if (isSpaceCode(c) || (wordAfter && (c < 48 || c > 57))) return false + } + return isAlnum(codePointBefore(text, open)) +} diff --git a/packages/comark/test/auto-close-core.test.ts b/packages/comark/test/auto-close-core.test.ts new file mode 100644 index 00000000..987e70dd --- /dev/null +++ b/packages/comark/test/auto-close-core.test.ts @@ -0,0 +1,105 @@ +import { gzipSync } from 'node:zlib' +import { fileURLToPath } from 'node:url' +import { build } from 'vite' +import { describe, expect, it } from 'vitest' +import { autoCloseMarkdown as autoCloseFull, type AutoCloseOptions } from '../src/auto-close.ts' +import { autoCloseMarkdown, dropTrailingOpeners, type AutoCloseCoreOptions } from '../src/auto-close/core.ts' +import { loadSpecCases, sectionAwareMapOptions, toGenericAutoCloseOptions } from './spec-runner.mjs' + +const SPEC_PATH = fileURLToPath(new URL('../SPEC/auto-close.md', import.meta.url)) + +/** The `comark/auto-close` flags that `comark/auto-close/core` leaves out. */ +const COMARK_OFF: AutoCloseOptions = { + syntax: false, + attributes: false, + frontmatter: false, + math: false, + blockMath: false, + inlineMath: false, + bracketMath: false, + tables: false, +} + +/** `comark/auto-close/core` with the full closer's `dropTrailingOpeners` option. */ +function core(markdown: string, options: AutoCloseOptions): string { + const source = + options.dropTrailingOpeners === true ? dropTrailingOpeners(markdown, { inlineCode: options.inlineCode }) : markdown + return autoCloseMarkdown(source, options as AutoCloseCoreOptions) +} + +function full(markdown: string, options: AutoCloseOptions): string { + return autoCloseFull(markdown, { ...options, ...COMARK_OFF }) +} + +describe('comark/auto-close/core', () => { + it('matches comark/auto-close with Comark syntax and tables off on every SPEC case', () => { + const cases = loadSpecCases(SPEC_PATH) + expect(cases.length).toBeGreaterThan(0) + for (const c of cases) { + const options = toGenericAutoCloseOptions(sectionAwareMapOptions(c.options, c)) as AutoCloseOptions + expect(core(c.input, options), JSON.stringify(c.input)).toBe(full(c.input, options)) + // A stream sees every prefix of the input. + for (let end = 1; end < c.input.length; end++) { + const prefix = c.input.slice(0, end) + expect(core(prefix, options), JSON.stringify(prefix)).toBe(full(prefix, options)) + } + } + }) + + it('matches comark/auto-close on generated documents', () => { + // Comma-separated, so the list stays one expression. + const tokens = ( + '*,**,***,_,__,~,~~,`,``,```,$,$$,\\(,\\),\\[,\\],[,],](,![,(,),{,},{.cls,",<,>,,:,::,:::,' + + '::alert,::card{a="b,---,--,-,=,- ,1. ,> ,# ,| , |,|---,\n,\n,\n\n, , , ,\t, ,a,word,20,中文,。,😀,title: x,=25' + ).split(',') + const flags = ['dropTrailingOpeners', 'italic', 'inlineCode', 'links', 'htmlTags'] + let seed = 1 + const random = () => (seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff + for (let n = 0; n < 5000; n++) { + let markdown = '' + for (let k = 1 + Math.floor(random() * 12); k > 0; k--) markdown += tokens[Math.floor(random() * tokens.length)] + const options: Record = { linkMode: random() < 0.5 ? 'protocol' : 'text-only' } + for (const flag of flags) if (random() < 0.3) options[flag] = random() < 0.5 + expect(core(markdown, options), JSON.stringify([markdown, options])).toBe(full(markdown, options)) + } + }) + + it('leaves Comark syntax and tables as text', () => { + expect(autoCloseMarkdown('::alert\nSome **bold')).toBe('::alert\nSome **bold**') + expect(autoCloseMarkdown('::card{title="x')).toBe('::card{title="x') + expect(autoCloseMarkdown('Text{.cls **bold')).toBe('Text{.cls **bold**') + expect(autoCloseMarkdown('$x + y')).toBe('$x + y') + expect(autoCloseMarkdown('---\ntitle: x')).toBe('---\ntitle: x') + expect(autoCloseMarkdown('| a | b |\n| c')).toBe('| a | b |\n| c') + }) + + it('heals CommonMark and GFM like comark/auto-close', () => { + expect(autoCloseMarkdown('Some **bold and `code')).toBe('Some **bold and `code`**') + expect(autoCloseMarkdown('[link](http://a')).toBe('[link](comark:incomplete-link)') + expect(autoCloseMarkdown('[link', { linkMode: 'text-only' })).toBe('link') + expect(autoCloseMarkdown('```js\nconst x = *1')).toBe('```js\nconst x = *1') + expect(autoCloseMarkdown('- item\n- ')).toBe('- item') + expect(autoCloseMarkdown('Hello { + const entry = fileURLToPath(new URL('../src/auto-close/core.ts', import.meta.url)) + const result = await build({ + configFile: false, + logLevel: 'silent', + build: { lib: { entry, formats: ['es'] }, minify: true, write: false }, + }) + const bundles = Array.isArray(result) ? result : [result] + const chunks = bundles.flatMap((bundle) => + 'output' in bundle ? bundle.output.filter((output) => output.type === 'chunk') : [] + ) + expect(chunks).toHaveLength(1) + const retained = Object.entries(chunks[0]!.modules) + .filter(([, module]) => module.renderedLength > 0) + .map(([id]) => id.slice(id.indexOf('/src/'))) + expect(retained).toEqual(['/src/internal/auto-close.ts', '/src/auto-close/core.ts']) + expect(gzipSync(chunks[0]!.code).length).toBeLessThan(5 * 1024) + }) +}) diff --git a/test/bundle.test.ts b/test/bundle.test.ts index b0d64568..4a53f440 100644 --- a/test/bundle.test.ts +++ b/test/bundle.test.ts @@ -77,7 +77,7 @@ describe('package bundle size', { timeout: 60_000 }, () => { "@comark/react": "42.9k (83 files)", "@comark/svelte": "50.3k (91 files)", "@comark/vue": "62.6k (89 files)", - "comark": "439k (171 files)", + "comark": "446k (175 files)", } `) }) From 659ea50f1154f466b9a9577f9289500ecbde1eae Mon Sep 17 00:00:00 2001 From: onmax Date: Tue, 17 Nov 2026 10:36:07 +0100 Subject: [PATCH 2/2] refactor(auto-close): trim comments in the core split Comark syntax, math, frontmatter and table completion plug into the shared scanner through a `Syntax` object, so a bundle that imports only `comark/auto-close/core` never contains them. `ComarkSyntax` is a class rather than closures so each call allocates one object and the hot methods stay shared. Cuts the added doc blocks to one line each, drops the comments the new test file gained, and stops re-exporting `AutoCloseCoreOptions` from `comark/auto-close`, which nothing imports. The comment cuts shrink the published `.d.ts` files, so the bundle size line moves from 446k to 444k. --- packages/comark/src/auto-close.ts | 11 ++---- packages/comark/src/auto-close/core.ts | 23 ++----------- packages/comark/src/internal/auto-close.ts | 35 +++----------------- packages/comark/test/auto-close-core.test.ts | 4 --- test/bundle.test.ts | 2 +- 5 files changed, 10 insertions(+), 65 deletions(-) diff --git a/packages/comark/src/auto-close.ts b/packages/comark/src/auto-close.ts index a463591c..16a8d745 100644 --- a/packages/comark/src/auto-close.ts +++ b/packages/comark/src/auto-close.ts @@ -1,7 +1,5 @@ /** - * Auto-closes unclosed markdown and Comark syntax: the CommonMark/GFM closer of - * `comark/auto-close/core`, plus component fences, attribute scopes, math, - * frontmatter and GFM tables, layered on it as a `Syntax`. + * Auto-closes unclosed markdown and Comark component syntax. * * Behavioral contract: `packages/comark/SPEC/auto-close.md`. */ @@ -11,7 +9,7 @@ import { autoClose, dropTrailingOpeners, F_MATH, LINE_DROP, LINE_SKIP, resolveOp import { findBracketClose, isBracketMath } from './internal/bracket-math.ts' export { INCOMPLETE_IMAGE_PLACEHOLDER, INCOMPLETE_LINK_PLACEHOLDER } from './internal/auto-close.ts' -export type { AutoCloseCoreOptions, LinkMode } from './internal/auto-close.ts' +export type { LinkMode } from './internal/auto-close.ts' export interface AutoCloseOptions extends AutoCloseCoreOptions { frontmatter?: boolean @@ -57,11 +55,6 @@ interface Component { yaml: boolean } -/** - * The Comark syntax of one call and the state it keeps across both passes. A - * class rather than closures, so a call allocates one object and the hot - * methods stay shared. - */ class ComarkSyntax implements Syntax { open = false #components: boolean diff --git a/packages/comark/src/auto-close/core.ts b/packages/comark/src/auto-close/core.ts index 29896035..2ebfef13 100644 --- a/packages/comark/src/auto-close/core.ts +++ b/packages/comark/src/auto-close/core.ts @@ -1,13 +1,4 @@ -/** - * The CommonMark/GFM auto-closer, without Comark syntax: inline markers, links, - * images, incomplete HTML tags, list comparison escapes and the setext guard, - * with fences and raw HTML left alone. Use it with a parser that has no - * components, attributes, math or frontmatter plugins (such as `comark/core` - * without them), or a renderer that completes tables itself; `comark/auto-close` - * handles all of those. - * - * Behavioral contract: `packages/comark/SPEC/auto-close.md`. - */ +/** CommonMark/GFM auto-close without Comark syntax or table completion; contract in `SPEC/auto-close.md`. */ import type { AutoCloseCoreOptions } from '../internal/auto-close.ts' import { autoClose, dropTrailingOpeners as dropOpeners, resolveOptions } from '../internal/auto-close.ts' @@ -15,22 +6,12 @@ import { autoClose, dropTrailingOpeners as dropOpeners, resolveOptions } from '. export { INCOMPLETE_IMAGE_PLACEHOLDER, INCOMPLETE_LINK_PLACEHOLDER } from '../internal/auto-close.ts' export type { AutoCloseCoreOptions, LinkMode } from '../internal/auto-close.ts' -/** - * Closes the CommonMark/GFM syntax still open at the end of `markdown`. Same - * result as `autoCloseMarkdown` from `comark/auto-close` with `syntax`, - * `attributes`, `math`, `frontmatter` and `tables` off. - */ export function autoCloseMarkdown(markdown: string, options: AutoCloseCoreOptions = {}): string { if (!markdown) return markdown return autoClose(markdown, resolveOptions(options, false), null) } -/** - * Drops a trailing opener (`* _ $ : [ { !`) after whitespace at EOF so a - * half-typed marker does not flash while streaming (`hello *` → `hello`). Run - * it before `autoCloseMarkdown`, with the same `inlineCode` option; together - * they match `comark/auto-close` with `dropTrailingOpeners: true`. - */ +/** Drops a half-typed trailing opener (`hello *` → `hello`); run it before `autoCloseMarkdown`. */ export function dropTrailingOpeners(markdown: string, options: Pick = {}): string { return dropOpeners(markdown, options.inlineCode !== false) } diff --git a/packages/comark/src/internal/auto-close.ts b/packages/comark/src/internal/auto-close.ts index af7e0d68..012fcacb 100644 --- a/packages/comark/src/internal/auto-close.ts +++ b/packages/comark/src/internal/auto-close.ts @@ -1,15 +1,11 @@ /** - * The CommonMark/GFM auto-closer that `comark/auto-close` and - * `comark/auto-close/core` share. Comark syntax (components, attributes, math, - * frontmatter) and table completion plug in through a `Syntax`, so a bundle - * that only imports the core entry never contains them. + * The CommonMark/GFM auto-closer shared by `comark/auto-close` and `comark/auto-close/core`. * * Two O(n) passes, no backtracking: * * 1. `scanBlocks` — one walk over the document on offsets only (no per-line * strings): fences, raw HTML, trailing table, and the range eligible for - * inline healing (the last soft-wrapped paragraph). `Syntax.line` sees - * every line outside fences and raw HTML. + * inline healing (the last soft-wrapped paragraph). * 2. `healRegion` — one walk over that range with a single delimiter stack. * Unclosed frames are closed LIFO at EOF; edits (tilde escapes, dropped * brackets) are collected as positions and applied once at the end, so the @@ -54,7 +50,6 @@ export interface AutoCloseCoreOptions { /** Resolved options — every flag settled once, so the hot loops only read booleans. */ export interface Opts { - /** Skip attached `{...}` attribute scopes. */ attributes: boolean linkMode: LinkMode linkPh: string @@ -90,37 +85,17 @@ export function resolveOptions(options: AutoCloseCoreOptions, attributes: boolea } } -/** `Syntax.line` result: the line was consumed by the syntax. */ export const LINE_SKIP = 1 -/** `Syntax.line` result: drop this line and everything after it. */ export const LINE_DROP = 2 -/** - * Syntax layered on the CommonMark/GFM closer for one call. Holds its own state - * across the passes, so it is created per call. - */ export interface Syntax { - /** - * A block that shields everything after it (frontmatter, `$$`) is open: - * `line` sees every line, and nothing is healed if it is still open at EOF. - */ + /** A shielding block (frontmatter, `$$`) is open, so nothing is healed at EOF. */ open: boolean - /** - * Called, before the closer looks at it, for a line outside fences and raw - * HTML that starts with `$`, `-` or `:`, or for any line while `open`. Other - * lines skip the call, which keeps the block pass fast. `st`…`en` is the - * trimmed content, `c0` its first char code (-1 when blank). Returns 0, - * `LINE_SKIP` or `LINE_DROP`. - */ + /** Sees lines starting with `$`, `-` or `:`, and every line while `open`; returns 0, `LINE_SKIP` or `LINE_DROP`. */ line(src: string, i: number, ls: number, st: number, en: number, c0: number, last: boolean): number - /** - * At a `\` in the healed region: the index of the `\` that closes a math - * span opened here, or -1 to treat it as an escape. - */ + /** Returns the index of the `\` that closes a math span opened at `i`, or -1. */ bracket(text: string, i: number, lineStart: number, len: number): number - /** At a `$` run in the healed region: updates `frames` and returns the run length. */ dollar(text: string, i: number, len: number, frames: Frame[], top: Frame | null): number - /** Document-level closers, applied last. `healed` is false when no region was healed. */ finish(result: string, source: string, healed: boolean, table: boolean): string } diff --git a/packages/comark/test/auto-close-core.test.ts b/packages/comark/test/auto-close-core.test.ts index 987e70dd..f8a64186 100644 --- a/packages/comark/test/auto-close-core.test.ts +++ b/packages/comark/test/auto-close-core.test.ts @@ -8,7 +8,6 @@ import { loadSpecCases, sectionAwareMapOptions, toGenericAutoCloseOptions } from const SPEC_PATH = fileURLToPath(new URL('../SPEC/auto-close.md', import.meta.url)) -/** The `comark/auto-close` flags that `comark/auto-close/core` leaves out. */ const COMARK_OFF: AutoCloseOptions = { syntax: false, attributes: false, @@ -20,7 +19,6 @@ const COMARK_OFF: AutoCloseOptions = { tables: false, } -/** `comark/auto-close/core` with the full closer's `dropTrailingOpeners` option. */ function core(markdown: string, options: AutoCloseOptions): string { const source = options.dropTrailingOpeners === true ? dropTrailingOpeners(markdown, { inlineCode: options.inlineCode }) : markdown @@ -38,7 +36,6 @@ describe('comark/auto-close/core', () => { for (const c of cases) { const options = toGenericAutoCloseOptions(sectionAwareMapOptions(c.options, c)) as AutoCloseOptions expect(core(c.input, options), JSON.stringify(c.input)).toBe(full(c.input, options)) - // A stream sees every prefix of the input. for (let end = 1; end < c.input.length; end++) { const prefix = c.input.slice(0, end) expect(core(prefix, options), JSON.stringify(prefix)).toBe(full(prefix, options)) @@ -47,7 +44,6 @@ describe('comark/auto-close/core', () => { }) it('matches comark/auto-close on generated documents', () => { - // Comma-separated, so the list stays one expression. const tokens = ( '*,**,***,_,__,~,~~,`,``,```,$,$$,\\(,\\),\\[,\\],[,],](,![,(,),{,},{.cls,",<,>,,:,::,:::,' + '::alert,::card{a="b,---,--,-,=,- ,1. ,> ,# ,| , |,|---,\n,\n,\n\n, , , ,\t, ,a,word,20,中文,。,😀,title: x,=25' diff --git a/test/bundle.test.ts b/test/bundle.test.ts index 4a53f440..e36f2efe 100644 --- a/test/bundle.test.ts +++ b/test/bundle.test.ts @@ -77,7 +77,7 @@ describe('package bundle size', { timeout: 60_000 }, () => { "@comark/react": "42.9k (83 files)", "@comark/svelte": "50.3k (91 files)", "@comark/vue": "62.6k (89 files)", - "comark": "446k (175 files)", + "comark": "444k (175 files)", } `) })