@arbidocs/blocks 0.4.100 → 0.4.102

package/node_modules/@docx-editor.dev/core/dist/collaboration.d.ts

@@ -0,0 +1,269 @@
+/**
+ * `@docx-editor.dev/core/collaboration` — provider-neutral collaboration contracts.
+ *
+ * This lane names the attachment between the canonical tree and an optional replication
+ * implementation. It performs no networking and imports no CRDT.
+ *
+ * @packageDocumentation
+ * @public
+ */
+import { S as StoryScope } from './tree-package-fragment-BeeKxDw8.js';
+import { W as TreeDocOp } from './types-barrel-D3xCgQX6.js';
+import { CollaborationDocumentPort } from './collaboration/replication.js';
+import { C as CollaborationStatus, a as CollaborationStatusSnapshot, b as CollaborationFailureCode } from './failure-NS2lsya4.js';
+export { c as CollaborationFailure, d as createCollaborationStatusTracker, i as isCollaborationFailureCode } from './failure-NS2lsya4.js';
+import './image-resources-BN-hUgCn.js';
+import './editor-scope-OHPwVQ5l.js';
+
+/**
+ * A peer's presence color is attacker-controlled: it arrives over awareness from whoever is in
+ * the room, and the engine paints it into a CSS custom property that the stylesheet consumes in
+ * a `background` shorthand. A custom property substitutes verbatim, so `url(...)` is a valid
+ * `<bg-image>` there — an unvalidated color is a zero-click GET to any host the peer names, on
+ * every replica that paints their caret. A length cap does not help: `url(//host/t)` is short.
+ *
+ * So the only colors that reach a style property are the two shapes this engine itself produces:
+ * a hex literal, or a reference to one of the review author slots the core stylesheet owns.
+ * Anything else is dropped and the caller falls back to the accent color.
+ */
+/**
+ * Return `value` when it is a color this engine can safely paint, otherwise `undefined`.
+ *
+ * @public
+ */
+declare function safeParticipantColor(value: string | undefined): string | undefined;
+
+/**
+ * `@docx-editor.dev/core/collaboration` — provider-neutral collaboration contracts.
+ *
+ * This lane names the attachment between the canonical tree and an optional replication
+ * implementation. It performs no networking and imports no CRDT.
+ *
+ * @packageDocumentation
+ * @public
+ */
+
+/** Human or automation identity attached to authored collaboration transactions. @public */
+interface CollaborationIdentity {
+    /** Stable author id, 1 to 256 characters after trimming. Recorded on authored changes. */
+    readonly actorId: string;
+    /** Display name, 1 to 256 characters after trimming. */
+    readonly name: string;
+    /** Presence color, at most 64 characters. An unsafe CSS color falls back to the accent. */
+    readonly color?: string;
+    /** `agent` for automation. Defaults to `human`. */
+    readonly role?: 'human' | 'agent';
+}
+/** One validated identity visible through ephemeral collaboration presence. @public */
+interface CollaborationParticipant extends CollaborationIdentity {
+    /** True for this replica's own participant. */
+    readonly isLocal: boolean;
+}
+/**
+ * One endpoint of a published selection: a stable paragraph id and a UTF-16 offset.
+ *
+ * The wire payload carries only these two endpoints. The receiver walks its own canonical
+ * tree to find the paragraphs between them, so a select-all does not grow with document size.
+ *
+ * @public
+ */
+interface CollaborationSelectionAddress {
+    /** The stable `w14:paraId` of the paragraph. */
+    readonly paragraphId: string;
+    /** A UTF-16 offset in the paragraph's text. */
+    readonly offset: number;
+}
+/**
+ * How a published selection covers the document.
+ *
+ * Absent or omitted means a character range. `cells` means the table rectangle whose
+ * corner cells contain the two endpoints. The payload still carries only those endpoints,
+ * so a large table selection does not grow with the number of selected cells.
+ *
+ * @public
+ */
+type CollaborationSelectionKind = 'cells';
+/**
+ * One endpoint of a remote selection resolved into this replica's canonical addresses.
+ *
+ * `paragraphId` is the stable `w14:paraId`. `nodeId` is replica-local and is used to paint.
+ *
+ * @public
+ */
+interface CollaborationRemoteSelectionAddress {
+    /** The stable `w14:paraId` of the paragraph. */
+    readonly paragraphId: string;
+    /** The paragraph's node id in this replica's editor tree. */
+    readonly nodeId: string;
+    /** A UTF-16 offset in the paragraph's text. */
+    readonly offset: number;
+}
+/**
+ * Stable remote selection resolved into this replica's canonical paragraph addresses.
+ *
+ * Anchor and head may name different paragraphs. A collapsed caret is the same address twice.
+ *
+ * @public
+ */
+interface CollaborationRemoteSelection {
+    /** The participant's `actorId`. */
+    readonly actorId: string;
+    /** The participant's display name. */
+    readonly name: string;
+    /** The participant's presence color, when it published a safe one. */
+    readonly color?: string;
+    /** Where the selection starts. */
+    readonly anchor: CollaborationRemoteSelectionAddress;
+    /** Where the selection ends: the remote caret. */
+    readonly head: CollaborationRemoteSelectionAddress;
+    /** `cells` for a table cell rectangle; absent for a character range. */
+    readonly kind?: CollaborationSelectionKind;
+}
+/**
+ * Selection published by the local editor through ephemeral awareness.
+ *
+ * Publish an anchor address and a head address. Do not materialize every covered paragraph.
+ *
+ * @public
+ */
+interface CollaborationLocalSelection {
+    /** Where the selection starts. */
+    readonly anchor: CollaborationSelectionAddress;
+    /** Where the selection ends: the caret. */
+    readonly head: CollaborationSelectionAddress;
+    /** `cells` for a table cell rectangle; absent for a character range. */
+    readonly kind?: CollaborationSelectionKind;
+}
+/**
+ * Where a collaboration session carried the local selection across the last remote change.
+ *
+ * The editor uses `to` only while its selection still equals `from`: a selection the user
+ * moved since is the user's. @public
+ */
+interface CollaborationSelectionMove {
+    /** The selection the session carried, as the editor last published it. */
+    readonly from: CollaborationEditorSelection;
+    /** Where it stands now: beside the same characters, wherever they show. */
+    readonly to: CollaborationEditorSelection;
+}
+/** A selection in this replica's editor. @public */
+interface CollaborationEditorSelection {
+    /** Where the selection starts: it stays put when the selection extends. */
+    readonly anchor: CollaborationEditorPosition;
+    /** Where the selection ends: the caret. */
+    readonly head: CollaborationEditorPosition;
+}
+/**
+ * A position in this replica's editor tree. Unlike a stable paragraph id, which a remote
+ * change can rename on one replica, a node id names one paragraph of this editor. @public
+ */
+interface CollaborationEditorPosition {
+    /** The node id of the paragraph in this replica's editor tree. */
+    readonly nodeId: string;
+    /** A UTF-16 offset in the paragraph's text. */
+    readonly offset: number;
+}
+/**
+ * Optional replication session attached to an editor or headless automation host.
+ *
+ * Implementations own replication state only. The attached document port remains the authored
+ * authority for reads, layout, paint, and save.
+ *
+ * @public
+ */
+interface EditorCollaborationSession {
+    /** The room's document id. An attached port must carry the same id. */
+    readonly documentId: string;
+    /** Unique identity for this attachment lifetime. It prevents operation ID reuse after reconnect. */
+    readonly sessionId: string;
+    /** The validated local identity. */
+    readonly identity: CollaborationIdentity;
+    /** Current lifecycle state. */
+    status(): CollaborationStatus;
+    /**
+     * Cached status, current reason, and last failure.
+     *
+     * Same reference until any of those values change. A host that mounts after a
+     * recovered error still reads {@link CollaborationStatusSnapshot.lastFailure}.
+     */
+    statusSnapshot(): CollaborationStatusSnapshot;
+    /** Call `listener` on each status or reason change. Returns the unsubscribe function. */
+    subscribeStatus(listener: (status: CollaborationStatus, reason?: CollaborationFailureCode, detail?: string) => void): () => void;
+    /**
+     * Attach the editor's document port and start replicating. Returns the detach function.
+     * A second, different port moves the session to `error` with `port-already-attached`.
+     */
+    attach(port: CollaborationDocumentPort): () => void;
+    /**
+     * Whether an editor has attached its document port to this replica.
+     *
+     * False means edits do not replicate, whatever `status()` says — the usual cause is a host
+     * that did not remount the editor when the session appeared, so `collaborationModule`
+     * never attached. That mistake used to be reachable only as a `console.warn`, which a
+     * production build discards; this is the same fact as a value a host can render.
+     */
+    readonly attached: boolean;
+    /**
+     * Check whether `ops` may commit now. Returns `null` to admit them, or the refusal code.
+     * Call it before every store transaction a custom port commits.
+     */
+    gateOperations(ops: readonly TreeDocOp[], scope: StoryScope): CollaborationFailureCode | null;
+    /** Whether the shared undo history holds a local step to undo. */
+    canUndo(): boolean;
+    /** Whether the shared undo history holds a local step to redo. */
+    canRedo(): boolean;
+    /** Undo this participant's last step; others' edits stay. Returns false when refused. */
+    undo(): boolean;
+    /** Redo this participant's last undone step. Returns false when refused. */
+    redo(): boolean;
+    /**
+     * The selection the last `undo` or `redo` restored: the one its author had before the
+     * undone change. Null when the step recorded none. Optional; a session without it leaves
+     * the editor to place the caret at the change.
+     */
+    historySelection?(): CollaborationLocalSelection | null;
+    /**
+     * Where the last remote change carried the local selection, on the shared characters
+     * beside its endpoints, and the selection it was carried from, both in the editor's
+     * paragraph node ids. Null when the session could not carry it. Optional; without it the
+     * editor maps the selection by text.
+     */
+    remoteSelectionMove?(): CollaborationSelectionMove | null;
+    /** Publish the local selection through presence. `null` clears it. */
+    setLocalSelection(selection: CollaborationLocalSelection | null): void;
+    /** Participants in presence, this replica included. Capped at 256. */
+    participants(): readonly CollaborationParticipant[];
+    /** Call `listener` when the participant list changes. Returns the unsubscribe function. */
+    subscribeParticipants(listener: (participants: readonly CollaborationParticipant[]) => void): () => void;
+    /** Other participants' selections, resolved into this replica's addresses. */
+    remoteSelections(): readonly CollaborationRemoteSelection[];
+    /** Call `listener` when a remote selection changes. Returns the unsubscribe function. */
+    subscribeRemoteSelections(listener: (selections: readonly CollaborationRemoteSelection[]) => void): () => void;
+    /**
+     * Publish queued local journals to shared state.
+     *
+     * Local typing does not wait for replication. Undo, destroy, and page hide call this
+     * so a queued journal is never dropped.
+     */
+    flushPendingJournals(): void;
+    /** Stop replicating and release listeners. The status becomes `destroyed`. */
+    destroy(): void;
+}
+/**
+ * What a collaboration module contributes: the replica the surface attaches.
+ *
+ * @public
+ */
+interface CollaborationModuleContribution {
+    /**
+     * A ready session. The host creates the Yjs room, then wraps it with
+     * `collaborationModule({ session })`.
+     *
+     * Core does not build a session from a document id: the opened package has
+     * no collaboration room identity. That identity is chosen before mount.
+     */
+    readonly session: EditorCollaborationSession;
+}
+
+export { CollaborationFailureCode, CollaborationStatus, CollaborationStatusSnapshot, safeParticipantColor };
+export type { CollaborationEditorPosition, CollaborationEditorSelection, CollaborationIdentity, CollaborationLocalSelection, CollaborationModuleContribution, CollaborationParticipant, CollaborationRemoteSelection, CollaborationRemoteSelectionAddress, CollaborationSelectionAddress, CollaborationSelectionKind, CollaborationSelectionMove, EditorCollaborationSession };

