@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Syntax/RedNodeStore.d.ts

@@ -0,0 +1,116 @@
+/**
+ * DocumentEngine — RedNodeStore
+ *
+ * Canonical store for RedNodes. Ensures that structurally identical subtrees
+ * share the EXACT SAME RedNode instance in RAM.
+ *
+ * This is the RedNode-level complement to GreenNodePool (which handles
+ * structural sharing at the GreenNode level).
+ *
+ * Architecture:
+ * - Keyed by GreenNode._hash (deterministic structural hash)
+ * - Bottom-up: children are stored first, then parents reference them
+ * - Immutable structural data: once a RedNode is in the store, its `children`
+ *   array and `green` reference never change
+ * - Mutable metadata: the store's RedNode has canonical metadata (derived from
+ *   green.text). Position-specific metadata lives in PositionRef.localOverlay.
+ *
+ * Benefits:
+ * - Memory deduplication: 100 identical blocks = 1 RedNode + 99 lightweight refs
+ * - Render caching: BBCodeCanvas can memoize by canonicalId
+ * - Faster incremental parse: unchanged subtrees keep their RedNode identity
+ * - HTMLRenderer cache: same canonicalId = same HTML (cache hits)
+ */
+import { GreenNode } from './GreenNode';
+import { RedNode } from './RedNode';
+import type { NodeKind, NodeMetadata } from '../Types/core';
+/**
+ * Derives a node's canonical metadata from its GreenNode.
+ *
+ * Injected rather than hardcoded: metadata extraction is *language* semantics
+ * (what `=#ff0000,#00ff00` means for a `gradient`), and this module sits in the
+ * language-agnostic `Syntax` layer. The BBCode implementation lives in
+ * `BBCode/BBCodeToGreenNode.ts`; pass it via the constructor.
+ */
+export type MetadataExtractor = (green: GreenNode) => NodeMetadata;
+export declare class RedNodeStore {
+    private canonicals;
+    private _hits;
+    private _misses;
+    private _collisions;
+    private readonly extractMetadata;
+    /**
+     * @param extractMetadata  How to derive canonical metadata from a green node.
+     *   Defaults to producing none — the store stays language-agnostic unless a
+     *   caller supplies the mapping.
+     */
+    constructor(extractMetadata?: MetadataExtractor);
+    /**
+     * Get or create a canonical RedNode for the given GreenNode.
+     *
+     * The store is keyed by `green._hash` — a 32-bit FNV structural hash — so a
+     * matching key is necessary but NOT sufficient proof of identity. The
+     * canonical pipeline (GreenNodePool interning) guarantees that structurally
+     * identical greens ARE the same object, which is what makes reference
+     * equality a sound discriminator:
+     *
+     * - same hash + same green reference  → HIT, reuse the canonical
+     * - same hash + different green       → COLLISION: a distinct subtree shares
+     *   the 32-bit hash. It is never reused as the registered canonical and never
+     *   overwrites it (that would corrupt every future hit for the registered
+     *   node). The colliding subtree simply loses canonicalization — rebuilt on
+     *   each call. Guarding correctness costs a rare dedup miss; the alternative
+     *   costs a wrong AST.
+     * - no hash entry                     → MISS, create and register
+     *
+     * Invariant preserved: a hash collision can never make one structure be
+     * represented by another structure's RedNode.
+     *
+     * @param green  The GreenNode to wrap
+     * @param metadata  Optional metadata to set (overrides intrinsic metadata)
+     * @param kind  Optional kind override
+     * @returns The canonical RedNode (shared if already exists)
+     */
+    getOrCreate(green: GreenNode, metadata?: NodeMetadata, kind?: NodeKind): RedNode;
+    /**
+     * Build a canonical RedNode for `green` WITHOUT registering it.
+     *
+     * Shared by the miss path (which registers the result) and the collision
+     * path (which must not). Both need the same bottom-up construction:
+     * children are canonicalized first, then the parent references them.
+     */
+    private buildCanonical;
+    /**
+     * Look up a canonical RedNode by its structural hash.
+     */
+    getByHash(hash: string): RedNode | undefined;
+    /**
+     * Check if a GreenNode already has a canonical RedNode.
+     *
+     * Mirrors `getOrCreate`'s discriminator, including the identity check. A
+     * present hash entry only proves *some* structure registered under this
+     * 32-bit hash; if it is a different green, `getOrCreate` counts a collision
+     * and builds an unregistered node, so answering `true` here would be the
+     * opposite of the truth for any caller deciding whether canonicalization has
+     * already happened.
+     */
+    has(green: GreenNode): boolean;
+    /**
+     * Get the number of unique canonical nodes.
+     */
+    get size(): number;
+    /**
+     * Get store statistics.
+     */
+    get stats(): {
+        size: number;
+        hits: number;
+        misses: number;
+        collisions: number;
+        deduplicationRatio: string;
+    };
+    /**
+     * Clear all canonical nodes.
+     */
+    clear(): void;
+}

