myrole-docx-editor 0.1.0

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

@@ -0,0 +1,411 @@
+import { type DocxDocument } from './index';
+/**
+ * Vue typée au-dessus du modèle passthrough : ce qu'il faut pour dessiner
+ * une page qui ressemble à Word.
+ *
+ * ponytail: on ne modélise que ce qu'on affiche. Chaque champ ajouté ici
+ * passe par la cascade de styles (styles.ts) avant lecture.
+ */
+export interface ParagraphStyle {
+    /** identifiant de style Word, ex. `Titre1` */
+    styleId?: string;
+    /** niveau de titre déduit du style, 1..6 */
+    heading?: number;
+    align?: 'left' | 'center' | 'right' | 'justify';
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    /** taille en points */
+    sizePt?: number;
+    /** police de caractère */
+    fontFamily?: string;
+    /** couleur du texte (hex sans #, ex. `2F5496`) */
+    color?: string;
+    /** retraits et espacements, en points */
+    indentLeftPt?: number;
+    /**
+     * `w:ind w:left` DÉCLARÉ PAR LE PARAGRAPHE, hors héritage de style.
+     *
+     * ECMA-376 place le `w:pPr` du NIVEAU de numérotation entre le style et le
+     * formatage direct : le retrait du niveau l'emporte sur celui du style de
+     * liste, et cède au retrait écrit sur le paragraphe. Sans distinguer les
+     * deux, `Paragraphedeliste` (`w:left="720"`) écrasait le `w:left="1080"` du
+     * niveau, et le « J. » de « CREW CINE SKYLARK » partait 18 pt trop à gauche
+     * — 94,3 pt au lieu des 112,6 de Word — avec tout son paragraphe.
+     */
+    indentLeftDirectPt?: number;
+    indentRightPt?: number;
+    indentFirstPt?: number;
+    spaceBeforePt?: number;
+    spaceAfterPt?: number;
+    /** interligne en multiple de la ligne simple (w:lineRule="auto") */
+    lineHeight?: number;
+    /** hauteur de ligne imposée, en points (w:lineRule="exact") */
+    lineExactPt?: number;
+    /** hauteur de ligne minimale, en points (w:lineRule="atLeast") */
+    lineMinPt?: number;
+    /** fond de paragraphe (w:shd fill), hex sans # */
+    shdFill?: string;
+    /** encadrement du paragraphe (w:pBdr) — Word dessine le trait ET réserve son `w:space` */
+    borders?: ParaBorders;
+    /** taquets de tabulation explicites (w:tabs), en points depuis la marge, triés */
+    tabStops?: TabStop[];
+    /**
+     * `w:widowControl` — Word l'active par DÉFAUT et refuse alors de laisser une
+     * ligne seule en bas ou en haut d'une page : il descend le paragraphe entier.
+     * Ces matrices le désactivent souvent explicitement (`w:val="0"`).
+     */
+    widowControl?: boolean;
+    /** `w:keepNext` — reste sur la même page que le paragraphe suivant. */
+    keepNext?: boolean;
+    /**
+     * `w:pageBreakBefore` — Word ouvre une page AVANT ce paragraphe.
+     *
+     * 30 documents du corpus, 270 paragraphes. Le manquer ne coûte pas une ligne
+     * mais une PAGE : une fois la frontière ratée, toutes les suivantes le sont.
+     */
+    pageBreakBefore?: boolean;
+    /** `w:keepLines` — le paragraphe ne se coupe pas entre deux pages. */
+    keepLines?: boolean;
+    /**
+     * `w:contextualSpacing` — supprime l'espacement entre deux paragraphes de
+     * MÊME style. 71 % de ces matrices le déclarent : venues du HTML, elles
+     * enchaînent des paragraphes identiques dont Word ne sépare pas les lignes.
+     * Mesuré au banc : 11,52 pt de pas au lieu de 17,52 avec 6 pt déclarés.
+     */
+    contextualSpacing?: boolean;
+    /** `w:textAlignment` — alignement vertical des glyphes dans la ligne. */
+    textAlignment?: 'center' | 'top' | 'bottom';
+    /** `w:framePr` — le paragraphe est un CADRE posé, hors du fil. Voir `FrameInfo`. */
+    frame?: FrameInfo;
+}
+/**
+ * Un paragraphe encadré (`w:framePr`).
+ *
+ * Word le sort du fil et le pose à une position : c'est l'ancêtre de la zone de
+ * texte, et 19 % de ces matrices s'en servent — presque toujours pour le numéro
+ * de page, `w:xAlign="right"` dans un pied. Le laisser dans le fil lui donne la
+ * position du fil (à gauche) ET lui fait réserver sa hauteur : sur FIEF le pied
+ * mesurait 20 pt de haut au lieu de zéro, et le numéro sortait à gauche.
+ *
+ * Les distances sont en points ; `w:x`/`w:y` ne valent que si l'alignement
+ * correspondant est absent.
+ */
+export interface FrameInfo {
+    widthPt?: number;
+    heightPt?: number;
+    xPt?: number;
+    yPt?: number;
+    hAnchor: 'text' | 'margin' | 'page';
+    vAnchor: 'text' | 'margin' | 'page';
+    xAlign?: 'left' | 'center' | 'right' | 'inside' | 'outside';
+    yAlign?: 'top' | 'center' | 'bottom' | 'inside' | 'outside';
+    /** `none` = le texte ne l'habille pas — le cas du numéro de page. */
+    wrap?: string;
+}
+export interface TabStop {
+    posPt: number;
+    align: 'left' | 'center' | 'right' | 'decimal' | 'bar';
+    /**
+     * `w:leader` — le caractère qui REMPLIT le blanc jusqu'au taquet.
+     *
+     * 44 documents du corpus posent 689 conduites en points, 4 en soulignés, 2 en
+     * tirets. Sans elles, une ligne « Lieu de tournage : XXX ............ » se
+     * composait à 68 pt là où Word en fait 524 : le blanc restait blanc.
+     */
+    leader?: string;
+}
+/** Un côté d'encadrement de paragraphe. `spacePt` est déjà en points (w:space
+ *  vaut des points pour w:pBdr, contrairement aux twips habituels). */
+export interface ParaBorder {
+    style: string;
+    sizePt: number;
+    color?: string;
+    spacePt: number;
+}
+export interface ParaBorders {
+    top?: ParaBorder;
+    bottom?: ParaBorder;
+    left?: ParaBorder;
+    right?: ParaBorder;
+    /**
+     * `w:between` — le trait que Word pose ENTRE deux paragraphes qui portent le
+     * même encadrement, à la place du bas de l'un et du haut de l'autre.
+     *
+     * Le moteur fusionnait déjà ces deux paragraphes en un seul cadre et sautait
+     * le trait ; c'est juste quand `w:between` est absent, et faux quand il est
+     * là — 126 documents du corpus le posent, 1849 fois dans leur corps.
+     */
+    between?: ParaBorder;
+}
+export interface PageSetup {
+    widthPt: number;
+    heightPt: number;
+    marginTopPt: number;
+    marginRightPt: number;
+    marginBottomPt: number;
+    marginLeftPt: number;
+    orient?: 'landscape';
+    /** nombre de colonnes (1 par défaut) */
+    columns?: number;
+    /** gouttière entre colonnes, en points */
+    columnGapPt?: number;
+    /** largeurs explicites (w:equalWidth="0") : [largeur, gouttière après] par colonne, en points.
+     *  Word autorise des colonnes inégales — les répartir également décale tout le texte. */
+    columnWidthsPt?: Array<{
+        widthPt: number;
+        spacePt: number;
+    }>;
+    /**
+     * Gouttière de reliure (`w:pgMar/@w:gutter`), en points.
+     *
+     * Word l'AJOUTE à la marge intérieure — la gauche par défaut, le haut si
+     * `w:gutterAtTop`. C'est la marge de reliure d'un document destiné à être
+     * relié ou agrafé ; l'ignorer décale toute la zone de texte de sa valeur, et
+     * ces contrats en portent.
+     */
+    gutterPt?: number;
+    /** la gouttière se prend en HAUT et non à gauche (`w:gutterAtTop`) */
+    gutterAtTop?: boolean;
+    /** distance du bord haut au haut de l'en-tête (w:pgMar/@w:header), en points */
+    headerDistPt?: number;
+    /** distance du bord bas au bas du pied (w:pgMar/@w:footer), en points */
+    footerDistPt?: number;
+    /** références d'en-tête/pied de CETTE section — une section qui n'en déclare
+     *  pas hérite de la précédente, comme chez Word. */
+    headerRefs?: PartRef[];
+    footerRefs?: PartRef[];
+    /**
+     * `w:titlePg` — la première page de la section a ses PROPRES en-tête et pied.
+     *
+     * Sans lui, une référence `w:type="first"` ne doit PAS être utilisée : Word
+     * l'ignore et pose l'en-tête ordinaire. 81 documents du corpus déclarent une
+     * référence « first » sans déclarer `w:titlePg` ; la prendre leur donnait un
+     * en-tête d'une autre hauteur sur la page 1, donc un corps qui démarre au
+     * mauvais y et une page entière décalée.
+     */
+    titlePg?: boolean;
+    /** `w:pgNumType w:start` — numéro auquel la numérotation REPART dans cette section */
+    pageNumStart?: number;
+    /** `w:pgNumType w:fmt` — `decimal` par défaut, `numberInDash` écrit « - 3 - » */
+    pageNumFmt?: string;
+    /** police par défaut du document */
+    fontFamily?: string;
+    fontSizePt?: number;
+}
+/** Référence à un en-tête ou pied : son type Word et l'id de relation. */
+export interface PartRef {
+    type: 'default' | 'first' | 'even';
+    rId: string;
+}
+export interface RunStyle {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    dstrike?: boolean;
+    /** taille en points */
+    sizePt?: number;
+    fontFamily?: string;
+    /** couleur hex sans #, ex. `2F5496` */
+    color?: string;
+    /** surbrillance Word (nom de couleur, ex. `yellow`) */
+    highlight?: string;
+    /** `w:bdr` — cadre autour du RUN, distinct du `w:pBdr` du paragraphe */
+    border?: ParaBorder;
+    vertAlign?: 'superscript' | 'subscript';
+    /**
+     * `w:position` — texte ÉLEVÉ ou abaissé, en points (positif = vers le haut).
+     *
+     * Indépendant de `w:vertAlign` : l'exposant réduit aussi le corps, `w:position`
+     * ne fait que déplacer la ligne de base. Word le compte en demi-points.
+     */
+    positionPt?: number;
+    smallCaps?: boolean;
+    allCaps?: boolean;
+    /** texte masqué */
+    vanish?: boolean;
+    /**
+     * Échelle HORIZONTALE des glyphes (`w:rPr/w:w`), en pourcentage.
+     *
+     * Word étire ou resserre chaque glyphe sans toucher à sa hauteur : à 90 %,
+     * tout le texte est un dixième plus étroit, ce qui change les coupures de
+     * ligne et la position de chaque mot. 285 des 1336 documents du corpus la
+     * déclarent, 45 294 runs à 90 % et 22 028 à 105 %.
+     *
+     * `undefined` vaut 100 %.
+     */
+    scaleW?: number;
+    /**
+     * Interlettrage (`w:rPr/w:spacing/@w:val`), en points.
+     *
+     * Word l'ajoute APRÈS chaque caractère. Sur « Vanished », soixante-neuf runs
+     * portent `w:val="2"` — un dixième de point par caractère, soit douze points
+     * sur une ligne de cent vingt : un mot entier. Nous l'ignorions, nos lignes
+     * sortaient d'autant plus courtes, et chacune gardait un mot que Word renvoie.
+     */
+    letterSpacingPt?: number;
+}
+export interface ImageInfo {
+    /** r:id de l'image dans les relations de la part parente */
+    rId: string;
+    widthPt: number;
+    heightPt: number;
+    /**
+     * `a:srcRect` — la partie de l'image effectivement montrée, en fractions du
+     * fichier source (gauche, haut, droite, bas rognés).
+     *
+     * Word rogne l'image et ÉTIRE la partie restante dans la boîte. L'ignorer
+     * dessine tout le fichier dans la boîte : sur le logo de « Cascadeur FLEUR »,
+     * dont le `a:srcRect` garde 42 % de la largeur et 16 % de la hauteur, le
+     * VIXENS sortait cinq fois trop petit et perdu au milieu d'un cadre vide.
+     */
+    crop?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    /**
+     * Ancrage (`wp:anchor`) : l'image est posée à ces coordonnées et ne prend
+     * aucune place dans le fil. Absent pour une image en ligne (`wp:inline`).
+     *
+     * `relH`/`relV` disent par rapport à quoi : `page`, `margin`, `column`
+     * (= marge gauche du texte) ou `paragraph` (= position courante du fil).
+     * Ignorer les images ancrées faisait disparaître tous les logos d'en-tête.
+     */
+    anchor?: {
+        xPt: number;
+        yPt: number;
+        relH: string;
+        relV: string;
+        /**
+         * Habillage. `none` (`wp:wrapNone`) = l'image flotte et ne prend aucune
+         * place ; tous les autres font que Word RÉSERVE sa hauteur dans le fil.
+         */
+        wrap?: 'none' | 'square' | 'topAndBottom' | 'tight' | 'through';
+    };
+}
+export interface StyledRun {
+    text: string;
+    style: RunStyle;
+    /** présent pour les runs image (text est vide) */
+    image?: ImageInfo;
+    /**
+     * Marqueur libre posé par l'appelant, ignoré du rendu.
+     *
+     * Sert à retrouver *où* un run a été dessiné : après healing chaque tag de
+     * matrice occupe son propre run, donc marquer le run suffit à situer le tag
+     * dans la mise en page — sans que le renderer ait à connaître les tags.
+     */
+    mark?: string;
+    /**
+     * Boîte réservée dans le flux, à la place du texte.
+     *
+     * Le renderer l'intègre à sa césure et publie son rectangle, mais n'y peint
+     * rien : c'est ce qui permet à une extension d'insérer son propre affichage
+     * DANS la mise en page plutôt que par-dessus.
+     */
+    box?: {
+        widthPx: number;
+        heightPx: number;
+    };
+    /**
+     * Champ Word dont ce run porte le résultat mis en cache.
+     *
+     * Le .docx garde la dernière valeur calculée par Word — « Page 2 sur 4 » dans
+     * un document qui en fait 9. C'est au rendu de recalculer.
+     */
+    field?: 'page' | 'numPages';
+    /**
+     * Numéro de l'appel de note que ce run porte (1 pour la première du fil).
+     *
+     * Le texte du run porte déjà le chiffre en exposant ; ce champ dit au moteur
+     * QUELLE note de `word/footnotes.xml` va au bas de la page où ce run tombe.
+     * Sans lui, le renvoi s'affichait et la note restait invisible.
+     */
+    footnote?: number;
+}
+export interface StyledParagraph {
+    style: ParagraphStyle;
+    runs: StyledRun[];
+}
+/**
+ * Polices de THÈME (`w:asciiTheme="minorHAnsi"`).
+ *
+ * 1043 des 1335 matrices — 78 % — ne nomment jamais leur police : elles
+ * renvoient au thème, qui la déclare dans `word/theme/theme1.xml`. Sans cette
+ * résolution, `w:rFonts` n'a pas de `w:ascii` et la police tombe sur un repli
+ * arbitraire : sur le formulaire « 3 bis », « Segoe UI Symbol » au lieu de
+ * Calibri, donc un interligne de 1,15 au lieu de 1,2207 et 6 % de hauteur
+ * perdue à chaque ligne.
+ *
+ * `major` habille les titres, `minor` le texte courant. `majorCs`/`minorCs`
+ * sont l'emplacement ÉCRITURE COMPLEXE du même thème (`a:cs`) : c'est là que
+ * pointe un `w:asciiTheme="minorBidi"`, et pas sur le latin.
+ */
+export interface ThemeFonts {
+    major?: string;
+    minor?: string;
+    majorCs?: string;
+    minorCs?: string;
+}
+export declare function themeFonts(doc: DocxDocument): ThemeFonts;
+/** Mise en forme de chaque paragraphe de `word/document.xml`, dans l'ordre.
+ *  Résout la cascade : docDefaults → chaîne basedOn → formatage direct. */
+export declare function paragraphStyles(doc: DocxDocument): ParagraphStyle[];
+export declare function styledParagraphs(doc: DocxDocument): StyledParagraph[];
+/** Format de page et police par défaut — A4 portrait si le document ne dit rien.
+ *  Pour les documents multi-sections, utiliser `sections()` à la place. */
+export declare function pageSetup(doc: DocxDocument): PageSetup;
+/**
+ * Toutes les sections du document, dans l'ordre.
+ *
+ * Chaque section a son format de page, ses marges, et ses en-têtes/pieds. Une
+ * section qui ne déclare pas de `headerReference` hérite de la précédente —
+ * c'est la règle de Word, et l'ignorer coûtait 30 pt en haut de chaque page à
+ * partir de la deuxième sur les documents dont seule la première section
+ * déclare son en-tête.
+ */
+export declare function sections(doc: DocxDocument): PageSetup[];
+/**
+ * `w:defaultTabStop` de settings.xml, en points (36 pt si absent).
+ *
+ * C'est l'intervalle des taquets implicites : sans lui, un document réglé à
+ * 1,25 cm voit toutes ses tabulations tomber au mauvais endroit.
+ */
+/**
+ * `w:doNotExpandShiftReturn` — une ligne JUSTIFIÉE qui se termine par un
+ * `w:br` n'est pas étirée à la colonne.
+ *
+ * C'est le comportement de Word depuis 2007, et 115 des 400 documents mesurés
+ * le déclarent. Sans lui, chaque adresse et chaque énumération composée avec
+ * des retours à la ligne dans un paragraphe justifié sortait étirée sur toute
+ * la largeur, un mot par intervalle.
+ */
+/**
+ * `w:ulTrailSpace` — le soulignement couvre l'espace de FIN de ligne.
+ *
+ * Word ne souligne pas les blancs terminaux, sauf si le document le demande.
+ * Nous les soulignions toujours : le trait dépassait le dernier mot de la
+ * largeur d'une espace sur les 165 documents des 400 qui ne posent pas le
+ * drapeau. Les 235 autres le posent, et pour ceux-là notre trait était juste.
+ */
+export declare function underlineTrailingSpace(doc: DocxDocument): boolean;
+/**
+ * `w:evenAndOddHeaders` — les pages PAIRES ont leur propre en-tête et pied.
+ *
+ * 335 documents du corpus déclarent une référence « even », mais **36
+ * seulement** posent le drapeau qui l'active : servir la part « even » sans lui
+ * donnerait à 299 documents un en-tête que Word n'y met pas. Même piège que
+ * `w:titlePg`.
+ */
+export declare function evenAndOddHeaders(doc: DocxDocument): boolean;
+export declare function noExpandShiftReturn(doc: DocxDocument): boolean;
+/**
+ * `w:compatSetting w:name="compatibilityMode"` of settings.xml — the Word
+ * version whose layout rules the document asks for (11 = Word 2003 … 15 =
+ * Word 2013+). Absent means 12, as [MS-OI29500] specifies.
+ */
+export declare function compatibilityMode(doc: DocxDocument): number;
+export declare function defaultTabStopPt(doc: DocxDocument): number;

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