package/node_modules/@docx-editor.dev/core/dist/collaboration.js

@@ -0,0 +1 @@
+export{a as safeParticipantColor}from'./chunk-6JIJOZDW.js';var C={"already-initialized":true,"authentication-failed":true,"baseline-digest-mismatch":true,"baseline-too-large":true,"blob-digest-mismatch":true,"blob-read":true,"blob-store-full":true,"blob-too-large":true,"collaboration-format-mismatch":true,"collaboration-session-destroyed":true,"collaboration-session-not-attached":true,"collaboration-session-not-ready":true,"collaboration-text-limit":true,"concurrent-seed":true,"document-id-mismatch":true,"duplicate-paragraph-id":true,"experimental-collaboration-body-text-only":true,"experimental-collaboration-existing-paragraphs-only":true,"experimental-collaboration-text-only":true,"experimental-collaboration-untracked-text-only":true,"immutable-baseline-changed":true,"immutable-metadata-changed":true,"initialization-aborted":true,"initialization-timeout":true,"invalid-baseline":true,"invalid-blob-descriptor":true,"invalid-bound":true,"invalid-document-id":true,"invalid-identity":true,"invalid-identity-color":true,"invalid-logical-id":true,"invalid-relationships":true,"invalid-saved-room":true,"invalid-session-id":true,"invalid-shared-metadata":true,"invalid-string":true,"local-mirror-failed":true,"materialize-dropped-content":true,"missing-blob":true,"missing-local-blob":true,"missing-root":true,"no-main-document-part":true,"not-initialized":true,"paragraph-set-mismatch":true,"port-already-attached":true,"protocol-version-mismatch":true,"prototype-key":true,"remote-apply-failed":true,"room-generation-changed":true,"saved-room-unavailable":true,"schema-version-mismatch":true,"shared-schema-invalid":true,"text-too-long":true,"too-many-attributes":true,"too-many-children":true,"too-many-nodes":true,"too-many-parts":true,"too-many-relationships":true,transport:true,"transport-disconnected":true,"tree-too-deep":true,"unknown-logical-id":true,"unknown-paragraph-id":true,"unsafe-part-name":true,"unsupported-root-key":true};function g(e){return Object.hasOwn(C,e)}function f(e,o){return e===o?true:!e||!o?false:e.code===o.code&&e.detail===o.detail}function h(e,o){return Object.freeze(o!==void 0&&o.length>0?{code:e,detail:o}:{code:e})}function S(e="initializing"){let o=e,a,l,s=0,r=false,i=false,d=Object.freeze({status:o,reason:a,lastFailure:l,failureCount:s,recovering:r,waiting:i}),u=()=>{d=Object.freeze({status:o,reason:a,lastFailure:l,failureCount:s,recovering:r,waiting:i});};return {status:()=>o,snapshot:()=>d,set(t,c,p,m=false){let n=c===void 0?void 0:h(c,p),b=t==="error"&&m;return o===t&&f(a,n)&&r===b?false:(o=t,a=n,r=b,t==="error"&&n&&(l=n,s+=1),u(),true)},setWaiting(t){return i===t?false:(i=t,u(),true)}}}export{S as createCollaborationStatusTracker,g as isCollaborationFailureCode};

