@shbernal/ts-pptx 4.0.1 → 4.2.0

package/dist/{entry-compose-DCnvBZz2.d.ts → entry-compose-CiakSt-f.d.ts}

@@ -1,12 +1,11 @@
-import { d as SHAPE_NAME, i as CHART_NAME, m as SlideObjectType, v as WRITE_OUTPUT_TYPE } from "./enums-BUKTUB6V.js";
-import { Bt as TextMeasurement, Ft as TableLayoutResult, Ht as TextPropsOptions, Kt as ImageProps, Nt as SlideComment, Ot as MeasureTextOptions, Q as ChartOpts, S as HexColor, Vt as TextProps, Z as ChartMulti, c as WriteFileProps, d as ThemeProps, f as BackgroundOption, i as PresLayout, jt as OverflowBoxOptions, kt as NotesProps, l as WriteProps, n as PackagePart, nn as ShapeProps, o as SectionProps, r as PartsProps, s as WriteBaseProps, t as CustomPropertyValue, xt as OptsChartData } from "./pres-C6qgOFAa.js";
-import { L as TableToSlidesProps, M as TableProps, N as TableRow, S as AnimationProps, T as TransitionProps, a as Slide, b as SlideMasterProps, n as GroupChildProps, o as SlideLayout, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, x as SlideNumberProps, y as SlideMasterObject } from "./slide-Dx2ZeVZ6.js";
-import { r as EmbeddedFontSlot } from "./embedded-fonts-DarT9aoa.js";
-import { A as SlideObject, D as SectionInternalProps, E as PresentationPropsInternal, M as SlideRelChart, N as SlideRelMedia, O as SlideLayoutInternal, T as PresSlideInternal, j as SlideRel, k as SlideMasterInternal, n as FontMetricsRegistry, w as ObjectOptionsInternal } from "./font-metrics-v5fn7s7e.js";
-import { s as MediaError } from "./diagnostics-D8ot4Ei7.js";
-import { c as ExtractedSlides, s as ExtractedSlide } from "./presentation-types-8jLQHI4M.js";
-import { r as ZipWriter } from "./zip-C0leZZMj.js";
-//#region src/runtime/types.d.ts
+import { L as TableToSlidesProps, M as TableProps, N as TableRow, S as AnimationProps, T as TransitionProps, a as Slide, b as SlideMasterProps, n as GroupChildProps, o as SlideLayout, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, x as SlideNumberProps, y as SlideMasterObject } from "./slide-BmT4kMoO.js";
+import { C as HexColor, Dt as OptsChartData, It as MeasureTextOptions, Jt as TextMeasurement, Lt as NotesProps, Ut as TableLayoutResult, Vt as SlideComment, Xt as TextPropsOptions, Yt as TextProps, c as WriteFileProps, en as ImageProps, f as ThemeProps, i as PresLayout, it as ChartOpts, l as WriteOutputMap, n as PackagePart, o as SectionProps, p as BackgroundOption, r as PartsProps, rt as ChartMulti, s as WriteBaseProps, t as CustomPropertyValue, u as WriteProps, un as ShapeProps, zt as OverflowBoxOptions } from "./pres-BkEkUAEM.js";
+import { d as SHAPE_NAME, i as CHART_NAME, m as SlideObjectType, v as WRITE_OUTPUT_TYPE } from "./enums-PcXr3o3J.js";
+import { A as SlideObject, D as SectionInternalProps, E as PresentationPropsInternal, M as SlideRelChart, N as SlideRelMedia, O as SlideLayoutInternal, T as PresSlideInternal, j as SlideRel, k as SlideMasterInternal, n as FontMetricsRegistry, w as ObjectOptionsInternal } from "./font-metrics-DTppw4t3.js";
+import { u as MediaError } from "./diagnostics-MoA4MBq5.js";
+import { r as EmbeddedFontSlot } from "./embedded-fonts-U7HIIhPO.js";
+import { c as ExtractedSlides, s as ExtractedSlide } from "./presentation-types-BgnZR-0a.js";
+import { r as ZipWriter } from "./zip-uUjs9Cqx.js";
 type RuntimeAdapter = {
   readonly writeFileOutputType: WRITE_OUTPUT_TYPE | null;
   /**
@@ -41,8 +40,6 @@ type RuntimeAdapter = {
    */
   loadFontData: (source: string) => Promise<Uint8Array>;
 };
