@miliastry/quasar 1.0.6 → 1.1.0

package/dist/types/Utils/TagVocabulary.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Quasar — Enumerated attribute vocabularies
+ *
+ * Some tags take an attribute that is not free text: `[effect=glow]`,
+ * `[anim=glitch]`, `[container=grid]`, `[separator=dots]`. The set of values
+ * each one accepts was, until now, knowable only by reading the `switch` in
+ * `HTMLRenderer` — so the editor could offer tag names but never values, and
+ * an author had to remember thirty-six magic words.
+ *
+ * ── Why this is a problem worth a module ──
+ *
+ * Every one of those switches ends in a `default:`, and none of the defaults
+ * is an error. A misspelling does not fail; it renders something else:
+ *
+ *   [anim=glich]      → `bb-pulse`   (a different animation)
+ *   [container=gird]  → `bb-stack`   (a different container)
+ *   [effect=nen]      → a bare span  (no effect at all)
+ *   [img=round,shadow]→ ignored      (`parseImgAttr` is exclusive, not flags)
+ *
+ * The author sees a preview that works and never learns the value was wrong.
+ * Offering the vocabulary at the point of typing is the cheapest fix, and it
+ * needs the vocabulary to exist as data rather than as control flow.
+ *
+ * ── Why here and not in the editor ──
+ *
+ * This is the engine's knowledge: the renderer decides what `glow` means, so
+ * the renderer's package owns the list of what is spellable. A copy in the
+ * editor would be a fourth transcription of an engine fact, which is the
+ * exact mistake `TagSyntax` and `EffectMath` were both written to undo.
+ *
+ * `TagVocabulary.test.ts` pins every value below to the renderer: a value
+ * that stops being handled starts rendering as the fallback, and the test
+ * fails. The list cannot silently drift away from the behaviour.
+ *
+ * Human-readable descriptions are deliberately NOT here. Quasar has no
+ * locales; the editor names these values through its own i18n.
+ */
+/** How an attribute's value is written. */
+export type VocabularySyntax = 
+/** Exactly one of `values`. */
+'enum'
+/** Any subset of `values`, comma- or space-separated. */
+ | 'flags';
+export interface AttributeVocabulary {
+    /** The tag whose attribute this describes. */
+    tag: string;
+    /** Every value the engine actually handles, in the renderer's own order. */
+    values: readonly string[];
+    syntax: VocabularySyntax;
+    /**
+     * The value an unrecognised attribute behaves as, or `null` when an
+     * unrecognised attribute simply does nothing.
+     *
+     * This is the honest part: it is what the `default:` branch does, not what
+     * the documentation wishes it did.
+     */
+    fallback: string | null;
+    /**
+     * Whether a `:<param>` suffix is read after the value.
+     *
+     * What the suffix MEANS is per value, not per tag, which is why this is
+     * only a boolean: `[effect=glow:#2EE6E2]` and `[tables=striped:#hex]` take
+     * a colour, but `[container=grid:3]` takes a column count and
+     * `[container=flex:12]` a gap in pixels. Completion needs no more than
+     * "there is a suffix here, and it is not part of the vocabulary".
+     */
+    suffixed: boolean;
+}
+/** `[effect=…]` — `HTMLRenderer.renderEffect`. */
+export declare const EFFECT_TYPES: readonly ['glow', 'neon', 'outline', 'emboss', 'engrave', 'shimmer', 'ghost', 'rainbow', 'fire', 'ice'];
+/** `[anim=…]` — `HTMLRenderer.renderAnim`. */
+export declare const ANIM_TYPES: readonly ['bounce', 'shake', 'pulse', 'fade-in', 'fade-out', 'typewriter', 'wave', 'sparkle', 'glitch', 'levitate'];
+/**
+ * `[container=…]` — `HTMLRenderer.renderContainer`.
+ *
+ * `neonbox` is the unhyphenated spelling of `neon-box` and renders
+ * identically; it stays in the list because a document may carry it, but the
+ * hyphenated form is the canonical one and comes first.
+ */
+export declare const CONTAINER_TYPES: readonly ['stack', 'flex', 'grid', 'middle', 'square', 'circle', 'card', 'glass', 'neon-box', 'neonbox'];
+/** `[separator=…]` — `HTMLRenderer.renderSeparator`. */
+export declare const SEPARATOR_VARIANTS: readonly ['line', 'dots', 'stars'];
+/** `[tables=…]` — `HTMLRenderer.renderTables`. Combinable. */
+export declare const TABLE_FLAGS: readonly ['striped', 'borders'];
+/**
+ * `[img=…]` — `parseImgAttr` in `Syntax/nodeAttr`.
+ *
+ * Exclusive despite reading like flags: the parser returns on the first
+ * match, so `[img=round,shadow]` yields neither. A dimension pair
+ * (`[img=200x100]`) is the other accepted form and is not enumerable.
+ */
+export declare const IMG_MODIFIERS: readonly ['round', 'shadow', 'float'];
+/**
+ * The vocabulary for a tag's attribute, or `null` when its attribute is free
+ * text (`[box=Título]`, `[url=…]`, `[size=200]`).
+ *
+ * Case-insensitive, because the renderer lowercases before matching.
+ *
+ * Note this answers only "what can be spelled here"; whether the tag exists
+ * at all is a dialect question, and the caller already knows the dialect.
+ */
+export declare function attributeVocabularyFor(tag: string): AttributeVocabulary | null;
+/** Every vocabulary, for tests and for tooling that enumerates them. */
+export declare function allAttributeVocabularies(): readonly AttributeVocabulary[];