package/node_modules/@docx-editor.dev/core/dist/contracts/document.cjs

@@ -0,0 +1 @@
+'use strict';

package/node_modules/@docx-editor.dev/core/dist/contracts/document.d.ts

@@ -0,0 +1,290 @@
+/**
+ * `@docx-editor.dev/core/contracts/document` — the document-level edit and query vocabulary.
+ *
+ * The subset that means something without a live editor: what an automation host or an LLM tool
+ * can ask for and change.
+ *
+ * A CONTRACT module, not a barrel. `contracts/editor` builds the `Editor` command and query
+ * surfaces on top of these, so they cannot live in the package root: the root re-exports
+ * runtime from `../editor`, and a contract importing the root would invert the dependency —
+ * safe today only because that import is type-only, and one accidental value import away from
+ * pulling the painted engine into a server bundle.
+ *
+ * @packageDocumentation
+ * @public
+ */
+import { D as DocxDocument, E as ExecResult, i as ContentControlType, j as DocTarget, k as RunFormatting, l as Extent, I as InsertableContentControlType, m as ContainerRef, n as ContentControlFilter, o as DocRange, p as Revision, q as DocComment, S as StyleDefinitions } from '../types-barrel-D3xCgQX6.js';
+export { B as Block, r as ColorValue, s as ContentControl, t as DocAnchor, u as DocAnchorRange, v as DocLocation, w as DocumentBody, x as ExecErrorCode, H as HeaderFooterSet, y as IndentFormatting, P as Paragraph, z as ParagraphFlags, A as ParagraphTabStop, F as RevisionType, G as Section, J as SectionProperties, K as StyleDefinition, T as Table, L as Theme, M as ThemeColorScheme } from '../types-barrel-D3xCgQX6.js';
+import '../editor-scope-OHPwVQ5l.js';
+
+/**
+ * `@docx-editor.dev/core/contracts/document` — the document-level edit and query vocabulary.
+ *
+ * The subset that means something without a live editor: what an automation host or an LLM tool
+ * can ask for and change.
+ *
+ * A CONTRACT module, not a barrel. `contracts/editor` builds the `Editor` command and query
+ * surfaces on top of these, so they cannot live in the package root: the root re-exports
+ * runtime from `../editor`, and a contract importing the root would invert the dependency —
+ * safe today only because that import is type-only, and one accidental value import away from
+ * pulling the painted engine into a server bundle.
+ *
+ * @packageDocumentation
+ * @public
+ */
+
+/**
+ * The document-executable edit vocabulary.
+ *
+ * An interface rather than a closed union so extensions can widen it by
+ * declaration merging. A sealed union cannot be extended by a plugin, and the
+ * runtime dispatch is already registry-backed.
+ */
+interface DocEdits {
+    insertText: {
+        target: DocTarget;
+        text: string;
+    };
+    replaceText: {
+        target: DocTarget;
+        text: string;
+    };
+    deleteText: {
+        target: DocTarget;
+    };
+    applyFormatting: {
+        target: DocTarget;
+        marks: RunFormatting;
+    };
+    setParagraphStyle: {
+        target: DocTarget;
+        styleId: string;
+    };
+    insertTable: {
+        target: DocTarget;
+        rows: number;
+        cols: number;
+    };
+    insertImage: {
+        target: DocTarget;
+        data: Uint8Array;
+        extent?: Extent;
+    };
+    insertHyperlink: {
+        target: DocTarget;
+        href: string;
+        text?: string;
+    };
+    removeHyperlink: {
+        target: DocTarget;
+    };
+    /**
+     * `'section'` is Word's Next Page break; `'sectionContinuous'` keeps the new section on
+     * the sheet the previous one ended, which is how a mid-page column or margin change is
+     * authored. `'column'` belongs to the multi-column lane and is refused for now.
+     */
+    insertBreak: {
+        target: DocTarget;
+        kind: 'page' | 'column' | 'line' | 'section' | 'sectionContinuous';
+    };
+    /**
+     * Word's Increase/Decrease Indent.
+     *
+     * A numbered or bulleted paragraph changes LEVEL, so its marker re-resolves from the
+     * numbering definition — a bullet becomes a hollow circle, a `1.` becomes an `a.`.
+     * Every other paragraph moves its left indent by one default tab stop.
+     */
+    adjustIndent: {
+        target: DocTarget;
+        direction: 'increase' | 'decrease';
+    };
+    /**
+     * Word's Bullets and Numbering.
+     *
+     * Turns the selection into a list, or takes it out of one when it already is. The
+     * definition is created on first use, `numbering.xml` included.
+     */
+    toggleList: {
+        target: DocTarget;
+        kind: 'bullet' | 'ordered';
+    };
+    splitParagraph: {
+        target: DocTarget;
+    };
+    mergeParagraphs: {
+        target: DocTarget;
+    };
+    setVariable: {
+        name: string;
+        value: string;
+    };
+    applyVariables: {
+        values: Record<string, string>;
+    };
+    /**
+     * Authored family. `author` is required: tracked-ness is verb identity, not a
+     * boolean flag, so there is no global trackChanges toggle to forget.
+     */
+    proposeReplacement: {
+        target: DocTarget;
+        replaceWith: string;
+        author: string;
+    };
+    proposeInsertion: {
+        target: DocTarget;
+        text: string;
+        author: string;
+    };
+    proposeDeletion: {
+        target: DocTarget;
+        author: string;
+    };
+    addComment: {
+        target: DocTarget;
+        text: string;
+        author: string;
+    };
+    replyComment: {
+        commentId: string;
+        text: string;
+        author: string;
+    };
+    resolveComment: {
+        commentId: string;
+    };
+    acceptRevision: {
+        id: number;
+        part?: 'body' | 'footnote' | 'endnote';
+        noteId?: number;
+    };
+    rejectRevision: {
+        id: number;
+        part?: 'body' | 'footnote' | 'endnote';
+        noteId?: number;
+    };
+    acceptAllRevisions: Record<never, never>;
+    rejectAllRevisions: Record<never, never>;
+    /**
+     * Author a NEW control over the addressed span.
+     *
+     * A RANGE becomes a wrapper around the characters that are already there. A COLLAPSED
+     * position inserts an empty control showing its type's prompt, which is Word's own gesture
+     * and the one a template host reaches for: the first character typed replaces the prompt
+     * whole, so nothing has to detect and undo text the caller never asked for.
+     *
+     * `title` is Word's `w:alias` — the label a user sees — and `tag` is `w:tag`, the
+     * machine-readable identity a host looks the control back up by. Named as the automation
+     * protocol names them, so a caller who reaches for both surfaces writes one vocabulary.
+     *
+     * One paragraph only. A control that starts in one paragraph and ends in another is a BLOCK
+     * wrapper over both, a different element than the inline one this authors — refused rather
+     * than guessed, so a caller learns which they asked for.
+     */
+    insertContentControl: {
+        target: DocTarget;
+        subtype: InsertableContentControlType;
+        tag?: string;
+        title?: string;
+    };
+    setContentControlValue: {
+        target: DocTarget;
+        value: string;
+    };
+    removeContentControl: {
+        target: DocTarget;
+    };
+    addRepeatingSectionItem: {
+        target: DocTarget;
+        index?: number;
+    };
+    removeRepeatingSectionItem: {
+        target: DocTarget;
+        index: number;
+    };
+}
+/**
+ * One edit, as a discriminated union derived from {@link DocEdits}.
+ *
+ * Adding a key to `DocEdits` — including by declaration merging from a plugin — widens this
+ * automatically, so the union never drifts from the vocabulary it is built out of.
+ */
+type DocEdit = {
+    [K in keyof DocEdits]: {
+        type: K;
+    } & DocEdits[K];
+}[keyof DocEdits];
+/**
+ * What applying a batch of edits produced: the new document, and a per-edit verdict.
+ *
+ * `results` is positionally aligned with the input, so an edit that failed is identified by its
+ * index rather than by anything the caller has to correlate.
+ */
+interface ApplyResult {
+    doc: DocxDocument;
+    /** One per edit, positionally aligned with the input. */
+    results: ExecResult[];
+}
+/**
+ * The document-readable query vocabulary, keyed identically to {@link DocQueryResults}.
+ *
+ * An interface rather than a closed union for the same reason {@link DocEdits} is: an extension
+ * widens it by declaration merging, and the runtime dispatch is registry-backed.
+ */
+interface DocQueries {
+    paragraphs: {
+        container?: ContainerRef;
+    };
+    findText: {
+        text: string;
+        container?: ContainerRef;
+    };
+    contentControls: {
+        filter?: ContentControlFilter;
+    };
+    revisions: {
+        part?: 'body' | 'footnote' | 'endnote';
+    };
+    comments: {
+        resolved?: boolean;
+    };
+    styles: Record<never, never>;
+    variables: Record<never, never>;
+}
+/** One query, as a discriminated union derived from {@link DocQueries}. */
+type DocQuery = {
+    [K in keyof DocQueries]: {
+        type: K;
+    } & DocQueries[K];
+}[keyof DocQueries];
+/** What each query returns. Keyed identically to `DocQueries`. */
+interface DocQueryResults {
+    paragraphs: readonly ParagraphSummary[];
+    findText: readonly DocRange[];
+    contentControls: readonly ContentControlSummary[];
+    revisions: readonly Revision[];
+    comments: readonly DocComment[];
+    styles: StyleDefinitions;
+    variables: Readonly<Record<string, string>>;
+}
+/**
+ * A paragraph reduced to what a listing needs: its stable handle, its text, and its style.
+ *
+ * `paraId` is what a follow-up edit addresses, so a summary without one names a paragraph the
+ * file gave no `w14:paraId` and that a `DocAnchor` cannot reach.
+ */
+interface ParagraphSummary {
+    readonly paraId?: string;
+    readonly text: string;
+    readonly styleId?: string;
+}
+/** A content control reduced to what a listing needs: its identity, kind, and lock state. */
+interface ContentControlSummary {
+    readonly id: string;
+    readonly tag?: string;
+    readonly alias?: string;
+    readonly controlType: ContentControlType;
+    readonly locked?: boolean;
+}
+
+export { ContainerRef, ContentControlFilter, ContentControlType, DocComment, DocRange, DocTarget, DocxDocument, ExecResult, Extent, InsertableContentControlType, Revision, RunFormatting, StyleDefinitions };
+export type { ApplyResult, ContentControlSummary, DocEdit, DocEdits, DocQueries, DocQuery, DocQueryResults, ParagraphSummary };