@@ -0,0 +1,63 @@
+import { type DocxDocument } from './index';
+export interface ListInfo {
+    numId: number;
+    level: number;
+    /** habillage de la puce, lu dans `w:lvl/w:rPr` — voir `NumLevel` */
+    markerBold?: boolean;
+    markerItalic?: boolean;
+    markerUnderline?: boolean;
+    markerColor?: string;
+    /** Texte du marqueur résolu (ex. `●`, `1.`, `a)`) */
+    marker: string;
+    /** `w:lvlJc` — 7600 niveaux du corpus alignent leur marqueur à DROITE. */
+    markerAlign?: 'left' | 'right' | 'center';
+    indentLeftPt?: number;
+    indentHangingPt?: number;
+    /** `w:legacy` — boîte du marqueur et espace après, en points */
+    legacyIndentPt?: number;
+    legacySpacePt?: number;
+    /**
+     * Police et corps de la PUCE, déclarés par le niveau de numérotation.
+     *
+     * Word les prend là en priorité, pas sur la marque de paragraphe. Sur
+     * « LES 3 BRESTOISES », le niveau déclare `w:sz w:val="16"` — 8 pt — alors
+     * que la marque en dit 11 : nos lignes de liste sortaient 3,3 pt trop hautes,
+     * et l'écart s'accumulait sur toute la page.
+     */
+    markerFont?: string;
+    markerSizePt?: number;
+    /**
+     * `w:lvlPicBulletId` — la puce est une IMAGE, pas un glyphe.
+     *
+     * `w:numPicBullet` la déclare en tête de `numbering.xml`, sous la forme d'un
+     * `w:pict/v:shape` VML dont l'attribut `style` donne la taille. Word dessine
+     * l'image ; le `w:lvlText` que le niveau garde à côté (`\uF0B7`, la puce
+     * Symbol) n'est qu'un repli de compatibilité, et Word ne l'écrit pas —
+     * vérifié dans son PDF, où la ligne commence directement par son texte.
+     *
+     * Deux documents du corpus, et l'avance du marqueur ne change pas : c'est le
+     * GLYPHE dessiné qui change.
+     */
+    markerImage?: {
+        rId: string;
+        widthPt: number;
+        heightPt: number;
+    };
+    /**
+     * Séparateur entre le marqueur et le texte (`w:suff`, `tab` par défaut).
+     *
+     * Word ne colle jamais le texte contre le numéro : il saute au taquet. Quand
+     * le renfoncement le fixe, c'est le retrait gauche ; sinon c'est un taquet
+     * ordinaire — sur « Vanished », « a) » à 55,1 pt est suivi de « L'Acteur » à
+     * 83,4, soit l'origine de la cellule plus un `w:defaultTabStop`.
+     */
+    suffix?: 'tab' | 'space' | 'nothing';
+}
+/**
+ * `w:numFmt` → le compteur écrit. Sert aussi aux NUMÉROS DE PAGE
+ * (`w:pgNumType/@w:fmt`), qui emploient exactement la même énumération.
+ */
+export declare function formatCounter(value: number, fmt: string): string;
+/** Résout les listes pour chaque paragraphe du document (tableau parallèle à `paragraphs(doc)`).
+ *  `undefined` = pas un élément de liste. Maintient les compteurs en séquence. */
+export declare function resolveNumbering(doc: DocxDocument): (ListInfo | undefined)[];

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

