myrole-docx-editor 0.1.0

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

@@ -0,0 +1,254 @@
+import { bodyBlocks, type DocxDocument, type XmlNode } from './index';
+import { styledParagraphs, type ParagraphStyle, type RunStyle, type StyledRun } from './layout';
+import { resolveNumbering, type ListInfo } from './numbering';
+import { tables } from './tables';
+/**
+ * Les gestes d'édition, exprimés dans le modèle.
+ *
+ * Tout passe par l'arbre `DocxDocument` — jamais par les vues typées, qui ne
+ * portent qu'une part de ce que Word écrit et perdraient le reste au retour.
+ * L'adresse est celle de `spans.ts` : rang de paragraphe, rang de caractère.
+ * C'est exactement celle que le curseur rend à l'écran.
+ *
+ * Chaque commande renvoie la position où le curseur doit se retrouver, ou
+ * `null` si elle n'a rien pu faire. L'appelant recompose ensuite : ces gestes
+ * changent la pagination, il n'y a pas de mise à jour partielle à espérer.
+ */
+/**
+ * Adresse d'un point du document.
+ *
+ * `part` dit dans quel fichier du zip vit le paragraphe : le corps par défaut,
+ * mais un en-tête ou un pied est fait des mêmes `w:p` dans un autre fichier.
+ * C'est tout ce qui les séparait de l'éditeur — leur adresse n'était pas
+ * exprimable, et un rang de paragraphe seul aurait désigné le corps.
+ */
+export interface DocPos {
+    para: number;
+    off: number;
+    part?: string;
+}
+/** La part d'une adresse, le corps par défaut. */
+export declare const partOf: (p: {
+    part?: string;
+}) => string;
+/** Insère `text` au point, ou remplace la plage. Renvoie la position d'arrivée. */
+export declare function insertText(doc: DocxDocument, a: DocPos, b: DocPos, text: string): DocPos | null;
+/**
+ * Supprime la plage, en recollant les paragraphes qu'elle traverse.
+ *
+ * Le paragraphe d'arrivée est absorbé par celui de départ, qui garde sa propre
+ * mise en forme : c'est ce que fait Word — la marque de paragraphe survivante
+ * est celle du HAUT.
+ */
+export declare function deleteRange(doc: DocxDocument, a: DocPos, b: DocPos): DocPos | null;
+/**
+ * Coupe le paragraphe au point — la touche Entrée.
+ *
+ * Le nouveau paragraphe hérite du `w:pPr` de l'ancien : c'est ce que fait Word,
+ * et sans lui une liste numérotée perdrait son `w:numPr` à chaque retour.
+ */
+export declare function splitParagraph(doc: DocxDocument, pos: DocPos): DocPos | null;
+/**
+ * Recolle un paragraphe sur le précédent — Retour arrière en tête de ligne.
+ *
+ * Renvoie la position de la soudure, là où le curseur doit rester.
+ */
+export declare function joinParagraph(doc: DocxDocument, para: number): DocPos | null;
+/** Insère un rang vide au-dessus ou au-dessous de celui du curseur. */
+export declare function insertTableRow(doc: DocxDocument, para: number, where: 'above' | 'below'): boolean;
+/** Retire le rang du curseur ; le dernier rang emporte le tableau. */
+export declare function deleteTableRow(doc: DocxDocument, para: number): boolean;
+/** Retire le tableau qui contient ce paragraphe. */
+export declare function deleteTable(doc: DocxDocument, para: number): boolean;
+/**
+ * Déplace le tableau devant le bloc de premier niveau qui porte `target`.
+ *
+ * C'est le geste de la poignée de déplacement : on ne dépose pas « à un
+ * caractère près » mais ENTRE deux blocs — un tableau ne s'insère pas au milieu
+ * d'un paragraphe.
+ */
+export declare function moveTable(doc: DocxDocument, para: number, target: number): boolean;
+/**
+ * Insère une colonne vide à gauche ou à droite de celle du curseur.
+ *
+ * ponytail: la colonne est repérée par son RANG DE CELLULE, pas par sa colonne
+ * de grille. Sur un tableau à cellules fusionnées (`w:gridSpan`), les deux
+ * divergent et l'insertion tombe à côté. À reprendre quand un document réel le
+ * montre — le corpus n'en a pas encore fourni.
+ */
+export declare function insertTableColumn(doc: DocxDocument, para: number, where: 'left' | 'right'): boolean;
+/** Retire la colonne du curseur ; la dernière emporte le tableau. */
+export declare function deleteTableColumn(doc: DocxDocument, para: number): boolean;
+/**
+ * Change la largeur d'une colonne de grille — la gouttière qu'on tire sur la règle.
+ *
+ * Word tient la largeur à DEUX endroits : `w:tblGrid/w:gridCol` pour la grille,
+ * `w:tcPr/w:tcW` pour chaque cellule. N'en changer qu'un donne un tableau dont
+ * la grille et les cellules se contredisent, et Word tranche alors comme il
+ * l'entend. On garde la largeur TOTALE : la colonne voisine cède ce que
+ * celle-ci prend, sinon le tableau déborde de sa page.
+ */
+export declare function setTableColumn(doc: DocxDocument, para: number, col: number, widthPt: number): boolean;
+/**
+ * Retire la n-ième image d'un paragraphe.
+ *
+ * On supprime le RUN qui la porte, pas seulement le `w:drawing` : un run vidé
+ * de son dessin ne porterait plus rien et compterait pourtant encore comme run
+ * — assez pour dérégler l'adressage sans qu'on voie quoi que ce soit.
+ */
+export declare function deleteImage(doc: DocxDocument, para: number, index: number): boolean;
+/**
+ * Redimensionne la n-ième image d'un paragraphe.
+ *
+ * Word écrit la taille à DEUX endroits — `wp:extent`, qui dit la place prise
+ * dans le fil, et `a:ext`, qui dit la taille du dessin. N'en changer qu'un
+ * donne une image étirée dans un cadre qui ne lui va pas.
+ */
+export declare function resizeImage(doc: DocxDocument, para: number, index: number, widthPt: number, heightPt: number): boolean;
+/**
+ * Insère un saut au point — de page, de colonne ou de ligne.
+ *
+ * Un saut n'est pas du texte : c'est un `w:br` dans le run. On découpe donc le
+ * run comme pour une insertion ordinaire, mais le morceau du milieu porte la
+ * balise au lieu d'un `w:t`. Il compte pour UN caractère dans l'adressage,
+ * comme partout ailleurs (`runSpans`).
+ */
+export declare function insertBreak(doc: DocxDocument, at: DocPos, type?: 'page' | 'column' | 'line'): DocPos | null;
+/**
+ * Propriétés de run qu'on sait poser. `null` efface la propriété, la laissant
+ * retomber sur la cascade de styles — ce n'est pas la même chose que `false`,
+ * qui la nie explicitement.
+ */
+export interface RunPatch {
+    bold?: boolean | null;
+    italic?: boolean | null;
+    underline?: boolean | null;
+    strike?: boolean | null;
+    sizePt?: number | null;
+    fontFamily?: string | null;
+    color?: string | null;
+    highlight?: string | null;
+    vertAlign?: 'superscript' | 'subscript' | null;
+}
+/**
+ * Applique une mise en forme à la plage `[from, to)` d'un paragraphe.
+ *
+ * Les runs à cheval sur les bornes sont **découpés** : seul le texte
+ * sélectionné change, le reste garde sa mise en forme d'origine. C'est le même
+ * découpage que la réécriture de tag, et pour la même raison.
+ */
+export declare function formatRange(doc: DocxDocument, para: number, from: number, to: number, patch: RunPatch, part?: string): boolean;
+/**
+ * Un run neuf portant exactement cette mise en forme.
+ *
+ * Sert au collage : le texte venu d'ailleurs n'a pas de run d'origine à
+ * découper, il faut en fabriquer un.
+ */
+export declare function runFromStyle(text: string, patch: RunPatch): XmlNode;
+/** Propriétés de paragraphe qu'on sait poser. */
+export interface ParaPatch {
+    align?: 'left' | 'center' | 'right' | 'justify' | null;
+    indentLeftPt?: number | null;
+    indentRightPt?: number | null;
+    /** retrait de PREMIÈRE ligne, positif ; exclusif avec `hangingPt` chez Word */
+    indentFirstPt?: number | null;
+    /** retrait NÉGATIF de première ligne — la ligne 1 dépasse à gauche */
+    hangingPt?: number | null;
+    spaceBeforePt?: number | null;
+    spaceAfterPt?: number | null;
+    styleId?: string | null;
+}
+/** Applique une mise en forme au paragraphe entier. */
+export declare function formatParagraph(doc: DocxDocument, para: number, patch: ParaPatch, part?: string): boolean;
+/** Marges d'une section, en points. Chaque champ omis reste inchangé. */
+export interface MarginPatch {
+    leftPt?: number;
+    rightPt?: number;
+    topPt?: number;
+    bottomPt?: number;
+    /** gouttière de reliure — s'ajoute à la marge intérieure, elle ne la remplace pas */
+    gutterPt?: number;
+}
+/**
+ * Déplace les marges d'une section — ce que fait la règle quand on tire une
+ * gouttière.
+ *
+ * Word garde les quatre marges dans un seul `w:pgMar` avec aussi `w:header`,
+ * `w:footer` et `w:gutter` : on fusionne attribut par attribut pour ne pas
+ * emporter la distance de l'en-tête en réglant la marge gauche.
+ */
+export declare function setMargins(doc: DocxDocument, section: number, patch: MarginPatch): boolean;
+/** Rang de la section qui contient ce paragraphe. */
+export declare function sectionOf(views: DocViews, para: number): number;
+/** Où le curseur se trouve, et ce qu'une barre d'outils doit y montrer. */
+export interface EditContext {
+    pos: DocPos;
+    /** style effectif du run sous le curseur — cascade résolue */
+    run: RunStyle;
+    /** style effectif du paragraphe */
+    paragraph: ParagraphStyle;
+    /** texte du paragraphe, pour les gestes qui travaillent par mot ou par ligne */
+    text: string;
+    /** cellule courante, quand le curseur est dans un tableau */
+    table?: {
+        tableIndex: number;
+        row: number;
+        col: number;
+        rows: number;
+        cols: number;
+    };
+    /**
+     * Images du paragraphe courant, dans l'ordre.
+     *
+     * ponytail: du PARAGRAPHE, pas « sous le curseur ». Une image n'occupe aucun
+     * caractère — elle n'a donc pas d'adresse où poser un curseur, et il n'existe
+     * pas encore de sélection d'objet. Lister celles du paragraphe suffit pour
+     * les redimensionner ; la sélection d'objet viendra avec la poignée de
+     * redimensionnement.
+     */
+    images: NonNullable<StyledRun['image']>[];
+    /** puce ou numéro du paragraphe, quand il en porte un */
+    list?: ListInfo;
+}
+/**
+ * Vues déjà calculées, passées plutôt que recalculées.
+ *
+ * `contextAt` est appelé à CHAQUE déplacement du curseur. Recalculer
+ * `styledParagraphs` à chaque flèche, c'est refaire la cascade de styles de
+ * tout le document — 194 ms sur un contrat de 42 pages. L'appelant les a déjà
+ * sous la main pour dessiner : il les prête.
+ */
+export interface DocViews {
+    styled: ReturnType<typeof styledParagraphs>;
+    blocks: ReturnType<typeof bodyBlocks>;
+    tables: ReturnType<typeof tables>;
+    numbering: ReturnType<typeof resolveNumbering>;
+}
+/**
+ * Ce qu'il faut savoir pour afficher les bons réglages.
+ *
+ * Une barre d'outils Word ne montre pas la même chose selon qu'on est dans du
+ * texte, dans une cellule ou sur une image. Plutôt que de faire deviner l'UI,
+ * on lui donne l'état complet en un appel.
+ */
+export declare function contextAt(doc: DocxDocument, pos: DocPos, views: DocViews): EditContext | null;
+export declare function orderPos(a: DocPos, b: DocPos): [DocPos, DocPos];
+/** Deux adresses désignent-elles la même part ? */
+export declare const samePart: (a: DocPos, b: DocPos) => boolean;
+/** Longueur du texte d'un paragraphe, dans l'espace d'adressage de l'éditeur. */
+export declare function paraLength(doc: DocxDocument, para: number, part?: string): number;
+/**
+ * Bornes de l'unité qui entoure `off` — le double-clic.
+ *
+ * Sur une frontière, le mot de GAUCHE l'emporte : collé à la fin de « un », on
+ * sélectionne « un », pas l'espace qui suit. C'est ce que fait Word.
+ *
+ * Une plage vide n'est jamais rendue quand il y a quelque chose à prendre :
+ * double-cliquer sur une espace prend la suite d'espaces, sur un « ( » prend la
+ * ponctuation. Auparavant le geste « ne marchait pas » une fois sur trois dans
+ * des contrats qui en sont pleins.
+ */
+export declare function wordAt(text: string, off: number, locale?: string): {
+    from: number;
+    to: number;
+};

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

