@betteroffice/docx 0.0.1

package/dist/types-dYdjUZMo.d.mts

@@ -0,0 +1,311 @@
+import { Document } from './types/document.mjs';
+import { Position, Range, AgentCommand } from './types/agentApi.mjs';
+
+/**
+ * Core Plugin System Types
+ *
+ * Defines the interfaces for headless plugins that work in Node.js
+ * without React/DOM dependencies. These plugins extend DocumentAgent
+ * with additional commands and expose MCP tools for AI integration.
+ */
+
+/**
+ * Core plugin interface - headless, works in Node.js
+ *
+ * Plugins can:
+ * - Register command handlers that DocumentAgent dispatches to
+ * - Declare MCP tools that the MCP server exposes to AI clients
+ * - Have optional initialization logic
+ * - Declare dependencies on other plugins
+ */
+interface CorePlugin {
+    /** Unique plugin identifier */
+    id: string;
+    /** Human-readable plugin name */
+    name: string;
+    /** Plugin version (semver) */
+    version?: string;
+    /** Plugin description */
+    description?: string;
+    /**
+     * Command handlers this plugin provides.
+     * DocumentAgent dispatches commands to these handlers.
+     *
+     * @example
+     * ```ts
+     * commandHandlers: {
+     *   'insertTemplateVariable': (doc, cmd) => {
+     *     // Transform document
+     *     return modifiedDoc;
+     *   },
+     * }
+     * ```
+     */
+    commandHandlers?: Record<string, CommandHandler>;
+    /**
+     * MCP tools this plugin exposes.
+     * MCP server collects these from all plugins.
+     */
+    mcpTools?: McpToolDefinition[];
+    /**
+     * Optional setup when plugin is registered.
+     * Called once during plugin registration.
+     */
+    initialize?: () => void | Promise<void>;
+    /**
+     * Optional cleanup when plugin is unregistered.
+     */
+    destroy?: () => void | Promise<void>;
+    /**
+     * Dependencies on other plugins (by ID).
+     * The registry ensures dependencies are loaded first.
+     */
+    dependencies?: string[];
+}
+/**
+ * Command handler function type
+ *
+ * Receives a document and a command, returns a modified document.
+ * Must be pure/immutable - always return a new document.
+ */
+type CommandHandler = (doc: Document, command: PluginCommand) => Document;
+/**
+ * Extended command type for plugins
+ *
+ * Plugins can define custom command types beyond the built-in AgentCommand types.
+ */
+interface PluginCommand {
+    /** Command type identifier */
+    type: string;
+    /** Unique command ID (for undo tracking) */
+    id?: string;
+    /** Position for positional commands */
+    position?: Position;
+    /** Range for range-based commands */
+    range?: Range;
+    /** Additional command-specific data */
+    [key: string]: unknown;
+}
+/**
+ * Result of command execution
+ */
+interface CommandResult {
+    /** The modified document */
+    document: Document;
+    /** Whether the command succeeded */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Metadata about the operation */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * MCP tool definition
+ *
+ * Describes a tool that can be called by AI clients through the MCP server.
+ */
+interface McpToolDefinition {
+    /** Tool name (used in MCP protocol) */
+    name: string;
+    /** Human-readable description for AI */
+    description: string;
+    /**
+     * JSON Schema for tool input validation.
+     * Can be a Zod schema or plain JSON Schema object.
+     */
+    inputSchema: JsonSchema | ZodSchemaLike;
+    /**
+     * Handler function for the tool.
+     * Receives validated input and returns a result.
+     */
+    handler: McpToolHandler;
+    /**
+     * Optional annotations for the tool
+     */
+    annotations?: McpToolAnnotations;
+}
+/**
+ * MCP tool handler function
+ */
+type McpToolHandler = (input: unknown, context: McpToolContext) => Promise<McpToolResult> | McpToolResult;
+/**
+ * Context passed to MCP tool handlers
+ */
+interface McpToolContext {
+    /** Current document (if loaded) */
+    document?: Document;
+    /** Document buffer (if loaded) */
+    documentBuffer?: ArrayBuffer;
+    /** Session state */
+    session: McpSession;
+    /** Logger for debugging */
+    log: (message: string, data?: unknown) => void;
+}
+/**
+ * MCP session state
+ *
+ * Maintains state across tool calls within a session.
+ */
+interface McpSession {
+    /** Session ID */
+    id: string;
+    /** Loaded documents by ID */
+    documents: Map<string, LoadedDocument>;
+    /** Custom session data */
+    data: Map<string, unknown>;
+}
+/**
+ * A loaded document in the session
+ */
+interface LoadedDocument {
+    /** Document ID */
+    id: string;
+    /** Parsed document */
+    document: Document;
+    /** Original buffer (for repacking) */
+    buffer?: ArrayBuffer;
+    /** Source filename or path */
+    source?: string;
+    /** Last modified timestamp */
+    lastModified: number;
+}
+/**
+ * MCP tool result
+ */
+interface McpToolResult {
+    /** Result content */
+    content: McpToolContent[];
+    /** Whether this is an error result */
+    isError?: boolean;
+}
+/**
+ * MCP tool content types
+ */
+type McpToolContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    data: string;
+    mimeType: string;
+} | {
+    type: 'resource';
+    uri: string;
+    mimeType?: string;
+    text?: string;
+};
+/**
+ * MCP tool annotations
+ */
+interface McpToolAnnotations {
+    /** Tool category for organization */
+    category?: string;
+    /** Whether this tool modifies the document */
+    readOnly?: boolean;
+    /** Estimated cost/complexity */
+    complexity?: 'low' | 'medium' | 'high';
+    /** Example usage */
+    examples?: McpToolExample[];
+}
+/**
+ * MCP tool example
+ */
+interface McpToolExample {
+    /** Example description */
+    description: string;
+    /** Example input */
+    input: unknown;
+    /** Expected output description */
+    output?: string;
+}
+/**
+ * JSON Schema definition (subset)
+ */
+interface JsonSchema {
+    type?: string | string[];
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    required?: string[];
+    description?: string;
+    enum?: unknown[];
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    additionalProperties?: boolean | JsonSchema;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    allOf?: JsonSchema[];
+    $ref?: string;
+}
+/**
+ * Zod-like schema interface for compatibility
+ */
+interface ZodSchemaLike {
+    _def?: unknown;
+    parse?: (data: unknown) => unknown;
+    safeParse?: (data: unknown) => {
+        success: boolean;
+        data?: unknown;
+        error?: unknown;
+    };
+}
+/**
+ * Check if a schema is Zod-like
+ */
+declare function isZodSchema(schema: unknown): schema is ZodSchemaLike;
+/**
+ * Plugin lifecycle events
+ */
+type PluginEvent = {
+    type: 'registered';
+    plugin: CorePlugin;
+} | {
+    type: 'unregistered';
+    pluginId: string;
+} | {
+    type: 'error';
+    pluginId: string;
+    error: Error;
+};
+/**
+ * Plugin event listener
+ */
+type PluginEventListener = (event: PluginEvent) => void;
+/**
+ * Extract command type from a union
+ */
+type ExtractCommand<T extends AgentCommand, Type extends string> = T extends {
+    type: Type;
+} ? T : never;
+/**
+ * Create a typed command handler
+ */
+type TypedCommandHandler<T extends PluginCommand> = (doc: Document, command: T) => Document;
+/**
+ * Plugin configuration options
+ */
+interface PluginOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom configuration */
+    config?: Record<string, unknown>;
+}
+/**
+ * Result of plugin registration
+ */
+interface PluginRegistrationResult {
+    /** Whether registration succeeded */
+    success: boolean;
+    /** Registered plugin (if successful) */
+    plugin?: CorePlugin;
+    /** Error message (if failed) */
+    error?: string;
+    /** Warning messages */
+    warnings?: string[];
+}
+
+export { type CommandHandler as C, type ExtractCommand as E, type JsonSchema as J, type LoadedDocument as L, type McpSession as M, type PluginCommand as P, type TypedCommandHandler as T, type ZodSchemaLike as Z, type CommandResult as a, type CorePlugin as b, type McpToolAnnotations as c, type McpToolContent as d, type McpToolContext as e, type McpToolDefinition as f, type McpToolHandler as g, type McpToolResult as h, type PluginEvent as i, type PluginEventListener as j, type PluginOptions as k, type PluginRegistrationResult as l, isZodSchema as m, type McpToolExample as n };