package/dist/types/Syntax/TreeBuilder.d.ts

@@ -0,0 +1,54 @@
+/**
+ * DocumentEngine — TreeBuilder
+ *
+ * Converts a TokenStream into a GreenNode tree.
+ * This is the bridge between the Lexer and the Syntax Tree.
+ *
+ * The TreeBuilder is language-agnostic — it uses registry-based
+ * node factories to build the appropriate tree structure.
+ */
+import { GreenNode } from './GreenNode';
+import { RedNode } from './RedNode';
+import type { TokenStream, Token } from '../Types/tokens';
+import type { NodeKind } from '../Types/core';
+export interface BuildResult {
+    green: GreenNode;
+    red: RedNode;
+    tokens: Token[];
+}
+export interface NodeFactory {
+    /** Create a GreenNode from a token or sequence of tokens */
+    createGreen(tokens: Token[], stream: TokenStream): GreenNode | null;
+    /** Create a RedNode from a green node */
+    createRed(green: GreenNode, parent?: RedNode | null): RedNode;
+}
+export declare class TreeBuilder {
+    private factories;
+    private defaultKind;
+    constructor(defaultKind?: NodeKind);
+    /**
+     * Register a node factory for a specific token kind or tag name.
+     */
+    register(kind: string, factory: NodeFactory): void;
+    /**
+     * Build a tree from a token stream.
+     */
+    build(stream: TokenStream): BuildResult;
+    /**
+     * Build a green tree from a token array.
+     * Uses registered factories to determine node structure.
+     *
+     * By default, creates a flat document structure.
+     * Language-specific builders (like BBCodeParser) override this.
+     */
+    buildGreen(tokens: Token[]): GreenNode;
+    /**
+     * Build a red tree from a green tree.
+     */
+    buildRed(green: GreenNode, parent?: RedNode | null, kind?: NodeKind): RedNode;
+    /**
+     * Create a RedNode directly from children (for language-specific parsers).
+     */
+    createRedFromChildren(kind: NodeKind, text: string, children: RedNode[], parent?: RedNode | null): RedNode;
+    private tagToKind;
+}

package/dist/types/Syntax/__tests__/GreenNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Syntax/__tests__/RedNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Syntax/__tests__/RedNodeStore.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Syntax/greenEdit.d.ts

