@betteroffice/docx 0.0.1

package/dist/measureBlocksPipeline-Df0Bbrwy.d.mts

@@ -0,0 +1,109 @@
+import { W as WrapTextDirection, i as PageGeometry, e as LayoutBlock, B as BlockExtent } from './types-DNrYr6yQ.mjs';
+
+/**
+ * Clamp floating-wrap margins so at least a usable strip of the line
+ * remains. Unchecked margins from near-full-width tables/images can exceed
+ * contentWidth and collapse every line to ~1 glyph (the "single character
+ * per line after a wide floating table" bug).
+ *
+ * Returned margins are zeroed when:
+ * - either side alone is >= contentWidth (no strip on that side at all), or
+ * - their sum is >= contentWidth (no strip exists between the two sides).
+ */
+declare function clampFloatingWrapMargins(leftMargin: number, rightMargin: number, contentWidth: number): {
+    leftMargin: number;
+    rightMargin: number;
+};
+interface FloatingExclusionRect {
+    /** which margin absorbs the exclusion when wrapText alone doesn't pick a side. */
+    side: 'left' | 'right';
+    /** object's left edge in content-area px. */
+    x: number;
+    /** object's top edge in content-area px. */
+    y: number;
+    width: number;
+    height: number;
+    distTop: number;
+    distBottom: number;
+    distLeft: number;
+    distRight: number;
+    wrapText?: WrapTextDirection;
+    wrapType?: string;
+}
+interface FloatingImageZone {
+    leftMargin: number;
+    rightMargin: number;
+    topY: number;
+    bottomY: number;
+    segments?: FloatingLineSegmentZone[];
+    /**
+     * Full-width vertical band (OOXML `topAndBottom` wrap): no text fits beside
+     * it, so any line overlapping `[topY, bottomY]` is pushed below the band.
+     */
+    fullWidthBlock?: boolean;
+}
+interface FloatingLineSegmentZone {
+    leftOffset: number;
+    availableWidth: number;
+}
+interface FloatingLineMargins {
+    leftMargin: number;
+    rightMargin: number;
+    segments?: FloatingLineSegmentZone[];
+}
+declare function rectsToFloatingZones(rects: FloatingExclusionRect[], contentWidth: number): FloatingImageZone[];
+declare function getFloatingMargins(lineY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, paragraphYOffset: number): FloatingLineMargins;
+
+/**
+ * Floating-aware block measurement pipeline.
+ *
+ * Pre-scans a block list to extract exclusion zones from anchored images,
+ * floating tables, and floating text boxes; groups co-located floats so
+ * their combined exclusion applies starting from the earliest anchor; then
+ * walks the blocks calling the caller-supplied `measureBlock` with the
+ * active zones and cumulative Y at each step.
+ *
+ * Adapters (React, Vue) provide their own `measureBlock` so they can
+ * decide e.g. whether to cache paragraph measures. The orchestration,
+ * extraction, and grouping live here so both adapters stay in lockstep.
+ *
+ * @packageDocumentation
+ * @public
+ */
+
+/**
+ * Block-measurement callback shape passed to {@link measureBlocksWithFloats}.
+ * Adapters (React, Vue) supply this so they can decide platform-specific
+ * concerns (e.g. paragraph-measure caching, per-section width) while
+ * sharing the floating-zone orchestration. This is adapter-author API,
+ * not end-consumer API.
+ *
+ * @public
+ */
+type MeasureBlockFn = (block: LayoutBlock, contentWidth: number, floatingZones?: FloatingImageZone[], cumulativeY?: number) => BlockExtent;
+/**
+ * Page geometry (CSS px) used to resolve page/margin-relative anchored objects
+ * into content-area coordinates — currently the vertical anchor of a top-pinned
+ * `topAndBottom` band. Same shape the painter uses (see `pageGeometryFromPage`),
+ * so both paths resolve to identical positions.
+ *
+ * @public
+ */
+type FloatPageGeometry = PageGeometry;
+/**
+ * Walk `blocks` and produce one `BlockExtent` per block. Before measuring, this
+ * extracts floating exclusion zones (images / floating tables / floating
+ * textboxes), groups overlapping co-located floats, and threads the active
+ * zones plus cumulative Y into each `measureBlock` call.
+ *
+ * Pass `pageGeometry` whenever the document may contain page/margin-anchored
+ * `topAndBottom` text boxes (e.g. a title banner pinned to the page top):
+ * without it their reserved band falls back to flow-relative Y and the band
+ * won't line up with where the painter places the box. Build it with the
+ * shared `pageGeometryFromPage` helper.
+ *
+ * @public
+ */
+declare function measureBlocksWithFloats(blocks: LayoutBlock[], contentWidth: number | number[], measureBlock: MeasureBlockFn, pageGeometry?: FloatPageGeometry): BlockExtent[];
+
+export { type FloatPageGeometry as F, type MeasureBlockFn as M, type FloatingExclusionRect as a, type FloatingImageZone as b, type FloatingLineSegmentZone as c, clampFloatingWrapMargins as d, getFloatingMargins as g, measureBlocksWithFloats as m, rectsToFloatingZones as r };

