@betteroffice/docx 0.0.1

package/dist/wasm-edit.d.mts

@@ -0,0 +1,473 @@
+import { W as WasmAsyncInput } from './loadWasmAsset-CMvnVkfA.mjs';
+
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * One yrs replica of the DOCX editing model, held for a JS host.
+ *
+ * Owns the [`EditingDoc`] plus the (single) JS update observer. The JS facade
+ * multiplexes its own listener set over that one callback.
+ */
+declare class EditSession {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Accepts tracked changes (S4b): pending insertions become plain content,
+     * pending deletions are carried out; `pPrIns` marks clear (the split
+     * stays), `pPrDel` marks join with the following paragraph (its pPr
+     * survives). `target_json`: `{"revisionId": string}` for one coalesced
+     * revision (any story) or
+     * `{"story","startPara","startOffset","endPara","endOffset"}` for a Loc
+     * range. Receipt: `{"revisionIds": [string, …]}` — the revision ids
+     * resolved. Resolving never stamps a new revision.
+     */
+    accept_change(target_json: string): string;
+    /**
+     * Adds a sticky-anchored comment. `ranges_json`:
+     * `[{"story","startPara","startOffset","endPara","endOffset"}, …]`;
+     * `body_json` is any JSON value. Receipt: `{"commentId"}`.
+     */
+    add_comment(ranges_json: string, author: string, date: string, body_json: string): string;
+    /**
+     * Apply one ordinary collapsed character deletion (or adjacent paragraph
+     * merge at a boundary) and return the resulting resident FrameDelta.
+     */
+    apply_delete(direction: string, expected_frame_epoch: number): Uint8Array;
+    /**
+     * Instrumented twin of `apply_delete`, used only by opt-in browser perf
+     * traces. Keeping this separate leaves the production hot path timer-free.
+     */
+    apply_delete_profiled(direction: string, expected_frame_epoch: number): Uint8Array;
+    /**
+     * Apply one ordinary collapsed body-text insertion and return the
+     * resulting FrameDelta. Selection, measurement inputs, pagination
+     * checkpoints, and display state all remain resident in this session.
+     */
+    apply_input(text: string, expected_frame_epoch: number): Uint8Array;
+    /**
+     * Last opt-in `apply_input_profiled` stage timings as a compact JSON object.
+     */
+    apply_input_profile_json(): string;
+    /**
+     * Instrumented twin of `apply_input`, used only by opt-in browser perf
+     * traces. Keeping this separate leaves the production hot path timer-free.
+     */
+    apply_input_profiled(text: string, expected_frame_epoch: number): Uint8Array;
+    /**
+     * Applies an update produced by this document's dedicated local worker.
+     * The local origin lets the main replica's UndoManager retain ownership of
+     * the edit; remote/collaboration updates must use `apply_update` instead.
+     */
+    apply_local_update(update: Uint8Array): void;
+    /**
+     * Applies a paragraph style id to every paragraph intersecting
+     * `[start, end)`. With no host style resolver at this boundary, this is
+     * the PM fallback path: write `pStyle` without fabricating a resolved
+     * paragraph/run formatting projection.
+     */
+    apply_paragraph_style(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, style_id: string, author_name?: string | null, author_date?: string | null): void;
+    /**
+     * Applies a batch of raw story mutations in ONE transaction — the
+     * coexistence bridge's mirror-into-yrs path (not a user-intent op). `ops_json`
+     * is `[{ "op":"insert"|"delete"|"format"|"insertEmbed"|"setEmbedAttr"
+     * |"setComment"|"removeComment", "index", … }, …]`; each op's index (and each
+     * `setComment` `[start, end)` range) is read against the story state after all
+     * prior ops in the batch. Attributes/payloads are faithful mirrors of the
+     * bridge's lowered PM state (tracked-change stamps arrive inside `attrs`;
+     * comments are keyed by the PM comment id and anchored sticky, side-map only).
+     */
+    apply_raw_ops(story: string, ops_json: string): void;
+    /**
+     * Applies a remote/incremental yrs v1 update.
+     */
+    apply_update(update: Uint8Array): void;
+    /**
+     * Binary FrameDelta v1 display output. The returned `Vec<u8>` is exposed
+     * by wasm-bindgen as a transferable-friendly `Uint8Array`.
+     */
+    build_display_list_frame(input: string, expected_frame_epoch: number): Uint8Array;
+    /**
+     * Build display primitives against the same resident font store used by
+     * this session's measurement path.
+     */
+    build_display_list_json(input: string): string;
+    can_redo(): boolean;
+    can_undo(): boolean;
+    /**
+     * Resolves the current local cell selection, or `null` before the host
+     * establishes one. Deleted endpoints clamp to a surviving nearby cell.
+     */
+    cell_selection(): string;
+    /**
+     * Clears the authored `value` from a stable-id content-control embed.
+     */
+    clear_content_control_value(embed_id: string): void;
+    /**
+     * Clears every direct formatting attribute over `[start, end)`, while
+     * retaining hyperlinks and tracked-change stamps.
+     */
+    clear_formatting(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number): void;
+    /**
+     * Clear this editing wasm's resident measurement fonts.
+     */
+    clear_measure_fonts(): void;
+    /**
+     * Drops the update observer registered by [`EditSession::set_update_observer`].
+     */
+    clear_update_observer(): void;
+    client_id(): number;
+    /**
+     * Adds a story with one paragraph. Receipt: `{"paraId"}` (the final
+     * pilcrow's paragraph).
+     */
+    create_story(story_id: string, initial_text: string, p_style: string, alignment: string): string;
+    /**
+     * Deletes every column covered by an explicit cell range.
+     */
+    delete_column(range_json: string): string;
+    /**
+     * Deletes `[start, end)` given as two Locs in one story. A range whose
+     * ends sit in different paragraphs spans the boundary pilcrows, so the
+     * plain delete also merges (the pilcrow-as-character dividend).
+     * Suggesting mode retains the content with a `del` revision instead.
+     * Receipt: `{"revisionId": string|null}`.
+     */
+    delete_range(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Deletes every row covered by an explicit cell range.
+     */
+    delete_row(range_json: string, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Removes one complete story (used for unreachable table-cell stories).
+     */
+    delete_story(story_id: string): void;
+    /**
+     * Removes one complete table plus all of its reachable cell stories.
+     */
+    delete_table(table_json: string): string;
+    /**
+     * Hit-test without re-serializing the resident display list through JS.
+     */
+    display_hit_test_regions_json(page_index: number, x: number, y: number): string;
+    /**
+     * Body range geometry without a display-list JSON round trip.
+     */
+    display_range_rects_json(from: number, to: number): string;
+    /**
+     * Region-scoped range geometry without a display-list JSON round trip.
+     */
+    display_range_rects_region_json(region: string, r_id: string, from: number, to: number): string;
+    /**
+     * Full document state as one yrs v1 update (Yjs wire format).
+     */
+    encode_state(): Uint8Array;
+    /**
+     * Applies a set-valued, tri-state inline formatting delta over
+     * `[start, end)` in one transaction. Omitted fields are kept and `null`
+     * fields are cleared.
+     */
+    format_range(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, delta_json: string): void;
+    /**
+     * Inserts a column left (`after = false`) or right (`after = true`) of a cell.
+     */
+    insert_column(at_json: string, after: boolean): string;
+    /**
+     * Inserts one native inline image embed at a paragraph-keyed location.
+     */
+    insert_image(story: string, para_id: string, offset: number, payload_json: string, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Inserts a native page-break embed at a Loc.
+     */
+    insert_page_break(story: string, para_id: string, offset: number): void;
+    /**
+     * Inserts a row above (`after = false`) or below (`after = true`) a cell.
+     */
+    insert_row(at_json: string, after: boolean, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Inserts a native section-break embed at a Loc.
+     */
+    insert_section_break(story: string, para_id: string, offset: number, break_type: string): void;
+    /**
+     * Inserts a rectangular structural table at a paragraph-keyed location.
+     */
+    insert_table(story: string, para_id: string, offset: number, rows: number, columns: number, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Inserts paragraph-break-free text at `(story, para_id, offset)`.
+     * Receipt: `{"revisionId": string|null}` (non-null in suggesting mode).
+     */
+    insert_text(story: string, para_id: string, offset: number, text: string, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Inserts a typed watermark embed at a Loc.
+     */
+    insert_watermark(story: string, para_id: string, offset: number, watermark_json: string): void;
+    /**
+     * Paginate and retain the measured input and Layout. The full JSON return
+     * remains the migration parity bridge until binary frames consume it.
+     */
+    layout_document_json(input: string): string;
+    /**
+     * Every tracked-change run/paragraph-mark revision across all stories,
+     * in deterministic story/position order.
+     */
+    list_revisions(): string;
+    /**
+     * Hydrates this replica from an encoded yrs update (the bytes form of
+     * `load` — typically another replica's `encode_state()` output).
+     */
+    load(update: Uint8Array): void;
+    /**
+     * Seeds stories from JSON (the json form of `load`):
+     * `[{"storyId","paragraphs":[{"text","pStyle"?,"alignment"?}, …]}, …]`.
+     * Paragraph text must not contain paragraph breaks. Returns
+     * `{storyId: [paraId, …]}` in document order. This is an S1 seeding
+     * scaffold composed from public ops; the real `load(ParsedDocument)`
+     * belongs to the ops track.
+     */
+    load_json(stories_json: string): string;
+    /**
+     * `{"start","end"}` — the paragraph's story span; `end` is its pilcrow's
+     * index, so `end - start` is the paragraph length (`offset` domain).
+     */
+    locate_paragraph(story: string, para_id: string): string;
+    /**
+     * Paragraph-measure compatibility export on the resident engine module.
+     */
+    measure_paragraph_json(input: string): string;
+    /**
+     * Merges a rectangular cell range into its top-left cell.
+     */
+    merge_cells(range_json: string): string;
+    /**
+     * Merges `para_id` with the FOLLOWING paragraph by deleting (plain) or
+     * `del`-marking (suggesting) its pilcrow. Errors on the story's final
+     * paragraph. Receipt: `{"revisionId": string|null}`.
+     */
+    merge_paragraphs(story: string, para_id: string, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Creates a replica. `client_id` must be a non-negative safe integer —
+     * the host allocates it (yjs-style random 32-bit ids are fine).
+     */
+    constructor(client_id: number);
+    /**
+     * Resolve one glyph outline from the session's resident font store.
+     */
+    outline_glyph_json(font_id: number, glyph_id: number): string;
+    /**
+     * Compact paragraph-position projection in one story traversal:
+     * `[{"paraId","length"}]`. Length counts UTF-16 text and inline embed
+     * units before each paragraph's pilcrow. The JS input shim uses this
+     * instead of crossing the wasm boundary once per paragraph.
+     */
+    paragraph_spans(story: string): string;
+    /**
+     * `[{"paraId","text","properties"}]` in document order. `properties`
+     * carries pStyle/alignment plus any op-set extras.
+     */
+    paragraphs(story: string): string;
+    /**
+     * Reapplies the latest locally undone transaction.
+     */
+    redo(): boolean;
+    /**
+     * Current local redo stack size. Zero before a story starts tracking.
+     */
+    redo_depth(): number;
+    /**
+     * Register font bytes in this editing wasm's resident measurement store.
+     * Returned ids are valid for measurement and display work in this module.
+     */
+    register_measure_font(bytes: Uint8Array): number;
+    /**
+     * Rejects tracked changes — the inverse of [`EditSession::accept_change`]:
+     * pending insertions roll back, pending deletions restore their text;
+     * `pPrIns` marks join back with the following paragraph, `pPrDel` marks
+     * clear (the split stays). Same target and receipt shapes.
+     */
+    reject_change(target_json: string): string;
+    /**
+     * Replaces `[start, end)` with text in one transaction. The inserted text
+     * adopts the first replaced unit's formatting; in suggesting mode the
+     * deletion and insertion share one revision id.
+     */
+    replace_range(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, text: string, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * Current offsets of a comment's sticky anchors:
+     * `[{"story","start","end"}]`. Errors when an anchor no longer resolves.
+     */
+    resolve_comment(comment_id: string): string;
+    /**
+     * Resolves this peer's current sticky selection as two public Locs, or
+     * `null` before the host establishes an initial selection.
+     */
+    selection(): string;
+    /**
+     * Aggregated toolbar/a11y state over one paragraph-addressed story
+     * range. Toggle marks are `true`, `false`, or `"mixed"`; value marks
+     * are their uniform value or `null` when absent/mixed.
+     */
+    selection_context(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number): string;
+    /**
+     * Replaces the selected cells' complete border property object.
+     */
+    set_cell_borders(range_json: string, borders_json: string): string;
+    /**
+     * Stores a rectangular anchor-cell → head-cell selection outside the yrs
+     * document. `range_json` is a [`TableRange`]. The table embed is held by a
+     * sticky index and the endpoints by stable cell-story identity.
+     */
+    set_cell_selection(range_json: string): void;
+    /**
+     * Sets/clears selected cells' background color (hex without or with `#`).
+     */
+    set_cell_shading(range_json: string, color?: string | null): string;
+    /**
+     * Merges a JSON cell-format patch into every selected cell's `tcPr`.
+     */
+    set_cell_text_format(range_json: string, patch_json: string): string;
+    /**
+     * Sets one grid-column width in twips.
+     */
+    set_column_width(at_json: string, width_twips: number): string;
+    /**
+     * Sets the authored `value` on a stable-id content-control embed.
+     */
+    set_content_control_value(embed_id: string, value_json: string): void;
+    /**
+     * Sets the authored `value` on a content-control embed at a paragraph-keyed
+     * position. This is the fallback for valid controls that have no authored
+     * `w:id`/tag and therefore cannot be addressed by stable payload identity.
+     */
+    set_content_control_value_at(story: string, para_id: string, offset: number, value_json: string): void;
+    /**
+     * Sets or clears the protected hyperlink attribute over `[start, end)`.
+     * `hyperlink_json` is an object (`{href, tooltip?, rId?}`) or `null`.
+     */
+    set_hyperlink(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, hyperlink_json: string): void;
+    /**
+     * Commits image geometry fields to a stable-id image embed in one
+     * transaction. `null` fields clear; `other` is flattened into the payload.
+     */
+    set_image_geometry(embed_id: string, geometry_json: string): void;
+    /**
+     * Sets one paragraph property (any JSON value) on `para_id`'s pilcrow.
+     * `paraId` / the embed discriminator are reserved.
+     */
+    set_paragraph_attr(para_id: string, key: string, value_json: string): void;
+    /**
+     * Applies a tri-state paragraph-property delta to every paragraph
+     * intersecting `[start, end)` in one transaction.
+     */
+    set_paragraph_attrs(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, attrs_json: string, author_name?: string | null, author_date?: string | null): void;
+    /**
+     * Stores this peer's anchor/head as sticky positions. `Assoc::After`
+     * makes a collapsed caret advance with text inserted at the caret.
+     */
+    set_selection(story: string, anchor_para: string, anchor_offset: number, head_para: string, head_offset: number): void;
+    /**
+     * Sets the table-wide preferred width in twips.
+     */
+    set_table_width(table_json: string, width_twips: number): string;
+    /**
+     * Subscribes `callback(update: Uint8Array)` to every committed
+     * transaction (v1 encoding — feed it straight to `apply_update` on a
+     * peer). One observer per session; a second call replaces the first.
+     * The facade fans out to multiple JS listeners over this single hook.
+     */
+    set_update_observer(callback: Function): void;
+    /**
+     * Splits the cell covering `at` into the requested grid. Omitted
+     * dimensions unmerge the cell into its existing covered slots.
+     */
+    split_cell(at_json: string, rows?: number | null, columns?: number | null): string;
+    /**
+     * Splits a paragraph at `(story, para_id, offset)` by inserting one
+     * pilcrow. Under the S1 split the FIRST half keeps the original paraId and
+     * the SECOND half is re-minted. Receipt:
+     * `{"firstParaId","secondParaId","revisionId": string|null}`.
+     */
+    split_paragraph(story: string, para_id: string, offset: number, author_name?: string | null, author_date?: string | null): string;
+    /**
+     * The story's `canonical-stream-v1` FNV-1a checksum as a decimal string
+     * (u64 exceeds JS safe-integer range). The coexistence watchdog compares
+     * this against the PM projector's checksum after every mirrored edit.
+     */
+    story_checksum(story: string): string;
+    /**
+     * Story ids currently in the document, sorted for determinism.
+     */
+    story_ids(): string[];
+    /**
+     * Story length in UTF-16 units (every embed, pilcrows included, = 1).
+     */
+    story_len(story: string): number;
+    /**
+     * The raw formatted-segment view (the render bridge's input):
+     * `[{"kind":"text","text",…} | {"kind":"pilcrow","paraId","properties",…}
+     * | {"kind":"embed",…}]`, each with `"attributes"` (run marks plus
+     * `ins`/`del` revision values).
+     */
+    story_segments(story: string): string;
+    /**
+     * Applies one run mark over `[start, end)` (two Locs in one story). Simple
+     * marks toggle; font/size/color set (see [`apply_mark`]). `mark_json`:
+     * `{"type":"bold"|"italic"|"underline"|"strike"|"superscript"|"subscript"} |
+     * {"type":"fontFamily"|"color","value":string} |
+     * {"type":"fontSize","value":number}`.
+     */
+    toggle_mark(story: string, start_para: string, start_offset: number, end_para: string, end_offset: number, mark_json: string): void;
+    /**
+     * Starts local undo tracking for a structural table transaction. Besides
+     * the parent story (which owns the table embed), the stories root must be
+     * in scope so undo/redo also removes/restores cell-story map entries.
+     */
+    track_table_undo(story: string): void;
+    /**
+     * Starts local-origin undo tracking for one story. Hosts call this lazily
+     * after import/seeding but before the first direct input operation, so the
+     * initial document is not an undo step.
+     */
+    track_undo(story: string): void;
+    /**
+     * Reverts the latest local-origin transaction. Remote/system mirror
+     * transactions are excluded by `DocUndoManager`'s tracked-origin policy.
+     */
+    undo(): boolean;
+    /**
+     * Current local undo stack size. Zero before a story starts tracking.
+     */
+    undo_depth(): number;
+    /**
+     * Lowers a story straight to the renderer's `LayoutBlock[]` (JSON) — the
+     * yrs-authoritative render path (the eventual replacement for the TS
+     * `toLayoutBlocks(pmDoc)`). Errors with an unsupported-embed message on any
+     * non-native content (e.g. an opaque page-break blob) until that class is
+     * promoted to native; the host falls back to the PM render path there.
+     * `env_json` carries theme colors, the default tab stop, and list numeric
+     * ids (see [`parse_render_env`]).
+     */
+    yrs_blocks_for_story(story: string, env_json: string): string;
+}
+
+/**
+ * Loader for the docx-edit wasm (the Rust yrs editing core + resident layout
+ * engine). External-asset pattern — see ./loadWasmAsset.ts for the init
+ * contract and URL-geometry invariant.
+ *
+ * Reached only via the `src/yrs/` facade's dynamic `import()`, so the glue
+ * (and the wasm fetch) stay out of every non-editor bundle path. The facade's
+ * async `createYrsSession` awaits {@link preloadEditWasm} before constructing
+ * a session, which also covers the resident engine worker (it bootstraps
+ * through the same facade inside the worker context).
+ */
+
+/** Load + instantiate the editing-core wasm (browser path). Idempotent. */
+declare function preloadEditWasm(input?: WasmAsyncInput): Promise<void>;
+/**
+ * Constructs a raw wasm `EditSession` replica after ensuring the module is
+ * initialized. The `src/yrs/` facade wraps this in the typed `YrsSession`
+ * surface — nothing else should call it.
+ */
+declare function createEditSession(clientId: number): EditSession;
+
+export { EditSession, createEditSession, preloadEditWasm };

package/dist/wasm-edit.mjs

@@ -0,0 +1 @@
+export{b as createEditSession,a as preloadEditWasm}from'./chunk-NEWOMDTX.mjs';import'./chunk-T4EZMUXM.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/wasm-layout.d.mts

@@ -0,0 +1,112 @@
+import { W as WasmAsyncInput } from './loadWasmAsset-CMvnVkfA.mjs';
+
+/**
+ * Loader for the docx-layout wasm (the Rust display-list builder and the
+ * ooxml-text measure surface). External-asset pattern — see ./loadWasmAsset.ts
+ * for the init contract and URL-geometry invariant.
+ *
+ * IMPORTANT: reach this module only via dynamic `import()` — its consumers are
+ * the canvas renderer and the Rust measurement source, and those dynamic-import
+ * seams await {@link preloadLayoutWasm} before first use.
+ *
+ * Requires a CSP that permits wasm compilation (`wasm-unsafe-eval`).
+ */
+
+/** Load + instantiate the layout wasm (browser path). Idempotent. */
+declare function preloadLayoutWasm(input?: WasmAsyncInput): Promise<void>;
+/**
+ * Region-aware hit test over a display list: page-local point in,
+ * `{"region":"body"|"header"|"footer","rId"?,"pos":n|null}` (or `"null"` for
+ * an out-of-range page) JSON out. Header/footer hits identify the HF PM doc
+ * by `rId`; their `pos` refers to that doc, not the body doc.
+ */
+declare function hitTestRegionsJson(displayList: string, pageIndex: number, x: number, y: number): string;
+/**
+ * Highlight rects for a body PM range over a display list: JSON array of
+ * `{pageIndex, x, y, width, height}` in page-local px. Body-only — HF doc
+ * positions live in different PM docs and are never consulted.
+ */
+declare function rangeRectsJson(displayList: string, from: number, to: number): string;
+/**
+ * True when the embedded layout wasm carries the session-handle query exports.
+ * Callers gate the handle path on this and otherwise use the JSON-arg exports.
+ */
+declare function hasDisplayListSession(): boolean;
+/**
+ * True when the embedded layout wasm carries the region-aware range-rect exports
+ * (`range_rects_region_json` and its by-handle twin). Callers gate the HF
+ * selection/caret geometry on this and otherwise return `[]` — probing here
+ * avoids ever invoking (and thus dropping the session handle over) an absent
+ * export before the integrator re-embeds.
+ */
+declare function hasRangeRectsRegion(): boolean;
+/**
+ * Parse a display list once and return a handle the by-handle queries reuse.
+ * Throws when the export is absent (pre-re-embed) or the JSON is malformed;
+ * the query facade catches it and stays on the JSON-arg path.
+ */
+declare function openDisplayList(displayList: string): number;
+/** Drop a display-list handle so its parsed list is freed. No-op when the export is absent. */
+declare function closeDisplayList(handle: number): void;
+/**
+ * Region-aware hit test against a stored display list (by handle). Throws when
+ * the export is absent or the handle is unknown/closed — the facade catches it
+ * and falls back to `hitTestRegionsJson`.
+ */
+declare function hitTestRegionsByHandle(handle: number, pageIndex: number, x: number, y: number): string;
+/**
+ * Highlight rects for a body PM range against a stored display list (by handle).
+ * Throws when the export is absent or the handle is unknown/closed.
+ */
+declare function rangeRectsByHandle(handle: number, from: number, to: number): string;
+/**
+ * Region-aware highlight rects for a PM range: `region` is
+ * `"body" | "header" | "footer"`; `rId` scopes header/footer to one HF part
+ * (empty string for body / match-any). The `from`/`to` refer to that region's
+ * PM doc. Like the session exports, this is resolved by name so the glyph/HF
+ * pipeline is safe to ship before the integrator re-embeds; throws when absent
+ * so the facade falls back to `[]` (HF selection geometry stays a documented
+ * gap until the re-embed lands).
+ */
+declare function rangeRectsRegionJson(displayList: string, region: string, rId: string, from: number, to: number): string;
+/**
+ * Region-aware highlight rects against a stored display list (by handle). Throws
+ * when the export is absent or the handle is unknown/closed.
+ */
+declare function rangeRectsRegionByHandle(handle: number, region: string, rId: string, from: number, to: number): string;
+/** `{ measured, options, layout }` JSON in, `DisplayList` JSON out. Throws on inputs the Rust builder rejects. */
+declare function buildDisplayListJson(input: string): string;
+/**
+ * Pagination: `{ measured, options }` JSON in (the golden-fixture envelope),
+ * `Layout` JSON out. Throws for inputs the Rust layout kernel rejects — the
+ * layout pipeline surfaces the error and keeps the previous committed
+ * layout; there is no fallback engine.
+ */
+declare function layoutDocumentJson(input: string): string;
+/**
+ * Register raw sfnt bytes with the measurement FontStore; returns the font id
+ * that `measureParagraphJson` inputs reference in their `fontChains`. Throws
+ * on malformed bytes (embedded fonts are attacker-controlled — the engine
+ * rejects unparseable input at this boundary).
+ */
+declare function registerMeasureFont(bytes: Uint8Array): number;
+/** Drop every registered measurement font (ids restart at 0). Callers must re-register before the next `measureParagraphJson`. */
+declare function clearMeasureFonts(): void;
+/**
+ * Measurement input JSON in, `ParagraphExtent` JSON out. Throws with a
+ * message starting `"UNSUPPORTED"` for blocks the Rust engine cannot measure
+ * yet — the caller must fall back to browser measurement for that block.
+ */
+declare function measureParagraphJson(input: string): string;
+/**
+ * Glyph outline for `(fontId, glyphId)` as JSON:
+ * `{"upem":2048,"cmds":[{"t":"M",..},{"t":"L",..},{"t":"Q",..},{"t":"C",..},{"t":"Z"}]}`
+ * — commands in font units, y-up (font convention). `fontId` is a
+ * measurement-FontStore id (`registerMeasureFont`), `glyphId` a glyph index
+ * from shaping. Throws when the export is absent (pre-integration) or the
+ * glyph cannot be extracted; the canvas backend catches it and paints the run
+ * via `fillText` so text is never invisible.
+ */
+declare function outlineGlyphJson(fontId: number, glyphId: number): string;
+
+export { buildDisplayListJson, clearMeasureFonts, closeDisplayList, hasDisplayListSession, hasRangeRectsRegion, hitTestRegionsByHandle, hitTestRegionsJson, layoutDocumentJson, measureParagraphJson, openDisplayList, outlineGlyphJson, preloadLayoutWasm, rangeRectsByHandle, rangeRectsJson, rangeRectsRegionByHandle, rangeRectsRegionJson, registerMeasureFont };

package/dist/wasm-layout.mjs

@@ -0,0 +1 @@
+export{l as buildDisplayListJson,o as clearMeasureFonts,g as closeDisplayList,d as hasDisplayListSession,e as hasRangeRectsRegion,h as hitTestRegionsByHandle,b as hitTestRegionsJson,m as layoutDocumentJson,p as measureParagraphJson,f as openDisplayList,q as outlineGlyphJson,a as preloadLayoutWasm,i as rangeRectsByHandle,c as rangeRectsJson,k as rangeRectsRegionByHandle,j as rangeRectsRegionJson,n as registerMeasureFont}from'./chunk-CIRN3LZA.mjs';import'./chunk-T4EZMUXM.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/wasm-opc.d.mts

@@ -0,0 +1,16 @@
+import { W as WasmAsyncInput } from './loadWasmAsset-CMvnVkfA.mjs';
+
+/**
+ * Loader for the ooxml-opc wasm (the OPC zip container: unzip/rezip with
+ * zip-bomb and path-traversal guards). External-asset pattern — see
+ * ./loadWasmAsset.ts for the init contract and URL-geometry invariant.
+ */
+
+/** Load + instantiate the container wasm (browser path). Idempotent. */
+declare function preloadOpcWasm(input?: WasmAsyncInput): Promise<void>;
+/** Inflate a DOCX container into `{ [path]: Uint8Array }`. */
+declare function unzipContainer(data: Uint8Array): Record<string, Uint8Array>;
+/** Deflate `{ [path]: Uint8Array }` into DOCX bytes. */
+declare function rezipContainer(entries: Record<string, Uint8Array>): Uint8Array;
+
+export { preloadOpcWasm, rezipContainer, unzipContainer };

package/dist/wasm-opc.mjs

@@ -0,0 +1 @@
+export{a as preloadOpcWasm,c as rezipContainer,b as unzipContainer}from'./chunk-H3JCIGWK.mjs';import'./chunk-T4EZMUXM.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/wasm-parse.d.mts

@@ -0,0 +1,18 @@
+import { W as WasmAsyncInput } from './loadWasmAsset-CMvnVkfA.mjs';
+
+/**
+ * Loader for the docx-parse wasm (the Rust DOCX parser/serializer wire).
+ * External-asset pattern — see ./loadWasmAsset.ts for the init contract and
+ * URL-geometry invariant.
+ */
+
+/** Load + instantiate the parser wasm (browser path). Idempotent. */
+declare function preloadParseWasm(input?: WasmAsyncInput): Promise<void>;
+declare function parseDocxS9Wire(data: Uint8Array, optionsJson: string): string;
+declare function parseRelationshipsXmlWire(data: Uint8Array, partPath: string): string;
+declare function serializeDocxS10Wire(requestJson: string): string;
+declare function serializeDocxS11Wire(requestJson: string): string;
+declare function serializeDocxS12Wire(requestJson: string): string;
+declare function writeDocxS13Wire(requestJson: string, originalDocx: Uint8Array): Uint8Array;
+
+export { parseDocxS9Wire, parseRelationshipsXmlWire, preloadParseWasm, serializeDocxS10Wire, serializeDocxS11Wire, serializeDocxS12Wire, writeDocxS13Wire };

package/dist/wasm-parse.mjs

@@ -0,0 +1 @@
+export{b as parseDocxS9Wire,c as parseRelationshipsXmlWire,a as preloadParseWasm,d as serializeDocxS10Wire,e as serializeDocxS11Wire,f as serializeDocxS12Wire,g as writeDocxS13Wire}from'./chunk-SINEY6ZF.mjs';import'./chunk-T4EZMUXM.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/watermarkApi-DCxjutkg.d.mts

@@ -0,0 +1,38 @@
+import { Document } from './types/document.mjs';
+import { W as Watermark } from './content-sSHuWw49.mjs';
+
+/**
+ * Watermark document API
+ *
+ * Platform-agnostic helpers for reading and applying a document watermark.
+ * Shared by the React and Vue adapters (and the imperative ref API) so the
+ * "Design → Watermark" behavior stays identical across frameworks.
+ *
+ * A watermark lives on `HeaderFooter.watermark`. MS Word repeats the same
+ * watermark across the default, first-page, and even-page headers of every
+ * section, so `setDocumentWatermark`:
+ *
+ * 1. Applies the watermark (a per-header copy) to every existing header, and
+ * 2. Creates the header parts a section needs but lacks, so the watermark
+ *    still shows on title pages (`w:titlePg`) and even pages
+ *    (`w:evenAndOddHeaders`) and on documents that had no header at all.
+ *
+ * To avoid breaking header inheritance (a section that omits a header
+ * reference inherits the previous section's header — Word's "link to
+ * previous"), a missing `first`/`even` header part is only created when **no**
+ * header of that type exists anywhere in the document, i.e. there is nothing to
+ * inherit. All updates are immutable — a new `Document` is returned so the
+ * change lands in the host's undo/redo history.
+ */
+
+/** Read the document's watermark (the first header that carries one). */
+declare function getDocumentWatermark(doc: Document | null | undefined): Watermark | undefined;
+/**
+ * Return a new `Document` with the watermark applied to all headers, or removed
+ * when `watermark` is null. Creates the header parts a section needs but lacks
+ * (default for a headerless doc; first/even for title/even pages) so the
+ * watermark shows on every page MS Word would show it.
+ */
+declare function setDocumentWatermark(doc: Document, watermark: Watermark | null): Document;
+
+export { getDocumentWatermark as g, setDocumentWatermark as s };