@@ -0,0 +1,64 @@
+/**
+ * DocumentEngine — Green tree editing primitives
+ *
+ * The green tree is immutable, so an edit is not a mutation: it is a new tree
+ * that shares everything the edit did not touch.
+ *
+ * ─── What used to be here ───────────────────────────────────────────────────
+ *
+ * `shiftGreen(node, delta)` — a deep copy of a subtree with every range moved.
+ * It existed because green nodes carried absolute positions, so inserting three
+ * characters near the top of a document meant rebuilding every node after the
+ * insertion point just to renumber it. On a 19.6 KB document that was 14% of
+ * the cost of an incremental reparse, spent entirely on producing structurally
+ * identical copies of nodes that had not changed.
+ *
+ * It is gone, and there is nothing to replace it with. Green nodes have widths,
+ * not positions (see `GreenNode.ts`), so text inserted before a subtree changes
+ * where it is — which is the red tree's business — and not what it is. A
+ * sibling after an edit is now shared by reference, exactly like a sibling
+ * before it always was.
+ */
+import { GreenNode } from './GreenNode';
+/** One step of the descent from the root to the node being replaced. */
+export interface SpineStep {
+    /** The ancestor. */
+    node: GreenNode;
+    /** Index of the child that the descent continued into. */
+    index: number;
+}
+/**
+ * Rebuild the ancestor spine after replacing one node.
+ *
+ * `spine` runs root-first; `replacement` takes the place of
+ * `spine[spine.length - 1].node.children[spine[spine.length - 1].index]`.
+ *
+ * Only the spine itself is rebuilt — one new node per level of nesting, and
+ * every other subtree in the document is carried over by reference. The
+ * ancestors' widths follow from their new children automatically, so there is
+ * no delta to propagate and no way to get the arithmetic wrong.
+ */
+export declare function spliceGreen(spine: readonly SpineStep[], replacement: GreenNode): GreenNode;
+/**
+ * Replace a node's children while keeping the node itself — its kind, its
+ * attributes and, above all, its delimiters.
+ *
+ * The incremental parser re-parses a span strictly INSIDE a node, so that
+ * node's own `[centre]` and `[/centre]` never pass through the parser again and
+ * cannot be reinterpreted. `leadingWidth`/`trailingWidth` carry across
+ * untouched; the new width follows from the new children.
+ */
+export declare function withChildren(node: GreenNode, children: GreenNode[]): GreenNode;
+/**
+ * Replace the children `[from, to)` of `node` with `replacement`.
+ *
+ * The unit an edit actually touches is a RUN OF SIBLINGS, not a whole node.
+ * Re-parsing a container's entire contents because one character changed
+ * somewhere inside it meant that typing into a large `[notice]` re-lexed 66% of
+ * the document per keystroke; and an edit at document level had no enclosing
+ * container at all, so it fell back to a full rebuild — which is where the
+ * caret sits while you write the end of a post, the single most common case.
+ *
+ * Everything outside `[from, to)` is carried over by reference.
+ */
+export declare function withChildrenSpliced(node: GreenNode, from: number, to: number, replacement: readonly GreenNode[]): GreenNode;

package/dist/types/Syntax/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Quasar — Structural Hashing Primitives (FNV-1a)
+ *
+ * Shared by GreenNode (`_hash`, for interning and structural sharing) and
+ * NodeMatcher (subtree fingerprints, for cross-version node matching).
+ *
+ * FNV-1a is chosen for the same reason Roslyn uses a cheap non-cryptographic
+ * hash: this runs once per node on every keystroke, so throughput matters far
+ * more than adversarial collision resistance. `Math.imul` keeps the multiply
+ * in 32-bit integer space instead of promoting to doubles.
+ */
+export declare const FNV_OFFSET = 2166136261;
+export declare const FNV_PRIME = 16777619;
+/** Secondary basis, used to build a 64-bit key from two independent lanes. */
+export declare const FNV_OFFSET_ALT = 668265263;
+export declare function hashString(seed: number, str: string): number;
+export declare function hashUint32(seed: number, value: number): number;

package/dist/types/Syntax/index.d.ts

@@ -0,0 +1,8 @@
+export { GreenNode, greenNode, greenLeaf } from './GreenNode';
+export { RedNode } from './RedNode';
+export { TreeBuilder } from './TreeBuilder';
+export type { BuildResult, NodeFactory } from './TreeBuilder';
+export { checkPartition, assertPartition } from './partition';
+export type { PartitionViolation, PartitionViolationKind, CheckPartitionOptions, } from './partition';
+export { NodeMatcher } from './NodeMatcher';
+export type { MatchResult, MatchStatus, NodeMatch } from './NodeMatcher';