package/dist/units-O5Y02RKQ.d.mts

@@ -0,0 +1,34 @@
+/**
+ * Pixels per inch at standard DPI
+ *
+ * @public
+ */
+declare const PIXELS_PER_INCH = 96;
+/**
+ * Convert EMUs to pixels (at 96 DPI)
+ *
+ * 1 inch = 914400 EMUs = 96 pixels
+ * Returns 0 for null/undefined/NaN inputs.
+ *
+ * @public
+ */
+declare function emuToPixels(emu: number | undefined | null): number;
+/**
+ * Convert pixels to EMUs.
+ * EMU coordinates in OOXML are integer-typed (xs:long); rounding here keeps
+ * floating-point drift (e.g. 52 px → 495299.99999999994) out of the document.
+ *
+ * @public
+ */
+declare function pixelsToEmu(px: number): number;
+/**
+ * Convert points to pixels (at 96 DPI)
+ *
+ * 1 inch = 72 points = 96 pixels
+ * → 1 point = 96/72 pixels = 4/3 pixels
+ *
+ * @public
+ */
+declare function pointsToPixels(points: number): number;
+
+export { PIXELS_PER_INCH as P, pointsToPixels as a, emuToPixels as e, pixelsToEmu as p };

package/dist/utils/autoScroll.d.mts