@@ -0,0 +1,60 @@
+import { type DocxDocument } from './index';
+/**
+ * Polices embarquées.
+ *
+ * Word range les polices du document dans le zip sous forme `.odttf` :
+ * un TTF ou OTF dont les **32 premiers octets** sont brouillés par un XOR avec
+ * la clé `w:fontKey` déclarée à côté (ECMA-376 §15.2.13). Il ne s'agit pas de
+ * chiffrement — juste d'un garde-fou de licence — et le désobfuscage est
+ * réversible en une passe.
+ *
+ * Pourquoi ça compte ici : `0_comedien.docx` embarque 17 polices, 99 % de ses
+ * 6,2 Mo. Un renderer qui dessine avec les polices système à la place n'a pas
+ * les mêmes métriques, donc pas les mêmes retours à la ligne, donc pas la même
+ * pagination. Les polices voyagent avec le document — autant s'en servir.
+ */
+export type FontStyle = 'regular' | 'bold' | 'italic' | 'boldItalic';
+export interface EmbeddedFont {
+    /** nom tel que le document le demande dans `w:rFonts` */
+    family: string;
+    style: FontStyle;
+    /** chemin de la part dans le zip */
+    part: string;
+    /** octets désobfusqués, prêts pour `new FontFace(...)` */
+    data: Uint8Array;
+}
+/**
+ * Défait le XOR des 32 premiers octets.
+ *
+ * La clé est le GUID lu **à l'envers** : son dernier octet en premier. C'est le
+ * détail qui fait échouer les implémentations naïves — un GUID lu à l'endroit
+ * produit un fichier qui ressemble à une police et n'en est pas une.
+ */
+export declare function deobfuscateFont(data: Uint8Array, fontKey: string): Uint8Array;
+/** Le désobfuscage a-t-il produit une police plausible ? */
+export declare function looksLikeFont(data: Uint8Array): boolean;
+/**
+ * `w:altName` — le remplaçant que WORD LUI-MÊME désigne, document par document.
+ *
+ * `word/fontTable.xml` déclare chaque police employée et, quand elle risque de
+ * manquer, la famille par laquelle la remplacer. C'est une table écrite par
+ * Word à l'enregistrement, pas une convention : **2 764 couples dans le
+ * corpus**, et elle explique pourquoi aucun alias GLOBAL ne pouvait gagner —
+ * « Times » y renvoie à « Times New Roman » dans 286 documents et à
+ * « Sylfaen » dans 101 autres.
+ *
+ * Les plus fréquents : MS Mincho → ＭＳ 明朝, New York → Times New Roman,
+ * New Century Schlbk → Century Schoolbook, Marianne → Cambria, Gadget → Arial.
+ *
+ * À consulter AVANT la table d'alias, et seulement quand la famille demandée
+ * n'est pas servie — Word ne s'en sert que dans ce cas.
+ */
+export declare function fontAltNames(doc: DocxDocument): Map<string, string>;
+/** Toutes les polices embarquées, désobfusquées. */
+export declare function embeddedFonts(doc: DocxDocument): EmbeddedFont[];
+/** Déclaration CSS `@font-face` prête à injecter, via une URL d'objet. */
+export declare const fontFaceDescriptor: (f: EmbeddedFont) => {
+    family: string;
+    weight: string;
+    style: string;
+};

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

