@a3s-lab/office 0.2.2 → 0.4.0

package/dist/internal/features/work/work-document-word-line-metrics.d.ts

@@ -3,9 +3,11 @@ declare module '@tiptap/extension-text-style' {
     interface TextStyleAttributes {
         wordLineHeightFactor?: number | null;
         wordSnapToGrid?: boolean | null;
+        themeColor?: string | null;
     }
 }
 export declare function documentWordLineHeightFactor(fontFamily: unknown): number;
 export declare function normalizedDocumentWordLineHeightFactor(value: unknown): number | null;
 export declare const DocumentTextStyle: import("@tiptap/core").Mark<import("@tiptap/extension-text-style").TextStyleOptions, any>;
+export declare const DocumentHighlight: import("@tiptap/core").Mark<import("@tiptap/extension-highlight").HighlightOptions, any>;
 export declare const DocumentFontFamily: import("@tiptap/core").Extension<import("@tiptap/extension-text-style/font-family").FontFamilyOptions, any>;

package/dist/internal/features/work/work-docx-bookmark-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxBookmarksAndLinks(archive: OoxmlPackage, document: Document): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-bookmark-import.d.ts

@@ -0,0 +1,24 @@
+export interface ImportedDocxBookmarkMarkers {
+    bookmarks: ImportedDocxBookmarkMarker[];
+    references: ImportedDocxBookmarkReferenceMarker[];
+}
+interface ImportedDocxBookmarkMarker {
+    start: string;
+    end: string;
+    id: string;
+    name: string;
+    sourceName: string;
+    nativeId: number;
+}
+interface ImportedDocxBookmarkReferenceMarker {
+    start: string;
+    end: string;
+    targetId: string;
+    targetName: string;
+    instruction: string;
+    display: string;
+}
+export declare function markDocxBookmarks(document: Document): ImportedDocxBookmarkMarkers;
+export declare function applyImportedDocxBookmarkMarkers(document: Document, markers: ImportedDocxBookmarkMarkers): void;
+export declare function hasImportedDocxBookmarkMarkers(markers: ImportedDocxBookmarkMarkers): boolean;
+export {};

package/dist/internal/features/work/work-docx-bookmarks.d.ts