@@ -0,0 +1,24 @@
+/**
+ * Drag auto-scroll geometry shared by the React and Vue adapters.
+ *
+ * When the user drag-selects and the pointer nears the top/bottom edge of the
+ * scroll container, the container should auto-scroll at a speed proportional to
+ * how deep into the edge zone the pointer is. The per-frame loop and the
+ * framework wiring stay in each adapter's hook; this is just the pure delta.
+ */
+/** Pixel distance from the container edge where auto-scroll activates. */
+declare const AUTO_SCROLL_EDGE_ZONE = 40;
+/** Maximum scroll speed in pixels per frame (~60fps). */
+declare const AUTO_SCROLL_MAX_SPEED = 12;
+/**
+ * Vertical scroll delta (px/frame) for a pointer at `mouseY` over a container
+ * whose viewport spans `rect.top`..`rect.bottom`. Negative scrolls up, positive
+ * down, 0 when the pointer is outside both edge zones. Speed ramps linearly
+ * from 0 at the edge-zone boundary to `AUTO_SCROLL_MAX_SPEED` at the edge.
+ */
+declare function computeAutoScrollDelta(rect: {
+    top: number;
+    bottom: number;
+}, mouseY: number): number;
+
+export { AUTO_SCROLL_EDGE_ZONE, AUTO_SCROLL_MAX_SPEED, computeAutoScrollDelta };

package/dist/utils/autoScroll.mjs

@@ -0,0 +1 @@
+import'../chunk-TTRUPDAB.mjs';var o=40,A=12;function S(_,E){if(E<_.top+40){let O=Math.max(0,_.top+40-E);return -Math.min(12,O/40*12)}if(E>_.bottom-40){let O=Math.max(0,E-(_.bottom-40));return Math.min(12,O/40*12)}return 0}export{o as AUTO_SCROLL_EDGE_ZONE,A as AUTO_SCROLL_MAX_SPEED,S as computeAutoScrollDelta};