@@ -0,0 +1,28 @@
+import { type DocxDocument, type XmlNode } from './index';
+/**
+ * Run healer — port du composant critique de LumiClone pour fast-xml-parser.
+ *
+ * Problème : Word fragmente les tags template ({{ }} et {% %}) en plusieurs
+ * <w:r> à cause du correcteur orthographique, de l'autocomplétion et des
+ * marques de révision. Après healing, chaque tag tient dans un seul <w:r>.
+ *
+ * Les runs enveloppés dans un `w:hyperlink`, un `w:sdt` ou un `w:ins` sont
+ * traversés comme les autres : `runSpans` descend dans les mêmes conteneurs
+ * que la vue typée.
+ */
+export declare const TAG_RE: RegExp;
+/** Crée un run avec le rPr du template et un seul w:t. */
+export declare function makeRun(template: XmlNode, text: string): XmlNode;
+/**
+ * Portion `[from, to)` d'un run, en **conservant ses enfants non textuels**.
+ *
+ * Recopier le texte à plat perdrait les `w:tab` et `w:br` qui l'entourent — et
+ * dans les matrices, un tag est presque toujours précédé de tabulations
+ * (`\t\t{{ salarie.nom }}`). Les effacer déplace toute la ligne : mesuré à
+ * 828 633 pixels d'écart sur `0_technicien.docx` avant ce correctif.
+ */
+export declare function sliceRun(run: XmlNode, from: number, to: number): XmlNode | null;
+/** Soigne les tags template fragmentés dans tout le document.
+ *  Modifie `doc.xml` en place — chaque tag {{ }} ou {% %} se retrouve
+ *  dans un seul `<w:r>`. Le round-trip `writeDocx` produit le XML nettoyé. */
+export declare function healTags(doc: DocxDocument): number;

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