@@ -0,0 +1,17 @@
+import { type WorkDocumentBookmarkBoundaryKind } from './work-document-bookmarks';
+interface DocxBookmarkBoundaryPatch {
+    marker: string;
+    id: string;
+    name: string;
+    nativeId: number;
+    kind: WorkDocumentBookmarkBoundaryKind;
+}
+export declare class DocxBookmarkPatchCollector {
+    private readonly sourceHtml;
+    readonly patches: DocxBookmarkBoundaryPatch[];
+    private nextMarker;
+    constructor(sourceHtml: string);
+    register(element: HTMLElement): string | null;
+}
+export declare function patchDocxBookmarks(buffer: ArrayBuffer, patches: readonly DocxBookmarkBoundaryPatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-comment-durable-id-preservation.d.ts

@@ -0,0 +1,2 @@
+import type JSZip from 'jszip';
+export declare function preserveDocxCommentDurableIds(generated: JSZip, source: JSZip, sourcePath: string): Promise<boolean>;

package/dist/internal/features/work/work-docx-comment-export.d.ts

@@ -0,0 +1,3 @@
+import type { ICommentOptions } from 'docx';
+import type { AssignedDocxCommentThread } from './work-docx-note-comment-identity';
+export declare function createDocxCommentRecords(threads: readonly AssignedDocxCommentThread[], docx: typeof import('docx'), commentIds: Map<string, number>): ICommentOptions[];

package/dist/internal/features/work/work-docx-comment-metadata.d.ts

@@ -0,0 +1,2 @@
+import { type AssignedDocxCommentThread } from './work-docx-note-comment-identity';
+export declare function patchDocxCommentMetadata(buffer: ArrayBuffer, threads: readonly AssignedDocxCommentThread[]): Promise<ArrayBuffer>;

package/dist/internal/features/work/work-docx-drawing-extension-preservation.d.ts

@@ -0,0 +1,4 @@
+import type JSZip from 'jszip';
+import { type DocxIgnorableExtensionPair } from './work-docx-ignorable-extension-preservation';
+export declare function preserveDocxDrawingExtensions(generated: JSZip, source: JSZip, generatedPaths: readonly string[], sourcePaths: readonly string[]): Promise<void>;
+export declare function preserveDocxDrawingExtensionsAtScopes(generatedDocument: Document, sourceDocument: Document, scopes: readonly DocxIgnorableExtensionPair[]): void;

package/dist/internal/features/work/work-docx-equation-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxEquations(archive: OoxmlPackage, document: Document | null): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-equation-export.d.ts

@@ -0,0 +1,14 @@
+import { type WorkDocumentEquation } from './work-document-equations';
+interface DocxEquationPatch {
+    marker: string;
+    equation: WorkDocumentEquation;
+}
+export declare class DocxEquationPatchCollector {
+    private readonly source;
+    readonly patches: DocxEquationPatch[];
+    private nextMarker;
+    constructor(source: string);
+    marker(element: HTMLElement): string | null;
+}
+export declare function patchDocxEquations(buffer: ArrayBuffer, patches: readonly DocxEquationPatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-equation-import.d.ts

@@ -0,0 +1,30 @@
+import { type WorkDocumentEquation } from './work-document-equations';
+import { type OoxmlPackage } from './work-ooxml-package';
+export interface ImportedDocxEquationMarkers {
+    equations: ImportedDocxEquationMarker[];
+}
+export interface MarkedDocxEquationPart {
+    document: Document;
+    path: string;
+}
+export interface DocxEquationInspection {
+    equation: WorkDocumentEquation | null;
+    text: string;
+    status: 'supported' | 'unsupported' | 'spoofed';
+}
+interface ImportedDocxEquationMarker {
+    marker: string;
+    equation: WorkDocumentEquation;
+}
+export declare function markDocxPackageEquations(archive: OoxmlPackage, document: Document, existingParts?: readonly MarkedDocxEquationPart[]): Promise<{
+    markers: ImportedDocxEquationMarkers;
+    parts: MarkedDocxEquationPart[];
+    changed: boolean;
+}>;
+export declare function applyImportedDocxEquationMarkers(document: Document, markers: ImportedDocxEquationMarkers): void;
+export declare function hasImportedDocxEquationMarkers(markers: ImportedDocxEquationMarkers): boolean;
+export declare function inspectDocxEquation(element: Element): DocxEquationInspection;
+export declare function docxEquationPlainText(element: Element): string;
+export declare function isSupportedDocxEquationPlacement(element: Element): boolean;
+export declare function docxEquationHtml(element: Element): string;
+export {};

package/dist/internal/features/work/work-docx-equation-story.d.ts

@@ -0,0 +1,9 @@
+export type DocxEquationPlacement = 'inline' | 'block';
+export declare function isDocxEquationLikeRoot(element: Element): boolean;
+export declare function closestDocxEquationLikeRoot(element: Element | null): Element | null;
+export declare function docxEquationPlacement(element: Element): DocxEquationPlacement | null;
+export declare function docxEquationWordReplacement(document: Document, source: Element, text: string, placement: DocxEquationPlacement): Element;
+export declare function docxEquationWordFallbackForContext(document: Document, source: Element, text: string, placement: DocxEquationPlacement | null): Element | null;
+export declare function replaceDocxEquationTextMarker(text: Text, marker: string, replacement: HTMLElement): void;
+export declare function docxEquationTextNodes(root: ParentNode): Text[];
+export declare function escapeDocxEquationHtml(value: string): string;

package/dist/internal/features/work/work-docx-export-formatting.d.ts

@@ -1,5 +1,5 @@
 import type { TabStopDefinition } from 'docx';
-export declare function paragraphAlignment(element: HTMLElement, docx: typeof import('docx')): "right" | "left" | "center" | "both" | undefined;
+export declare function paragraphAlignment(element: HTMLElement, docx: typeof import('docx')): "center" | "right" | "left" | "both" | undefined;
 export declare function paragraphDirectionOptions(element: HTMLElement): {
     bidirectional?: boolean;
 };
@@ -18,10 +18,12 @@ export declare function paragraphIndent(element: HTMLElement, tag: string): {
     firstLine?: number;
 } | undefined;
 export declare function paragraphPaginationOptions(element: HTMLElement): {
+    outlineLevel?: number | undefined;
     keepLines: boolean | undefined;
     keepNext: boolean | undefined;
     pageBreakBefore: boolean | undefined;
     widowControl: boolean | undefined;
+    contextualSpacing: boolean | undefined;
 };
 export declare function paragraphTabStops(element: HTMLElement, docx: typeof import('docx')): TabStopDefinition[] | undefined;
 export declare function dataBoolean(value: string | undefined): boolean | undefined;

package/dist/internal/features/work/work-docx-export-image.d.ts

@@ -1,2 +1,6 @@
 import type { ParagraphChild } from 'docx';
-export declare function imageToDocx(element: HTMLImageElement, docx: typeof import('docx')): Promise<ParagraphChild>;
+import type { DocxImageCropPatchCollector } from './work-docx-image-crop';
+import type { DocxImageIdentityPatchCollector } from './work-docx-image-identity';
+import type { DocxImageLayerPatchCollector } from './work-docx-image-layer';
+import type { DocxImageWrapPatchCollector } from './work-docx-image-wrap';
+export declare function imageToDocx(element: HTMLImageElement, docx: typeof import('docx'), cropPatches?: DocxImageCropPatchCollector, wrapPatches?: DocxImageWrapPatchCollector, layerPatches?: DocxImageLayerPatchCollector, identityPatches?: DocxImageIdentityPatchCollector): Promise<ParagraphChild>;

package/dist/internal/features/work/work-docx-export.d.ts

@@ -1,2 +1,2 @@
 import type { WorkDocumentContent } from './work-types';
-export declare function createDocxBlob(content: WorkDocumentContent): Promise<Blob>;
+export declare function createDocxBlob(content: WorkDocumentContent, sourcePackage?: ArrayBuffer): Promise<Blob>;

package/dist/internal/features/work/work-docx-field-instructions.d.ts

@@ -2,7 +2,15 @@ export interface DocxFieldOccurrence {
     instruction: string;
     start: Element;
     end: Element;
+    syntax: 'simple' | 'complex' | 'orphan';
+    complete: boolean;
+    nested: boolean;
+    containsNested: boolean;
+    sameParagraph: boolean;
+    inDeletion: boolean;
 }
 export declare function docxFieldInstructions(root: ParentNode): string[];
 export declare function docxFieldOccurrences(root: ParentNode): DocxFieldOccurrence[];
+export declare function docxFieldOccurrenceIsInlineEditable(field: DocxFieldOccurrence): boolean;
+export declare function hasInvalidDocxFieldStructure(root: ParentNode): boolean;
 export declare function docxFieldResultText(field: DocxFieldOccurrence): string;

package/dist/internal/features/work/work-docx-font-table-preservation.d.ts

@@ -0,0 +1,3 @@
+import type JSZip from 'jszip';
+import type { PreservedRelationshipReference } from './work-ooxml-relationship-preservation';
+export declare function preserveDocxFontTable(generated: JSZip, source: JSZip, relationships: ReadonlyMap<string, PreservedRelationshipReference>, fontPartPaths: ReadonlySet<string>, generatedPath?: string, sourcePath?: string): Promise<void>;

package/dist/internal/features/work/work-docx-ignorable-extension-preservation.d.ts

@@ -0,0 +1,15 @@
+export declare const DOCX_WORDPROCESSING_NAMESPACES: Set<string>;
+export type DocxExtensionDocumentRole = 'generated' | 'source';
+export interface DocxIgnorableExtensionOptions {
+    semanticKey?: (element: Element, role: DocxExtensionDocumentRole) => string;
+    isAdditionalSemanticNamespace?: (namespace: string) => boolean;
+    allowExtensionNamespace?: (namespace: string) => boolean;
+    allowMatchedElementMerge?: (generated: Element, source: Element, depth: number) => boolean;
+    allowSemanticElement?: (element: Element, generatedSemanticNames: ReadonlySet<string>) => boolean;
+}
+export interface DocxIgnorableExtensionPair {
+    generated: Element;
+    source: Element;
+}
+export declare function mergeDocxIgnorableExtensions(generatedDocument: Document, sourceDocument: Document, options?: DocxIgnorableExtensionOptions): void;
+export declare function mergeDocxIgnorableExtensionsAtPairs(generatedDocument: Document, sourceDocument: Document, pairs: readonly DocxIgnorableExtensionPair[], options?: DocxIgnorableExtensionOptions): void;

package/dist/internal/features/work/work-docx-image-crop.d.ts

@@ -0,0 +1,12 @@
+import type { WorkDocumentImageCrop } from './work-document-image-layout';
+interface DocxImageCropPatch {
+    marker: string;
+    crop: WorkDocumentImageCrop;
+}
+export declare class DocxImageCropPatchCollector {
+    readonly patches: DocxImageCropPatch[];
+    private nextMarker;
+    marker(crop: WorkDocumentImageCrop | null): string;
+}
+export declare function patchDocxImageCrops(buffer: ArrayBuffer, patches: readonly DocxImageCropPatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-image-identity.d.ts

@@ -0,0 +1,17 @@
+import { type WorkDocumentImageIdentity } from './work-document-image-identity';
+interface DocxImageIdentityPatch {
+    marker: string;
+    identity: WorkDocumentImageIdentity;
+}
+export interface DocxImageIdentityRegistration {
+    marker: string;
+    docPropertiesId: number;
+}
+export declare class DocxImageIdentityPatchCollector {
+    readonly patches: DocxImageIdentityPatch[];
+    private readonly registry;
+    private nextMarker;
+    register(element: HTMLImageElement): DocxImageIdentityRegistration;
+}
+export declare function patchDocxImageIdentities(buffer: ArrayBuffer, patches: readonly DocxImageIdentityPatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-image-layer.d.ts

@@ -0,0 +1,12 @@
+import { type WorkDocumentImageLayer, type WorkDocumentImageLayout } from './work-document-image-layout';
+interface DocxImageLayerPatch {
+    marker: string;
+    layer: WorkDocumentImageLayer;
+}
+export declare class DocxImageLayerPatchCollector {
+    readonly patches: DocxImageLayerPatch[];
+    private nextMarker;
+    marker(layout: WorkDocumentImageLayout, layer: WorkDocumentImageLayer): string;
+}
+export declare function patchDocxImageLayers(buffer: ArrayBuffer, patches: readonly DocxImageLayerPatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-image-layout-import.d.ts

@@ -1,12 +1,24 @@
-import { type WorkDocumentImageLayoutOptions } from './work-document-image-layout';
+import { type WorkDocumentImageIdentity, type WorkDocumentImageIdentityRegistry } from './work-document-image-identity';
+import { type WorkDocumentImageCrop, type WorkDocumentImageLayer, type WorkDocumentImageLayoutOptions, type WorkDocumentImagePosition } from './work-document-image-layout';
+import { type WorkDocumentImageWrapContour } from './work-document-image-wrap-contour';
 export interface ImportedDocxImageLayoutMarker {
     startMarker: string;
     endMarker: string;
     options: WorkDocumentImageLayoutOptions;
+    position: WorkDocumentImagePosition | null;
+    crop: WorkDocumentImageCrop | null;
+    contour: WorkDocumentImageWrapContour | null;
+    layer: WorkDocumentImageLayer | null;
+    identity: WorkDocumentImageIdentity;
 }
 export interface ImportedDocxImageLayoutMarkers {
     images: ImportedDocxImageLayoutMarker[];
 }
-export declare function markDocxImageLayouts(document: Document): ImportedDocxImageLayoutMarkers;
+export interface ImportedDocxImageLayoutMarkerState {
+    identityRegistry: WorkDocumentImageIdentityRegistry;
+    nextMarker: number;
+}
+export declare function createImportedDocxImageLayoutMarkerState(): ImportedDocxImageLayoutMarkerState;
+export declare function markDocxImageLayouts(document: Document, state?: ImportedDocxImageLayoutMarkerState): ImportedDocxImageLayoutMarkers;
 export declare function applyImportedDocxImageLayoutMarkers(document: Document, markers: ImportedDocxImageLayoutMarkers): void;
 export declare function hasImportedDocxImageLayoutMarkers(markers: ImportedDocxImageLayoutMarkers): boolean;

package/dist/internal/features/work/work-docx-image-wrap.d.ts

@@ -0,0 +1,15 @@
+import { type WorkDocumentImageLayoutOptions } from './work-document-image-layout';
+import { type WorkDocumentImageWrapContour } from './work-document-image-wrap-contour';
+interface DocxImageWrapPatch {
+    marker: string;
+    layout: 'through' | 'tight';
+    options: WorkDocumentImageLayoutOptions;
+    contour: WorkDocumentImageWrapContour;
+}
+export declare class DocxImageWrapPatchCollector {
+    readonly patches: DocxImageWrapPatch[];
+    private nextMarker;
+    marker(options: WorkDocumentImageLayoutOptions, contour: WorkDocumentImageWrapContour | null): string;
+}
+export declare function patchDocxImageWraps(buffer: ArrayBuffer, patches: readonly DocxImageWrapPatch[]): Promise<ArrayBuffer>;
+export {};

package/dist/internal/features/work/work-docx-import.d.ts

@@ -1,14 +1,19 @@
+import { type ImportedDocxBookmarkMarkers } from './work-docx-bookmark-import';
 import { type ImportedDocxCaptionMarkers } from './work-docx-caption-import';
 import { type ImportedDocxChangeMarkers } from './work-docx-change-import';
 import { type ImportedDocxCitationMarkers } from './work-docx-citation-import';
 import { type ImportedDocxCommentMarkers } from './work-docx-comment-import';
+import { type ImportedDocxEquationMarkers } from './work-docx-equation-import';
 import { type ImportedDocxFieldMarkers } from './work-docx-field-import';
-import { type ImportedDocxListMarkers } from './work-docx-list-import';
 import { type ImportedDocxImageLayoutMarkers } from './work-docx-image-layout-import';
-import { type ImportedDocxParagraphDirectionMarkers } from './work-docx-paragraph-direction-import';
+import { type ImportedDocxListMarkers } from './work-docx-list-import';
 import { type ImportedDocxParagraphAlignmentMarkers } from './work-docx-paragraph-alignment-import';
+import { type ImportedDocxParagraphDirectionMarkers } from './work-docx-paragraph-direction-import';
+import { type ImportedDocxParagraphIdentityMarkers } from './work-docx-paragraph-identity-import';
 import { type ImportedDocxParagraphIndentMarkers } from './work-docx-paragraph-indent-import';
 import { type ImportedDocxParagraphPaginationMarkers } from './work-docx-paragraph-pagination-import';
+import { type ImportedDocxParagraphBorderMarkers } from './work-docx-paragraph-borders-import';
+import { type ImportedDocxParagraphShadingMarkers } from './work-docx-paragraph-shading-import';
 import { type ImportedDocxParagraphSpacingMarkers } from './work-docx-paragraph-spacing-import';
 import { type ImportedDocxRunFormattingMarkers } from './work-docx-run-formatting-import';
 import { type ImportedDocxParagraphTabStopMarkers } from './work-docx-tab-stop-import';
@@ -25,16 +30,21 @@ export interface PreparedDocxImport {
     }>;
     pageColor?: string;
     captionMarkers: ImportedDocxCaptionMarkers;
+    bookmarkMarkers: ImportedDocxBookmarkMarkers;
     changeMarkers: ImportedDocxChangeMarkers;
     commentMarkers: ImportedDocxCommentMarkers;
     fieldMarkers: ImportedDocxFieldMarkers;
+    equationMarkers: ImportedDocxEquationMarkers;
     citationMarkers: ImportedDocxCitationMarkers;
     listMarkers: ImportedDocxListMarkers;
     imageLayoutMarkers: ImportedDocxImageLayoutMarkers;
+    paragraphIdentityMarkers: ImportedDocxParagraphIdentityMarkers;
     paragraphAlignmentMarkers: ImportedDocxParagraphAlignmentMarkers;
     paragraphDirectionMarkers: ImportedDocxParagraphDirectionMarkers;
     paragraphIndentMarkers: ImportedDocxParagraphIndentMarkers;
     paragraphPaginationMarkers: ImportedDocxParagraphPaginationMarkers;
+    paragraphBorderMarkers: ImportedDocxParagraphBorderMarkers;
+    paragraphShadingMarkers: ImportedDocxParagraphShadingMarkers;
     paragraphSpacingMarkers: ImportedDocxParagraphSpacingMarkers;
     runFormattingMarkers: ImportedDocxRunFormattingMarkers;
     tabStopMarkers: ImportedDocxParagraphTabStopMarkers;
@@ -45,6 +55,6 @@ export interface PreparedDocxImport {
     trackChanges: boolean;
 }
 export declare function prepareDocxImport(buffer: ArrayBuffer): Promise<PreparedDocxImport>;
-export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
+export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
 export declare function readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
 export {};

package/dist/internal/features/work/work-docx-list-export.d.ts

@@ -0,0 +1,18 @@
+import type { INumberingOptions, ParagraphChild } from 'docx';
+import type { DocxSourceNumberingIdentity } from './work-docx-numbering-extension-preservation';
+import { type DocxParagraphBorderPatchCollector } from './work-docx-paragraph-borders-export';
+import type { DocxThemePatchCollector } from './work-docx-theme-reference';
+export interface DocxListExportContext {
+    numbering: Array<INumberingOptions['config'][number]>;
+    nextNumberingReference: number;
+    numberingReferences: Map<string, string>;
+    numberingLevels: Map<string, Array<INumberingOptions['config'][number]['levels'][number]>>;
+    numberingRestartRules: Array<Map<number, number>>;
+    numberingRestartRulesByIdentity: Map<string, Map<number, number>>;
+    numberingSourceIdentities: Array<DocxSourceNumberingIdentity | null>;
+    paragraphBorderPatches?: DocxParagraphBorderPatchCollector;
+    themePatches?: DocxThemePatchCollector;
+}
+type InlineRuns = (element: HTMLElement) => Promise<ParagraphChild[]>;
+export declare function listToDocxParagraphs(list: HTMLElement, docx: typeof import('docx'), context: DocxListExportContext, inlineRuns: InlineRuns, depth?: number): Promise<Array<InstanceType<typeof docx.Paragraph>>>;
+export {};

package/dist/internal/features/work/work-docx-list-import.d.ts

@@ -1,6 +1,20 @@
 export interface ImportedDocxListMarker {
     marker: string;
     start: number;
+    numberingId: number;
+    abstractNumberingId?: number;
+    level: number;
+    format?: string;
+    text?: string;
+    suffix?: string;
+    alignment?: string;
+    indentLeft?: number;
+    indentRight?: number;
+    indentStart?: number;
+    indentEnd?: number;
+    indentHanging?: number;
+    indentFirstLine?: number;
+    restartAfterLevel?: number;
     type?: ImportedDocxOrderedListType;
     bulletStyle?: ImportedDocxBulletListStyle;
 }

package/dist/internal/features/work/work-docx-note-comment-content-control-block-preservation.d.ts

@@ -0,0 +1,18 @@
+import type { DocxIgnorableExtensionPair } from './work-docx-ignorable-extension-preservation';
+import { type BlockContentControlRecord, type StaticContentBlockRecord } from './work-docx-note-comment-content-control-model';
+type NoteCommentKind = 'comment' | 'note';
+export interface BlockPlanUnit {
+    controls: BlockContentControlRecord[];
+    generated: StaticContentBlockRecord[];
+    kind: 'block';
+    source: BlockContentControlRecord;
+    targets: Element[];
+}
+export interface ContentControlAppliedPairs {
+    content: DocxIgnorableExtensionPair[];
+    runs: DocxIgnorableExtensionPair[];
+    structure: DocxIgnorableExtensionPair[];
+}
+export declare function blockCandidates(scope: Element, generated: readonly StaticContentBlockRecord[], source: readonly StaticContentBlockRecord[]): StaticContentBlockRecord[][];
+export declare function applyBlockUnit(document: Document, unit: BlockPlanUnit, assignedIds: ReadonlyMap<Element, string | null>, kind: NoteCommentKind, applied: ContentControlAppliedPairs): void;
+export {};

package/dist/internal/features/work/work-docx-note-comment-content-control-model.d.ts

@@ -0,0 +1,47 @@
+import { type StaticContentControlDefinition } from './work-docx-note-comment-content-control-properties';
+import { type StaticContentBlockRecord } from './work-docx-note-comment-content-control-table-model';
+type DocumentRole = 'generated' | 'source';
+export interface ContentControlLimits {
+    generatedCells: number;
+    generatedControls: number;
+    generatedParagraphs: number;
+    generatedRuns: number;
+    generatedTables: number;
+    sourceCells: number;
+    sourceControls: number;
+    sourceParagraphs: number;
+    sourceRuns: number;
+    sourceTables: number;
+}
+export interface StaticContentRunRecord {
+    element: Element;
+    end: number;
+    start: number;
+    text: string;
+}
+export interface InlineContentControlRecord extends StaticContentControlDefinition {
+    end: number;
+    runs: StaticContentRunRecord[];
+    start: number;
+    text: string;
+}
+export interface StaticContentParagraphRecord {
+    controls: InlineContentControlRecord[];
+    element: Element;
+    runs: StaticContentRunRecord[];
+    text: string;
+}
+export interface BlockContentControlRecord extends StaticContentControlDefinition {
+    blocks: StaticContentBlockRecord[];
+    paragraphs: StaticContentParagraphRecord[];
+}
+export type { StaticContentBlockRecord };
+export declare function createContentControlLimits(): ContentControlLimits;
+export declare function readStaticInlineParagraph(paragraph: Element, role: DocumentRole, limits: ContentControlLimits): StaticContentParagraphRecord | null;
+export declare function readStaticBlockControl(control: Element, limits: ContentControlLimits): BlockContentControlRecord | null;
+export declare function readStaticScopeBlocks(scope: Element, role: 'generated' | 'source', limits: ContentControlLimits): StaticContentBlockRecord[];
+export declare function readStaticContentBlock(element: Element, role: 'generated' | 'source', limits: ContentControlLimits): StaticContentBlockRecord | null;
+export declare function directWordParagraphs(scope: Element): Element[];
+export declare function directWordControls(scope: Element): Element[];
+export declare function staticRunSpanKey(run: StaticContentRunRecord): string;
+export declare function alignStaticRunBoundaries(paragraph: Element, boundaries: readonly number[]): boolean;

package/dist/internal/features/work/work-docx-note-comment-content-control-preservation.d.ts

@@ -0,0 +1,4 @@
+import { type DocxIgnorableExtensionPair } from './work-docx-ignorable-extension-preservation';
+type NoteCommentKind = 'comment' | 'note';
+export declare function preserveDocxNoteCommentContentControls(generatedDocument: Document, sourceDocument: Document, scopes: readonly DocxIgnorableExtensionPair[], kind: NoteCommentKind): void;
+export {};

package/dist/internal/features/work/work-docx-note-comment-content-control-properties.d.ts

@@ -0,0 +1,17 @@
+import { type DocxIgnorableExtensionPair } from './work-docx-ignorable-extension-preservation';
+export interface StaticContentControlDefinition {
+    content: Element;
+    control: Element;
+    endProperties: Element | null;
+    id: string | null;
+    multiLine: boolean;
+    properties: Element;
+    type: 'richText' | 'text';
+}
+export interface StaticContentControlShell {
+    content: Element;
+    control: Element;
+    pairs: DocxIgnorableExtensionPair[];
+}
+export declare function readStaticContentControlDefinition(control: Element): StaticContentControlDefinition | null;
+export declare function createStaticContentControlShell(document: Document, source: StaticContentControlDefinition, assignedId: string | null, targetContext: Element, kind: 'comment' | 'note'): StaticContentControlShell | null;

package/dist/internal/features/work/work-docx-note-comment-content-control-table-model.d.ts

@@ -0,0 +1,17 @@
+import type { ContentControlLimits, StaticContentParagraphRecord } from './work-docx-note-comment-content-control-model';
+type DocumentRole = 'generated' | 'source';
+interface StaticContentStructureRecord {
+    element: Element;
+    key: string;
+}
+export interface StaticContentBlockRecord {
+    element: Element;
+    extensionScopes: StaticContentStructureRecord[];
+    fingerprint: string;
+    kind: 'paragraph' | 'table';
+    paragraphs: StaticContentParagraphRecord[];
+}
+type ParagraphReader = (paragraph: Element, role: DocumentRole, limits: ContentControlLimits) => StaticContentParagraphRecord | null;
+export declare function paragraphContentBlock(paragraph: StaticContentParagraphRecord): StaticContentBlockRecord;
+export declare function readStaticTableBlock(table: Element, role: DocumentRole, limits: ContentControlLimits, readParagraph: ParagraphReader): StaticContentBlockRecord | null;
+export {};

package/dist/internal/features/work/work-docx-note-comment-content-control-xml.d.ts

@@ -0,0 +1,14 @@
+export declare const CONTENT_CONTROL_MC_NAMESPACE = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+export declare const CONTENT_CONTROL_RELATIONSHIP_NAMESPACES: Set<string>;
+export declare const CONTENT_CONTROL_WORD_2012_NAMESPACE = "http://schemas.microsoft.com/office/word/2012/wordml";
+export declare function isContentControlSemanticNamespace(namespace: string): boolean;
+export declare function isDocxWordElement(element: Element): boolean;
+export declare function wordDirectChildren(element: Element, localName: string): Element[];
+export declare function hasOnlyPassiveContentControlAttributes(element: Element): boolean;
+export declare function hasUnsupportedContentControlSemanticChild(element: Element): boolean;
+export declare function hasContentControlRelationshipReference(root: Element): boolean;
+export declare function createWordElement(document: Document, context: Element, localName: string): Element;
+export declare function createNamespacedElement(document: Document, context: Element, namespace: string, preferredPrefix: string, localName: string): Element;
+export declare function setWordContentControlAttribute(element: Element, context: Element, localName: string, value: string): void;
+export declare function setNamespacedContentControlAttribute(element: Element, context: Element, namespace: string, preferredPrefix: string, localName: string, value: string): void;
+export declare function ensureIgnorableContentControlNamespace(root: Element, namespace: string, preferredPrefix: string): void;

package/dist/internal/features/work/work-docx-note-comment-extension-preservation.d.ts

@@ -0,0 +1,2 @@
+import type JSZip from 'jszip';
+export declare function preserveDocxNoteCommentExtensions(generated: JSZip, source: JSZip): Promise<void>;

package/dist/internal/features/work/work-docx-note-comment-hyperlink-content.d.ts

@@ -0,0 +1,40 @@
+import { type DocxHyperlinkDestination, type DocxHyperlinkRelationshipState } from './work-docx-note-comment-hyperlink-relationships';
+type DocumentRole = 'generated' | 'source';
+export interface NoteCommentHyperlinkContentLimits {
+    generatedParagraphs: number;
+    generatedRuns: number;
+    sourceParagraphs: number;
+    sourceRuns: number;
+}
+export interface NoteCommentParagraphRecord {
+    element: Element;
+    hyperlinks: NoteCommentHyperlinkRecord[];
+    identity: string;
+    runs: NoteCommentRunRecord[];
+    text: string;
+}
+type ParagraphContent = Omit<NoteCommentParagraphRecord, 'element' | 'identity'>;
+export interface NoteCommentHyperlinkRecord {
+    destination: DocxHyperlinkDestination | null;
+    element: Element;
+    end: number;
+    start: number;
+    text: string;
+}
+export interface NoteCommentRunRecord {
+    container: Element | null;
+    element: Element;
+    end: number;
+    start: number;
+    text: string;
+}
+export declare function noteCommentContentParagraphs(scope: Element, role: DocumentRole, relationships: DocxHyperlinkRelationshipState, limits: NoteCommentHyperlinkContentLimits): NoteCommentParagraphRecord[];
+export declare function noteCommentParagraphContent(paragraph: Element, relationships: DocxHyperlinkRelationshipState, role: DocumentRole): ParagraphContent | null;
+export declare function groupNoteCommentParagraphs(paragraphs: readonly NoteCommentParagraphRecord[]): Map<string, NoteCommentParagraphRecord[]>;
+export declare function groupNoteCommentHyperlinks(hyperlinks: readonly NoteCommentHyperlinkRecord[]): Map<string, NoteCommentHyperlinkRecord[]>;
+export declare function noteCommentHyperlinkSpanKey(item: NoteCommentHyperlinkRecord): string;
+export declare function noteCommentHyperlinksOverlap(left: NoteCommentHyperlinkRecord, right: NoteCommentHyperlinkRecord): boolean;
+export declare function restoreElementChildren(element: Element, children: readonly Node[]): void;
+export declare function alignCommentRunBoundaries(generated: NoteCommentParagraphRecord, source: NoteCommentParagraphRecord): boolean;
+export declare function isKnownOoxmlNamespace(namespace: string): boolean;
+export {};

package/dist/internal/features/work/work-docx-note-comment-hyperlink-preservation.d.ts

@@ -0,0 +1,5 @@
+import type JSZip from 'jszip';
+import { type DocxIgnorableExtensionPair } from './work-docx-ignorable-extension-preservation';
+type NoteCommentKind = 'comment' | 'note';
+export declare function preserveDocxNoteCommentHyperlinks(generatedArchive: JSZip, sourceArchive: JSZip, generatedDocument: Document, sourceDocument: Document, scopes: readonly DocxIgnorableExtensionPair[], kind: NoteCommentKind, ownerPart: string): Promise<void>;
+export {};

package/dist/internal/features/work/work-docx-note-comment-hyperlink-relationships.d.ts

@@ -0,0 +1,35 @@
+import type JSZip from 'jszip';
+export interface DocxHyperlinkDestination {
+    kind: 'external' | 'internal';
+    relationshipId?: string;
+    target: string;
+}
+interface RelationshipRecord {
+    id: string;
+    target: string;
+    targetMode: string;
+    type: string;
+}
+interface RelationshipDocument {
+    byId: Map<string, RelationshipRecord>;
+    document: Document;
+    usedIds: Set<string>;
+}
+export interface DocxHyperlinkRelationshipState {
+    archive: JSZip;
+    dirty: boolean;
+    generated: RelationshipDocument | null;
+    generatedMalformed: boolean;
+    path: string;
+    source: RelationshipDocument | null;
+}
+export interface DocxExternalHyperlinkRequest {
+    sourceId: string;
+    target: string;
+}
+export declare function loadDocxHyperlinkRelationshipState(generatedArchive: JSZip, sourceArchive: JSZip, ownerPart: string): Promise<DocxHyperlinkRelationshipState>;
+export declare function readDocxHyperlinkDestination(hyperlink: Element, state: DocxHyperlinkRelationshipState, role: 'generated' | 'source'): DocxHyperlinkDestination | null;
+export declare function ensureDocxExternalHyperlinkRelationships(state: DocxHyperlinkRelationshipState, requests: readonly DocxExternalHyperlinkRequest[]): string[] | null;
+export declare function setDocxHyperlinkDestination(hyperlink: Element, root: Element, destination: DocxHyperlinkDestination, relationshipId?: string): boolean;
+export declare function flushDocxHyperlinkRelationships(state: DocxHyperlinkRelationshipState): void;
+export {};