package/dist/measuredBlock-DZwz8zhD.d.mts

@@ -0,0 +1,26 @@
+import { e as LayoutBlock, B as BlockExtent } from './types-DNrYr6yQ.mjs';
+
+/**
+ * The colocated block+measure unit consumed by the paginator.
+ */
+
+/**
+ * A flow block paired with its measurement. The paginator consumes
+ * `MeasuredBlock[]` instead of two parallel `LayoutBlock[]` + `BlockExtent[]`
+ * arrays kept in lockstep by index — colocating the pair makes a misaligned
+ * block/measure unrepresentable.
+ * @public
+ */
+type MeasuredBlock = {
+    block: LayoutBlock;
+    measure: BlockExtent;
+};
+/**
+ * Zip aligned `blocks` and `measures` into `MeasuredBlock[]`. This is the one
+ * place a length assumption is localized — the pervasive per-index coupling it
+ * replaces is what the measured-block model removes.
+ * @public
+ */
+declare function toMeasuredBlocks(blocks: LayoutBlock[], measures: BlockExtent[]): MeasuredBlock[];
+
+export { type MeasuredBlock as M, toMeasuredBlocks as t };

package/dist/plugin-api/RenderedDomContext.d.mts

@@ -0,0 +1,114 @@
+import { RenderedDomContext, PositionCoordinates } from './types.mjs';
+import { D as DisplayListRect, a as DisplayListQueries } from '../displayListQueries-p-ijSzdh.mjs';
+import '../types/document.mjs';
+import '../content-sSHuWw49.mjs';
+import '../formatting-DoL7KBSL.mjs';
+import '../docx/wrapTypes.mjs';
+import '../styles-VxNcXLdi.mjs';
+import '../settingsParser-CcGvtmCK.mjs';
+import '../rustDisplayList-dqunvwxH.mjs';
+import '../types-DNrYr6yQ.mjs';
+import '../measuredBlock-DZwz8zhD.mjs';
+
+/**
+ * RenderedDomContext Implementation
+ *
+ * Provides position mapping over the canvas renderer's output. Geometry is
+ * served by the Rust display-list queries when available; DOM fallbacks read
+ * the accessibility mirror's data-doc-start/data-doc-end span contract.
+ * @packageDocumentation
+ * @public
+ */
+
+/**
+ * Options controlling how a {@link RenderedDomContextImpl} resolves geometry.
+ *
+ * @public
+ */
+interface RenderedDomContextOptions {
+    /** Immutable display-list query source. Omit for the mirror-DOM backend. */
+    displayListQueries?: DisplayListQueries;
+    /** Page-local display-list geometry → pages-container coordinates. */
+    projector?: DisplayListPageProjector;
+}
+interface ProjectedDisplayListRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Canvas-host projection contract kept separate from document geometry. */
+interface DisplayListPageProjector {
+    projectRect(rect: DisplayListRect): ProjectedDisplayListRect | null;
+    getPageBounds(pageIndex: number): ProjectedDisplayListRect | null;
+}
+/**
+ * Project through the live canvas for each page. Reading its client rect is a
+ * host-coordinate transform only; document geometry stays display-list-owned.
+ */
+declare function createCanvasHostProjector(pagesContainer: HTMLElement, queries: DisplayListQueries, zoom?: number): DisplayListPageProjector;
+/**
+ * Implementation of RenderedDomContext.
+ *
+ * This class provides position mapping between display-list document
+ * positions and pixel coordinates in the rendered output. Geometry comes
+ * from the Rust display-list queries; the DOM fallbacks use the
+ * data-doc-start and data-doc-end attributes the accessibility mirror
+ * emits (see {@link RenderedDomContextOptions}).
+ */
+declare class RenderedDomContextImpl implements RenderedDomContext {
+    pagesContainer: HTMLElement;
+    zoom: number;
+    private readonly queries;
+    private readonly projector;
+    constructor(pagesContainer: HTMLElement, zoom?: number, options?: RenderedDomContextOptions);
+    /**
+     * Run spans (`data-doc-start`/`data-doc-end`) in reading order, deep-queried
+     * from the a11y mirror subtree nested under `.canvas-pages`.
+     */
+    private spanEntries;
+    /** Empty-paragraph runs, deep-queried from the a11y mirror. */
+    private emptyRuns;
+    /**
+     * Get pixel coordinates for a display position.
+     * Uses the browser's text rendering via Range API for precise positioning.
+     */
+    getCoordinatesForPosition(position: number): PositionCoordinates | null;
+    /**
+     * Find DOM elements that overlap with a display-position range.
+     */
+    findElementsForRange(from: number, to: number): Element[];
+    /**
+     * Get bounding rectangles for a range of text.
+     * Handles line wraps by returning multiple rects.
+     */
+    getRectsForRange(from: number, to: number): Array<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    getCoordinatesForHfPosition(region: 'header' | 'footer', rId: string, position: number, pageIndex: number): PositionCoordinates | null;
+    getRectsForHfRange(region: 'header' | 'footer', rId: string, from: number, to: number, pageIndex: number): ProjectedDisplayListRect[];
+    getPageBounds(pageIndex: number): ProjectedDisplayListRect | null;
+    /**
+     * Get the offset of the pages container from its parent viewport.
+     * This is needed for positioning overlays that are rendered in the
+     * viewport container rather than directly in the pages container.
+     */
+    getContainerOffset(): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Create a RenderedDomContext for a pages container element.
+ *
+ * @param pagesContainer - The `.canvas-pages` host holding the rendered pages
+ * @param zoom - Current zoom level (default 1)
+ * @param options - query/projector backend options. Omit for the mirror-DOM
+ *   fallback.
+ */
+declare function createRenderedDomContext(pagesContainer: HTMLElement, zoom?: number, options?: RenderedDomContextOptions): RenderedDomContext;
+
+export { type DisplayListPageProjector, type ProjectedDisplayListRect, RenderedDomContextImpl, type RenderedDomContextOptions, createCanvasHostProjector, createRenderedDomContext };

package/dist/plugin-api/RenderedDomContext.mjs

@@ -0,0 +1 @@
+import {a}from'../chunk-WRWRCBLK.mjs';import {b}from'../chunk-TTRUPDAB.mjs';function E(h,n,s=1){let t=s>0?s:1,o=e=>{let r=n.pageSize(e.pageIndex),i=a(h,n,e.pageIndex);if(!i||!r||r.width<=0||r.height<=0)return null;let a$1=h.getBoundingClientRect(),c=i.width/r.width,u=i.height/r.height;return {x:(i.left-a$1.left+e.x*c)/t,y:(i.top-a$1.top+e.y*u)/t,width:e.width*c/t,height:e.height*u/t}};return {projectRect:o,getPageBounds:e=>{let r=n.pageBounds(e);return r?o(r):null}}}var f=class{constructor(n,s=1,t){b(this,"pagesContainer");b(this,"zoom");b(this,"queries");b(this,"projector");if(this.pagesContainer=n,this.zoom=s,this.queries=t?.displayListQueries??null,this.projector=t?.projector??null,this.queries===null!=(this.projector===null))throw new Error("RenderedDomContext requires displayListQueries and projector together")}spanEntries(){let n=[],s=Array.from(this.pagesContainer.querySelectorAll(".layout-page-content")),t=s.length>0?s:[this.pagesContainer];for(let o of t)for(let e of Array.from(o.querySelectorAll("span[data-doc-start][data-doc-end]")))n.push({el:e,start:Number(e.dataset.docStart),end:Number(e.dataset.docEnd)});return n}emptyRuns(){return Array.from(this.pagesContainer.querySelectorAll(".layout-empty-run"))}getCoordinatesForPosition(n){if(this.queries&&this.projector){let t=this.queries.caretRect(n),o=t?this.projector.projectRect(t):null;return o?{x:o.x,y:o.y,height:o.height}:null}let s=this.pagesContainer.getBoundingClientRect();for(let{el:t,start:o,end:e}of this.spanEntries()){let r=t;if(t.classList.contains("layout-run-tab")){if(n>=o&&n<e){let i=t.getBoundingClientRect(),a=t.closest(".layout-line"),c=a?a.offsetHeight:16;return {x:(i.left-s.left)/this.zoom,y:(i.top-s.top)/this.zoom,height:c/this.zoom}}continue}if(n>=o&&n<=e&&r.firstChild?.nodeType===Node.TEXT_NODE){let i=r.firstChild,a=Math.min(n-o,i.length),c=t.ownerDocument;if(!c)continue;let u=c.createRange();u.setStart(i,a),u.setEnd(i,a);let p=u.getBoundingClientRect(),d=t.closest(".layout-line"),l=d?d.offsetHeight:16;return {x:(p.left-s.left)/this.zoom,y:(p.top-s.top)/this.zoom,height:l/this.zoom}}}for(let t of this.emptyRuns()){let o=t.closest(".layout-paragraph");if(!o)continue;let e=Number(o.dataset.docStart),r=Number(o.dataset.docEnd);if(n>=e&&n<=r){let i=t.getBoundingClientRect(),a=t.closest(".layout-line"),c=a?a.offsetHeight:16;return {x:(i.left-s.left)/this.zoom,y:(i.top-s.top)/this.zoom,height:c/this.zoom}}}return null}findElementsForRange(n,s){let t=[];for(let{el:o,start:e,end:r}of this.spanEntries())r>n&&e<s&&t.push(o);return t}getRectsForRange(n,s){if(this.queries&&this.projector)return this.queries.rangeRects(n,s).map(e=>this.projector.projectRect(e)).filter(e=>e!==null);let t=this.pagesContainer.getBoundingClientRect(),o=[];for(let{el:e,start:r,end:i}of this.spanEntries()){let a=e;if(i>n&&r<s){if(e.classList.contains("layout-run-tab")){let l=e.getBoundingClientRect();o.push({x:(l.left-t.left)/this.zoom,y:(l.top-t.top)/this.zoom,width:l.width/this.zoom,height:l.height/this.zoom});continue}if(a.firstChild?.nodeType!==Node.TEXT_NODE)continue;let c=a.firstChild,u=e.ownerDocument;if(!u)continue;let p=Math.max(0,n-r),d=Math.min(c.length,s-r);if(p<d){let l=u.createRange();l.setStart(c,p),l.setEnd(c,d);let R=l.getClientRects();for(let m of Array.from(R))o.push({x:(m.left-t.left)/this.zoom,y:(m.top-t.top)/this.zoom,width:m.width/this.zoom,height:m.height/this.zoom});}}}return o}getCoordinatesForHfPosition(n,s,t,o){if(!this.queries||!this.projector)return null;let e=this.queries.hfCaretRects(n,s,t).find(i=>i.pageIndex===o),r=e?this.projector.projectRect(e):null;return r?{x:r.x,y:r.y,height:r.height}:null}getRectsForHfRange(n,s,t,o,e){return !this.queries||!this.projector?[]:this.queries.hfRangeRects(n,s,t,o).filter(r=>r.pageIndex===e).map(r=>this.projector.projectRect(r)).filter(r=>r!==null)}getPageBounds(n){if(this.projector)return this.projector.getPageBounds(n);let s=this.pagesContainer.querySelectorAll(".layout-page"),t=Array.from(s).find((r,i)=>Number(r.dataset.pageIndex??i)===n);if(!t)return null;let o=t.getBoundingClientRect(),e=this.pagesContainer.getBoundingClientRect();return {x:(o.left-e.left)/this.zoom,y:(o.top-e.top)/this.zoom,width:o.width/this.zoom,height:o.height/this.zoom}}getContainerOffset(){let n=this.pagesContainer.parentElement;if(!n)return {x:0,y:0};let s=this.pagesContainer.getBoundingClientRect(),t=n.getBoundingClientRect();return {x:(s.left-t.left)/this.zoom,y:(s.top-t.top)/this.zoom}}};function L(h,n=1,s){return new f(h,n,s)}export{f as RenderedDomContextImpl,E as createCanvasHostProjector,L as createRenderedDomContext};

package/dist/plugin-api/index.d.mts

@@ -0,0 +1,7 @@
+export { EditorPluginCore, PanelConfig, PluginPanelProps, PositionCoordinates, RenderedDomContext, SidebarItem, SidebarItemContext } from './types.mjs';
+import '../types/document.mjs';
+import '../content-sSHuWw49.mjs';
+import '../formatting-DoL7KBSL.mjs';
+import '../docx/wrapTypes.mjs';
+import '../styles-VxNcXLdi.mjs';
+import '../settingsParser-CcGvtmCK.mjs';

package/dist/plugin-api/resolveItemPositions.d.mts

@@ -0,0 +1,39 @@
+import { SidebarItem, RenderedDomContext } from './types.mjs';
+import '../types/document.mjs';
+import '../content-sSHuWw49.mjs';
+import '../formatting-DoL7KBSL.mjs';
+import '../docx/wrapTypes.mjs';
+import '../styles-VxNcXLdi.mjs';
+import '../settingsParser-CcGvtmCK.mjs';
+
+/**
+ * Pure layout algorithm: given a list of sidebar items + their
+ * anchor sources, return a list of resolved Y positions with
+ * collision avoidance applied. Lifted from React's
+ * components/sidebar/resolveItemPositions.ts so the Vue adapter
+ * can call it directly.
+ *
+ * The algorithm walks the items in three priority stages:
+ *   1. explicit fixedY (already in scroll-container coords)
+ *   2. anchorKey lookup in anchorPositions (layout/pagination coords)
+ *   3. DOM-based anchor lookup via renderedDomContext.getRectsForRange
+ *   4. last-known cache so cards don't pop out during transient layout
+ *
+ * Then it sorts by target Y and pushes overlapping cards down by
+ * their height + MIN_CARD_GAP.
+ * @packageDocumentation
+ * @public
+ */
+
+/** Generic sidebar item with optional fixedY / estimatedHeight. */
+interface ResolvableSidebarItem extends SidebarItem {
+    fixedY?: number;
+    estimatedHeight?: number;
+}
+interface ResolvedPosition<T extends ResolvableSidebarItem = ResolvableSidebarItem> {
+    item: T;
+    y: number;
+}
+declare function resolveItemPositions<T extends ResolvableSidebarItem>(items: T[], anchorPositions: Map<string, number>, renderedDomContext: RenderedDomContext | null, zoom: number, cardHeights: Map<string, number>, lastKnown: Map<string, number>): ResolvedPosition<T>[];
+
+export { type ResolvableSidebarItem, type ResolvedPosition, resolveItemPositions };

package/dist/plugin-api/resolveItemPositions.mjs

@@ -0,0 +1 @@
+import'../chunk-YUOKI2HB.mjs';import'../chunk-TTRUPDAB.mjs';function p(s,u,n,r,d,l){if(s.length===0)return [];let a=n?.getContainerOffset(),o=[];for(let e of s){let t;if(e.fixedY!=null&&(t=e.fixedY*r),t==null&&e.anchorKey){let i=u.get(e.anchorKey);i!=null&&(t=i*r);}if(t==null&&n){let i=n.getRectsForRange(e.anchorPos,e.anchorPos+1);i.length>0&&a&&(t=(i[0].y+a.y)*r);}if(t==null){let i=l.get(e.id);i!=null&&(t=i);}t!=null&&(o.push({item:e,targetY:t}),l.set(e.id,t));}o.sort((e,t)=>{let i=e.targetY-t.targetY;return i!==0?i:(e.item.priority??0)-(t.item.priority??0)});let m=[],f=0;for(let e of o){let t=d.get(e.item.id)??e.item.estimatedHeight??80,i=Math.max(e.targetY,f+8);m.push({item:e.item,y:i}),f=i+t;}return m}export{p as resolveItemPositions};

package/dist/plugin-api/types.d.mts

@@ -0,0 +1,193 @@
+import { Document } from '../types/document.mjs';
+import '../content-sSHuWw49.mjs';
+import '../formatting-DoL7KBSL.mjs';
+import '../docx/wrapTypes.mjs';
+import '../styles-VxNcXLdi.mjs';
+import '../settingsParser-CcGvtmCK.mjs';
+
+/**
+ * Framework-Agnostic Plugin Interface for the DOCX Editor
+ *
+ * Core plugin types that can be used by any framework (React, Vue, etc.).
+ * Framework-specific adapters extend EditorPluginCore with their own
+ * UI rendering capabilities (e.g., ReactEditorPlugin, VueEditorPlugin).
+ * @packageDocumentation
+ * @public
+ */
+
+/**
+ * Coordinates returned by position lookup in the rendered DOM.
+ */
+interface PositionCoordinates {
+    x: number;
+    y: number;
+    height: number;
+}
+/**
+ * Context for accessing rendered-page geometry in the paged editor.
+ *
+ * Provides position mapping over the canvas renderer's output (Rust
+ * display-list queries, with the accessibility mirror's DOM as fallback).
+ * Use this for rendering overlays, annotations, and other visual elements
+ * positioned relative to rendered content.
+ *
+ * The mirror DOM uses data-doc-start/data-doc-end attributes on spans
+ * to map between display positions and DOM elements.
+ */
+interface RenderedDomContext {
+    /** The container element holding all rendered pages. */
+    pagesContainer: HTMLElement;
+    /**
+     * Get pixel coordinates for a display position in the rendered DOM.
+     * Returns null if the position cannot be found.
+     */
+    getCoordinatesForPosition(position: number): PositionCoordinates | null;
+    /**
+     * Find DOM elements that overlap with a display-position range.
+     */
+    findElementsForRange(from: number, to: number): Element[];
+    /**
+     * Get bounding rectangles for a range of text, accounting for line wraps.
+     * Returns rects relative to the pages container.
+     */
+    getRectsForRange(from: number, to: number): Array<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    /** Query-backed caret coordinates for one explicit header/footer page. */
+    getCoordinatesForHfPosition(region: 'header' | 'footer', rId: string, position: number, pageIndex: number): PositionCoordinates | null;
+    /** Query-backed range rectangles for one explicit header/footer page. */
+    getRectsForHfRange(region: 'header' | 'footer', rId: string, from: number, to: number, pageIndex: number): Array<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    /** Bounds of one rendered page relative to the pages container. */
+    getPageBounds(pageIndex: number): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /** Current zoom level (1 = 100%). */
+    zoom: number;
+    /**
+     * Offset of the pages container from its parent viewport.
+     */
+    getContainerOffset(): {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Props passed to plugin panel components (framework-agnostic base).
+ */
+interface PluginPanelProps<TState = unknown> {
+    /** Current serializer-facing document snapshot. */
+    document: Document | null;
+    /** Scroll editor to a specific position */
+    scrollToPosition: (pos: number) => void;
+    /** Select a range in the editor */
+    selectRange: (from: number, to: number) => void;
+    /** Plugin-specific state (managed by the plugin) */
+    pluginState: TState;
+    /** Width of the panel in pixels */
+    panelWidth: number;
+    /**
+     * Context for the rendered pages (canvas renderer output).
+     * May be null if layout hasn't completed yet.
+     */
+    renderedDomContext: RenderedDomContext | null;
+}
+/**
+ * Configuration for plugin panel rendering.
+ */
+interface PanelConfig {
+    /** Where to render the panel */
+    position: 'left' | 'right' | 'bottom';
+    /** Default width/height of the panel */
+    defaultSize: number;
+    /** Minimum size */
+    minSize?: number;
+    /** Maximum size */
+    maxSize?: number;
+    /** Whether the panel is resizable */
+    resizable?: boolean;
+    /** Whether the panel can be collapsed */
+    collapsible?: boolean;
+    /** Initial collapsed state */
+    defaultCollapsed?: boolean;
+}
+/**
+ * Framework-agnostic core plugin interface.
+ *
+ * Contains all non-UI plugin capabilities:
+ * - State management (initialize, onStateChange, destroy)
+ * - CSS injection
+ * - Panel configuration
+ *
+ * Framework adapters (ReactEditorPlugin, VueEditorPlugin) extend this
+ * with their own Panel component type and renderOverlay function.
+ */
+interface EditorPluginCore<TState = any> {
+    /** Unique plugin identifier */
+    id: string;
+    /** Display name for the plugin */
+    name: string;
+    /**
+     * Configuration for the panel (position, size, etc.)
+     */
+    panelConfig?: PanelConfig;
+    /**
+     * Called when the projected document changes.
+     * Use this to update plugin-specific state based on document changes.
+     */
+    onStateChange?: (document: Document) => TState | undefined;
+    /**
+     * Initialize plugin state when the plugin is first loaded.
+     */
+    initialize?: (document: Document | null) => TState;
+    /**
+     * Called when the plugin is being destroyed.
+     * Use this for cleanup (subscriptions, timers, etc.)
+     */
+    destroy?: () => void;
+    /**
+     * CSS styles to inject for this plugin.
+     * Can be a string of CSS or a URL to a stylesheet.
+     */
+    styles?: string;
+}
+/**
+ * A sidebar item anchored to a document position.
+ * Framework adapters extend this with rendering capabilities.
+ */
+interface SidebarItem {
+    /** Unique ID for this item (used as React key and for overlap resolution). */
+    id: string;
+    /** Display position this item anchors to. */
+    anchorPos: number;
+    /** Optional key into the anchorPositions Map (e.g. "comment-42", "revision-7"). */
+    anchorKey?: string;
+    /** Sort priority within items at the same anchor Y. Lower = first. Default: 0. */
+    priority?: number;
+    /** Temporary items (e.g. "add comment" input) skip entrance animation. */
+    isTemporary?: boolean;
+    /** Pre-computed Y position (scroll-container coords, pre-zoom). Overrides anchor resolution. */
+    fixedY?: number;
+}
+/**
+ * Context provided to plugins when computing sidebar items.
+ */
+interface SidebarItemContext {
+    document: Document | null;
+    renderedDomContext: RenderedDomContext | null;
+    /** Pre-computed Y positions from layout engine (keys like "comment-{id}"). */
+    anchorPositions: Map<string, number>;
+    zoom: number;
+}
+
+export type { EditorPluginCore, PanelConfig, PluginPanelProps, PositionCoordinates, RenderedDomContext, SidebarItem, SidebarItemContext };

package/dist/processTemplate-HDUIZFJ5.mjs

@@ -0,0 +1 @@
+export{j as createTemplateProcessor,k as default,g as getMissingVariables,e as getTemplateTags,h as previewTemplate,a as processTemplate,i as processTemplateAdvanced,d as processTemplateAndDownload,c as processTemplateAsBlob,b as processTemplateDetailed,f as validateTemplate}from'./chunk-O2QSE2I7.mjs';import'./chunk-TTRUPDAB.mjs';

package/dist/registry-DMM5VTdT.d.mts

@@ -0,0 +1,165 @@
+import { b as CorePlugin, k as PluginOptions, l as PluginRegistrationResult, C as CommandHandler, f as McpToolDefinition, j as PluginEventListener } from './types-dYdjUZMo.mjs';
+
+/**
+ * Plugin Registry
+ *
+ * Central registry for core plugins. Manages plugin lifecycle,
+ * collects command handlers from all plugins, and aggregates
+ * MCP tool definitions for the MCP server.
+ */
+
+/**
+ * Plugin Registry - manages core plugins
+ *
+ * @example
+ * ```ts
+ * import { pluginRegistry, docxtemplaterPlugin } from '@betteroffice/docx/core-plugins';
+ *
+ * // Register plugins
+ * pluginRegistry.register(docxtemplaterPlugin);
+ *
+ * // Get all MCP tools for MCP server
+ * const tools = pluginRegistry.getMcpTools();
+ *
+ * // Get command handler for executor
+ * const handler = pluginRegistry.getCommandHandler('insertTemplateVariable');
+ * ```
+ */
+declare class PluginRegistry {
+    private plugins;
+    private commandHandlers;
+    private eventListeners;
+    private initialized;
+    /**
+     * Register a plugin
+     *
+     * @param plugin - The plugin to register
+     * @param options - Optional configuration
+     * @returns Registration result
+     */
+    register(plugin: CorePlugin, options?: PluginOptions): PluginRegistrationResult;
+    /**
+     * Unregister a plugin
+     *
+     * @param pluginId - ID of the plugin to unregister
+     * @returns Whether unregistration succeeded
+     */
+    unregister(pluginId: string): boolean;
+    /**
+     * Get a registered plugin by ID
+     *
+     * @param id - Plugin ID
+     * @returns The plugin or undefined
+     */
+    get(id: string): CorePlugin | undefined;
+    /**
+     * Get all registered plugins
+     *
+     * @returns Array of all plugins
+     */
+    getAll(): CorePlugin[];
+    /**
+     * Check if a plugin is registered
+     *
+     * @param id - Plugin ID
+     * @returns Whether the plugin is registered
+     */
+    has(id: string): boolean;
+    /**
+     * Get number of registered plugins
+     */
+    get size(): number;
+    /**
+     * Get a command handler for a command type
+     *
+     * @param commandType - The command type
+     * @returns The handler or undefined
+     */
+    getCommandHandler(commandType: string): CommandHandler | undefined;
+    /**
+     * Get all registered command types
+     *
+     * @returns Array of command type strings
+     */
+    getCommandTypes(): string[];
+    /**
+     * Check if a command type has a handler
+     *
+     * @param commandType - The command type
+     * @returns Whether a handler exists
+     */
+    hasCommandHandler(commandType: string): boolean;
+    /**
+     * Get all MCP tools from all registered plugins
+     *
+     * @returns Array of MCP tool definitions
+     */
+    getMcpTools(): McpToolDefinition[];
+    /**
+     * Get MCP tools from a specific plugin
+     *
+     * @param pluginId - Plugin ID
+     * @returns Array of MCP tool definitions
+     */
+    getMcpToolsForPlugin(pluginId: string): McpToolDefinition[];
+    /**
+     * Get an MCP tool by name
+     *
+     * @param toolName - Tool name
+     * @returns The tool definition or undefined
+     */
+    getMcpTool(toolName: string): McpToolDefinition | undefined;
+    /**
+     * Add an event listener
+     *
+     * @param listener - Event listener function
+     */
+    addEventListener(listener: PluginEventListener): void;
+    /**
+     * Remove an event listener
+     *
+     * @param listener - Event listener function
+     */
+    removeEventListener(listener: PluginEventListener): void;
+    /**
+     * Emit an event to all listeners
+     */
+    private emit;
+    /**
+     * Clear all registered plugins
+     *
+     * Useful for testing or resetting state.
+     */
+    clear(): void;
+    /**
+     * Get registry state for debugging
+     */
+    getDebugInfo(): {
+        plugins: string[];
+        commandTypes: string[];
+        mcpTools: string[];
+        initialized: string[];
+    };
+}
+/**
+ * Global plugin registry instance
+ *
+ * Use this for registering plugins and accessing their capabilities.
+ */
+declare const pluginRegistry: PluginRegistry;
+/**
+ * Register multiple plugins at once
+ *
+ * @param plugins - Array of plugins to register
+ * @returns Array of registration results
+ */
+declare function registerPlugins(plugins: CorePlugin[], options?: PluginOptions): PluginRegistrationResult[];
+/**
+ * Create a plugin registration helper with options pre-configured
+ *
+ * @param options - Default options for plugin registration
+ * @returns Registration function
+ */
+declare function createPluginRegistrar(options: PluginOptions): (plugin: CorePlugin) => PluginRegistrationResult;
+
+export { PluginRegistry as P, createPluginRegistrar as c, pluginRegistry as p, registerPlugins as r };