myrole-docx-editor 0.1.0

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

@@ -0,0 +1,196 @@
+import { type DocxDocument, type XmlNode } from './index';
+/** Un élément de cellule : un paragraphe du fil, ou un tableau imbriqué. */
+export type CellBlock = {
+    kind: 'p';
+} | {
+    kind: 'tbl';
+    table: TableInfo;
+};
+export interface CellInfo {
+    widthPt?: number;
+    /** nombre de colonnes fusionnées (1 = pas de fusion) */
+    gridSpan: number;
+    /** fusion verticale : `restart` = première cellule, `continue` = suite, absent = pas de fusion */
+    vMerge?: 'restart' | 'continue';
+    /** couleur de fond hex (sans #) */
+    fill?: string;
+    vAlign?: 'top' | 'center' | 'bottom';
+    /**
+     * Bordures propres à la cellule (`w:tcBorders`).
+     *
+     * Beaucoup de tableaux ne déclarent RIEN au niveau de la table et tout au
+     * niveau des cellules — la grille horaire de Colo 2 en est une. Les ignorer
+     * faisait disparaître ses traits, et privait chaque rang des 0,5 pt que Word
+     * compte pour eux.
+     */
+    borders?: TableBorders;
+    /**
+     * Marges intérieures propres à la cellule (`w:tcPr/w:tcMar`).
+     *
+     * Elles remplacent celles du tableau et de son style, côté par côté. 55
+     * documents du corpus en déclarent, et sans elles ces cellules-là posaient
+     * leur texte à la marge du tableau au lieu de la leur.
+     */
+    marginPt?: Partial<{
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    }>;
+    /** paragraphes bruts de la cellule — à passer à styledParagraphs ou paragraphText */
+    paragraphs: XmlNode[];
+    /**
+     * Contenu de la cellule dans l'ordre : ses paragraphes ET ses tableaux
+     * IMBRIQUÉS. `paragraphs` sert au décompte du fil, `content` au dessin.
+     *
+     * Un tableau imbriqué est courant dans ces matrices : sur « Vanished », tout
+     * le corps tient dans un tableau, et chaque formulaire d'état civil est un
+     * second tableau dans une de ses cellules. Les ignorer aplatissait le
+     * formulaire en une colonne — « Nom : » puis « Nom de Jeune Fille : » l'un
+     * sous l'autre, là où Word les met côte à côte.
+     */
+    content: CellBlock[];
+}
+export interface RowInfo {
+    heightPt?: number;
+    /**
+     * `w:hRule` : comment lire `heightPt`.
+     *
+     * `atLeast` (défaut) en fait un minimum, `exact` une hauteur IMPOSÉE — Word
+     * y rogne ce qui dépasse — et `auto` l'ignore. Tout traiter en minimum
+     * gonflait chaque rang du formulaire de La Stagiaire de 1,7 pt : ses neuf
+     * rangs déclarent 372 twips exacts, soit 18,6 pt, et nous en composions 20,3.
+     */
+    heightRule?: 'auto' | 'atLeast' | 'exact';
+    /**
+     * `w:tblPrEx` — propriétés du tableau redéfinies pour CE rang.
+     *
+     * Word garde ces exceptions quand deux tableaux ont été fusionnés ou qu'un
+     * rang a été collé d'ailleurs : le rang conserve alors les marges et les
+     * bordures de son tableau d'origine. 49 documents du corpus en portent, et
+     * l'exception la plus fréquente est `w:tblCellMar` (29 documents).
+     *
+     * Elle s'intercale entre le niveau TABLEAU et le niveau CELLULE.
+     */
+    cellMarginPt?: Partial<{
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    }>;
+    /**
+     * `w:gridBefore` — colonnes de la grille que ce rang SAUTE avant sa première
+     * cellule. Le rang commence alors décalé de leur largeur cumulée.
+     *
+     * Son symétrique `w:gridAfter` ne déplace rien — les abscisses sont posées
+     * depuis le début de la grille — mais il décide de la BORDURE : la dernière
+     * cellule d'un rang raccourci ne touche pas le bord droit du tableau.
+     */
+    gridBefore?: number;
+    /**
+     * `w:cantSplit` — ce rang ne se coupe PAS en travers d'une page.
+     *
+     * 106 documents du corpus le posent, 302 rangs. Sans lui, généraliser la
+     * coupure de rang casse exactement ceux qui l'interdisent.
+     */
+    cantSplit?: boolean;
+    /**
+     * `w:gridAfter` — colonnes de la grille que ce rang laisse VIDES après sa
+     * dernière cellule. Symétrique de `gridBefore` : le rang s'arrête avant le
+     * bord droit du tableau, et sa dernière cellule ne porte donc pas la bordure
+     * droite de la table.
+     */
+    gridAfter?: number;
+    /**
+     * `w:tblHeader` — rang d'en-tête, REPÉTÉ en haut de chaque page que le
+     * tableau traverse. 17 documents du corpus, 118 rangs.
+     */
+    header?: boolean;
+    /** `w:tblCellSpacing` du rang — écrase celui du tableau */
+    cellSpacingPt?: number;
+    cells: CellInfo[];
+}
+export interface BorderDef {
+    style: string;
+    sizePt: number;
+    color?: string;
+}
+export interface TableBorders {
+    top?: BorderDef;
+    bottom?: BorderDef;
+    left?: BorderDef;
+    right?: BorderDef;
+    insideH?: BorderDef;
+    insideV?: BorderDef;
+}
+export interface TableInfo {
+    widthPt?: number;
+    align?: 'left' | 'center' | 'right';
+    /**
+     * `w:tblLayout w:type="fixed"` — la grille est FIGÉE, pas ajustée au contenu.
+     *
+     * Sans effet mesurable sur ce corpus : Word écrit la grille qu'il a calculée
+     * dans le fichier, et la réutilise à l'ouverture même en autofit. Comparé sur
+     * les documents à tableau, l'écart horizontal médian vaut 0,05 pt des deux
+     * côtés (voir boucle-fidelite.md). Lu par exigence de couverture, et pour que
+     * l'écrivain puisse le préserver.
+     */
+    layoutFixed?: boolean;
+    /**
+     * Retrait depuis la marge gauche, en points (`w:tblInd`).
+     *
+     * Word l'applique au bord du tableau, pas à son contenu. Il vaut souvent
+     * 108 twips — 5,4 pt — et l'ignorer décale toute la grille : mesuré à 12 px
+     * sur `template-77.docx` à 150 dpi.
+     */
+    indentPt?: number;
+    /**
+     * Tableau FLOTTANT ancré VERTICALEMENT (`w:tblpPr w:vertAnchor` + `w:tblpY`).
+     *
+     * Le haut du tableau est posé à `floatTopPt` du bord de la feuille
+     * (`page`) ou de la marge haute (`margin`), et pas là où le fil en est.
+     * Word accepte que ce soit AU-DESSUS de la marge : « Avenant The Land »
+     * ancre sa grille à 27,2 pt d'une feuille dont la marge haute vaut 36, et
+     * tout le document y vit — 8,2 pt d'écart sur ses 91 lignes.
+     *
+     * L'ancrage `text`, qui est le défaut et compte 108 des 118 cas du corpus,
+     * n'est pas concerné : il ne déplace rien.
+     */
+    floatTopPt?: number;
+    floatFrom?: 'page' | 'margin';
+    /**
+     * A SMALL floating table anchored to the text (`w:tblpPr` with
+     * `w:vertAnchor="text"` and a horizontal anchor on the page or the margin),
+     * no wider than an inch: Word draws it beside the flow, which goes on at
+     * the same height. The GAUMONT matrices put a 36 pt checkbox at the page's
+     * right edge before each « □ Vous refusez… » line; composing it in the flow
+     * cost 22 pt and a page break. 55 documents of the bench carry one, 48 of
+     * them broken.
+     */
+    floatBeside?: boolean;
+    /** its left edge from the page's left edge, in points (page anchor only) */
+    floatXPt?: number;
+    /** largeur de chaque colonne de la grille, en points */
+    gridColsPt: number[];
+    /** bordures du tableau — absent = pas de tblBorders explicite */
+    borders?: TableBorders;
+    /** marges intérieures des cellules (w:tblCellMar), en points */
+    cellMarginPt?: {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    };
+    /** `w:tblCellSpacing` du tableau — un rang peut le redéfinir */
+    cellSpacingPt?: number;
+    rows: RowInfo[];
+}
+/**
+ * Les tableaux de PREMIER NIVEAU, dans l'ordre du document.
+ *
+ * Les imbriqués n'y figurent pas : ils vivent dans le `content` de leur
+ * cellule. Les inclure ici décalait les index — `bodyBlocks` ne compte que les
+ * tableaux de premier niveau, si bien qu'après le premier tableau à imbriqué,
+ * chaque bloc désignait le mauvais tableau.
+ */
+export declare function tables(doc: DocxDocument): TableInfo[];

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