@@ -0,0 +1,51 @@
+import { type DocxDocument } from './index';
+import { type DocPos } from './editor';
+import { type PastedRun } from './insert';
+/**
+ * Ce qu'un collage apporte de plus que du texte : des listes, des tableaux,
+ * des images.
+ *
+ * Le presse-papiers ne rend pas une suite de runs mais une STRUCTURE — un `li`
+ * n'est pas un paragraphe indenté, c'est un paragraphe qui pointe une
+ * numérotation ; un `td` n'est pas un texte séparé par des tabulations. Les
+ * traduire demande d'écrire dans `numbering.xml` et de fabriquer un `w:tbl`,
+ * chacun avec ses règles.
+ */
+export type PastedBlock = {
+    kind: 'para';
+    runs: PastedRun[];
+    list?: {
+        level: number;
+        ordered: boolean;
+    };
+}
+/** Rangs → cellules → runs. Une cellule vide est un tableau de runs vide. */
+ | {
+    kind: 'table';
+    rows: PastedRun[][][];
+} | {
+    kind: 'image';
+    data: Uint8Array;
+    ext: string;
+    widthPt: number;
+    heightPt: number;
+};
+/**
+ * Un `w:numId` bon pour une liste collée — trouvé, ou créé.
+ *
+ * On RÉUTILISE la première liste du document dont le niveau 0 a le bon format :
+ * en fabriquer une par collage remplirait `numbering.xml` de définitions
+ * jumelles, et Word les montrerait toutes dans sa galerie. Le fichier peut
+ * manquer entièrement — c'est le cas d'un document qui n'a jamais eu de liste,
+ * et il faut alors l'ajouter au paquet : la part, son type, sa relation.
+ */
+export declare function ensureListNum(doc: DocxDocument, ordered: boolean): number | null;
+/**
+ * Colle une suite de blocs au point, et rend où le curseur se retrouve.
+ *
+ * Un tableau et une image ne s'insèrent pas DANS un paragraphe : on coupe au
+ * point, et le bloc se glisse entre les deux moitiés. Le rang du paragraphe
+ * d'après avance alors de tout ce que le bloc apporte — une cellule est un
+ * paragraphe comme un autre dans l'adressage du modèle.
+ */
+export declare function pasteBlocks(doc: DocxDocument, at: DocPos, blocks: PastedBlock[]): DocPos | null;

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

