@json-to-office/core-docx 7.2.0 → 7.3.0

package/dist/renderers/chartText.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A native chart's text roles, shared by both DOCX renderers.
+ *
+ * The IR carries one chart text style, resolved from the theme. A chart part
+ * has more text than that: tick labels, the legend, axis titles and the chart
+ * title. Which of them takes the style as is, and which adjusts it, is decided
+ * here once, so the two backends cannot drift apart on a chart's type — each
+ * only spells the roles in its own vocabulary.
+ *
+ * No `docx` or `@office-open` import: this sits outside both renderer
+ * directories, and the import boundary forbids either here.
+ */
+import type { DocxIrChartTextFont } from '../ir/types';
+/** Word's chart title size over its chart text size: 14pt over 10pt. */
+export declare const CHART_TITLE_SCALE = 1.4;
+/** One chart text role: face, size in points, colour and weight. */
+export interface ChartTextRole {
+    fontFamily: string;
+    fontSize: number;
+    color: string;
+    bold?: boolean;
+}
+export interface ChartTextRoles {
+    /**
+     * Tick labels and the legend. No weight: as a chart-wide default, a `b`
+     * would also unbold the chart title.
+     */
+    text: ChartTextRole;
+    /**
+     * Axis titles: the chart text at its own weight, which Word would otherwise
+     * draw at its large bold default.
+     */
+    axisTitle: ChartTextRole;
+    /**
+     * The chart title. Once the chart text states a size the title has to state
+     * its own: Word scales an unsized title up from that default, LibreOffice
+     * draws it at the default itself — a title no bigger than a tick label. So
+     * it is written at Word's own ratio, bold as Word draws it.
+     */
+    title: ChartTextRole;
+}
+export declare function chartTextRoles(font: DocxIrChartTextFont): ChartTextRoles;
+//# sourceMappingURL=chartText.d.ts.map

package/dist/renderers/chartText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartText.d.ts","sourceRoot":"","sources":["../../src/renderers/chartText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC,oEAAoE;AACpE,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,EAAE,aAAa,CAAC;IACpB;;;OAGG;IACH,SAAS,EAAE,aAAa,CAAC;IACzB;;;;;OAKG;IACH,KAAK,EAAE,aAAa,CAAC;CACtB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,mBAAmB,GAAG,cAAc,CAYxE"}

package/dist/renderers/docxjs/charts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A native chart on the docx.js renderer: `DocxIrChartRun` → docx 9.8's
+ * `ChartRun`.
+ *
+ * `ChartRun` writes the whole of a chart — the `c:chartSpace` part, its
+ * relationship and the workbook "Edit Data" opens — so this layer only
+ * translates vocabulary. Parity with office-open is on content and placement:
+ * data, series order and names, series colours, every text element's face,
+ * size, colour and weight, the title and axis titles, the legend, the extent
+ * and the anchor, and a chart area with no fill and no border. The plot's
+ * internals — gridlines, tick marks, axis lines, bar gaps — follow what Word
+ * writes for a chart made with Insert Chart, which is what `ChartRun`
+ * defaults to, and office-open writes the same (`../office-open/chartLook.ts`);
+ * a `ChartRun` default that changes has to change there too, or the
+ * cross-backend chart test fails.
+ *
+ * The chart-wide font carries no size in `ChartRun` (`Omit<ChartFont,
+ * "size">`), so every text element states its own. A new text element — data
+ * labels, a data table — has to do the same, or Word draws it at 9pt.
+ *
+ * `docx/charts` is loaded when `render()` starts rather than with the package:
+ * see `docxSubpath.ts`. Only types come from it statically.
+ */
+import type { IFloating, ParagraphChild } from 'docx';
+import type { ChartRunOptions } from 'docx/charts';
+import type { DocxIrChartRun } from '../../ir/types';
+/**
+ * Load `docx/charts`, once per process. Never rejects: a docx without the
+ * entry fails only a document that draws a chart, when it is emitted.
+ * `render()` awaits it; a caller of `buildDocument` with charts must too.
+ */
+export declare function loadDocxCharts(): Promise<void>;
+/**
+ * `DocxIrChartRun` → `ChartRunOptions`.
+ *
+ * Pure, and exported for tests: asserting on options is far cheaper than
+ * unzipping a chart part.
+ */
+export declare function chartRunOptions(chart: DocxIrChartRun, floating?: IFloating): ChartRunOptions;
+/**
+ * A chart run. Throws a named error when `docx/charts` was never loaded, or
+ * could not be — a docx older than 9.8.0.
+ */
+export declare function emitChart(chart: DocxIrChartRun, floating?: IFloating): ParagraphChild;
+//# sourceMappingURL=charts.d.ts.map

package/dist/renderers/docxjs/charts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"charts.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/charts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AACtD,OAAO,KAAK,EAIV,eAAe,EAEhB,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAA6B,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAQhF;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAE9C;AAuBD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,QAAQ,CAAC,EAAE,SAAS,GACnB,eAAe,CAsIjB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,cAAc,EACrB,QAAQ,CAAC,EAAE,SAAS,GACnB,cAAc,CAMhB"}