package/dist/utils/cardStyles.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Tiny shared CSSProperties shape so framework-agnostic style
+ * objects in core don't need to import from React or Vue. Both
+ * adapters' `CSSProperties` types are structurally compatible
+ * with this looser shape (string | number values, camelCased keys).
+ */
+type CSSProperties = Record<string, string | number | undefined>;
+
+/**
+ * Sidebar card chrome — shared between React and Vue. Numeric
+ * pixel values rather than `'8px'` strings so both adapters'
+ * CSSProperties shapes accept them. Lifted from
+ * `packages/docx-react/src/components/sidebar/cardStyles.ts` and the
+ * Vue mirror so there's one canonical table.
+ * @packageDocumentation
+ * @public
+ */
+
+declare const CARD_STYLE_COLLAPSED: CSSProperties;
+declare const CARD_STYLE_EXPANDED: CSSProperties;
+
+export { CARD_STYLE_COLLAPSED, CARD_STYLE_EXPANDED };

package/dist/utils/cardStyles.mjs

@@ -0,0 +1 @@
+import'../chunk-TTRUPDAB.mjs';var d={padding:"8px 10px",borderRadius:8,backgroundColor:"var(--doc-card)",cursor:"pointer",boxShadow:"var(--doc-card-shadow)"},a={padding:"10px 12px",borderRadius:8,backgroundColor:"var(--doc-surface)",cursor:"pointer",boxShadow:"var(--doc-card-shadow-strong)"};export{d as CARD_STYLE_COLLAPSED,a as CARD_STYLE_EXPANDED};

package/dist/utils/comments.d.mts