package/dist/types/Utils/TagVocabulary.test.d.ts

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

package/dist/types/Utils/color.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Quasar — Color Utilities
+ *
+ * Standalone color functions for gradient/grow/exporter interpolation.
+ * No external dependencies — pure math.
+ *
+ * Ported from TextStudio/lib/color.ts (originally backed by culori).
+ * These are the minimal subset needed for internal tag export.
+ */
+export type Easing = 'linear' | 'easeIn' | 'easeOut' | 'easeInOut';
+/**
+ * Mix two hex colors via linear RGB interpolation.
+ * t in [0, 1] — 0 = from, 1 = to.
+ */
+export declare function mixHex(from: string, to: string, t: number): string;
+/**
+ * Mix across multiple hex colors.
+ * t in [0, 1] maps across the color array linearly.
+ */
+export declare function mixMultiple(colors: string[], t: number): string;
+/**
+ * Convert HSL to hex string.
+ * @param h hue in [0, 360]
+ * @param s saturation in [0, 1]
+ * @param l lightness in [0, 1]
+ */
+export declare function hslToHex(h: number, s: number, l: number): string;
+export declare function clamp(n: number, min?: number, max?: number): number;
+export declare function ease(t: number, kind: Easing): number;

package/dist/types/Utils/dom-to-svg.d.ts

@@ -0,0 +1,28 @@
+export interface DomToSVGOptions {
+    backgroundColor?: string;
+    includeBackground?: boolean;
+    /** Scale factor applied to all coordinates (default 1) */
+    scale?: number;
+    /** Maximum unscaled height in pixels to scan and render into the SVG (useful for thumbnails). Elements and lines below this cutoff are omitted. */
+    maxHeight?: number;
+}
+export interface SVGLayerInfo {
+    id: string;
+    tag: string;
+    depth: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    type: 'image' | 'iframe' | 'audio' | 'background' | 'border' | 'group' | 'text';
+    text?: string;
+}
+export interface DomToSVGResult {
+    svg: string;
+    width: number;
+    height: number;
+    layerCount: number;
+    layers: SVGLayerInfo[];
+}
+export declare function domToSVG(root: HTMLElement, options?: DomToSVGOptions): string;
+export declare function domToSVGResult(root: HTMLElement, options?: DomToSVGOptions): DomToSVGResult;

package/dist/types/Utils/dom-to-svg.test.d.ts

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