@@ -0,0 +1,61 @@
+import { type DocxDocument, type XmlNode } from './index';
+/**
+ * Zones de texte ancrées du corps (`w:txbxContent`).
+ *
+ * Word les pose à des coordonnées, hors du fil : elles ne décalent pas le texte
+ * courant et ne comptent pas dans la pagination. On les excluait donc du fil
+ * (leurs paragraphes fausseraient tous les index) — mais on ne les dessinait pas
+ * pour autant, et leur contenu disparaissait. Sur Colo 2, un bloc de tarifs de
+ * 378 caractères manquait, et son absence décalait la frontière page 6/7 : les
+ * pages 7 à 9 n'avaient plus un seul mot à sa place.
+ *
+ * Une zone est rattachée au paragraphe du FIL qui porte son ancre — c'est lui
+ * qui décide sur quelle page elle atterrit.
+ */
+export interface TextBoxInfo {
+    /** index, dans `paragraphs(doc)`, du paragraphe qui porte l'ancre */
+    paraIndex: number;
+    /** décalage de l'ancre, en points */
+    xPt: number;
+    yPt: number;
+    /** repères de `wp:positionH` / `wp:positionV` : page, margin, column, paragraph */
+    relH: string;
+    relV: string;
+    widthPt: number;
+    heightPt: number;
+    /** marges internes du cadre (`a:bodyPr`), en points — voir `insets` */
+    insetLeftPt: number;
+    insetTopPt: number;
+    insetRightPt: number;
+    /**
+     * Mode d'habillage. `none` = l'objet flotte devant ou derrière le texte et ne
+     * prend aucune place ; tous les autres font que Word RÉSERVE sa hauteur dans
+     * le fil. Sur Colo 2, deux blocs en `wrapSquare` de 61 et 49 pt décidaient à
+     * eux seuls de la frontière entre les pages 6 et 7.
+     */
+    wrap: 'none' | 'square' | 'topAndBottom' | 'tight' | 'through';
+    /** paragraphes bruts de la zone — à styler comme ceux d'un en-tête */
+    paragraphs: XmlNode[];
+    /** `wp:inline` : la zone part du RETRAIT de son paragraphe, pas de la marge */
+    inline?: boolean;
+}
+/**
+ * Les cinq modes d'habillage de DrawingML, nommés.
+ *
+ * `wp:wrapNone` fait flotter l'objet devant ou derrière le texte : il ne prend
+ * aucune place. `wp:wrapTopAndBottom` lui donne sa propre bande — le texte
+ * reprend dessous, toute sa hauteur est réservée. `wp:wrapSquare`,
+ * `wp:wrapTight` et `wp:wrapThrough` font passer le texte À CÔTÉ.
+ */
+export declare const WRAP_TAGS: Record<string, TextBoxInfo['wrap']>;
+export declare function cssPt(style: string, prop: string): number | undefined;
+export declare function textBoxes(doc: DocxDocument): TextBoxInfo[];
+/**
+ * Zones ancrées portées par une liste de paragraphes quelconque.
+ *
+ * Les en-têtes et pieds en ont aussi — le paraphe « Paraphes Salarié.e » de
+ * Colo 2 en est une. On les excluait du fil pour ne pas les voir surgir à
+ * gauche, mais rien ne les dessinait ensuite : elles disparaissaient purement
+ * et simplement du rendu.
+ */
+export declare function textBoxesIn(flow: XmlNode[]): TextBoxInfo[];