@@ -0,0 +1,120 @@
+import { P as Paragraph, B as BlockContent, C as Comment } from '../content-sSHuWw49.mjs';
+import '../formatting-DoL7KBSL.mjs';
+import '../docx/wrapTypes.mjs';
+
+/**
+ * Framework-agnostic comment + tracked-change helpers shared by the
+ * React and Vue adapters. The data shapes and string-formatting rules
+ * here are part of the visible UI (avatar colors, date strings) so
+ * keep this file as the single source of truth — both adapters import
+ * from here. CSS-property factories live in adapter-specific files
+ * (sidebar/cardUtils.ts in React, sidebar/sidebarUtils.ts in Vue).
+ * @packageDocumentation
+ * @public
+ */
+
+/** Extract plain text from a Comment's paragraph content. */
+declare function getCommentText(paragraphs?: Paragraph[] | BlockContent[]): string;
+/** Extract text from the richest available comment body projection. */
+declare function getRichCommentText(comment: Pick<Comment, 'content' | 'blockContent'>): string;
+declare function formatDate(dateStr?: string): string;
+declare function getInitials(name: string): string;
+declare function getAvatarColor(name: string): string;
+/** Prefer an authored reviewer color/palette assignment over name hashing. */
+declare function getReviewColor(reviewer: {
+    name?: string;
+    color?: string;
+    paletteIndex?: number;
+} | undefined): string;
+/** Stable id shared by mirror anchors and framework comment cards. */
+declare function getCommentSemanticId(commentId: string | number): string;
+declare function truncateText(text: string, maxLength?: number): string;
+/**
+ * One tracked change surfaced by `extractTrackedChanges`. Each entry
+ * groups all sites of one revision into a single row that the sidebar
+ * renders as one card. Resolve via {@link acceptChangeById} /
+ * {@link rejectChangeById} for any type — the by-id resolver walks
+ * every site sharing the id so coalesced edits clear in one click.
+ *
+ * @public
+ */
+interface TrackedChangeEntry {
+    /**
+     * Revision shape. Inline shapes (`insertion`, `deletion`, `replacement`)
+     * wrap text runs; the rest are structural revisions on node attrs.
+     *
+     * - `insertion` — text was added (`<w:ins>`).
+     * - `deletion` — text was struck through but not removed (`<w:del>`).
+     * - `replacement` — a deletion + insertion by the same author at the
+     *   same position+time; sidebar shows one combined card. `deletedText`
+     *   and `insertionRevisionId` are set on this variant.
+     * - `paragraphMarkInsertion` / `paragraphMarkDeletion` — Enter /
+     *   Backspace produced a tracked paragraph break (`<w:pPr><w:rPr><w:ins/>` /
+     *   `<w:del/>`).
+     * - `paragraphPropertiesChanged` — formatting (alignment, spacing,
+     *   etc.) on the paragraph was changed (`<w:pPrChange>`).
+     * - `rowInserted` / `rowDeleted` / `rowPropertiesChanged` — table
+     *   row authored / removed / formatted (`<w:trPr><w:ins/>` / `<w:del/>`
+     *   / `<w:trPrChange>`).
+     * - `cellInserted` / `cellDeleted` / `cellMerged` /
+     *   `cellPropertiesChanged` — per-cell revisions
+     *   (`<w:cellIns>` / `<w:cellDel>` / `<w:cellMerge>` / `<w:tcPrChange>`).
+     * - `tablePropertiesChanged` — table-level formatting
+     *   (`<w:tblPrChange>`).
+     */
+    type: 'insertion' | 'deletion' | 'replacement' | 'paragraphMarkInsertion' | 'paragraphMarkDeletion' | 'paragraphPropertiesChanged' | 'rowInserted' | 'rowDeleted' | 'rowPropertiesChanged' | 'cellInserted' | 'cellDeleted' | 'cellMerged' | 'cellPropertiesChanged' | 'tableInserted' | 'tableDeleted' | 'tablePropertiesChanged';
+    /**
+     * Affected text. For inline types this is the run's text; for
+     * structural types it's the surrounding paragraph / cell content
+     * (truncated by the sidebar before display).
+     */
+    text: string;
+    /**
+     * Only set when `type === 'replacement'` — the text the user removed.
+     * The inserted text lives in {@link TrackedChangeEntry.text}.
+     */
+    deletedText?: string;
+    /** Author that minted the revision (`w:author`). */
+    author: string;
+    /** ISO timestamp the revision was minted (`w:date`). May be undefined for legacy imports. */
+    date?: string;
+    /**
+     * Document position where the revision starts. For inline types this
+     * is the start of the marked text run; for structural types it's the
+     * containing paragraph / row / cell / table node's start position.
+     * Used by the sidebar to anchor the card at the correct vertical
+     * offset.
+     */
+    from: number;
+    /**
+     * Document position where the revision ends. For inline coalesced
+     * runs that span multiple paragraphs, this is the END position of the
+     * LAST run in the group; the intervening structural positions are not
+     * preserved.
+     */
+    to: number;
+    /**
+     * The `w:id` of the revision. Pass to
+     * {@link acceptChangeById} / {@link rejectChangeById} to resolve every
+     * site sharing this id — including pPrIns paragraph attrs and
+     * subsequent typed runs in the same editing session.
+     */
+    revisionId: number;
+    /**
+     * Only set when `type === 'replacement'` — the insertion half carries
+     * a DIFFERENT `w:id` from the deletion (sharing would trip the OOXML
+     * move-pair serializer). Card Accept handlers dispatch BOTH ids to
+     * clear the deletion and the insertion + any coalesced paragraph-marks.
+     */
+    insertionRevisionId?: number;
+    /**
+     * Extra `w:id`s that map to the same logical revision as this card.
+     * Populated when the extractor coalesces a burst of distinct ids by
+     * (author, date) — e.g. a foreign document where the source editor
+     * minted a fresh id per atomic edit. Accept/reject handlers must
+     * resolve every id in this list in addition to {@link revisionId}.
+     */
+    coalescedRevisionIds?: number[];
+}
+
+export { type TrackedChangeEntry, formatDate, getAvatarColor, getCommentSemanticId, getCommentText, getInitials, getReviewColor, getRichCommentText, truncateText };

package/dist/utils/comments.mjs