@@ -0,0 +1,113 @@
+/**
+ * Représentation JSON d'un .docx.
+ *
+ * ponytail: modèle "passthrough-first". On ne type RIEN au départ : chaque part XML
+ * est un arbre ordonné fidèle, chaque binaire reste brut. Le round-trip est donc
+ * parfait dès J1, et on "promeut" progressivement des noeuds vers un modèle typé
+ * (paragraphe, run, table...) au fur et à mesure des besoins de l'éditeur.
+ * Upgrade path: ajouter des vues typées au-dessus de `parts`, jamais à la place.
+ */
+export type XmlNode = Record<string, any>;
+export type XmlTree = XmlNode[];
+export interface DocxDocument {
+    /** parts XML parsées, clé = chemin dans le zip (ex: "word/document.xml") */
+    xml: Record<string, XmlTree>;
+    /** parts binaires (images, fonts, thumbnails...) conservées telles quelles */
+    bin: Record<string, Uint8Array>;
+    /** ordre original des entrées du zip, pour rebuild déterministe */
+    order: string[];
+}
+export declare function readDocx(buf: Uint8Array): DocxDocument;
+export declare function writeDocx(doc: DocxDocument): Uint8Array;
+/** Nom de balise d'un noeud ordonné (les clés `:@` / `#text` sont des métadonnées). */
+export declare function tagOf(node: XmlNode): string;
+/** Parcours en profondeur de tous les noeuds d'un arbre. */
+export declare function walk(tree: XmlTree): Generator<XmlNode>;
+/**
+ * Comme `walk`, mais sans entrer dans les `mc:Fallback`.
+ *
+ * Une forme moderne s'écrit deux fois : une `mc:Choice` pour les lecteurs
+ * récents, une `mc:Fallback` avec le MÊME contenu pour les anciens. Un lecteur
+ * en affiche une seule. On les affichait toutes les deux — le pied de page de
+ * Colo 2 sortait « Paraphes Salarié.e » quatre fois.
+ */
+export declare function walkRendered(tree: XmlTree, opts?: {
+    skipTextBoxes?: boolean;
+}): Generator<XmlNode>;
+/**
+ * Premier nœud portant ce tag, sans matérialiser l'arbre.
+ *
+ * `[...walk(tree)].find(...)` construit un tableau de TOUS les nœuds avant d'en
+ * chercher un — sur un contrat de 42 pages, cinquante mille objets pour trouver
+ * `w:body`, qui est le deuxième. Le générateur s'arrête au premier trouvé.
+ */
+export declare function firstTag(tree: XmlTree, tag: string): XmlNode | undefined;
+/** Attribut d'un noeud XML ordonné. */
+export declare const attr: (n: XmlNode | undefined, name: string) => string | undefined;
+/** Premier enfant direct portant le tag donné. */
+export declare const childOf: (node: XmlNode, tag: string) => XmlNode | undefined;
+/** Texte d'un paragraphe (`w:p`), en concaténant ses `w:t`. */
+export declare function paragraphText(p: XmlNode): string;
+/**
+ * Tous les paragraphes du FIL de word/document.xml, dans l'ordre.
+ *
+ * Les zones de texte en sont exclues : elles sont ancrées, Word les pose hors
+ * du fil, et `bodyBlocks` ne les énumère pas. Les compter ici décalait tous les
+ * index suivants — sur Colo 2, un tableau affichait le texte du paragraphe
+ * d'à côté dans ses cellules, neuf paragraphes plus loin.
+ */
+export declare const BODY = "word/document.xml";
+/**
+ * Les paragraphes du fil d'une PART, dans l'ordre.
+ *
+ * Le corps par défaut, mais un en-tête ou un pied est fait des mêmes `w:p` —
+ * ils vivent simplement dans un autre fichier du zip. C'est tout ce qui les
+ * séparait de l'éditeur : leur adresse n'était pas exprimable.
+ */
+export declare function paragraphsIn(doc: DocxDocument, part?: string): XmlNode[];
+/** Les paragraphes du corps — le cas courant. */
+export declare function paragraphs(doc: DocxDocument): XmlNode[];
+/** Options de parcours du fil : ni variantes de repli, ni zones ancrées. */
+export declare const FLOW: {
+    readonly skipTextBoxes: true;
+};
+export type BodyBlock = {
+    type: 'paragraph';
+    paraIndex: number;
+    sectionIndex: number;
+} | {
+    type: 'table';
+    tableIndex: number;
+    paraStart: number;
+    paraCount: number;
+    sectionIndex: number;
+} | {
+    type: 'sectionBreak';
+    sectionIndex: number;
+    breakType: 'nextPage' | 'continuous' | 'evenPage' | 'oddPage';
+};
+/** Séquence ordonnée des éléments de premier niveau du body (paragraphes et tableaux).
+ *  Inclut des `sectionBreak` quand le layout change (colonnes, marges, orientation).
+ *  Le renderer itère là-dessus et pioche dans styledParagraphs[paraIndex] ou tables()[tableIndex]. */
+export declare function bodyBlocks(doc: DocxDocument): BodyBlock[];
+/**
+ * Nombre de pages que Word a rendues, lu dans `w:lastRenderedPageBreak`.
+ *
+ * Fiable pour les documents sans tableau bilingue multi-page. Retourne
+ * `undefined` si aucun marqueur n'est trouvé (le document n'a jamais été
+ * imprimé par Word).
+ */
+export declare function wordPageCount(doc: DocxDocument): number | undefined;
+export * from './layout';
+export * from './spans';
+export * from './styles';
+export * from './numbering';
+export * from './tables';
+export * from './rels';
+export * from './heal';
+export * from './edit';
+export * from './editor';
+export * from './insert';
+export * from './paste';
+export * from './fonts';
+export * from './textbox';

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