package/dist/renderers/docxjs/docxSubpath.d.ts

@@ -0,0 +1,34 @@
+/**
+ * A `docx` subpath entry — `docx/charts`, `docx/shapes` — loaded when a
+ * render first asks for it.
+ *
+ * Dynamic rather than static on purpose. `docx` is a peer dependency and those
+ * entries exist from 9.8.0 on: a static import would make the whole package
+ * fail to load (`ERR_PACKAGE_PATH_NOT_EXPORTED`) for a consumer on an older
+ * docx, including one that never draws a chart or a drawing group. tsup keeps
+ * `import('docx/…')` external (`external: ['docx']`), so nothing is inlined
+ * either way; what changes is when the module is evaluated.
+ *
+ * `load()` never rejects. A failed import is kept, and `get()` reports it —
+ * naming the component that needed the entry — only when a document actually
+ * needs it, so a document without one renders on any docx the peer range
+ * allows.
+ *
+ * The importer must be a literal `() => import('docx/…')` at the call site:
+ * that is what tsup keeps external and what `vi.mock('docx/…')` intercepts.
+ */
+export interface DocxSubpath<T> {
+    /** The entry, e.g. `docx/charts`. */
+    readonly specifier: string;
+    /** Start the import (once per process) and wait for it. Never rejects. */
+    load(): Promise<void>;
+    /** Whether the entry loaded. */
+    loaded(): boolean;
+    /**
+     * The loaded module. Throws a named error when `load()` was never awaited
+     * or the import failed.
+     */
+    get(): T;
+}
+export declare function docxSubpath<T>(specifier: `docx/${string}`, component: string, importer: () => Promise<T>): DocxSubpath<T>;
+//# sourceMappingURL=docxSubpath.d.ts.map

package/dist/renderers/docxjs/docxSubpath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docxSubpath.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/docxSubpath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,qCAAqC;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,0EAA0E;IAC1E,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,gCAAgC;IAChC,MAAM,IAAI,OAAO,CAAC;IAClB;;;OAGG;IACH,GAAG,IAAI,CAAC,CAAC;CACV;AAED,wBAAgB,WAAW,CAAC,CAAC,EAC3B,SAAS,EAAE,QAAQ,MAAM,EAAE,EAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACzB,WAAW,CAAC,CAAC,CAAC,CAoChB"}

package/dist/renderers/docxjs/drawingGroup.d.ts

