@voithos-labs/aragonite 0.10.4 → 0.10.7

package/dist/core/directive/container-opener.js

@@ -19,18 +19,20 @@ export function registerDirectiveOpeners() {
     const container = declaredPluginKind(DIRECTIVE_CONTAINER);
     const leaf = declaredPluginKind(DIRECTIVE_LEAF);
     registerBlockOpener(container, {
-        // Priced off the ladder, never as a bare integer, so renumbering a built-in moves this
-        // with it. A colon fence collides with no built-in matcher; it only needs the gap.
+        // Derived from the built-in priorities, never a bare integer, so renumbering a built-in
+        // moves this with it. A colon fence collides with no built-in matcher; it only needs a gap.
         priority: OPENER_PRIORITIES.blockquote + 5,
         interruptsParagraph: (line) => matchDirectiveOpener(line) !== null,
         tryOpen(ctx) {
             const fence = matchDirectiveOpener(ctx.line.text);
             if (!fence)
                 return null;
-            const lineEnding = trailingLineEnding(ctx.line.raw);
+            // A one-line leaf at the end of the source takes the source's first break, else LF.
+            const sourceEnding = (ctx.lines[0]?.lineEnding || '\n');
+            const lineEnding = trailingLineEnding(ctx.line.raw, sourceEnding);
             if (fence.tier === 'leaf') {
-                const def = resolveDirective('leaf', fence.name);
-                const factory = resolveBlockDirectiveFactory('leaf', fence.name);
+                const def = resolveDirective('leaf', fence.name, ctx.grammar);
+                const factory = resolveBlockDirectiveFactory('leaf', fence.name, ctx.grammar);
                 if (factory) {
                     const parsed = {
                         fence,
@@ -62,12 +64,13 @@ export function registerDirectiveOpeners() {
             // body stays inside this parse entry, so it inherits its scope.
             const body = parseContainerBody(bodyText, DIRECTIVE_BODY_WRAP, {
                 scope: ctx.isDocumentParse ? 'document' : 'fragment',
-                depth: ctx.depth + 1
+                depth: ctx.depth + 1,
+                grammar: ctx.grammar
             });
-            // isDirectiveCloser guarantees an all-colon line, so its length IS the colon count.
+            // isDirectiveCloser guarantees an all-colon line, so its length is the colon count.
             const closerColonCount = closerLine.text.length;
             const closerNewline = closerLine.raw.endsWith('\n');
-            const factory = resolveBlockDirectiveFactory('container', fence.name);
+            const factory = resolveBlockDirectiveFactory('container', fence.name, ctx.grammar);
             if (factory) {
                 const parsed = {
                     fence,
@@ -126,10 +129,8 @@ function closerIndex(lines) {
     closerIndexCache.set(lines, index);
     return index;
 }
-/**
- * Smallest closer-index slot at or after `from` whose count is >= `min`, or -1. Padding leaves
- * hold 0 and an opener runs at least two colons, so they never match.
- */
+/** First closer index at or after `from` with a run of at least `min` colons, or -1. Padding
+ *  leaves hold 0, and an opener runs at least two colons, so they never match. */
 function firstCloserAtLeast(index, from, min) {
     const descend = (node, lo, hi) => {
         if (hi <= from || index.maxCounts[node] < min)

package/dist/core/directive/grammar.d.ts

@@ -15,11 +15,8 @@ export interface DirectiveFence {
 }
 export declare function matchDirectiveOpener(lineText: string): DirectiveFence | null;
 export declare function isDirectiveCloser(lineText: string, openColonCount: number): boolean;
-/**
- * The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
- * `minimum`. Without it a body line reproducing the terminator reads as the container's own
- * closer and ejects everything below it on reparse.
- */
+/** The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
+ *  `minimum`, so no body line reads as the container's closer on reparse. */
 export declare function escalatedColonCount(body: string, minimum: number): number;
 export declare function serializeDirective(parts: {
     colonCount: number;

package/dist/core/directive/grammar.js

@@ -3,8 +3,11 @@
  * Byte round-trip is the master invariant: `serializeDirective` reproduces the opener colons,
  * the verbatim `info` (leading separator included), the body wrap, and a matched closer exactly.
  */
+import { WHITESPACE_CHARS, WHITESPACE_CLASS } from '../lines';
 import { escalateTerminatorRun } from '../terminator-escalation';
-const OPENER = /^(:{2,})([A-Za-z][A-Za-z0-9-]*)(.*)$/;
+// The `s` flag lets the info string run to the line's end over a line separator (U+2028),
+// which the line splitter keeps inside a line.
+const OPENER = /^(:{2,})([A-Za-z][A-Za-z0-9-]*)(.*)$/s;
 export function matchDirectiveOpener(lineText) {
     const match = OPENER.exec(lineText);
     if (!match)
@@ -26,11 +29,8 @@ export function isDirectiveCloser(lineText, openColonCount) {
         count++;
     return count >= openColonCount && count === lineText.length;
 }
-/**
- * The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
- * `minimum`. Without it a body line reproducing the terminator reads as the container's own
- * closer and ejects everything below it on reparse.
- */
+/** The colon count needed to wrap `body`: one past its longest whole-line colon run, never below
+ *  `minimum`, so no body line reads as the container's closer on reparse. */
 export function escalatedColonCount(body, minimum) {
     // A closer line is colons end to end, so its own length IS the run.
     return escalateTerminatorRun(body, minimum, (text, required) => isDirectiveCloser(text, required) ? text.length : null);
@@ -39,18 +39,18 @@ export function escalatedColonCount(body, minimum) {
 export function serializeDirective(parts) {
     const lineEnding = parts.lineEnding ?? '\n';
     const inner = `${parts.innerPrefix}${parts.body}${parts.innerSuffix}`;
-    // Re-derived on every emit rather than latched into metadata, so two emits over the same
-    // state always agree (G1.13). `colonCount` is a floor, not a target.
+    // Escalated from the body on every emit, so the fence holds before the editor re-reads the
+    // metadata; `colonCount` is a floor, not a target.
     const colonCount = escalatedColonCount(inner, parts.colonCount);
     const opener = ':'.repeat(colonCount);
     const closer = ':'.repeat(Math.max(colonCount, parts.closerColonCount ?? colonCount));
     const closerEnd = (parts.closerNewline ?? true) ? (parts.closerLineEnding ?? lineEnding) : '';
     return `${opener}${parts.name}${parts.info}${lineEnding}${inner}${closer}${closerEnd}`;
 }
-const LABEL = /^\s*\[([^\]]*)\]/;
+const LABEL = new RegExp(`^${WHITESPACE_CLASS}*\\[([^\\]]*)\\]`);
 const BRACES = /\{([^}]*)\}/;
 // Quoted segments fold in, so `title="a b"` stays one token instead of splitting on its space.
-const ATTR_TOKEN = /(?:[^\s"]+|"[^"]*")+/g;
+const ATTR_TOKEN = new RegExp(`(?:[^${WHITESPACE_CHARS}"]+|"[^"]*")+`, 'g');
 /**
  * Opt-in `info -> structure` reader for a leading `[label]` and a `{#id .class key=val}` block.
  * One-way: there is no inverse serializer, and the verbatim `info` stays the round-trip truth.

package/dist/core/directive/kinds.d.ts

@@ -9,7 +9,7 @@ import type { ContainerBodyWrap } from '../parser';
 export declare const DIRECTIVE_CONTAINER = "directiveContainer";
 export declare const DIRECTIVE_LEAF = "directiveLeaf";
 export declare const DIRECTIVE_TEXT = "directiveText";
-/** The `:::` opener and closer bracket every directive body, whatever kind the name mints. */
+/** The `:::` opener and closer bracket every directive body, whatever kind the name maps to. */
 export declare const DIRECTIVE_BODY_WRAP: ContainerBodyWrap;
 /** Fence bytes a container node round-trips through `rebuildDirectiveContainerRaw`. */
 export interface DirectiveContainerMetadata {
@@ -18,14 +18,11 @@ export interface DirectiveContainerMetadata {
     info: string;
     closerColonCount: number;
     closerNewline: boolean;
-    /** Authored line ending for the opener and closer chrome lines. */
+    /** Authored line ending for the opener and closer fence lines. */
     lineEnding: string;
 }
 export declare function registerDirectiveKinds(): void;
-/**
- * The `:` recognizer (text-recognizer.ts) stamps this kind on the span it delimits. The widget
- * opts into `revealSource`, so focus swaps the island for editable source and blur/Enter commits
- * (the shared reveal primitive in widget-interaction.ts). Idempotent for HMR.
- */
+/** The `:` recognizer gives this kind to the span it delimits. The widget opts into `revealSource`,
+ *  so focus swaps it for its editable source. Idempotent for HMR. */
 export declare function registerDirectiveTextKind(): void;
 export declare function rebuildDirectiveContainerRaw(node: CstNode): void;

package/dist/core/directive/kinds.js

@@ -8,14 +8,14 @@ import { declarePluginKind, declarePluginInlineKind, isInlineKindDeclared } from
 import { registerBlockKind, isBlockKindRegistered } from '../../schema/block-kind-descriptor';
 import { containerClosure } from '../../schema/closure';
 import { getPluginMetadata } from '../nodes';
-import { displayLength, trimTrailingLineEnding, trailingLineEnding } from '../lines';
+import { displayLength, ownTrailingLineEnding, trimTrailingLineEnding } from '../lines';
 import { concatChildren as serializeChildren } from '../serializer';
 import { registerInlineWidgetKind, mintWidgetShell } from '../inline/inline-widgets';
 import { matchDirectiveOpener, serializeDirective } from './grammar';
 export const DIRECTIVE_CONTAINER = 'directiveContainer';
 export const DIRECTIVE_LEAF = 'directiveLeaf';
 export const DIRECTIVE_TEXT = 'directiveText';
-/** The `:::` opener and closer bracket every directive body, whatever kind the name mints. */
+/** The `:::` opener and closer bracket every directive body, whatever kind the name maps to. */
 export const DIRECTIVE_BODY_WRAP = {
     afterOpenerLine: true,
     beforeCloserLine: true
@@ -24,10 +24,11 @@ export function registerDirectiveKinds() {
     if (isBlockKindRegistered(DIRECTIVE_CONTAINER))
         return; // idempotent for HMR / re-import
     registerBlockKind(declarePluginKind(DIRECTIVE_CONTAINER), {
+        label: 'Directive',
         mergeRole: 'container',
         editable: true,
         supportsInline: false,
-        // Opaque tier rule: no textual escape hatch at either edge, so both take the gap caret.
+        // An opaque container has no text of its own at either edge, so both take the gap caret.
         gapEdges: 'both',
         container: {
             contract: 'opaque',
@@ -51,11 +52,12 @@ export function registerDirectiveKinds() {
         })
     });
     registerBlockKind(declarePluginKind(DIRECTIVE_LEAF), {
+        label: 'Directive',
         gapEdges: 'none',
         mergeRole: 'not-mergeable',
         editable: true,
         supportsInline: false,
-        getContentRange: directiveLeafContentRange,
+        contentStart: { range: directiveLeafContentRange },
         keymap: DIRECTIVE_LEAF_KEYMAP,
         conformanceFixture: '::spoiler\n',
         closure: {
@@ -78,11 +80,8 @@ export function registerDirectiveKinds() {
     });
 }
 // ── Text tier: inline `:name[label]{attrs}` ────────────────────────────────────
-/**
- * The `:` recognizer (text-recognizer.ts) stamps this kind on the span it delimits. The widget
- * opts into `revealSource`, so focus swaps the island for editable source and blur/Enter commits
- * (the shared reveal primitive in widget-interaction.ts). Idempotent for HMR.
- */
+/** The `:` recognizer gives this kind to the span it delimits. The widget opts into `revealSource`,
+ *  so focus swaps it for its editable source. Idempotent for HMR. */
 export function registerDirectiveTextKind() {
     if (isInlineKindDeclared(DIRECTIVE_TEXT))
         return;
@@ -99,8 +98,8 @@ function buildDirectiveTextWidget(node, raw) {
     shell.textContent = raw.slice(node.start, node.end);
     return shell;
 }
-// Enter opens a paragraph sibling: a leaf never holds an in-line break, so the split reparses
-// its empty tail. Backspace/Delete take the not-mergeable walk, moving focus without joining.
+// Enter opens a paragraph sibling, since a leaf never holds a line break; Backspace and Delete at
+// an edge move focus without joining, as for any block that doesn't merge.
 const DIRECTIVE_LEAF_KEYMAP = [
     { chord: 'Enter', command: 'block.split' },
     { chord: 'Tab', command: 'block.insertTab' },
@@ -109,8 +108,8 @@ const DIRECTIVE_LEAF_KEYMAP = [
     { chord: 'Alt+ArrowUp', command: 'block.moveUp' },
     { chord: 'Alt+ArrowDown', command: 'block.moveDown' }
 ];
-// The `::name` fence is a dimmed marker prefix, on the heading marker-range mechanism. A raw
-// that no longer opens a fence reparses to a paragraph first, so the null branch is a floor.
+// The `::name` fence is a dimmed marker prefix, like a heading's. A raw that stops opening a fence
+// reparses to a paragraph first, so the null branch is only a fallback.
 function directiveLeafContentRange(node) {
     const fence = matchDirectiveOpener(trimTrailingLineEnding(node.raw));
     const start = fence ? fence.colonCount + fence.name.length : 0;
@@ -130,8 +129,7 @@ export function rebuildDirectiveContainerRaw(node) {
         closerColonCount: meta.closerColonCount,
         closerNewline: meta.closerNewline,
         lineEnding: meta.lineEnding,
-        // The parse side threads only the opener ending, so a mixed-ending directive recovers
-        // the closer's from the current raw, whose last line it is.
-        closerLineEnding: trailingLineEnding(node.raw)
+        // The closer is the raw's last line, so its ending is the raw's own, else the opener's.
+        closerLineEnding: ownTrailingLineEnding(node.raw) || undefined
     });
 }

package/dist/core/directive/registry.d.ts

@@ -1,11 +1,13 @@
 /**
- * Name-to-kind registry for the directive primitive: the shared opener resolves a fence's
- * `(tier, name)` here, then delegates to `fromDirective` or builds a lossless generic node.
+ * Name-to-kind registry for the directive syntax: the shared opener resolves a fence's
+ * `(tier, name)` (tier: container, leaf or text) here, then delegates to `fromDirective` or
+ * builds a lossless generic node.
  * Register-once with no unregister, the `customElements` model the schema registries follow.
  * Tier scopes the key, so a container and a leaf may share a name.
  */
 import type { DirectiveTier, DirectiveFence } from './grammar';
 import type { AnyBlockKind, PluginInlineKind, CstNode, InlineNode, Document } from '../nodes';
+import type { GrammarView } from '../../schema/block-openers';
 export interface ParsedDirective {
     fence: DirectiveFence;
     body?: Document;
@@ -15,7 +17,7 @@ export interface ParsedDirective {
     raw: string;
     closerColonCount: number;
     closerNewline: boolean;
-    /** Opener line ending; a factory stores it so a rebuild reproduces CRLF chrome lines. */
+    /** Opener line ending; a factory stores it so a rebuild keeps CRLF fence lines. */
     lineEnding: string;
 }
 export interface DirectiveDefinition {
@@ -24,16 +26,17 @@ export interface DirectiveDefinition {
     fromDirective?(parsed: ParsedDirective): CstNode | InlineNode;
 }
 export declare function registerDirective(tier: DirectiveTier, name: string, def: DirectiveDefinition): void;
-export declare function resolveDirective(tier: DirectiveTier, name: string): DirectiveDefinition | undefined;
+/** The name's definition under an editor's grammar; a name its plugin registered is absent where
+ *  the editor left that plugin out, so the fence reads as the generic directive. */
+export declare function resolveDirective(tier: DirectiveTier, name: string, grammar: GrammarView): DirectiveDefinition | undefined;
 /**
- * Pre-narrowed: the registration contract above guarantees a block node for these tiers, so the
- * union narrowing lives at this choke point instead of a cast per opener call site.
+ * Pre-narrowed: registration guarantees a block node for these tiers, so the union narrowing
+ * happens here once instead of a cast per opener call site.
  */
-export declare function resolveBlockDirectiveFactory(tier: 'leaf' | 'container', name: string): ((parsed: ParsedDirective) => CstNode) | undefined;
+export declare function resolveBlockDirectiveFactory(tier: 'leaf' | 'container', name: string, grammar: GrammarView): ((parsed: ParsedDirective) => CstNode) | undefined;
 export declare function isDirectiveRegistered(tier: DirectiveTier, name: string): boolean;
 /**
  * What "does this kind have a recognizer" must ask: a directive kind owns no opener of its own,
- * so an opener-registry probe alone reads the whole directive tier as unrecognizable.
+ * so checking the opener registry alone reads every directive kind as unrecognizable.
  */
 export declare function isDirectiveKind(kind: AnyBlockKind | PluginInlineKind): boolean;
-export declare function __resetDirectiveRegistryForTests(): void;

package/dist/core/directive/registry.js

@@ -1,11 +1,15 @@
 /**
- * Name-to-kind registry for the directive primitive: the shared opener resolves a fence's
- * `(tier, name)` here, then delegates to `fromDirective` or builds a lossless generic node.
+ * Name-to-kind registry for the directive syntax: the shared opener resolves a fence's
+ * `(tier, name)` (tier: container, leaf or text) here, then delegates to `fromDirective` or
+ * builds a lossless generic node.
  * Register-once with no unregister, the `customElements` model the schema registries follow.
  * Tier scopes the key, so a container and a leaf may share a name.
  */
-import { registerOnce } from '../../schema/register-once';
-const definitions = new Map();
+import { createPluginRegistry } from '../../schema/plugin-registry';
+const definitions = createPluginRegistry({
+    label: 'registerDirective',
+    isBuiltin: () => false
+});
 const keyOf = (tier, name) => `${tier}:${name}`;
 export function registerDirective(tier, name, def) {
     // Fail loud at registration so a tier/factory mismatch can't silently no-op at dispatch.
@@ -17,17 +21,19 @@ export function registerDirective(tier, name, def) {
         throw new Error(`registerDirective: text "${name}" is kind-only; fromDirective is not used for inline nodes.`);
     }
     const key = keyOf(tier, name);
-    registerOnce(definitions.has(key), () => definitions.set(key, def), `registerDirective: "${key}" is already registered. Directives are register-once.`);
+    definitions.register(key, def, `registerDirective: "${key}" is already registered. Directives are register-once.`);
 }
-export function resolveDirective(tier, name) {
-    return definitions.get(keyOf(tier, name));
+/** The name's definition under an editor's grammar; a name its plugin registered is absent where
+ *  the editor left that plugin out, so the fence reads as the generic directive. */
+export function resolveDirective(tier, name, grammar) {
+    return definitions.get(keyOf(tier, name), grammar.activation);
 }
 /**
- * Pre-narrowed: the registration contract above guarantees a block node for these tiers, so the
- * union narrowing lives at this choke point instead of a cast per opener call site.
+ * Pre-narrowed: registration guarantees a block node for these tiers, so the union narrowing
+ * happens here once instead of a cast per opener call site.
  */
-export function resolveBlockDirectiveFactory(tier, name) {
-    const factory = definitions.get(keyOf(tier, name))?.fromDirective;
+export function resolveBlockDirectiveFactory(tier, name, grammar) {
+    const factory = resolveDirective(tier, name, grammar)?.fromDirective;
     return factory;
 }
 export function isDirectiveRegistered(tier, name) {
@@ -35,15 +41,8 @@ export function isDirectiveRegistered(tier, name) {
 }
 /**
  * What "does this kind have a recognizer" must ask: a directive kind owns no opener of its own,
- * so an opener-registry probe alone reads the whole directive tier as unrecognizable.
+ * so checking the opener registry alone reads every directive kind as unrecognizable.
  */
 export function isDirectiveKind(kind) {
-    for (const def of definitions.values()) {
-        if (def.kind === kind)
-            return true;
-    }
-    return false;
-}
-export function __resetDirectiveRegistryForTests() {
-    definitions.clear();
+    return definitions.records().some(({ value }) => value.kind === kind);
 }

package/dist/core/directive/text-recognizer.d.ts

@@ -1,8 +1,9 @@
 /**
- * Inline text-directive recognizer for `:name[label]{attrs}`. It OWNS the whole span: returning
+ * Inline text-directive recognizer for `:name[label]{attrs}`. It owns the whole span: returning
  * `end` past the `[label]{attrs}` keeps the scanner's bracket stack from competing for the inner
  * `[label]`. Conservative by construction, declining unless `[` or `{` follows the name, so
  * `:smile:`, `10:30`, and `://` stay literal. Meaning is parsed elsewhere (`grammar.ts`).
  */
 import type { InlineNode, PluginInlineKind } from '../nodes';
-export declare function recognizeTextDirective(raw: string, pos: number, end: number, kind: PluginInlineKind): InlineNode | null;
+import type { GrammarView } from '../../schema/block-openers';
+export declare function recognizeTextDirective(raw: string, pos: number, end: number, kind: PluginInlineKind, grammar: GrammarView): InlineNode | null;

package/dist/core/directive/text-recognizer.js

@@ -1,5 +1,5 @@
 /**
- * Inline text-directive recognizer for `:name[label]{attrs}`. It OWNS the whole span: returning
+ * Inline text-directive recognizer for `:name[label]{attrs}`. It owns the whole span: returning
  * `end` past the `[label]{attrs}` keeps the scanner's bracket stack from competing for the inner
  * `[label]`. Conservative by construction, declining unless `[` or `{` follows the name, so
  * `:smile:`, `10:30`, and `://` stay literal. Meaning is parsed elsewhere (`grammar.ts`).
@@ -8,12 +8,8 @@ import { createBoundedMemo } from '../../bounded-memo';
 import { resolveDirective } from './registry';
 const isNameStart = (code) => (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a); // A-Z a-z
 const isNameChar = (code) => isNameStart(code) || (code >= 0x30 && code <= 0x39) || code === 0x2d; // + 0-9 -
-/**
- * Balanced-run matches for one block's raw. Without the memo, a paragraph carrying many `:name[`
- * starts pays a full block scan each. Matching is prefix-determined, so one stack pass answers
- * every consultation and the caller's `end` filters the result. Bounded rather than weak-keyed
- * because a string cannot key a WeakMap; two entries cover a block's own scan.
- */
+/** Balanced-run matches per block raw, so a paragraph with many `:name[` starts pays one scan:
+ *  matching is prefix-determined, and the caller's `end` filters the result. */
 const balancedRuns = createBoundedMemo({ cap: 2 });
 function matchBalancedRuns(raw) {
     const label = new Map();
@@ -50,7 +46,7 @@ function consumeBalanced(raw, open, end, openCh) {
     const close = (openCh === '[' ? runs.label : runs.attrs).get(open);
     return close !== undefined && close <= end ? close : -1;
 }
-export function recognizeTextDirective(raw, pos, end, kind) {
+export function recognizeTextDirective(raw, pos, end, kind, grammar) {
     // `://` is a scheme separator (http://, mailto:), never a directive.
     if (raw[pos + 1] === '/' && raw[pos + 2] === '/')
         return null;
@@ -82,6 +78,6 @@ export function recognizeTextDirective(raw, pos, end, kind) {
     }
     // Sibling-path parity with the block opener: a registered name resolves to the plugin's own
     // inline kind, an unregistered one keeps the generic `kind`.
-    const def = resolveDirective('text', raw.slice(pos + 1, nameEnd));
+    const def = resolveDirective('text', raw.slice(pos + 1, nameEnd), grammar);
     return { kind: (def?.kind ?? kind), start: pos, end: i };
 }

package/dist/core/escapable.d.ts

@@ -1,6 +1,2 @@
-/**
- * CommonMark's 32 escapable ASCII punctuation characters (§2.4). A core leaf because both the
- * inline scanner and the block-level link-reference parser (§4.7) need it, and neither should
- * import the other's directory to reach a lexical constant.
- */
+/** CommonMark's escapable ASCII punctuation (§2.4), shared by the inline and block parsers. */
 export declare const ESCAPABLE_PUNCTUATION: Set<string>;

package/dist/core/escapable.js

@@ -1,6 +1,2 @@
-/**
- * CommonMark's 32 escapable ASCII punctuation characters (§2.4). A core leaf because both the
- * inline scanner and the block-level link-reference parser (§4.7) need it, and neither should
- * import the other's directory to reach a lexical constant.
- */
+/** CommonMark's escapable ASCII punctuation (§2.4), shared by the inline and block parsers. */
 export const ESCAPABLE_PUNCTUATION = new Set('!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~');

package/dist/core/inline/backticks.d.ts

@@ -1,12 +1,11 @@
 /**
  * Backtick-run indexing for code spans (CommonMark §6.1): a run of N backticks closes with the
  * next run of exactly N. Indexed once, then binary-searched per opener, because a per-opener
- * forward rescan to EOF turns a run-length ladder quadratic.
+ * forward rescan to EOF turns a sequence of growing run lengths quadratic.
  */
 /**
- * Wrap `content` as a code span. The fence runs one backtick past the longest run it encloses, so
- * nothing inside can close it; content touching a backtick at either edge takes a space pad too,
- * without which the fence and that byte merge into one longer run and the span closes elsewhere.
+ * The fence runs one backtick past the longest run inside, so nothing inside closes it; content
+ * with a backtick at an edge gets a space pad, or that backtick would merge into the fence.
  */
 export declare function wrapAsCodeSpan(content: string): string;
 /** Run start positions by run length, ascending within each length. */

package/dist/core/inline/backticks.js

@@ -1,12 +1,11 @@
 /**
  * Backtick-run indexing for code spans (CommonMark §6.1): a run of N backticks closes with the
  * next run of exactly N. Indexed once, then binary-searched per opener, because a per-opener
- * forward rescan to EOF turns a run-length ladder quadratic.
+ * forward rescan to EOF turns a sequence of growing run lengths quadratic.
  */
 /**
- * Wrap `content` as a code span. The fence runs one backtick past the longest run it encloses, so
- * nothing inside can close it; content touching a backtick at either edge takes a space pad too,
- * without which the fence and that byte merge into one longer run and the span closes elsewhere.
+ * The fence runs one backtick past the longest run inside, so nothing inside closes it; content
+ * with a backtick at an edge gets a space pad, or that backtick would merge into the fence.
  */
 export function wrapAsCodeSpan(content) {
     const fence = '`'.repeat(longestBacktickRun(content) + 1);

package/dist/core/inline/character-refs.js

@@ -3,6 +3,7 @@
  * Per spec, zero, out-of-range, and surrogate code points decode to U+FFFD.
  */
 import { HTML5_NAMED_ENTITIES } from './html-entities';
+import { isHighSurrogate, isLowSurrogate } from '../lines';
 const REPLACEMENT = '�';
 // The longest body that can decode (`CounterClockwiseContourIntegral`). Capping the `;` search
 // keeps `&`-floods linear, where an unbounded indexOf rescans the region per candidate.
@@ -62,7 +63,7 @@ function decodeNumeric(body) {
         return REPLACEMENT;
     if (codePoint > 0x10ffff)
         return REPLACEMENT;
-    if (codePoint >= 0xd800 && codePoint <= 0xdfff)
+    if (isHighSurrogate(codePoint) || isLowSurrogate(codePoint))
         return REPLACEMENT;
     // The C1 range decodes verbatim, no cp1252 remap: a divergence from an HTML5 reference here
     // is deliberate, following CommonMark §2.5's letter.

package/dist/core/inline/destination-bytes.d.ts

@@ -1,7 +1,10 @@
 /**
- * The scan's inverse for the two fields every bracketed construct hides: a destination and a
- * title. One home so the image and link write seams cannot drift apart on what needs escaping —
- * the sibling-path shape that put an unencoded space in one seam and not the other.
+ * The inverse of `link-destination.ts` for the two fields every bracketed construct hides: a
+ * destination and a title. Reading the written bytes gives the value back, so the image and link
+ * write paths cannot change a url or title the user did not edit.
  */
+/** A bare destination (CommonMark §6.3) for `url`, its parentheses escaped only when they don't
+ *  all balance. */
 export declare function encodeDestination(url: string): string;
+/** A title's bytes for the double-quoted form. */
 export declare function escapeTitle(title: string): string;

package/dist/core/inline/destination-bytes.js

@@ -1,14 +1,56 @@
 /**
- * The scan's inverse for the two fields every bracketed construct hides: a destination and a
- * title. One home so the image and link write seams cannot drift apart on what needs escaping —
- * the sibling-path shape that put an unencoded space in one seam and not the other.
+ * The inverse of `link-destination.ts` for the two fields every bracketed construct hides: a
+ * destination and a title. Reading the written bytes gives the value back, so the image and link
+ * write paths cannot change a url or title the user did not edit.
  */
-// Bare destinations end at whitespace/`"`/`'` and carry parens only in balanced pairs
-// (CommonMark §6.3); a trailing backslash would escape the closer instead. Idempotent: an
-// encoded URL has no literal stop-char left.
+import { matchCharacterReference } from './character-refs';
+// ── Destinations ────────────────────────────────────────────────────────────
+/** A bare destination (CommonMark §6.3) for `url`, its parentheses escaped only when they don't
+ *  all balance. */
 export function encodeDestination(url) {
-    return url.replace(/[ \t\r\n()"'\\]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0'));
+    const escapeParens = !parensBalance(url);
+    let out = '';
+    for (let i = 0; i < url.length; i++) {
+        const ch = url[i];
+        if (DESTINATION_ENCODED.has(ch))
+            out += percentEncoded(ch);
+        else if ((ch === '(' || ch === ')') && escapeParens)
+            out += '\\' + ch;
+        else
+            out += escapedAmpersand(url, i) + ch;
+    }
+    return out;
 }
+// The destination parser percent-encodes these anyway, so encoding them changes no value; left
+// raw, each would end the destination, open the angle form, or escape the next byte.
+const DESTINATION_ENCODED = new Set(' \t\r\n\u000b\u000c"<>\\');
+function percentEncoded(ch) {
+    return '%' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0');
+}
+function parensBalance(url) {
+    let depth = 0;
+    for (const ch of url) {
+        if (ch === '(')
+            depth++;
+        else if (ch === ')' && --depth < 0)
+            return false;
+    }
+    return depth === 0;
+}
+// ── Titles ──────────────────────────────────────────────────────────────────
+/** A title's bytes for the double-quoted form. */
 export function escapeTitle(title) {
-    return title.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    let out = '';
+    for (let i = 0; i < title.length; i++) {
+        const ch = title[i];
+        out += ch === '\\' || ch === '"' ? '\\' + ch : escapedAmpersand(title, i) + ch;
+    }
+    return out;
+}
+// ── Shared ──────────────────────────────────────────────────────────────────
+/** The backslash an `&` needs when the text after it would read as a character reference. */
+function escapedAmpersand(text, at) {
+    if (text[at] !== '&')
+        return '';
+    return matchCharacterReference(text, at, text.length)?.decoded !== undefined ? '\\' : '';
 }

package/dist/core/inline/entity-widget.d.ts

@@ -1,11 +1,12 @@
 /**
- * Visibility gate and DOM builder for the decoded-entity inline widget. A character reference
+ * Visibility check and DOM builder for the decoded-entity inline widget. A character reference
  * renders as an atomic widget showing its decoded glyph, but only when that glyph is visible:
  * an entity decoding to nothing drawable (` `, `​`) keeps its literal
- * source span, because an invisible atomic island is a caret trap.
+ * source span, because the caret would get stuck on an invisible widget.
  */
 import type { InlineNode } from '../nodes';
 /** True when the decoded value draws at least one glyph, so it earns a widget. */
 export declare function entityRendersGlyph(decoded: string | undefined): boolean;
-/** Source bytes ride the shell's `data-source-*`, so the raw-aware walk reads back `©`. */
+/** The source bytes live on the shell's `data-source-*`, so the DOM-to-offset traversal reads
+ *  `©` rather than the glyph. */
 export declare function buildEntityWidget(node: InlineNode): HTMLSpanElement;

package/dist/core/inline/entity-widget.js

@@ -1,19 +1,19 @@
 /**
- * Visibility gate and DOM builder for the decoded-entity inline widget. A character reference
+ * Visibility check and DOM builder for the decoded-entity inline widget. A character reference
  * renders as an atomic widget showing its decoded glyph, but only when that glyph is visible:
  * an entity decoding to nothing drawable (` `, `​`) keeps its literal
- * source span, because an invisible atomic island is a caret trap.
+ * source span, because the caret would get stuck on an invisible widget.
  */
 import { mintWidgetShell } from './inline-widgets';
-// Zero-advance categories only. `Mn`/`Me` are here because a lone combining mark (`́`)
-// has nothing to combine with and draws nothing; spacing marks (`Mc`) keep real advance and
-// stay widgets. The empty string (a non-decoding node) is invisible by the same test.
+// Zero-advance categories only: a lone combining mark (`Mn`/`Me`, `́`) has nothing to
+// combine with and draws nothing, while a spacing mark (`Mc`) has real width and stays a widget.
 const RENDERS_NO_GLYPH = /^[\p{Cc}\p{Cf}\p{Zs}\p{Zl}\p{Zp}\p{Mn}\p{Me}]*$/u;
 /** True when the decoded value draws at least one glyph, so it earns a widget. */
 export function entityRendersGlyph(decoded) {
     return decoded !== undefined && !RENDERS_NO_GLYPH.test(decoded);
 }
-/** Source bytes ride the shell's `data-source-*`, so the raw-aware walk reads back `©`. */
+/** The source bytes live on the shell's `data-source-*`, so the DOM-to-offset traversal reads
+ *  `©` rather than the glyph. */
 export function buildEntityWidget(node) {
     const shell = mintWidgetShell('md-entity-widget', node);
     shell.textContent = node.decoded ?? '';