@betteroffice/docx 0.0.1 → 0.0.3

package/dist/rustDisplayList-BRuZBqdL.d.mts

@@ -0,0 +1,278 @@
+import { a as Layout } from './types-BfqUl2h_.mjs';
+import { MeasuredBlock } from './layout/pagination/index.mjs';
+import { D as DisplayList, R as RetainedFrame } from './frameDelta-D965X8yK.mjs';
+
+/**
+ * JS seam to the Rust display-list builder (crates/docx-layout).
+ *
+ * Marshals the same `{ measured, options, layout }` triple the golden
+ * fixtures pin (see scripts/export-displaylist-fixtures.ts) across the wasm
+ * boundary and parses the resulting DisplayList. All paint/geometry decisions
+ * happen in Rust — this module is serialization glue only.
+ *
+ * The wasm module is loaded lazily via dynamic import on first build, so the
+ * ~800KB inlined binary costs nothing until the experimental canvas renderer
+ * is actually enabled.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+
+/**
+ * One header/footer part in the `headersFooters` envelope field: the measured
+ * blocks of the HF ProseMirror doc identified by `rId`, plus the band metrics
+ * `convertHeaderFooterPmDocToContent` computed (passed through verbatim — the
+ * Rust builder re-derives nothing).
+ */
+interface DisplayListHfVariant {
+    rId: string;
+    kind: 'header' | 'footer';
+    type: 'default' | 'first' | 'even';
+    /** `toMeasuredBlocks(content.blocks, content.measures)` — same schema as body `measured` */
+    measured: MeasuredBlock[];
+    /** HeaderFooterContent.height (in-flow stack incl. floating blocks) */
+    height: number;
+    /** HeaderFooterContent.flowHeight (in-flow band height; fallback: height) */
+    flowHeight?: number;
+    visualTop?: number;
+    visualBottom?: number;
+    /**
+     * Per-page resolved widths of PAGE/NUMPAGES field runs in this HF part, so a
+     * centered/right-aligned line carrying such a field re-centers per page. The
+     * line width is measured ONCE at the field's fallback text ("1"), so without
+     * this the builder holds the same centered position on every page even though
+     * "Page 2 of 3"/"Page 10 of 12" have different widths. Omitted ⇒ the fields
+     * ride the char-distributed fallback width (byte-identical to before).
+     */
+    fieldWidths?: DisplayListFieldWidths[];
+}
+/**
+ * Per-page widths of one PAGE/NUMPAGES field run in an HF part. `pmStart` is the
+ * field run's position in the HF ProseMirror doc (the key the Rust builder
+ * matches). `fallbackWidth` is the width the measure baked into `line.width`
+ * (the field's fallback text); `perPage[i]` is the width of the field's resolved
+ * text on layout page index `i` (PAGE → that page's number, NUMPAGES → total).
+ */
+interface DisplayListFieldWidths {
+    pmStart: number;
+    fallbackWidth: number;
+    perPage: number[];
+}
+/**
+ * Optional header/footer payload of the builder envelope. Absent ⇒ the Rust
+ * output is byte-identical to the body-only build. Flags come off the section
+ * properties / settings the DOM painter uses; distances are the same px the
+ * painter resolves (`headerDistance ?? page.margins.header ?? 48`).
+ */
+interface DisplayListHeadersFooters {
+    titlePg?: boolean;
+    evenAndOddHeaders?: boolean;
+    headerDistance?: number;
+    footerDistance?: number;
+    /** Page-level Word watermark, painted behind body/header/footer content. */
+    watermark?: DisplayListWatermark;
+    variants: DisplayListHfVariant[];
+    /** Stable section identity. Undefined = document-global legacy envelope. */
+    sectionId?: string;
+    /** Zero-based section index. */
+    sectionIndex?: number;
+}
+type DisplayListWatermark = DisplayListTextWatermark | DisplayListPictureWatermark;
+interface DisplayListTextWatermark {
+    kind: 'text';
+    text: string;
+    font: string;
+    color: string;
+    semitransparent: boolean;
+    layout: 'diagonal' | 'horizontal';
+    fontSize?: number;
+    /** Undefined defaults to true for watermarks. */
+    decorative?: boolean;
+}
+interface DisplayListPictureWatermark {
+    kind: 'picture';
+    relId?: string;
+    dataUrl?: string;
+    scale: number;
+    washout: boolean;
+    widthEmu?: number;
+    heightEmu?: number;
+    /** Undefined defaults to true for watermarks. */
+    decorative?: boolean;
+}
+/** One measured note in a page/section note area. */
+interface DisplayListNoteItem {
+    kind?: 'footnote' | 'endnote';
+    id?: number;
+    displayLabel?: string;
+    measured?: MeasuredBlock[];
+    height?: number;
+    anchorDocStart?: number;
+    anchorDocEnd?: number;
+    customMarkFollows?: boolean;
+}
+/** Typed non-fragmented note-region input for the Rust display builder. */
+interface DisplayListNoteArea {
+    pageIndex?: number;
+    sectionId?: string;
+    kind?: 'footnote' | 'endnote';
+    placement?: 'pageBottom' | 'beneathText' | 'sectEnd' | 'docEnd';
+    y?: number;
+    height?: number;
+    columns?: number;
+    separator?: DisplayListNoteItem;
+    notes?: DisplayListNoteItem[];
+}
+/** Stable reviewer palette entry for comments/revisions. */
+interface DisplayListCommentAuthor {
+    id?: string;
+    name?: string;
+    paletteIndex?: number;
+    color?: string;
+}
+/** One reply of a comment thread (a11y announcement input). */
+interface DisplayListCommentReply {
+    id?: number;
+    authorId?: string;
+    authorName?: string;
+    date?: string;
+    /** Plain-text body (the builder caps it before it reaches primitives). */
+    text?: string;
+}
+/**
+ * Per-comment thread metadata keyed by comment id, joined by the builder onto
+ * every primitive carrying that id in `commentIds` so the a11y mirror can
+ * announce the complete thread (author name, date, body, replies). All string
+ * values are file-derived/attacker-controlled; consumers must only ever
+ * assign them via textContent/setAttribute.
+ */
+interface DisplayListCommentThread {
+    /** Comment id — matches the numeric ids in `resolvedCommentIds`/`commentIds`. */
+    id?: number;
+    authorId?: string;
+    authorName?: string;
+    date?: string;
+    /** Plain-text body (builder-capped before emission). */
+    text?: string;
+    /** Replies in thread order (builder-capped count and text). */
+    replies?: DisplayListCommentReply[];
+}
+/** The `{ measured, options, layout }` envelope the Rust builder consumes. */
+interface DisplayListBuildInputs {
+    /** Serialization contract version. Undefined reads as legacy version 0. */
+    contractVersion?: number;
+    measured: MeasuredBlock[];
+    options: unknown;
+    layout: Layout;
+    /** header/footer parts + section flags; omitted ⇒ body-only display list */
+    headersFooters?: DisplayListHeadersFooters;
+    /**
+     * Doc-wide font-id chains keyed `"<family lowercase>|<bold 0|1>|<italic 0|1>"`
+     * → measurement `FontStore` ids — the SAME map the measurement input carries.
+     * Present only under Rust measurement (the ids must belong to a populated
+     * store); its presence against that store is what gates GlyphRun emission.
+     * Omitted ⇒ every text run takes the browser-measured `TextRunPrimitive` path
+     * (byte-identical to the pre-glyph build).
+     */
+    fontChains?: Record<string, number[]>;
+    /** Page/section note regions. Undefined = no note emission. */
+    noteAreas?: DisplayListNoteArea[];
+    /** Resolved comments suppressed from active tint. Undefined = none known. */
+    resolvedCommentIds?: number[];
+    /** Stable reviewer palette. Undefined = legacy hard-coded colors. */
+    commentAuthors?: DisplayListCommentAuthor[];
+    /** Per-comment thread metadata for a11y announcements. Undefined = none. */
+    commentThreads?: DisplayListCommentThread[];
+}
+/** Minimal engine surface, injectable so tests can fake the wasm module. */
+interface RustDisplayListEngine {
+    buildDisplayListJson(input: string): string;
+    /** Resident editing engines expose binary deltas; the stateless layout wasm does not. */
+    buildDisplayListFrame?(input: string, expectedFrameEpoch: number): Uint8Array;
+    /** One-owner ordinary input path; available on the resident editing engine. */
+    applyInput?(text: string, expectedFrameEpoch: number): Uint8Array;
+    displayHitTestRegionsJson?(pageIndex: number, x: number, y: number): string;
+    displayRangeRectsJson?(from: number, to: number): string;
+    displayRangeRectsRegionJson?(region: 'body' | 'header' | 'footer', rId: string, from: number, to: number): string;
+}
+type RustDisplayListSourceErrorStage = 'load' | 'build' | 'parse' | 'decode' | 'apply';
+interface RustDisplayFrameResult {
+    displayList: DisplayList;
+    /** Null only on the compatibility JSON engine path. */
+    frame: RetainedFrame | null;
+    transport: 'frame-delta-v1' | 'json';
+}
+/**
+ * Typed terminal error from the mandatory Rust display-list source. Hosts may
+ * surface this through their editor error boundary; it is never permission to
+ * silently substitute painter geometry.
+ */
+declare class RustDisplayListSourceError extends Error {
+    readonly stage: RustDisplayListSourceErrorStage;
+    constructor(stage: RustDisplayListSourceErrorStage, cause: unknown);
+}
+/**
+ * Query surface over an already-built display list, injectable so tests can
+ * fake the wasm module.
+ *
+ * The `*Json` calls take the display-list JSON string as an argument (the Rust
+ * side re-parses it per query — callers should cache the string). The
+ * session-handle members parse the list ONCE (`openDisplayList` → handle) and
+ * answer many queries by handle with no re-serialization, reusing the same
+ * hit/range logic so results are byte-identical. The handle members are
+ * OPTIONAL: the embedded wasm carries them only after the integrator re-embeds,
+ * so `createDisplayListQueries` feature-detects `hasDisplayListSession` and
+ * falls back to the `*Json` path when they are absent.
+ */
+interface RustDisplayListQueryEngine {
+    /** region-aware hit test → `{"region","rId"?,"pos"}` or `"null"` JSON */
+    hitTestRegionsJson(displayList: string, pageIndex: number, x: number, y: number): string;
+    /** body PM range → JSON array of `{pageIndex,x,y,width,height}` rects */
+    rangeRectsJson(displayList: string, from: number, to: number): string;
+    /**
+     * Region-aware PM range → JSON array of rects. `region` is
+     * `'body' | 'header' | 'footer'`; `rId` scopes header/footer to one HF part
+     * (empty for body / match-any). OPTIONAL: the embedded wasm carries it only
+     * after the integrator re-embeds, so `createDisplayListQueries` falls back to
+     * `[]` when absent (HF selection geometry stays a documented gap until then).
+     */
+    rangeRectsRegionJson?(displayList: string, region: string, rId: string, from: number, to: number): string;
+    /** true when the embedded wasm carries the region-aware range-rect exports */
+    hasRangeRectsRegion?(): boolean;
+    /** true when the embedded wasm carries the session-handle exports below */
+    hasDisplayListSession?(): boolean;
+    /** parse a display list once, return a handle for the by-handle queries */
+    openDisplayList?(displayList: string): number;
+    /** free a handle's parsed display list */
+    closeDisplayList?(handle: number): void;
+    /** patch a stored display list's changed pages in place (see layout wasm) */
+    updateDisplayList?(handle: number, update: string): void;
+    /** true when the embedded wasm carries the page-delta update export */
+    hasDisplayListUpdate?(): boolean;
+    /** region-aware hit test against a stored display list (by handle) */
+    hitTestRegionsByHandle?(handle: number, pageIndex: number, x: number, y: number): string;
+    /** body PM range against a stored display list (by handle) */
+    rangeRectsByHandle?(handle: number, from: number, to: number): string;
+    /** region-aware PM range against a stored display list (by handle) */
+    rangeRectsRegionByHandle?(handle: number, region: string, rId: string, from: number, to: number): string;
+}
+/**
+ * Lazily load the wasm query surface (hit-test + range-rects). Shares the
+ * module promise with `buildRustDisplayList`, so on the canvas-renderer path
+ * the engine is already resolved by the time the first display list lands.
+ */
+declare function loadRustDisplayListQueryEngine(): Promise<RustDisplayListQueryEngine>;
+/** Display-only fields sent to an engine that already retains pagination. */
+declare function encodeDisplayListFrameExtras(inputs: DisplayListBuildInputs): string;
+/**
+ * Build a DisplayList for a computed layout through the Rust engine. Throws
+ * when the wasm module fails to load or the builder rejects the input — the
+ * caller is expected to fall back to the DOM painter.
+ */
+declare function buildRustDisplayList(inputs: DisplayListBuildInputs, engine?: RustDisplayListEngine): Promise<DisplayList>;
+/**
+ * Production display build. Resident editing engines return FrameDelta v1;
+ * older/stateless engines retain the full-JSON parity path.
+ */
+declare function buildRustDisplayFrame(inputs: DisplayListBuildInputs, engine?: RustDisplayListEngine, previous?: RetainedFrame | null): Promise<RustDisplayFrameResult>;
+
+export { type DisplayListHeadersFooters as D, type RustDisplayListQueryEngine as R, type DisplayListBuildInputs as a, type DisplayListHfVariant as b, type DisplayListPictureWatermark as c, type DisplayListTextWatermark as d, type DisplayListWatermark as e, type RustDisplayFrameResult as f, type RustDisplayListEngine as g, RustDisplayListSourceError as h, type RustDisplayListSourceErrorStage as i, buildRustDisplayFrame as j, buildRustDisplayList as k, encodeDisplayListFrameExtras as l, loadRustDisplayListQueryEngine as m };