package/node_modules/@docx-editor.dev/core/dist/contracts/editor.cjs

@@ -0,0 +1 @@
+'use strict';var chunkUKVVUHZL_cjs=require('../chunk-UKVVUHZL.cjs');Object.defineProperty(exports,"EditorFontError",{enumerable:true,get:function(){return chunkUKVVUHZL_cjs.a}});

package/node_modules/@docx-editor.dev/core/dist/contracts/editor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `@docx-editor.dev/core/contracts/editor` — the `Editor` contract adapters are written against.
+ *
+ * Commands go through `can` before `exec`; queries answer against the live, laid-out document.
+ * Type-only declarations let adapters name the surface without importing the engine.
+ *
+ * @packageDocumentation
+ * @public
+ */
+export { a as ReviewDisplayMode } from '../revision-projection-DZ4kKVev.js';
+import '../review-pane-D9jm8DcY.js';
+export { h as AnchorHighlightAnimation, A as AnchorHighlightOptions, L as AuthoredNoteNumbering, C as CanResult, f as ClearAnchorHighlightOptions, M as DocumentChange, N as DocumentEditingMode, O as DocumentHandle, D as DocumentSource, i as Editor, P as EditorAnchorNavigation, e as EditorCommand, Q as EditorCommandShape, U as EditorCommands, V as EditorError, W as EditorEvents, E as EditorFontError, X as EditorFontErrorCode, Y as EditorFormatPainterCommands, _ as EditorHeaderFooterCommands, $ as EditorHighlights, a0 as EditorNoteCommands, a1 as EditorPosition, a2 as EditorQueries, a3 as EditorQuery, a4 as EditorQueryResults, a5 as EditorReviewHits, a6 as EditorSelection, d as EditorSnapshot, a as FontConfiguration, F as FontFaceRequest, b as FontSource, c as FontSourceSubstitution, a7 as FormatPainterLevel, a8 as FormatPainterMode, z as FormatPainterSurfaceState, a9 as FurnitureVariant, aa as HeaderFooterSlotArgs, ab as HeaderFooterState, l as HighlightHit, k as HighlightOptions, H as HighlightRange, m as HighlightRect, j as HighlightResult, ac as HyperlinkInfo, I as ImageContext, n as ImageCropPercent, ad as NoteKind, ae as NotePropertiesSide, af as NotePropertiesState, ag as PageSetup, ah as ResolveReviewChangesOptions, ai as ResolvedNoteNumbering, aj as ReviewActivationOptions, ak as ReviewChangesAttribution, al as ReviewCommentPlacement, am as ReviewCustomPlacement, R as ReviewItemHit, an as ReviewItemPlacement, ao as ReviewItemPlacementBase, ap as ReviewItemQuery, aq as ReviewItemRevealEvent, ar as ReviewItemRevealSource, as as ReviewRevisionPlacement, g as ScrollPlacement, S as ScrollToAnchorOptions, p as SelectedImageState, at as SetReviewChangesAuthorOptions, B as TableBorderEdgeTarget, G as TableBorderSpec, J as TableBorderStyle, au as TableBorderTarget, av as TableCellVerticalAlignment, aw as TableColumnDividerResizeTarget, ax as TableColumnOccurrenceTarget, K as TableContext, ay as TableRightEdgeResizeTarget, az as TableRowOccurrenceTarget, T as TextMatch, q as TrackedChangeFilterMode, r as TrackedChangePredicate, aA as ZoomFitTarget, Z as ZoomMode } from '../editor-Ci7IZGmG.js';
+export { B as Block, r as ColorValue, C as CommentRecord, m as ContainerRef, s as ContentControl, n as ContentControlFilter, i as ContentControlType, t as DocAnchor, u as DocAnchorRange, q as DocComment, v as DocLocation, o as DocRange, j as DocTarget, w as DocumentBody, D as DocxDocument, av as DocxDocumentJSON, aw as DrawingHorizontalReferenceFrame, am as DrawingKind, ap as DrawingLocks, ao as DrawingPositionInput, ax as DrawingVerticalReferenceFrame, x as ExecErrorCode, E as ExecResult, l as Extent, ay as FontDefinition, H as HeaderFooterSet, an as ImageWrapTarget, y as IndentFormatting, I as InsertableContentControlType, az as NumberingRef, aA as PageMargins, P as Paragraph, aB as ParagraphDisagreements, z as ParagraphFlags, aq as ParagraphFormatCommand, A as ParagraphTabStop, aC as Point, as as Rect, c as ReviewCommentItem, d as ReviewCustomItem, a as ReviewItem, e as ReviewPosition, f as ReviewRange, b as ReviewRevisionItem, g as ReviewRevisionKind, p as Revision, h as RevisionAddress, a3 as RevisionAuthorResult, a6 as RevisionBatchResult, F as RevisionType, aD as Run, k as RunFormatting, G as Section, J as SectionProperties, at as SelectionPin, K as StyleDefinition, S as StyleDefinitions, T as Table, aE as TableCell, aF as TableRow, L as Theme, M as ThemeColorScheme, au as Unsubscribe, ar as Watermark } from '../types-barrel-D3xCgQX6.js';
+export { ContentControlSummary, DocEdits, DocQueries, DocQueryResults, ParagraphSummary } from './document.js';
+export { b as EditorExecOptions, E as EditorScope, H as HistoryDiagnostic, a as HistoryGroup, c as HistoryGroupOutcome, V as ViewScope } from '../editor-scope-OHPwVQ5l.js';
+export { InteractionAffinity, InteractionOutcome, InteractionOutcomeCode, SemanticIdentity, SemanticTarget } from './interaction.js';
+export { S as SemanticPosition, a as SemanticSelection } from '../semantic-interaction-CIC-PooQ.js';
+export { b as ImageResourceState, P as PreservedImageMime, R as RenderableImageMime, S as SupportedImageMime, V as ValidatedImageBytesHandle, c as VectorImageMime } from '../image-resources-BN-hUgCn.js';
+import '../document-protection-BAGVGqaP.js';
+import '../failure-NS2lsya4.js';
+import '../semantic-records-4B3WwFAi.js';
+import '../omml-equation-CuzBL5DD.js';

package/node_modules/@docx-editor.dev/core/dist/contracts/editor.js

@@ -0,0 +1 @@
+export{a as EditorFontError}from'../chunk-S6J4O5XP.js';

package/node_modules/@docx-editor.dev/core/dist/contracts/interaction.cjs

@@ -0,0 +1 @@
+'use strict';