package/dist/types/packages/docx-render/src/border.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Un style de bordure Word n'est pas toujours UN trait.
+ *
+ * `w:val="double"` en dessine deux, `triple` trois, `threeDEmboss` deux tons,
+ * et les pointillés un seul mais haché. Le moteur ne connaissait que le trait
+ * plein : `rules.ts` retrouvait 46 % des traits de Word, et le document qui en
+ * perdait le plus opposait trois filets parallèles chez Word à un seul chez
+ * nous.
+ *
+ * Ce que le corpus emploie, sur 400 documents :
+ *
+ *   single 12846 (320 doc) · double 296 (10) · threeDEmboss/Engrave 302 (6)
+ *   dotted 119 (5) · thickThinLargeGap 80 (1) · triple 16 (1)
+ *
+ * Les proportions viennent d'ECMA-376 : la LARGEUR DÉCLARÉE est celle de
+ * l'ensemble, filets et jours compris. Un `double` de 3 pt fait donc trois
+ * bandes d'un point — trait, jour, trait — et non deux traits de 3 pt.
+ */
+/** Un filet : son décalage par rapport à l'axe, et son épaisseur. */
+export interface Stroke {
+    offset: number;
+    width: number;
+}
+/** Motif de tirets, en multiples de l'épaisseur. Vide = trait plein. */
+export declare function dashPattern(style: string, w: number): number[];
+/**
+ * Les filets d'un style, pour une largeur totale `w`.
+ *
+ * L'axe est le milieu de la bordure : un filet à l'offset 0 le recouvre.
+ */
+export declare function borderStrokes(style: string, w: number): Stroke[];
+/**
+ * Hauteur totale occupée par un style, de son bord extérieur à l'autre — ce
+ * que Word RÉSERVE au-dessus ou au-dessous du texte, `w:space` non compris.
+ * Vaut `w` pour tout, sauf les styles 3D qui en prennent le double.
+ */
+export declare function borderExtent(style: string, w: number): number;
+/** Contrôle : la somme des filets ne dépasse jamais la largeur déclarée — sauf les 3D, mesurés au double. */
+export declare function borderSelfTest(): void;