@@ -0,0 +1,30 @@
+import { type DocxDocument } from './index';
+import { type DocPos, type RunPatch } from './editor';
+export interface InsertedImage {
+    /** où le curseur se retrouve, après l'image */
+    pos: DocPos;
+    /** chemin de la part créée dans le zip */
+    path: string;
+}
+/**
+ * Insère une image EN LIGNE au point.
+ *
+ * Les quatre gestes du paquet OPC, dans l'ordre : l'octet, le type de contenu,
+ * la relation, puis seulement le nœud. `widthPt`/`heightPt` sont la taille
+ * d'affichage ; c'est à l'appelant de la déduire des pixels de l'image, lui
+ * seul sait la décoder.
+ */
+export declare function insertImage(doc: DocxDocument, at: DocPos, data: Uint8Array, ext: string, widthPt: number, heightPt: number): InsertedImage | null;
+/** Un morceau de texte collé, avec la mise en forme qu'il portait. */
+export interface PastedRun {
+    text: string;
+    style: RunPatch;
+}
+/**
+ * Insère une suite de runs mis en forme au point.
+ *
+ * Le texte venu d'ailleurs n'a pas de run d'origine à découper : on en
+ * fabrique. Le run qui portait le point est coupé en deux, et les nouveaux se
+ * glissent entre les morceaux.
+ */
+export declare function insertRuns(doc: DocxDocument, at: DocPos, runs: PastedRun[]): DocPos | null;