@@ -0,0 +1,79 @@
+/**
+ * A drawing group (`wpg:wgp`), as a `docx/shapes` `ShapeGroupRun`.
+ *
+ * **A group, not a canvas.** `docx/shapes` also has `ShapeCanvasRun`, but a
+ * canvas's children keep their own size, so a canvas authored at one size and
+ * placed at another cannot be expressed; it also writes the whole diagram
+ * twice (`wpc:wpc` plus a `wpg:wgp` fallback in `mc:AlternateContent`). A
+ * group scales its children onto its extent and writes one bare `wpg:wgp`,
+ * which is exactly what the office-open adapter writes.
+ *
+ * **The pad.** `ShapeGroupRun` has no child-space option: it sets `a:chOff`
+ * and `a:chExt` to the union of the children's unrotated boxes. The IR's child
+ * space is the whole canvas, so when the children do not already reach every
+ * edge — any visual without a background — the first (bottom-most) child is an
+ * invisible, decorative rectangle the size of the canvas, the same pad
+ * upstream's own canvas-to-group fallback uses. With a background the union
+ * already is the canvas and no pad is written, so the child list matches
+ * office-open's.
+ *
+ * **The tolerance.** The compiler rounds each offset and extent on its own, so
+ * an element meant to end on the canvas edge can overshoot it by an EMU or
+ * two. Within `OVERFLOW_TOLERANCE_EMU` that counts as reaching the edge: no
+ * pad, and the placed size is kept. Beyond it the children really overflow,
+ * and the group keeps the authored scale — the extent grows by the overflow —
+ * where office-open draws the overflow outside a frame of the placed size.
+ *
+ * **The markers.** docx.js writes two things this adapter must not keep, and
+ * offers no option to leave them out, so each is replaced by a marker the
+ * post-pack repair (`drawingGroupRepair.ts`) removes:
+ * - With no truthy alt text, docx.js describes the group from its children's
+ *   names (`descr="Canvas background. Shape elements[0]."`). A marker
+ *   description suppresses that, and the repair drops the attribute.
+ * - It never writes `wps:cNvSpPr txBox="1"`, which is how Word tells a text box
+ *   from a shape holding text. A marker title on the text box's `wps:cNvPr`
+ *   says where it belongs, and the repair moves it there.
+ * The markers are chosen per IR (`chooseMarkers`) so that no string an author
+ * wrote can contain one: nothing authored is ever stripped, and the repair's
+ * check that no marker survived cannot be tripped by content.
+ *
+ * **Stated defaults.** Where `docx/shapes` defaults differ from OOXML's, the
+ * OOXML default is stated: text anchored at the top rather than centred, no
+ * fill, and no line rather than a black 1pt one.
+ *
+ * **Partial outlines**, as office-open draws them: an outline with no colour
+ * strokes nothing (office-open writes an `a:ln` with no fill), and one with a
+ * colour but no width is a hairline (`w="0"`, office-open's omitted `w`).
+ *
+ * **Clamps.** docx throws for a line width or text inset outside 0–1584pt,
+ * which is also the most `ST_LineWidth` and Word allow; the schema has no
+ * maximum for either, so they are clamped rather than refused. Transparency is
+ * clamped to 0–100 for the same reason.
+ */
+import type { IShapeGroupOptions, ImageSource } from 'docx/shapes';
+import type { DocxIR, DocxIrDrawingGroupRun } from '../../ir/types';
+import { type DrawingGroupFactory, type EmitResources } from './emit';
+export type ShapesModule = typeof import('docx/shapes');
+/** The picture a group child draws, for one resource at one size. */
+export type GroupPictureSource = (resourceId: string, placement: {
+    widthEmu: number;
+    heightEmu: number;
+}) => ImageSource;
+export interface DrawingGroupMarkers {
+    /** A `wp:docPr` description standing for "no alt text". */
+    readonly noAltText: string;
+    /** A `wps:cNvPr` title standing for `wps:cNvSpPr txBox="1"`. */
+    readonly textBox: string;
+}
+export declare const DEFAULT_MARKERS: DrawingGroupMarkers;
+/** Two independent `Math.round` calls in `ir/nativeVisual.ts`: 1 EMU each. */
+export declare const OVERFLOW_TOLERANCE_EMU = 2;
+/**
+ * Markers no string in this IR contains, so the repair can never strip or
+ * trip on authored content.
+ */
+export declare function chooseMarkers(ir: DocxIR): DrawingGroupMarkers;
+export declare function createDrawingGroupFactory(shapes: ShapesModule, pictures: GroupPictureSource, markers: DrawingGroupMarkers): DrawingGroupFactory;
+/** Exported for tests: asserting on the option bag needs no `docx/shapes`. */
+export declare function drawingGroupOptions(group: DocxIrDrawingGroupRun, resources: EmitResources, pictures: GroupPictureSource, markers?: DrawingGroupMarkers): IShapeGroupOptions;
+//# sourceMappingURL=drawingGroup.d.ts.map

package/dist/renderers/docxjs/drawingGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawingGroup.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/drawingGroup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAGH,OAAO,KAAK,EAEV,kBAAkB,EAClB,WAAW,EAIZ,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EACV,MAAM,EAIN,qBAAqB,EAKtB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAGL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACnB,MAAM,QAAQ,CAAC;AAGhB,MAAM,MAAM,YAAY,GAAG,cAAc,aAAa,CAAC,CAAC;AAExD,qEAAqE;AACrE,MAAM,MAAM,kBAAkB,GAAG,CAC/B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KAC/C,WAAW,CAAC;AAEjB,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,eAAO,MAAM,eAAe,EAAE,mBAG7B,CAAC;AAKF,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,mBAAmB,CAa7D;AA+BD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,mBAAmB,GAC3B,mBAAmB,CAKrB;AAED,8EAA8E;AAC9E,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,qBAAqB,EAC5B,SAAS,EAAE,aAAa,EACxB,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,GAAE,mBAAqC,GAC7C,kBAAkB,CAkDpB"}

package/dist/renderers/docxjs/drawingGroupRepair.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Post-pack repair for drawing groups written by `docx/shapes`.
+ *
+ * Runs after `fixFloatingImageIdsInBuffer`, and only for a package whose IR
+ * holds a drawing group. Three things `docx/shapes` writes cannot be stated
+ * through its options, so they are put right here:
+ *
+ * - **Child ids.** Every `wps:cNvPr`/`pic:cNvPr`/`wpg:cNvPr` inside a group is
+ *   drawn from docx's process-wide drawing counter, so the same document came
+ *   out with different ids depending on what the process built before. They
+ *   are renumbered in one sequence that starts after the highest drawing id
+ *   anywhere else in the package, walking the parts in the order
+ *   `fixFloatingImageIds` numbers `wp:docPr` in. Taking the maximum rather
+ *   than assuming a count keeps this pass independent of how that one
+ *   numbers. No connector (`a:stCxn`/`a:endCxn`) is ever emitted, so nothing
+ *   refers to these ids.
+ * - **Rotation.** docx writes `rot` as degrees × 60000 without rounding, and
+ *   `7.123456°` becomes `rot="427407.36"`, which `ST_Angle` (an int) forbids.
+ *   It is rounded — and not wrapped into [0, 360°), exactly as office-open's
+ *   `emitAngle` writes it, so `-30°` stays `rot="-1800000"`.
+ * - **Markers** (see `drawingGroup.ts`): the `wp:docPr` description that stood
+ *   for "no alt text" is dropped, and the `wps:cNvPr` title that stood for a
+ *   text box becomes `wps:cNvSpPr txBox="1"`. A marker that survives means
+ *   docx changed how it serialises one of them; that is a pipeline bug and
+ *   throws, naming the part, rather than shipping a stray attribute.
+ *
+ * Every part holding a group is rewritten unconditionally, for the reason
+ * `fixFloatingImageIds` gives: whether an id "changed" depends on the process
+ * counter, and a rewritten entry is deflated differently from one left alone,
+ * so a changed-only rule would leak the counter into the package bytes.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import type { DrawingGroupMarkers } from './drawingGroup';
+export declare function repairDrawingGroupsInBuffer(buffer: Buffer, markers: DrawingGroupMarkers): Buffer;
+//# sourceMappingURL=drawingGroupRepair.d.ts.map