package/dist/rustMeasureSource-D1KsQvVC.d.mts

@@ -0,0 +1,106 @@
+import { CompatibilityFlags } from './types/document.mjs';
+
+/**
+ * Script bucket a fallback face provides glyph coverage for. Han text is
+ * region-resolved by the caller (SC/TC/JP/KR — see `rustMeasureSource.ts`);
+ * kana, Hangul, Arabic and Hebrew detect directly.
+ *
+ * @public
+ */
+type FontScript = 'cjk-sc' | 'cjk-tc' | 'cjk-jp' | 'cjk-kr' | 'arabic' | 'hebrew';
+/**
+ * Resolver for the bundled metric-compatible set (Carlito↔Calibri,
+ * Liberation↔Arial/Times/Courier, …). Returns a lazy byte loader so the
+ * (lazily fetched, same-origin) binary is only downloaded when a document
+ * actually needs the face, or `undefined` when the family has no bundled
+ * substitute.
+ *
+ * @public
+ */
+interface BundledFontProvider {
+    /** Resolve a Word family to bundled metric-compatible face byte loaders, or undefined. */
+    resolve(family: string, bold: boolean, italic: boolean): (() => Promise<ArrayBuffer>) | undefined;
+    /**
+     * Optional per-script coverage fallback (Noto CJK/RTL faces). Same loader
+     * contract as {@link BundledFontProvider.resolve}; providers without
+     * script faces simply omit the method. These faces are coverage fallbacks
+     * first, metric approximations second — CJK metric compatibility is much
+     * weaker than the Carlito/Calibri class of substitutes.
+     */
+    resolveScriptFallback?(script: FontScript, bold: boolean, italic: boolean): (() => Promise<ArrayBuffer>) | undefined;
+    /**
+     * The always-available last-resort base face (broad-coverage Latin —
+     * Liberation Sans/Serif per serif-ness). Unlike {@link
+     * BundledFontProvider.resolve}, a conforming provider (e.g.
+     * `@betteroffice/docx-fonts`'s `resolveLastResortFace`) returns a loader for
+     * EVERY family, so the chain this registry builds is guaranteed non-empty
+     * and a run never routes to the browser measurer for want of font bytes. The
+     * face's metrics are the base font's, not the requested family's — the
+     * accepted divergence for a truly-unknown font, in exchange for staying on
+     * the native measurement path.
+     *
+     * Optional so mock/partial providers can omit it; when absent (or returning
+     * undefined) an unmapped family still yields an empty chain and the caller
+     * browser-falls-back that run — the pre-policy behavior. Same lazy loader
+     * contract as {@link BundledFontProvider.resolve}.
+     */
+    resolveLastResort?(family: string, bold: boolean, italic: boolean): (() => Promise<ArrayBuffer>) | undefined;
+}
+/**
+ * One embedded face extracted from the open document. Structurally identical
+ * to `EmbeddedFontFace` (`utils/embeddedFonts.ts`), so the output of
+ * `getEmbeddedFontFaces` feeds straight in; duplicated here so this module
+ * stays decoupled from the loader.
+ *
+ * @public
+ */
+interface EmbeddedFaceInput {
+    /** Word font name the face is registered under (attacker-controlled). */
+    family: string;
+    /** `'bold'` for the embedBold/embedBoldItalic slots, else `'normal'`. */
+    weight: 'normal' | 'bold';
+    /** `'italic'` for the embedItalic/embedBoldItalic slots, else `'normal'`. */
+    style: 'normal' | 'italic';
+    /** De-obfuscated OpenType/TrueType bytes. */
+    data: ArrayBuffer;
+    /** Whether the source face was subsetted (`w:subsetted`). */
+    subsetted: boolean;
+}
+
+interface RustTextEngine {
+    registerFont(bytes: Uint8Array): number;
+    clearFonts(): void;
+}
+interface ResidentFontRequirement {
+    key: string;
+    family: string;
+    bold: boolean;
+    italic: boolean;
+    scripts?: FontScript[];
+}
+interface ResidentMeasurementConfig {
+    fontChains: Record<string, number[]>;
+    defaults: {
+        fontSize: 11;
+        fontFamily: 'Calibri';
+    };
+    compat: {
+        noLeading: boolean;
+        doNotExpandShiftReturn: boolean;
+    };
+    authoritativeShaping: true;
+}
+interface RustMeasureSource {
+    setEmbeddedFaces(faces: EmbeddedFaceInput[]): void;
+    setCompat(flags: CompatibilityFlags | undefined): void;
+    prepareFontRequirements(requirements: ResidentFontRequirement[]): Promise<boolean>;
+    measurementConfigForRequirements(requirements: ResidentFontRequirement[]): ResidentMeasurementConfig | undefined;
+    clear(): void;
+}
+declare function getRustTextEngine(): Promise<RustTextEngine>;
+declare function createRustMeasureSource(options: {
+    engine: RustTextEngine;
+    bundled?: BundledFontProvider;
+}): RustMeasureSource;
+
+export { type BundledFontProvider as B, type EmbeddedFaceInput as E, type FontScript as F, type ResidentMeasurementConfig as R, type ResidentFontRequirement as a, type RustMeasureSource as b, type RustTextEngine as c, createRustMeasureSource as d, getRustTextEngine as g };