@@ -0,0 +1,18 @@
+import { type DocxDocument } from './index';
+/**
+ * Résolution des relations OPC (`.rels`).
+ *
+ * ponytail: lookup table pure, pas de traversée récursive des parts liées.
+ * Le consommateur résout rId → target, puis accède à doc.xml[target] ou doc.bin[target].
+ */
+export interface Relationship {
+    /** type court (ex. `image`, `header`, `hyperlink`, `styles`) */
+    type: string;
+    /** chemin résolu dans le zip, ou URL externe */
+    target: string;
+    /** true pour les liens externes (hyperlinks, etc.) */
+    external: boolean;
+}
+/** Résout les relations OPC pour une part donnée.
+ *  Par défaut : `word/document.xml` → ses headers, images, hyperlinks, etc. */
+export declare function relationships(doc: DocxDocument, partPath?: string): Map<string, Relationship>;

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

@@ -0,0 +1,69 @@
+import { type XmlNode } from './index';
+/**
+ * Adressage d'un paragraphe : où commence et finit chaque run, en caractères.
+ *
+ * C'est la **couture** entre la lecture et l'écriture. La lecture
+ * (`styledParagraphs` → renderer → curseur) rend une position à l'écran sous
+ * la forme d'un rang de caractère dans un paragraphe ; l'écriture
+ * (`healTags`, `replaceRange`) doit retrouver le run qui porte ce caractère.
+ * Si les deux ne comptent pas les mêmes caractères, une position lue à l'écran
+ * ne désigne pas celui qu'on réécrit — et l'éditeur écrit à côté, sans rien
+ * signaler.
+ *
+ * Le piège qui a motivé ce fichier : `styledParagraphs` descend dans les
+ * conteneurs inline (`w:hyperlink`, `w:sdt`, `w:ins`…), l'écriture ne regardait
+ * que les `w:r` enfants DIRECTS du `w:p`. Dans un paragraphe qui porte un lien,
+ * les deux comptes divergent. Une seule fonction les tient désormais d'accord.
+ */
+/**
+ * Marque d'un `w:br` ou `w:tab` dans le texte d'adressage.
+ *
+ * Un non-caractère : `TAG_RE` l'exclut, donc aucun tag ne peut se recoudre
+ * par-dessus un saut ou une tabulation. Il occupe UN caractère, exactement
+ * comme le `\t` / `\n` / `\f` que produit `styledParagraphs` au même endroit —
+ * c'est ce qui aligne les deux comptes.
+ */
+export declare const SENTINEL = "\uFFFE";
+/**
+ * Conteneurs traversés pour atteindre les runs.
+ *
+ * Word enveloppe des runs dans un lien, un contrôle de contenu ou une marque
+ * de révision sans que ça change le texte affiché. La vue typée les traverse ;
+ * l'adressage doit traverser les mêmes, sinon les offsets divergent.
+ */
+export declare const RUN_CONTAINERS: Set<string>;
+/** Texte d'un run, SENTINEL pour chaque `w:br` / `w:tab`. */
+export declare function runText(run: XmlNode): string;
+/**
+ * Un run et la plage de caractères qu'il occupe dans son paragraphe.
+ *
+ * `parent` et non le `w:p` : un run peut vivre dans un conteneur inline, et
+ * c'est dans CE tableau qu'il faut découper pour le remplacer.
+ */
+export interface RunSpan {
+    /** tableau qui contient le run — enfants du `w:p`, ou d'un conteneur inline */
+    parent: XmlNode[];
+    /** rang du run dans `parent` */
+    idx: number;
+    /** bornes dans le texte du paragraphe, `[start, end)` */
+    start: number;
+    end: number;
+}
+/**
+ * Découpe un paragraphe en runs adressables, dans l'ordre de lecture.
+ *
+ * Les runs sans texte (une image seule, un code de champ) n'occupent aucun
+ * caractère et ne produisent donc pas de span — la vue typée n'en produit pas
+ * de `StyledRun` non plus.
+ */
+export declare function runSpans(p: XmlNode): {
+    spans: RunSpan[];
+    text: string;
+};
+/**
+ * Runs qui portent au moins un caractère de la plage `[from, to)`.
+ *
+ * Une plage vide — un curseur, pas une sélection — désigne le run qui la
+ * contient, pour que l'insertion hérite de sa mise en forme.
+ */
+export declare function spansIn(spans: RunSpan[], from: number, to: number): RunSpan[];

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