package/dist/renderers/docxjs/drawingGroupRepair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawingGroupRepair.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/drawingGroupRepair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAOH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAe1D,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,mBAAmB,GAC3B,MAAM,CA0DR"}

package/dist/renderers/docxjs/emit.d.ts

@@ -12,7 +12,7 @@
  *   is dropped by Word and paragraph tab stops only bind to real tab runs.
  */
 import { AlignmentType, Paragraph, Table, TableOfContents, type IParagraphOptions, type IRunOptions, type ParagraphChild } from 'docx';
-import type { DocxIrBlock, DocxIrFloating, DocxIrImageRun, DocxIrInline, DocxIrParagraph, DocxIrParagraphFormatting, DocxIrRunFormatting, DocxIrTable } from '../../ir/types';
+import type { DocxIrBlock, DocxIrDrawingGroupRun, DocxIrFloating, DocxIrImageRun, DocxIrInline, DocxIrParagraph, DocxIrParagraphFormatting, DocxIrRunFormatting, DocxIrTable } from '../../ir/types';
 export declare const ALIGNMENT: Readonly<Record<string, (typeof AlignmentType)[keyof typeof AlignmentType]>>;
 /**
  * Image runs, keyed by IR resource id.
@@ -21,7 +21,15 @@ export declare const ALIGNMENT: Readonly<Record<string, (typeof AlignmentType)[k
  * asynchronous — it rasterises a fallback. So the renderer builds them all
  * before the document, and this layer only places them.
  */
-export type EmitResources = ReadonlyMap<string, ImageRunFactory>;
+export interface EmitResources extends ReadonlyMap<string, ImageRunFactory> {
+    /**
+     * Builds a drawing group's run. Present only when the IR holds one, because
+     * `docx/shapes` is loaded on demand (`drawingGroup.ts`).
+     */
+    readonly drawingGroup?: DrawingGroupFactory;
+}
+/** Builds the run for one drawing group, placed and anchored. */
+export type DrawingGroupFactory = (group: DocxIrDrawingGroupRun, resources: EmitResources) => ParagraphChild;
 /** Builds the run for one placement, which carries its own size and anchor. */
 export type ImageRunFactory = (image: DocxIrImageRun) => ParagraphChild;
 export declare function runOptions(formatting: DocxIrRunFormatting | undefined): IRunOptions;