@@ -0,0 +1,4 @@
+import'../chunk-TTRUPDAB.mjs';function i(e){return n(e).trim()}function u(e){return i(e.blockContent?.length?e.blockContent:e.content)}function n(e){if(e==null)return "";if(Array.isArray(e))return e.map(n).join("");if(typeof e!="object")return "";let t=e;switch(t.type){case "text":return typeof t.text=="string"?t.text:"";case "tab":return "	";case "break":return `
+`;case "softHyphen":return "\xAD";case "noBreakHyphen":return "\u2011";case "symbol":return typeof t.char=="string"?t.char:"";case "paragraph":return `${n(t.content)}
+`;case "run":case "inlineSdt":case "blockSdt":return n(t.content);case "hyperlink":return n(t.structuredChildren??t.children);case "simpleField":{let r=t.structuredResult;return n(r?.inline??r?.blocks??t.content)}case "complexField":{let r=t.structuredResult;return n(r?.inline??r?.blocks??t.fieldResult)}case "table":return n(t.rows);case "tableRow":return `${t.cells?.map(n).join("	")??""}
+`;case "tableCell":return n(t.content).trimEnd();default:return ""}}function l(e){if(!e)return "";let t=new Date(e);return Number.isNaN(t.getTime())?"":t.toLocaleString(void 0,{hour:"numeric",minute:"2-digit",month:"short",day:"numeric"})}function d(e){return e.split(/\s+/).map(t=>t[0]).join("").toUpperCase().slice(0,2)}var o=["#6DCCB1","#79AAD9","#EE789D","#A987D1","#E6A85F","#F2CC8F","#68B3A2","#B07AA1","#59A14F","#FF9DA7","#E15759","#76B7B2"];function s(e){let t=0;for(let r=0;r<e.length;r++)t=e.charCodeAt(r)+((t<<5)-t);return o[Math.abs(t)%o.length]}function g(e){if(e?.color)return e.color;if(e?.paletteIndex!==void 0){let t=(e.paletteIndex%o.length+o.length)%o.length;return o[t]}return s(e?.name??"")}function p(e){return `oox-comment-${String(e).replace(/[^a-zA-Z0-9_-]/g,"-")}`}function h(e,t=50){return e.length>t?e.slice(0,t)+"...":e}export{l as formatDate,s as getAvatarColor,p as getCommentSemanticId,i as getCommentText,d as getInitials,g as getReviewColor,u as getRichCommentText,h as truncateText};

package/dist/utils/findReplace.d.mts