package/dist/types/packages/docx-render/src/document.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A parsed .docx, turned into everything `render()` needs.
+ *
+ * This lived in the canvas app, which meant the only way to lay a document out
+ * was to load it in a browser. It is pure — no DOM, no fetch, no canvas — so
+ * moving it here lets Node compose the same document from the same inputs, and
+ * removes the risk of the two paths drifting apart.
+ *
+ * Images are the one thing it cannot resolve on its own: decoding a PNG needs
+ * a platform. The caller passes them in, or leaves them out.
+ */
+import { styledParagraphs, type DocxDocument, type XmlNode } from '../../docx-model/src/index';
+import type { BodyBlock, TableInfo } from '../../docx-model/src/index';
+import type { Footnotes } from './types';
+import type { RenderInput } from './renderer';
+/** Applies the document's full style cascade to paragraphs that are not in the flow. */
+export declare function styleParagraphs(doc: DocxDocument, paras: XmlNode[]): import("../../docx-model/src/index").StyledParagraph[];
+/**
+ * A header/footer part, laid out like a body — paragraphs AND tables.
+ *
+ * Flattening the part to a list of paragraphs stacks a table's cells one under
+ * the other instead of side by side. Word composes them as a grid, so the two
+ * columns of a letterhead share a baseline; we produced twice the height and
+ * the wrong x. And a header's height sets the body top on EVERY page, so the
+ * whole document shifted — 54.3 pt on "Avenant Désanchantées", constant to
+ * within 0.2 pt. 42 corpus documents carry a table in a header or a footer.
+ *
+ * The trick is to hand the part to the machinery that already knows how to do
+ * this: rebuild it as a virtual `word/document.xml` and call the very same
+ * `styledParagraphs`, `bodyBlocks` and `tables` the body uses. No second
+ * implementation to keep in step, and the paragraph indices that `bodyBlocks`
+ * emits line up with `styledParagraphs` by construction.
+ */
+export declare function partContent(doc: DocxDocument, partPath: string): {
+    paragraphs: ReturnType<typeof styledParagraphs>;
+    blocks: BodyBlock[];
+    tables: TableInfo[];
+};
+/**
+ * Les notes de bas de page, composées comme des paragraphes du corps.
+ *
+ * `word/footnotes.xml` range les notes dans l'ordre de leurs renvois, après
+ * deux fausses notes (`w:type="separator"` et `"continuationSeparator"`) que
+ * Word réserve au filet. La n-ième vraie note est donc l'appel n° n du fil —
+ * ce que `w:footnoteReference` numérote de son côté.
+ *
+ * ponytail: paragraphes seulement. Une note qui contient un TABLEAU sortira
+ * aplatie ; aucun des quatre documents du corpus qui ont des notes n'en a.
+ */
+export declare function footnoteContent(doc: DocxDocument): Footnotes | undefined;
+/** Paragraphs only — kept for callers that do not lay out tables. */
+export declare function partParagraphs(doc: DocxDocument, partPath: string): import("../../docx-model/src/index").StyledParagraph[];
+/** Everything `render()` needs, except the surface and the images. */
+export type DocumentLayout = Omit<RenderInput, 'container' | 'newPage' | 'images'>;
+export declare function buildRenderInput(doc: DocxDocument): DocumentLayout;