package/dist/renderers/docxjs/emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,aAAa,EAeb,SAAS,EAMT,KAAK,EAIL,eAAe,EAQf,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAEhB,KAAK,cAAc,EACpB,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EACV,WAAW,EAEX,cAAc,EAEd,cAAc,EACd,YAAY,EACZ,eAAe,EACf,yBAAyB,EAGzB,mBAAmB,EAEnB,WAAW,EAKZ,MAAM,gBAAgB,CAAC;AAExB,eAAO,MAAM,SAAS,EAAE,QAAQ,CAC9B,MAAM,CAAC,MAAM,EAAE,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC,CAQnE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AAEjE,+EAA+E;AAC/E,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,cAAc,CAAC;AA2ExE,wBAAgB,UAAU,CACxB,UAAU,EAAE,mBAAmB,GAAG,SAAS,GAC1C,WAAW,CA8Bb;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,SAAS,GAAE,aAAyB,GACnC,cAAc,EAAE,CAwKlB;AAyDD,gDAAgD;AAChD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwEzB;AA4CD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,yBAAyB,GAAG,SAAS,GAChD,OAAO,CAAC,iBAAiB,CAAC,CAoE5B;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,eAAe,EACtB,SAAS,GAAE,aAAyB,GACnC,SAAS,CAsBX;AAqCD,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,SAAS,GAAE,aAAyB,GACnC,SAAS,GAAG,KAAK,GAAG,eAAe,CAWrC;AA4ED,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,SAAS,GAAE,aAAyB,GACnC,KAAK,CA+BP"}
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,aAAa,EAeb,SAAS,EAMT,KAAK,EAIL,eAAe,EASf,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAEhB,KAAK,cAAc,EACpB,MAAM,MAAM,CAAC;AAGd,OAAO,KAAK,EACV,WAAW,EAEX,qBAAqB,EACrB,cAAc,EAEd,cAAc,EACd,YAAY,EACZ,eAAe,EACf,yBAAyB,EAGzB,mBAAmB,EAEnB,WAAW,EAKZ,MAAM,gBAAgB,CAAC;AAExB,eAAO,MAAM,SAAS,EAAE,QAAQ,CAC9B,MAAM,CAAC,MAAM,EAAE,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC,CAQnE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,aAAc,SAAQ,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC;IACzE;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;CAC7C;AAED,iEAAiE;AACjE,MAAM,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,qBAAqB,EAC5B,SAAS,EAAE,aAAa,KACrB,cAAc,CAAC;AAEpB,+EAA+E;AAC/E,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,cAAc,KAAK,cAAc,CAAC;AA2ExE,wBAAgB,UAAU,CACxB,UAAU,EAAE,mBAAmB,GAAG,SAAS,GAC1C,WAAW,CAqCb;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,SAAS,GAAE,aAAyB,GACnC,cAAc,EAAE,CAqLlB;AAyDD,gDAAgD;AAChD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,cAAc,GACvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwEzB;AA4CD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,yBAAyB,GAAG,SAAS,GAChD,OAAO,CAAC,iBAAiB,CAAC,CAoE5B;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,eAAe,EACtB,SAAS,GAAE,aAAyB,GACnC,SAAS,CAsBX;AAqCD,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,SAAS,GAAE,aAAyB,GACnC,SAAS,GAAG,KAAK,GAAG,eAAe,CAWrC;AA4ED,wBAAgB,SAAS,CACvB,KAAK,EAAE,WAAW,EAClB,SAAS,GAAE,aAAyB,GACnC,KAAK,CA+BP"}

package/dist/renderers/docxjs/index.d.ts

@@ -16,7 +16,8 @@ export declare function createDocxJsRenderer(): DocxRenderer;
  * Build the docx.js object graph for an IR document.
  *
  * Exported for tests: asserting on the object graph is far cheaper, and far
- * more legible, than unzipping a package.
+ * more legible, than unzipping a package. An IR with charts needs
+ * `await loadDocxCharts()` first; `render()` does it.
  */
 export declare function buildDocument(ir: DocxIR, resources?: EmitResources): Document;
 //# sourceMappingURL=index.d.ts.map

package/dist/renderers/docxjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAIL,QAAQ,EAYT,MAAM,MAAM,CAAC;AAMd,OAAO,KAAK,EACV,MAAM,EAOP,MAAM,gBAAgB,CAAC;AAQxB,OAAO,KAAK,EAAqB,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAKL,KAAK,aAAa,EAEnB,MAAM,QAAQ,CAAC;AAGhB,eAAO,MAAM,kBAAkB,EAAE,cAAyB,CAAC;AAyC3D,wBAAgB,oBAAoB,IAAI,YAAY,CA8BnD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,SAAS,GAAE,aAAyB,GACnC,QAAQ,CA6CV"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAIL,QAAQ,EAcT,MAAM,MAAM,CAAC;AAOd,OAAO,KAAK,EACV,MAAM,EAQP,MAAM,gBAAgB,CAAC;AAQxB,OAAO,KAAK,EAAqB,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAKL,KAAK,aAAa,EAEnB,MAAM,QAAQ,CAAC;AAUhB,eAAO,MAAM,kBAAkB,EAAE,cAAyB,CAAC;AAwD3D,wBAAgB,oBAAoB,IAAI,YAAY,CAkDnD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,SAAS,GAAE,aAAyB,GACnC,QAAQ,CA8CV"}

package/dist/renderers/docxjs/presetShapes.d.ts