@@ -0,0 +1,114 @@
+/**
+ * Find & Replace Utility Functions
+ *
+ * Pure utility functions for text search, pattern matching, and
+ * document search. Lifted from packages/docx-react/src/components/dialogs/
+ * findReplaceUtils.ts so the React adapter and the Vue adapter share
+ * one implementation.
+ * @packageDocumentation
+ * @public
+ */
+/**
+ * A single match result in the document
+ */
+interface FindMatch {
+    /** Index of the paragraph containing the match */
+    paragraphIndex: number;
+    /** Index of the run/content within the paragraph */
+    contentIndex: number;
+    /** Character offset within the content */
+    startOffset: number;
+    /** Character offset for end of match */
+    endOffset: number;
+    /** The matched text */
+    text: string;
+}
+/**
+ * Find options for controlling search behavior
+ */
+interface FindOptions {
+    /** Whether to match case */
+    matchCase: boolean;
+    /** Whether to match whole words only */
+    matchWholeWord: boolean;
+    /** Whether to use regular expressions (future) */
+    useRegex?: boolean;
+}
+/**
+ * Find result with all matches
+ */
+interface FindResult {
+    /** All matches found */
+    matches: FindMatch[];
+    /** Total match count */
+    totalCount: number;
+    /** Current match index (0-based) */
+    currentIndex: number;
+}
+/**
+ * Highlight options for document rendering
+ */
+interface HighlightOptions {
+    /** Background color for current match */
+    currentMatchColor: string;
+    /** Background color for other matches */
+    otherMatchColor: string;
+}
+/**
+ * Create default find options
+ */
+declare function createDefaultFindOptions(): FindOptions;
+/**
+ * Escape string for use in regex pattern
+ */
+declare function escapeRegexString(str: string): string;
+/**
+ * Create a regex pattern from search text and options
+ */
+declare function createSearchPattern(searchText: string, options: FindOptions): RegExp | null;
+/**
+ * Find all matches of search text in content
+ */
+declare function findAllMatches(content: string, searchText: string, options: FindOptions): Array<{
+    start: number;
+    end: number;
+}>;
+/**
+ * Replace text in content
+ */
+declare function replaceAllInContent(content: string, searchText: string, replaceText: string, options: FindOptions): string;
+/**
+ * Replace first match in content
+ */
+declare function replaceFirstInContent(content: string, searchText: string, replaceText: string, options: FindOptions, startIndex?: number): {
+    content: string;
+    replaced: boolean;
+    matchStart: number;
+    matchEnd: number;
+};
+/**
+ * Get match count for status display
+ */
+declare function getMatchCountText(result: FindResult | null): string;
+/**
+ * Check if search text is empty or whitespace-only
+ */
+declare function isEmptySearch(searchText: string): boolean;
+/**
+ * Get default highlight options
+ */
+declare function getDefaultHighlightOptions(): HighlightOptions;
+/**
+ * Find all matches in a document
+ */
+declare function findInDocument(document: any, searchText: string, options: FindOptions): FindMatch[];
+/**
+ * Find matches in a single paragraph
+ */
+declare function findInParagraph(paragraph: any, searchText: string, options: FindOptions, paragraphIndex: number): FindMatch[];
+/**
+ * Scroll to a match in the document
+ */
+declare function scrollToMatch(containerElement: HTMLElement | null, match: FindMatch): void;
+
+export { type FindMatch, type FindOptions, type FindResult, type HighlightOptions, createDefaultFindOptions, createSearchPattern, escapeRegexString, findAllMatches, findInDocument, findInParagraph, getDefaultHighlightOptions, getMatchCountText, isEmptySearch, replaceAllInContent, replaceFirstInContent, scrollToMatch };

package/dist/utils/findReplace.mjs

