@shbernal/ts-pptx 4.1.0 → 4.2.0

package/dist/{slide-BqPtyKmb.d.ts → slide-BmT4kMoO.d.ts}

@@ -1,11 +1,10 @@
-import { d as SHAPE_NAME, h as TableStyle, i as CHART_NAME, m as SlideObjectType } from "./enums-DQRpVOLh.js";
-import { $ as ChartOpts, At as NotesProps, B as ShadowProps, C as HexColor, Dt as PlaceholderProps, E as Margin, Et as ObjectNameProps, F as ConnectorProps, Ht as TextProps, Jt as MediaProps, Kt as ImageBaseProps, L as FillOption, Lt as TextBaseProps, Ot as CommentProps, P as BorderProps, Q as ChartMulti, S as HAlign, St as OptsChartData, Tt as ObjectLockProps, Ut as TextPropsOptions, Xt as OleObjectProps, _ as DataOrPathProps, bn as TRANSITION_TYPES, g as Coord, gn as PresetMaterialType, h as Color, k as PositionProps, mn as LightRigType, p as BackgroundOption, pn as LightRigDirection, qt as ImageProps, rn as ShapeProps, sn as BevelPresetType, v as DataOrPathRequiredProps, wt as CommonObjectDescriptor, xn as TextHorzOverflowType, yn as TEXT_AUTONUM_SCHEMES, z as HyperlinkProps, zt as TextFitShrinkProps } from "./pres-BA9_lJbY.js";
-//#region src/types/table.d.ts
+import { d as SHAPE_NAME, h as TableStyle, i as CHART_NAME, m as SlideObjectType } from "./enums-PcXr3o3J.js";
+import { $t as ImageBaseProps, A as PositionProps, At as ObjectLockProps, C as HexColor, Dn as TEXT_AUTONUM_SCHEMES, Dt as OptsChartData, E as Margin, Ft as CommentProps, H as HyperlinkProps, I as BorderProps, Kt as TextFitShrinkProps, L as ConnectorProps, Lt as NotesProps, Nt as PlaceholderOption, On as TRANSITION_TYPES, Pt as PlaceholderProps, S as HAlign, U as ShadowProps, Wt as TextBaseProps, Xt as TextPropsOptions, Yt as TextProps, _ as DataOrPathProps, bn as LightRigDirection, en as ImageProps, g as Coord, h as Color, it as ChartOpts, jt as ObjectNameProps, k as PlaceholderPositionProps, kn as TextHorzOverflowType, kt as CommonObjectDescriptor, mn as BevelPresetType, p as BackgroundOption, rn as OleObjectProps, rt as ChartMulti, tn as MediaProps, un as ShapeProps, v as DataOrPathRequiredProps, wn as PresetMaterialType, xn as LightRigType, z as FillOption } from "./pres-BkEkUAEM.js";
 /**
  * A `<table>` element, from whatever DOM implementation the caller has.
  *
  * Deliberately *not* `lib.dom`'s `Element`. `lib.dom`'s types are built for a browser, and a
- * non-browser DOM's element type — happy-dom's, jsdom's — declares its own members and does
+ * non-browser DOM's element type (happy-dom's, jsdom's) declares its own members and does
  * not satisfy them, so demanding `Element` would reject from TypeScript exactly the
  * implementations `pptx-ts/html` exists to accept. Requiring the three members the conversion
  * actually calls keeps a mistyped argument an error while letting every real DOM through.
@@ -105,12 +104,12 @@ interface TableToSlidesProps extends Omit<TableProps, 'autoPage' | 'colW' | 'aut
   slideMargin?: Margin;
 }
 /**
- * A table cell's corner-to-corner rules (`a:tcPr/a:lnTlToBr` / `a:lnBlToTr`) — the
+ * A table cell's corner-to-corner rules (`a:tcPr/a:lnTlToBr` / `a:lnBlToTr`), the
  * "Diagonal Down Border" / "Diagonal Up Border" of PowerPoint's border gallery.
  *
  * Deliberately its own object rather than two more entries on {@link TableCellProps.border}'s
  * tuple: widening that tuple to six would break every existing caller for a construct almost
- * no deck uses, and the two diagonals are not edges — they do not participate in the
+ * no deck uses, and the two diagonals are not edges: they do not participate in the
  * perimeter, and they are not inherited by a merged region's covered cells.
  *
  * @example diagonal: { tlToBr: { type:'solid', color:'C00000', width:1 } } // strike a cell out
@@ -126,8 +125,8 @@ interface TableCellDiagonals {
  * A cell's 3-D bevel (`a:tcPr/a:cell3D`).
  *
  * A minimal surface over `CT_Cell3D`, which is a required `a:bevel` plus an optional
- * `a:lightRig`. PowerPoint's table UI exposes no control for it — it reaches a deck through a
- * theme's table style or through another producer — so this exists to author and reproduce
+ * `a:lightRig`. PowerPoint's table UI exposes no control for it (it reaches a deck through a
+ * theme's table style or through another producer), so this exists to author and reproduce
  * one, not as a general 3-D model.
  */
 interface TableCell3DProps {
@@ -172,6 +171,10 @@ interface TableCellProps extends TextBaseProps {
    * the text, below zero lowers it. On a cell it applies to every run that states none.
    */
   baseline?: NonNullable<TextPropsOptions['baseline']>;
+  /** Character spacing in points, as {@link TextPropsOptions.charSpacing}. On a cell it applies to every run that states none. */
+  charSpacing?: NonNullable<TextPropsOptions['charSpacing']>;
+  /** Kerning threshold in points, as {@link TextPropsOptions.kerning}. On a cell it applies to every run that states none. */
+  kerning?: NonNullable<TextPropsOptions['kerning']>;
   /**
    * Text shadow (`a:rPr/a:effectLst`), as {@link TextPropsOptions.shadow} takes it on a run. A cell
    * has no shape effect of its own, so on a cell this is the shadow of every run that states none.
@@ -200,7 +203,7 @@ interface TableCellProps extends TextBaseProps {
    * - a single `BorderProps` is broadcast to all four sides
    * - an array is read in **TRBL** order (`[top, right, bottom, left]`)
    *
-   * Overrides the table-level {@link TableProps.border} default entirely — the two do not
+   * Overrides the table-level {@link TableProps.border} default entirely; the two do not
    * merge per side. A `null` entry is a hole: that edge is left out of `a:tcPr` and keeps
    * inheriting from the table style, while `{ type: 'none' }` writes an explicit no-line
    * that overrides it. For the two corner-to-corner rules see {@link diagonal}; for the
@@ -208,11 +211,11 @@ interface TableCellProps extends TextBaseProps {
    */
   border?: BorderProps | [BorderProps | null, BorderProps | null, BorderProps | null, BorderProps | null];
   /**
-   * The cell's corner-to-corner rules — PowerPoint's "Diagonal Down/Up Border".
+   * The cell's corner-to-corner rules: PowerPoint's "Diagonal Down/Up Border".
    *
    * Kept off {@link border}'s tuple on purpose: see {@link TableCellDiagonals}. A diagonal
    * on a merged cell is one stroke across the whole region, so only the span origin carries
-   * it — the covered cells inherit the origin's *edges* but never its diagonals.
+   * it. The covered cells inherit the origin's *edges* but never its diagonals.
    * @example diagonal: { tlToBr: { type:'solid', color:'C00000' } } // strike the cell out
    */
   diagonal?: TableCellDiagonals;
@@ -225,7 +228,7 @@ interface TableCellProps extends TextBaseProps {
    * left-aligned text in a wide cell, `anchorCtr: true` centres the ragged-right column of
    * lines as a unit while keeping their left edges flush with each other.
    *
-   * `false` is the schema default, so it emits nothing — the same reasoning as
+   * `false` is the schema default, so it emits nothing, the same reasoning as
    * `horzOverflow: 'clip'`.
    * @default false
    */
@@ -241,9 +244,9 @@ interface TableCellProps extends TextBaseProps {
    */
   colspan?: number;
   /**
-   * Cell fill — a solid color, or a picture that fills the cell (`a:blipFill` in
+   * Cell fill: a solid color, or a picture that fills the cell (`a:blipFill` in
    * the cell's `a:tcPr`, stretched to the cell box). A picture fill embeds the
-   * image as slide media; identical sources are embedded once. Raster only —
+   * image as slide media; identical sources are embedded once. Raster only:
    * an SVG source warns and is ignored, matching shape fills. A bare {@link Color} is
    * shorthand for a solid fill ({@link FillOption}).
    * @example 'FF0000' // hex color (red), shorthand for { color:'FF0000' }
@@ -262,13 +265,13 @@ interface TableCellProps extends TextBaseProps {
    * This is **not** a text-wrap switch, despite the name. Lines always wrap to the column
    * width; only an individual character too wide to fit on a line by itself is affected, so
    * it matters for oversized display type, wide CJK/emoji glyphs, and icon fonts in a narrow
-   * column. PowerPoint has no per-cell no-wrap at all — `wrap="none"` on a cell's `a:bodyPr`
+   * column. PowerPoint has no per-cell no-wrap at all: `wrap="none"` on a cell's `a:bodyPr`
    * is discarded on the next save (probe:
    * `test/read/fixtures/authoring/probe-table-cell-wrap.ps1`).
    * `'clip'` is written as asked but is the schema default, so PowerPoint drops the
-   * attribute again the first time it saves the deck — the visible result is the same
+   * attribute again the first time it saves the deck. The visible result is the same
    * either way, and leaving this unset emits nothing at all.
-   * @default (unset — PowerPoint clips)
+   * @default (unset; PowerPoint clips)
    * @example 'overflow' // a 60pt glyph in a 0.5in column draws whole instead of being cut
    */
   horzOverflow?: TextHorzOverflowType;
@@ -285,11 +288,11 @@ interface TableCellProps extends TextBaseProps {
   /**
    * Shrink cell text to fit when it would overflow the cell's fixed height.
    * - `'shrink'` measures the wrapped text and bakes a **reduced literal font size**
-   *   onto the cell's runs so the text fits — PowerPoint does not support text
+   *   onto the cell's runs so the text fits. PowerPoint does not support text
    *   autofit (`normAutofit`) inside table cells, so there is no font-scale flag to
    *   set; the size itself is lowered, which both PowerPoint and LibreOffice render
    *   identically with no edit/resize.
-   * - Requires the cell font registered via {@link TsPptx.registerFontMetrics}. With no
+   * - Requires the cell font registered via {@link PptxTs.registerFontMetrics}. With no
    *   metrics registered at all it is a silent no-op (the cell keeps its authored size); once
    *   any face is registered, an unregistered face is estimated and warns once per write.
    * - Only triggers when the cell's row has a **fixed** height that the text exceeds.
@@ -302,16 +305,18 @@ interface TableCellProps extends TextBaseProps {
    */
   fit?: 'none' | 'shrink' | 'resize' | TextFitShrinkProps;
 }
-interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
+interface TableProps extends PlaceholderPositionProps, TextBaseProps, ObjectNameProps {
   /**
    * Name of a table/content placeholder defined on the slide layout/master to bind this table to.
    * - when it matches a layout/master placeholder, the table's `<p:graphicFrame>` emits that
    *   placeholder's `<p:ph>` (idx/type) so PowerPoint treats the table as filling the placeholder
    *   (e.g. a "Title and Content" content placeholder)
    * - the table also inherits the placeholder's position/size for any of x/y/w/h left unset
+   * - a {@link PlaceholderBinding} states the `p:ph` to write, with or without such a placeholder
    * @example 'body' // bind to the layout placeholder named 'body'
+   * @example { idx: 1 } // fill placeholder 1 of a layout this deck does not define
    */
-  placeholder?: string;
+  placeholder?: PlaceholderOption;
   /**
    * Whether to enable auto-paging
    * - auto-paging creates new slides as content overflows a slide
@@ -359,7 +364,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    *
    * Steers the default table width, `fitColumns: 'shrink'`, and every page the auto-pager
    * creates. It was declared on {@link TableToSlidesProps} only, while the pager read it on
-   * both paths — so from `addTable` it worked at run time and the type rejected it, and the
+   * both paths, so from `addTable` it worked at run time and the type rejected it, and the
    * table definer ignored it either way, which made "does my table respect `slideMargin`"
    * depend on whether `autoPage` was on.
    */
@@ -373,15 +378,15 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    */
   autoPagePlaceholder?: boolean;
   /**
-   * Default border for **every cell** in the table — not the table's outer perimeter.
+   * Default border for **every cell** in the table, not the table's outer perimeter.
    *
    * A single `BorderProps` is broadcast to all four sides of each cell; an array is read
    * in TRBL order and applied to each cell's own four sides. So
    * `border: [{type:'solid'}, {type:'none'}, {type:'solid'}, {type:'none'}]` gives *every*
-   * cell a top and bottom rule — a full set of horizontal grid lines, not a rule at the
+   * cell a top and bottom rule: a full set of horizontal grid lines, not a rule at the
    * top and bottom of the table. A cell's own `options.border` overrides this entirely.
    *
-   * A `null` entry is a hole — that edge inherits from the table style — where
+   * A `null` entry is a hole (that edge inherits from the table style), where
    * `{ type: 'none' }` writes an explicit no-line that overrides it. Authoring nothing at
    * all depends on {@link tableStyle}: a styled table leaves every edge absent so the style
    * paints its grid, and a table with no style takes four no-fill sides, which is what keeps
@@ -395,7 +400,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    */
   border?: BorderProps | [BorderProps | null, BorderProps | null, BorderProps | null, BorderProps | null];
   /**
-   * Border for the table's outer perimeter only — the top edge of the first row, the
+   * Border for the table's outer perimeter only: the top edge of the first row, the
    * bottom edge of the last row, the left edge of the first column and the right edge of
    * the last column.
    *
@@ -406,7 +411,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    * own `options.border`) already put there.
    *
    * Applied **after** every other border source, so it wins on the sides it touches and
-   * leaves the interior alone — the "outline the table, no interior grid" case is
+   * leaves the interior alone. The "outline the table, no interior grid" case is
    * `outerBorder` with no `border` at all. Merged cells are handled: a span's covered cells
    * inherit the origin's borders, so a colspan straddling the last column still gets the
    * right-hand rule.
@@ -491,7 +496,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
   /**
    * Lay the table out right-to-left.
    * Emits `rtl="1"` on `<a:tblPr>`, which mirrors the column order so the first
-   * column renders on the right — the correct layout for RTL scripts (Arabic, Hebrew).
+   * column renders on the right, the correct layout for RTL scripts (Arabic, Hebrew).
    * This controls only the table/column direction; per-cell text direction is set
    * with each cell's `rtlMode` option.
    * @default false
@@ -507,7 +512,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    *
    * **Only a built-in GUID renders.** PowerPoint resolves `<a:tableStyleId>` against
    * its own table-style gallery and never reads a style definition out of the package,
-   * so a GUID it does not recognise leaves the table with PowerPoint's no-style look —
+   * so a GUID it does not recognise leaves the table with PowerPoint's no-style look:
    * a black hairline grid. For brand colours use direct formatting instead:
    * `headerRow`, `columns[i]`, the table-level {@link border} / {@link fill}, or per-cell
    * options. See `docs/tables.md` → "Apply a built-in table style".
@@ -521,7 +526,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    * This is how a header is styled distinctly from the body: each property is merged
    * onto every cell of row 0 (`fill`, `color`, `bold`, `align`, `border`, etc.).
    *
-   * Precedence (highest wins), matching how PowerPoint resolves styling — direct cell
+   * Precedence (highest wins), matching how PowerPoint resolves styling, where direct cell
    * formatting overrides a table-style region:
    * 1. explicit per-cell `options` on a row-0 cell
    * 2. this `headerRow`
@@ -537,13 +542,13 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    * Per-column default cell styling, applied as direct per-cell formatting.
    *
    * `columns[i]` is merged onto every cell that starts in column `i` (`fill`, `color`,
-   * `bold`, `align`, `valign`, `border`, `margin`, …), so a wide **colored** matrix —
-   * per-column fills, maturity-gradient headers — does not require hand-writing a fill
+   * `bold`, `align`, `valign`, `border`, `margin`, …), so a wide **colored** matrix
+   * (per-column fills, maturity-gradient headers) does not require hand-writing a fill
    * onto every cell. Entries may be sparse (`columns[2]` alone styles only column 2);
    * an `undefined`/omitted entry leaves that column untouched. The whole option is
    * optional and degrades cleanly to today's text-on-white when not given.
    *
-   * Precedence (highest wins), matching how PowerPoint resolves styling — direct cell
+   * Precedence (highest wins), matching how PowerPoint resolves styling, where direct cell
    * formatting overrides a table-style region:
    * 1. explicit per-cell `options`
    * 2. `headerRow` (row 0 only)
@@ -571,7 +576,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    */
   columns?: TableCellProps[];
   /**
-   * Default cell background — **stamped onto every cell**, not painted behind the table.
+   * Default cell background, **stamped onto every cell**, not painted behind the table.
    *
    * Each cell that does not set its own `options.fill` (or take one from `headerRow` /
    * `columns[i]`) gets this as its own `a:tcPr` fill. A picture fill is embedded once and
@@ -579,8 +584,8 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    *
    * Visually this is usually what you want, but it is not what a source deck contains, and
    * it has one real consequence: because every cell ends up explicitly filled, a cell that
-   * later gets its own fill has nothing to fall back to. For a genuine table background —
-   * one `a:tblPr` fill that cells sit on top of — use {@link tableFill}. A bare
+   * later gets its own fill has nothing to fall back to. For a genuine table background
+   * (one `a:tblPr` fill that cells sit on top of), use {@link tableFill}. A bare
    * {@link Color} is shorthand for a solid fill ({@link FillOption}).
    * @example 'FF0000' // hex color (red), shorthand for { color:'FF0000' }
    * @example { color:'FF0000' } // hex color (red)
@@ -590,18 +595,18 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    */
   fill?: FillOption;
   /**
-   * The table's own background (`a:tblPr` fill) — one fill behind the whole table that
+   * The table's own background (`a:tblPr` fill): one fill behind the whole table that
    * every cell sits on top of.
    *
    * The counterpart to {@link fill}, and the difference is where the paint lands rather
    * than how it looks: `fill` copies a colour onto every cell, while this writes a single
-   * fill on the table itself. That matters when a cell is meant to be transparent — with
+   * fill on the table itself. That matters when a cell is meant to be transparent: with
    * `tableFill`, an unfilled cell shows the table background through; with `fill` there is
    * no such thing as an unfilled cell. It is also what a deck read back from PowerPoint
    * actually carries, so a replica reproduces the source's structure rather than an
    * equivalent-looking flattening of it.
    *
-   * Takes the same {@link FillOption} a cell does — solid, gradient, pattern or picture,
+   * Takes the same {@link FillOption} a cell does: solid, gradient, pattern or picture,
    * or a bare {@link Color} as shorthand for a solid fill.
    * @example 'F2F2F2' // shorthand for { color:'F2F2F2' }
    * @example { color:'F2F2F2' } // a light background behind the whole table
@@ -622,7 +627,7 @@ interface TableProps extends PositionProps, TextBaseProps, ObjectNameProps {
    * value and anything that does not read as a finite number are not heights, so they do
    * not pin: the row is sized from the table's `h` instead, or grows to fit if there is
    * none, and a `table/invalid-row-height` diagnostic says so. A *missing* array slot, or
-   * `null` in it, is different and is silent — that is how an auto-height row is spelled.
+   * `null` in it, is different and is silent; that is how an auto-height row is spelled.
    *
    * The reading is shared by everything that answers a question about row height: the
    * emitted `<a:tr h>`, the export-time measured-fit pass, the auto-pager, and
@@ -643,7 +648,7 @@ interface TableCell {
   /**
    * Cell content: a plain string, or an array of `TableCell` runs for mixed formatting.
    * (A `number` is still coerced to a string at runtime for plain-JS callers, but is no
-   * longer part of the type — pass `String(n)` from TypeScript.)
+   * longer part of the type; pass `String(n)` from TypeScript.)
    */
   text?: string | TableCell[];
   options?: TableCellProps;
@@ -672,8 +677,8 @@ interface TableRowSlide {
   /**
    * The column grid (inches) the pager measured this page against, one entry per grid column.
    *
-   * The pager resolves `colW` — normalizing a short array, and distributing the usable width
-   * when the caller gave none — and the emitted table has to use the same grid, or the widths
+   * The pager resolves `colW` (normalizing a short array, and distributing the usable width
+   * when the caller gave none), and the emitted table has to use the same grid, or the widths
    * the text was wrapped to are not the widths it is drawn in. This carried it by writing
    * back onto the options bag it was handed, which made a reused bag change the next call's
    * output; it rides out here instead.
@@ -681,8 +686,6 @@ interface TableRowSlide {
   colW?: number[];
 }
 type TableRow = TableCell[];
-//#endregion
-//#region src/types/animation.d.ts
 /**
  * Base ECMA-376 slide-transition type (`p:transition`'s single type child). Each
  * maps to a `<p:TYPE/>` element; type-specific variants (e.g. direction) go in
@@ -715,8 +718,8 @@ interface TransitionProps {
   sound?: TransitionSoundProps;
 }
 /**
- * A transition sound (`p:sndAc`). Either a **start sound** — an embedded WAV played
- * when the transition runs (`p:stSnd` → `p:snd`), optionally looped — or the
+ * A transition sound (`p:sndAc`). Either a **start sound** (an embedded WAV played
+ * when the transition runs, `p:stSnd` → `p:snd`, optionally looped) or the
  * **stop-previous** form (`p:endSnd`) that silences a still-playing transition
  * sound. Built-in PowerPoint sounds embed identically to a custom file, so there is
  * no separate built-in path: supply the WAV bytes via `data` or `path`.
@@ -769,11 +772,16 @@ interface AnimationProps {
   /** Effect duration in milliseconds; preset-specific default when omitted. */
   durationMs?: number;
 }
-//#endregion
-//#region src/types/master.d.ts
-interface SlideNumberProps extends PositionProps, TextBaseProps {
+/**
+ * The slide number placeholder: one paragraph holding one slide-number field.
+ *
+ * Takes the `TextBaseProps` that format that field, its paragraph and its text body. `bullet`,
+ * `breakLine`, `softBreakBefore` and `tabStops` are left out: they shape a paragraph's list
+ * marker, its breaks between runs and its tab characters, and the field has none of them.
+ */
+interface SlideNumberProps extends PositionProps, Omit<TextBaseProps, 'bullet' | 'breakLine' | 'softBreakBefore' | 'tabStops'> {
   /**
-   * margin (inches) — text-frame internal margin; a value `>= 1` warns as a likely legacy points value
+   * margin (inches): text-frame internal margin; a value `>= 1` warns as a likely legacy points value
    */
   margin?: Margin;
 }
@@ -793,7 +801,7 @@ interface SlideMasterChartProps {
  * One object on a slide master, as a key-tagged descriptor.
  *
  * The six descriptors it shares with a group child are {@link CommonObjectDescriptor}; the two
- * below are the master's own — a chart, which a group cannot hold, and a placeholder, which is
+ * below are the master's own: a chart, which a group cannot hold, and a placeholder, which is
  * the whole point of a master.
  */
 type SlideMasterObject = CommonObjectDescriptor | {
@@ -810,7 +818,7 @@ type SlideMasterObject = CommonObjectDescriptor | {
 };
 /**
  * Bullet configuration for one slide-master text-style level (`a:buChar`/`a:buAutoNum`/`a:buNone`).
- * A focused subset of the run-level bullet model — picture bullets and per-glyph sizing are not
+ * A focused subset of the run-level bullet model: picture bullets and per-glyph sizing are not
  * supported in master defaults (those require slide rels). Set `bullet: false` to suppress the
  * level's bullet entirely.
  */
@@ -836,7 +844,7 @@ interface MasterTextStyleLevel {
   fontSize?: number;
   /** Font face (`a:defRPr/a:latin@typeface`). Unset keeps the theme font (`+mn-lt`/`+mj-lt`). */
   fontFace?: string;
-  /** Text color — hex (`'C00000'`) or theme slot (`'tx1'`) — emitted as `a:defRPr/a:solidFill`. */
+  /** Text color, hex (`'C00000'`) or theme slot (`'tx1'`), emitted as `a:defRPr/a:solidFill`. */
   color?: Color;
   /** Bold text (`a:defRPr@b`). */
   bold?: boolean;
@@ -848,7 +856,11 @@ interface MasterTextStyleLevel {
   marginLeft?: number;
   /** First-line indent in inches (`a:lvlNpPr@indent`); negative produces a hanging bullet. */
   indent?: number;
-  /** Bullet config: `false` emits `a:buNone`; an object configures a char/number bullet. Unset keeps the level default. */
+  /**
+   * Bullet config: `false` emits `a:buNone`; `true` gives the level a bullet, its own glyph where
+   * the level default has one and `•` where it has none (the title); an object configures a
+   * char/number bullet. Unset keeps the level default.
+   */
   bullet?: boolean | MasterBulletProps;
 }
 /**
@@ -881,8 +893,6 @@ interface SlideMasterProps {
    */
   textStyles?: MasterTextStyleProps;
 }
-//#endregion
-//#region src/types/model3d.d.ts
 /** A point or direction in the model's 3D scene, in metres. */
 interface Model3dPoint {
   x: number;
@@ -893,7 +903,7 @@ interface Model3dPoint {
  * Camera override for `addModel3d()`, mapping onto `am3d:camera`.
  *
  * The defaults are what PowerPoint itself wrote for a 2×2×2 cube, and they are correct for any
- * model whose bounding box is roughly cubic **once `meterPerModelUnit` is right** — the camera is
+ * model whose bounding box is roughly cubic **once `meterPerModelUnit` is right**. The camera is
  * expressed in metres, so the scale is what actually decides framing.
  *
  * PowerPoint's own rule, measured against three models: it normalizes the model's largest
@@ -938,7 +948,7 @@ interface Model3dCameraProps {
  */
 interface Model3dBaseProps extends PositionProps, ObjectNameProps {
   /**
-   * Picture of the model shown wherever the live 3D view is unavailable — a raster image `path`
+   * Picture of the model shown wherever the live 3D view is unavailable: a raster image `path`
    * (Node/local) or base64 `data:` URI.
    * - the library cannot render a 3D scene, so when this is omitted a neutral gray placeholder is
    *   embedded; PowerPoint 2019+ draws the live model on screen, in exports and in print, but older
@@ -956,13 +966,13 @@ interface Model3dBaseProps extends PositionProps, ObjectNameProps {
    */
   camera?: Model3dCameraProps;
   /**
-   * Metres per model unit (`am3d:trans/am3d:meterPerModelUnit`) — the scale that decides how
+   * Metres per model unit (`am3d:trans/am3d:meterPerModelUnit`): the scale that decides how
    * large the model is in the scene the {@link camera} looks at.
    *
    * This is the single override most models need. PowerPoint sets it to `1 / maxExtent`, where
    * `maxExtent` is the model's largest bounding-box dimension in model units, which normalizes
-   * every model to 1 metre across. pptx-ts does not parse the `.glb`, so it cannot measure that
-   * — it defaults to `0.5`, correct for a model 2 units across. A model 100 units across left at
+   * every model to 1 metre across. pptx-ts does not parse the `.glb`, so it cannot measure that;
+   * it defaults to `0.5`, correct for a model 2 units across. A model 100 units across left at
    * the default is a 50-metre object with the camera 2.26 metres from its centre, i.e. the
    * viewer is inside it.
    * - range: greater than 0
@@ -971,7 +981,7 @@ interface Model3dBaseProps extends PositionProps, ObjectNameProps {
    */
   meterPerModelUnit?: number;
   /**
-   * Alt text (`p:cNvPr@descr`) — what a screen reader announces for the model.
+   * Alt text (`p:cNvPr@descr`): what a screen reader announces for the model.
    */
   altText?: string;
 }
@@ -983,14 +993,12 @@ interface Model3dBaseProps extends PositionProps, ObjectNameProps {
  * intrinsic aspect ratio, and the library never opens the payload.
  */
 type Model3dProps = Model3dBaseProps & DataOrPathRequiredProps;
-//#endregion
-//#region src/types/zoom.d.ts
 /** Options shared by all three zoom kinds. */
 interface ZoomBaseProps extends PositionProps {
   /** Object name (PowerPoint selection-pane label). Auto-named (e.g. `Slide Zoom 3`) when omitted. */
   objectName?: string;
   /**
-   * Ship a caller-supplied thumbnail instead of the gray placeholder — a raster image `path`
+   * Ship a caller-supplied thumbnail instead of the gray placeholder: a raster image `path`
    * (Node/local) or base64 `data:` URI. Shown as-authored (not auto-refreshed by PowerPoint).
    */
   coverImage?: {
@@ -1010,7 +1018,7 @@ interface ZoomBaseProps extends PositionProps {
    * A zoom is a `p:graphicFrame`, so these land on its `a:graphicFrameLocks` and the flags that
    * apply are the graphic-frame ones (`noGrp`, `noDrilldown`, `noSelect`, `noChangeAspect`,
    * `noMove`, `noResize`); a picture-only flag warns and is dropped, as everywhere else. The
-   * `mc:Fallback` picture keeps its own fixed lock set — it is what pre-2016 consumers draw, and
+   * `mc:Fallback` picture keeps its own fixed lock set. It is what pre-2016 consumers draw, and
    * folding a graphic-frame flag set onto a `a:picLocks` element would warn about every flag the
    * two element types do not share.
    *
@@ -1022,7 +1030,7 @@ interface ZoomBaseProps extends PositionProps {
 }
 /** Slide Zoom: a tile that zooms to a single target slide. */
 interface SlideZoomProps extends ZoomBaseProps {
-  /** Target slide — a `Slide` returned by `addSlide()`, or its 1-based slide number. */
+  /** Target slide: a `Slide` returned by `addSlide()`, or its 1-based slide number. */
   target: Slide | number;
 }
 /** Section Zoom: a tile that zooms to the start of a named section. */
@@ -1035,8 +1043,6 @@ interface SectionZoomProps extends ZoomBaseProps {
  * The section containing the host slide is excluded (a summary does not link to itself).
  */
 type SummaryZoomProps = ZoomBaseProps;
-//#endregion
-//#region src/types/slide.d.ts
 /**
  * A child object that can be placed inside a group via `slide.addGroup()`.
  *
@@ -1057,7 +1063,7 @@ type GroupChildProps = CommonObjectDescriptor | {
  * Options for `slide.addGroup()`.
  *
  * The group keeps an identity child coordinate space (`chOff/chExt == off/ext`) at every depth:
- * children — including nested groups — keep their slide-absolute `x/y/w/h`. A consequence worth
+ * children, including nested groups, keep their slide-absolute `x/y/w/h`. A consequence worth
  * knowing: a group's own frame never moves or scales its children, it only places the selection
  * handle and the rotate pivot.
  *
@@ -1073,7 +1079,7 @@ interface GroupProps extends PositionProps, ObjectNameProps {
   /** Flip the group vertically */
   flipV?: boolean;
 }
-interface ObjectOptions extends ImageBaseProps, PositionProps, ShapeProps, TableCellProps, TextPropsOptions {
+interface ObjectOptions extends ImageBaseProps, Omit<ShapeProps, keyof PositionProps>, TableCellProps, TextPropsOptions {
   cx?: Coord;
   cy?: Coord;
   margin?: Margin;
@@ -1101,7 +1107,7 @@ interface SlideLayout {
 }
 /**
  * One authored object on a slide, as {@link Slide.objects} reports it: what it is and how it is
- * addressed, not how it is drawn. It is a snapshot taken when the getter ran, not a live handle —
+ * addressed, not how it is drawn. It is a snapshot taken when the getter ran, not a live handle:
  * nothing on it writes back, and a later `addShape`/`groupObjects` leaves it describing the slide
  * as it was.
  *
@@ -1109,11 +1115,11 @@ interface SlideLayout {
  * whose descriptors nobody kept, and the only durable handle on them is the `objectName` each one
  * was authored with; without a way to enumerate those, a consumer that wants to act on what is
  * already there has to either make every renderer surrender its internals or keep a parallel
- * ledger of what it added — and a ledger is wrong the moment a renderer adds an object it did not
+ * ledger of what it added, and a ledger is wrong the moment a renderer adds an object it did not
  * announce.
  */
 interface SlideObjectInfo {
-  /** What kind of object this is — the same value the object was authored as. */
+  /** What kind of object this is: the same value the object was authored as. */
   readonly type: SlideObjectType;
   /**
    * Selection Pane name, in the spelling the caller passed to `objectName`, so it can be handed
@@ -1121,7 +1127,7 @@ interface SlideObjectInfo {
    *
    * Always a string: an object authored without a name still gets the generated `Shape 3` /
    * `Text 1` / `Group 2` identity PowerPoint shows in the Selection Pane, and that name addresses
-   * it just as well. The two are indistinguishable here on purpose — nothing downstream of
+   * it just as well. The two are indistinguishable here on purpose: nothing downstream of
    * authoring records which is which, and a consumer that cares can tell them apart by the
    * naming convention it chose for its own objects.
    */
@@ -1130,7 +1136,7 @@ interface SlideObjectInfo {
   readonly isPlaceholder: boolean;
   /**
    * Whether `groupObjects()` would accept this object on kind alone. It cannot speak for the
-   * *selection* — an unresolved, duplicated or ambiguous name still throws — so it answers "is
+   * *selection* (an unresolved, duplicated or ambiguous name still throws), so it answers "is
    * this object groupable", never "will this call succeed".
    */
   readonly canGroup: boolean;
@@ -1148,7 +1154,7 @@ interface SlideObjectInfo {
  * `exactOptionalPropertyTypes`: `SlideBuilder` implements them as accessor pairs, so the property
  * is *always* present on a real slide and its getter answers `undefined` when nothing is set.
  * There is no absent state for the declaration to describe. Writing one is also how the setters
- * are cleared — `slide.transition = undefined` removes the `p:transition` — and an interface that
+ * are cleared (`slide.transition = undefined` removes the `p:transition`), and an interface that
  * could not express the value its own setter takes would be describing a different type.
  */
 interface Slide {
@@ -1159,7 +1165,7 @@ interface Slide {
   addConnector: (options: ConnectorProps) => Slide;
   addImage: (options: ImageProps) => Slide;
   addMedia: (options: MediaProps) => Slide;
-  /** Embed a 3D model (Insert ▸ 3D Models) — a `.glb` PowerPoint 2019+ renders live. */
+  /** Embed a 3D model (Insert ▸ 3D Models): a `.glb` PowerPoint 2019+ renders live. */
   addModel3d: (options: Model3dProps) => Slide;
   /** Embed an OLE object (Insert ▸ Object) whose bytes travel inside the `.pptx`. */
   addOleObject: (options: OleObjectProps) => Slide;
@@ -1174,22 +1180,22 @@ interface Slide {
   /** Group objects already on this slide, addressed by their `objectName`, into a single group. */
   groupObjects: (objectNames: string[], options?: GroupProps) => Slide;
   /**
-   * Add a Slide Zoom — a clickable tile that zooms to a single target slide (Insert ▸ Zoom).
+   * Add a Slide Zoom: a clickable tile that zooms to a single target slide (Insert ▸ Zoom).
    * @example slide.addSlideZoom({ target: intro, x: 1, y: 1, w: 3, h: 1.7 })
    */
   addSlideZoom: (options: SlideZoomProps) => Slide;
   /**
-   * Add a Section Zoom — a clickable tile that zooms to the start of a named section.
+   * Add a Section Zoom: a clickable tile that zooms to the start of a named section.
    * @example slide.addSectionZoom({ sectionTitle: 'Results', x: 1, y: 1, w: 3, h: 1.7 })
    */
   addSectionZoom: (options: SectionZoomProps) => Slide;
   /**
-   * Add a Summary Zoom — a grid of tiles, one per section (excluding this slide's own section).
+   * Add a Summary Zoom: a grid of tiles, one per section (excluding this slide's own section).
    * @example slide.addSummaryZoom({ x: 0.5, y: 1.5, w: 11, h: 4.5 })
    */
   addSummaryZoom: (options: SummaryZoomProps) => Slide;
   /**
-   * The objects authored on this slide so far, bottom-to-top in z-order — the read-back half of
+   * The objects authored on this slide so far, bottom-to-top in z-order: the read-back half of
    * `groupObjects()`, which addresses those same objects by name but until now gave no way to
    * learn the names.
    *
@@ -1236,7 +1242,10 @@ interface Slide {
    */
   background?: BackgroundOption | undefined;
   /**
-   * Default text color (hex format)
+   * Default text color (hex format): the color of `addText` and table text that states none
+   * itself, on its shape or on its table. Read when the slide is written, so it reaches text
+   * added before it was set. Placeholder text and hyperlinks keep inheriting their colors, and a
+   * table with a hyperlink in it states no default color at all.
    * @example 'FF3399'
    * @default '000000' (DEF_FONT_COLOR)
    */
@@ -1256,6 +1265,5 @@ interface AddSlideProps {
   masterTitle?: string;
   sectionTitle?: string;
 }
-//#endregion
 export { TableCellDiagonals as A, AnimationTrigger as C, TransitionType as D, TransitionSoundProps as E, TableToSlidesDocument as F, TableToSlidesElement as I, TableToSlidesProps as L, TableProps as M, TableRow as N, TableCell as O, TableRowSlide as P, AnimationProps as S, TransitionProps as T, MasterTextStyleProps as _, Slide as a, SlideMasterProps as b, SectionZoomProps as c, ZoomBaseProps as d, Model3dCameraProps as f, MasterTextStyleLevel as g, MasterBulletProps as h, ObjectOptions as i, TableCellProps as j, TableCell3DProps as k, SlideZoomProps as l, Model3dProps as m, GroupChildProps as n, SlideLayout as o, Model3dPoint as p, GroupProps as r, SlideObjectInfo as s, AddSlideProps as t, SummaryZoomProps as u, SlideMasterChartProps as v, PresetEffect as w, SlideNumberProps as x, SlideMasterObject as y };
-//# sourceMappingURL=slide-BqPtyKmb.d.ts.map
+//# sourceMappingURL=slide-BmT4kMoO.d.ts.map

package/dist/slide-BmT4kMoO.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide-BmT4kMoO.d.ts","names":[],"sources":["../src/types/table.ts","../src/types/animation.ts","../src/types/master.ts","../src/types/model3d.ts","../src/types/zoom.ts","../src/types/slide.ts"],"mappings":"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"}

package/dist/{slide-size-BalTjFuv.js → slide-size-SkScz1ig.js}

@@ -1,4 +1,4 @@
-//#region src/ooxml/slide-size.ts
+// src/ooxml/slide-size.ts
 /**
 * The slide size a presentation has when `presentation.xml` declares none.
 *
@@ -82,7 +82,6 @@ function presentationFormatLabel(widthEmu, heightEmu) {
 function slideSizeType(widthEmu, heightEmu) {
 	return standardSlideSize(widthEmu, heightEmu)?.type;
 }
-//#endregion
 export { presentationFormatLabel as n, slideSizeType as r, ABSENT_SLIDE_SIZE_EMU as t };
 
-//# sourceMappingURL=slide-size-BalTjFuv.js.map
+//# sourceMappingURL=slide-size-SkScz1ig.js.map