package/dist/selectiveSave-CVoajSKE.d.mts

@@ -0,0 +1,56 @@
+import { Document } from './types/document.mjs';
+import { D as DocxInput } from './docxInput-DTbCa48g.mjs';
+
+/**
+ * Public DOCX parser facade.
+ *
+ * Rust S9 owns ZIP/XML parsing. TypeScript only normalizes host inputs,
+ * rehydrates the public `Document`, reports progress, and registers fonts.
+ * @packageDocumentation
+ * @public
+ */
+
+type ProgressCallback = (stage: string, percent: number) => void;
+interface ParseOptions {
+    onProgress?: ProgressCallback;
+    preloadFonts?: boolean;
+    parseHeadersFooters?: boolean;
+    parseNotes?: boolean;
+}
+declare function parseDocx(input: DocxInput, options?: ParseOptions): Promise<Document>;
+
+/**
+ * Public DOCX package I/O wrappers.
+ *
+ * Model serialization and selective package writing are Rust-owned. The
+ * TypeScript kept here is compatibility glue for public ZIP utilities and host
+ * values; package inflation/deflation continues through `docx-container` wasm.
+ * @packageDocumentation
+ * @public
+ */
+
+interface RepackOptions {
+    /** Retained for signature compatibility; `docx-container` chooses compression. */
+    compressionLevel?: number;
+    updateModifiedDate?: boolean;
+    modifiedBy?: string;
+}
+/** Repack a public Document through the live Rust S13 writer. */
+declare function repackDocx(doc: Document, options?: RepackOptions): Promise<ArrayBuffer>;
+declare function updateMultipleFiles(originalBuffer: ArrayBuffer, updates: Map<string, string | ArrayBuffer>, options?: RepackOptions): Promise<ArrayBuffer>;
+declare function createDocx(doc: Document): Promise<ArrayBuffer>;
+
+/** Rust-backed selective DOCX save compatibility wrapper. */
+
+interface SelectiveSaveOptions {
+    changedParaIds: Set<string>;
+    structuralChange: boolean;
+    hasUntrackedChanges: boolean;
+}
+/**
+ * Patch changed paragraphs through the Rust S13 writer. Returns `null` when
+ * selective save is unsafe so callers can fall back to a full repack.
+ */
+declare function attemptSelectiveSave(doc: Document, originalBuffer: ArrayBuffer, options: SelectiveSaveOptions): Promise<ArrayBuffer | null>;
+
+export { attemptSelectiveSave as a, createDocx as c, parseDocx as p, repackDocx as r, updateMultipleFiles as u };