-//#endregion
-//#region src/units.d.ts
 /**
  * DrawingML angle unit. `ST_Angle` (`rot`, shadow `dir`, gradient `ang`, …) is measured in
  * sixtieths-of-a-thousandth of a degree, i.e. 60000 units per degree. Multiply a value in
@@ -74,7 +71,7 @@ declare const HUNDREDTHS_PER_POINT = 100;
  */
 declare function ptToHundredths(pt: number): number;
 /**
- * English Metric Units — the integer unit OOXML serializes geometry in (914400 per inch).
+ * English Metric Units: the integer unit OOXML serializes geometry in (914400 per inch).
  *
  * Branded so a value that has already been resolved to EMU cannot be silently fed back into a
  * unit converter: {@link coordToEmu} only accepts a user `Coord`, so passing an `Emu` into it is
@@ -85,7 +82,7 @@ type Emu = number & {
   readonly __unit: 'emu';
 };
 /** Default pixel density for the `"<n>px"` coordinate unit: CSS reference pixels, also the
- *  density ts-pptx assumes when reading an image header's pixel dimensions. */
+ *  density pptx-ts assumes when reading an image header's pixel dimensions. */
 declare const DEFAULT_PX_PER_INCH = 96;
 /**
  * The largest DrawingML coordinate, in EMU: the `maxInclusive` of `ST_Coordinate`, the type of
@@ -96,11 +93,11 @@ declare const MAX_COORDINATE_EMU = 27273042316900;
 declare const MIN_COORDINATE_EMU = -27273042329600;
 type StandardLayoutName = 'LAYOUT_4x3' | 'LAYOUT_16x9' | 'LAYOUT_16x10' | 'LAYOUT_WIDE';
 interface StandardLayout {
-  /** ts-pptx layout key used with `pptx.layout`. */
+  /** pptx-ts layout key used with `pptx.layout`. */
   readonly layout: StandardLayoutName;
   /** PresentationML slide-size preset name, or `custom` for PowerPoint widescreen. */
   readonly name: string;
-  /** Slide width in inches — inches is ts-pptx's default coordinate unit, so this is the value to use for `addText`/`addShape` math. */
+  /** Slide width in inches. Inches is pptx-ts's default coordinate unit, so this is the value to use for `addText`/`addShape` math. */
   readonly widthIn: number;
   /** Slide height in inches. */
   readonly heightIn: number;
@@ -119,7 +116,7 @@ declare function pixelsToEmu(pixels: number, dpi: number): Emu;
  * only `parseCoord` needs it, because every `'50%'` a caller writes comes through there; it is
  * exported because a consumer computing its own geometry against a slide axis needs the same
  * arithmetic, and it belongs with the rest of the conversion set beside it rather than hidden
- * behind the one caller. Left exported deliberately rather than by oversight — this note is the
+ * behind the one caller. Left exported deliberately rather than by oversight. This note is the
  * difference between the two, as it is on {@link emuToPixels}.
  * @param percent - percentage value (e.g. `50` for 50%)
  * @param axisEmu - the axis length in EMU (slide width for x/w, height for y/h)
@@ -145,15 +142,15 @@ declare function emuToInches(emu: number): number;
  * EMU → points, the unit the write API states line widths, font sizes and text insets in.
  *
  * The one conversion, for the library as well as for a consumer: three private forms of