package/dist/types/Syntax/nodeAttr.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Cómo se lee el atributo de una etiqueta BBCode, y qué valores se aceptan.
+ *
+ * ── Por qué esto vive fuera del renderizador ───────────────────────────────
+ *
+ * Era privado de `HTMLRenderer`, así que cualquier otro consumidor que
+ * necesitara el mismo dato tenía que reinventarlo — y se reinventó mal. Los
+ * presets del lienzo de BBCodeCanvas leían `node.text` en crudo, con el `=`
+ * pegado delante: `[color=#ff0000]` acababa produciendo `color: "=#ff0000"`,
+ * que es CSS inválido, así que el color no se pintaba en absoluto. Lo mismo con
+ * `font_size` y `url`.
+ *
+ * No es un helper nuevo: es el mismo código, movido a donde los dos lo ven. Si
+ * el renderizador y el lienzo vuelven a divergir, al menos divergirán desde el
+ * mismo sitio.
+ */
+import type { RedNode } from './RedNode';
+import type { TokenResolverFn } from '../Tokens';
+/**
+ * El valor del atributo de un nodo.
+ *
+ * Los atributos BBCode vienen como `=VALOR` (`=#61afef`, `="Autor"`,
+ * `=https://osu.ppy.sh`): se quita el `=` y las comillas envolventes. Una
+ * etiqueta sin atributo —el contenido de un `[img]`, por ejemplo— devuelve su
+ * texto tal cual.
+ *
+ * Con `key`, gana lo que haya en `metadata`: es lo que escribe el Inspector al
+ * editar una propiedad, y tiene que pesar más que el texto original del
+ * documento, que todavía no se ha reescrito.
+ */
+export declare function nodeAttrValue(node: RedNode, key?: string): string;
+/**
+ * Un color que se puede meter en un `style`, o `null`.
+ *
+ * Devolver `null` en vez de el valor crudo no es remilgo: `[color=red;"
+ * onmouseover="alert(1)]` cierra el atributo e inyecta un manejador de eventos.
+ * Escapar solo neutralizaría la inyección, pero dejaría CSS roto, así que se
+ * valida la FORMA y se descarta lo que no sea un valor que quisiéramos admitir.
+ *
+ * Un hex sin `#` se completa: `[color=ff0000]` es como lo escribe medio mundo.
+ */
+export declare function sanitizeColor(raw: string, resolver?: TokenResolverFn): string | null;
+/** El tamaño de `[size=…]` como número, o `null`. Se interpola en `%`. */
+export declare function sanitizeFontSize(raw: string, resolver?: TokenResolverFn): string | null;
+/** La familia de `[font=…]`, o `null`. */
+export declare function sanitizeFontFamily(raw: string, resolver?: TokenResolverFn): string | null;
+/** Lo que puede significar el atributo de un `[img=…]`. */
+export interface ImgAttr {
+    w?: number;
+    h?: number;
+    round?: boolean;
+    shadow?: boolean;
+    float?: boolean;
+}
+/**
+ * El modificador de una imagen: `[img=200x100]`, `[img=round]`, `[img=shadow]`,
+ * `[img=float]`.
+ *
+ * Vive aquí y no en el renderizador porque es interpretación del ATRIBUTO, no
+ * de cómo se pinta: quien quiera respetar un `round` necesita este mismo
+ * significado, y hasta ahora el lienzo simplemente lo ignoraba.
+ */
+export declare function parseImgAttr(v: string | null): ImgAttr;

package/dist/types/Syntax/partition.d.ts