package/dist/styles/index.d.mts

@@ -1,5 +1,5 @@
-import { P as ParagraphFormatting, T as TextFormatting, p as TableLook } from '../formatting-DoL7KBSL.mjs';
-import { a as StyleDefinitions, S as Style, D as DocDefaults } from '../styles-VxNcXLdi.mjs';
+import { P as ParagraphFormatting, a as TextFormatting } from '../formatting-D1EPSaJP.mjs';
+import { S as StyleDefinitions, a as Style, D as DocDefaults } from '../styles-Dn_o3Vo5.mjs';
 
 /**
  * Style Resolver for ProseMirror Editor
@@ -8,7 +8,7 @@ import { a as StyleDefinitions, S as Style, D as DocDefaults } from '../styles-V
  * Handles the cascade:
  * 1. Document defaults (docDefaults)
  * 2. Normal style (if no explicit styleId)
- * 3. Style chain (basedOn inheritance - already resolved by styleParser)
+ * 3. Style chain (basedOn inheritance resolved during parsing)
  * 4. Inline properties
  *
  * Based on ECMA-376 style cascade rules.
@@ -124,39 +124,4 @@ declare class StyleResolver {
  */
 declare function createStyleResolver(styleDefinitions: StyleDefinitions | undefined): StyleResolver;
 
