myrole-docx-editor 0.1.0

package/dist/types/packages/docx-editor/src/inspector.d.ts

@@ -0,0 +1,101 @@
+import { type DocxDocument } from '../../docx-model/src/index';
+import type { LineTrace } from '../../docx-render/src/index';
+export interface InspectorData {
+    /** Métadonnées du document */
+    meta: {
+        title?: string;
+        author?: string;
+        lastModifiedBy?: string;
+        created?: string;
+        modified?: string;
+        revision?: string;
+        application?: string;
+    };
+    /** Mise en page */
+    page: {
+        widthPt: number;
+        heightPt: number;
+        marginTopPt: number;
+        marginRightPt: number;
+        marginBottomPt: number;
+        marginLeftPt: number;
+        orient?: string;
+        columns?: number;
+        columnGapPt?: number;
+        defaultFont?: string;
+        defaultSizePt?: number;
+    };
+    /** Sections */
+    sections: Array<{
+        index: number;
+        widthPt: number;
+        heightPt: number;
+        marginsPt: {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+        columns: number;
+        orient?: string;
+    }>;
+    /** Statistiques */
+    stats: {
+        paragraphs: number;
+        runs: number;
+        characters: number;
+        words: number;
+        lineBreaks: number;
+        tables: number;
+        images: number;
+        comments: number;
+        bookmarks: number;
+        hyperlinks: number;
+        embeddedFonts: number;
+        xmlParts: number;
+        binParts: number;
+    };
+    /** Polices */
+    fonts: {
+        embedded: Array<{
+            family: string;
+            style: string;
+            sizeKB: number;
+        }>;
+        used: Array<{
+            family: string;
+            runs: number;
+            percent: number;
+        }>;
+    };
+    /** Assets binaires */
+    assets: Array<{
+        path: string;
+        type: string;
+        sizeKB: number;
+    }>;
+    /** Commentaires Word */
+    comments: Array<{
+        id: string;
+        author: string;
+        date?: string;
+        text: string;
+        paragraphs?: number[];
+    }>;
+    /** Tags de template ({{ }} et {% %}) */
+    tags: Array<{
+        paragraph: number;
+        raw: string;
+        kind: string;
+    }>;
+    /** Positions des lignes dessinées (depuis onLine) */
+    lines?: LineTrace[];
+    /** Blocs du body */
+    blocks: Array<{
+        type: string;
+        index: number;
+        sectionIndex: number;
+        details?: string;
+    }>;
+}
+export declare function inspect(doc: DocxDocument, lines?: LineTrace[]): InspectorData;

package/dist/types/packages/docx-editor/src/react.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The React face of the SDK.
+ *
+ *   <DocxEditor src={file} onSave={(bytes) => upload(bytes)} style={{ height: '100vh' }} />
+ *
+ * The component owns one `createDocxEditor` for its lifetime; `src` changes
+ * reload the document in place, every other option is read at mount. React is
+ * an optional peer: nothing here runs unless `myrole-docx-editor/react` is
+ * imported.
+ */
+import { type CSSProperties } from 'react';
+import { type DocxEditorHandle, type DocxEditorOptions } from './sdk';
+export interface DocxEditorProps extends Omit<DocxEditorOptions, 'onReady'> {
+    /** the document: bytes, a Blob/File, or a URL */
+    src?: ArrayBuffer | Uint8Array | Blob | string;
+    className?: string;
+    style?: CSSProperties;
+    /** the handle, once mounted */
+    onReady?: (editor: DocxEditorHandle) => void;
+}
+export declare const DocxEditor: import("react").ForwardRefExoticComponent<DocxEditorProps & import("react").RefAttributes<DocxEditorHandle | null>>;
+/** A ref to hand to `<DocxEditor ref={…}>`, and the handle once it exists. */
+export declare function useDocxEditor(): import("react").RefObject<DocxEditorHandle | null>;
+export type { DocxEditorHandle, DocxEditorOptions } from './sdk';

package/dist/types/packages/docx-editor/src/ruler.d.ts

@@ -0,0 +1,4 @@
+import type { Editor } from './editor';
+export declare function mountRuler(hostH: HTMLElement, hostV: HTMLElement, pages: HTMLElement, scroller: HTMLElement, editor: Editor): {
+    draw: () => void;
+};

package/dist/types/packages/docx-editor/src/sdk.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The SDK: one call mounts the Word-like editor in an element.
+ *
+ *   const h = createDocxEditor(el, { onSave: (bytes) => upload(bytes) })
+ *   await h.load(file)
+ *
+ * Everything the app did in `main.ts` lives here — the document pipeline
+ * (fonts, embedded faces, images, headers and footers, anchored text boxes,
+ * the variables layer), the editor, the chrome — behind one handle, so the
+ * host page owns nothing but a `<div>`.
+ *
+ * One editor per page. The inspector, the variables panel and the bench read
+ * a few elements by id (`#info`, `#pages`, `#inspector`…); two editors on one
+ * page would share them. ponytail: scope the ids to the root the day a page
+ * needs two editors.
+ */
+import { type DocxDocument } from '../../docx-model/src/index';
+import type { Tag } from '../../docx-tags/src/index';
+import { type Editor } from './editor';
+import { type LibraryExtras } from './vars-library';
+import { type CommentRange } from './comments';
+export type ChromeMode = 'full' | 'viewer' | 'none';
+export type Theme = 'light' | 'dark' | 'system';
+export type DocxEditorEvent = 'load' | 'change' | 'selection' | 'render' | 'save' | 'context' | 'zoom';
+export interface DocxEditorOptions {
+    /** `full`: ribbon, rulers, panels. `viewer`: read-only pages under a slim header. `none`: pages only. */
+    chrome?: ChromeMode;
+    readOnly?: boolean;
+    theme?: Theme;
+    /** directory that holds `ttf/` — see `fonts.ts` */
+    fontsUrl?: string | URL;
+    /** hard cap on the page count — a guard against a runaway layout, never an alignment */
+    maxPages?: number;
+    /** the document after a quiet period, and on tab change — where autosave goes */
+    onSave?: (bytes: Uint8Array) => void | Promise<void>;
+    onChange?: () => void;
+    onReady?: (handle: DocxEditorHandle) => void;
+    zoom?: number;
+    rulers?: boolean;
+    statusBar?: boolean;
+    fileName?: string;
+    /** preview values; when absent the preview deduces a sample set from the tags */
+    values?: Record<string, unknown>;
+    /** open the editor on the last-used side panel */
+    panel?: 'variables' | 'inspector' | null;
+    /** the fields and snippets the application offers, beyond what the document already uses */
+    library?: LibraryExtras;
+    /** show Word's comments as marks on the text (default true) */
+    comments?: boolean;
+}
+export interface DocxEditorHandle {
+    load(src: ArrayBuffer | Uint8Array | Blob | string): Promise<void>;
+    /** the document as .docx bytes, now */
+    save(): Uint8Array;
+    /** triggers the browser download */
+    download(name?: string): void;
+    /** the low-level editor: commands, selection, formatting — `null` before the first load */
+    readonly editor: Editor | null;
+    readonly document: DocxDocument | null;
+    readonly root: HTMLElement;
+    pages(): number;
+    fileName(name?: string): string;
+    setZoom(z: number): void;
+    getZoom(): number;
+    setTheme(t: Theme): void;
+    setReadOnly(on: boolean): void;
+    showPanel(p: 'variables' | 'inspector' | null): void;
+    /** Word's comments of the open document, with their ranges */
+    comments(): CommentRange[];
+    showComments(on: boolean): void;
+    variables: {
+        tags(): Tag[];
+        /** show the GENERATED document: values interpolated, false sections hidden */
+        preview(on: boolean, values?: Record<string, unknown>): Promise<void>;
+        previewOn(): boolean;
+    };
+    on(ev: DocxEditorEvent, fn: (payload?: unknown) => void): () => void;
+    destroy(): void;
+}
+/** The paragraph styles a document declares — what the Styles gallery lists. */
+export declare function paragraphStyles(doc: DocxDocument): {
+    id: string;
+    name: string;
+}[];
+export declare function createDocxEditor(container: HTMLElement, options?: DocxEditorOptions): DocxEditorHandle;

package/dist/types/packages/docx-editor/src/ui/icons.d.ts

@@ -0,0 +1,2 @@
+export declare function hasIcon(id: string): boolean;
+export declare function icon(id: string, size?: number): SVGElement;

package/dist/types/packages/docx-editor/src/ui/shell.d.ts

@@ -0,0 +1,57 @@
+export type ChromeMode = 'full' | 'viewer' | 'none';
+export type Theme = 'light' | 'dark' | 'system';
+export type Panel = 'variables' | 'inspector';
+export interface ShellHost {
+    open(file: File): void;
+    save(): void;
+    zoom(z: number): void;
+    panel(p: Panel | null): void;
+    rename(name: string): void;
+}
+export interface ShellOptions {
+    mode: ChromeMode;
+    theme: Theme;
+    rulers: boolean;
+    statusBar: boolean;
+    fileName: string;
+    host: ShellHost;
+}
+export interface Shell {
+    root: HTMLElement;
+    pagesEl: HTMLElement;
+    mainEl: HTMLElement;
+    ribbonEl: HTMLElement;
+    rulerH: HTMLElement;
+    rulerV: HTMLElement;
+    varsEl: HTMLElement;
+    inspectorEl: HTMLElement;
+    statusEl: HTMLElement;
+    /** the composition line the bench reads (« N page(s) ») */
+    info: HTMLElement;
+    /** what happens while a document opens, step by step */
+    loader: Loader;
+    setFileName(name: string): void;
+    setSaveState(s: string): void;
+    setPages(n: number): void;
+    setWords(n: number): void;
+    setPosition(page: number, pages: number, selChars: number): void;
+    setZoom(z: number): void;
+    setTheme(t: Theme): void;
+    theme(): Theme;
+    setRulers(on: boolean): void;
+    rulers(): boolean;
+    setStatusBar(on: boolean): void;
+    setReadOnly(on: boolean): void;
+    showPanel(p: Panel | null): void;
+    panel(): Panel | null;
+    destroy(): void;
+}
+export interface Loader {
+    start(name: string): void;
+    /** closes the previous step with its elapsed time and opens this one */
+    step(label: string, detail?: string): void;
+    done(summary: string): void;
+    fail(message: string): void;
+}
+export declare const ZOOM_STEPS: number[];
+export declare function mountShell(container: HTMLElement, o: ShellOptions): Shell;

package/dist/types/packages/docx-editor/src/variables.d.ts

@@ -0,0 +1,68 @@
+import type { MarkRect } from '../../docx-render/src/index';
+import type { StyledParagraph } from '../../docx-model/src/index';
+import { type Tag } from '../../docx-tags/src/index';
+import { type Evaluated } from '../../docx-vars/src/index';
+/**
+ * Les variables d'une matrice, dans l'éditeur.
+ *
+ * Le POC variables avait montré qu'un tag peut s'afficher en badge lisible et
+ * s'éditer en blocs. Il ne pouvait pas les ÉCRIRE : « rien n'est écrit dans le
+ * docx », disait sa page de limites. Ici le document est éditable, et c'est ce
+ * qui change tout — un badge n'est plus une vue, c'est une poignée.
+ *
+ * Trois pièces, dans cet ordre — l'inverse ne peut produire que du recouvrement :
+ *
+ * 1. **mesurer** les badges hors écran, à la largeur utile de la page ;
+ * 2. **composer** en donnant au renderer une BOÎTE de cette taille à la place
+ *    du texte du tag — il l'écarte comme un mot insécable ;
+ * 3. **poser** chaque badge dans la boîte que le renderer lui a gardée.
+ *
+ * La boîte garde le texte du tag. Elle ne le dessine pas — mais le rang de
+ * chaque caractère qui SUIT dans le paragraphe en dépend, et un curseur posé
+ * après un badge écrirait sinon quatorze caractères trop tôt.
+ */
+export interface VarsHost {
+    /** Texte de chaque paragraphe, tel que les EXTENSIONS le voient. */
+    paras(): string[];
+    /** Curseur courant, pour les extensions qui s'y intéressent. */
+    caret(): {
+        para: number;
+        offset: number;
+    } | null;
+    /** Le badge a été choisi : à l'hôte d'ouvrir ce qu'il veut. */
+    onSelect(tag: Tag): void;
+    /** Redemande une composition — une extension a changé d'avis. */
+    refresh(): void;
+}
+export interface Variables {
+    /**
+     * Relit les tags et remesure leurs badges.
+     *
+     * On scanne le texte des paragraphes STYLÉS, pas celui du modèle : c'est lui
+     * que le renderer compose et que le curseur adresse. Une tabulation ou un
+     * saut de ligne suffisent à les faire diverger, et les badges se posaient
+     * alors à côté de leur tag.
+     */
+    rescan(pageWidthPx: number, styled: StyledParagraph[]): void;
+    /** Les tags lus au dernier passage. */
+    tags(): Tag[];
+    /** Le tag qui porte cette adresse, s'il y en a un. */
+    at(para: number, off: number): Tag | undefined;
+    /** Remplace le texte des tags par des boîtes de la taille de leur badge. */
+    substitute(styled: StyledParagraph[]): StyledParagraph[];
+    /**
+     * APERÇU — le document GÉNÉRÉ, à la place des badges.
+     *
+     * `null` pour revenir aux badges. Avec une évaluation, chaque tag de valeur
+     * rend son résultat et les sections fausses masquent leur contenu : c'est le
+     * document que la génération produira, composé par le même moteur et à la
+     * même fidélité que le reste. L'atelier des variables savait le faire depuis
+     * le début ; l'éditeur, non — il ne montrait que les tags.
+     */
+    setPreview(ev: Evaluated | null): void;
+    /** Pose les badges dans les boîtes que le renderer a publiées. */
+    place(layers: HTMLElement[], rects: MarkRect[]): void;
+    /** Met en évidence le badge d'un tag — ou aucun. */
+    highlight(id: number | null): void;
+}
+export declare function createVariables(host: VarsHost): Variables;

package/dist/types/packages/docx-editor/src/vars-blockly.d.ts

@@ -0,0 +1,9 @@
+import { type BlockJson } from '../../docx-vars/src/index';
+import type { Tag } from '../../docx-tags/src/index';
+export interface BlocklyView {
+    load(tree: BlockJson): void;
+    read(): BlockJson | null;
+    resize(): void;
+    dispose(): void;
+}
+export declare function mountBlockly(holder: HTMLElement, onChange: () => void, tags: () => Tag[]): BlocklyView;

package/dist/types/packages/docx-editor/src/vars-complete.d.ts

@@ -0,0 +1,60 @@
+import { type LibEntry } from './vars-library';
+import type { Tag } from '../../docx-tags/src/index';
+/**
+ * L'autocomplétion, dans le document.
+ *
+ * Elle ne se déclenche pas n'importe où — une liste qui s'ouvre pendant qu'on
+ * rédige une phrase est une nuisance. Deux endroits, et deux seulement :
+ *
+ * - **dans un tag ouvert** (`{{` ou `{%` sans fermeture avant le curseur) :
+ *   champs et fonctions, c'est-à-dire ce qui a le droit d'y figurer ;
+ * - **après un `/` en début de mot** : les extraits, comme partout ailleurs
+ *   depuis que Notion en a fait une convention.
+ *
+ * Le clavier passe AVANT l'éditeur : la capture est posée sur le champ de
+ * frappe, et les flèches, Entrée, Tab et Échap ne redescendent pas jusqu'à lui
+ * tant que la liste est ouverte. Sans ça, ↓ déplacerait le curseur dans la page
+ * pendant qu'on parcourt la liste.
+ */
+export interface CompleteHost {
+    /** Le champ invisible qui reçoit la frappe — c'est là qu'on capture. */
+    input: HTMLElement;
+    tags(): Tag[];
+    /** Texte d'un paragraphe du corps. */
+    textOf(para: number): string;
+    /** Où est le curseur, ou `null`. */
+    caret(): {
+        para: number;
+        off: number;
+    } | null;
+    /** Remplace une plage du paragraphe courant par ce texte. */
+    replace(para: number, from: number, to: number, text: string): void;
+    /** Where to hang the list; by default under the page's caret. */
+    anchor?(): DOMRect | undefined;
+}
+export interface Completer {
+    /** À rappeler après chaque frappe : ouvre, met à jour ou referme. */
+    refresh(): void;
+    close(): void;
+    open(): boolean;
+}
+/** Ce qu'on est en train de taper, et ce qu'on a le droit d'y proposer. */
+interface Context {
+    para: number;
+    /** plage du fragment à remplacer */
+    from: number;
+    to: number;
+    prefix: string;
+    kinds: LibEntry['kind'][];
+    /** ce qu'on insère : le code entier, ou seulement l'expression */
+    as: 'code' | 'expr';
+}
+/**
+ * Lit le contexte de frappe autour du curseur.
+ *
+ * On regarde le texte AVANT le curseur seulement : ce qui suit n'appartient
+ * pas encore à ce qu'on écrit.
+ */
+export declare function contextAt(text: string, off: number): Context | null;
+export declare function createCompleter(host: CompleteHost): Completer;
+export {};

package/dist/types/packages/docx-editor/src/vars-library.d.ts

@@ -0,0 +1,59 @@
+import type { Tag } from '../../docx-tags/src/index';
+import { type IconName } from '../../docx-vars/src/index';
+/**
+ * La bibliothèque : ce qu'on peut poser dans un document.
+ *
+ * Trois natures, et l'ordre n'est pas indifférent — il suit ce que le corpus
+ * dit du travail réel. Les CHAMPS d'abord, parce que l'écrasante majorité des
+ * variables sont des accès de champ simples. Les FONCTIONS ensuite. Les
+ * EXTRAITS enfin, qui sont ce qui manque le plus au rédacteur de matrice : il
+ * ne réécrit pas un champ, il réécrit un paragraphe conditionnel entier.
+ *
+ * Chaque entrée sait ce qu'elle INSÈRE — c'est la seule chose que l'hôte a
+ * besoin de savoir d'elle.
+ */
+export interface LibEntry {
+    kind: 'champ' | 'fonction' | 'extrait';
+    key: string;
+    label: string;
+    sub: string;
+    icon: IconName;
+    /** Ce que l'entrée pose dans le document. */
+    code: string;
+    /** Ce qu'on met dans une expression, sans les accolades. */
+    expr: string;
+    desc?: string;
+}
+/** A field the host declares — what the matrix MAY use, beyond what it already does. */
+export interface LibraryField {
+    /** `salarie.nom` */
+    path: string;
+    label?: string;
+    desc?: string;
+}
+/** A snippet the host declares — a whole block, ready to paste. */
+export interface LibrarySnippet {
+    id: string;
+    title: string;
+    code: string;
+    category?: string;
+    desc?: string;
+}
+export interface LibraryExtras {
+    fields?: LibraryField[];
+    snippets?: LibrarySnippet[];
+    /** keep the built-in snippets next to the host's (default true) */
+    builtinSnippets?: boolean;
+}
+export declare function configureLibrary(x: LibraryExtras): void;
+export declare function libraryEntries(tags: Tag[]): LibEntry[];
+/** Filtre sans accent ni casse — on cherche « majore », on trouve « Majoré ». */
+export declare const fold: (s: string) => string;
+export declare function filterEntries(all: LibEntry[], kind: string, query: string): LibEntry[];
+/**
+ * Une ligne de bibliothèque, telle qu'elle s'affiche partout.
+ *
+ * La même dans le panneau et dans l'autocomplétion du document : ce qu'on
+ * apprend d'un endroit vaut pour l'autre.
+ */
+export declare function entryRow(e: LibEntry): HTMLElement;

package/dist/types/packages/docx-editor/src/vars-panel.d.ts

@@ -0,0 +1,38 @@
+import { type Tag } from '../../docx-tags/src/index';
+/**
+ * Le panneau des variables : lire un tag, l'éditer, en poser un nouveau.
+ *
+ * C'est la boucle que le POC avait ouverte sans pouvoir la fermer — il savait
+ * lire un tag, le montrer en blocs et regénérer son code, mais « rien n'est
+ * écrit dans le docx ». Ici *Appliquer* passe par les gestes du modèle : la
+ * plage du tag est remplacée, l'annulation la ramène, et la composition
+ * incrémentale ne refait que la page touchée.
+ *
+ * Deux façons de voir les blocs, parce qu'elles ne servent pas à la même chose :
+ *
+ * - **Blocs** (par défaut) — du DOM qui se replie. Il remplit le panneau à
+ *   n'importe quelle largeur, sans zoom ni défilement horizontal.
+ * - **Blockly** — le canvas, chargé à la demande. Il ne se replie pas, mais il
+ *   sait ce que le DOM ne fait pas encore aussi bien : restructurer librement
+ *   une expression au glisser-déposer.
+ *
+ * L'ARBRE est le même dans les deux : `blockify` le produit, `blockToTag` le
+ * relit. Basculer d'un mode à l'autre ne perd rien.
+ */
+export interface VarsPanelHost {
+    /** Remplace la plage d'un tag par ce texte, à travers l'éditeur. */
+    apply(tag: Tag, text: string): void;
+    /** Pose ce texte au curseur. */
+    insert(text: string): void;
+    /** Tous les tags du document — la bibliothèque de champs s'en déduit. */
+    tags(): Tag[];
+}
+export interface VarsPanel {
+    /** Montre un tag. `null` referme le panneau. */
+    show(tag: Tag | null): void;
+    /** Ouvre la bibliothèque, sans tag. */
+    library(): void;
+    current(): Tag | null;
+    open(): boolean;
+}
+export declare function mountVarsPanel(root: HTMLElement, host: VarsPanelHost): VarsPanel;

package/dist/types/packages/docx-model/src/edit.d.ts

@@ -0,0 +1,64 @@
+import { type DocxDocument } from './index';
+/**
+ * Réécriture d'une plage de caractères dans le document.
+ *
+ * C'est la brique qui manquait pour éditer : jusqu'ici tout se lisait, rien ne
+ * repartait dans le docx. Elle repose entièrement sur le **découpage de run** —
+ * une plage partage presque toujours son `<w:r>` avec du texte voisin, et on ne
+ * peut pas remplacer l'une sans préserver l'autre, mise en forme comprise.
+ *
+ * L'adresse est celle de `spans.ts` : un rang de paragraphe et des bornes de
+ * caractères. C'est la MÊME que celle que le curseur rend à l'écran, et c'est
+ * volontaire — sans quoi l'éditeur écrirait à côté de ce qu'on a cliqué.
+ *
+ * ponytail: la substitution reste du texte par du texte, dans UN paragraphe.
+ * Insérer des images ou franchir une frontière de paragraphe viendra quand
+ * l'éditeur en aura besoin.
+ */
+/**
+ * Remplace `[from, to)` du paragraphe `para` par `text`.
+ *
+ * Le texte inséré hérite de la mise en forme du run qui portait le début de la
+ * plage : c'est ce que fait Word quand on tape au milieu d'un mot en gras.
+ * Une plage vide insère au point.
+ *
+ * Renvoie `false` sans rien modifier quand la plage traverse deux conteneurs
+ * inline différents (moitié dans un `w:hyperlink`, moitié dehors) — la
+ * remplacer d'un seul découpage sortirait du texte de son conteneur.
+ */
+export declare function replaceRange(doc: DocxDocument, para: number, from: number, to: number, text: string, part?: string): boolean;
+export interface TagSite {
+    /** rang du tag dans l'ordre du document, aligné sur `scanTags` */
+    index: number;
+    raw: string;
+    /** index du paragraphe */
+    para: number;
+    /** bornes du tag dans le TEXTE du paragraphe — la même adresse qu'un curseur */
+    from: number;
+    to: number;
+    /** false si le tag reste éclaté sur plusieurs conteneurs — non réécrivable */
+    writable: boolean;
+}
+/**
+ * Tous les emplacements de tag, dans l'ordre du document.
+ *
+ * À appeler sur un document déjà soigné : un tag encore éclaté est signalé
+ * `writable: false` plutôt que réécrit de travers.
+ */
+export declare function tagSites(doc: DocxDocument): TagSite[];
+/**
+ * Remplace le texte des tags désignés par leur rang.
+ *
+ * Le document est **soigné d'abord** : sans ça un tag éclaté par Word n'est
+ * adressable dans aucun run. Les réécritures sont appliquées de droite à
+ * gauche dans chaque paragraphe, pour que les positions déjà calculées restent
+ * valides. Renvoie les rangs effectivement réécrits.
+ */
+export declare function replaceTags(doc: DocxDocument, replacements: Map<number, string>): number[];
+/**
+ * Réécrit chaque tag par lui-même.
+ *
+ * C'est le test qui compte : découper un run puis y remettre exactement le même
+ * texte doit être **neutre**. Si le document change, le découpage est faux.
+ */
+export declare function rewriteIdentity(doc: DocxDocument): number[];