@@ -0,0 +1,233 @@
+/**
+ * OOXML preset names → the names `docx/shapes` takes.
+ *
+ * The IR speaks OOXML — `a:prstGeom/@prst`, `a:prstDash/@val` — because that
+ * is what a DOCX stores and what the office-open backend writes verbatim.
+ * `docx/shapes` takes readable names instead (`roundRect` is
+ * `"roundedRectangle"`, `sysDot` is `"shortDot"`) and translates them back on
+ * the way out. Its own OOXML tables are declared but not exported, so the
+ * mapping lives here.
+ *
+ * Both maps are total over what docx 9.8.0 accepts, and a compile-time guard
+ * breaks the build when an upgrade adds a name the map lacks. Both lookups
+ * throw on a name they do not know rather than passing it through: docx throws
+ * for an unknown preset, but it writes an empty `<a:prstDash/>` for an unknown
+ * dash, which Word reads as solid — a silent change of look.
+ */
+import type { LineDash, PresetShapeType } from 'docx/shapes';
+/**
+ * OOXML `a:prstGeom/@prst` → `docx/shapes` preset name, total over the 187
+ * `ST_ShapeType` values. Generated from `PRESET_SHAPE_OOXML_NAMES` in
+ * `docx/dist/shapes.d.ts`, in upstream order.
+ */
+export declare const OOXML_PRESET_TO_DOCX: {
+    readonly line: "line";
+    readonly lineInv: "inverseLine";
+    readonly straightConnector1: "straightConnector";
+    readonly bentConnector2: "elbowConnectorOneBend";
+    readonly bentConnector3: "elbowConnector";
+    readonly bentConnector4: "elbowConnectorThreeBends";
+    readonly bentConnector5: "elbowConnectorFourBends";
+    readonly curvedConnector2: "curvedConnectorOneBend";
+    readonly curvedConnector3: "curvedConnector";
+    readonly curvedConnector4: "curvedConnectorThreeBends";
+    readonly curvedConnector5: "curvedConnectorFourBends";
+    readonly triangle: "triangle";
+    readonly rtTriangle: "rightTriangle";
+    readonly diamond: "diamond";
+    readonly parallelogram: "parallelogram";
+    readonly trapezoid: "trapezoid";
+    readonly nonIsoscelesTrapezoid: "nonIsoscelesTrapezoid";
+    readonly pentagon: "pentagon";
+    readonly hexagon: "hexagon";
+    readonly heptagon: "heptagon";
+    readonly octagon: "octagon";
+    readonly decagon: "decagon";
+    readonly dodecagon: "dodecagon";
+    readonly ellipse: "ellipse";
+    readonly teardrop: "teardrop";
+    readonly pieWedge: "pieWedge";
+    readonly pie: "pie";
+    readonly blockArc: "blockArc";
+    readonly donut: "donut";
+    readonly noSmoking: "noSymbol";
+    readonly chord: "chord";
+    readonly arc: "arc";
+    readonly frame: "frame";
+    readonly halfFrame: "halfFrame";
+    readonly corner: "lShape";
+    readonly diagStripe: "diagonalStripe";
+    readonly plus: "cross";
+    readonly plaque: "plaque";
+    readonly can: "cylinder";
+    readonly cube: "cube";
+    readonly bevel: "beveledRectangle";
+    readonly foldedCorner: "foldedCorner";
+    readonly smileyFace: "smileyFace";
+    readonly heart: "heart";
+    readonly lightningBolt: "lightningBolt";
+    readonly sun: "sun";
+    readonly moon: "moon";
+    readonly cloud: "cloud";
+    readonly leftBracket: "leftBracket";
+    readonly rightBracket: "rightBracket";
+    readonly leftBrace: "leftBrace";
+    readonly rightBrace: "rightBrace";
+    readonly bracketPair: "bracketPair";
+    readonly bracePair: "bracePair";
+    readonly rect: "rectangle";
+    readonly roundRect: "roundedRectangle";
+    readonly round1Rect: "roundedCornerRectangle";
+    readonly round2SameRect: "topRoundedCornersRectangle";
+    readonly round2DiagRect: "diagonalRoundedCornersRectangle";
+    readonly snip1Rect: "snippedCornerRectangle";
+    readonly snip2SameRect: "topSnippedCornersRectangle";
+    readonly snip2DiagRect: "diagonalSnippedCornersRectangle";
+    readonly snipRoundRect: "roundedAndSnippedCornersRectangle";
+    readonly rightArrow: "rightArrow";
+    readonly leftArrow: "leftArrow";
+    readonly upArrow: "upArrow";
+    readonly downArrow: "downArrow";
+    readonly leftRightArrow: "leftRightArrow";
+    readonly upDownArrow: "upDownArrow";
+    readonly quadArrow: "quadArrow";
+    readonly leftRightUpArrow: "leftRightUpArrow";
+    readonly bentArrow: "bentArrow";
+    readonly uturnArrow: "uTurnArrow";
+    readonly leftUpArrow: "leftUpArrow";
+    readonly bentUpArrow: "bentUpArrow";
+    readonly curvedRightArrow: "curvedRightArrow";
+    readonly curvedLeftArrow: "curvedLeftArrow";
+    readonly curvedUpArrow: "curvedUpArrow";
+    readonly curvedDownArrow: "curvedDownArrow";
+    readonly stripedRightArrow: "stripedRightArrow";
+    readonly notchedRightArrow: "notchedRightArrow";
+    readonly homePlate: "pentagonArrow";
+    readonly chevron: "chevron";
+    readonly rightArrowCallout: "rightArrowCallout";
+    readonly downArrowCallout: "downArrowCallout";
+    readonly leftArrowCallout: "leftArrowCallout";
+    readonly upArrowCallout: "upArrowCallout";
+    readonly leftRightArrowCallout: "leftRightArrowCallout";
+    readonly upDownArrowCallout: "upDownArrowCallout";
+    readonly quadArrowCallout: "quadArrowCallout";
+    readonly circularArrow: "circularArrow";
+    readonly leftCircularArrow: "leftCircularArrow";
+    readonly leftRightCircularArrow: "leftRightCircularArrow";
+    readonly swooshArrow: "swooshArrow";
+    readonly mathPlus: "mathPlus";
+    readonly mathMinus: "mathMinus";
+    readonly mathMultiply: "mathMultiply";
+    readonly mathDivide: "mathDivide";
+    readonly mathEqual: "mathEqual";
+    readonly mathNotEqual: "mathNotEqual";
+    readonly flowChartProcess: "flowChartProcess";
+    readonly flowChartAlternateProcess: "flowChartAlternateProcess";
+    readonly flowChartDecision: "flowChartDecision";
+    readonly flowChartInputOutput: "flowChartInputOutput";
+    readonly flowChartPredefinedProcess: "flowChartPredefinedProcess";
+    readonly flowChartInternalStorage: "flowChartInternalStorage";
+    readonly flowChartDocument: "flowChartDocument";
+    readonly flowChartMultidocument: "flowChartMultidocument";
+    readonly flowChartTerminator: "flowChartTerminator";
+    readonly flowChartPreparation: "flowChartPreparation";
+    readonly flowChartManualInput: "flowChartManualInput";
+    readonly flowChartManualOperation: "flowChartManualOperation";
+    readonly flowChartConnector: "flowChartConnector";
+    readonly flowChartOffpageConnector: "flowChartOffpageConnector";
+    readonly flowChartPunchedCard: "flowChartPunchedCard";
+    readonly flowChartPunchedTape: "flowChartPunchedTape";
+    readonly flowChartSummingJunction: "flowChartSummingJunction";
+    readonly flowChartOr: "flowChartOr";
+    readonly flowChartCollate: "flowChartCollate";
+    readonly flowChartSort: "flowChartSort";
+    readonly flowChartExtract: "flowChartExtract";
+    readonly flowChartMerge: "flowChartMerge";
+    readonly flowChartOfflineStorage: "flowChartOfflineStorage";
+    readonly flowChartOnlineStorage: "flowChartOnlineStorage";
+    readonly flowChartDelay: "flowChartDelay";
+    readonly flowChartMagneticTape: "flowChartMagneticTape";
+    readonly flowChartMagneticDisk: "flowChartMagneticDisk";
+    readonly flowChartMagneticDrum: "flowChartMagneticDrum";
+    readonly flowChartDisplay: "flowChartDisplay";
+    readonly irregularSeal1: "explosion12";
+    readonly irregularSeal2: "explosion14";
+    readonly star4: "star4";
+    readonly star5: "star5";
+    readonly star6: "star6";
+    readonly star7: "star7";
+    readonly star8: "star8";
+    readonly star10: "star10";
+    readonly star12: "star12";
+    readonly star16: "star16";
+    readonly star24: "star24";
+    readonly star32: "star32";
+    readonly ribbon2: "ribbonUp";
+    readonly ribbon: "ribbonDown";
+    readonly ellipseRibbon2: "curvedRibbonUp";
+    readonly ellipseRibbon: "curvedRibbonDown";
+    readonly leftRightRibbon: "leftRightRibbon";
+    readonly verticalScroll: "verticalScroll";
+    readonly horizontalScroll: "horizontalScroll";
+    readonly wave: "wave";
+    readonly doubleWave: "doubleWave";
+    readonly wedgeRectCallout: "rectangularCallout";
+    readonly wedgeRoundRectCallout: "roundedRectangularCallout";
+    readonly wedgeEllipseCallout: "ellipticalCallout";
+    readonly cloudCallout: "cloudCallout";
+    readonly borderCallout1: "lineCallout";
+    readonly borderCallout2: "bentLineCallout";
+    readonly borderCallout3: "doubleBentLineCallout";
+    readonly accentCallout1: "lineCalloutWithAccentBar";
+    readonly accentCallout2: "bentLineCalloutWithAccentBar";
+    readonly accentCallout3: "doubleBentLineCalloutWithAccentBar";
+    readonly callout1: "lineCalloutWithNoBorder";
+    readonly callout2: "bentLineCalloutWithNoBorder";
+    readonly callout3: "doubleBentLineCalloutWithNoBorder";
+    readonly accentBorderCallout1: "lineCalloutWithBorderAndAccentBar";
+    readonly accentBorderCallout2: "bentLineCalloutWithBorderAndAccentBar";
+    readonly accentBorderCallout3: "doubleBentLineCalloutWithBorderAndAccentBar";
+    readonly actionButtonBlank: "actionButtonBlank";
+    readonly actionButtonHome: "actionButtonHome";
+    readonly actionButtonHelp: "actionButtonHelp";
+    readonly actionButtonInformation: "actionButtonInformation";
+    readonly actionButtonForwardNext: "actionButtonForwardNext";
+    readonly actionButtonBackPrevious: "actionButtonBackPrevious";
+    readonly actionButtonEnd: "actionButtonEnd";
+    readonly actionButtonBeginning: "actionButtonBeginning";
+    readonly actionButtonReturn: "actionButtonReturn";
+    readonly actionButtonDocument: "actionButtonDocument";
+    readonly actionButtonSound: "actionButtonSound";
+    readonly actionButtonMovie: "actionButtonMovie";
+    readonly gear6: "gear6";
+    readonly gear9: "gear9";
+    readonly funnel: "funnel";
+    readonly cornerTabs: "cornerTabs";
+    readonly squareTabs: "squareTabs";
+    readonly plaqueTabs: "plaqueTabs";
+    readonly chartX: "chartX";
+    readonly chartStar: "chartStar";
+    readonly chartPlus: "chartPlus";
+};
+/** The `docx/shapes` name for an OOXML preset geometry. */
+export declare function docxPresetShape(geometry: string): PresetShapeType;
+/** OOXML `a:prstDash/@val` → `docx/shapes` dash name, total over `ST_PresetLineDashVal`. */
+export declare const OOXML_DASH_TO_DOCX: {
+    readonly solid: "solid";
+    readonly dot: "dot";
+    readonly dash: "dash";
+    readonly lgDash: "longDash";
+    readonly dashDot: "dashDot";
+    readonly lgDashDot: "longDashDot";
+    readonly lgDashDotDot: "longDashDotDot";
+    readonly sysDash: "shortDash";
+    readonly sysDot: "shortDot";
+    readonly sysDashDot: "shortDashDot";
+    readonly sysDashDotDot: "shortDashDotDot";
+};
+/**
+ * The `docx/shapes` name for an OOXML dash. Throws on an unknown one, which
+ * docx itself would write as an empty `<a:prstDash/>` without a word.
+ */
+export declare function docxLineDash(dash: string): LineDash;
+//# sourceMappingURL=presetShapes.d.ts.map

