@shbernal/ts-pptx 4.1.0 → 4.2.0

package/dist/{entry-compose-6hF9aTmT.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-DQRpVOLh.js";
-import { $ as ChartOpts, At as NotesProps, C as HexColor, Ht as TextProps, It as TableLayoutResult, Mt as OverflowBoxOptions, Pt as SlideComment, Q as ChartMulti, St as OptsChartData, Ut as TextPropsOptions, Vt as TextMeasurement, c as WriteFileProps, f as ThemeProps, i as PresLayout, kt as MeasureTextOptions, l as WriteOutputMap, n as PackagePart, o as SectionProps, p as BackgroundOption, qt as ImageProps, r as PartsProps, rn as ShapeProps, s as WriteBaseProps, t as CustomPropertyValue, u as WriteProps } from "./pres-BA9_lJbY.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-BqPtyKmb.js";
-import { r as EmbeddedFontSlot } from "./embedded-fonts-CI_YGW2d.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-CBGmhLo0.js";
-import { s as MediaError } from "./diagnostics-DiMmBU8P.js";
-import { c as ExtractedSlides, s as ExtractedSlide } from "./presentation-types-B3VQH4Bz.js";
-import { r as ZipWriter } from "./zip-CTll_dr0.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
@@ -100,7 +97,7 @@ interface StandardLayout {
   readonly layout: StandardLayoutName;
   /** PresentationML slide-size preset name, or `custom` for PowerPoint widescreen. */
   readonly name: string;
-  /** Slide width in inches — inches is pptx-ts'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 {
@@ -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[];
@@ -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`, …)
@@ -855,7 +843,7 @@ declare class PresentationCore {
    */
   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.
@@ -909,20 +897,14 @@ 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
 /**
  * pptx-ts: the construct families every presentation carries
  *
@@ -989,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. */
@@ -1043,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-6hF9aTmT.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":";;;;;;;;KAIY;WACF,qBAAqB;;;;;;;;;;;;EAY9B,YAAY,KAAK;IAAkB;QAAmB;;;;;;;;;EAStD,sBAAsB,KAAK,kBAAkB,QAAQ;EACrD,YAAY,kBAAkB,eAAe,cAAc,OAAO,eAAe;;;;;;;EAOjF,eAAe,mBAAmB,QAAQ;;;;;;;cClB9B;;;;;;cAOA;;;;;;;cAQA;;;;;;cAOA;;;;;iBAMG,eAAe;;;;;;;;;KAanB;WAA0B;;;;cASzB;;;;;cAMA;;cAGA;KAED;UAEK;;WAEP,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;iBAGM,YAAY,iBAAiB;iBAK7B,YAAY,iBAAiB;iBAK7B,YAAY,gBAAgB,cAAc;;;;;;;;;;;;;iBAkB1C,aAAa,iBAAiB,kBAAkB;;;;;;;;;;;;;;;iBAoBhD,WAAW,wBAAwB,kBAAkB;iBAoCrD,YAAY;;;;;;;;;;;;;;;;;;;;iBAwBZ,YAAY;;;;;;;;;iBAaZ,YAAY,aAAa;cAiB5B,kBAAkB,SAAS,OAAO,oBAAoB;;KC7LvD,WAAW;;;;;;;;;;;;;;;;;;;UCAN;;EAEhB,KAAK;;;;;;;;;EASL;;;;;;;;EAQA,UAAU,YAAY;;EAEtB,OAAO,oBAAoB,sBAAsB;;EAEjD;IAAS;IAAW;IAAW;IAAY;;;EAE3C,aAAa;;EAEb,eAAe;;;;;;EAMf,UAAU;;;;;;;;;;;KAYC,qBACT,gBAAgB,QAChB,gBAAgB,YAChB,gBAAgB,QAChB,gBAAgB,QAChB,gBAAgB,UAChB,gBAAgB,YAChB,gBAAgB,cAChB,gBAAgB,QAChB,gBAAgB,OAChB,gBAAgB;;KAaP,kBAAkB,KAAK;;;;;;;;;;;;;;;;;KAkBvB,gBAAgB,QAAQ,OAAO,oBAAoB;;UCjF9C;WACP;WACA;;;;;;;UAQO;WACP;WACA;WACA;;;KC/BE,aAAa,oBAAoB,sBAAsB;;;;;;;;UASlD;;;;;;;WAOP;;WAEA,QAAQ;;WAER,eAAe;;;UAIR;;WAEP,iBAAiB,OAAO,mBAAmB,qBAAqB,KAAK;;WAErE,eAAe,MAAM,2BAA2B,KAAK;;;;;;WAMrD,kBAAkB,QAAQ,YAAY,KAAK,cAAc;;;;;WAKzD,eAAe,MAAM;;;;;;UAOd;WACP,YAAY,MAAM,8BAA8B;WAChD,gBAAgB,MAAM,8BAA8B;WACpD,YAAY,OAAO,mBAAmB,wBAAwB;WAC9D,aAAa,QAAQ,qBAAqB,yBAAyB;WACnE,YAAY,MAAM,8BAA8B;;cCbrC;;mBACH;EAEV,WAAW,QAAQ,+BAA+B;EAClD,WAAW,qBAAqB;EAChC,mBAAmB;EACnB;EACA,aAAa;EACb,OAAO;EACP,YAAY;EACZ,YAAY;EACZ;EACA;EACA,cAAc;EACd;EACA,mBAAmB;EACnB,eAAe;EACf,WAAW;EACX,qBAAqB;EACrB,aAAa;;;;;;WAOJ,eAAe;;;;;;;;EAShB,cAAc;EACd,UAAU;EACV,YAAY;EACZ,cAAc;EACd,UAAU;EACV,UAAU;EACV,UAAU;EACV,YAAY;EACZ,UAAU;EACV,cAAc;EACd,gBAAgB;EAChB,UAAU;EACV,cAAc;EACd,gBAAgB;EAChB,UAAU;EACV,SAAS;EACT,cAAc;EAE7B,YAAY;IACX,WAAW,QAAQ,+BAA+B;IAClD,WAAW,qBAAqB;IAChC,mBAAmB;IACnB,YAAY;IACZ,cAAc,OAAO;IACrB;IACA;IACA;IACA,aAAa;IACb,SAAS;IACT,cAAc;;;;;;;;;;UAwDP;MACG,WAAW,OAAO;MASlB,cAAc;;;;;UAQjB;MACG,MAAM,OAAO;MAIb,SAAS;;;;UAOZ;MACG,OAAO;MAIP;;;;;UAUH;MACG,WAAW,OAAO;MAIlB,cAAc;;;;MAOd,YAAY,OAAO;MAMnB,eAAe;;;;;;;;;;MAaf,sBAAsB;;;;;;;;;MAYtB,oBAAoB;;MAOpB;;MAKA;;;;;;KC5OA;;KAkBA;;;;;;KAwBP,OAAO,UAAU,sBAAsB,OAAO,iBAAiB,MAAM,WAAW,MAAM;;;;;;;;;;KAW/E,kBAAkB,KAAK,QAAQ,kCAAkC,OAAO;EACnF,YACC,OAAO,cACP,MAAM,kBAAkB,cACxB,OAAO;IAAc,OAAO;;;;;;;UA6Bb;WACP,MAAM;WACN,aAAa;;;;;;;;;UAUN;EAChB,eACC,KAAK,2BACL,eAAe,aACf,MAAM,uBACF;EACL,gBAAgB,KAAK,2BAA2B,eAAe,aAAa,MAAM;EAClF,eAAe,KAAK,2BAA2B,MAAM,YAAY,MAAM,eAAe;EACtF,iBAAiB,KAAK,2BAA2B,eAAe,SAAS;;;;;;;KAgB9D;;KAqBP,gBAAgB,UAAU,sBAAsB,QAAQ,mBAAmB,OAAO,aAAa;;;;;;;KAQxF,kBACV,KAAK,uBAAuB,QAAQ,mBAAmB,OAAO,gBAAgB;;;;;;;;;UAW/D;WACP,UAAU,OAAO,sBAAsB;;;UAIhC;;WAEP,MAAM;;WAEN,UAAU;;WAEV,WAAW;;WAEX,YAAY;;WAEZ,QAAQ;;WAER,sBAAsB;;WAEtB,UAAU;;;;;;KAgER,wBAAwB,KAAK,YAAW,KAAK,8BAA8B,YAAY,YAAY,SACxG,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;cCnKE;;;;;;;;;;;;;;UAeZ;MACG,OAAO,gBAAgB;MAgBvB;;;;mBAOM;MACN;;;;UAeH;MACG,OAAO;MAIP;;;;UAOH;MACG,QAAQ;MAIR;;;;;UAQH;MACG,SAAS;MAIT;;;;UAOH;MACG,QAAQ;MAIR;;;;UAOH;MACG,MAAM,OAAO;MAIb,SAAS;;;;UAOZ;MACG,MAAM;MAIN;;;;;UAQH;MACG,cAAc;MASd;;;;;UAQH;MACG,QAAQ;MAIR;;mBAKM;;mBAGA;MACN,UAAU;;mBAKJ;MACN,YAAY;;UAKf;;;;;;;qBAQW,eAAe;MACvB,gBAAgB;cAIf;UAoBJ;UAiBA;MACG,cAAc;mBAIR;;mBAaA;;mBAGA;EAEjB,YAAY,SAAS,gBAAgB,mBAAmB;;;;;;mBA6DvC;;;;;;mBAoBA;;;;;;mBAQA;;;;;mBAMA;;;;;UAaT;;;;;;;;;;;;;;;EAyBR,gBAAa;IAAkB;QAAgD,QAAQ;;;;;;;;;YAsB7E,aAAa,gBAAgB,qBACtC,QAAQ,IACN,wBAAwB,YAAY,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCrD,oBACL,cACA,iBAAiB,aAAa,aAC9B;IAAS;IAAgB;IAAkB;MACzC;;;;;;;;;;;;;;;;;;;;;;;;EAmCG,UAAU;IACf;IACA,OAAO,cAAc;IACrB;IACA,QAAQ;MACL;;;;;;;;;;;;;;;;EAoDJ,YAAY,eAAe,aAAa,MAAM,qBAAqB;;;;;;;;;;;EAcnE,aAAa,eAAe,aAAa,MAAM;;;;;;;;;;;;;;;;;;;EAsB/C,YAAY,MAAM,YAAY,MAAM,aAAa;;;;;;;;;EAc3C,QAAQ,QAAQ,iBAAiB,QAAQ;;;;;;;;EAczC,MAAM,UAAU,4BAA4B,QAAQ,WAAW,KAAK,QAAQ,eAAe;;;;;;;;;;;;;;;;;EAyB3F,QAAQ,QAAQ,aAAa,QAAQ;;;;;;;EAYrC,UAAU,QAAQ,iBAAiB;;;;;;;EAqBzC,kBAAkB,cAAc,OAAO;;;;;;EAUvC,WAAW,SAAS;;;;;;EA6CpB,SAAS,UAAU,gBAAgB;;;;;;EAqFnC,aAAa,QAAQ;;;;;EAgDrB,kBAAkB,OAAO;;;;;iBC97BV,iBAAiB,KAAK;;;;iBCEtB,kBAAkB,KAAK;;;;;;;;;;;;;;cCN1B;;;I,eAAAA,c;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCSR,oBAAoB,MAAM,qBAAqB,GAAG,8BAA6B,SAAS,cAAa;;KAGrG,QAAQ,GAAG,KAAK,eAAc,YAAY,qBAAoB,MAAM,MAAM;;;;;;;;UASrE,iBAAiB;EAC1B;KACE,MAAM,iBAAiB,SAAS;MAAc,MAAM;QAAe;KACnE,QAAQ,cAAc,UAAU,YAAY;;;;KAKnC,eAAe,oBAAoB,qBAAqB,cAC7D,oBAAoB,QAAQ;EAAc;gBAChD;;KAIW,sBAAsB,oBAAoB,qBAAqB,cACpE,oBAAoB,QAAQ;EAAc;kCAC1C;;;;;;;;;KAWK,cAAc,UAAU,qBAAqB,KAAK,OAAO,wBACnE,KAAK,IAAI,gBAAgB,4BACvB,iBAAiB,cAAc,IAAI,KACnC,QAAQ,MAAM,IAAI,cAAc;;KAI/B,+BACH,WAAW,wBAAwB,wBAAwB,YAAY,oBAAoB;;;;;KAOjF,qBAAqB,UAAU,mBAAmB,gBAAgB,uBAAuB,KACpG,qCACmB,uBAEnB,KAAK,2BAA2B;EAAO,WAAW,UAAU,kBAAkB,cAAc;;;UAG5E,eAAe,oBAAoB;;EAEnD,MAAM;;;KAIK,SAAS,oBAAoB,qBAAqB,qBAC7D,0BAA0B,4BAA4B,MACtD,iCAAiC,4BAA4B"}

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

@@ -1,4 +1,4 @@
-//#region src/diagnostics.ts
+// src/diagnostics.ts
 /** Prefix stamped on every warning so consumers can attribute console noise to this library. */
 const WARN_PREFIX = "pptx-ts";
 /** The default handler: one `console.warn` line per diagnostic, prefixed. */
@@ -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 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,12 +167,12 @@ 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 pptx-ts, not in your deck or your code. Please report it:\nhttps://github.com/shbernal/pptx-ts/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.
 *
@@ -183,20 +182,37 @@ const REPORT_NOTICE = "This is a bug in pptx-ts, not in your deck or your code.
 *
 * 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-Da2nXCJm.js.map
+//# sourceMappingURL=entry-errors-JMthgJ2g.js.map

package/dist/entry-errors-JMthgJ2g.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-errors-JMthgJ2g.js","names":[],"sources":["../src/diagnostics.ts","../src/errors.ts","../src/entry-errors.ts"],"sourcesContent":["/**\n * Central sink for library diagnostics.\n *\n * Every user-facing warning is routed through {@link warn} / {@link warnOnce} rather than calling\n * `console.warn` directly, so there is one place to apply a consistent prefix and one place a\n * consumer can take over (see {@link setDiagnosticHandler}). This module has no *runtime* imports\n * so it can be used from anywhere without risking an import cycle; `codes.ts` is types only and is\n * erased at compile time, so it does not cost that property.\n *\n * **A diagnostic's `code` is API; its `message` is not.** The code is a stable identifier a\n * consumer may branch on (`if (d.code === 'chart/non-finite-value')`); the wording behind it is\n * free to improve in any release. The vocabulary lives in `codes.ts` and is shared with the thrown\n * surface (`errors.ts`), so a condition that can both warn and throw reads the same either way.\n */\n\nimport type { DiagnosticCode } from './codes.js'\n\nexport type { DiagnosticCode }\n\n/** One diagnostic emitted by the library. */\nexport interface Diagnostic {\n\t/** Stable condition identifier; see {@link DiagnosticCode}. Branch on this, not on the text. */\n\treadonly code: DiagnosticCode\n\t/** Human-readable explanation. Free to change in any release; do not parse it. */\n\treadonly message: string\n\t/**\n\t * Structured context for the condition, when a site has any to give.\n\t *\n\t * Every rejection of an `ST_` enum value populates it: `checkEnumOrWarn` (`ooxml/check-enum.ts`)\n\t * carries `received` (the value the caller passed) and `valid`, the whole legal list, plus\n\t * whatever the call site adds. That reaches a handler for a line dash type, a table cell's 3-D\n\t * preset and a table's horizontal overflow, among others. Nothing else populates it yet, so a\n\t * handler must still treat the field as optional and must not assume a particular key is there\n\t * for a given code.\n\t */\n\treadonly detail?: Readonly<Record<string, unknown>>\n}\n\n/** Receives every {@link Diagnostic} the library emits. See {@link setDiagnosticHandler}. */\nexport type DiagnosticHandler = (diagnostic: Diagnostic) => void\n\n/** Prefix stamped on every warning so consumers can attribute console noise to this library. */\nconst WARN_PREFIX = 'pptx-ts'\n\n/** The default handler: one `console.warn` line per diagnostic, prefixed. */\nconst consoleHandler: DiagnosticHandler = (diagnostic) => {\n\tconsole.warn(`${WARN_PREFIX}: ${diagnostic.message}`)\n}\n\nlet handler: DiagnosticHandler = consoleHandler\n\n/**\n * Route every library diagnostic to `handler`, or pass `null` to restore the default\n * (one prefixed `console.warn` per diagnostic).\n *\n * This is process-global rather than per-presentation, deliberately: the emitting code is a tree\n * of free functions in `gen/**` with no presentation in scope, and threading a handler through\n * every signature would be a far larger and worse change than the problem warrants. The practical\n * consequence is that a process building several decks concurrently cannot attribute a diagnostic\n * to one of them. If that matters, correlate on `code`, or build the decks one at a time with the\n * handler set around each build: a handler set around concurrent builds sees all of their\n * diagnostics.\n *\n * A throwing handler propagates out of whatever library call emitted the diagnostic, which is the\n * supported way to make a specific condition fatal:\n *\n * ```ts\n * setDiagnosticHandler((d) => {\n *   if (d.code === 'coord/bare-number-is-inches') throw new Error(d.message)\n * })\n * ```\n * @param next - the receiver, or `null` to restore the console default\n */\nexport function setDiagnosticHandler(next: DiagnosticHandler | null): void {\n\thandler = next ?? consoleHandler\n}\n\n/**\n * Emit a library diagnostic.\n * @param code - the stable condition identifier ({@link DiagnosticCode})\n * @param message - explanation, without a `pptx-ts:` prefix (the default handler adds one)\n * @param detail - optional structured context\n */\nexport function warn(code: DiagnosticCode, message: string, detail?: Readonly<Record<string, unknown>>): void {\n\thandler(detail === undefined ? { code, message } : { code, message, detail })\n}\n\n// Track diagnostics already emitted so a recurring condition (e.g. the same out-of-range fontSize\n// on every cell of a table) is reported once instead of flooding the handler. Keyed on code AND\n// message, so a *different* offending value under the same code still reports.\nconst seen = new Set<string>()\n\n/**\n * Emit a library diagnostic at most once per distinct code+message.\n *\n * \"Once\" is **process-global**, the same scope {@link setDiagnosticHandler} has and for the\n * same reason: the emitting code is a tree of free functions in `gen/**` with no presentation\n * in scope. The consequence is different, though, and worth stating on its own: a process that\n * builds several decks does not get a second report of a condition an earlier deck already\n * tripped, so the second deck's diagnostics are incomplete rather than merely unattributed.\n * {@link resetDiagnosticState} is how a host that cares gets each build a clean slate.\n *\n * @param code - the stable condition identifier ({@link DiagnosticCode})\n * @param message - explanation (see {@link warn})\n * @param detail - optional structured context\n */\nexport function warnOnce(code: DiagnosticCode, message: string, detail?: Readonly<Record<string, unknown>>): void {\n\tconst key = `${code}\\0${message}`\n\tif (seen.has(key)) return\n\tseen.add(key)\n\twarn(code, message, detail)\n}\n\n/**\n * Clear the `warnOnce` dedupe set, so a condition already reported reports again. (`warnOnce` is\n * internal and carries no page of its own, so it is named rather than linked.)\n *\n * Call it between builds in a host that builds more than one deck per process and wants each\n * build's diagnostics complete. Without it, deck two is silent about anything deck one already\n * warned for, which reads as \"no problems found\" rather than as \"already mentioned\".\n *\n * It also bounds the set. Most `warnOnce` messages interpolate the offending value, so a server\n * building decks from user input accumulates one entry per distinct bad value with no way to\n * release them.\n *\n * This does not touch the handler. {@link setDiagnosticHandler} owns that, and the two are\n * reset independently on purpose: a host usually installs its handler once and wants it to\n * survive.\n */\nexport function resetDiagnosticState(): void {\n\tseen.clear()\n}\n","/**\n * The library's error taxonomy.\n *\n * Every failure pptx-ts raises is a {@link PptxTsError} carrying a stable {@link ErrorCode}, so a\n * consumer can tell *\"you passed a bad coordinate\"* from *\"this font file is corrupt\"* from\n * *\"these bytes are not a package\"* without matching on message substrings. The classes are a\n * deliberately flat, coarse bucket (five of them), and the code carries the specificity. Do not\n * add a class per throw site; add a code.\n *\n * **The class and the code are API. The message is not.** Branch on `instanceof` and on `code`;\n * the wording behind them is free to improve in any release. Every error remains an\n * `instanceof Error`, so existing `catch` blocks keep working.\n *\n * Which class to reach for:\n *\n * | class | the failure is | who fixes it |\n * |---|---|---|\n * | {@link InvalidOptionError} | the caller passed something unusable | the caller's code |\n * | {@link UnsupportedFeatureError} | a well-formed request this build/runtime/shape cannot express | the caller's expectations, or the environment |\n * | {@link PackageReadError} | the input bytes are not a readable package | the input file |\n * | {@link MediaError} | a referenced image/font/AV resource would not load or decode | the resource |\n * | {@link InternalError} | an invariant of the library itself did not hold | pptx-ts (file a bug) |\n *\n * **Which of these is worth reporting upstream.** `InternalError` always is, and says so at\n * runtime. The middle three are worth reporting when the environment disagrees with us:\n * a `PackageReadError` on a file that opens cleanly in PowerPoint, a `MediaError` on an asset every\n * other tool loads, an `UnsupportedFeatureError` for something PowerPoint can plainly express.\n * `InvalidOptionError` is worth reporting only if the deck it refused is one PowerPoint can\n * express. See `skills/pptx-ts-upstream` for how to file one.\n *\n * @see `docs/errors-and-warnings.md` for the consumer-facing contract.\n * @see `codes.ts` for the code vocabulary, which is shared with the diagnostic (warning) surface.\n */\n\nimport type {\n\tErrorCode,\n\tInternalErrorCode,\n\tInvalidOptionErrorCode,\n\tMediaErrorCode,\n\tPackageReadErrorCode,\n\tUnsupportedFeatureErrorCode,\n} from './codes.js'\n\n/** Extra context accepted by every {@link PptxTsError} constructor. */\nexport interface PptxTsErrorOptions extends ErrorOptions {\n\t/**\n\t * Structured context for the condition, when a site has any to give. Mirrors `Diagnostic.detail`\n\t * so the same condition looks the same whether it was warned or thrown.\n\t */\n\treadonly detail?: Readonly<Record<string, unknown>>\n}\n\n/**\n * Base class for every error pptx-ts throws.\n *\n * Catch this to catch anything from the library; narrow with `instanceof` on a subclass, or branch\n * on {@link PptxTsError.code}, to react to something specific. It is never thrown directly: every\n * site picks one of the five subclasses.\n */\nexport class PptxTsError extends Error {\n\t/** Stable condition identifier (see {@link ErrorCode}). Branch on this, not on the text. */\n\treadonly code: ErrorCode\n\n\t/** Structured context for the condition, when the throwing site had any to give. */\n\treadonly detail?: Readonly<Record<string, unknown>>\n\n\t/**\n\t * @param code - the stable condition identifier\n\t * @param message - explanation for a human reading a stack trace; not part of the contract\n\t * @param options - standard `cause`, plus optional structured `detail`\n\t */\n\tconstructor(code: ErrorCode, message: string, options?: PptxTsErrorOptions) {\n\t\tsuper(message, options)\n\t\t// `name` drives how a stack trace and `console.log` label the error, and the default from\n\t\t// `Error` would say \"Error\" for every subclass. Derive it from the constructor so a subclass\n\t\t// never has to remember to set it.\n\t\tthis.name = new.target.name\n\t\tthis.code = code\n\t\tif (options?.detail !== undefined) this.detail = options.detail\n\t}\n}\n\n/**\n * The caller passed something the library cannot use: a non-finite coordinate, an unknown enum\n * value, a required option left out, a value outside its legal range.\n *\n * This is the error behind the project's throw-rather-than-coerce policy: emitting a degenerate\n * result (a zero-size shape, a silently dropped option) hides the mistake, so the library refuses\n * instead. Reaching one means the calling code needs to change.\n */\nexport class InvalidOptionError extends PptxTsError {\n\tdeclare readonly code: InvalidOptionErrorCode\n\tconstructor(code: InvalidOptionErrorCode, message: string, options?: PptxTsErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * The request is well-formed but cannot be expressed here: an optional peer dependency is not\n * installed, the runtime lacks a capability, or the shape/feature has no OOXML representation the\n * library emits.\n *\n * Distinct from {@link InvalidOptionError} because the caller did nothing wrong (the answer is\n * \"not here\", not \"not like that\"), and the fix is usually to install something or pick a different\n * approach rather than to correct a value.\n */\nexport class UnsupportedFeatureError extends PptxTsError {\n\tdeclare readonly code: UnsupportedFeatureErrorCode\n\tconstructor(code: UnsupportedFeatureErrorCode, message: string, options?: PptxTsErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * The bytes handed to the library are not a package it can read, or a part inside one is\n * structurally malformed: a missing `[Content_Types].xml`, a relationship pointing at nothing, a\n * slide part with no root element.\n *\n * Always about *input*. A problem with something the library is being asked to produce is an\n * {@link InvalidOptionError}.\n */\nexport class PackageReadError extends PptxTsError {\n\tdeclare readonly code: PackageReadErrorCode\n\tconstructor(code: PackageReadErrorCode, message: string, options?: PptxTsErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * A referenced image, font, or audio/video resource could not be fetched, read, or decoded.\n *\n * Kept apart from {@link PackageReadError} because the failure is in a resource the deck *points\n * at*, not in the package structure (a broken URL, an unreadable path, a corrupt font file), and\n * a consumer typically retries or substitutes rather than rejecting the deck.\n */\nexport class MediaError extends PptxTsError {\n\tdeclare readonly code: MediaErrorCode\n\tconstructor(code: MediaErrorCode, message: string, options?: PptxTsErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * Where a report of an `InternalError` should go. Appended to the message rather than left to the\n * docs, because a stack trace is the only artefact of the failure that reaches whoever (or\n * whatever) is debugging it. A pointer anywhere else is a pointer they have to already be looking\n * for. Most code that calls this library is written by an agent in a repository that is not this\n * one, and an agent that hits a library defect routes around it silently unless something in front\n * of it says the report is worth making.\n */\nconst REPORT_NOTICE =\n\t'This is a bug in pptx-ts, not in your deck or your code. Please report it:\\n' +\n\t'https://github.com/shbernal/pptx-ts/issues/new?template=bug.yml'\n\n/**\n * An invariant the library maintains itself did not hold.\n *\n * No consumer input should be able to produce one, which is the whole reason it is a separate\n * class: seeing it means the bug is in pptx-ts, and the useful response is to file it rather than\n * to keep adjusting the input.\n *\n * It is the one class in the taxonomy that extends its own message, appending `REPORT_NOTICE`\n * below the invariant that broke. The constructor is where that lives so a throw site added later\n * inherits it. The alternative, a notice pasted at each of the sites, is one every future site can\n * forget. Every other class leaves `message` exactly as given: a malformed package is the routine\n * outcome for a library that reads untrusted files, and a \"report this\" banner on each corrupt\n * input would train callers to ignore the one banner that always means something.\n *\n * This does not make the message API (see the class doc on {@link PptxTsError}). Branch on\n * `instanceof` or on {@link InternalError.code}, never on the text.\n */\nexport class InternalError extends PptxTsError {\n\tdeclare readonly code: InternalErrorCode\n\tconstructor(code: InternalErrorCode, message: string, options?: PptxTsErrorOptions) {\n\t\tsuper(code, `${message}\\n\\n${REPORT_NOTICE}`, options)\n\t}\n}\n","/**\n * pptx-ts: the error taxonomy, as every entry point republishes it\n *\n * Every failure the library throws. The classes and their `code` are API; the message is not.\n *\n * Each published subpath (`.`, `./read`, `./html`, `./zip`, …) re-exports this module so\n * `instanceof` works whichever one a consumer imports. That property depends on all of them\n * resolving to a single `errors.js`. They do, because there is one module here and\n * every entry names it. This file exists so that stays structurally true: the list used to be\n * pasted into all ten entries, identical down to the comment, and nothing would have caught\n * one of them drifting.\n *\n * Entries re-export it wholesale (`export * from './entry-errors.js'`) rather than naming the\n * members again, so adding an error class publishes it everywhere in one edit.\n */\n\nimport { PptxTsError, type PptxTsErrorOptions } from './errors.js'\nimport type { PptxTsCode } from './codes.js'\n\nexport {\n\tPptxTsError,\n\tInvalidOptionError,\n\tUnsupportedFeatureError,\n\tPackageReadError,\n\tMediaError,\n\tInternalError,\n\ttype PptxTsErrorOptions,\n} from './errors.js'\nexport type {\n\tErrorCode,\n\tPptxTsCode,\n\tInvalidOptionErrorCode,\n\tUnsupportedFeatureErrorCode,\n\tPackageReadErrorCode,\n\tMediaErrorCode,\n\tInternalErrorCode,\n} from './codes.js'\n\n/** @deprecated Renamed to {@link PptxTsError}. This alias is removed in v5. */\nexport const TsPptxError = PptxTsError\n/** @deprecated Renamed to {@link PptxTsError}. This alias is removed in v5. */\nexport type TsPptxError = PptxTsError\n/** @deprecated Renamed to {@link PptxTsErrorOptions}. This alias is removed in v5. */\nexport type TsPptxErrorOptions = PptxTsErrorOptions\n/** @deprecated Renamed to {@link PptxTsCode}. This alias is removed in v5. */\nexport type TsPptxCode = PptxTsCode\n"],"mappings":";;AA0CA,MAAM,cAAc;;AAGpB,MAAM,kBAAqC,eAAe;CACzD,QAAQ,KAAK,GAAG,YAAY,IAAI,WAAW,SAAS;AACrD;AAEA,IAAI,UAA6B;;;;;;;;;;;;;;;;;;;;;;;AAwBjC,SAAgB,qBAAqB,MAAsC;CAC1E,UAAU,QAAQ;AACnB;;;;;;;AAQA,SAAgB,KAAK,MAAsB,SAAiB,QAAkD;CAC7G,QAAQ,WAAW,KAAA,IAAY;EAAE;EAAM;CAAQ,IAAI;EAAE;EAAM;EAAS;CAAO,CAAC;AAC7E;AAKA,MAAM,uBAAO,IAAI,IAAY;;;;;;;;;;;;;;;AAgB7B,SAAgB,SAAS,MAAsB,SAAiB,QAAkD;CACjH,MAAM,MAAM,GAAG,KAAK,IAAI;CACxB,IAAI,KAAK,IAAI,GAAG,GAAG;CACnB,KAAK,IAAI,GAAG;CACZ,KAAK,MAAM,SAAS,MAAM;AAC3B;;;;;;;;;;;;;;;;;AAkBA,SAAgB,uBAA6B;CAC5C,KAAK,MAAM;AACZ;;;;;;;;;ACxEA,IAAa,cAAb,cAAiC,MAAM;;CAEtC;;CAGA;;;;;;CAOA,YAAY,MAAiB,SAAiB,SAA8B;EAC3E,MAAM,SAAS,OAAO;EAItB,KAAK,OAAO,WAAW;EACvB,KAAK,OAAO;EACZ,IAAI,SAAS,WAAW,KAAA,GAAW,KAAK,SAAS,QAAQ;CAC1D;AACD;;;;;;;;;AAUA,IAAa,qBAAb,cAAwC,YAAY;CAEnD,YAAY,MAA8B,SAAiB,SAA8B;EACxF,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;CAExD,YAAY,MAAmC,SAAiB,SAA8B;EAC7F,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;;AAUA,IAAa,mBAAb,cAAsC,YAAY;CAEjD,YAAY,MAA4B,SAAiB,SAA8B;EACtF,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;AASA,IAAa,aAAb,cAAgC,YAAY;CAE3C,YAAY,MAAsB,SAAiB,SAA8B;EAChF,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;;AAUA,MAAM,gBACL;;;;;;;;;;;;;;;;;;AAoBD,IAAa,gBAAb,cAAmC,YAAY;CAE9C,YAAY,MAAyB,SAAiB,SAA8B;EACnF,MAAM,MAAM,GAAG,QAAQ,MAAM,iBAAiB,OAAO;CACtD;AACD;;;;;;;;;;;;;;;;;;ACzIA,MAAa,cAAc"}