package/dist/types/packages/docx-render/src/font-advances.d.ts

@@ -0,0 +1 @@
+export declare const FONT_MEASURERS: Record<string, (text: string) => number>;

package/dist/types/packages/docx-render/src/hit.d.ts

@@ -0,0 +1,94 @@
+import type { LineTrace } from './types';
+/**
+ * Du pixel à l'adresse, et retour.
+ *
+ * Le renderer publie déjà où il a dessiné chaque mot ; depuis que la trace
+ * porte aussi le rang du paragraphe et celui du premier caractère de chaque
+ * mot, elle est une **carte cliquable** du document. Ce fichier ne recalcule
+ * aucune mise en page : il lit ce qui a été dessiné. C'est ce qui rend le
+ * curseur indépendant de la fidélité — il se pose juste là où le texte est,
+ * même si ce n'est pas encore exactement là où Word le mettrait.
+ *
+ * ponytail: pas d'index spatial. Un document de 42 pages publie ~1 500 lignes,
+ * qu'un balayage traverse en moins d'une milliseconde. Un quadtree le jour où
+ * une mesure le réclame.
+ */
+/**
+ * Adresse d'un point dans le document.
+ *
+ * `part` dit dans quel fichier du zip vit le paragraphe — `undefined` pour le
+ * corps. Sans lui, le paragraphe 0 d'un en-tête et celui du corps auraient la
+ * même adresse.
+ */
+export interface DocPos {
+    para: number;
+    off: number;
+    part?: string;
+}
+/** Une adresse et le trait qui la matérialise, en px CSS relatifs à sa page. */
+export interface CaretRect extends DocPos {
+    page: number;
+    x: number;
+    top: number;
+    height: number;
+}
+/** Un rectangle de sélection sur une ligne, en px CSS relatifs à sa page. */
+export interface SelRect {
+    page: number;
+    x: number;
+    top: number;
+    width: number;
+    height: number;
+}
+/**
+ * Lignes adressables : celles dont le renderer a publié le rang du paragraphe.
+ *
+ * Le corps, mais aussi les en-têtes et pieds depuis qu'ils portent le chemin de
+ * leur part. Ce qui reste dehors — les zones de texte ancrées — n'a pas
+ * d'adresse dans le modèle, et le curseur ne s'y pose pas.
+ */
+export declare function editableLines(lines: LineTrace[]): LineTrace[];
+/**
+ * Comment traduire une abscisse en rang de caractère.
+ *
+ * `caret` cherche la FRONTIÈRE la plus proche — c'est là qu'on pose un curseur,
+ * et cliquer sur la moitié droite d'une lettre place le trait après elle.
+ * `char` cherche le CARACTÈRE survolé, ce que réclame un double-clic : cliquer
+ * sur la première lettre d'un mot doit prendre ce mot, pas celui d'avant parce
+ * que sa frontière était deux pixels plus près.
+ */
+export type HitMode = 'caret' | 'char';
+/**
+ * Adresse éditable la plus proche d'un point de la page.
+ *
+ * Un clic dans une marge, entre deux paragraphes ou sous la dernière ligne ne
+ * doit pas être perdu : à défaut de ligne sous le curseur, on prend la plus
+ * proche verticalement — c'est ce que fait Word.
+ */
+export declare function hitTest(lines: LineTrace[], page: number, x: number, y: number, mode?: HitMode): CaretRect | null;
+/** Trait du curseur pour une adresse — `null` si elle n'a pas été dessinée. */
+export declare function caretAt(lines: LineTrace[], pos: DocPos, page?: number): CaretRect | null;
+/** Ordonne deux adresses — une sélection se tire dans les deux sens. */
+export declare function ordered(a: DocPos, b: DocPos): [DocPos, DocPos];
+export declare const samePos: (a: DocPos | null, b: DocPos | null) => boolean;
+/**
+ * Rectangles à surligner pour une sélection, un par ligne traversée.
+ *
+ * Une ligne entièrement prise va du premier au dernier mot dessiné : on ne
+ * peint pas jusqu'à la marge. C'est un choix — Word prolonge légèrement — mais
+ * l'encre est ce que la trace connaît vraiment.
+ */
+export declare function selectionRects(lines: LineTrace[], a: DocPos, b: DocPos): SelRect[];
+/** Bornes de caractères effectivement dessinées pour un paragraphe. */
+export declare function paraRange(lines: LineTrace[], para: number, part?: string): {
+    from: number;
+    to: number;
+} | null;
+/**
+ * Ligne au-dessus ou au-dessous, à la même abscisse — les flèches verticales.
+ *
+ * Word garde l'abscisse VOULUE pendant une suite de flèches : passer sur une
+ * ligne courte puis revenir ne doit pas ramener le curseur au bord. L'appelant
+ * conserve donc `wantX` et nous le repasse.
+ */
+export declare function verticalStep(lines: LineTrace[], pos: DocPos, dir: -1 | 1, wantX: number): DocPos | null;

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

