pptx-ts 0.0.1 → 4.0.0

package/dist/diagnostics-D8ot4Ei7.d.ts

@@ -0,0 +1,244 @@
+//#region src/codes.d.ts
+/**
+ * The library's condition vocabulary — one registry covering both surfaces a problem can take.
+ *
+ * A **code** names a *condition*, in `area/condition` form. The same condition keeps the same code
+ * whichever way it reaches the consumer: as a non-fatal {@link Diagnostic} (see `diagnostics.ts`)
+ * or as a thrown {@link TsPptxError} (see `errors.ts`). `coord/non-finite` means "a coordinate was
+ * `NaN`/`Infinity`" in both directions, and a consumer that special-cases it only has to learn the
+ * one string.
+ *
+ * **A code is API; the message that carries it is not.** Adding a code is back-compatible;
+ * removing or renaming one is a breaking change. Every union here is closed, so a new warning or
+ * throw site cannot be written without naming its condition in this file — that is the enforcement
+ * mechanism for keeping the vocabulary curated rather than accumulated. Reuse an existing code when
+ * the condition is genuinely the same, even if the wording differs and even if it is reported from
+ * a different entry point.
+ *
+ * The error codes are grouped by the {@link TsPptxError} subclass that carries them, not by area,
+ * because that pairing is type-enforced: `new MediaError('coord/non-finite', …)` does not compile.
+ * A condition that can genuinely arrive under two different classes needs two codes, because the
+ * class is part of what the consumer branches on.
+ *
+ * This module is types only — it emits no runtime code, so importing it can never create an import
+ * cycle and `diagnostics.ts` keeps the "safe to use from anywhere" property its header claims.
+ */
+/**
+ * The stable identifier for a non-fatal condition the library reports and then works around.
+ *
+ * Codes are shared across entry points where the *condition* is the same even though the message
+ * differs — an image whose natural size cannot be measured reports
+ * `image/unmeasurable-natural-size` whether it came from `addImage` or from `Picture.setImage`.
+ */
+type DiagnosticCode = 'object-name/empty' | 'object-name/control-characters' | 'object-name/too-long' | 'object-name/duplicate' | 'animation/target-index-out-of-range' | 'animation/target-not-found' | 'animation/target-missing' | 'animation/unknown-preset' | 'chart/invalid-axis-time-unit' | 'chart/non-finite-value' | 'chart/error-bars-missing-values' | 'chart/axis-type-conflict' | 'chart/invalid-metadata' | 'chart/invalid-metadata-key' | 'chart/invalid-metadata-value' | 'chart/option-out-of-range' | 'chart/option-not-on-axis' | 'chart/option-not-supported' | 'chart/invalid-option-value' | 'chart/invalid-subtotal-index' | 'chart/symbol-size-out-of-range' | 'chart/invalid-grid-line-size' | 'chart/invalid-grid-line-style' | 'chart/invalid-grid-line-cap' | 'chart/layout-out-of-range' | 'chart/stock-series-count' | 'chart/point-count-mismatch' | 'chart/point-index-out-of-range' | 'comment/missing-author' | 'comment/missing-text' | 'connector/bends-ignored-for-straight' | 'connector/adj-out-of-range' | 'connector/unresolved-binding' | 'group/unsupported-child' | 'group/unrecognized-child' | 'group/no-children' | 'group/partial-frame' | 'family/child-not-composed' | 'image-fill/missing-source' | 'image-fill/missing-base64-header' | 'image-fill/svg-unsupported' | 'image-fill/unresolved-media' | 'preview-image/missing-base64-header' | 'background/missing-base64-header' | 'image/crop-and-sizing-conflict' | 'image/unmeasurable-natural-size' | 'image/bilevel-threshold-out-of-range' | 'table/invalid-border' | 'table/invalid-outer-border' | 'table/invalid-horz-overflow' | 'table/invalid-cell3d' | 'table/col-width-count-mismatch' | 'table/invalid-col-width' | 'table/span-out-of-range' | 'table/cell-past-grid' | 'table/autopage-height-too-small' | 'table/autopage-rowspan-too-tall' | 'table/invalid-row-height' | 'table/invalid-margin' | 'table/invalid-header-row-count' | 'text/invalid-valign' | 'text/invalid-vertical' | 'text/invalid-warp' | 'text/invalid-columns' | 'text/invalid-column-spacing' | 'text/invalid-indent-level' | 'text/invalid-fit-percentage' | 'text/invalid-strike' | 'text/invalid-caps' | 'text/invalid-underline' | 'text/invalid-tab-alignment' | 'text/char-spacing-out-of-range' | 'text/line-spacing-out-of-range' | 'text/paragraph-margin-out-of-range' | 'text/paragraph-indent-out-of-range' | 'font/size-out-of-range' | 'bullet/size-out-of-range' | 'bullet/image-missing-base64-header' | 'bullet/image-embed-failed' | 'bullet/invalid-character-code' | 'bullet/start-at-out-of-range' | 'bullet/invalid-number-type' | 'transition/unknown-type' | 'transition/unknown-variant' | 'zoom/missing-target' | 'zoom/unresolved-target' | 'zoom/missing-section-title' | 'zoom/section-not-found' | 'zoom/section-empty' | 'zoom/no-sections-to-summarize' | 'zoom/transition-duration-out-of-range' | 'color/not-a-string' | 'color/invalid-value' | 'color/empty-string' | 'shadow/invalid-type' | 'shadow/angle-out-of-range' | 'glow/size-out-of-range' | 'shadow/blur-out-of-range' | 'shadow/offset-out-of-range' | 'shadow/transparency-out-of-range' | 'shadow/color-has-hash' | 'geometry/invalid-shape-adjust' | 'geometry/shape-adjust-overridden' | 'geometry/arc-node-point-ignored' | 'shape/degenerate-extent' | 'frame/zero-extent' | 'geometry/invalid-guide' | 'geometry/unknown-guide-operation' | 'geometry/invalid-connection-site' | 'border/unknown-key' | 'border/invalid-dash-type' | 'line/invalid-arrow-type' | 'object-lock/unsupported-on-shape' | 'media/load-failed' | 'media/svg-preview-failed' | 'model3d/preview-missing' | 'media/invalid-loop-count' | 'theme/invalid-color-override' | 'master/invalid-text-style-font-size' | 'master/invalid-text-style-length' | 'master/too-many-text-style-levels' | 'notes/hyperlink-slide-unsupported' | 'html/image-missing-source' | 'section/missing-argument' | 'section/missing-title' | 'section/duplicate-title' | 'section/invalid-order' | 'slide/section-not-found' | 'slide/master-not-found' | 'slide/removed-link-target' | 'layout/invalid-definition' | 'core/revision-not-a-whole-number' | 'diagram/drawing-cache-not-updated' | 'diagram/point-has-no-text-body' | 'inspect/group-transform-missing' | 'inspect/group-transform-degenerate' | 'measure/shrink-unmeasured' | 'measure/resize-unmeasured' | 'measure/heuristic-metrics' | 'measure/uncovered-codepoints' | 'margin/legacy-points' | 'gradient/center-out-of-range' | 'transparency/out-of-range' | 'opacity/out-of-range' | 'line/width-out-of-range' | 'coord/bare-number-is-inches' | 'layout/size-out-of-range';
+/**
+ * Conditions carried by `InvalidOptionError`: the caller passed something the library cannot use.
+ *
+ * This is the largest group by design — the project's stated policy is to throw rather than coerce
+ * (`AGENTS.md` → "Silent coercion of invalid input is a footgun"), so most throws are here.
+ */
+type InvalidOptionErrorCode = 'coord/non-finite' | 'percent/non-finite' | 'coord/not-positive' | 'coord/invalid-format' | 'coord/out-of-range' | 'bullet/start-at-not-a-number' | 'presentation/first-slide-num-not-an-integer' | 'geometry/arc-angle-non-finite' | 'shadow/angle-non-finite' | 'chart/missing-type' | 'chart/option-non-finite' | 'chart/unknown-type' | 'chart/secondary-axis-unused' | 'chart/axis-count-mismatch' | 'chart/too-many-columns' | 'chart/bubble-in-combo' | 'shape/missing-type' | 'shape/unknown-preset' | 'connector/missing-endpoints' | 'connector/invalid-type' | 'connector/invalid-bends' | 'connector/adj-count-mismatch' | 'connector/adj-non-finite' | 'connector/invalid-binding-name' | 'connector/invalid-connection-site' | 'line/invalid-cap' | 'group/missing-object-names' | 'group/invalid-object-name' | 'group/duplicate-object-name' | 'group/unresolved-object-name' | 'group/ambiguous-object-name' | 'gradient/angle-non-finite' | 'gradient/too-few-stops' | 'gradient/stop-position-non-finite' | 'gradient/stop-position-out-of-range' | 'gradient/rotate-with-shape-not-boolean' | 'gradient/scaled-not-boolean' | 'pattern-fill/missing-pattern' | 'image/missing-source' | 'image/path-not-a-string' | 'image/data-not-a-string' | 'image/missing-base64-header' | 'image/crop-window-overflows' | 'image/crop-inset-out-of-range' | 'image/crop-insets-exceed-extent' | 'media/missing-source' | 'media/missing-base64-header' | 'media/cover-missing-base64-header' | 'media/online-missing-link' | 'ole/missing-source' | 'ole/invalid-image-size' | 'zoom/invalid-transition-duration' | 'transition/invalid-time' | 'transition/sound-unsupported' | 'model3d/missing-source' | 'model3d/invalid-camera' | 'model3d/invalid-fov' | 'model3d/invalid-scale' | 'layout/invalid-definition' | 'table/rows-not-an-array' | 'table/rows-not-nested' | 'table/invalid-cell-anchor' | 'table/invalid-cell-vert' | 'table/invalid-cell-overflow' | 'table/invalid-cell-margin' | 'table/invalid-cell-border' | 'table/row-index-out-of-range' | 'table/column-index-out-of-range' | 'table/merge-range-invalid' | 'hyperlink/not-an-object' | 'hyperlink/missing-target' | 'hyperlink/conflicting-targets' | 'hyperlink/invalid-slide' | 'slide/link-past-last-slide' | 'text/invalid-text' | 'clip/invalid-shape' | 'html/no-document' | 'html/table-not-found' | 'html/table-has-no-cells' | 'color/invalid-hex' | 'color/invalid-scheme-token' | 'text/invalid-underline' | 'slide/index-out-of-range' | 'slide/foreign-target' | 'slide/id-space-exhausted' | 'shape/index-out-of-range' | 'layout/ambiguous-name' | 'layout/not-found' | 'layout/foreign-handle' | 'import/slide-size-mismatch' | 'import/slide-size-unknown' | 'import/unresolved-slide-link' | 'import/destination-missing-master' | 'import/destination-missing-layout' | 'import/output-index-conflict' | 'import/output-index-out-of-range' | 'import/rescale-conflict' | 'image/undeterminable-extension' | 'image/undeterminable-type' | 'image/missing-content-type' | 'image/fit-needs-extent' | 'font/size-not-positive' | 'script/unresolved-asset-reference' | 'script/non-finite-literal' | 'package/duplicate-part-name' | 'part/not-xml' | 'relationship/duplicate-id' | 'relationship/not-found' | 'relationship/external-has-no-partname' | 'oxml/unknown-namespace-prefix' | 'oxml/invalid-qname' | 'font/missing-typeface' | 'font/invalid-style-slot' | 'font/invalid-base64' | 'font/missing-source' | 'font/collection-index-out-of-range' | 'font/collection-face-not-found' | 'layout/unknown' | 'master/missing-title' | 'math/invalid-latex' | 'math/invalid-mathml' | 'zip/unsupported-input' | 'zip/unsupported-output';
+/**
+ * Conditions carried by `UnsupportedFeatureError`: the request is well-formed, but this build,
+ * runtime, or shape cannot express it. Distinct from `InvalidOptionError` because the caller did
+ * nothing wrong — the answer is "not here", not "not like that".
+ */
+type UnsupportedFeatureErrorCode = 'gradient/type-unsupported' | 'line/image-fill-unsupported' | 'group/kind-not-groupable' | 'shape/element-unsupported' | 'shape/fill-unsupported' | 'shape/line-unsupported' | 'shape/no-text-frame' | 'math/missing-optional-peer' | 'font/opentype-unavailable' | 'zip/filesystem-unavailable' | 'runtime/file-output-unavailable' | 'family/not-composed';
+/**
+ * Conditions carried by `PackageReadError`: the bytes handed to the library are not a package it
+ * can read, or a part inside one is structurally malformed. Always about *input*, never about
+ * something the library is asked to produce.
+ */
+type PackageReadErrorCode = 'zip/not-a-zip-archive' | 'zip/file-read-failed' | 'package/not-an-opc-package' | 'package/content-types-invalid-root' | 'package/content-types-entry-incomplete' | 'package/part-content-type-missing' | 'package/relationships-invalid-root' | 'package/relationship-incomplete' | 'package/relationship-invalid-target-mode' | 'package/duplicate-relationship-id' | 'package/relationship-target-escapes-root' | 'package/relationship-target-missing' | 'package/office-document-relationship-invalid' | 'package/part-missing' | 'package/part-has-no-root' | 'slide/no-shape-tree' | 'shape/no-non-visual-properties' | 'table/cell-has-no-text-body' | 'diagram/parent-edge-cycle';
+/**
+ * Conditions carried by `MediaError`: an image, font, or audio/video payload could not be fetched,
+ * read, or decoded. Kept separate from `PackageReadError` because the failure is in a *referenced
+ * resource*, not in the package structure, and the recovery is usually different (fix the URL or
+ * the file, not the deck).
+ */
+type MediaErrorCode = 'media/load-failed' | 'font/fetch-failed' | 'font/read-failed' | 'font/parse-failed' | 'media/fetch-failed' | 'media/read-failed' | 'media/decode-failed' | 'media/svg-preview-failed';
+/**
+ * Conditions carried by `InternalError`: an invariant the library maintains itself did not hold.
+ * Reaching one is a bug in ts-pptx, not something a consumer can fix by changing their input —
+ * which is exactly why it is worth being able to tell apart from the four classes above.
+ */
+type InternalErrorCode = 'layout/default-not-registered' | 'slide/rel-index-out-of-range' | 'slide/part-already-in-deck' | 'import/part-went-missing' | 'import/slide-link-not-placed' | 'import/rescale-mode-changed' | 'chart/type-not-routed' | 'slide/object-type-not-routed' | 'ooxml/member-not-in-sequence' | 'slide/link-target-not-a-number' | 'hyperlink/not-validated' | 'animation/timing-scaffold-failed' | 'media/rel-ids-not-consecutive' | 'oxml/node-has-no-document' | 'oxml/node-has-no-parent';
+/**
+ * Every condition the library can throw. See {@link TsPptxCode} for the whole vocabulary.
+ *
+ * **Which of these is worth reporting upstream.** An `InternalErrorCode` always is, and the error
+ * carrying it says so at runtime. A `PackageReadErrorCode` on a file that opens cleanly in
+ * PowerPoint, a `MediaErrorCode` on an asset every other tool loads, and an
+ * `UnsupportedFeatureErrorCode` for something PowerPoint can plainly express are all gaps on our
+ * side rather than bad input — the project's supported bar is "the output opens cleanly in
+ * Microsoft PowerPoint", and it reads in both directions. An `InvalidOptionErrorCode` is worth
+ * reporting only if the deck it refused is one PowerPoint can express.
+ *
+ * `npx skills add shbernal/ts-pptx` installs the skill that walks through filing one.
+ */
+type ErrorCode = InvalidOptionErrorCode | UnsupportedFeatureErrorCode | PackageReadErrorCode | MediaErrorCode | InternalErrorCode;
+/** Every condition the library can report, warned or thrown. */
+type TsPptxCode = DiagnosticCode | ErrorCode;
+//#endregion
+//#region src/errors.d.ts
+/** Extra context accepted by every {@link TsPptxError} constructor. */
+interface TsPptxErrorOptions extends ErrorOptions {
+  /**
+   * Structured context for the condition, when a site has any to give. Mirrors `Diagnostic.detail`
+   * so the same condition looks the same whether it was warned or thrown.
+   */
+  readonly detail?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Base class for every error ts-pptx throws.
+ *
+ * Catch this to catch anything from the library; narrow with `instanceof` on a subclass, or branch
+ * on {@link TsPptxError.code}, to react to something specific. It is never thrown directly — every
+ * site picks one of the five subclasses.
+ */
+declare class TsPptxError extends Error {
+  /** Stable condition identifier — see {@link ErrorCode}. Branch on this, not on the text. */
+  readonly code: ErrorCode;
+  /** Structured context for the condition, when the throwing site had any to give. */
+  readonly detail?: Readonly<Record<string, unknown>>;
+  /**
+   * @param code - the stable condition identifier
+   * @param message - explanation for a human reading a stack trace; not part of the contract
+   * @param options - standard `cause`, plus optional structured `detail`
+   */
+  constructor(code: ErrorCode, message: string, options?: TsPptxErrorOptions);
+}
+/**
+ * The caller passed something the library cannot use — a non-finite coordinate, an unknown enum
+ * value, a required option left out, a value outside its legal range.
+ *
+ * This is the error behind the project's throw-rather-than-coerce policy: emitting a degenerate
+ * result (a zero-size shape, a silently dropped option) hides the mistake, so the library refuses
+ * instead. Reaching one means the calling code needs to change.
+ */
+declare class InvalidOptionError extends TsPptxError {
+  readonly code: InvalidOptionErrorCode;
+  constructor(code: InvalidOptionErrorCode, message: string, options?: TsPptxErrorOptions);
+}
+/**
+ * The request is well-formed but cannot be expressed here: an optional peer dependency is not
+ * installed, the runtime lacks a capability, or the shape/feature has no OOXML representation the
+ * library emits.
+ *
+ * Distinct from {@link InvalidOptionError} because the caller did nothing wrong — the answer is
+ * "not here", not "not like that" — and the fix is usually to install something or pick a different
+ * approach rather than to correct a value.
+ */
+declare class UnsupportedFeatureError extends TsPptxError {
+  readonly code: UnsupportedFeatureErrorCode;
+  constructor(code: UnsupportedFeatureErrorCode, message: string, options?: TsPptxErrorOptions);
+}
+/**
+ * The bytes handed to the library are not a package it can read, or a part inside one is
+ * structurally malformed — a missing `[Content_Types].xml`, a relationship pointing at nothing, a
+ * slide part with no root element.
+ *
+ * Always about *input*. A problem with something the library is being asked to produce is an
+ * {@link InvalidOptionError}.
+ */
+declare class PackageReadError extends TsPptxError {
+  readonly code: PackageReadErrorCode;
+  constructor(code: PackageReadErrorCode, message: string, options?: TsPptxErrorOptions);
+}
+/**
+ * A referenced image, font, or audio/video resource could not be fetched, read, or decoded.
+ *
+ * Kept apart from {@link PackageReadError} because the failure is in a resource the deck *points
+ * at*, not in the package structure — a broken URL, an unreadable path, a corrupt font file — and
+ * a consumer typically retries or substitutes rather than rejecting the deck.
+ */
+declare class MediaError extends TsPptxError {
+  readonly code: MediaErrorCode;
+  constructor(code: MediaErrorCode, message: string, options?: TsPptxErrorOptions);
+}
+/**
+ * An invariant the library maintains itself did not hold.
+ *
+ * No consumer input should be able to produce one, which is the whole reason it is a separate
+ * class: seeing it means the bug is in ts-pptx, and the useful response is to file it rather than
+ * to keep adjusting the input.
+ *
+ * It is the one class in the taxonomy that extends its own message, appending `REPORT_NOTICE`
+ * below the invariant that broke. The constructor is where that lives so a throw site added later
+ * inherits it — the alternative, a notice pasted at each of the sites, is one every future site can
+ * forget. Every other class leaves `message` exactly as given: a malformed package is the routine
+ * outcome for a library that reads untrusted files, and a "report this" banner on each corrupt
+ * input would train callers to ignore the one banner that always means something.
+ *
+ * This does not make the message API — see the class doc on {@link TsPptxError}. Branch on
+ * `instanceof` or on {@link InternalError.code}, never on the text.
+ */
+declare class InternalError extends TsPptxError {
+  readonly code: InternalErrorCode;
+  constructor(code: InternalErrorCode, message: string, options?: TsPptxErrorOptions);
+}
+//#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.
+   *
+   * Every rejection of an `ST_` enum value populates it: `checkEnumOrWarn` (`ooxml/check-enum.ts`)
+   * carries `received` — the value the caller passed — and `valid`, the whole legal list, plus
+   * whatever the call site adds. That reaches a handler for a line dash type, a table cell's 3-D
+   * preset and a table's horizontal overflow, among others. Nothing else populates it yet, so a
+   * handler must still treat the field as optional and must not assume a particular key is there
+   * for a given code.
+   */
+  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 build the decks one at a time with the
+ * handler set around each build: a handler set around concurrent builds sees all of their
+ * diagnostics.
+ *
+ * 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 `warnOnce` dedupe set, so a condition already reported reports again. (`warnOnce` is
+ * internal and carries no page of its own, so it is named rather than linked.)
+ *
+ * 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 { PackageReadErrorCode as _, InternalError as a, PackageReadError as c, UnsupportedFeatureError as d, DiagnosticCode as f, MediaErrorCode as g, InvalidOptionErrorCode as h, setDiagnosticHandler as i, TsPptxError as l, InternalErrorCode as m, DiagnosticHandler as n, InvalidOptionError as o, ErrorCode as p, resetDiagnosticState as r, MediaError as s, Diagnostic as t, TsPptxErrorOptions as u, TsPptxCode as v, UnsupportedFeatureErrorCode as y };
+//# sourceMappingURL=diagnostics-D8ot4Ei7.d.ts.map

package/dist/diagnostics-D8ot4Ei7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics-D8ot4Ei7.d.ts","names":[],"sources":["../src/codes.ts","../src/errors.ts","../src/diagnostics.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCY;;;;;;;KA8KA;;;;;;KAwKA;;;;;;KAwBA;;;;;;;KAkCA;;;;;;KAwBA;;;;;;;;;;;;;;KAiEA,YACT,yBACA,8BACA,uBACA,iBACA;;KAGS,aAAa,iBAAiB;;;;UCrezB,2BAA2B;;;;;WAKlC,SAAS,SAAS;;;;;;;;;cAUf,oBAAoB;;WAEvB,MAAM;;WAGN,SAAS,SAAS;;;;;;EAO3B,YAAY,MAAM,WAAW,iBAAiB,UAAU;;;;;;;;;;cAmB5C,2BAA2B;WACtB,MAAM;EACvB,YAAY,MAAM,wBAAwB,iBAAiB,UAAU;;;;;;;;;;;cAczD,gCAAgC;WAC3B,MAAM;EACvB,YAAY,MAAM,6BAA6B,iBAAiB,UAAU;;;;;;;;;;cAa9D,yBAAyB;WACpB,MAAM;EACvB,YAAY,MAAM,sBAAsB,iBAAiB,UAAU;;;;;;;;;cAYvD,mBAAmB;WACd,MAAM;EACvB,YAAY,MAAM,gBAAgB,iBAAiB,UAAU;;;;;;;;;;;;;;;;;;;cAkCjD,sBAAsB;WACjB,MAAM;EACvB,YAAY,MAAM,mBAAmB,iBAAiB,UAAU;;;;;UCzJhD;;WAEP,MAAM;;WAEN;;;;;;;;;;;WAWA,SAAS,SAAS;;;KAIhB,qBAAqB,YAAY;;;;;;;;;;;;;;;;;;;;;;;iBAkC7B,qBAAqB,MAAM;;;;;;;;;;;;;;;;;iBAwD3B"}

package/dist/embedded-fonts-DarT9aoa.d.ts

@@ -0,0 +1,20 @@
+import { un as EMBEDDED_FONT_SLOTS } from "./pres-C6qgOFAa.js";
+//#region src/embedded-fonts.d.ts
+type EmbeddedFontSlot = (typeof EMBEDDED_FONT_SLOTS)[number];
+/** One embeddable face: a slot plus the raw font bytes (absent in pure read-side merges). */
+interface EmbeddedFontFace {
+  slot: EmbeddedFontSlot;
+  bytes?: Uint8Array;
+}
+/** A typeface family with 1..4 embedded faces — one `p:embeddedFont` entry. */
+interface EmbeddedFont {
+  /** `p:font/@typeface` — MUST match the family name used in run/`fontFace` typefaces or PowerPoint won't bind it. */
+  typeface: string;
+  panose?: string;
+  pitchFamily?: number;
+  charset?: number;
+  faces: EmbeddedFontFace[];
+}
+//#endregion
+export { EmbeddedFontFace as n, EmbeddedFontSlot as r, EmbeddedFont as t };
+//# sourceMappingURL=embedded-fonts-DarT9aoa.d.ts.map

package/dist/embedded-fonts-DarT9aoa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedded-fonts-DarT9aoa.d.ts","names":[],"sources":["../src/embedded-fonts.ts"],"mappings":";;KAyCY,2BAA2B;;UAGtB;EAChB,MAAM;EACN,QAAQ;;;UAIQ;;EAEhB;EACA;EACA;EACA;EACA,OAAO"}