pptx-ts 0.0.1

package/dist/diagnostics-Du_s75MT.d.ts

@@ -0,0 +1,829 @@
+import { f as SHAPE_NAME, h as SlideObjectType, i as CHART_NAME, s as ChartType, y as WRITE_OUTPUT_TYPE } from "./enums-CvRYniUA.js";
+import { C as TableCell, D as TableProps, G as Margin, Gt as OptsChartData, J as PositionProps, Jt as ObjectLockProps, N as BackgroundProps, O as TableRow, Qt as MeasureTextOptions, R as GeometryPoint, St as ChartOpts, _n as MediaType, a as Slide, an as TableLayoutResult, f as MasterTextStyleProps, g as SlideNumberProps, gn as MediaProps, h as SlideMasterProps, i as ObjectOptions, ln as TextMeasurement, o as SlideLayout, rn as SlideComment, rt as HyperlinkProps, t as AddSlideProps, tn as OverflowBoxOptions, un as TextProps, xt as ChartMulti } from "./slide-js0QpRV-.js";
+import { c as WriteFileProps, d as ThemeProps, i as PresLayout, l as WriteProps, n as PackagePart, o as SectionProps, r as PartsProps, s as WriteBaseProps, t as CustomPropertyValue } from "./pres-C5__xkDh.js";
+import { a as ExtractedSlides, gn as EmbeddedFontSlot } from "./presentation-types-DP_8jog7.js";
+import { c as DiagnosticCode } from "./errors-PflMPWBn.js";
+//#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`
+   * (Node/local) or base64 `data:` URI. Shown as-authored (not auto-refreshed by PowerPoint).
+   */
+  coverImage?: {
+    path?: string;
+    data?: string;
+  };
+  /**
+   * After the zoom animates to its target, return to this (parent) slide when the target's
+   * content finishes. Maps to `zmPr@returnToParent`. Default `false`.
+   */
+  returnToParent?: boolean;
+  /** Zoom transition duration in milliseconds (`zmPr@transitionDur`). Default `1000`. */
+  transitionDur?: number;
+  /**
+   * Object lock flags ({@link ObjectLockProps}), as `objectLock` on every other object type.
+   *
+   * 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
+   * folding a graphic-frame flag set onto a `a:picLocks` element would warn about every flag the
+   * two element types do not share.
+   *
+   * `noChangeAspect` is on by default (a zoom tile mirrors its target slide's aspect); pass it
+   * `false` to lift it.
+   * @example { noMove: true, noResize: true } // pin the tile in place
+   */
+  objectLock?: ObjectLockProps;
+}
+/** 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 | number;
+}
+/** Section Zoom: a tile that zooms to the start of a named section. */
+interface SectionZoomProps extends ZoomBaseProps {
+  /** Title of the target section (as passed to `addSection({ title })`). */
+  sectionTitle: string;
+}
+/**
+ * Summary Zoom: a grid of tiles, one per section, that navigates to each section's start.
+ * The section containing the host slide is excluded (a summary does not link to itself).
+ */
+type SummaryZoomProps = ZoomBaseProps;
+//#endregion
+//#region src/types/internal.d.ts
+interface OptsChartDataInternal extends OptsChartData {
+  labels?: string[][];
+  /** Series index; always assigned by addChartDefinition() before this internal shape is built. */
+  _dataIndex: number;
+}
+interface ChartOptsInternal extends ChartOpts {
+  _type?: ChartType | ChartMulti[];
+}
+interface SlideRelChart extends OptsChartData {
+  type: CHART_NAME | ChartMulti[];
+  opts: ChartOptsInternal;
+  data: OptsChartDataInternal[];
+  rId: number;
+  Target: string;
+  globalId: number;
+  fileName: string;
+  /**
+   * True when `type` is a chartEx (cx:) chart (e.g. waterfall): the part is emitted as
+   * `chartEx{globalId}.xml` in the chart-extension namespace, gets the `chartex+xml` content
+   * type and the MS `.../2014/relationships/chartEx` rel type, and is referenced from the slide
+   * via `<mc:AlternateContent>`. Set at define time from {@link isChartExType}.
+   */
+  isChartEx?: boolean;
+}
+interface SlideRel {
+  type: SlideObjectType;
+  /**
+   * Relationship target, stored **unescaped**. Every emitter escapes it on the way out
+   * (`gen/slide/object.ts`, `gen/slide/notes.ts`, and `read/opc/relationships.ts` for the
+   * append path). Escaping at definition time instead would double-escape on append,
+   * where the serializer escapes again — so `&` in a hyperlink or online-video URL must
+   * arrive here verbatim.
+   */
+  Target: string;
+  fileName?: string;
+  data: any[] | string;
+  opts?: ChartOpts;
+  path?: string;
+  extn?: string;
+  globalId?: number;
+  rId: number;
+}
+interface SlideRelMedia {
+  type: string;
+  opts?: MediaProps;
+  path?: string;
+  extn?: string;
+  data?: string | ArrayBuffer;
+  /** used to indicate that a media file has already been read/enocded (PERF) */
+  isDuplicate?: boolean;
+  isSvgPng?: boolean;
+  svgSize?: {
+    w: number;
+    h: number;
+  };
+  /**
+   * Embedded OLE object part (`addOleObject`): the `.rels` `Type` URI to emit — `.../package` for
+   * an embedded OPC package (xlsx/docx/pptx, themselves zips) or `.../oleObject` for a generic OLE
+   * server blob (ECMA-376 Part 1 §15.2.10). Present only on OLE payload rels, where it takes
+   * precedence over the image/audio/video branch in `slideObjectRelationsToXml` and `type` carries
+   * the part's content type verbatim for `[Content_Types].xml`. The object's preview picture is a
+   * separate, perfectly ordinary image rel.
+   */
+  oleRelType?: string;
+  /**
+   * Embedded 3D model part (`addModel3d`): the `.rels` `Type` URI to emit — the Microsoft
+   * `…/office/2017/06/relationships/model3d` type, which no `includes('image'|'audio'|'video')`
+   * sniff would ever reach. Present only on the `.glb` payload rel, where it takes precedence
+   * over the image/audio/video branch in `slideObjectRelationsToXml` and `type` carries the
+   * part's content type verbatim for `[Content_Types].xml`. The model's preview picture is a
+   * separate, perfectly ordinary image rel. Same escape hatch as {@link oleRelType}.
+   */
+  model3dRelType?: string;
+  rId: number;
+  /** Unescaped — see {@link SlideRel.Target}. Doubles as the zip entry name for embedded media. */
+  Target: string;
+}
+interface SlideObject {
+  _type: SlideObjectType;
+  options?: ObjectOptions;
+  text?: TextProps[];
+  arrTabRows?: TableCell[][];
+  chartRid?: number;
+  image?: string;
+  imageRid?: number;
+  hyperlink?: HyperlinkProps;
+  media?: string;
+  mtype?: MediaType;
+  mediaRid?: number;
+  loop?: boolean;
+  loopCount?: number;
+  shape?: SHAPE_NAME;
+  _groupObjects?: SlideObject[];
+  zoom?: ZoomInternal;
+  ole?: OleInternal;
+  model3d?: Model3dInternal;
+}
+/**
+ * Resolved 3D-model payload carried on a {@link SlideObject} until `gen/slide/objects/model3d.ts`
+ * emits it. Camera values are already in `am3d`'s wire units so the emitter does no arithmetic:
+ * positions in 1/36,000,000ths of a metre, `fov` in 60000ths of a degree, and
+ * `meterPerModelUnitN` over a fixed denominator of 1,000,000.
+ */
+interface Model3dInternal {
+  /** rId of the embedded `.glb` part rel (see {@link SlideRelMedia.model3dRelType}). */
+  modelRid: number;
+  /** rId of the preview picture's image rel — shared by `am3d:blip` and the `mc:Fallback` `p:pic`. */
+  previewRid: number;
+  /** `am3d:camera/am3d:pos` (`@x`/`@y`/`@z`). */
+  pos: {
+    x: number;
+    y: number;
+    z: number;
+  };
+  /** `am3d:camera/am3d:lookAt` (`@x`/`@y`/`@z`). */
+  lookAt: {
+    x: number;
+    y: number;
+    z: number;
+  };
+  /** `am3d:camera/am3d:up` (`@dx`/`@dy`/`@dz`). */
+  up: {
+    dx: number;
+    dy: number;
+    dz: number;
+  };
+  /** `am3d:perspective@fov`, in 60000ths of a degree. */
+  fov: number;
+  /** `am3d:meterPerModelUnit@n`; `@d` is always 1,000,000. */
+  meterPerModelUnitN: number;
+}
+/** Resolved OLE payload carried on a {@link SlideObject} until `gen/slide/objects/ole.ts` emits it. */
+interface OleInternal {
+  /** rId of the embedded object part rel (see {@link SlideRelMedia.oleRelType}). */
+  objectRid: number;
+  /** rId of the preview picture's image rel (`p:pic > a:blip@r:embed`). */
+  previewRid: number;
+  /** `p:oleObj@progId` — the OLE server PowerPoint launches on double-click. */
+  progId: string;
+  /** `p:oleObj@name` — the object's kind as PowerPoint labels it (`Worksheet`, `Document`, …). */
+  name: string;
+  /** `p:oleObj@showAsIcon`; omitted when false, matching PowerPoint. */
+  showAsIcon: boolean;
+  /** `p:oleObj@imgW`/`@imgH` (EMU). Undefined means "use the frame's own extent". */
+  imgW?: number;
+  imgH?: number;
+}
+/** One tile inside a zoom object (a Slide/Section Zoom has one; a Summary Zoom has N). */
+interface ZoomTileInternal {
+  /** Slide Zoom: target slide id (= `PresSlideInternal._slideId`, emitted as `sldZmObj@sldId`). */
+  sldId?: number;
+  /** Section/Summary Zoom: target section GUID (`{...}`, emitted as `sectionZmObj@sectionId`). */
+  sectionId?: string;
+  /** rId of the preview/cover image blip (`zmPr>blipFill>a:blip@r:embed`). Shared across tiles when identical. */
+  previewRid: number;
+  /** rId of the `.../slide` rel used by the `mc:Fallback` picture's `hlinkClick` (target/section-start slide). */
+  fallbackSlideRid: number;
+  /** Per-tile `zmPr@id` GUID (`{...}`). */
+  zmPrId: string;
+  /** Summary Zoom only: this tile's grid cell within the graphic-frame coordinate space (EMU). */
+  grid?: {
+    x: number;
+    y: number;
+    cx: number;
+    cy: number;
+  };
+}
+/** Resolved zoom payload carried on a {@link SlideObject} until `gen/slide/objects/zoom.ts` emits it. */
+interface ZoomInternal {
+  variant: 'slide' | 'section' | 'summary';
+  tiles: ZoomTileInternal[];
+  /** `zmPr@returnToParent`; emitted as `"0"`/`"1"` for Slide Zoom, omitted for Section/Summary. */
+  returnToParent: boolean;
+  /** `zmPr@transitionDur` (ms). */
+  transitionDur: number;
+}
+interface SlideBaseProps {
+  _bkgdImgRid?: number;
+  _margin?: Margin;
+  _name?: string;
+  _presLayout: PresLayout;
+  _rels: SlideRel[];
+  _relsChart: SlideRelChart[];
+  _relsMedia: SlideRelMedia[];
+  _relsNotes?: SlideRel[];
+  _comments?: SlideComment[];
+  _txStyles?: MasterTextStyleProps;
+  _slideNum: number;
+  _slideNumberProps?: SlideNumberProps | null;
+  _slideObjects: SlideObject[];
+  /**
+   * Per-kind counters backing default Selection Pane names (`Shape 0`, `Image 1`, `Group 1`, …),
+   * keyed by `SlideObjectType`. Monotonic for the life of the slide: an object consumes its index
+   * when it is added, whether it stays top-level or is moved into a group's `_groupObjects`.
+   * Lazily created by `nextObjectNameIdx` (`gen/define/object-name.ts`).
+   */
+  _objectNameCounts?: Partial<Record<SlideObjectType, number>>;
+  background?: BackgroundProps;
+}
+interface SlideLayoutInternal extends SlideBaseProps, SlideLayout {
+  _slide?: {
+    _bkgdImgRid?: number;
+    back: string;
+    color: string;
+    hidden?: boolean;
+  } | null;
+}
+//#endregion
+//#region src/runtime/types.d.ts
+type RuntimeAdapter = {
+  readonly writeFileOutputType: WRITE_OUTPUT_TYPE | null;
+  /**
+   * Load a media file into a base64 payload for `rel.data`.
+   *
+   * **Two encodings are accepted, deliberately.** Either raw base64 (`iVBORw0…`) or a full
+   * data URI (`data:image/png;base64,iVBORw0…`). The browser adapter returns the second
+   * because `FileReader.readAsDataURL` is what decodes a blob without blocking; Node and the
+   * neutral adapter return the first because neither has a `FileReader`. So an adapter may
+   * return whichever its host makes cheap: `gen/media.ts` puts the result through
+   * {@link toMediaDataUri} on the way into `rel.data`, and everything past that point sees one
+   * form. Do not add a third: that helper recognizes exactly these two.
+   */
+  loadMedia: (rel: SlideRelMedia & {
+    path: string;
+  }) => Promise<string>;
+  createSvgPngPreview: (rel: SlideRelMedia) => Promise<string>;
+  writeFile: (fileName: string, data: string | ArrayBuffer | Blob | Uint8Array) => Promise<string>;
+  /**
+   * Load a font file into raw bytes for `registerFontMetrics`.
+   *
+   * An `http:`/`https:` URL is fetched by every adapter. Anything else is a filesystem path,
+   * which only the Node adapter can read; elsewhere it is a load failure naming the path.
+   */
+  loadFontData: (source: string) => Promise<Uint8Array>;
+};
+//#endregion
+//#region src/units.d.ts
+/**
+ * Public unit conversion helpers and standard PowerPoint slide-layout constants.
+ */
+declare const EMU_PER_INCH = 914400;
+declare const EMU_PER_POINT = 12700;
+declare const POINTS_PER_INCH = 72;
+/**
+ * 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
+ * degrees by this to get the OOXML integer.
+ */
+declare const ANGLE_UNITS_PER_DEGREE = 60000;
+/**
+ * DrawingML fixed-point percentage scale. `ST_Percentage` / `ST_PositiveFixedPercentage` and
+ * related types (`<a:alpha>`, `<a:spcPct>`, shape adjustment guides, `<p:tav tm>`, …) encode
+ * 100% as the integer 100000. Multiply a 0-1 fraction by this to get the OOXML value.
+ */
+declare const PERCENT_SCALE = 100000;
+/**
+ * Scale for a percentage supplied as 0-100 (rather than a 0-1 fraction) into the same
+ * fixed-point percentage integer as {@link PERCENT_SCALE} (1% = 1000 units, i.e. thousandths
+ * of a percent). Use for inputs documented as percents: transparency/alpha, image crop insets,
+ * gradient stops, bullet size, connector adjust, etc.
+ */
+declare const FIXED_PCT_PER_PERCENT: number;
+/**
+ * DrawingML text measures font size (`sz`), character spacing (`spc`) and point line/paragraph
+ * spacing (`<a:spcPts val>`) in hundredths of a point. Multiply a value in points by this to get
+ * the OOXML integer.
+ */
+declare const HUNDREDTHS_PER_POINT = 100;
+/**
+ * Convert a value in points to hundredths of a point (rounded), the integer unit DrawingML uses
+ * for `sz`, `spc`, and `<a:spcPts val>`. See {@link HUNDREDTHS_PER_POINT}.
+ */
+declare function ptToHundredths(pt: number): number;
+/**
+ * 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
+ * a compile-time error. This replaces the old runtime "a number ≥ 100 must already be EMU"
+ * magnitude guess, which silently mis-rendered values near the threshold.
+ */
+type Emu = number & {
+  readonly __unit: 'emu';
+};
+/** Default pixel density for the `"<n>px"` coordinate unit: CSS reference pixels, also the
+ *  density ts-pptx assumes when reading an image header's pixel dimensions. */
+declare const DEFAULT_PX_PER_INCH = 96;
+type StandardLayoutName = 'LAYOUT_4x3' | 'LAYOUT_16x9' | 'LAYOUT_16x10' | 'LAYOUT_WIDE';
+interface StandardLayout {
+  /** ts-pptx layout key used with `pptx.layout`. */
+  readonly layout: StandardLayoutName;
+  /** PresentationML slide-size preset name, or `custom` for PowerPoint widescreen. */
+  readonly name: string;
+  /** Slide width in inches — inches is ts-pptx's default coordinate unit, so this is the value to use for `addText`/`addShape` math. */
+  readonly widthIn: number;
+  /** Slide height in inches. */
+  readonly heightIn: number;
+  /** Slide width in English Metric Units. */
+  readonly widthEmu: number;
+  /** Slide height in English Metric Units. */
+  readonly heightEmu: number;
+}
+declare function inchesToEmu(inches: number): Emu;
+declare function pointsToEmu(points: number): Emu;
+declare function pixelsToEmu(pixels: number, dpi: number): Emu;
+/**
+ * Resolve a percentage of an axis length to EMU.
+ * @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)
+ */
+declare function percentToEmu(percent: number, axisEmu: number): Emu;
+/**
+ * The single user-coordinate → EMU boundary. Convert each user-supplied coordinate exactly once.
+ *
+ * Accepts (see {@link Coord}):
+ * - a bare `number` → **always inches** (the documented unit); no magnitude guessing
+ * - `"<n>%"` → percentage of `axisEmu`
+ * - `"<n>in"` / `"<n>pt"` / `"<n>px"` / `"<n>emu"` → explicit units (the escape hatch for non-inch
+ *   values). `px` is resolved at {@link DEFAULT_PX_PER_INCH} (96), for authoring against a known
+ *   web/source canvas size.
+ *
+ * Throws on non-finite or unparseable input rather than silently emitting a degenerate 0-size.
+ * @param value - user coordinate
+ * @param axisEmu - axis length in EMU, used only to resolve percentages
+ */
+declare function coordToEmu(value: number | string, axisEmu: number): Emu;
+declare function emuToInches(emu: number): number;
+declare function emuToPoints(emu: number): number;
+declare function emuToPixels(emu: number, dpi: number): number;
+declare const STANDARD_LAYOUTS: Readonly<Record<StandardLayoutName, StandardLayout>>;
+//#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
+ * 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
+ * package entry, not read off the instance.
+ *
+ * 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 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
+ * (`browser.ts`) so it stays out of the Node build and out of the core chunk.
+ */
+declare class PresentationCore {
+  /**
+   * Presentation layout name
+   * Standard layouts:
+   * - 'LAYOUT_4x3'   (10"    x 7.5")
+   * - 'LAYOUT_16x9'  (10"    x 5.625")
+   * - 'LAYOUT_16x10' (10"    x 6.25")
+   * - 'LAYOUT_WIDE'  (13.333" x 7.5")
+   * Custom layouts:
+   * Use `pptx.defineLayout()` to create custom layouts (e.g.: 'A4')
+   * @type {string}
+   * @see https://support.office.com/en-us/article/Change-the-size-of-your-slides-040a811c-be43-40b9-8d04-0de5ed79987e
+   */
+  private _layout;
+  set layout(value: string | StandardLayout);
+  get layout(): string;
+  /**
+   * ts-pptx Library Version
+   */
+  private readonly _version;
+  get version(): string;
+  /**
+   * @type {string}
+   */
+  private _author;
+  set author(value: string);
+  get author(): string;
+  /**
+   * @type {string}
+   */
+  private _company;
+  set company(value: string);
+  get company(): string;
+  /**
+   * @type {string}
+   * @note the `revision` value must be a whole number only (without "." or "," - otherwise, PPT will throw errors upon opening!)
+   */
+  private _revision;
+  set revision(value: string);
+  get revision(): string;
+  /**
+   * @type {string}
+   */
+  private _subject;
+  set subject(value: string);
+  get subject(): string;
+  /**
+   * @type {ThemeProps}
+   */
+  private _theme;
+  set theme(value: ThemeProps);
+  get theme(): ThemeProps;
+  /**
+   * @type {string}
+   */
+  private _title;
+  set title(value: string);
+  get title(): string;
+  /** Slide number shown on the first slide (maps to firstSlideNum in presentation.xml) */
+  private _firstSlideNum;
+  set firstSlideNum(value: number);
+  get firstSlideNum(): number;
+  /**
+   * Whether Right-to-Left (RTL) mode is enabled
+   * @type {boolean}
+   */
+  private _rtlMode;
+  set rtlMode(value: boolean);
+  get rtlMode(): boolean;
+  /** master slide layout object */
+  private readonly _masterSlide;
+  get masterSlide(): Slide;
+  /** this Presentation's Slide objects */
+  private readonly _slides;
+  get slides(): Slide[];
+  /** this Presentation's sections */
+  private readonly _sections;
+  get sections(): SectionProps[];
+  /** custom document properties stored in docProps/custom.xml */
+  private _customProperties;
+  /**
+   * 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
+   * browser build only (it reads a live DOM), see `browser.ts`.
+   */
+  protected readonly _slideLayouts: SlideLayoutInternal[];
+  get slideLayouts(): SlideLayout[];
+  private get internalPresentation();
+  private LAYOUTS;
+  private _presLayout;
+  get presLayout(): PresLayout;
+  private readonly _runtime;
+  /** Write-side font metrics for measured text fit (`fit:'shrink'`). @see registerFontMetrics */
+  private readonly _fontMetrics;
+  /** Author-side embedded font faces, accumulated by {@link embedFont} and emitted at write time. */
+  private readonly _embeddedFonts;
+  constructor(runtime: RuntimeAdapter);
+  /**
+   * Provides an API for `addTableDefinition` to create slides as needed for auto-paging
+   * @param {AddSlideProps} options - slide masterTitle and/or sectionTitle
+   * @return {Slide} new Slide
+   */
+  private readonly addNewSlide;
+  /**
+   * Provides an API for `addTableDefinition` to get slide reference by number
+   * @param {number} slideNum - slide number
+   * @return {Slide} Slide
+   */
+  private readonly getSlide;
+  /**
+   * Provides the live section list to the `Slide` class so Section/Summary Zoom can resolve
+   * a section title to its stable GUID and enumerate sections in order.
+   * @return {SectionInternalProps[]} the presentation's sections
+   */
+  private readonly getSections;
+  /**
+   * Enables the `Slide` class to set ts-pptx [Presentation] master/layout slidenumbers
+   * @param {SlideNumberProps} slideNum - slide number config
+   */
+  private readonly setSlideNumber;
+  /**
+   * Assemble the slice of internal state the packaging layer reads. `PresentationCore` owns the
+   * authored deck; `writePackage` (in `package/assemble.ts`) turns it into OOXML parts.
+   */
+  private packageSource;
+  /**
+   * 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
+   * splice the slides in via `Presentation.appendSlides()` (see `ts-pptx/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
+   * path consumes each descriptor to reserve the parts and rebuild the rel graph.
+   */
+  extractSlides: (opts?: {
+    onMediaError?: 'throw' | 'placeholder';
+  }) => Promise<ExtractedSlides>;
+  /**
+   * Register a font's metrics so `fit:'shrink'` text boxes are measured and a real
+   * `fontScale` is baked at export time (text renders pre-shrunk in headless
+   * renderers and on plain file-open, with no manual edit/resize).
+   *
+   * Without registered metrics, `fit:'shrink'` keeps its current behavior (a bare
+   * `<a:normAutofit/>` that only PowerPoint recomputes on edit). Register the same
+   * face once per weight/style you use; bold/italic advances differ.
+   *
+   * **Font collections** (`.ttc`/`.otc`, how MS Gothic, Yu Gothic, SimSun, Microsoft
+   * YaHei and Cambria ship on Windows) hold several fonts in one file, so one has to be
+   * chosen. With no `font` option, `face` is used as the selector, which is usually what
+   * you meant; a `face` that names no font in the collection throws rather than falling
+   * back to the first, since measuring the wrong member is invisible downstream. Pass
+   * `font` when the deck-side name differs from the name inside the file, and use
+   * `listFontFaces` from `ts-pptx/measure` to see what a file holds.
+   * @param {string} face - font family name as used in `fontFace` (e.g. 'Aptos')
+   * @param {string | Uint8Array | ArrayBuffer} source - font file path/URL (Node/web) or raw TTF/OTF/TTC bytes
+   * @param {object} [opts] - variant flags (advances differ per weight/style) and collection selection
+   * @param {boolean} [opts.bold] - these are the bold advances
+   * @param {boolean} [opts.italic] - these are the italic advances
+   * @param {number | string} [opts.font] - which font inside a collection: 0-based index, or a name
+   * @example await pptx.registerFontMetrics('Aptos', '/usr/share/fonts/Aptos.ttf')
+   * @example await pptx.registerFontMetrics('Aptos', aptosBoldBytes, { bold: true })
+   * @example await pptx.registerFontMetrics('MS PGothic', 'C:/Windows/Fonts/msgothic.ttc')
+   * @example await pptx.registerFontMetrics('Cambria Math', 'C:/Windows/Fonts/cambria.ttc', { font: 1 })
+   */
+  registerFontMetrics(face: string, source: string | Uint8Array | ArrayBuffer, opts?: {
+    bold?: boolean;
+    italic?: boolean;
+    font?: number | string;
+  }): Promise<void>;
+  /**
+   * Embed a font face so the deck renders with it even on machines that do not
+   * have it installed. The **whole** face is embedded (not glyph-subset) under
+   * `/ppt/fonts/` and wired into `presentation.xml` (`p:embeddedFontLst` +
+   * `embedTrueTypeFonts="1"`), exactly as PowerPoint's "Embed fonts in the file"
+   * does. Call once per face/weight you use.
+   *
+   * The declared `typeface` MUST match the family name used in your run/`fontFace`
+   * typefaces (e.g. `addText('hi', { fontFace: 'Silkscreen' })`) or PowerPoint
+   * will not bind the embedded bytes to the text. Repeated calls with the same
+   * `typeface` and different `style` accumulate into one `p:embeddedFont` entry.
+   *
+   * Font licensing is the caller's responsibility: the bytes are embedded as
+   * handed over; `OS/2.fsType` embedding-permission bits are not enforced.
+   * @param {object} opts - font source + identity
+   * @param {string} [opts.path] - font file path (Node) or URL (web) to a `.ttf`/`.otf`
+   * @param {ArrayBuffer | Uint8Array | string} [opts.data] - raw font bytes, or a base64 string, in lieu of `path`
+   * @param {string} opts.typeface - family name as referenced by run/`fontFace` typefaces
+   * @param {EmbeddedFontSlot} [opts.style] - face slot; defaults to `'regular'`
+   * @example await pptx.embedFont({ path: '/fonts/Silkscreen-Regular.ttf', typeface: 'Silkscreen' })
+   * @example await pptx.embedFont({ path: '/fonts/Silkscreen-Bold.ttf', typeface: 'Silkscreen', style: 'bold' })
+   */
+  embedFont(opts: {
+    path?: string;
+    data?: ArrayBuffer | Uint8Array | string;
+    typeface: string;
+    style?: EmbeddedFontSlot;
+  }): 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
+   * value `fit:'shrink'`/`'resize'` would bake. Synchronous: register the face's metrics
+   * first with {@link TsPptx.registerFontMetrics} (lookup is sync).
+   *
+   * 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`)
+   * @param {MeasureTextOptions} opts - width (inches), font size/face (points), and spacing
+   * @returns {TextMeasurement} laid-out height + line count + fit helpers
+   * @example const m = pptx.measureText('Long heading…', { wIn: 3, fontSize: 18, fontFace: 'Aptos' })
+   * @example if (pptx.measureText(runs, { wIn, fontSize, fontFace }).heightIn > cardHeightIn) growCard()
+   */
+  measureText(text: string | TextProps[], opts: MeasureTextOptions): TextMeasurement;
+  /**
+   * 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
+   * 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
+   * @param {OverflowBoxOptions} opts - {@link MeasureTextOptions} plus the box inner height `hIn`
+   * @returns {boolean} true if the text overflows the box
+   */
+  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
+   * 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
+   * 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`, …)
+   * @returns {TableLayoutResult} per-cell rectangles (inches) plus overall table bounds
+   * @example
+   * const g = pptx.tableLayout(rows, { x: 1, y: 1, w: 8, colW: [2, 3, 3] })
+   * const c = g.cells.find(c => c.row === 0 && c.col === 2)
+   * slide.addImage({ path: 'logo.png', x: c.xIn, y: c.yIn, w: c.wIn, h: c.hIn })
+   */
+  tableLayout(rows: TableRow[], opts: TableProps): TableLayoutResult;
+  /**
+   * Export the current presentation as portable ZIP bytes. Unlike the former
+   * `stream()` method, this does not imply incremental output or convert the
+   * archive to a Node `Buffer`: package assembly is synchronous and the returned
+   * `Uint8Array` works unchanged in Node, browsers, and workers.
+   * @param {WriteBaseProps} props - output properties
+   * @returns {Promise<Uint8Array>} complete `.pptx` archive bytes
+   */
+  toBytes(props?: WriteBaseProps): Promise<Uint8Array>;
+  /**
+   * Export the current Presentation as ZIP content with the selected type
+   * @param {WriteProps} props output properties
+   * @returns {Promise<string | ArrayBuffer | Blob | Uint8Array>} file content in selected type
+   */
+  write(props?: WriteProps): Promise<string | ArrayBuffer | Blob | Uint8Array>;
+  /**
+   * 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.
+   *
+   * The returned parts are byte-identical, per part, to what `write()` emits for the same deck,
+   * and their order is the package's emission order. Both are a stability-guaranteed observable
+   * contract: adding a new part in a later release is backward-compatible as long as existing
+   * part paths and their relative order do not shift; renaming or reordering an existing part is
+   * a breaking change. Each call returns fresh `Uint8Array` views over per-call buffers (a new
+   * assembly runs each time), so callers may retain or transfer them without defensive copying.
+   * @param {PartsProps} props - assembly options (`onMediaError` only; compression/output shape
+   *   are zip concerns that do not apply to unzipped parts)
+   * @returns {Promise<PackagePart[]>} the package parts in emission order
+   */
+  toParts(props?: PartsProps): Promise<PackagePart[]>;
+  /**
+   * Export the current Presentation.
+   * Write the generated presentation to disk (Node) or trigger a download (browser).
+   * @param {WriteFileProps} props - output file properties
+   * @returns {Promise<string>} the presentation name
+   */
+  writeFile(props?: WriteFileProps): Promise<string>;
+  /**
+   * Set a custom document property stored in `docProps/custom.xml`.
+   * Calling with the same name replaces the existing value.
+   * @param name - property name
+   * @param value - string, integer/float number, boolean, or Date
+   */
+  setCustomProperty(name: string, value: CustomPropertyValue): void;
+  /**
+   * Add a new Section to Presentation
+   * @param {SectionProps} section - section properties
+   * @example pptx.addSection({ title:'Charts' });
+   */
+  addSection(section: SectionProps): void;
+  /**
+   * Add a new Slide to Presentation
+   * @param {AddSlideProps} options - slide options
+   * @returns {Slide} the new Slide
+   */
+  addSlide(options?: AddSlideProps): Slide;
+  /**
+   * Create a custom Slide Layout in any size
+   * @param {PresLayout} layout - layout properties
+   * @example pptx.defineLayout({ name:'A3', width:16.5, height:11.7 });
+   */
+  defineLayout(layout: PresLayout): void;
+  /**
+   * Create a new slide master [layout] for the Presentation
+   * @param {SlideMasterProps} props - layout properties
+   */
+  defineSlideMaster(props: SlideMasterProps): void;
+}
+//#endregion
+//#region src/clip.d.ts
+/**
+ * Which edge of the box is the half-disc's FLAT side; the arc bulges toward the opposite edge.
+ * `'right'` = flat right edge, arc bulging left.
+ */
+type FlatSide = 'left' | 'right';
+/**
+ * Which half-disc proportion to trace. Both are flat-on-one-edge, bulging half-discs whose arc
+ * reaches the opposite edge near mid-height; they differ only in how far the arc reaches.
+ * - `'deep'` — the arc spans about 32% of the box width, symmetric about mid-height (the default).
+ * - `'shallow'` — the arc spans about 13%, slightly asymmetric, with its apex just below mid-height.
+ */
+type HalfDiscPreset = 'deep' | 'shallow';
+/** A named clip silhouette, resolved to a `points` path by {@link clipPath}. */
+type ClipShape =
+/**
+ * A rectangle with one side replaced by an elliptical arc that bulges toward the opposite
+ * edge, reaching it near mid-height — the "D" a picture placeholder cuts on a cover slide.
+ */
+{
+  kind: 'half-disc';
+  flat: FlatSide;
+  preset?: HalfDiscPreset;
+};
+/**
+ * Resolve a {@link ClipShape} to a freeform `points` path filling a `w × h` box, ready to hand
+ * to `addImage({ points })`.
+ *
+ * `w`/`h` are the image box's size **in inches** and must match the `w`/`h` the picture is drawn
+ * at — the path is emitted in the box's own coordinate space, not normalized (see the module
+ * note above).
+ * @param {ClipShape} shape - the named silhouette and its options
+ * @param {number} w - image box width (inches)
+ * @param {number} h - image box height (inches)
+ * @returns {GeometryPoint[]} the freeform path, for `addImage({ points })`
+ * @example
+ * const w = 5.22, h = 7.5
+ * slide.addImage({
+ *   path: 'cover.jpg', x: 0, y: 0, w, h,
+ *   points: clipPath({ kind: 'half-disc', flat: 'right' }, w, h),
+ *   sizing: { type: 'cover' },   // center-crop the photo into the "D"
+ * })
+ */
+declare function clipPath(shape: ClipShape, w: number, h: number): GeometryPoint[];
+//#endregion
+//#region src/diagnostics.d.ts
+/** One diagnostic emitted by the library. */
+interface Diagnostic {
+  /** Stable condition identifier — see {@link DiagnosticCode}. Branch on this, not on the text. */
+  readonly code: DiagnosticCode;
+  /** Human-readable explanation. Free to change in any release; do not parse it. */
+  readonly message: string;
+  /**
+   * Structured context for the condition, when a site has any to give. No site populates it
+   * today; it exists so one can start to without a breaking signature change.
+   */
+  readonly detail?: Readonly<Record<string, unknown>>;
+}
+/** Receives every {@link Diagnostic} the library emits. See {@link setDiagnosticHandler}. */
+type DiagnosticHandler = (diagnostic: Diagnostic) => void;
+/**
+ * Route every library diagnostic to `handler`, or pass `null` to restore the default
+ * (one prefixed `console.warn` per diagnostic).
+ *
+ * This is process-global rather than per-presentation, deliberately: the emitting code is a tree
+ * of free functions in `gen/**` with no presentation in scope, and threading a handler through
+ * every signature would be a far larger and worse change than the problem warrants. The practical
+ * consequence is that a process building several decks concurrently cannot attribute a diagnostic
+ * to one of them; if that matters, correlate on `code` or set the handler around each build.
+ *
+ * A throwing handler propagates out of whatever library call emitted the diagnostic, which is the
+ * supported way to make a specific condition fatal:
+ *
+ * ```ts
+ * setDiagnosticHandler((d) => {
+ *   if (d.code === 'coord/bare-number-is-inches') throw new Error(d.message)
+ * })
+ * ```
+ * @param next - the receiver, or `null` to restore the console default
+ */
+declare function setDiagnosticHandler(next: DiagnosticHandler | null): void;
+/**
+ * Clear the {@link warnOnce} dedupe set, so a condition already reported reports again.
+ *
+ * Call it between builds in a host that builds more than one deck per process and wants each
+ * build's diagnostics complete. Without it, deck two is silent about anything deck one already
+ * warned for, which reads as "no problems found" rather than as "already mentioned".
+ *
+ * It also bounds the set. Most `warnOnce` messages interpolate the offending value, so a server
+ * 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
+ * reset independently on purpose: a host usually installs its handler once and wants it to
+ * survive.
+ */
+declare function resetDiagnosticState(): void;
+//#endregion
+export { ptToHundredths as A, emuToInches as C, percentToEmu as D, inchesToEmu as E, SlideZoomProps as M, SummaryZoomProps as N, pixelsToEmu as O, ZoomBaseProps as P, coordToEmu as S, emuToPoints as T, PERCENT_SCALE as _, ClipShape as a, StandardLayout as b, clipPath as c, DEFAULT_PX_PER_INCH as d, EMU_PER_INCH as f, HUNDREDTHS_PER_POINT as g, FIXED_PCT_PER_PERCENT as h, setDiagnosticHandler as i, SectionZoomProps as j, pointsToEmu as k, PresentationCore as l, Emu as m, DiagnosticHandler as n, FlatSide as o, EMU_PER_POINT as p, resetDiagnosticState as r, HalfDiscPreset as s, Diagnostic as t, ANGLE_UNITS_PER_DEGREE as u, POINTS_PER_INCH as v, emuToPixels as w, StandardLayoutName as x, STANDARD_LAYOUTS as y };
+//# sourceMappingURL=diagnostics-Du_s75MT.d.ts.map