pptx-ts 0.0.1 → 4.0.0

package/dist/entry-compose-DCnvBZz2.d.ts

@@ -0,0 +1,1046 @@
+import { d as SHAPE_NAME, i as CHART_NAME, m as SlideObjectType, v as WRITE_OUTPUT_TYPE } from "./enums-BUKTUB6V.js";
+import { Bt as TextMeasurement, Ft as TableLayoutResult, Ht as TextPropsOptions, Kt as ImageProps, Nt as SlideComment, Ot as MeasureTextOptions, Q as ChartOpts, S as HexColor, Vt as TextProps, Z as ChartMulti, c as WriteFileProps, d as ThemeProps, f as BackgroundOption, i as PresLayout, jt as OverflowBoxOptions, kt as NotesProps, l as WriteProps, n as PackagePart, nn as ShapeProps, o as SectionProps, r as PartsProps, s as WriteBaseProps, t as CustomPropertyValue, xt as OptsChartData } from "./pres-C6qgOFAa.js";
+import { L as TableToSlidesProps, M as TableProps, N as TableRow, S as AnimationProps, T as TransitionProps, a as Slide, b as SlideMasterProps, n as GroupChildProps, o as SlideLayout, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, x as SlideNumberProps, y as SlideMasterObject } from "./slide-Dx2ZeVZ6.js";
+import { r as EmbeddedFontSlot } from "./embedded-fonts-DarT9aoa.js";
+import { A as SlideObject, D as SectionInternalProps, E as PresentationPropsInternal, M as SlideRelChart, N as SlideRelMedia, O as SlideLayoutInternal, T as PresSlideInternal, j as SlideRel, k as SlideMasterInternal, n as FontMetricsRegistry, w as ObjectOptionsInternal } from "./font-metrics-v5fn7s7e.js";
+import { s as MediaError } from "./diagnostics-D8ot4Ei7.js";
+import { c as ExtractedSlides, s as ExtractedSlide } from "./presentation-types-8jLQHI4M.js";
+import { r as ZipWriter } from "./zip-C0leZZMj.js";
+//#region src/runtime/types.d.ts
+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>;
+  /**
+   * Write the PNG fallback an SVG rel needs into `rel.data`.
+   *
+   * Resolves with the failure rather than rejecting, having stamped the placeholder either way:
+   * whether a failed preview fails the export is `onMediaError`'s decision, and `gen/media.ts`
+   * makes it once for every adapter and every way the SVG arrived. `null` means nothing failed,
+   * which includes a runtime with no rasterizer, whose placeholder is its only output.
+   */
+  createSvgPngPreview: (rel: SlideRelMedia) => Promise<MediaError | null>;
+  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
+/**
+ * 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;
+/**
+ * The largest DrawingML coordinate, in EMU: the `maxInclusive` of `ST_Coordinate`, the type of
+ * every shape offset and extent. The range is not symmetric; see {@link MIN_COORDINATE_EMU}.
+ */
+declare const MAX_COORDINATE_EMU = 27273042316900;
+/** The smallest DrawingML coordinate, in EMU: the `minInclusive` of `ST_Coordinate`. */
+declare const MIN_COORDINATE_EMU = -27273042329600;
+type StandardLayoutName = 'LAYOUT_4x3' | 'LAYOUT_16x9' | 'LAYOUT_16x10' | 'LAYOUT_WIDE';
+interface StandardLayout {
+  /** ts-pptx layout key used with `pptx.layout`. */
+  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.
+ *
+ * **Published for consumers, and reached from one place inside `src/` on purpose.** Internally
+ * 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
+ * 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)
+ */
+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;
+/**
+ * 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
+ * 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
+ * `(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
+ * stating a value and the wrong one for a pass whose whole job is to degrade quietly. Those
+ * sites keep the division; nothing else may.
+ */
+declare function emuToPoints(emu: number): number;
+/**
+ * EMU → whole pixels at a stated DPI.
+ *
+ * **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.
+ */
+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.
+ *
+ * One object rather than a positional prefix because the prefix was not actually shared: `slide`
+ * sat in position 3 for two of the nine renderers and was absent from the other seven, and
+ * `renderImageObject` took six adjacent `number` parameters that no type could tell apart.
+ * Transposing `cx` and `cy` there compiled, shipped, and produced a stretched picture that
+ * nothing outside a rendered slide would have flagged. Named fields make that transposition
+ * impossible to write.
+ *
+ * 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 RenderContext {
+  /** The slide object being emitted. */
+  obj: SlideObject;
+  /**
+   * 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
+   * 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.
+   *
+   * 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. */
+  slide: PresSlideInternal | SlideLayoutInternal | SlideMasterInternal;
+  /** The resolved box in EMU: normalized for negative extents, then overridden by a placeholder. */
+  frame: {
+    x: number;
+    y: number;
+    cx: number;
+    cy: number;
+  };
+  /** The layout placeholder this object inherits from, or `null`. */
+  placeholder: SlideObject | null;
+  /** `<a:xfrm>` placement attributes (`flipH`, `flipV`, `rot`); attribute order is byte-significant. */
+  locationAttrs: XmlAttrs;
+  /**
+   * The object's options, already normalized by the dispatch. Read these rather than
+   * re-narrowing `obj.options`: each renderer has exactly one call site, and a contract stated
+   * there beats a defensive re-assignment in every callee.
+   */
+  itemOpts: ObjectOptionsInternal;
+}
+/**
+ * The `SlideObjectType` members that a renderer emits a shape for.
+ *
+ * Not every member is one. `group` recurses back into the walk and owns the frame and bounds
+ * logic that belongs to the dispatch, so it stays there; `notes`, `tablecell`, `hyperlink` and
+ * `online` are not shapes at all and emit nothing. Those five are spelled out in the dispatch
+ * beside this union's members, which is what makes a new enum member fail to compile until
+ * someone says which kind it is.
+ */
+type RenderedObjectType = SlideObjectType.chart | SlideObjectType.connector | SlideObjectType.image | SlideObjectType.media | SlideObjectType.model3d | SlideObjectType.oleObject | SlideObjectType.placeholder | SlideObjectType.table | SlideObjectType.text | SlideObjectType.zoom;
+/** 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
+ * looks like, supplied to it from outside.
+ *
+ * It has to come from outside. A named import inside a reachable function body is retained
+ * unconditionally, so a `switch` that calls `renderChartObject` links the chart emitter into every
+ * program that writes a slide, text-only ones included; a table built in the dispatch module would
+ * import the same ten names and change nothing. Passed down the write path alongside the deck
+ * state rather than registered into a module-level map: a mutable global populated at import time
+ * is how the same input came to produce different bytes once already (see the chart-part-id
+ * counter in `package/assemble.ts`), and it would also stop two decks built from different sets of
+ * families in one process from each getting their own.
+ *
+ * `Partial` because a caller may legitimately supply fewer than ten. An object whose family is
+ * 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;
+  readonly contentType: string;
+}
+/**
+ * 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
+ * is a fact about the bytes already shipped, not a style choice.
+ */
+interface ContentTypeOverride {
+  readonly partName: string;
+  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. */
+type PartTarget = PresSlideInternal | SlideLayoutInternal | SlideMasterInternal;
+/**
+ * One construct family's contribution to the package.
+ *
+ * Every hook is optional and every hook is called at one fixed point in the emission order, which
+ * is what keeps zip part order and `[Content_Types].xml` byte-identical no matter which families a
+ * program links.
+ */
+interface PartContributor {
+  /**
+   * Rank among contributors that write into the same slot. Fixed here, with the family, rather
+   * than taken from the order a caller happens to list contributors in: the list is a tier's
+   * business, and the same deck has to come out byte-identical from every tier that can write it.
+   * Spaced by ten so a family can be slotted between two others without renumbering.
+   */
+  readonly order: number;
+  /** Parts this family writes into the package. */
+  readonly parts?: ContributedParts;
+  /** Content-type entries this family's parts need to resolve. */
+  readonly contentTypes?: ContributedContentTypes;
+}
+/** Where a family's parts go into the zip. Order within each hook is the order they are added. */
+interface ContributedParts {
+  /** Written right after slide `slideNumber`'s own part and its rels, inside the slide loop. */
+  readonly withEachSlide?: (slide: PresSlideInternal, slideNumber: number, zip: ZipWriter) => void;
+  /** 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 —
+   * 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;
+}
+/**
+ * Which `[Content_Types].xml` entries a family needs. Each hook names the slot its entries land
+ * in; see {@link ContentTypeContributions} for where those slots sit in the emitted order.
+ */
+interface ContributedContentTypes {
+  readonly defaults?: (pres: PresentationPropsInternal) => ContentTypeDefault[];
+  readonly presentation?: (pres: PresentationPropsInternal) => ContentTypeOverride[];
+  readonly perSlide?: (slide: PresSlideInternal, slideNumber: number) => ContentTypeOverride[];
+  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;
+  addSlide: (layout: SlideLayoutInternal | null) => PresSlideInternal;
+  getSlide: (slideNum: number) => PresSlideInternal | undefined;
+  getSections: () => SectionInternalProps[];
+  _name: string;
+  _presLayout: PresLayout;
+  _rels: SlideRel[];
+  _relsChart: SlideRelChart[];
+  _relsMedia: SlideRelMedia[];
+  _rId: number;
+  _slideId: number;
+  _slideLayout: SlideLayoutInternal | null;
+  _slideNum: number;
+  _slideNumberProps: SlideNumberProps | null;
+  _slideObjects: SlideObject[];
+  _comments: SlideComment[];
+  _newAutoPagedSlides: PresSlideInternal[];
+  _animations: AnimationProps[];
+  /**
+   * The child-descriptor authors this presentation was composed with, for the group family: a
+   * group's children resolve through the same table a slide master's `objects` do, so a group can
+   * hold exactly the kinds this presentation can author.
+   */
+  readonly _childAuthors: ChildAuthors;
+  /**
+   * 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
+   * name of the family it needs, rather than `undefined is not a function`.
+   */
+  addAnimation: Slide['addAnimation'];
+  addChart: Slide['addChart'];
+  addComment: Slide['addComment'];
+  addConnector: Slide['addConnector'];
+  addGroup: Slide['addGroup'];
+  addImage: Slide['addImage'];
+  addMedia: Slide['addMedia'];
+  addModel3d: Slide['addModel3d'];
+  addNotes: Slide['addNotes'];
+  addOleObject: Slide['addOleObject'];
+  addSectionZoom: Slide['addSectionZoom'];
+  addShape: Slide['addShape'];
+  addSlideZoom: Slide['addSlideZoom'];
+  addSummaryZoom: Slide['addSummaryZoom'];
+  addTable: Slide['addTable'];
+  addText: Slide['addText'];
+  groupObjects: Slide['groupObjects'];
+  constructor(params: {
+    addSlide: (layout: SlideLayoutInternal | null) => PresSlideInternal;
+    getSlide: (slideNum: number) => PresSlideInternal | undefined;
+    getSections?: () => SectionInternalProps[];
+    presLayout: PresLayout;
+    setSlideNum: (value: SlideNumberProps) => void;
+    slideId: number;
+    slideRId: number;
+    slideNumber: number;
+    slideLayout?: SlideLayoutInternal;
+    authors: SlideAuthors;
+    childAuthors: ChildAuthors;
+  });
+  /**
+   * Background color or image
+   * @type {BackgroundProps}
+   * @example solid color `background: { color:'FF0000' }`
+   * @example color+trans `background: { color:'FF0000', transparency:0.5 }`
+   * @example base64 `background: { data:'image/png;base64,ABC[...]123' }`
+   * @example url `background: { path:'https://some.url/image.jpg'}`
+   */
+  private _background?;
+  set background(props: BackgroundOption | undefined);
+  get background(): BackgroundOption | undefined;
+  /**
+   * Default font color
+   * @type {HexColor}
+   */
+  private _color?;
+  set color(value: HexColor);
+  get color(): HexColor | undefined;
+  /**
+   * @type {boolean}
+   */
+  private _hidden;
+  set hidden(value: boolean);
+  get hidden(): boolean;
+  /**
+   * Slide-show transition (`p:transition`) played when advancing to this slide.
+   * @type {TransitionProps}
+   */
+  private _transition?;
+  set transition(value: TransitionProps | undefined);
+  get transition(): TransitionProps | undefined;
+  /**
+   * @type {SlideNumberProps}
+   */
+  set slideNumber(value: SlideNumberProps);
+  get slideNumber(): SlideNumberProps | undefined;
+  /**
+   * Every continuation slide this slide's tables have spilled onto, in call order, each once.
+   *
+   * Across calls, not per call: a slide can carry more than one `addTable`, and each auto-paging
+   * one appends whatever it spilled onto. The list was assigned rather than appended, so a second
+   * table erased the first table's report while its slides stayed in the deck. "Spilled onto"
+   * rather than "created" because a later table lands on the earlier one's continuations instead
+   * of making its own, and those are reported once.
+   */
+  get newAutoPagedSlides(): Slide[];
+  /**
+   * The objects authored on this slide so far, bottom-to-top in z-order.
+   *
+   * Built fresh on every access rather than cached: the underlying list is mutated in place by
+   * `addGroup`/`groupObjects` as well as appended to, so a cache would have to be invalidated from
+   * every authoring path and would go stale the first time one was added without remembering.
+   * Building it costs a walk of a list a slide-sized deck keeps in the dozens.
+   */
+  get objects(): readonly SlideObjectInfo[];
+  /** Slide width in inches (resolved from the active presentation layout). */
+  get width(): number;
+  /** 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.
+ */
+type FamilyName = 'animations' | 'chart' | 'comments' | 'connector' | 'group' | 'image' | 'measure' | 'media' | 'model3d' | 'notes' | 'ole' | 'shape' | 'table' | 'text' | 'zoom';
+/** The `Slide` methods that come from a family rather than from the slide itself. */
+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
+ * 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;
+/**
+ * The slide methods a list of families supplies between them, each optional because a program
+ * composed without a family does not have its methods.
+ *
+ * Derived from {@link Slide} rather than restated, so an author cannot drift from the method it
+ * backs. `addChart` is written out because it is the one overloaded member: `Parameters` reads the
+ * last overload only, which would let a family that handles just the combo form type-check while
+ * the public method promises both.
+ */
+type SlideAuthors = { [M in Exclude<SlideAuthorMethod, 'addChart'>]?: Author<M>; } & {
+  addChart?: (slide: SlideBuilder, arg1: OptsChartData[] | ChartMulti[], arg2?: ChartOpts & {
+    type?: CHART_NAME;
+  }) => void;
+};
+/**
+ * What a presentation-level author is given: the deck it is authoring onto, and the write-side
+ * font metrics, which the presentation keeps private and a family cannot reach through the class.
+ */
+interface PresentationAuthorContext {
+  readonly pres: PresentationCore;
+  readonly fontMetrics: FontMetricsRegistry;
+}
+/**
+ * The presentation methods that come from a family rather than from the presentation itself.
+ *
+ * Written out with their signatures rather than derived from the class, because the class is what
+ * they are being lifted out of. Each returns its own answer, so unlike a slide author there is
+ * nothing generic to apply on the way back.
+ */
+interface PresentationAuthors {
+  measureText?: (ctx: PresentationAuthorContext, text: string | TextProps[], opts: MeasureTextOptions) => TextMeasurement;
+  overflowsBox?: (ctx: PresentationAuthorContext, text: string | TextProps[], opts: OverflowBoxOptions) => boolean;
+  tableLayout?: (ctx: PresentationAuthorContext, rows: TableRow[], opts: TableProps) => TableLayoutResult;
+  tableToSlides?: (ctx: PresentationAuthorContext, eleId: string, options: TableToSlidesProps) => void;
+}
+/**
+ * The key-tagged child descriptors a slide master's `objects` and a group's `children` are written
+ * with (`{ text: … }`, `{ rect: … }`, …). `placeholder` is not one: it is master-specific and needs
+ * the object's index, so `createSlideMaster` handles it itself.
+ */
+type ChildDescriptorKey = 'chart' | 'image' | 'line' | 'rect' | 'roundRect' | 'shape' | 'text';
+/** The payload behind one descriptor key, taken from the descriptor union so it cannot drift. */
+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
+ * {@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.
+ */
+type ChildAuthors = { [K in ChildDescriptorKey]?: (target: PresSlideInternal, child: ChildDescriptor<K>) => void; };
+/**
+ * What a family contributes to an *extraction* -- the second emission path, which serializes a
+ * slide for injection into a deck read from bytes rather than for a package of its own.
+ *
+ * One slot so far. Extraction re-emits a slide's shapes through the same renderer table a write
+ * uses, so a family with only shapes to draw needs nothing here; charts are the exception because
+ * an extracted chart carries its part XML and its workbook alongside the slide body.
+ */
+interface SlideExtractors {
+  readonly charts?: (slide: PresSlideInternal) => ExtractedSlide['charts'];
+}
+/** One construct family. Every slot is optional; a family fills the ones it has something to say about. */
+interface ConstructFamily {
+  /** This family's name, for the diagnostic a program without it raises. */
+  readonly name: FamilyName;
+  /** Methods this family adds to a slide. */
+  readonly authors?: SlideAuthors;
+  /** Child descriptors this family recognises inside a slide master or a group. */
+  readonly children?: ChildAuthors;
+  /** The shape kinds this family emits XML for, keyed by `SlideObjectType`. */
+  readonly renderers?: RendererTable;
+  /** The parts this family puts in the written package. */
+  readonly parts?: PartContributor;
+  /** Methods this family adds to the presentation itself. */
+  readonly presentationAuthors?: PresentationAuthors;
+  /** What this family adds to an extracted slide, beyond the shape XML its renderer emits. */
+  readonly extract?: SlideExtractors;
+}
+/**
+ * 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
+ * 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 {
+  #private;
+  /**
+   * 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)
+   * @throws {InvalidOptionError} when the value is not an integer `xsd:int` can hold
+   */
+  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;
+  /** the slide master the deck's master part is written from; not a `Slide`, so not handed out */
+  private readonly _masterSlide;
+  /** 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, families: readonly ConstructFamily[]);
+  /**
+   * Provides an API for `addTableDefinition` to create slides as needed for auto-paging
+   * @param layout - the layout of the slide the table is paged from
+   * @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 `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
+   * path consumes each descriptor to reserve the parts and rebuild the rel graph.
+   */
+  extractSlides: (opts?: {
+    onMediaError?: 'throw' | 'placeholder';
+  }) => Promise<ExtractedSlides>;
+  /**
+   * One of this presentation's family-supplied methods, or the failure that names the family it
+   * would have come from. The methods that call it stay on the class because their signatures are
+   * the public contract; what they reach is what a family owns.
+   *
+   * `protected` for the browser entry, whose `tableToSlides` is one of these and is declared on
+   * the subclass so that a Node build never links the DOM reader.
+   */
+  protected familyAuthor<M extends keyof PresentationAuthors>(method: M): BoundPresentationAuthor<NonNullable<PresentationAuthors[M]>>;
+  /**
+   * Register a font's metrics so `fit:'shrink'` and `fit:'resize'` text is measured at
+   * export time: `'shrink'` bakes a real `fontScale` and `'resize'` a real box height, so
+   * the text renders fitted in headless renderers and on plain file-open, with no manual
+   * edit/resize.
+   *
+   * Without registered metrics, both write the bare flag (`<a:normAutofit/>` or
+   * `<a:spAutoFit/>`) 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 `pptx-ts/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. A string is always a path or URL here; base64 text is `embedFont`'s `data`, not this.
+   * @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 (bare or a
+   *   whole `data:` URL), in lieu of `path`. Unlike `registerFontMetrics`, a string here is never a 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/gen/slide/objects/text.d.ts
+/**
+ * Render a `text` / `placeholder` slide object to its `<p:sp>` XML.
+ */
+declare function renderTextObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/slide/objects/image.d.ts
+/**
+ * Render an `image` slide object to its `<p:pic>` XML (sizing/crop, rounding, hyperlink, shadow).
+ */
+declare function renderImageObject(ctx: RenderContext): string;
+//#endregion
+//#region src/families/core.d.ts
+/**
+ * ts-pptx: the construct families every presentation carries
+ *
+ * The core tier. A composed presentation gets these whether it asks for them or not, so
+ * `createPresentation()` with no families still authors text, shapes, images, groups and speaker
+ * notes -- a deck, rather than a slide-shaped hole.
+ *
+ * The line is a judgement rather than a measurement: these five are what "a slide" means to most
+ * callers, they are cheap, and a surface that made someone compose `text` before it could write a
+ * word would be a worse default than one that costs a few kilobytes more. A family is core when
+ * leaving it out would make the result something other than a deck; everything else is asked for.
+ */
+/** Every family a composed presentation carries without being asked. */
+declare const CORE_CONSTRUCT_FAMILIES: readonly [{
+  name: "text";
+  authors: {
+    addText(slide: SlideBuilder, text: string | number | TextProps[], options: TextPropsOptions | undefined): void;
+  };
+  children: {
+    text(target: PresSlideInternal, child: {
+      text: string | number | TextProps[];
+      options?: TextPropsOptions;
+    }): void;
+  };
+  renderers: {
+    placeholder: typeof renderTextObject;
+    text: typeof renderTextObject;
+  };
+}, {
+  name: "shape";
+  authors: {
+    addShape(slide: SlideBuilder, shapeName: SHAPE_NAME, options: ShapeProps | undefined): void;
+  };
+  children: {
+    line(target: PresSlideInternal, child: ShapeProps): void;
+    rect(target: PresSlideInternal, child: ShapeProps): void;
+    roundRect(target: PresSlideInternal, child: ShapeProps): void;
+    shape(target: PresSlideInternal, child: {
+      type: SHAPE_NAME;
+      options?: ShapeProps;
+    }): void;
+  };
+}, {
+  name: "image";
+  authors: {
+    addImage(slide: SlideBuilder, options: ImageProps): void;
+  };
+  children: {
+    image(target: PresSlideInternal, child: ImageProps): void;
+  };
+  renderers: {
+    image: typeof renderImageObject;
+  };
+}, {
+  name: "group";
+  authors: {
+    addGroup(slide: SlideBuilder, children: GroupChildProps[], options: GroupProps | undefined): void;
+    groupObjects(slide: SlideBuilder, objectNames: string[], options: GroupProps | undefined): void;
+  };
+}, {
+  name: "notes";
+  authors: {
+    addNotes(slide: SlideBuilder, notes: string | NotesProps[] | NotesProps): void;
+  };
+  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. */
+type Chained<F, S> = F extends ((...args: infer A) => unknown) ? (...args: A) => S : never;
+/**
+ * The overloaded methods, re-pointed by hand.
+ *
+ * `Chained` reads one call signature, and TypeScript hands a conditional type the *last* overload,
+ * so `addChart` would come out taking a combo array and nothing else. There is one such method, and
+ * writing it out is cheaper than a generic that unrolls an arbitrary overload list.
+ */
+interface ChainedOverloads<S> {
+  addChart: {
+    (data: OptsChartData[], options: ChartOpts & {
+      type: CHART_NAME;
+    }): S;
+    (charts: ChartMulti[], options?: ChartOpts): S;
+  };
+}
+/** The slide methods a family list supplies between them. */
+type SlideMethodsOf<Fs extends readonly ConstructFamily[]> = Extract<keyof UnionToIntersection<Extract<Fs[number], {
+  authors: object;
+}>['authors']>, SlideAuthorMethod>;
+/** The presentation methods a family list supplies between them. */
+type PresentationMethodsOf<Fs extends readonly ConstructFamily[]> = Extract<keyof UnionToIntersection<Extract<Fs[number], {
+  presentationAuthors: object;
+}>['presentationAuthors']>, keyof PresentationAuthors>;
+/**
+ * A slide from a composed presentation: everything a slide is, plus exactly the authoring methods
+ * `M` names.
+ *
+ * Parameterized by method name rather than by the family list, so what an editor shows a caller is
+ * the list of calls this slide takes. The methods answer this same type, so a chain cannot widen
+ * back to the full surface and offer a call the deck was not composed for.
+ */
+type ComposedSlide<M extends SlideAuthorMethod> = Omit<Slide, SlideAuthorMethod> & { [K in M]: K extends keyof ChainedOverloads<unknown> ? ChainedOverloads<ComposedSlide<M>>[K] : Chained<Slide[K], ComposedSlide<M>>; };
+/** Every presentation method a family can supply, as the presentation exposes it. */
+type PresentationFamilyMethods = { [K in keyof PresentationAuthors]-?: BoundPresentationAuthor<NonNullable<PresentationAuthors[K]>>; };
+/**
+ * A composed presentation: the whole deck-level API, with `addSlide` answering a slide that carries
+ * only `M`, and only the presentation-level methods `P` names.
+ */
+type ComposedPresentation<M extends SlideAuthorMethod, P extends keyof PresentationAuthors> = Omit<PresentationCore, 'addSlide' | keyof PresentationAuthors> & Pick<PresentationFamilyMethods, P> & {
+  addSlide: (options?: AddSlideProps) => ComposedSlide<M>;
+};
+/** What `createPresentation` takes: the families this deck needs beyond the core tier. */
+interface ComposeOptions<Fs extends readonly ConstructFamily[]> {
+  /** Construct families to compose in, from `pptx-ts/families`. Listing one twice is harmless. */
+  use?: Fs;
+}
+/** What a family list composes to once the core tier is in front of it. */
+type Composed<Fs extends readonly ConstructFamily[]> = ComposedPresentation<SlideMethodsOf<[...typeof CORE_CONSTRUCT_FAMILIES, ...Fs]>, PresentationMethodsOf<[...typeof CORE_CONSTRUCT_FAMILIES, ...Fs]>>;
+//#endregion
+export { pixelsToEmu as A, StandardLayoutName as C, emuToPoints as D, emuToPixels as E, ptToHundredths as M, inchesToEmu as O, StandardLayout as S, emuToInches as T, HUNDREDTHS_PER_POINT as _, renderImageObject as a, PERCENT_SCALE as b, ConstructFamily as c, PartContributor as d, RenderContext as f, FIXED_PCT_PER_PERCENT as g, Emu as h, ComposedSlide as i, pointsToEmu as j, percentToEmu as k, PresentationAuthorContext as l, DEFAULT_PX_PER_INCH as m, Composed as n, renderTextObject as o, ANGLE_UNITS_PER_DEGREE as p, ComposedPresentation as r, PresentationCore as s, ComposeOptions as t, SlideBuilder as u, MAX_COORDINATE_EMU as v, coordToEmu as w, STANDARD_LAYOUTS as x, MIN_COORDINATE_EMU as y };
+//# sourceMappingURL=entry-compose-DCnvBZz2.d.ts.map