package/dist/types/Utils/treeTransformers.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Quasar — Tree Transformers
+ *
+ * Apply effects (gradient, grow, rainbow, central, multi) across an entire RedNode tree.
+ * These functions walk the tree, track global text position,
+ * and wrap each text leaf in internal effect nodes
+ * with position metadata so the TagRegistry handlers produce
+ * correctly interpolated output.
+ *
+ * DESIGN:
+ *   Two-pass approach:
+ *     1. Collect total text length (for normalization)
+ *     2. Walk again, wrapping text nodes with effect nodes
+ *
+ *   Non-text nodes (img, video, audio, code blocks) are preserved unchanged.
+ *   Structural nodes (box, quote, list) recurse into children.
+ *   Formatting nodes (b, i, u, color) recurse — effects go INSIDE formatting.
+ *
+ *   Example:
+ *     Input:  [box][b]Hello[/b] World[/box]
+ *     Output: [box][b][gradient][b]H[/b][gradient][b]e[/b]...[/b]
+ *                    [gradient] W[/gradient]...[/gradient]
+ *
+ *   Actually simpler — each text leaf gets its own gradient node with
+ *   globalOffset metadata, and the handler does the interpolation.
+ */
+import { RedNode } from '../Syntax/RedNode';
+import type { Easing } from './color';
+export interface GradientEffect {
+    kind: 'gradient';
+    colors: string[];
+    unit?: 'character' | 'word' | 'line';
+    easing?: Easing;
+}
+export interface GrowEffect {
+    kind: 'grow';
+    min?: number;
+    max?: number;
+    cycles?: number;
+}
+export interface RainbowEffect {
+    kind: 'rainbow';
+    saturation?: number;
+    lightness?: number;
+    spread?: number;
+    offset?: number;
+}
+export interface CentralGradientEffect {
+    kind: 'central_gradient';
+    colors: string[];
+    unit?: 'character' | 'word' | 'line';
+    easing?: Easing;
+}
+export interface MultiGradientEffect {
+    kind: 'multi_gradient';
+    colors: string[];
+    mode?: 'wave' | 'pulse';
+    unit?: 'character' | 'word' | 'line';
+    easing?: Easing;
+}
+export type TreeEffect = GradientEffect | GrowEffect | RainbowEffect | CentralGradientEffect | MultiGradientEffect;
+/**
+ * Count total plain text length across all text leaves in a tree.
+ */
+export declare function countTextLength(node: RedNode): number;
+/**
+ * Apply a gradient effect across an entire RedNode tree.
+ *
+ * The gradient is computed across ALL text content in the tree,
+ * so color transitions span across structural boundaries:
+ *
+ *   [b]Hello[/b] World  →  [b][color=#FF0000]H[/color]...[/b][color=#00FF00]W[/color]...
+ *
+ * @param root    The RedNode tree to transform
+ * @param colors  Array of hex colors to interpolate across
+ * @param options.unit      Split unit: 'character' (default), 'word', or 'line'
+ * @param options.easing    Easing function: 'linear' (default), 'easeIn', 'easeOut', 'easeInOut'
+ * @returns A new RedNode tree with gradient applied
+ */
+export declare function applyGradient(root: RedNode, colors: string[], options?: {
+    unit?: 'character' | 'word' | 'line';
+    easing?: Easing;
+}): RedNode;
+/**
+ * Apply a grow (size wave) effect across an entire RedNode tree.
+ *
+ * Size oscillates via sine wave across ALL text content:
+ *
+ *   [b]Hello[/b] World  →  [b][size=90]H[/size]...[/b][size=160]W[/size]...
+ *
+ * @param root    The RedNode tree to transform
+ * @param options.min       Minimum size % (default: 90)
+ * @param options.max       Maximum size % (default: 160)
+ * @param options.cycles    Number of sine cycles across text (default: 1)
+ * @returns A new RedNode tree with grow applied
+ */
+export declare function applyGrow(root: RedNode, options?: {
+    min?: number;
+    max?: number;
+    cycles?: number;
+}): RedNode;
+/**
+ * Apply a rainbow effect across an entire RedNode tree.
+ *
+ * Hue rotates across ALL text content using HSL color space:
+ *
+ *   [b]Hello[/b] World  →  [b][color=#FF0000]H[/color]...[/b][color=#00FF00]W[/color]...
+ *
+ * @param root    The RedNode tree to transform
+ * @param options.saturation  Saturation 0-100 (default: 80)
+ * @param options.lightness   Lightness 0-100 (default: 60)
+ * @param options.spread      Hue spread in degrees (default: 300)
+ * @param options.offset      Starting hue offset in degrees (default: 0)
+ * @returns A new RedNode tree with rainbow applied
+ */
+export declare function applyRainbow(root: RedNode, options?: {
+    saturation?: number;
+    lightness?: number;
+    spread?: number;
+    offset?: number;
+}): RedNode;
+/**
+ * Apply a central gradient across an entire RedNode tree.
+ *
+ * Gradient radiates from center outward (mirrored):
+ *
+ *   [b]Hello[/b] World  →  [b][color=#FF0000]H[/color]...[/b][color=#00FF00]W[/color]...
+ *
+ * @param root    The RedNode tree to transform
+ * @param colors  Array of hex colors to interpolate across
+ * @param options.unit      Split unit: 'character' (default), 'word', or 'line'
+ * @param options.easing    Easing function: 'linear' (default), 'easeIn', 'easeOut', 'easeInOut'
+ * @returns A new RedNode tree with central gradient applied
+ */
+export declare function applyCentralGradient(root: RedNode, colors: string[], options?: {
+    unit?: 'character' | 'word' | 'line';
+    easing?: Easing;
+}): RedNode;
+/**
+ * Apply a multi gradient (wave or pulse) across an entire RedNode tree.
+ *
+ * Wave mode: sine wave pattern across colors.
+ * Pulse mode: repeating gradient segments.
+ *
+ * @param root    The RedNode tree to transform
+ * @param colors  Array of hex colors to interpolate across
+ * @param options.mode      'wave' (default) or 'pulse'
+ * @param options.unit      Split unit: 'character' (default), 'word', or 'line'
+ * @param options.easing    Easing function: 'linear' (default), 'easeIn', 'easeOut', 'easeInOut'
+ * @returns A new RedNode tree with multi gradient applied
+ */
+export declare function applyMultiGradient(root: RedNode, colors: string[], options?: {
+    mode?: 'wave' | 'pulse';
+    unit?: 'character' | 'word' | 'line';
+    easing?: Easing;
+}): RedNode;
+/**
+ * Apply any supported effect across an entire RedNode tree.
+ */
+export declare function applyEffect(root: RedNode, effect: TreeEffect): RedNode;