@@ -0,0 +1,12 @@
+export { render } from './renderer';
+export { PT_PX } from './types';
+export type { RenderInput, RenderOptions, ResumeState } from './renderer';
+export type { ImageMap, ImageRect, LineTrace, MarkRect, PlacedTextBox, RowTrace, RuleTrace, SectionParts, TableRect, } from './types';
+export { caretAt, editableLines, hitTest, ordered, paraRange, samePos, selectionRects, verticalStep, } from './hit';
+export type { CaretRect, DocPos, HitMode, SelRect } from './hit';
+export { buildRenderInput, footnoteContent, partParagraphs, styleParagraphs } from './document';
+export type { DocumentLayout } from './document';
+export { NodeRenderingContext, nodeSurface } from './node-ctx';
+export type { FontLoader } from './node-ctx';
+export { borderStrokes, borderSelfTest, dashPattern } from './border';
+export { keepsWord, MAX_SHRINK, MIN_STRETCH, STRETCH_RATIO } from './text';

package/dist/types/packages/docx-render/src/metrics.d.ts

@@ -0,0 +1,6 @@
+export declare const FONT_LINE_RATIO: Record<string, number>;
+/** Ratio par défaut quand la police est inconnue — celui d'Arial et de Times. */
+export declare const DEFAULT_LINE_RATIO = 1.15;
+export declare function setLineRatios(r: Record<string, number>): void;
+/** Hauteur de ligne d'une police, en multiple de la taille de police. */
+export declare function lineRatio(family: string | undefined): number;

package/dist/types/packages/docx-render/src/node-ctx.d.ts

@@ -0,0 +1,36 @@
+/** Reads a TTF/OTF file. Node supplies `readFileSync`; a bundler, a fetch. */
+export type FontLoader = (family: string, weight: number, italic: boolean) => ArrayBuffer | undefined;
+export declare class NodeRenderingContext {
+    private load;
+    font: string;
+    letterSpacing: string;
+    fillStyle: string | CanvasGradient | CanvasPattern;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    lineWidth: number;
+    globalAlpha: number;
+    textBaseline: CanvasTextBaseline;
+    fontKerning: CanvasFontKerning;
+    private faces;
+    private stack;
+    constructor(load: FontLoader);
+    private face;
+    measureText(text: string): TextMetrics;
+    save(): void;
+    restore(): void;
+    fillRect(): void;
+    fillText(): void;
+    strokeText(): void;
+    beginPath(): void;
+    moveTo(): void;
+    lineTo(): void;
+    stroke(): void;
+    closePath(): void;
+    rect(): void;
+    clip(): void;
+    drawImage(): void;
+    scale(): void;
+    translate(): void;
+    setLineDash(): void;
+}
+/** A `newPage` for `render()` that composes without a browser. */
+export declare function nodeSurface(load: FontLoader): () => CanvasRenderingContext2D;