@@ -0,0 +1,67 @@
+/**
+ * DocumentEngine — Partition Invariant
+ *
+ * The green tree must PARTITION the source text: every character of the input
+ * is accounted for exactly once, and the tree can answer "which node owns
+ * offset N?" without ambiguity.
+ *
+ * Before the width model this was false in three ways, all measured:
+ *
+ *  1. Delimiters were not represented at all. `[b]hola[/b]` produced a `bold`
+ *     spanning `[0..13]` whose only child spanned `[3..7]` — 6 characters
+ *     inside the parent belonged to no node. 32.630 occurrences of
+ *     `parent.start != firstChild.start` in a single real document.
+ *  2. Siblings could occupy the same range. `"hola\n\nmundo"` produced
+ *     `spacing [4..6]` AND `empty_line [4..6]`, so offset 5 had two owners.
+ *  3. Orphaned closing tags were dropped silently, leaving holes in the root.
+ *
+ * ─── What this module still checks, and what it no longer needs to ──────────
+ *
+ * Most of the invariant is now STRUCTURAL. A green node has no position, and
+ * its width is computed by its own constructor as
+ * `leadingWidth + Σ child widths + trailingWidth`, so gaps, overlaps and
+ * mismatched delimiters are not states the type can be in. The checks for them
+ * were deleted along with the ability to fail them.
+ *
+ * Two things remain genuinely checkable, and they are the two that matter:
+ *
+ *  - **Coverage.** The root's width must equal the source length. If the parser
+ *    drops a token — which is exactly what the orphaned-closing-tag bug did —
+ *    the tree is internally consistent but describes a shorter document.
+ *  - **Leaf honesty.** A `text` token's width must equal the text it holds.
+ *    Nothing derives this, so nothing enforces it.
+ */
+import type { GreenNode } from './GreenNode';
+export type PartitionViolationKind = 
+/** The root's width does not match the source length. */
+'root-coverage'
+/** A leaf's width does not match the text it claims to hold. */
+ | 'leaf-width'
+/** A node's width disagrees with its own children plus delimiters. */
+ | 'width-mismatch';
+export interface PartitionViolation {
+    kind: PartitionViolationKind;
+    /** Structural path to the offending node, e.g. `document/paragraph[0]/bold[1]`. */
+    path: string;
+    nodeKind: string;
+    detail: string;
+}
+export interface CheckPartitionOptions {
+    /** Stop after this many violations. Default 200 — enough to diagnose, cheap to print. */
+    limit?: number;
+    /**
+     * Also require leaf widths to match `text.length`. Off by default: `text` on
+     * a leaf is overloaded (it holds tag attributes on element nodes and is empty
+     * on `spacing`/`empty_line`), so only `text`-kind leaves are checked even
+     * when this is on.
+     */
+    checkLeafWidths?: boolean;
+}
+/**
+ * Verify that `root` partitions `[0..sourceLength]`.
+ *
+ * Returns an empty array when the tree is well formed. Never throws.
+ */
+export declare function checkPartition(root: GreenNode, sourceLength: number, options?: CheckPartitionOptions): PartitionViolation[];
+/** Convenience for tests: throw a readable error if the invariant is broken. */
+export declare function assertPartition(root: GreenNode, sourceLength: number): void;

package/dist/types/Syntax/preserveNodeIds.d.ts

@@ -0,0 +1,47 @@
+/**
+ * DocumentEngine — preserveNodeIds
+ *
+ * Carry `RedNode.id` across a reparse, so a node that did not change keeps
+ * the identity it had in the previous tree.
+ *
+ * Why this exists: every element in the rendered HTML embeds `data-node-id`
+ * (the preview→Monaco click mapping reads it), and ids used to be regenerated
+ * on every parse. That made the HTML of *unchanged* subtrees differ between
+ * keystrokes, which defeated the DOMMorpher's `isEqualNode` fast path —
+ * measured on a one-character edit, only 2 of 5 top-level subtrees compared
+ * equal with ids embedded, versus 4 of 5 without them. Stable ids also make
+ * any future node-identity feature (selection preservation, collaboration)
+ * possible at all: two versions of a document can refer to the same node.
+ *
+ * The pairing strategy mirrors `NodeMatcher`'s Phase 0, which is validated at
+ * scale: walk both trees in lockstep, trim the common prefix and suffix of
+ * every child list, and only descend into the changed window when it is the
+ * single-child shape a keystroke produces. Three tiers of matching:
+ *
+ *   1. Reference-equal greens — the incremental splice shares untouched
+ *      subtrees by reference, so this covers almost everything while typing.
+ *      Identical by construction; adopt the whole subtree, no checks.
+ *   2. Hash-equal greens — the full-rebuild path reparses everything, so
+ *      nothing is reference-equal but unchanged subtrees hash the same.
+ *      Verified structurally before adopting (a 32-bit hash is not proof).
+ *   3. Same kind at the same position — the node itself changed (it is the
+ *      one being typed into) but it is still "the same element", so it keeps
+ *      its id and its children get the prefix/suffix treatment.
+ *
+ * Uniqueness is preserved by construction: the walk is strictly positional
+ * (old child i pairs with at most one new child), so an old id is adopted at
+ * most once, and ids never adopted stay as freshly generated — the global
+ * counter guarantees those cannot collide with anything older.
+ */
+import type { RedNode } from './RedNode';
+export interface PreserveIdsStats {
+    /** Nodes that kept their previous id */
+    adopted: number;
+    /** Nodes in the new tree that kept a fresh id */
+    fresh: number;
+}
+/**
+ * Copy ids from `oldRoot`'s tree onto the matching nodes of `newRoot`'s tree.
+ * Returns how many nodes were matched, for tests and diagnostics.
+ */
+export declare function preserveNodeIds(oldRoot: RedNode, newRoot: RedNode): PreserveIdsStats;

