@voithos-labs/aragonite 0.10.3 → 0.10.7

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 ?? '';

package/dist/core/inline/format-toggle.d.ts

@@ -1,19 +1,16 @@
 /**
- * Toggle an inline format inside a prose block. Over a SELECTION the direction is parse coverage,
- * not edge adjacency: a covered range unapplies (aligned strip, else split, over every covering run
- * in turn), overlapping or abutting runs apply over their union, a bare range wraps the core its
- * boundary whitespace leaves. Where the mode PAINTS delimiters the strip and the wrap write
- * unverified; every other candidate declines unless it verifies. At a COLLAPSED CARET: unwrap the
- * span, else drop the empty pair, else insert one (live-mode.md § 4.3). Every write clamps to the
- * CONTENT range: a marker in `# ` changes the kind.
+ * Toggles an inline mark inside a prose block, and answers whether a range already carries one.
+ * The parse decides the direction; in a mode that hides markers a candidate must leave the screen
+ * text unchanged (`docs/design/live-mode.md` § 2, and § 4.3 for a collapsed caret). Writes stay
+ * inside the content range, since a marker written into `# ` would change the block's kind.
  */
-import { type PresentationMode } from '../../presentation-mode';
 import { type InlineMarkKind } from '../../schema/inline-construct-policy';
+import type { Reading } from '../../schema/reading';
 import { type ContentRange } from './index';
 /** Named fields, because the two ranges and the display are all offsets into the same string:
  *  a swapped content-and-selection pair type-checks and splices markers into structural bytes. */
 export interface InlineFormatEdit {
-    /** The block's display bytes — its raw without the trailing line ending. */
+    /** The block's display bytes: its raw without the trailing line ending. */
     display: string;
     /** The bytes the block's own kind calls content; every write clamps into them. */
     content: ContentRange;
@@ -21,37 +18,34 @@ export interface InlineFormatEdit {
         start: number;
         end: number;
     };
+    /** How the block was drawn: without its link definitions a reference link reads as plain
+     *  brackets and a wrap cuts through it, and its mode decides whether a candidate is verified. */
+    reading: Reading;
 }
 export interface ToggleInlineFormatResult {
     newDisplay: string;
     newSelStart: number;
     newSelEnd: number;
 }
-/** Null for a kind whose row declares no mark, or for a press whose every candidate fails its
- *  verification: the vocabulary lives on the row, so a kind without one has no delimiters this
- *  seam could write, and a toggle's sound fallback is not writing. */
-export declare function toggleInlineFormat(edit: InlineFormatEdit, format: InlineMarkKind, mode: PresentationMode | undefined): ToggleInlineFormatResult | null;
-/** Whether a toggle right now would UNAPPLY — the pressed-state a toolbar paints. The same arms
- *  the toggle routes by, asked without emitting: a caret inside the construct, a selection
- *  carrying its own markers, flanked by them, or covered by a same-format construct. */
+/** Null for a kind whose policy row declares no mark (there are no delimiters to write) and for
+ *  a toggle whose every candidate fails verification: the safe fallback is to write nothing. */
+export declare function toggleInlineFormat(edit: InlineFormatEdit, format: InlineMarkKind): ToggleInlineFormatResult | null;
+/** Whether a toggle right now would unformat, which is the pressed state a toolbar shows. The
+ *  same checks the toggle routes by, asked without writing anything. */
 export declare function isInlineFormatActive(edit: InlineFormatEdit, format: InlineMarkKind): boolean;
-/** The pressed state a result would paint: the same read, over the bytes and range it hands back.
- *  One home for the after-read, so the seam's own direction check and the ladder guard cannot
- *  drift on the content-end arithmetic. */
+/** The same read over the bytes and range `result` hands back, kept here so the toggle's direction
+ *  check and the tests that re-read a result agree on where the content ends. */
 export declare function isInlineFormatActiveAfter(edit: InlineFormatEdit, result: ToggleInlineFormatResult, format: InlineMarkKind): boolean;
 /** Every registered mark the edit's range already carries. */
 export declare function activeInlineFormats(edit: InlineFormatEdit): Set<InlineMarkKind>;
-/** Which of `candidates` the range carries, off ONE parse of the block. A toolbar asks once per
- *  button on every selection change and every answer is the same walk; taking candidates rather
- *  than the vocabulary is what lets a range's running intersection stop re-asking ruled-out marks. */
+/** One parse of the block for every candidate. A toolbar asks per button on each selection
+ *  change, so a caller can leave out marks it has already ruled out. */
 export declare function inlineFormatsCovering(edit: InlineFormatEdit, candidates: Iterable<InlineMarkKind>): Set<InlineMarkKind>;
-/** The same read, one id at a time, with consecutive asks over one block state sharing the parse:
- *  a toolbar's buttons arrive as N separate calls, and only the caller knows they are one repaint.
- *  One slot, since the previous state is dead the moment a keystroke or the caret moves. */
+/** Shares one parse across a toolbar's per-button calls over the same block state. One memo
+ *  entry only, since a keystroke or a caret move retires the previous state. */
 export declare function createInlineFormatActiveMemo(): (edit: InlineFormatEdit, format: InlineMarkKind) => boolean;
-/** A range minus its boundary whitespace, null once nothing is left. One home for the trim, so the
- *  wrap here and the cross-block decomposition that trims before it ever asks
- *  (`selection/cross-block/format-range.ts`) cannot disagree about where a run may close. */
+/** Shared with the cross-block path (`selection/cross-block/format-range.ts`) so the two agree
+ *  on where a run may close. Null when nothing is left. */
 export declare function withoutBoundaryWhitespace(display: string, from: number, to: number): {
     start: number;
     end: number;