package/dist/renderers/docxjs/presetShapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetShapes.d.ts","sourceRoot":"","sources":["../../../src/renderers/docxjs/presetShapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4LmB,CAAC;AAWrD,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAUjE;AAED,4FAA4F;AAC5F,eAAO,MAAM,kBAAkB;;;;;;;;;;;;CAYc,CAAC;AAS9C;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAUnD"}

package/dist/renderers/office-open/chartLook.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Word's Insert Chart look, stated for office-open's charts.
+ *
+ * On the docx.js renderer `ChartRun` writes a chart the way Word's Insert
+ * Chart does: value gridlines and a category axis line in a tint of Text 1,
+ * no tick marks, Word's bar gaps, straight lines with round markers, slice
+ * borders in Background 1, a doughnut with a hole. `@office-open/docx` states
+ * none of it, and each reader fills the gap its own way — cross ticks, dark
+ * axis lines, no gridlines, curved lines, a doughnut with no hole — while two
+ * of the gaps misdraw the data: a scatter chart's x values go in as text, so a
+ * reader plots them at 1, 2, 3…, and an untitled chart gets a title invented
+ * from its lone series' name, which also rescales its value axis.
+ *
+ * So office-open writes the look docx.js writes, and a chart draws the same on
+ * either renderer; `__tests__/chart-cross-backend.test.ts` holds the two to
+ * it, element by element. The look lives here, in one place, in two halves:
+ * what each series object states on its own (`seriesLook`) and the rest, in
+ * the shared look's vocabulary (`plotLook`), which `chartLook` in
+ * `@json-to-office/shared/rendering` turns into backend options.
+ *
+ * The tints are theme references, as Word writes them, not colours: the
+ * gridlines follow the document theme's Text 1 on both renderers.
+ */
+import type { ChartOptions } from '@office-open/docx';
+import type { ChartPartInput } from '@json-to-office/shared/rendering';
+import type { DocxIrChartRun, DocxIrChartType } from '../../ir/types';
+/** The fields of a series the look sets on its own. */
+export type SeriesLookFields = Pick<ChartOptions['series'][number], 'marker' | 'smooth' | 'invertIfNegative'>;
+/**
+ * What each series object carries to the backend, which passes it through
+ * whole: the marker, a line that is not smoothed, and bars that keep their
+ * colour below zero.
+ *
+ * `c:smooth` has to be stated: with none, Word and LibreOffice both draw a
+ * line chart's series as a curve through its points.
+ */
+export declare function seriesLook(chartType: DocxIrChartType): SeriesLookFields;
+/**
+ * Everything of the look but the series' own fields, for one chart.
+ *
+ * Axis edits come back whole, for `chartParts.ts` to merge its axis titles
+ * into.
+ */
+export declare function plotLook(chart: DocxIrChartRun): Partial<ChartPartInput>;
+//# sourceMappingURL=chartLook.d.ts.map

package/dist/renderers/office-open/chartLook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chartLook.d.ts","sourceRoot":"","sources":["../../../src/renderers/office-open/chartLook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AA+CtE,uDAAuD;AACvD,MAAM,MAAM,gBAAgB,GAAG,IAAI,CACjC,YAAY,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAC9B,QAAQ,GAAG,QAAQ,GAAG,kBAAkB,CACzC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,eAAe,GAAG,gBAAgB,CAavE;AAwED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAuCvE"}