package/dist/types/Visitors/BBBlocksExporter.d.ts

@@ -0,0 +1,27 @@
+import { Visitor } from './Visitor';
+import type { VisitorContext } from './Visitor';
+import { RedNode } from '../Syntax/RedNode';
+export interface UIBBBlock {
+    id: string;
+    type: string;
+    attributes?: Record<string, string>;
+    children: UIBBBlock[];
+    content?: string;
+}
+export declare class BBBlocksExporter extends Visitor<UIBBBlock[]> {
+    private idCounter;
+    /**
+     * Un identificador único dentro de ESTA exportación.
+     *
+     * Llevaba un `Date.now().toString(36)` por nodo. El reloj no aportaba nada
+     * —los identificadores solo tienen que distinguirse entre sí dentro del
+     * lote— y se leía, y se convertía a base 36, una vez por nodo del árbol.
+     * El prefijo se calcula una sola vez por exportador para que dos lotes
+     * consecutivos sigan sin colisionar.
+     */
+    private readonly idPrefix;
+    private generateId;
+    visit(node: RedNode, context?: VisitorContext): UIBBBlock[];
+    export(root: RedNode): UIBBBlock[];
+    private exportNode;
+}

package/dist/types/Visitors/BBCodeExporter.d.ts

@@ -0,0 +1,90 @@
+/**
+ * DocumentEngine — BBCodeExporter
+ *
+ * Exports the Document Model / Red Tree back to BBCode text.
+ * This is how the internal representation becomes editable text.
+ *
+ * Uses the TagRegistry to determine how each node serializes.
+ * Plugins can register custom serializers for custom tags.
+ */
+import { RedNode } from '../Syntax/RedNode';
+import { Visitor } from './Visitor';
+import type { VisitorContext } from './Visitor';
+import { TagRegistry } from '../Model/TagRegistry';
+import { type TokenResolverFn, type TokenSource } from '../Tokens';
+/**
+ * Export target for BBCodeExporter.
+ * - 'osu': Expands Miliastry/Lyne-native tags into osu!-compatible BBCode.
+ * - 'miliastry': Preserves Miliastry-native tags as-is for round-trip editing.
+ * - 'lyne': Preserves Lyne-native tags as-is for round-trip editing.
+ */
+export type ExportTarget = 'osu' | 'miliastry' | 'lyne';
+export interface BBCodeExporterOptions {
+    registry?: TagRegistry;
+    target?: ExportTarget;
+    tokens?: TokenSource;
+    resolveTokens?: boolean;
+}
+export type BBCodeExportOptions = {
+    target?: ExportTarget;
+    tokens?: TokenSource;
+    resolveTokens?: boolean;
+};
+/**
+ * Tags que existen SOLO en Miliastry (registrados en el TagRegistry) y que
+ * osu! NO renderiza. Si un usuario pega `[shadow]`/`[zalgo]`/etc. en osu!,
+ * el texto sale roto (los corchetes se ven literalmente). Cuando el target
+ * es 'osu', estos tags se DEGRADAN a su contenido plano: mejor perder el
+ * efecto que romper la userpage. El target 'miliastry' los conserva.
+ */
+export declare const MILIASTRY_ONLY_TAGS: Set<string>;
+export declare const LYNE_ONLY_TAGS: Set<string>;
+export declare class BBCodeExporter extends Visitor<string> {
+    private registry;
+    private depth;
+    private target;
+    private tokens?;
+    private tokenResolver?;
+    private explicitResolveTokens?;
+    /**
+     * El resolvedor a aplicar en ESTE recorrido, o `null` si no hay expansión.
+     *
+     * Se decide una vez en `visit`, no por nodo: `shouldResolveTokens()` da la
+     * misma respuesta para todo el documento, y se estaba llamando en la rama
+     * de nodo texto, la más frecuente que hay.
+     */
+    private expandTokens;
+    constructor(registryOrOptions?: TagRegistry | BBCodeExporterOptions, target?: ExportTarget, options?: BBCodeExporterOptions | {
+        tokens?: TokenSource;
+        resolveTokens?: boolean;
+    });
+    /**
+     * Set the export target. Controls how Miliastry-native tags are serialized.
+     */
+    setTarget(target: ExportTarget): void;
+    setTokens(tokens?: TokenSource): void;
+    getTokens(): TokenSource | undefined;
+    getTokenResolver(): TokenResolverFn | undefined;
+    private shouldResolveTokens;
+    /**
+     * Export a RedNode tree to BBCode.
+     */
+    visit(node: RedNode, context?: VisitorContext): string;
+    /**
+     * Export the entire document to BBCode.
+     * Optionally override the export target or options for this specific call.
+     */
+    export(root: RedNode, targetOrOptions?: ExportTarget | BBCodeExportOptions, options?: BBCodeExportOptions): string;
+    /**
+     * Exporta los hijos directos y los concatena.
+     *
+     * Reemplaza el `children.map(...).join('')`, que asignaba un cierre y un
+     * array intermedio de N cadenas en cada nivel del árbol. `HTMLRenderer`
+     * hizo este mismo cambio y dejó la nota; el exportador se quedó atrás, y es
+     * el camino que corre bajo un límite de 60.000 caracteres.
+     */
+    private exportChildren;
+    private exportNode;
+    private kindToTagName;
+    private getTagAttributes;
+}