-/**
- * Which table style a freshly inserted table should wear.
- *
- * Both insert paths (toolbar and agent) call into here so a new table picks
- * up the document's own table look instead of a bare black grid. The
- * document can express that look two ways, and we trust them in order of
- * specificity: an explicit `w:defaultTableStyle` in settings.xml
- * (§17.15.1.44) wins when it points at a real style; failing that, a table
- * style marked `w:default="1"` (§17.7.4.18) is used — except when that
- * default is only the formatting-free base ("Table Normal"), which every
- * table already inherits and which would add nothing. With neither present
- * the caller keeps its plain-border fallback.
- *
- * We deliberately never guess by probing for the TableGrid builtin: a
- * document may ship that style without meaning it as its insert default,
- * and the two spec elements above are how templates state intent.
- */
-
-/**
- * `tblLook` Word applies to a brand-new table (val="04A0"): style the first
- * row and first column, enable horizontal banding, disable vertical banding.
- * Setting this lets a resolved table style paint its header-row and banding
- * conditional formatting on the inserted table, matching how Word renders a
- * fresh table created with that style.
- */
-declare const DEFAULT_NEW_TABLE_LOOK: TableLook;
-/**
- * StyleId a brand-new table should adopt, or `undefined` when the document
- * declares nothing usable (the caller then keeps its plain-border default).
- *
- * @param settingsStyleId - `w:defaultTableStyle` from settings.xml
- * @param styles - the document's style resolver (null when unavailable)
- */
-declare function pickTableStyleForInsert(settingsStyleId: string | undefined | null, styles: StyleResolver | null | undefined): string | undefined;
-
-export { DEFAULT_NEW_TABLE_LOOK, type ResolvedParagraphStyle, StyleResolver, createStyleResolver, pickTableStyleForInsert };
+export { type ResolvedParagraphStyle, StyleResolver, createStyleResolver };

package/dist/styles/index.mjs

@@ -1 +1 @@
-export{d as DEFAULT_NEW_TABLE_LOOK,b as StyleResolver,c as createStyleResolver,e as pickTableStyleForInsert}from'../chunk-KXNZFTTK.mjs';import'../chunk-TTRUPDAB.mjs';
+export{b as StyleResolver,c as createStyleResolver}from'../chunk-WBH3SXI6.mjs';import'../chunk-TTRUPDAB.mjs';

package/dist/{styles-VxNcXLdi.d.mts → styles-Dn_o3Vo5.d.mts}