package/dist/types/Tokens/TokenResolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Quasar Document Engine — Design Tokens
+ *
+ * Provides token types and normalization utilities for design token resolution.
+ * Completely independent of @miliastry/core.
+ */
+export interface DocumentTokens {
+    palette?: Record<string, string>;
+    variables?: Record<string, string>;
+}
+export type TokenResolverFn = (name: string) => string | undefined;
+export type TokenSource = DocumentTokens | TokenResolverFn;
+/**
+ * Normalizes a TokenSource into a TokenResolverFn.
+ *
+ * For DocumentTokens, checks palette[name] ?? variables[name], handling both
+ * with and without leading `$`.
+ * If source is already a function, passes it through.
+ */
+export declare function toTokenResolver(source?: TokenSource): TokenResolverFn | undefined;
+/**
+ * Resolves a token value if val starts with `$`.
+ * Strips `$` and looks up in resolver. If found, returns resolved value; otherwise returns val.
+ */
+export declare function resolveTokenValue(val: string, resolver?: TokenResolverFn): string;

package/dist/types/Tokens/index.d.ts

@@ -0,0 +1 @@
+export * from './TokenResolver';

package/dist/types/Transactions/Transaction.d.ts

@@ -0,0 +1,36 @@
+/**
+ * DocumentEngine — Transaction
+ *
+ * Groups operations into an atomic, undoable unit.
+ * Every modification to the document MUST go through a Transaction.
+ *
+ * Inspired by ProseMirror's Transaction system.
+ */
+import { RedNode } from '../Syntax/RedNode';
+import type { Operation } from '../Types/operations';
+export declare class Transaction {
+    readonly operations: Operation[];
+    readonly id: string;
+    readonly timestamp: number;
+    private _applied;
+    constructor(operations: Operation[]);
+    /**
+     * Apply the transaction to a RedNode tree.
+     * Returns the updated tree or null if application failed.
+     */
+    apply(root: RedNode): RedNode | null;
+    /**
+     * Create the inverse transaction (for undo).
+     */
+    invert(root: RedNode): Transaction;
+    /**
+     * Get a human-readable label for this transaction.
+     */
+    getLabel(): string;
+    private applyOperation;
+    private applyInsert;
+    private applyDelete;
+    private applyReplace;
+    private applyMove;
+    private applySetText;
+}

package/dist/types/Transactions/UndoManager.d.ts