package/dist/types/Visitors/BlockPatcher.d.ts

@@ -0,0 +1,91 @@
+/**
+ * DocumentEngine — BlockPatcher
+ *
+ * Incremental rendering for the HTML preview.
+ *
+ * The naive path — `renderToHTML(root)` + `morphHTML(container, html)` on every
+ * keystroke — re-serializes the ENTIRE document to a string and, worse, makes
+ * the browser re-parse that whole string (`template.innerHTML`) even when only
+ * one character changed. Profiled on an 18.5 KB document: `morphHTML` ≈ 29.8 ms
+ * per keystroke, of which ~27 ms is the full-HTML parse (morph ≈ baseline
+ * `innerHTML=`). The parser itself is ~0.5 ms.
+ *
+ * This module makes the DOM update O(changed block) instead of O(document):
+ *
+ *   - The document's top-level children are the independent "blocks".
+ *   - With stable `data-node-id`s (see `preserveNodeIds`) a block that did not
+ *     change renders to the SAME html string, or is even the SAME RedNode
+ *     object (red-subtree reuse). Either way we can detect "unchanged" without
+ *     touching the DOM.
+ *   - Only changed blocks are re-rendered and re-morphed, in place, keyed by
+ *     their element.
+ *   - Structural edits — a block inserted, removed or reordered (Enter,
+ *     backspace between blocks, moving a block in the visual builder) — are
+ *     reconciled BY KEY too. The stable ids let us insert/remove/move ONLY the
+ *     affected elements, so every untouched block keeps its DOM identity and
+ *     runtime state (an open `<details>`, media playback). When the edit
+ *     script adds more blocks than the previous document had (a whole new
+ *     document patched into the same container, ids regenerated en masse) we
+ *     fall back to a full rebuild: one `innerHTML` parse beats N per-block
+ *     ones.
+ *
+ * DOM alignment — "runs": a top-level block may render to an element, to a
+ * bare text node (`text`, osu `spacing`/`empty_line` quirks) or to nothing
+ * (`''`, an empty text leaf). Two adjacent bare-text blocks are merged into a
+ * single text node by the HTML parser, so a block↔node 1:1 pairing would
+ * silently misalign after such a merge. The reconciliation therefore works on
+ * RUNS: consecutive bare-text blocks form one "text run" that maps to exactly
+ * one text node (mirroring the parser), and element blocks are their own runs.
+ * The run list is the exact 1:1 mirror of `container.childNodes`.
+ */
+import { RedNode } from '../Syntax/RedNode';
+import { HTMLRenderer } from './HTMLRenderer';
+import type { TextChangeRange } from '../Incremental/ChangeTracker';
+export interface PatchBlocksOptions {
+    /** Renderer used to serialize blocks. Defaults to a shared HTMLRenderer. */
+    renderer?: HTMLRenderer;
+    /** Called when a block fails to morph; the caller can log it. */
+    onError?: (err: unknown) => void;
+    /**
+     * The source range of the edit that produced `rootNode`, if known.
+     *
+     * Lets the patcher reconcile ONLY the runs overlapping the edit (O(edit))
+     * instead of walking the whole document — the difference between ~2ms and
+     * ~100ms per keystroke on a 500k-character document. Coordinates are in
+     * new-source space with the old end kept separately; see `TextChangeRange`.
+     * When omitted, the patcher falls back to the full keyed reconcile — and it
+     * also reads the range attached to the root by `DocumentModel`.
+     */
+    change?: TextChangeRange;
+    /**
+     * Minimum top-level blocks for the windowed path to run; below it the full
+     * keyed walk is cheaper than the windowed bookkeeping. Defaults to
+     * `MIN_WINDOWED_BLOCKS` (200). Tests force `0` to exercise the windowed
+     * path on small documents.
+     */
+    minWindowedBlocks?: number;
+    /** If true, forces a full rebuild of the container instead of incremental patching. */
+    forceRebuild?: boolean;
+}
+export interface PatchBlocksStats {
+    /** Which path was taken. */
+    mode: 'full' | 'blocks';
+    /** Number of top-level blocks. */
+    total: number;
+    /** Blocks whose DOM was actually updated (0 = nothing changed). */
+    patched: number;
+    /** True when the windowed (O(edit)) reconcile ran, not the full keyed walk. */
+    windowed?: boolean;
+}
+/**
+ * Evict `container` from the patch cache so the next patch rebuilds afresh.
+ */
+export declare function clearPatchCache(container: HTMLElement): void;
+/**
+ * Reconcile `container`'s children against `rootNode`'s top-level blocks.
+ *
+ * Inline edits morph only the changed block; structural edits (insert, remove,
+ * reorder) are reconciled by key so untouched blocks keep their DOM identity.
+ * Returns what was done so callers/tests can assert the fast path fired.
+ */
+export declare function patchBlocksInto(container: HTMLElement, rootNode: RedNode | null, options?: PatchBlocksOptions): PatchBlocksStats;

package/dist/types/Visitors/DOMMorpher.d.ts

@@ -0,0 +1,13 @@
+/**
+ * DocumentEngine — DOMMorpher
+ *
+ * Reconciles and morphs an existing HTML DOM tree in-place to match a new HTML string.
+ * Operating on pure HTML string output from HTMLRenderer means ZERO changes to Quasar AST schemas.
+ *
+ * Features:
+ * - In-place attribute synchronization
+ * - In-place text node value updates
+ * - Preserves state of unchanged elements (spoilers, audio/video, selections)
+ * - Zero extra wrapper <div> elements
+ */
+export declare function morphHTML(container: HTMLElement, newHTML: string): void;