@@ -1,4 +1,4 @@
-import { T as TextFormatting, P as ParagraphFormatting, o as TableFormatting, s as TableRowFormatting, n as TableCellFormatting } from './formatting-DoL7KBSL.mjs';
+import { a as TextFormatting, P as ParagraphFormatting, b as TableFormatting, c as TableRowFormatting, d as TableCellFormatting } from './formatting-D1EPSaJP.mjs';
 
 /**
  * Styles, Theme, Font Table, Relationships & Media Types
@@ -186,4 +186,4 @@ interface MediaFile {
     dataUrl?: string;
 }
 
-export type { DocDefaults as D, FontTable as F, MediaFile as M, Relationship as R, Style as S, StyleDefinitions as a, RelationshipMap as b, FontEmbed as c, FontInfo as d, RelationshipType as e, StyleType as f };
+export type { DocDefaults as D, FontTable as F, MediaFile as M, RelationshipMap as R, StyleDefinitions as S, Style as a, FontEmbed as b, FontInfo as c, Relationship as d, RelationshipType as e, StyleType as f };

package/dist/types/content.d.mts

@@ -1,3 +1,3 @@
-export { B as BlockContent, p as BlockSdt, q as BookmarkEnd, r as BookmarkStart, s as BreakContent, n as Chart, t as ChartAxis, u as ChartContent, w as ChartLegend, z as ChartSeries, G as ChartType, J as Column, C as Comment, a as CommentRangeEnd, b as CommentRangeStart, U as ComplexField, X as DEFAULT_WATERMARK_PRESETS, D as Deletion, c as DocumentBody, Y as DrawingContent, E as Endnote, $ as EndnotePosition, a0 as EndnoteProperties, a1 as Field, a2 as FieldCharContent, a5 as FieldType, a6 as FooterReference, F as Footnote, a7 as FootnotePosition, a8 as FootnoteProperties, m as HeaderFooter, a9 as HeaderFooterType, aa as HeaderReference, H as Hyperlink, I as Image, ac as ImageCrop, af as ImagePadding, ag as ImagePosition, ai as ImageSize, aj as ImageTransform, ak as ImageWrap, am as InlineSdt, d as Insertion, an as InstrTextContent, ap as LineNumberRestart, ar as MathEquation, M as MoveFrom, as as MoveFromRangeEnd, at as MoveFromRangeStart, e as MoveTo, au as MoveToRangeEnd, av as MoveToRangeStart, aw as NoBreakHyphenContent, ay as NoteNumberRestart, az as NoteRefMarkContent, aA as NoteReferenceContent, aF as PageOrientation, P as Paragraph, f as ParagraphContent, aG as ParagraphPropertyChange, aH as PictureWatermark, aI as PropertyChangeInfo, R as Run, g as RunContent, aJ as RunPropertyChange, aM as SdtDataBinding, aP as SdtProperties, aQ as SdtType, aR as Section, S as SectionProperties, aS as SectionStart, aT as SeparatorContent, aU as Shape, aV as ShapeContent, aX as ShapeFill, aZ as ShapeOutline, a$ as ShapeTextBody, b1 as ShapeType, b2 as SimpleField, b3 as SoftHyphenContent, b6 as SymbolContent, b7 as TabContent, T as Table, h as TableCell, b8 as TableCellPropertyChange, b9 as TablePropertyChange, i as TableRow, ba as TableRowPropertyChange, bb as TableStructuralChangeInfo, bc as TextBox, j as TextContent, bd as TextWatermark, k as TrackedChangeInfo, l as TrackedRunChange, be as VerticalAlign, W as Watermark, bf as pictureWatermarkDisplayEmu } from '../content-sSHuWw49.mjs';
-import '../formatting-DoL7KBSL.mjs';
+export { B as BlockContent, m as BlockSdt, n as BookmarkEnd, o as BookmarkStart, p as BreakContent, e as Chart, q as ChartAxis, r as ChartContent, t as ChartLegend, w as ChartSeries, x as ChartType, y as Column, g as Comment, I as CommentRangeEnd, J as CommentRangeStart, L as ComplexField, O as DEFAULT_WATERMARK_PRESETS, Q as Deletion, h as DocumentBody, T as DrawingContent, k as Endnote, V as EndnotePosition, E as EndnoteProperties, X as Field, Y as FieldCharContent, $ as FieldType, a0 as FooterReference, j as Footnote, a1 as FootnotePosition, F as FootnoteProperties, H as HeaderFooter, a2 as HeaderFooterType, a3 as HeaderReference, a4 as Hyperlink, a6 as Image, a7 as ImageCrop, aa as ImagePadding, ab as ImagePosition, ad as ImageSize, ae as ImageTransform, af as ImageWrap, ah as InlineSdt, ai as Insertion, aj as InstrTextContent, al as LineNumberRestart, ao as MathEquation, ap as MoveFrom, aq as MoveFromRangeEnd, ar as MoveFromRangeStart, as as MoveTo, at as MoveToRangeEnd, au as MoveToRangeStart, av as NoBreakHyphenContent, aw as NoteNumberRestart, ax as NoteRefMarkContent, ay as NoteReferenceContent, aD as PageOrientation, f as Paragraph, aE as ParagraphContent, aF as ParagraphPropertyChange, aG as PictureWatermark, aH as PropertyChangeInfo, aI as Run, aJ as RunContent, aK as RunPropertyChange, aM as SdtDataBinding, b as SdtProperties, aP as SdtType, aQ as Section, S as SectionProperties, aR as SectionStart, aS as SeparatorContent, aT as Shape, aU as ShapeContent, aV as ShapeFill, aX as ShapeOutline, aZ as ShapeTextBody, a_ as ShapeType, a$ as SimpleField, b0 as SoftHyphenContent, b3 as SymbolContent, b4 as TabContent, b5 as Table, b6 as TableCell, b7 as TableCellPropertyChange, b8 as TablePropertyChange, b9 as TableRow, ba as TableRowPropertyChange, bb as TableStructuralChangeInfo, bc as TextBox, bd as TextContent, be as TextWatermark, bf as TrackedChangeInfo, bg as TrackedRunChange, bh as VerticalAlign, W as Watermark, bi as pictureWatermarkDisplayEmu } from '../content-MOZ6hKP4.mjs';
+import '../formatting-D1EPSaJP.mjs';
 import '../docx/wrapTypes.mjs';

package/dist/types/document.d.mts

@@ -1,13 +1,41 @@
-import { c as DocumentBody, N as NumberingDefinitions, F as Footnote, E as Endnote, m as HeaderFooter, n as Chart, o as BookmarkRange } from '../content-sSHuWw49.mjs';
-export { A as AbstractNumbering, B as BlockContent, p as BlockSdt, q as BookmarkEnd, r as BookmarkStart, s as BreakContent, t as ChartAxis, u as ChartContent, v as ChartGrouping, w as ChartLegend, x as ChartPlotGroup, y as ChartPoint, z as ChartSeries, G as ChartType, J as Column, C as Comment, K as CommentAnchorRange, O as CommentAuthor, a as CommentRangeEnd, b as CommentRangeStart, Q as CommentReferenceContent, U as ComplexField, V as ContentPosition, X as DEFAULT_WATERMARK_PRESETS, D as Deletion, Y as DrawingContent, Z as DrawingScene, _ as DrawingSceneNode, $ as EndnotePosition, a0 as EndnoteProperties, a1 as Field, a2 as FieldCharContent, a3 as FieldFormData, a4 as FieldInlineContent, a5 as FieldType, a6 as FooterReference, a7 as FootnotePosition, a8 as FootnoteProperties, a9 as HeaderFooterType, aa as HeaderReference, H as Hyperlink, ab as HyperlinkContent, I as Image, ac as ImageCrop, ad as ImageEffect, ae as ImageHyperlink, af as ImagePadding, ag as ImagePosition, ah as ImageRotationBounds, ai as ImageSize, aj as ImageTransform, ak as ImageWrap, al as ImageWrapPoint, am as InlineSdt, d as Insertion, an as InstrTextContent, ao as LevelSuffix, ap as LineNumberRestart, L as ListLevel, aq as ListRendering, ar as MathEquation, M as MoveFrom, as as MoveFromRangeEnd, at as MoveFromRangeStart, e as MoveTo, au as MoveToRangeEnd, av as MoveToRangeStart, aw as NoBreakHyphenContent, ax as NoteKind, ay as NoteNumberRestart, az as NoteRefMarkContent, aA as NoteReferenceContent, aB as NoteSeparatorReference, aC as NumberFormat, aD as NumberingInstance, aE as PageNumberingProperties, aF as PageOrientation, P as Paragraph, f as ParagraphContent, aG as ParagraphPropertyChange, aH as PictureWatermark, aI as PropertyChangeInfo, R as Run, g as RunContent, aJ as RunPropertyChange, aK as SdtCheckboxGlyph, aL as SdtControlState, aM as SdtDataBinding, aN as SdtDateState, aO as SdtGalleryState, aP as SdtProperties, aQ as SdtType, aR as Section, S as SectionProperties, aS as SectionStart, aT as SeparatorContent, aU as Shape, aV as ShapeContent, aW as ShapeEffect, aX as ShapeFill, aY as ShapeFillPaint, aZ as ShapeOutline, a_ as ShapeStrokePaint, a$ as ShapeTextBody, b0 as ShapeTextBodyProperties, b1 as ShapeType, b2 as SimpleField, b3 as SoftHyphenContent, b4 as StructuredFieldContent, b5 as StructuredFieldTree, b6 as SymbolContent, b7 as TabContent, T as Table, h as TableCell, b8 as TableCellPropertyChange, b9 as TablePropertyChange, i as TableRow, ba as TableRowPropertyChange, bb as TableStructuralChangeInfo, bc as TextBox, j as TextContent, bd as TextWatermark, k as TrackedChangeInfo, l as TrackedRunChange, be as VerticalAlign, W as Watermark, bf as pictureWatermarkDisplayEmu } from '../content-sSHuWw49.mjs';
-import { a as Theme, C as ColorValue } from '../formatting-DoL7KBSL.mjs';
-export { B as BorderSpec, c as CellMargins, e as ConditionalFormatStyle, E as EmphasisMark, F as FloatingTableProperties, L as LineSpacingRule, f as ParagraphAlignment, P as ParagraphFormatting, R as RunFontHint, h as RunLanguage, S as ShadingProperties, i as TabLeader, j as TabStop, k as TabStopAlignment, m as TableBorders, n as TableCellFormatting, o as TableFormatting, p as TableLook, q as TableMeasurement, s as TableRowFormatting, t as TableStyleCascade, u as TableStyleRegion, v as TableWidthType, w as TextEffect, T as TextFormatting, x as TextModernEffects, y as ThemeColorScheme, z as ThemeColorSlot, A as ThemeFont, D as ThemeFontScheme, U as UnderlineStyle } from '../formatting-DoL7KBSL.mjs';
-import { a as StyleDefinitions, F as FontTable, b as RelationshipMap, M as MediaFile } from '../styles-VxNcXLdi.mjs';
-export { D as DocDefaults, c as FontEmbed, d as FontInfo, R as Relationship, e as RelationshipType, S as Style, f as StyleType } from '../styles-VxNcXLdi.mjs';
-import { D as DocumentSettings } from '../settingsParser-CcGvtmCK.mjs';
-export { C as CompatibilityFlags } from '../settingsParser-CcGvtmCK.mjs';
+import { F as FootnoteProperties, E as EndnoteProperties, h as DocumentBody, i as NumberingDefinitions, j as Footnote, k as Endnote, H as HeaderFooter, e as Chart, l as BookmarkRange } from '../content-MOZ6hKP4.mjs';
+export { A as AbstractNumbering, B as BlockContent, m as BlockSdt, n as BookmarkEnd, o as BookmarkStart, p as BreakContent, q as ChartAxis, r as ChartContent, s as ChartGrouping, t as ChartLegend, u as ChartPlotGroup, v as ChartPoint, w as ChartSeries, x as ChartType, y as Column, g as Comment, z as CommentAnchorRange, G as CommentAuthor, I as CommentRangeEnd, J as CommentRangeStart, K as CommentReferenceContent, L as ComplexField, M as ContentPosition, O as DEFAULT_WATERMARK_PRESETS, Q as Deletion, T as DrawingContent, D as DrawingScene, U as DrawingSceneNode, V as EndnotePosition, X as Field, Y as FieldCharContent, Z as FieldFormData, _ as FieldInlineContent, $ as FieldType, a0 as FooterReference, a1 as FootnotePosition, a2 as HeaderFooterType, a3 as HeaderReference, a4 as Hyperlink, a5 as HyperlinkContent, a6 as Image, a7 as ImageCrop, a8 as ImageEffect, a9 as ImageHyperlink, aa as ImagePadding, ab as ImagePosition, ac as ImageRotationBounds, ad as ImageSize, ae as ImageTransform, af as ImageWrap, ag as ImageWrapPoint, ah as InlineSdt, ai as Insertion, aj as InstrTextContent, ak as LevelSuffix, al as LineNumberRestart, am as ListLevel, an as ListRendering, ao as MathEquation, ap as MoveFrom, aq as MoveFromRangeEnd, ar as MoveFromRangeStart, as as MoveTo, at as MoveToRangeEnd, au as MoveToRangeStart, av as NoBreakHyphenContent, N as NoteKind, aw as NoteNumberRestart, ax as NoteRefMarkContent, ay as NoteReferenceContent, az as NoteSeparatorReference, aA as NumberFormat, aB as NumberingInstance, aC as PageNumberingProperties, aD as PageOrientation, f as Paragraph, aE as ParagraphContent, aF as ParagraphPropertyChange, aG as PictureWatermark, aH as PropertyChangeInfo, aI as Run, aJ as RunContent, aK as RunPropertyChange, aL as SdtCheckboxGlyph, a as SdtControlState, aM as SdtDataBinding, aN as SdtDateState, aO as SdtGalleryState, b as SdtProperties, aP as SdtType, aQ as Section, S as SectionProperties, aR as SectionStart, aS as SeparatorContent, aT as Shape, aU as ShapeContent, c as ShapeEffect, aV as ShapeFill, aW as ShapeFillPaint, aX as ShapeOutline, aY as ShapeStrokePaint, aZ as ShapeTextBody, d as ShapeTextBodyProperties, a_ as ShapeType, a$ as SimpleField, b0 as SoftHyphenContent, b1 as StructuredFieldContent, b2 as StructuredFieldTree, b3 as SymbolContent, b4 as TabContent, b5 as Table, b6 as TableCell, b7 as TableCellPropertyChange, b8 as TablePropertyChange, b9 as TableRow, ba as TableRowPropertyChange, bb as TableStructuralChangeInfo, bc as TextBox, bd as TextContent, be as TextWatermark, bf as TrackedChangeInfo, bg as TrackedRunChange, bh as VerticalAlign, W as Watermark, bi as pictureWatermarkDisplayEmu } from '../content-MOZ6hKP4.mjs';
+import { e as Theme, C as ColorValue } from '../formatting-D1EPSaJP.mjs';
+export { B as BorderSpec, g as CellMargins, h as ConditionalFormatStyle, E as EmphasisMark, F as FloatingTableProperties, L as LineSpacingRule, i as ParagraphAlignment, P as ParagraphFormatting, R as RunFontHint, j as RunLanguage, S as ShadingProperties, k as TabLeader, l as TabStop, m as TabStopAlignment, n as TableBorders, d as TableCellFormatting, b as TableFormatting, o as TableLook, p as TableMeasurement, c as TableRowFormatting, q as TableStyleCascade, r as TableStyleRegion, s as TableWidthType, t as TextEffect, a as TextFormatting, T as TextModernEffects, u as ThemeColorScheme, f as ThemeColorSlot, v as ThemeFont, w as ThemeFontScheme, U as UnderlineStyle } from '../formatting-D1EPSaJP.mjs';
+import { S as StyleDefinitions, F as FontTable, R as RelationshipMap, M as MediaFile } from '../styles-Dn_o3Vo5.mjs';
+export { D as DocDefaults, b as FontEmbed, c as FontInfo, d as Relationship, e as RelationshipType, a as Style, f as StyleType } from '../styles-Dn_o3Vo5.mjs';
 import '../docx/wrapTypes.mjs';
 
+interface CompatibilityFlags {
+    compatibilityMode: number;
+    noLeading: boolean;
+    doNotExpandShiftReturn: boolean;
+    useWord97LineBreakRules: boolean;
+    balanceSingleByteDoubleByteWidth: boolean;
+}
+/** Public model contract rehydrated by the Rust S9 facade. */
+interface DocumentSettings {
+    defaultTabStop: number;
+    defaultTableStyle?: string;
+    themeFontLang?: {
+        eastAsia?: string;
+        bidi?: string;
+    };
+    compatibilityFlags: CompatibilityFlags;
+    updateFields?: boolean;
+    trackRevisions?: boolean;
+    doNotTrackMoves?: boolean;
+    doNotTrackFormatting?: boolean;
+    revisionView?: {
+        markup?: boolean;
+        comments?: boolean;
+        insertionsDeletions?: boolean;
+        formatting?: boolean;
+    };
+    footnotePr?: FootnoteProperties;
+    endnotePr?: EndnoteProperties;
+}
+
 /**
  * Comprehensive TypeScript types for full DOCX document representation
  *
@@ -91,12 +119,12 @@ interface DocxPackage {
  * Top-level parsed DOCX document — the result of `parseDocx(buffer)`.
  *
  * Wraps the unzipped DOCX package (`document.xml`, `styles.xml`, etc.),
- * the original buffer for round-trip saves, and any template variables /
- * parse warnings detected during ingestion.
+ * the original buffer for round-trip saves and parse warnings detected during
+ * ingestion.
  *
  * @example
  * ```ts
- * import { parseDocx } from '@betteroffice/docx/headless';
+ * import { parseDocx } from '@betteroffice/docx/docx';
  * const doc = await parseDocx(buffer);
  * console.log(doc.package.document.content.length);
  * ```
@@ -108,10 +136,8 @@ interface Document {
     package: DocxPackage;
     /** Original DOCX buffer. Kept for round-trip saves that preserve untouched parts. */
     originalBuffer?: ArrayBuffer;
-    /** Detected docxtemplater variables (e.g. `{name}`, `{address}`). Populated when the document is recognized as a template. */
-    templateVariables?: string[];
     /** Non-fatal parser diagnostics — malformed parts, unsupported features, fallbacks. */
     warnings?: string[];
 }
 
-export { BookmarkRange, Chart, ColorValue, type Document, DocumentBody, DocumentSettings, type DocxPackage, Endnote, FontTable, Footnote, HeaderFooter, MediaFile, NumberingDefinitions, RelationshipMap, StyleDefinitions, Theme };
+export { BookmarkRange, Chart, ColorValue, type CompatibilityFlags, type Document, DocumentBody, type DocumentSettings, type DocxPackage, Endnote, EndnoteProperties, FontTable, Footnote, FootnoteProperties, HeaderFooter, MediaFile, NumberingDefinitions, RelationshipMap, StyleDefinitions, Theme };