pptx-ts 0.0.1

package/dist/script.d.ts

@@ -0,0 +1,581 @@
+import { h as Presentation } from "./presentation-types-DP_8jog7.js";
+import { a as TsPptxError, d as InvalidOptionErrorCode, f as MediaErrorCode, h as UnsupportedFeatureErrorCode, i as PackageReadError, l as ErrorCode, m as TsPptxCode, n as InvalidOptionError, o as TsPptxErrorOptions, p as PackageReadErrorCode, r as MediaError, s as UnsupportedFeatureError, t as InternalError, u as InternalErrorCode } from "./errors-PflMPWBn.js";
+//#region src/script/fidelity.d.ts
+/**
+ * Fidelity notes — the declared, machine-checkable list of what a deck loses on the way
+ * to a script.
+ *
+ * A converter that warns about losses to a log has no way to be tested: the warnings are
+ * prose, nothing consumes them, and a missing one looks exactly like a clean run. Making
+ * the notes part of the IR inverts that. A note says "field X of shape Y will not come
+ * back", so a round-trip check can exclude precisely those fields and treat **any**
+ * remaining difference as a defect. Both directions then have teeth:
+ *
+ * - an *undeclared* loss fails the round-trip, because nothing excluded it;
+ * - a *declared* loss that actually survives is a stale note, and the check can say so.
+ *
+ * That is the whole reason notes are first-class rather than a side channel. It also
+ * means {@link FidelityNote.construct} is an identifier, not a sentence: it has to be
+ * matchable against a field path, so it is a stable dotted key and the human explanation
+ * lives in {@link FidelityNote.detail}.
+ */
+/** What happened to the construct. */
+type Disposition =
+/** Gone: nothing in the output carries it. */
+'dropped' |
+/**
+ * Present but structurally simplified — a value survives while the structure around
+ * it does not (threaded comment replies flattened into separate comments, a per-script
+ * font scheme reduced to latin, a placeholder demoted to a plain shape).
+ */
+'flattened' |
+/**
+ * Present and structurally intact, but not the same value — a re-encoding that a
+ * viewer may or may not be able to tell apart (a modern transition mapped to the
+ * nearest named one, a chart rebuilt from cached points rather than its workbook).
+ */
+'approximated';
+/**
+ * Which side of the library is responsible. Recording this is what makes the notes
+ * actionable rather than merely honest: `unread` and `unwritable` are bugs waiting to be
+ * fixed in a specific subsystem, while `unsupported` is a property of OOXML or of the
+ * chosen output tier and will not be fixed by more converter work.
+ */
+type Cause =
+/** The read API exposes no accessor for it, so the converter never saw it. */
+'unread' |
+/** Read fine, but the write API has no option that expresses it. */
+'unwritable' |
+/** Both sides can handle it; this output tier structurally cannot carry it. */
+'unsupported';
+/** One declared loss. */
+interface FidelityNote {
+  /** 1-based source slide, or `null` for a deck-level loss. */
+  slideNumber: number | null;
+  /** Source shape name (`p:cNvPr/@name`), or `null` when the loss is not shape-scoped. */
+  shapeName: string | null;
+  /**
+   * Stable dotted identifier for the lost construct — `line.width`, `text.tabStops`,
+   * `chart.workbook`. Matched mechanically by the round-trip check, so it must name a
+   * field path rather than describe one. Reuse an existing key for the same construct
+   * instead of coining a synonym.
+   */
+  construct: string;
+  disposition: Disposition;
+  cause: Cause;
+  /** Why, in a sentence, for a human reading the emitted script's header. */
+  detail: string;
+}
+/**
+ * Namespace for a loss recorded against a shape on a **slide layout** rather than on a slide,
+ * prepended to the construct by {@link layoutShapeScope}.
+ *
+ * The chrome mapper reuses the slide shape mapper wholesale — a rectangle on a layout is
+ * transcribed by the same code that transcribes one on a slide, which is what keeps the two
+ * from drifting. That sharing brings the slide vocabulary with it: a themed outline on a
+ * layout records `line.width` exactly as a slide's would. Left unmarked, those notes would be
+ * wrong twice over. A template-anchored script would report them, though it never rebuilds a
+ * layout and loses nothing; and the round trip would let one excuse a *slide* difference,
+ * because a layout note carries no slide number and a name like "Rectangle 7" repeats between
+ * the tiers. The prefix keeps the shared vocabulary and states which tier it is about.
+ *
+ * `layout.` rather than `master.`, which is how the other chrome constructs are spelled: those
+ * are named after the `defineSlideMaster` call that authors them, while these name the source
+ * tier the loss is on — and a master's own decoration is not re-authored at all, so a note
+ * under this prefix is always about a layout.
+ */
+declare const LAYOUT_NOTE_PREFIX = "layout.";
+//#endregion
+//#region src/script/ir.d.ts
+/**
+ * A reference to bytes held in {@link DeckIr.assets}, standing where a write-API option
+ * wants image/media data. Printed as a `path` or an inline `data:` literal depending on
+ * the print options — an IR-level decision would bake one choice into the IR and force a
+ * re-read to change it.
+ *
+ * The `$asset` sigil is deliberate: no write-API option object has a `$`-prefixed key,
+ * so a value carrying one is unambiguously a reference rather than user data.
+ */
+interface AssetRef {
+  $asset: string;
+}
+/** `true` when `value` is an {@link AssetRef} rather than a plain IR object. */
+declare function isAssetRef(value: unknown): value is AssetRef;
+/**
+ * Any value an IR may hold. Deliberately narrower than `unknown`: it excludes `undefined`
+ * so that "absent" has exactly one spelling (a missing key), which is what makes two IRs
+ * comparable field-by-field in a round-trip diff. `readModelToIr` never writes an
+ * `undefined` value.
+ */
+type IrValue = null | boolean | number | string | AssetRef | IrValue[] | {
+  [key: string]: IrValue;
+};
+/** Bytes referenced by an {@link AssetRef}, plus what a printer needs to name and type them. */
+interface AssetIr {
+  /** Stable key an {@link AssetRef} resolves against; also the emitted filename. */
+  name: string;
+  /** MIME type from the source package's content types, for an inline `data:` URI. */
+  contentType: string;
+  bytes: Uint8Array;
+}
+/**
+ * One write-API call on a slide, in the order it must be made. `method` names a real
+ * method on the authored slide and `args` are its positional arguments — so a printer is
+ * a formatter, and `readModelToIr` owns every semantic choice.
+ *
+ * Ordering is z-order: OOXML paints a slide's shape tree front-to-back in document order,
+ * and so does the write path, so preserving call order preserves overlap.
+ */
+interface CallIr {
+  method: 'addText' | 'addShape' | 'addImage' | 'addTable' | 'addChart' | 'addConnector' | 'addGroup' | 'addNotes';
+  args: IrValue[];
+  /**
+   * The source shape's name (`p:cNvPr/@name`), when it had one. Not an argument —
+   * carried so a printer can comment the call and a fidelity note can point at it.
+   */
+  sourceName?: string;
+}
+/**
+ * How a slide's content gets into the output deck.
+ *
+ * `authored` — every shape is transcribed into {@link CallIr}s and regenerated through
+ * the write API. This is the goal: the emitted source is editable, and a reader can see
+ * what the deck contains.
+ *
+ * `carried` — the slide holds at least one construct the write API cannot express at all
+ * (`chartEx` is the clear case: a full reader, no emitter), so transcribing it would
+ * silently produce a different deck. A printer that *can* copy the slide from the source
+ * package should do so: fidelity is higher than transcription, though the emitted source then
+ * says nothing about what is on the slide, which is a real cost and always carries a
+ * {@link FidelityNote}.
+ *
+ * This is a recommendation, not an erasure. {@link SlideIr.calls} is populated either way, so
+ * a printer with no source package to copy from prints them and loses only the unwritable
+ * construct rather than the whole slide.
+ */
+type SlideSource = 'authored' | 'carried';
+/**
+ * A slide's background, already reduced to what the write API's `background` accepts.
+ *
+ * `data` rather than `image`, because `BackgroundProps` is `DataOrPathProps & ShapeFillProps`
+ * and `data` is the key it actually reads — an `image` key would print, typecheck against
+ * `IrValue`, and be ignored at run time.
+ */
+interface BackgroundIr {
+  color?: string;
+  transparency?: number;
+  data?: AssetRef;
+}
+/**
+ * A transition's sound (`p:sndAc`), reduced to what `TransitionSoundProps` accepts.
+ *
+ * `data` rather than `path`, for the same reason a background image uses `data`: the bytes
+ * are the thing the IR carries, and a path would bind the script to a file layout the IR
+ * knows nothing about. The stop-previous form has no bytes at all — it silences a sound
+ * still playing from the previous slide — so it is the one shape here with no {@link AssetRef}.
+ */
+interface TransitionSoundIr {
+  /** Bytes of the embedded WAV, for a start sound. Absent for {@link stopPrevious}. */
+  data?: AssetRef;
+  /** `p:snd@name`, the display name PowerPoint shows for the sound. */
+  name?: string;
+  /** `p:stSnd@loop` — repeat until the next sound starts. Omitted when false, its default. */
+  loop?: boolean;
+  /** The `p:endSnd` form: stop the previous slide's sound rather than start one. */
+  stopPrevious?: boolean;
+}
+/**
+ * A slide's show transition (`p:transition`), as a literal `TransitionProps`.
+ *
+ * Only the base ECMA-376 transitions reach this type. The read model reports
+ * {@link TransitionInfo.type} as an *open string*, because PowerPoint's modern effects
+ * (Morph, Vortex, …) live in the `p14`/`p15`/`p159` namespaces and it decodes those too —
+ * but the write path names 21 base ones and nothing else, so `from-read/transition.ts`
+ * filters against that vocabulary and notes what it drops. Anything that survives is a name
+ * the write API's own `TransitionType` union accepts, which is what keeps a printed script
+ * compiling.
+ */
+interface TransitionIr {
+  /** The transition-type element's local name, guaranteed to be a writable one. */
+  type: string;
+  /** `p:transition@spd`. Always present — see `from-read/transition.ts` for why it is not omitted. */
+  speed: 'slow' | 'med' | 'fast';
+  /** `p14:dur` in milliseconds, when the source carried an exact duration. */
+  durationMs?: number;
+  /** `advClick`. Omitted when true, its default. */
+  advanceOnClick?: boolean;
+  /** `advTm` in milliseconds, when the slide auto-advances. */
+  advanceAfterMs?: number;
+  /** Type-specific attributes on the type element (`{ dir: 'd' }`, `{ spokes: '2' }`, …). */
+  variant?: {
+    [key: string]: string;
+  };
+  sound?: TransitionSoundIr;
+}
+/**
+ * The layout a slide should be bound to in the destination deck, identified two ways
+ * because neither alone is sufficient.
+ *
+ * The **name** is the portable identity: it is what lets a script built from one deck be
+ * re-pointed at a different template whose layouts happen to be named the same, and it is
+ * what a reader recognises. But `p:cSld@name` is not unique — a deck with several masters
+ * routinely carries several "Title and Content" layouts, and binding by an ambiguous name
+ * is an error, not a coin flip. The **index** into the deck's layout gallery always
+ * resolves, so it is the fallback, and {@link nameIsUnique} says which to trust.
+ */
+interface SlideLayoutIr {
+  /** `p:cSld@name` of the source layout (`''` when the layout is unnamed). */
+  name: string;
+  /** Zero-based position in the source deck's layout gallery, in master-then-layout order. */
+  index: number;
+  /** `false` when another layout in that gallery shares {@link name}. */
+  nameIsUnique: boolean;
+}
+/** One slide of the deck. */
+interface SlideIr {
+  /** 1-based index in the source deck; the identity a {@link FidelityNote} points at. */
+  number: number;
+  source: SlideSource;
+  /** The layout to bind to, or `null` when the source slide resolves none. */
+  layout: SlideLayoutIr | null;
+  /** `p:sld/@show="0"` — a slide hidden from presentation but present in the deck. */
+  hidden: boolean;
+  /** `p:cSld/@name`, when the source slide had one. */
+  name?: string;
+  background?: BackgroundIr;
+  /** Speaker notes as plain text. Notes-slide geometry and placeholders do not survive. */
+  notesText?: string;
+  /**
+   * The show transition, when the source has one the write API can name. Slide-scoped
+   * rather than a {@link CallIr} because the write API models it as a property assignment
+   * on the slide, not a method — the IR's `method` union names real methods only.
+   */
+  transition?: TransitionIr;
+  /**
+   * Write-API calls in z-order.
+   *
+   * Populated for every slide, **including a `carried` one**. A printer that can copy the
+   * source slide ignores these; one that cannot — a standalone output has no source package
+   * to copy from — prints them and is left with only the unwritable construct missing rather
+   * than the whole slide. Marking a slide `carried` is a recommendation, not an erasure.
+   */
+  calls: CallIr[];
+}
+/**
+ * A deck's theme, reduced to what `ThemeProps` accepts — the 12 `a:clrScheme` slots and the
+ * major/minor Latin, East-Asian and complex-script faces.
+ *
+ * What is *not* here is the point of the tier split. `a:fmtScheme` — the three fill, three
+ * line and three effect style lists a shape's `p:style` references — has no write-API
+ * counterpart and no read accessor, so a theme cannot be reproduced, only approximated.
+ */
+interface ThemeIr {
+  headFontFace?: string;
+  bodyFontFace?: string;
+  headFontFaceEA?: string;
+  bodyFontFaceEA?: string;
+  headFontFaceCS?: string;
+  bodyFontFaceCS?: string;
+  /** The 12 `a:clrScheme` slots as bare 6-digit hex, omitting any the theme leaves unset. */
+  colorScheme?: {
+    [slot: string]: string;
+  };
+}
+/**
+ * One source slide layout approximated as a `defineSlideMaster` call.
+ *
+ * The naming is the write API's, not OOXML's: `defineSlideMaster` creates a *layout* under
+ * the single shared master, which is exactly the granularity a source layout needs. A source
+ * deck's masters have no counterpart at all — hence {@link ChromeIr}'s multi-master note.
+ */
+interface MasterIr {
+  /**
+   * Gallery position of the source layout, matching {@link SlideLayoutIr.index}, so a slide
+   * finds the master it should bind to without re-deriving a name.
+   */
+  layoutIndex: number;
+  /**
+   * A `SlideMasterProps` literal. `props.title` is made unique across the deck, because it
+   * doubles as the key `addSlide({ masterTitle })` matches against and source layout names
+   * are not unique.
+   */
+  props: {
+    [key: string]: IrValue;
+  };
+}
+/**
+ * The deck's shared chrome, approximated for an output that has no template to inherit it
+ * from. A template-anchored printer ignores this entirely — the source deck *is* the chrome.
+ */
+interface ChromeIr {
+  theme: ThemeIr;
+  /** One entry per source layout, in gallery order. */
+  masters: MasterIr[];
+}
+/** Deck-level properties, reduced to the five `docProps` fields the write API sets. */
+interface DeckPropsIr {
+  title?: string;
+  author?: string;
+  company?: string;
+  subject?: string;
+  revision?: string;
+}
+/**
+ * A whole deck, ready to print.
+ *
+ * `widthEmu`/`heightEmu` are raw EMU rather than inches because that is what the read
+ * model reports and what the write API's `Coord` accepts verbatim; converting here would
+ * introduce a rounding decision at the wrong layer.
+ */
+interface DeckIr {
+  slideSize: {
+    widthEmu: number;
+    heightEmu: number;
+  };
+  props: DeckPropsIr;
+  /**
+   * Theme and layouts, approximated. Only a standalone printer reads this; a
+   * template-anchored one gets all of it byte-identical from the source deck instead.
+   */
+  chrome: ChromeIr;
+  slides: SlideIr[];
+  assets: AssetIr[];
+  /**
+   * Every construct that did not survive into {@link slides} intact. This is a
+   * *contract*, not a log: a round-trip check excludes exactly these fields from its
+   * diff, so an unnoted difference is a bug and a note nothing else corroborates is a
+   * stale claim. See {@link FidelityNote}.
+   */
+  fidelity: FidelityNote[];
+}
+//#endregion
+//#region src/script/from-read/deck.d.ts
+/** Convert a loaded deck into its IR. */
+declare function readModelToIr(pres: Presentation): DeckIr;
+//#endregion
+//#region src/script/print/common.d.ts
+/** How image bytes reach the emitted script. */
+type AssetMode =
+/** Written beside the script and read at run time. Keeps the script readable. */
+'file' |
+/** Inlined as `data:` literals. One self-contained file, at roughly 4/3 the byte size. */
+'inline';
+interface PrintedScript {
+  /** The TypeScript module source. */
+  code: string;
+  /**
+   * Image bytes the script expects to find in its asset directory, keyed by filename.
+   * Empty when the print options asked for `'inline'`, since the bytes are then in
+   * {@link code}.
+   */
+  assets: Map<string, Uint8Array>;
+  /**
+   * The losses that apply to **this** output: the IR's own notes, minus any this tier
+   * rescues, plus the ones this tier causes. Reproduced as a comment block at the top of
+   * {@link code}, so the artifact carries its own caveats.
+   */
+  notes: FidelityNote[];
+}
+//#endregion
+//#region src/script/print/script.d.ts
+interface PrintScriptOptions {
+  /**
+   * Path the emitted script loads its template from, resolved against the script's own
+   * location. This is the **source deck unchanged** — `fromTemplate` strips its slides.
+   * @default './template.pptx'
+   */
+  templatePath?: string;
+  /** Path the emitted script writes to, resolved against the script's own location. @default './output.pptx' */
+  outputPath?: string;
+  /** Directory the emitted script reads image assets from, when {@link assets} is `'file'`. @default './assets' */
+  assetDir?: string;
+  /** @default 'file' */
+  assets?: AssetMode;
+  /**
+   * Import specifier the emitted script uses, with `/read` appended for the read half.
+   * Defaults to this package's own published name; override it to point a generated
+   * script at a local build or a fork.
+   * @default '@shbernal/ts-pptx'
+   */
+  packageName?: string;
+}
+/** Turn a deck IR into a runnable, template-anchored TypeScript module. */
+declare function printScript(ir: DeckIr, options?: PrintScriptOptions): PrintedScript;
+//#endregion
+//#region src/script/print/standalone.d.ts
+interface PrintStandaloneScriptOptions {
+  /** Path the emitted script writes to, resolved against the script's own location. @default './output.pptx' */
+  outputPath?: string;
+  /** Directory the emitted script reads image assets from, when {@link assets} is `'file'`. @default './assets' */
+  assetDir?: string;
+  /** @default 'file' */
+  assets?: AssetMode;
+  /**
+   * Import specifier the emitted script uses. Defaults to this package's own published
+   * name; override it to point a generated script at a local build or a fork.
+   * @default '@shbernal/ts-pptx'
+   */
+  packageName?: string;
+}
+/** Turn a deck IR into a runnable TypeScript module that needs no template. */
+declare function printStandaloneScript(ir: DeckIr, options?: PrintStandaloneScriptOptions): PrintedScript;
+//#endregion
+//#region src/script/verify/canonical.d.ts
+/** One write-API call, with the source shape name lifted out as an address rather than data. */
+interface CanonicalCall {
+  method: string;
+  /** `p:cNvPr/@name` of the shape this call came from, used to point a difference at it. */
+  shapeName: string | null;
+  /**
+   * Every `objectName` appearing anywhere inside {@link args}, which for `addGroup` is the
+   * group's children.
+   *
+   * A fidelity note about a group's child is scoped to that child's name, but the child is
+   * not a call of its own — it is an argument to the group's. Without this the note and the
+   * difference it predicted would carry different names and never match, and a declared loss
+   * would be reported as a defect.
+   */
+  containedNames: string[];
+  args: IrValue[];
+}
+interface CanonicalSlide {
+  number: number;
+  hidden: boolean;
+  /**
+   * The name of the layout this slide binds to, which is the only part of the binding that
+   * is portable — a gallery *index* shifts whenever the output's gallery differs from the
+   * source's, which it always does for a standalone output.
+   *
+   * Here because the binding is otherwise invisible: a printer that bound every slide to the
+   * wrong layout, or to none, would produce identical calls and compare clean. The layout
+   * governs theme and colour-map resolution, so that is not a cosmetic difference.
+   */
+  layoutName: string | null;
+  background: IrValue | null;
+  notesText: string | null;
+  /**
+   * The show transition, or `null`.
+   *
+   * Here for the same reason {@link layoutName} is: a printer that stopped emitting
+   * transitions altogether would produce identical *calls* and compare clean, so the
+   * projection has to carry the slide-level properties the write API sets by assignment
+   * rather than by method. It is compared structurally (key by key), not as one opaque
+   * value, so a note can declare the loss of a transition's *sound* without also excusing a
+   * wrong transition *type*.
+   */
+  transition: IrValue | null;
+  calls: CanonicalCall[];
+}
+/**
+ * The deck's chrome, reduced the same way its slides are.
+ *
+ * Included for one reason: without it the diff cannot see the standalone tier's whole job.
+ * That tier re-authors the theme and one master per source layout, and a projection that
+ * covers only slides would report a printer emitting *neither* as a clean round trip — the
+ * same shape of hole mutation testing found in `added` differences, one level up. A
+ * template-anchored output compares equal here by construction, which is the claim that tier
+ * makes and is worth checking rather than assuming.
+ */
+interface CanonicalChrome {
+  theme: IrValue;
+  /** Each master's `defineSlideMaster` props, in gallery order. */
+  masters: IrValue[];
+}
+interface CanonicalDeck {
+  slideSize: {
+    widthEmu: number;
+    heightEmu: number;
+  };
+  /** The `docProps` the write API can set. Absent from the projection, a printer that set none would compare clean. */
+  props: IrValue;
+  chrome: CanonicalChrome;
+  slides: CanonicalSlide[];
+}
+/** Reduce a deck IR to the comparable form. */
+declare function canonicalDeckIr(ir: DeckIr): CanonicalDeck;
+//#endregion
+//#region src/script/verify/diff.d.ts
+/**
+ * Which way a difference points.
+ *
+ * `lost` and `changed` are the ones the fidelity contract governs — the source said
+ * something the output does not, or says differently. `added` is the write path being
+ * explicit where the source was implicit, which is *usually* harmless and is reported
+ * separately for a reason worth stating: this diff cannot tell whether the value the write
+ * path chose is the one the source was inheriting. An `added` `color` is benign if the
+ * shape was inheriting that colour and a silent repaint if it was not.
+ */
+type DifferenceKind = 'lost' | 'added' | 'changed';
+interface IrDifference {
+  /** 1-based source slide. */
+  slideNumber: number;
+  /** Source shape name, when the difference sits inside a call that has one. */
+  shapeName: string | null;
+  /**
+   * Shape names nested inside the same call — a group's children. A note scoped to one of
+   * these also declares differences reported against the call that carries it.
+   */
+  nestedNames: string[];
+  /** Where in the slide's projection, e.g. `calls[4].args[1].line.width`. */
+  path: string;
+  /**
+   * The option name the difference is about — the last object key on {@link path}, or
+   * `'*'` when a whole call is present on one side only. This is what a note's `construct`
+   * is matched against, which is why `construct` has to name a field path rather than
+   * describe one.
+   */
+  field: string;
+  kind: DifferenceKind;
+  /** The source value, JSON-encoded and truncated for reporting. `'—'` when absent. */
+  expected: string;
+  /** The output value, likewise. */
+  actual: string;
+  /** The note that declares this difference, when one does. */
+  declaredBy: FidelityNote | null;
+}
+interface RoundTripReport {
+  slideCount: number;
+  /** Every difference found, in deck order. */
+  differences: IrDifference[];
+  /**
+   * Differences neither a note nor a known write-path default accounts for.
+   * **These are the defects**, and the number this check gates on.
+   */
+  undeclared: IrDifference[];
+  /** Differences a note declared. The contract working. */
+  declared: IrDifference[];
+  /** `added` differences: the write path spelling out what the source left implicit. */
+  added: IrDifference[];
+  /**
+   * Notes that matched no difference.
+   *
+   * **Not a defect signal, despite the obvious reading.** Most notes name constructs the
+   * read model cannot see at all — a bullet's `a:buFont`, a shape's theme `effectRef` —
+   * so they are absent from *both* IRs and there is nothing for them to match. A note
+   * here is a candidate for review, not a stale claim.
+   */
+  unmatchedNotes: FidelityNote[];
+}
+/**
+ * Every note construct this table knows how to match, for a test to check against. The
+ * `layout.` spellings are not listed — they resolve through {@link isKnownNoteConstruct},
+ * which is what a corpus check should use.
+ */
+declare function knownNoteConstructs(): string[];
+/**
+ * Compare the deck a script was generated from against the deck it produced.
+ *
+ * `notes` must be the set that actually applies to the printed output — `printScript`'s
+ * returned `notes`, not `DeckIr.fidelity`. The two differ in both directions: the printer
+ * suppresses notes its tier rescues and adds ones its tier causes, so diffing against the
+ * IR's own list would both over- and under-exclude.
+ */
+declare function diffDeckIr(expected: CanonicalDeck, actual: CanonicalDeck, notes: FidelityNote[]): RoundTripReport;
+/**
+ * `true` when the coverage table can match this construct — directly or through the
+ * layout-shape fallback. The check a corpus test runs over every note both printers emit.
+ */
+declare function isKnownNoteConstruct(construct: string): boolean;
+//#endregion
+export { type AssetIr, type AssetMode, type AssetRef, type BackgroundIr, type CallIr, type CanonicalCall, type CanonicalChrome, type CanonicalDeck, type CanonicalSlide, type Cause, type ChromeIr, type DeckIr, type DeckPropsIr, type DifferenceKind, type Disposition, type ErrorCode, type FidelityNote, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, type IrDifference, type IrValue, LAYOUT_NOTE_PREFIX, type MasterIr, MediaError, type MediaErrorCode, PackageReadError, type PackageReadErrorCode, type PrintScriptOptions, type PrintStandaloneScriptOptions, type PrintedScript, type RoundTripReport, type SlideIr, type SlideLayoutIr, type SlideSource, type ThemeIr, type TransitionIr, type TransitionSoundIr, type TsPptxCode, TsPptxError, type TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, canonicalDeckIr, diffDeckIr, isAssetRef, isKnownNoteConstruct, knownNoteConstructs, printScript, printStandaloneScript, readModelToIr };
+//# sourceMappingURL=script.d.ts.map