@@ -0,0 +1,63 @@
+/**
+ * DocumentEngine — UndoManager
+ *
+ * Manages the undo/redo history stack.
+ *
+ * Entries are source-text snapshots, not stored tree mutations: the model
+ * rebuilds from text on undo/redo, so an entry stays replayable even after
+ * intervening rebuilds have replaced every node id it could have referenced.
+ * (The previous design stored `Transaction`s, whose `invert()` was only
+ * defined for one of the six operation kinds and whose one-shot `_applied`
+ * flag made redo a silent no-op.)
+ *
+ * Inspired by VSCode's undo stack.
+ */
+export interface UndoEntry {
+    /** Source text before the change */
+    before: string;
+    /** Source text after the change */
+    after: string;
+    label: string;
+    timestamp: number;
+}
+export declare class UndoManager {
+    private undoStack;
+    private redoStack;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Push a change (as before/after source snapshots) onto the undo stack.
+     */
+    push(snapshot: {
+        before: string;
+        after: string;
+    }, label?: string): void;
+    /**
+     * Undo the last change.
+     */
+    undo(): UndoEntry | null;
+    /**
+     * Redo the last undone change.
+     */
+    redo(): UndoEntry | null;
+    /**
+     * Peek at the top of the undo stack without removing.
+     */
+    peekUndo(): UndoEntry | null;
+    /**
+     * Peek at the top of the redo stack without removing.
+     */
+    peekRedo(): UndoEntry | null;
+    /**
+     * Clear both stacks.
+     */
+    clear(): void;
+    /**
+     * Get the number of undoable actions.
+     */
+    get undoCount(): number;
+    /**
+     * Get the number of redoable actions.
+     */
+    get redoCount(): number;
+}

package/dist/types/Transactions/index.d.ts

@@ -0,0 +1,3 @@
+export { Transaction } from './Transaction';
+export { UndoManager } from './UndoManager';
+export type { UndoEntry } from './UndoManager';

package/dist/types/Transformers/ASTOptimizer.d.ts

@@ -0,0 +1,34 @@
+import { DocumentModel } from '../Model/DocumentModel';
+import { Transformer, TransformResult } from './Transformer';
+export declare class ASTOptimizer implements Transformer {
+    transform(document: DocumentModel): TransformResult;
+    private applyRules;
+    private static VOID_TAGS;
+    private static UNMERGEABLE;
+    private isEmptyNode;
+    /**
+     * Two `paragraph` siblings with *nothing* between them.
+     *
+     * `paragraph` is in {@link UNMERGEABLE} for good reason — paragraphs are block
+     * separators and collapsing them normally would change the document. But this
+     * particular shape is one the optimizer creates itself and the parser never
+     * does: paragraphs exist because a block element split the inline content, so
+     * when a rule deletes that block (an empty `[notice]`, say) the two halves are
+     * left as adjacent paragraphs that no longer have anything separating them.
+     *
+     * That was the whole non-idempotence bug. Exporting such a tree emits no
+     * separator, so re-parsing folds the two paragraphs back into one and a second
+     * optimizer pass finds more work to do. Merging here makes the tree agree with
+     * its own round-trip.
+     *
+     * Verified empirically before relying on it: across 202.764 nodes (both real
+     * fixtures plus 20.000 seeded random documents) the parser produced this shape
+     * **zero** times, so the rule can only ever fire on optimizer-made trees.
+     *
+     * `spaces` must be empty — paragraphs separated by real spacing or blank lines
+     * are a genuine authored break and must survive.
+     */
+    private isOrphanedParagraphPair;
+    private canMerge;
+    private getRank;
+}

package/dist/types/Transformers/GradientTransformer.d.ts

@@ -0,0 +1,18 @@
+import { DocumentModel } from '../Model/DocumentModel';
+import { Transformer, TransformResult } from './Transformer';
+import { type Easing } from '../Utils/color';
+export interface GradientOptions {
+    from: string;
+    to: string;
+    unit: 'char' | 'word';
+    easing: Easing;
+    selectionRange?: {
+        start: number;
+        end: number;
+    };
+}
+export declare class GradientTransformer implements Transformer {
+    private options;
+    constructor(options?: Partial<GradientOptions>);
+    transform(document: DocumentModel): TransformResult;
+}

package/dist/types/Transformers/GrowTransformer.d.ts

@@ -0,0 +1,16 @@
+import { DocumentModel } from '../Model/DocumentModel';
+import { Transformer, TransformResult } from './Transformer';
+export interface GrowOptions {
+    minSize: number;
+    maxSize: number;
+    cycles: number;
+    selectionRange?: {
+        start: number;
+        end: number;
+    };
+}
+export declare class GrowTransformer implements Transformer {
+    private options;
+    constructor(options?: Partial<GrowOptions>);
+    transform(document: DocumentModel): TransformResult;
+}