@@ -0,0 +1,2 @@
+import'../chunk-TTRUPDAB.mjs';function F(){return {matchCase:false,matchWholeWord:false,useRegex:false}}function g(t){return t.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function p(t,e){if(!t)return null;try{let n;e.useRegex?n=t:n=g(t),e.matchWholeWord&&(n=`\\b${n}\\b`);let r=e.matchCase?"g":"gi";return new RegExp(n,r)}catch{return null}}function l(t,e,n){if(!t||!e)return [];let r=[],o=e;n.matchCase||(o=e.toLowerCase());let c=h=>h.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),i;n.matchWholeWord?i=`\\b${c(o)}\\b`:i=c(o);let a=n.matchCase?"g":"gi",s=new RegExp(i,a),f;for(;(f=s.exec(t))!==null;)r.push({start:f.index,end:f.index+f[0].length}),f[0].length===0&&s.lastIndex++;return r}function y(t,e,n,r){let o=p(e,r);return o?t.replace(o,n):t}function C(t,e,n,r,o=0){let c=l(t,e,r),i=c.find(s=>s.start>=o)||c[0];return i?{content:t.substring(0,i.start)+n+t.substring(i.end),replaced:true,matchStart:i.start,matchEnd:i.start+n.length}:{content:t,replaced:false,matchStart:-1,matchEnd:-1}}function M(t){return t?t.totalCount===0?"No results":t.totalCount===1?"1 match":`${t.currentIndex+1} of ${t.totalCount} matches`:""}function O(t){return !t||t.trim()===""}function R(){return {currentMatchColor:"#FFFF00",otherMatchColor:"#FFFFAA"}}function u(t){if(!t||!t.content)return "";let e="";for(let n of t.content)n.type==="text"?e+=n.text||"":n.type==="tab"?e+="	":n.type==="break"&&n.breakType==="textWrapping"&&(e+=`
+`);return e}function d(t){if(!t||!t.content)return "";let e="";for(let n of t.content)if(n.type==="run")e+=u(n);else if(n.type==="hyperlink")for(let r of n.children||[])r.type==="run"&&(e+=u(r));return e}function E(t,e,n){if(!t||!e)return [];let r=[],o=t.package?.document||t.package?.document;if(!o||!o.content)return r;let c=0;for(let i of o.content)if(i.type==="paragraph"){let a=x(i,e,n,c);r.push(...a),c++;}else if(i.type==="table")for(let a of i.rows||[])for(let s of a.cells||[])for(let f of s.content||[])f.type;return r}function x(t,e,n,r){let o=[],c=d(t);if(!c)return o;let i=l(c,e,n);for(let a of i){let s=m(t,a.start);o.push({paragraphIndex:r,contentIndex:s.contentIndex,startOffset:s.offsetInContent,endOffset:s.offsetInContent+(a.end-a.start),text:c.substring(a.start,a.end)});}return o}function m(t,e){if(!t||!t.content)return {contentIndex:0,runIndex:0,offsetInContent:e};let n=0,r=0;for(let o of t.content){let c="";if(o.type==="run")c=u(o);else if(o.type==="hyperlink")for(let a of o.children||[])a.type==="run"&&(c+=u(a));let i=c.length;if(n+i>e)return {contentIndex:r,runIndex:r,offsetInContent:e-n};n+=i,r++;}return {contentIndex:Math.max(0,t.content.length-1),runIndex:Math.max(0,t.content.length-1),offsetInContent:0}}function w(t,e){if(!t||!e)return;let n=t.querySelector(`[data-paragraph-index="${e.paragraphIndex}"]`);n&&n.scrollIntoView({behavior:"smooth",block:"center"});}export{F as createDefaultFindOptions,p as createSearchPattern,g as escapeRegexString,l as findAllMatches,E as findInDocument,x as findInParagraph,R as getDefaultHighlightOptions,M as getMatchCountText,O as isEmptySearch,y as replaceAllInContent,C as replaceFirstInContent,w as scrollToMatch};

package/dist/utils/findVerticalScrollParent.d.mts

@@ -0,0 +1,25 @@
+/**
+ * Pure DOM helpers — locate the element that vertically scrolls the
+ * paginated editor. Lifted from packages/docx-react/src/paged-editor/
+ * findVerticalScrollParent.ts so both adapters use the same logic
+ * for scroll-to-position, arrow-key line navigation, and drag
+ * auto-scroll.
+ * @packageDocumentation
+ * @public
+ */
+/**
+ * First ancestor of `el` with `overflow-y: auto|scroll` and a scrollable
+ * overflow height. Walk starts at `el.parentElement` (does not treat
+ * `el` itself as the scroller).
+ *
+ * @returns `null` when no such ancestor exists before `document.documentElement`.
+ */
+declare function findVerticalScrollParent(el: HTMLElement): HTMLElement | null;
+/**
+ * Same as {@link findVerticalScrollParent} but falls back to
+ * `document.documentElement` so callers always get a valid scroll
+ * target (matches legacy `scrollIntoView` root).
+ */
+declare function findVerticalScrollParentOrRoot(el: HTMLElement): HTMLElement;
+
+export { findVerticalScrollParent, findVerticalScrollParentOrRoot };

package/dist/utils/findVerticalScrollParent.mjs

@@ -0,0 +1 @@
+import'../chunk-TTRUPDAB.mjs';function l(t){let e=t.parentElement;for(;e&&e!==document.documentElement;){let{overflowY:n}=getComputedStyle(e);if((n==="auto"||n==="scroll")&&e.scrollHeight>e.clientHeight+1)return e;e=e.parentElement;}return null}function c(t){return l(t)??document.documentElement}export{l as findVerticalScrollParent,c as findVerticalScrollParentOrRoot};