@@ -0,0 +1,42 @@
+import { type DocxDocument, type XmlNode } from './index';
+/**
+ * Résolution de la cascade de styles OOXML.
+ *
+ * ponytail: on fusionne les nœuds XML bruts, on ne type rien ici.
+ * Les vues typées (layout.ts) lisent le résultat fusionné.
+ * Pas de résolution numbering/table-style — ajout quand le renderer les exige.
+ */
+export interface StyleDef {
+    type: string;
+    basedOn?: string;
+    pPr?: XmlNode;
+    rPr?: XmlNode;
+    /** `w:tblPr` d'un style de TABLEAU — c'est de là que viennent ses bordures */
+    tblPr?: XmlNode;
+    /**
+     * `w:tblStylePr` — mise en forme CONDITIONNELLE du style de tableau, un
+     * nœud par `w:type` : `firstRow`, `lastRow`, `firstCol`, `lastCol`,
+     * `band1Horz`/`band2Horz`, `band1Vert`/`band2Vert`, et les quatre coins.
+     * 14 documents du corpus en portent, 733 nœuds.
+     */
+    tblStylePr?: XmlNode[];
+    /** `w:default="1"` — le style que Word applique quand `w:pStyle` est absent */
+    isDefault?: boolean;
+}
+export interface DocDefaults {
+    pPr?: XmlNode;
+    rPr?: XmlNode;
+}
+/** Fusionne deux nœuds de propriétés (w:pPr ou w:rPr).
+ *  Chaque enfant du second remplace l'enfant de même tag dans le premier. */
+export declare function mergePr(base: XmlNode | undefined, over: XmlNode | undefined): XmlNode | undefined;
+/** Valeurs par défaut du document (w:docDefaults dans styles.xml). */
+export declare function docDefaults(doc: DocxDocument): DocDefaults;
+/** Carte { styleId → définition } extraite de styles.xml. */
+export declare function styleMap(doc: DocxDocument): Map<string, StyleDef>;
+/** Résout un style via sa chaîne basedOn, fusionné avec les défauts du document.
+ *  Retourne les nœuds pPr et rPr fusionnés, prêts pour extraction de propriétés. */
+export declare function resolveStyle(map: Map<string, StyleDef>, defaults: DocDefaults, styleId: string | undefined): {
+    pPr?: XmlNode;
+    rPr?: XmlNode;
+};