package/dist/types/packages/docx-render/src/paragraph.d.ts

@@ -0,0 +1,18 @@
+import type { StyledParagraph, ListInfo } from '../../docx-model/src/index';
+import { type DrawCtx } from './types';
+/**
+ * Composition d'un paragraphe : encadrement, fond, césure, justification.
+ *
+ * Sert au corps, aux en-têtes et pieds, et au contenu des cellules — c'est le
+ * même texte, avec un `DrawCtx` différent.
+ */
+/** Signature d'encadrement — deux paragraphes qui la partagent forment un seul
+ *  cadre chez Word, sans trait entre eux. */
+export declare function borderKey(p: StyledParagraph | undefined): string;
+/** Paragraphe fusionné avec son voisin : on saute le trait qui les séparerait. */
+interface BorderMerge {
+    top?: boolean;
+    bottom?: boolean;
+}
+export declare function drawParagraph(dc: DrawCtx, para: StyledParagraph, listInfo?: ListInfo, merge?: BorderMerge): number;
+export {};

package/dist/types/packages/docx-render/src/parts.d.ts

@@ -0,0 +1,40 @@
+import type { StyledParagraph, PageSetup } from '../../docx-model/src/index';
+import { type ImageMap, type LineTrace, type PageNums, type PartBlocks, type PlacedTextBox, type RuleTrace } from './types';
+/**
+ * En-tête et pied de page. Word les pose dans les marges : l'en-tête grandit
+ * vers le bas depuis `w:header`, le pied vers le HAUT depuis `w:footer`.
+ */
+export declare function drawHeader(ctx: CanvasRenderingContext2D, headerParas: StyledParagraph[], def: {
+    font: string;
+    sizePt: number;
+}, page: PageSetup, headerDistPt: number, onLine?: (l: LineTrace) => void, 
+/** `onRule` : le filet de séparation d'un en-tête est un TRAIT, pas du texte */
+onRule?: (r: RuleTrace) => void, pageNo?: number, defaultTabPt?: number, nums?: PageNums, images?: ImageMap, partPath?: string, blocks?: PartBlocks, 
+/** densité de la surface — les filets d'un tableau d'en-tête s'y accrochent */
+dpr?: number): number;
+/**
+ * Hauteur de FLUX d'un pied de page, en px.
+ *
+ * On le compose en transparent pour le mesurer — c'est ce que `drawFooter`
+ * faisait déjà pour savoir où le poser. Le renderer en a besoin AVANT de
+ * composer le corps : mesuré au banc de sondes (`pied-*`, `pieddist-*`), Word
+ * arrête le corps au plus haut des deux, la marge basse et le HAUT du pied :
+ *
+ *   lignes de pied    0      1      2      4
+ *   dernière ligne  790,6  777,9  765,2  740,0     (marge à 806,4)
+ *
+ * chaque ligne de pied recule le corps d'exactement une hauteur de ligne. Et en
+ * faisant varier `w:footer` seul, le corps ne bouge QUE lorsque le pied remonte
+ * au-dessus de la marge : distance 0 et 283 twips ne changent rien, 1134 recule
+ * le corps de 37,9 pt.
+ */
+export declare function footerFlowHeight(ctx: CanvasRenderingContext2D, footerParas: StyledParagraph[], def: {
+    font: string;
+    sizePt: number;
+}, page: PageSetup, defaultTabPt?: number, images?: ImageMap): number;
+export declare function drawFooter(ctx: CanvasRenderingContext2D, footerParas: StyledParagraph[], def: {
+    font: string;
+    sizePt: number;
+}, page: PageSetup, footerDistPt: number, onLine?: (l: LineTrace) => void, onRule?: (r: RuleTrace) => void, pageNo?: number, defaultTabPt?: number, nums?: PageNums, images?: ImageMap, boxes?: PlacedTextBox[], partPath?: string, 
+/** densité de la surface — les filets d'un tableau de pied s'y accrochent */
+dpr?: number): void;