package/dist/script.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script.d.ts","names":[],"sources":["../src/script/fidelity.ts","../src/script/ir.ts","../src/script/from-read/deck.ts","../src/script/print/common.ts","../src/script/print/script.ts","../src/script/print/standalone.ts","../src/script/verify/canonical.ts","../src/script/verify/diff.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;KAoBY;;;;;;;;;;;;;;;;;;;;;KAsBA;;;;;;;;UASK;;EAEhB;;EAEA;;;;;;;EAOA;EACA,aAAa;EACb,OAAO;;EAEP;;;;;;;;;;;;;;;;;;;;cAkDY;;;;;;;;;;;;UC/EI;EAChB;;;iBAIe,WAAW,iBAAiB,SAAS;;;;;;;KAUzC,6CAA6C,WAAW;GAAe,cAAc;;;UAmBhF;;EAEhB;;EAEA;EACA,OAAO;;;;;;;;;;UAWS;EAChB;EACA,MAAM;;;;;EAKN;;;;;;;;;;;;;;;;;;;;KAqBW;;;;;;;;UASK;EAChB;EACA;EACA,OAAO;;;;;;;;;;UAWS;;EAEhB,OAAO;;EAEP;;EAEA;;EAEA;;;;;;;;;;;;;UAcgB;;EAEhB;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;KAAa;;EACb,QAAQ;;;;;;;;;;;;;UAcQ;;EAEhB;;EAEA;;EAEA;;;UAIgB;;EAEhB;EACA,QAAQ;;EAER,QAAQ;;EAER;;EAEA;EACA,aAAa;;EAEb;;;;;;EAMA,aAAa;;;;;;;;;EASb,OAAO;;;;;;;;;;UAWS;EAChB;EACA;EACA;EACA;EACA;EACA;;EAEA;KAAiB;;;;;;;;;;UAUD;;;;;EAKhB;;;;;;EAMA;KAAU,cAAc;;;;;;;UAOR;EAChB,OAAO;;EAEP,SAAS;;;UAIO;EAChB;EACA;EACA;EACA;EACA;;;;;;;;;UAUgB;EAChB;IAAa;IAAkB;;EAC/B,OAAO;;;;;EAKP,QAAQ;EACR,QAAQ;EACR,QAAQ;;;;;;;EAOR,UAAU;;;;;iBCxNK,cAAc,MAAM,eAAe;;;;KC7EvC;;;;;UAMK;;EAEhB;;;;;;EAMA,QAAQ,YAAY;;;;;;EAMpB,OAAO;;;;UCYS;;;;;;EAMhB;;EAEA;;EAEA;;EAEA,SAAS;;;;;;;EAOT;;;iBA4Ce,YAAY,IAAI,QAAQ,UAAS,qBAA0B;;;UCpE1D;;EAEhB;;EAEA;;EAEA,SAAS;;;;;;EAMT;;;iBAee,sBAAsB,IAAI,QAAQ,UAAS,+BAAoC;;;;UC/C9E;EAChB;;EAEA;;;;;;;;;;EAUA;EACA,MAAM;;UAGU;EAChB;EACA;;;;;;;;;;EAUA;EACA,YAAY;EACZ;;;;;;;;;;;EAWA,YAAY;EACZ,OAAO;;;;;;;;;;;;UAaS;EAChB,OAAO;;EAEP,SAAS;;UAGO;EAChB;IAAa;IAAkB;;;EAE/B,OAAO;EACP,QAAQ;EACR,QAAQ;;;iBAoDO,gBAAgB,IAAI,SAAS;;;;;;;;;;;;;KCvFjC;UAsDK;;EAEhB;;EAEA;;;;;EAKA;;EAEA;;;;;;;EAOA;EACA,MAAM;;EAEN;;EAEA;;EAEA,YAAY;;UAGI;EAChB;;EAEA,aAAa;;;;;EAKb,YAAY;;EAEZ,UAAU;;EAEV,OAAO;;;;;;;;;EASP,gBAAgB;;;;;;;iBAgMD;;;;;;;;;iBAYA,WAAW,UAAU,eAAe,QAAQ,eAAe,OAAO,iBAAiB;;;;;iBAiYnF,qBAAqB"}