- * `emu / EMU_PER_POINT` had grown around it — the read model's `null`-propagating `ptFromEmu`,
- * the script mapper's `points`, and a dozen inline divisions — while this stayed published and
+ * `emu / EMU_PER_POINT` had grown around it (the read model's `null`-propagating `ptFromEmu`,
+ * the script mapper's `points`, and a dozen inline divisions) while this stayed published and
  * uncalled.
  *
  * **The policy, and its one exception.** Every EMU→points conversion goes through here or through
  * `ptFromEmu` in `src/read/api/coords.ts`, which is this with a `null` passed along. (Named rather
  * than linked: it is internal, so a reference link to it resolves to nothing in the published
  * reference.) The exception is
- * `measure/*` — `fit.ts`, `paragraphs.ts`, `table-fit.ts` — where an inner box is computed as
+ * `measure/*` (`fit.ts`, `paragraphs.ts`, `table-fit.ts`), where an inner box is computed as
  * `(extent - inset - inset) / EMU_PER_POINT` and then guarded with `!(x > 0)`. That guard is
  * written NaN-first on purpose: a box that cannot be measured is skipped, not reported. This
  * function asserts a finite input and throws instead, which is the right answer for a caller
@@ -167,16 +164,12 @@ declare function emuToPoints(emu: number): number;
  * **Published for consumers, and used nowhere in `src/` on purpose.** Nothing inside the
  * library thinks in pixels: it is the unit a caller placing library output on a canvas or in a
  * `<img>` needs, and the DPI is theirs to choose. Left exported deliberately rather than by
- * oversight — this note is the difference between the two.
+ * oversight. This note is the difference between the two.
  */
 declare function emuToPixels(emu: number, dpi: number): number;
 declare const STANDARD_LAYOUTS: Readonly<Record<StandardLayoutName, StandardLayout>>;
-//#endregion
-//#region src/gen/oxml/el.d.ts
 /** Attribute values; `undefined`/`null` omit the attribute entirely. */
 type XmlAttrs = Record<string, string | number | null | undefined>;
-//#endregion
-//#region src/gen/slide/objects/shared.d.ts
 /**
  * Everything the dispatch in `gen/slide/object.ts` has already resolved for one slide object,
  * handed to whichever renderer that object's `_type` selects.
@@ -191,9 +184,9 @@ type XmlAttrs = Record<string, string | number | null | undefined>;
  * Everything a renderer needs is here, and that is now a requirement rather than an observation:
  * a renderer is called through {@link RendererTable}, so it takes this and nothing else. Two used
  * to take a second argument. The connector's `shapeIds` map is genuine context and moved onto this
- * interface; the image's `{ imgWidth, imgHeight }` was `frame.cx`/`frame.cy` under another name —
- * the dispatch captured them from the same two variables the frame is built from, two statements
- * apart — so it reads the frame instead.
+ * interface; the image's `{ imgWidth, imgHeight }` was `frame.cx`/`frame.cy` under another name
+ * (the dispatch captured them from the same two variables the frame is built from, two statements
+ * apart), so it reads the frame instead.
  */
 interface RenderContext {
   /** The slide object being emitted. */
@@ -202,20 +195,20 @@ interface RenderContext {
    * Its `<p:cNvPr>` id, from the one allocator (`collectSlideShapeIds`).
    *
    * Every renderer used to recompute it as `idx + 2` off the walk index, and the group walk
-   * kept a second counter for children — so the map that answers a forward reference (a
+   * kept a second counter for children, so the map that answers a forward reference (a
    * connector's `a:stCxn`, an animation's `p:spTgt spid`) and the ids actually emitted were two
    * derivations that had to be kept in step by hand.
    */
   shapeId: number;
   /**
-   * Every object's id, not just this one's — the whole map `shapeId` was read out of.
+   * Every object's id, not just this one's: the whole map `shapeId` was read out of.
    *
    * A forward reference resolves through it: a connector names its endpoints by `objectName`
    * and has to answer with the id the target will be emitted with, which the walk has not
    * reached yet.
    */
   shapeIds: ReadonlyMap<SlideObject, number>;
-  /** The page it belongs to — a slide, a layout or the master. */
+  /** The page it belongs to: a slide, a layout or the master. */
   slide: PresSlideInternal | SlideLayoutInternal | SlideMasterInternal;
   /** The resolved box in EMU: normalized for negative extents, then overridden by a placeholder. */
   frame: {
@@ -248,7 +241,7 @@ type RenderedObjectType = SlideObjectType.chart | SlideObjectType.connector | Sl
 /** One shape family's emitter: everything it needs is in the {@link RenderContext}. */
 type ObjectRenderer = (ctx: RenderContext) => string;
 /**
- * Which renderer emits each shape family — the dispatch's whole knowledge of what a family's XML
+ * Which renderer emits each shape family: the dispatch's whole knowledge of what a family's XML
  * looks like, supplied to it from outside.
  *
  * It has to come from outside. A named import inside a reachable function body is retained
@@ -264,8 +257,6 @@ type ObjectRenderer = (ctx: RenderContext) => string;
  * absent is a routing bug rather than a silent omission, and the dispatch throws.
  */
 type RendererTable = Partial<Record<RenderedObjectType, ObjectRenderer>>;
-//#endregion
-//#region src/gen/opc/content-types.d.ts
 /** One `Default` entry: a file extension, and the content type every part named with it carries. */
 interface ContentTypeDefault {
   readonly extension: string;
@@ -273,7 +264,7 @@ interface ContentTypeDefault {
 }
 /**
  * One `Override` entry: an absolute part name and its content type. `leadingSpace` asks for the
- * historic insignificant space before the tag — see {@link LEADING_SPACE}; which entries carry it
+ * historic insignificant space before the tag (see {@link LEADING_SPACE}); which entries carry it
  * is a fact about the bytes already shipped, not a style choice.
  */
 interface ContentTypeOverride {
@@ -281,9 +272,7 @@ interface ContentTypeOverride {
   readonly contentType: string;
   readonly leadingSpace?: boolean;
 }
-//#endregion
-//#region src/package/parts/shared.d.ts
-/** A slide, a layout, or the master — anything carrying the rel arrays a part can be derived from. */
+/** A slide, a layout, or the master: anything carrying the rel arrays a part can be derived from. */
 type PartTarget = PresSlideInternal | SlideLayoutInternal | SlideMasterInternal;
 /**
  * One construct family's contribution to the package.
@@ -312,11 +301,16 @@ interface ContributedParts {
   /** Written once, after the slide master and its rels. */
   readonly afterMaster?: (pres: PresentationPropsInternal, zip: ZipWriter) => void;
   /**
-   * Written from one target's rel arrays, for every layout, then every slide, then the master —
+   * Written from one target's rel arrays, for every layout, then every slide, then the master,
    * last, alongside the media parts. Any promises returned join the single pool the packager
    * awaits, so a family with async part work does not serialize the write.
    */
   readonly fromTargetRels?: (target: PartTarget, zip: ZipWriter) => Promise<unknown>[] | void;
+  /**
+   * `a:tblStyle` elements for `ppt/tableStyles.xml`. The core writes that part, because every
+   * deck has one; a family only says what goes in it.
+   */
+  readonly tableStyles?: (pres: PresentationPropsInternal) => string[];
 }
 /**
  * Which `[Content_Types].xml` entries a family needs. Each hook names the slot its entries land
@@ -329,8 +323,6 @@ interface ContributedContentTypes {
   readonly perLayout?: (layout: SlideLayoutInternal, layoutNumber: number) => ContentTypeOverride[];
   readonly trailing?: (pres: PresentationPropsInternal) => ContentTypeOverride[];
 }
-//#endregion
-//#region src/slide.d.ts
 declare class SlideBuilder {
   #private;
   private readonly _setSlideNum;
@@ -361,7 +353,7 @@ declare class SlideBuilder {
    * The authoring methods, one per construct family, bound in the constructor.
    *
    * Declared here and assigned there: the signature each one keeps is the public one on
-   * {@link Slide}, and a method the presentation was not composed with still answers — with the
+   * {@link Slide}, and a method the presentation was not composed with still answers, with the
    * name of the family it needs, rather than `undefined is not a function`.
    */
   addAnimation: Slide['addAnimation'];
@@ -384,13 +376,13 @@ declare class SlideBuilder {
   constructor(params: {
     addSlide: (layout: SlideLayoutInternal | null) => PresSlideInternal;
     getSlide: (slideNum: number) => PresSlideInternal | undefined;
-    getSections?: () => SectionInternalProps[];
+    getSections: () => SectionInternalProps[];
     presLayout: PresLayout;
     setSlideNum: (value: SlideNumberProps) => void;
     slideId: number;
     slideRId: number;
     slideNumber: number;
-    slideLayout?: SlideLayoutInternal;
+    slideLayout: SlideLayoutInternal;
     authors: SlideAuthors;
     childAuthors: ChildAuthors;
   });
@@ -454,8 +446,6 @@ declare class SlideBuilder {
   /** Slide height in inches (resolved from the active presentation layout). */
   get height(): number;
 }
-//#endregion
-//#region src/families/shared.d.ts
 /**
  * Every construct family, by name. A name is what a diagnostic can say about a family that is not
  * composed, so it exists even for the families every tier carries.
@@ -465,7 +455,7 @@ type FamilyName = 'animations' | 'chart' | 'comments' | 'connector' | 'group' |
 type SlideAuthorMethod = 'addAnimation' | 'addChart' | 'addComment' | 'addConnector' | 'addGroup' | 'addImage' | 'addMedia' | 'addModel3d' | 'addNotes' | 'addOleObject' | 'addSectionZoom' | 'addShape' | 'addSlideZoom' | 'addSummaryZoom' | 'addTable' | 'addText' | 'groupObjects';
 /**
  * One family method's author: the public signature, with the slide it authors onto in front and
- * the return dropped. Chaining is not the author's business — `SlideBuilder` returns the slide
+ * the return dropped. Chaining is not the author's business: `SlideBuilder` returns the slide
  * from every bound method, so an author that returned one could only return the same one.
  */
 type Author<M extends SlideAuthorMethod> = (slide: SlideBuilder, ...args: Parameters<Slide[M]>) => void;
@@ -514,7 +504,7 @@ type ChildDescriptorKey = 'chart' | 'image' | 'line' | 'rect' | 'roundRect' | 's
 type ChildDescriptor<K extends ChildDescriptorKey> = Extract<SlideMasterObject, Record<K, unknown>>[K];
 /**
  * The child descriptors a list of families recognises. A descriptor whose key is missing is one
- * nothing composed can author, and both walks warn — naming the family behind the key when
+ * nothing composed can author, and both walks warn, naming the family behind the key when
  * {@link CHILD_DESCRIPTOR_FAMILIES} has one, so a `{ chart: … }` in a master's `objects` on a
  * chartless presentation says what to compose rather than disappearing from the deck.
  */
@@ -548,15 +538,13 @@ interface ConstructFamily {
   readonly extract?: SlideExtractors;
 }
 /**
- * A presentation author with its context already supplied — what a method on the presentation
+ * A presentation author with its context already supplied: what a method on the presentation
  * calls, having nothing left to pass but its own arguments.
  */
 type BoundPresentationAuthor<F> = F extends ((ctx: PresentationAuthorContext, ...args: infer A) => infer R) ? (...args: A) => R : never;
-//#endregion
-//#region src/presentation.d.ts
 /**
- * Main presentation class and package export flow — the public entry point consumers
- * instantiate (`new TsPptx()`). Owns presentation-level state and metadata, collects
+ * Main presentation class and package export flow: the public entry point consumers
+ * instantiate (`new PptxTs()`). Owns presentation-level state and metadata, collects
  * slides, and drives `write`/`writeFile`/`stream`. The actual OOXML string building is
  * delegated to the `gen-*` modules; runtime file/stream output goes through the injected
  * `RuntimeAdapter`. Enums (`AlignH`, `ChartType`, `ShapeType`, …) are imported from the
@@ -565,12 +553,12 @@ type BoundPresentationAuthor<F> = F extends ((ctx: PresentationAuthorContext, ..
  * Rough layout of the class body:
  *   - Metadata accessors      layout / author / company / title / theme / sections getters+setters
  *   - Private slide helpers    addNewSlide, getSlide, setSlideNumber
- *   - Public export methods    stream / write / writeFile — delegate packaging to `writePackage`
+ *   - Public export methods    stream / write / writeFile; delegate packaging to `writePackage`
  *   - Public authoring methods addSlide / defineLayout / defineSlideMaster / defineTableStyle
  *
  * Package assembly (`[Content_Types].xml`, the rels graph, per-part XML, the ZIP) lives in
  * `package/assemble.ts`; this class provides the deck state via {@link PresentationCore.packageSource}.
- * The live-DOM `tableToSlides()` is NOT here — it is added by the browser entry subclass
+ * The live-DOM `tableToSlides()` is NOT here; it is added by the browser entry subclass
  * (`browser.ts`) so it stays out of the Node build and out of the core chunk.
  */
 declare class PresentationCore {
@@ -591,7 +579,7 @@ declare class PresentationCore {
   set layout(value: string | StandardLayout);
   get layout(): string;
   /**
-   * ts-pptx Library Version
+   * pptx-ts Library Version
    */
   private readonly _version;
   get version(): string;
@@ -659,7 +647,7 @@ declare class PresentationCore {
   /**
    * slide layout definition objects, used for generating slide layout files.
    * `protected` (not `private`) so the browser entry subclass can resolve
-   * `tableToSlides({ masterTitle })` against them — that method lives on the
+   * `tableToSlides({ masterTitle })` against them. That method lives on the
    * browser build only (it reads a live DOM), see `browser.ts`.
    */
   protected readonly _slideLayouts: SlideLayoutInternal[];
@@ -693,7 +681,7 @@ declare class PresentationCore {
    */
   private readonly getSections;
   /**
-   * Enables the `Slide` class to set ts-pptx [Presentation] master/layout slidenumbers
+   * Enables the `Slide` class to set pptx-ts [Presentation] master/layout slidenumbers
    * @param {SlideNumberProps} slideNum - slide number config
    */
   private readonly setSlideNumber;
@@ -706,14 +694,14 @@ declare class PresentationCore {
    * Author + serialize this presentation's slides as injectable descriptors,
    * WITHOUT producing a `.pptx` package. Runs the same media-encode, placeholder
    * backfill, and measured-fit passes `write()` uses, then serializes each slide
-   * body and resolves its image media to decoded bytes — so a loaded deck can
+   * body and resolves its image media to decoded bytes, so a loaded deck can
    * splice the slides in via `Presentation.appendSlides()` (see `pptx-ts/read`)
    * while keeping its own masters/layouts/theme byte-identical.
    *
    * Returns the deck's slide size (EMU, for the destination size check) and one
    * descriptor per authored slide. Charts, audio/video media, online media, and
    * internal slide-to-slide hyperlinks are surfaced as descriptors alongside the
-   * serialized body — this method does not resolve them into a package; the append
+   * serialized body. This method does not resolve them into a package; the append
    * path consumes each descriptor to reserve the parts and rebuild the rel graph.
    */
   extractSlides: (opts?: {
@@ -793,11 +781,11 @@ declare class PresentationCore {
   }): Promise<void>;
   /**
    * Measure how tall text wraps at a given width, using the **same** calibrated wrap
-   * model the export-time autofit bake uses — so a layout-time prediction matches the
+   * model the export-time autofit bake uses, so a layout-time prediction matches the
    * value `fit:'shrink'`/`'resize'` would bake. Synchronous: register the face's metrics
-   * first with {@link TsPptx.registerFontMetrics} (lookup is sync).
+   * first with {@link PptxTs.registerFontMetrics} (lookup is sync).
    *
-   * Lets a consumer size its own geometry before export — grow a card to fit its text,
+   * Lets a consumer size its own geometry before export: grow a card to fit its text,
    * reflow a grid, or detect overflow at layout time. Heights err **tall** (conservative),
    * so the returned height is ≥ what PowerPoint/LibreOffice render.
    * @param {string | TextProps[]} text - a string or run array (per-run options override the defaults in `opts`)
@@ -810,7 +798,7 @@ declare class PresentationCore {
   /**
    * Convenience overflow check: `true` if `text` does not fit a box of inner size
    * `wIn`×`hIn` (inches) at full size. Because the model errs tall, this is a
-   * **conservative** (slightly over-reporting) check — appropriate for a build-time
+   * **conservative** (slightly over-reporting) check, appropriate for a build-time
    * warning, not a hard gate. An unmeasurable (unnamed theme-default) face reports
    * `false` (no overflow) so the linter does not false-positive on faces it cannot measure.
    * @param {string | TextProps[]} text - a string or run array
@@ -820,13 +808,13 @@ declare class PresentationCore {
   overflowsBox(text: string | TextProps[], opts: OverflowBoxOptions): boolean;
   /**
    * Compute the per-cell geometry of a table laid out at `opts.x`/`y`/`w`, without
-   * adding it to a slide — so a consumer can place images or shapes precisely over
+   * adding it to a slide, so a consumer can place images or shapes precisely over
    * cells. Column widths (cell `x`/`w`) are exact, derived from the same logic the
    * writer uses. Row heights (`y`/`h`) are exact when pinned by `rowH` (array or
    * scalar) or table `h`; an auto-height row is estimated with the same conservative
-   * (tall) text model as {@link TsPptx.measureText} and flagged `heightExact:false`
-   * (register the cell font via {@link TsPptx.registerFontMetrics} for an exact
-   * estimate). Geometry is for a single, un-paginated table — `autoPage` paging is
+   * (tall) text model as {@link PptxTs.measureText} and flagged `heightExact:false`
+   * (register the cell font via {@link PptxTs.registerFontMetrics} for an exact
+   * estimate). Geometry is for a single, un-paginated table; `autoPage` paging is
    * not modeled.
    * @param {TableRow[]} rows - the same `rows` passed to `slide.addTable`
    * @param {TableProps} opts - the same table options (`x`, `y`, `w`, `colW`, `rowH`, `h`, …)
@@ -849,11 +837,13 @@ declare class PresentationCore {
   /**
    * Export the current Presentation as ZIP content with the selected type
    * @param {WriteProps} props output properties
-   * @returns {Promise<string | ArrayBuffer | Blob | Uint8Array>} file content in selected type
+   * @returns file content in the selected type: a `Blob` when `outputType` is left out, else
+   * the {@link WriteOutputMap} entry for it
+   * @example const bytes = await pptx.write({ outputType: 'uint8array' }) // Uint8Array, no cast
    */
-  write(props?: WriteProps): Promise<string | ArrayBuffer | Blob | Uint8Array>;
+  write<T extends WRITE_OUTPUT_TYPE = 'blob'>(props?: WriteProps<T>): Promise<WriteOutputMap[T]>;
   /**
-   * Assemble the current Presentation into its OOXML package parts WITHOUT zipping — the raw
+   * Assemble the current Presentation into its OOXML package parts WITHOUT zipping: the raw
    * `path → bytes` contents `write()` would compress into the `.pptx`. Use this to stream parts
    * into a custom container, inspect individual parts, or feed a pipeline that does its own
    * archiving. To produce a real `.pptx` file, use {@link write} / {@link writeFile} instead.
@@ -907,22 +897,16 @@ declare class PresentationCore {
    */
   defineSlideMaster(props: SlideMasterProps): void;
 }
-//#endregion
-//#region src/gen/slide/objects/text.d.ts
 /**
  * Render a `text` / `placeholder` slide object to its `<p:sp>` XML.
  */
 declare function renderTextObject(ctx: RenderContext): string;
-//#endregion
-//#region src/gen/slide/objects/image.d.ts
 /**
  * Render an `image` slide object to its `<p:pic>` XML (sizing/crop, rounding, hyperlink, shadow).
  */
 declare function renderImageObject(ctx: RenderContext): string;
-//#endregion
-//#region src/families/core.d.ts
 /**
- * ts-pptx: the construct families every presentation carries
+ * pptx-ts: the construct families every presentation carries
  *
  * The core tier. A composed presentation gets these whether it asks for them or not, so
  * `createPresentation()` with no families still authors text, shapes, images, groups and speaker
@@ -987,8 +971,6 @@ declare const CORE_CONSTRUCT_FAMILIES: readonly [{
   };
   parts: PartContributor;
 }];
-//#endregion
-//#region src/entry-compose.d.ts
 /** Turn a union into the intersection of its members. */
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /** One method's public signature, re-pointed at the slide type the caller actually holds. */
@@ -1041,6 +1023,5 @@ interface ComposeOptions<Fs extends readonly ConstructFamily[]> {
 }
 /** What a family list composes to once the core tier is in front of it. */
 type Composed<Fs extends readonly ConstructFamily[]> = ComposedPresentation<SlideMethodsOf<[...typeof CORE_CONSTRUCT_FAMILIES, ...Fs]>, PresentationMethodsOf<[...typeof CORE_CONSTRUCT_FAMILIES, ...Fs]>>;
-//#endregion
 export { pixelsToEmu as A, StandardLayoutName as C, emuToPoints as D, emuToPixels as E, ptToHundredths as M, inchesToEmu as O, StandardLayout as S, emuToInches as T, HUNDREDTHS_PER_POINT as _, renderImageObject as a, PERCENT_SCALE as b, ConstructFamily as c, PartContributor as d, RenderContext as f, FIXED_PCT_PER_PERCENT as g, Emu as h, ComposedSlide as i, pointsToEmu as j, percentToEmu as k, PresentationAuthorContext as l, DEFAULT_PX_PER_INCH as m, Composed as n, renderTextObject as o, ANGLE_UNITS_PER_DEGREE as p, ComposedPresentation as r, PresentationCore as s, ComposeOptions as t, SlideBuilder as u, MAX_COORDINATE_EMU as v, coordToEmu as w, STANDARD_LAYOUTS as x, MIN_COORDINATE_EMU as y };
-//# sourceMappingURL=entry-compose-DCnvBZz2.d.ts.map
+//# sourceMappingURL=entry-compose-CiakSt-f.d.ts.map

package/dist/entry-compose-CiakSt-f.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-compose-CiakSt-f.d.ts","names":["_$___slide_js0.default"],"sources":["../src/runtime/types.ts","../src/units.ts","../src/gen/oxml/el.ts","../src/gen/slide/objects/shared.ts","../src/gen/opc/content-types.ts","../src/package/parts/shared.ts","../src/slide.ts","../src/families/shared.ts","../src/presentation.ts","../src/gen/slide/objects/text.ts","../src/gen/slide/objects/image.ts","../src/families/core.ts","../src/entry-compose.ts"],"mappings":"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"}

package/dist/{errors-C4oENPcu.js → entry-errors-JMthgJ2g.js}

@@ -1,6 +1,6 @@
-//#region src/diagnostics.ts
+// src/diagnostics.ts
 /** Prefix stamped on every warning so consumers can attribute console noise to this library. */
-const WARN_PREFIX = "ts-pptx";
+const WARN_PREFIX = "pptx-ts";
 /** The default handler: one `console.warn` line per diagnostic, prefixed. */
 const consoleHandler = (diagnostic) => {
 	console.warn(`${WARN_PREFIX}: ${diagnostic.message}`);
@@ -34,7 +34,7 @@ function setDiagnosticHandler(next) {
 /**
 * Emit a library diagnostic.
 * @param code - the stable condition identifier ({@link DiagnosticCode})
-* @param message - explanation, without a `ts-pptx:` prefix (the default handler adds one)
+* @param message - explanation, without a `pptx-ts:` prefix (the default handler adds one)
 * @param detail - optional structured context
 */
 function warn(code, message, detail) {
@@ -53,7 +53,7 @@ const seen = /* @__PURE__ */ new Set();
 *
 * "Once" is **process-global**, the same scope {@link setDiagnosticHandler} has and for the
 * same reason: the emitting code is a tree of free functions in `gen/**` with no presentation
-* in scope. The consequence is different, though, and worth stating on its own — a process that
+* in scope. The consequence is different, though, and worth stating on its own: a process that
 * builds several decks does not get a second report of a condition an earlier deck already
 * tripped, so the second deck's diagnostics are incomplete rather than merely unattributed.
 * {@link resetDiagnosticState} is how a host that cares gets each build a clean slate.
@@ -80,24 +80,23 @@ function warnOnce(code, message, detail) {
 * building decks from user input accumulates one entry per distinct bad value with no way to
 * release them.
 *
-* This does not touch the handler — {@link setDiagnosticHandler} owns that, and the two are
+* This does not touch the handler. {@link setDiagnosticHandler} owns that, and the two are
 * reset independently on purpose: a host usually installs its handler once and wants it to
 * survive.
 */
 function resetDiagnosticState() {
 	seen.clear();
 }
-//#endregion
-//#region src/errors.ts
+// src/errors.ts
 /**
-* Base class for every error ts-pptx throws.
+* Base class for every error pptx-ts throws.
 *
 * Catch this to catch anything from the library; narrow with `instanceof` on a subclass, or branch
-* on {@link TsPptxError.code}, to react to something specific. It is never thrown directly — every
+* on {@link PptxTsError.code}, to react to something specific. It is never thrown directly: every
 * site picks one of the five subclasses.
 */
-var TsPptxError = class extends Error {
-	/** Stable condition identifier — see {@link ErrorCode}. Branch on this, not on the text. */
+var PptxTsError = class extends Error {
+	/** Stable condition identifier (see {@link ErrorCode}). Branch on this, not on the text. */
 	code;
 	/** Structured context for the condition, when the throwing site had any to give. */
 	detail;
@@ -114,14 +113,14 @@ var TsPptxError = class extends Error {
 	}
 };
 /**
-* The caller passed something the library cannot use — a non-finite coordinate, an unknown enum
+* The caller passed something the library cannot use: a non-finite coordinate, an unknown enum
 * value, a required option left out, a value outside its legal range.
 *
 * This is the error behind the project's throw-rather-than-coerce policy: emitting a degenerate
 * result (a zero-size shape, a silently dropped option) hides the mistake, so the library refuses
 * instead. Reaching one means the calling code needs to change.
 */
-var InvalidOptionError = class extends TsPptxError {
+var InvalidOptionError = class extends PptxTsError {
 	constructor(code, message, options) {
 		super(code, message, options);
 	}
@@ -131,24 +130,24 @@ var InvalidOptionError = class extends TsPptxError {
 * installed, the runtime lacks a capability, or the shape/feature has no OOXML representation the
 * library emits.
 *
-* Distinct from {@link InvalidOptionError} because the caller did nothing wrong — the answer is
-* "not here", not "not like that" — and the fix is usually to install something or pick a different
+* Distinct from {@link InvalidOptionError} because the caller did nothing wrong (the answer is
+* "not here", not "not like that"), and the fix is usually to install something or pick a different
 * approach rather than to correct a value.
 */
-var UnsupportedFeatureError = class extends TsPptxError {
+var UnsupportedFeatureError = class extends PptxTsError {
 	constructor(code, message, options) {
 		super(code, message, options);
 	}
 };
 /**
 * The bytes handed to the library are not a package it can read, or a part inside one is
-* structurally malformed — a missing `[Content_Types].xml`, a relationship pointing at nothing, a
+* structurally malformed: a missing `[Content_Types].xml`, a relationship pointing at nothing, a
 * slide part with no root element.
 *
 * Always about *input*. A problem with something the library is being asked to produce is an
 * {@link InvalidOptionError}.
 */
-var PackageReadError = class extends TsPptxError {
+var PackageReadError = class extends PptxTsError {
 	constructor(code, message, options) {
 		super(code, message, options);
 	}
@@ -157,10 +156,10 @@ var PackageReadError = class extends TsPptxError {
 * A referenced image, font, or audio/video resource could not be fetched, read, or decoded.
 *
 * Kept apart from {@link PackageReadError} because the failure is in a resource the deck *points
-* at*, not in the package structure — a broken URL, an unreadable path, a corrupt font file — and
+* at*, not in the package structure (a broken URL, an unreadable path, a corrupt font file), and
 * a consumer typically retries or substitutes rather than rejecting the deck.
 */
-var MediaError = class extends TsPptxError {
+var MediaError = class extends PptxTsError {
 	constructor(code, message, options) {
 		super(code, message, options);
 	}
@@ -168,35 +167,52 @@ var MediaError = class extends TsPptxError {
 /**
 * Where a report of an `InternalError` should go. Appended to the message rather than left to the
 * docs, because a stack trace is the only artefact of the failure that reaches whoever (or
-* whatever) is debugging it — a pointer anywhere else is a pointer they have to already be looking
+* whatever) is debugging it. A pointer anywhere else is a pointer they have to already be looking
 * for. Most code that calls this library is written by an agent in a repository that is not this
 * one, and an agent that hits a library defect routes around it silently unless something in front
 * of it says the report is worth making.
 */
-const REPORT_NOTICE = "This is a bug in ts-pptx, not in your deck or your code. Please report it:\nhttps://github.com/shbernal/ts-pptx/issues/new?template=agent-report.yml";
+const REPORT_NOTICE = "This is a bug in pptx-ts, not in your deck or your code. Please report it:\nhttps://github.com/shbernal/pptx-ts/issues/new?template=bug.yml";
 /**
 * An invariant the library maintains itself did not hold.
 *
 * No consumer input should be able to produce one, which is the whole reason it is a separate
-* class: seeing it means the bug is in ts-pptx, and the useful response is to file it rather than
+* class: seeing it means the bug is in pptx-ts, and the useful response is to file it rather than
 * to keep adjusting the input.
 *
 * It is the one class in the taxonomy that extends its own message, appending `REPORT_NOTICE`
 * below the invariant that broke. The constructor is where that lives so a throw site added later
-* inherits it — the alternative, a notice pasted at each of the sites, is one every future site can
+* inherits it. The alternative, a notice pasted at each of the sites, is one every future site can
 * forget. Every other class leaves `message` exactly as given: a malformed package is the routine
 * outcome for a library that reads untrusted files, and a "report this" banner on each corrupt
 * input would train callers to ignore the one banner that always means something.
 *
-* This does not make the message API — see the class doc on {@link TsPptxError}. Branch on
+* This does not make the message API (see the class doc on {@link PptxTsError}). Branch on
 * `instanceof` or on {@link InternalError.code}, never on the text.
 */
-var InternalError = class extends TsPptxError {
+var InternalError = class extends PptxTsError {
 	constructor(code, message, options) {
 		super(code, `${message}\n\n${REPORT_NOTICE}`, options);
 	}
 };
-//#endregion
-export { TsPptxError as a, setDiagnosticHandler as c, PackageReadError as i, warn as l, InvalidOptionError as n, UnsupportedFeatureError as o, MediaError as r, resetDiagnosticState as s, InternalError as t, warnOnce as u };
+// src/entry-errors.ts
+/**
+* pptx-ts: the error taxonomy, as every entry point republishes it
+*
+* Every failure the library throws. The classes and their `code` are API; the message is not.
+*
+* Each published subpath (`.`, `./read`, `./html`, `./zip`, …) re-exports this module so
+* `instanceof` works whichever one a consumer imports. That property depends on all of them
+* resolving to a single `errors.js`. They do, because there is one module here and
+* every entry names it. This file exists so that stays structurally true: the list used to be
+* pasted into all ten entries, identical down to the comment, and nothing would have caught
+* one of them drifting.
+*
+* Entries re-export it wholesale (`export * from './entry-errors.js'`) rather than naming the
+* members again, so adding an error class publishes it everywhere in one edit.
+*/
+/** @deprecated Renamed to {@link PptxTsError}. This alias is removed in v5. */
+const TsPptxError = PptxTsError;
+export { PackageReadError as a, resetDiagnosticState as c, warnOnce as d, MediaError as i, setDiagnosticHandler as l, InternalError as n, PptxTsError as o, InvalidOptionError as r, UnsupportedFeatureError as s, TsPptxError as t, warn as u };
 
-//# sourceMappingURL=errors-C4oENPcu.js.map
+//# sourceMappingURL=entry-errors-JMthgJ2g.js.map