@shbernal/ts-pptx 3.1.0 → 3.3.0

package/dist/{slide-BRAtT8Dl.d.ts → slide-DWw9UoI6.d.ts}

@@ -1,8 +1,15 @@
-import { _ as TextAnchor, f as SHAPE_NAME, g as TableStyle, h as SlideObjectType, i as CHART_NAME, l as PLACEHOLDER_TYPE, t as AlignH } from "./enums-CoXnxiCI.js";
+import { _ as TextAnchor, f as SHAPE_NAME, g as TableStyle, h as SlideObjectType, i as CHART_NAME, l as PLACEHOLDER_TYPE, t as AlignH } from "./enums-CvRYniUA.js";
 //#region src/types/text.d.ts
 interface TextBaseProps {
   /**
    * Horizontal alignment
+   *
+   * When a shape's text is an array of runs, set this on **every run** of a paragraph.
+   * {@link breakLine} is not the only paragraph boundary: two adjacent runs whose `align`
+   * differs start a new one, so stating it on the opening run alone splits the paragraph in
+   * two. That is the mirror of {@link bullet}, {@link paraMarginLeft} and {@link paraIndent},
+   * which are read from the opening run only. Neither mistake changes the run count — the
+   * only symptom is a differently shaped paragraph, with no error.
    * @default 'left'
    */
   align?: HAlign;
@@ -28,9 +35,24 @@ interface TextBaseProps {
    * Add standard or custom bullet
    * - use `true` for standard bullet
    * - pass object options for custom bullet
+   * - `false` (and omitting the option) is the *explicit off*: it writes `<a:buNone/>`
+   *   plus `marL="0" indent="0"`, which overrides whatever bullet the layout's or
+   *   master's list style sets for this level
+   * - `'inherit'` states nothing at all — no bullet child and no margin attributes — so
+   *   the list style keeps reaching the paragraph. This is the one state omission
+   *   cannot spell, because omitting the option means `false` here for compatibility
+   *
+   * The margins are only a *default* of the bullet state: {@link paraMarginLeft} and
+   * {@link paraIndent} state `@marL`/`@indent` independently in any of the three, including
+   * an inherited margin under a drawn bullet.
+   *
+   * When a shape's text is an array of runs, state this on the **opening run only**. A run
+   * that draws a bullet starts a new paragraph by itself, so repeating it — the placement
+   * that {@link align} requires — turns one three-run paragraph into three one-run
+   * paragraphs. A paragraph takes its properties from its first run.
    * @default false
    */
-  bullet?: boolean | {
+  bullet?: boolean | 'inherit' | {
     /**
      * Bullet type
      * @default bullet
@@ -101,11 +123,14 @@ interface TextBaseProps {
     color?: HexColor;
   };
   /**
-   * Text capitalization
+   * Text capitalization (`a:rPr/@cap`, `ST_TextCapsType`)
    * - `'all'` = ALL CAPS
    * - `'small'` = Small Caps
-   * - `'none'` = no override (default)
+   * - `'none'` = the *explicit off*: it writes `cap="none"`, which overrides a capitalization
+   *   the run would otherwise inherit. Omitting the option states nothing and lets that
+   *   inheritance stand
    * - PowerPoint: Font > Effects > All Caps / Small Caps
+   * @default (unset) inherit
    */
   caps?: 'none' | 'small' | 'all';
   /**
@@ -156,6 +181,42 @@ interface TextBaseProps {
    * @example 'fr-CA' // french Canadian
    */
   lang?: string;
+  /**
+   * First-line indent (points) — `a:pPr/@indent`, the offset of the paragraph's FIRST line
+   * from {@link paraMarginLeft}. Negative hangs the first line to the left of the body, which
+   * is what a bulleted paragraph does; positive indents it to the right, the "first line
+   * indented" prose form. PowerPoint: Paragraph > Indentation > Special.
+   * - `'inherit'` writes no `@indent` at all, so the paragraph takes whatever its list style
+   *   (`a:lstStyle` → placeholder → layout → master) sets — the same third state
+   *   {@link bullet} spells, on the attribute beside it
+   * - omitting the option keeps the bullet-derived default: a drawn bullet hangs the first
+   *   line by its margin, `bullet: false` writes `indent="0"`, `bullet: 'inherit'` writes
+   *   nothing
+   * - a value here overrides all of those, in every bullet state
+   * @example -18 // hang the first line 18pt left of the body text
+   * @example 18 // indent the first line 18pt, prose style
+   * @example 'inherit' // keep the list style's indent, even on a bulleted paragraph
+   * @remarks Read from the **opening run** of a paragraph, like {@link bullet} and unlike
+   * {@link align}; a value on a continuation run is ignored.
+   */
+  paraIndent?: number | 'inherit';
+  /**
+   * Left margin of the paragraph (points) — `a:pPr/@marL`, where the paragraph's body text
+   * starts. This is the paragraph's own margin, not the text frame's internal padding
+   * (`margin`) and not the discrete outline level (`indentLevel`, which writes `a:p/@lvl`).
+   * PowerPoint: Paragraph > Indentation > Before text.
+   * - `'inherit'` writes no `@marL` at all, so the paragraph takes whatever its list style
+   *   (`a:lstStyle` → placeholder → layout → master) sets — the third state that omission
+   *   cannot spell, since omitting it writes the bullet-derived default
+   * - omitting the option keeps that default: a drawn bullet writes its own margin (see
+   *   `bullet.indent`), `bullet: false` writes `marL="0"`, `bullet: 'inherit'` writes nothing
+   * - a value here overrides all of those, in every bullet state
+   * @example 36 // body text starts 36pt (0.5in) from the frame's text edge
+   * @example 'inherit' // keep the list style's margin, even on a bulleted paragraph
+   * @remarks Read from the **opening run** of a paragraph, like {@link bullet} and unlike
+   * {@link align}; a value on a continuation run is ignored.
+   */
+  paraMarginLeft?: number | 'inherit';
   /**
    * Add a soft line-break (shift+enter) before line text content
    * @default false
@@ -189,10 +250,15 @@ interface TextBaseProps {
   /**
    * underline properties
    * - PowerPoint: Font > Color & Underline > Underline Style/Underline Color
-   * @default (none)
+   * - `style` is the full `ST_TextUnderlineType` enumeration (ECMA-376 §20.1.10.81)
+   * - `'none'` is the *explicit off*: it writes `a:rPr/@u="none"`, which overrides an
+   *   underline the run would otherwise inherit from its list style, placeholder, layout or
+   *   master. Omitting the option instead states nothing and lets that inheritance stand —
+   *   the two are different facts, not two spellings of one.
+   * @default (unset) inherit
    */
   underline?: {
-    style?: 'dash' | 'dashHeavy' | 'dashLong' | 'dashLongHeavy' | 'dbl' | 'dotDash' | 'dotDashHeave' | 'dotDotDash' | 'dotDotDashHeavy' | 'dotted' | 'dottedHeavy' | 'heavy' | 'none' | 'sng' | 'wavy' | 'wavyDbl' | 'wavyHeavy';
+    style?: 'dash' | 'dashHeavy' | 'dashLong' | 'dashLongHeavy' | 'dbl' | 'dotDash' | 'dotDashHeavy' | 'dotDotDash' | 'dotDotDashHeavy' | 'dotted' | 'dottedHeavy' | 'heavy' | 'none' | 'sng' | 'wavy' | 'wavyDbl' | 'wavyHeavy' | 'words';
     color?: Color;
   };
   /**
@@ -388,7 +454,19 @@ interface TextPropsOptions extends PositionProps, DataOrPathProps, TextBaseProps
   rtlMode?: boolean;
   shadow?: ShadowProps;
   shape?: SHAPE_NAME;
-  strike?: boolean | 'dblStrike' | 'sngStrike';
+  /**
+   * Strikethrough (`a:rPr/@strike`, `ST_TextStrikeType` — ECMA-376 §20.1.10.78)
+   * - `true` is `'sngStrike'`; `'dblStrike'` is the double rule
+   * - `'noStrike'` is the *explicit off*: it writes `strike="noStrike"`, which overrides a
+   *   strikethrough the run would otherwise inherit from its list style, placeholder, layout
+   *   or master
+   * - `false`, like leaving the option out, writes no attribute at all and so states
+   *   *nothing* — the run keeps whatever it inherits. This matches `bold`/`italic`, whose
+   *   falsy arm is likewise an omission; reach for `'noStrike'` when the intent is "not
+   *   struck" rather than "unspecified"
+   * @default (unset) inherit
+   */
+  strike?: boolean | 'noStrike' | 'sngStrike' | 'dblStrike';
   subscript?: boolean;
   superscript?: boolean;
   /**
@@ -491,6 +569,24 @@ interface TextMeasurement {
    * the face via {@link TsPptx.registerFontMetrics} for an exact result.
    */
   approximatedFaces: string[];
+  /**
+   * Code points in the measured text — sorted, deduplicated — whose run resolved to a
+   * **registered** face that has no glyph for them. Empty for fully covered text.
+   *
+   * Unlike everything else here, a non-empty list means the numbers are **not reliably
+   * conservative**. PowerPoint renders such a code point from a substituted face and
+   * measures it in that face's advances; this model has no fallback and charges the
+   * registered font's `.notdef` advance, which is unrelated to the glyph that paints. A
+   * `.notdef` wider than the real glyph over-reports (harmless); a narrower one
+   * under-reports the width and can drop a line, so `heightIn` may come back **short**
+   * and the text overflow. Register a face that covers them (or set an explicit
+   * `fontFace` on those runs) before trusting the height.
+   *
+   * Faces with no registered metrics are not audited — they measure through the
+   * cmap-less heuristic and are reported in {@link approximatedFaces} instead.
+   * `String.fromCodePoint(...uncoveredCodepoints)` renders the list.
+   */
+  uncoveredCodepoints: number[];
   /** True if the text fits a box of inner height `hIn` (inches) at full size. */
   fitsBox: (hIn: number) => boolean;
   /** The `fontScale` (percent) that fits inner height `hIn`; `100` if it already fits, never below the shrink floor. */
@@ -854,9 +950,18 @@ interface ChartPropsFillLine {
   border?: BorderProps;
   /**
    * PowerPoint: Format Chart Area/Plot Area > Fill
+   *
+   * Omitting `fill` leaves the area transparent (`<a:noFill/>`), as does a `fill` that
+   * states neither a `color` nor a `type` — `transparency` alone is not a fill, since
+   * there is no colour for the alpha to apply to.
+   *
+   * `type: 'image'` is not supported here and falls back to no fill with a warning: a
+   * blip fill needs a media relationship on the chart part, which nothing registers.
    * @example fill: {color: '696969'} // hex RGB color value
    * @example fill: {color: SchemeColor.background2} // Theme color value
-   * @example fill: {transparency: 50} // 50% transparency
+   * @example fill: {color: '696969', transparency: 50} // 50% transparent grey
+   * @example fill: {type: 'gradient', gradient: {kind: 'linear', angle: 90, stops: [{position: 0, color: '0088CC'}, {position: 100, color: 'FFFFFF'}]}}
+   * @example fill: {type: 'inherit'} // no fill child at all -- take the chart style's fill
    */
   fill?: ShapeFillProps;
 }
@@ -1674,9 +1779,21 @@ interface ShapeFillProps {
   transparency?: number;
   /**
    * Fill type
+   *
+   * `'none'` and `'inherit'` are different states, and both have to be spelled out
+   * because omitting `fill` is not one of them: the shape/text-box emitter defaults a
+   * missing `fill` to `<a:noFill/>`.
+   * - `'none'` emits `<a:noFill/>` — an explicit transparent interior.
+   * - `'inherit'` emits no fill child at all, leaving the interior to
+   *   `p:style/a:fillRef` or the placeholder. This is the only way to author that
+   *   state from `addShape`/`addText`.
+   *
+   * On a table cell (`TableCellProps.fill`) and a slide background the two spellings
+   * differ the same way, except that *omitting* the option there already means
+   * inherit, so `'inherit'` is merely the explicit form of the default.
    * @default 'solid'
    */
-  type?: 'none' | 'solid' | 'gradient' | 'pattern' | 'image';
+  type?: 'none' | 'inherit' | 'solid' | 'gradient' | 'pattern' | 'image';
   /**
    * Native PPTX gradient fill options.
    */
@@ -3326,7 +3443,9 @@ type SlideMasterObject = {
  * Any preset shape, addressed by `SHAPE_NAME` (e.g. `ShapeType.ellipse`).
  * Generalizes the `line`/`rect`/`roundRect` shortcuts to every preset the
  * `addShape()` serializer supports (ellipse, triangle, chevron, …).
- * @example { shape: { type: 'ellipse', options: { x: 1, y: 1, w: 2, h: 2, fill: { color: 'FF0000' } } } }
+ *
+ * A union member's comment cannot carry block tags, so this stands in for `@example`:
+ * `{ shape: { type: 'ellipse', options: { x: 1, y: 1, w: 2, h: 2, fill: { color: 'FF0000' } } } }`
  */
 {
   shape: {
@@ -3699,4 +3818,4 @@ interface AddSlideProps {
 }
 //#endregion
 export { HAlign as $, ChartSeriesOpts as $t, TableToSlidesDocument as A, ChartLineDash as At, ShapeAdjustHandleXY as B, ChartPropsChartHistogram as Bt, TableCell as C, ChartAreaProps as Ct, TableProps as D, ChartExBinning as Dt, TableCellProps as E, ChartErrorBarOptions as Et, MediaProps as F, ChartPropsAxisVal as Ft, BackgroundProps as G, ChartPropsChartStock as Gt, ShapeConnectionSite as H, ChartPropsChartPie as Ht, MediaType as I, ChartPropsBase as It, DataOrPathProps as J, ChartPropsDataLabel as Jt, Color as K, ChartPropsChartSurface as Kt, OleObjectProps as L, ChartPropsChartBar as Lt, TableToSlidesProps as M, ChartOpts as Mt, ImageBaseProps as N, ChartPropsAxisCat as Nt, TableRow as O, ChartExGeography as Ot, ImageProps as P, ChartPropsAxisSer as Pt, GradientStopProps as Q, ChartPropsTitle as Qt, ShapeAdjustHandle as R, ChartPropsChartBoxWhisker as Rt, TransitionType as S, textRuns as Sn, PresetMaterialType as St, TableCellDiagonals as T, ChartDataPointStyle as Tt, ShapeGuide as U, ChartPropsChartRadar as Ut, ShapeAdjustValue as V, ChartPropsChartLine as Vt, ShapeProps as W, ChartPropsChartRegionMap as Wt, GeometryPoint as X, ChartPropsFillLine as Xt, DataOrPathRequiredProps as Y, ChartPropsDataTable as Yt, GradientFillProps as Z, ChartPropsLegend as Zt, AnimationProps as _, TextGlowProps as _n, ShapeFillProps as _t, Slide as a, PlaceholderProps as an, PatternPreset as at, TransitionProps as b, TextPropsOptions as bn, LightRigDirection as bt, Model3dPoint as c, NotesProps as cn, TextVertType as ct, MasterTextStyleLevel as d, ResolvedCommentAuthor as dn, BorderProps as dt, LineCap as en, HexColor as et, MasterTextStyleProps as f, SlideComment as fn, ConnectorProps as ft, SlideNumberProps as g, TextFitShrinkProps as gn, ShadowProps as gt, SlideMasterProps as h, TextBaseProps as hn, HyperlinkProps as ht, ObjectOptions as i, ObjectNameProps as in, PatternFillProps as it, TableToSlidesElement as j, ChartMulti as jt, TableRowSlide as k, ChartExStatistics as kt, Model3dProps as l, NotesTextOptions as ln, ThemeColor as lt, SlideMasterObject as m, TableLayoutResult as mn, HyperlinkActionJump as mt, GroupChildProps as n, OptsChartGridLine as nn, LinearGradientFillProps as nt, SlideLayout as o, CommentProps as on, PositionProps as ot, SlideMasterChartProps as p, TableCellLayout as pn, ConnectorType as pt, Coord as q, ChartPropsChartWaterfall as qt, GroupProps as r, ObjectLockProps as rn, Margin as rt, Model3dCameraProps as s, MeasureTextOptions as sn, RadialGradientFillProps as st, AddSlideProps as t, OptsChartData as tn, ImageFillProps as tt, MasterBulletProps as u, OverflowBoxOptions as un, VAlign as ut, AnimationTrigger as v, TextMeasurement as vn, ShapeLineProps as vt, TableCell3DProps as w, ChartAxisTickMark as wt, TransitionSoundProps as x, textRun as xn, LightRigType as xt, PresetEffect as y, TextProps as yn, BevelPresetType as yt, ShapeAdjustHandlePolar as z, ChartPropsChartDoughnut as zt };
-//# sourceMappingURL=slide-BRAtT8Dl.d.ts.map
+//# sourceMappingURL=slide-DWw9UoI6.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slide-DWw9UoI6.d.ts","names":[],"sources":["../src/types/text.ts","../src/types/object.ts","../src/types/chart.ts","../src/ooxml/st-enums.ts","../src/types/style.ts","../src/types/core.ts","../src/types/shape.ts","../src/types/media.ts","../src/types/table.ts","../src/types/animation.ts","../src/types/master.ts","../src/types/model3d.ts","../src/types/slide.ts"],"mappings":"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"}

package/dist/{st-enums-evQG2A7Z.js → st-enums-bVnezkMJ.js}

@@ -1,4 +1,4 @@
-import { r as warnOnce } from "./diagnostics-DYQC7xLV.js";
+import { r as warnOnce } from "./diagnostics-H1QzgRSw.js";
 import { n as InvalidOptionError } from "./errors-Bvln0H-7.js";
 //#region src/media/base64.ts
 /**
@@ -251,28 +251,49 @@ function utf8Decode(bytes) {
 //#endregion
 //#region src/ooxml/rel-types.ts
 /**
+* OPC relationship type URIs, and the two schema-URI bases they are built from.
+*
+* These are long, near-identical strings that differ in one path segment, which makes a typo
+* both easy to write and invisible on review — a wrong URI does not throw, it silently matches
+* nothing on the read side and produces a part PowerPoint ignores or rejects on the write side.
+*
+* **Why this module is neither `gen/` nor `read/`.** Both halves need the same URIs, and for a
+* while each kept its own copy (`gen/oxml/schema-uris.ts`, `read/api/rel-types.ts`), with a note
+* in both saying a shared home was "a separate decision". It is this module: a rel type is a fact
+* about the OOXML package format, not about writing or reading one, so neither side should own it.
+* A divergence between the two copies would mean the writer emitting a rel the reader cannot find
+* — a round-trip bug with no compile-time signal.
+*
+* Only types used by more than one module live here. A rel type exactly one module cares about
+* (`chart`, `hyperlink`, `tags`, the two comments parts, `oleObject`, the MS media rels, …) stays
+* declared next to the code that reads or emits it — hoisting those would trade a definition you
+* can see for one you have to go and find, and buy nothing.
+*/
+/** Root of every ECMA-376 schema URI. Private: callers want one of the prefixes below. */
+const SCHEMA_BASE = "http://schemas.openxmlformats.org/";
+/**
 * Prefix for `.rels` `Type` URIs — append the type name (`slide`, `image`, `theme`, …).
 * Exported for the write side, which builds one-off rel types at their call sites.
 */
-const OFFICE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
+const OFFICE_REL = SCHEMA_BASE + "officeDocument/2006/relationships/";
 /** `xmlns` of every `<Relationships>` part. Also the prefix of the package-scoped rel types. */
-const PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+const PACKAGE_REL_NS = SCHEMA_BASE + "package/2006/relationships";
 /** `p:sldIdLst` → a slide part. */
-const SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+const SLIDE_REL = OFFICE_REL + "slide";
 /** A slide → its layout; a master → each of its layouts. */
-const SLIDE_LAYOUT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+const SLIDE_LAYOUT_REL = OFFICE_REL + "slideLayout";
 /** A layout → its master; the presentation → each master. */
-const SLIDE_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+const SLIDE_MASTER_REL = OFFICE_REL + "slideMaster";
 /** A slide → its notes slide. */
-const NOTES_SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+const NOTES_SLIDE_REL = OFFICE_REL + "notesSlide";
 /** A notes slide → the notes master; the presentation → the notes master. */
-const NOTES_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
+const NOTES_MASTER_REL = OFFICE_REL + "notesMaster";
 /** A master or notes master → its theme. Layouts and slides inherit it rather than holding one. */
-const THEME_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
+const THEME_REL = OFFICE_REL + "theme";
 /** The package root → `ppt/presentation.xml`. The entry point to everything above. */
-const OFFICE_DOCUMENT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+const OFFICE_DOCUMENT_REL = OFFICE_REL + "officeDocument";
 /** Any part → an image in `ppt/media/`. */
-const IMAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+const IMAGE_REL = OFFICE_REL + "image";
 //#endregion
 //#region src/ooxml/check-enum.ts
 /**
@@ -480,4 +501,4 @@ const PRESET_LINE_DASHES = [
 //#endregion
 export { getImageSizeFromBytes as C, svgMarkupToDataUri as E, getImageSizeFromBase64 as S, decodeBase64ToBytes as T, SLIDE_LAYOUT_REL as _, PRESET_MATERIALS as a, THEME_REL as b, TEXT_VERTICAL as c, IMAGE_REL as d, NOTES_MASTER_REL as f, PACKAGE_REL_NS as g, OFFICE_REL as h, PRESET_LINE_DASHES as i, checkEnumOrThrow as l, OFFICE_DOCUMENT_REL as m, LIGHT_RIGS as n, TEXT_ANCHORS as o, NOTES_SLIDE_REL as p, LIGHT_RIG_DIRECTIONS as r, TEXT_HORZ_OVERFLOW as s, BEVEL_PRESETS as t, checkEnumOrWarn as u, SLIDE_MASTER_REL as v, bytesToBase64 as w, fitSrcRectPercents as x, SLIDE_REL as y };
 
-//# sourceMappingURL=st-enums-evQG2A7Z.js.map
+//# sourceMappingURL=st-enums-bVnezkMJ.js.map

package/dist/{st-enums-evQG2A7Z.js.map → st-enums-bVnezkMJ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"st-enums-evQG2A7Z.js","names":[],"sources":["../src/media/base64.ts","../src/media/image-size.ts","../src/ooxml/rel-types.ts","../src/ooxml/check-enum.ts","../src/ooxml/st-enums.ts"],"sourcesContent":["/**\n * Base64 payload handling for media parts — isomorphic across Node and browsers\n * (`TextEncoder`/`atob`/`btoa` only, no `Buffer`).\n */\n\n/**\n * Encode raw SVG markup as a base64 `image/svg+xml` data URI.\n * - lets callers pass inline SVG to `addImage({ svg })` without hand-rolling base64\n * - isomorphic and UTF-8 safe: uses the global `TextEncoder`/`btoa` (Node and browsers)\n * @param {string} svg - SVG markup, e.g. `'<svg ...>...</svg>'`\n * @returns {string} a `data:image/svg+xml;base64,...` URI\n */\nexport function svgMarkupToDataUri(svg: string): string {\n\treturn `data:image/svg+xml;base64,${bytesToBase64(new TextEncoder().encode(svg))}`\n}\n\n/**\n * Encode raw bytes as base64 (no `data:` prefix) using only `btoa`, so the result is the same\n * on Node, in a browser, and in a runtime that has neither `Buffer` nor `FileReader`.\n *\n * Chunked because `String.fromCharCode(...spread)` blows the argument-count limit on a payload\n * of any real size — a multi-megabyte video rel would throw rather than encode.\n * @param {Uint8Array} bytes - the payload\n * @returns {string} base64 text\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n\tconst CHUNK = 0x8000\n\tlet binary = ''\n\tfor (let i = 0; i < bytes.length; i += CHUNK) binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK))\n\treturn btoa(binary)\n}\n\n/**\n * Decode a base64 image payload (raw base64 or a `data:` URI) to bytes.\n * - tolerant of the `data:[mime];base64,` prefix and of whitespace in the payload\n * @param {string} b64 - base64 string or data URI\n * @returns {Uint8Array | null} decoded bytes, or `null` when the payload is empty/undecodable\n */\nexport function decodeBase64ToBytes(b64: string): Uint8Array | null {\n\tif (!b64) return null\n\t// Strip any `data:...;base64,` prefix and surrounding whitespace\n\tconst comma = b64.indexOf('base64,')\n\tconst payload = (comma >= 0 ? b64.slice(comma + 'base64,'.length) : b64).replace(/\\s/g, '')\n\tif (!payload) return null\n\ttry {\n\t\tconst binary = atob(payload)\n\t\tconst bytes = new Uint8Array(binary.length)\n\t\tfor (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)\n\t\treturn bytes\n\t} catch {\n\t\treturn null\n\t}\n}\n","/**\n * Intrinsic image geometry: reading a natural pixel size out of header bytes, and the\n * `<a:srcRect>` crop math that fits that natural size into a display box.\n *\n * Shared by both sides of the library — the write path (`addImage({ sizing })`) and the read\n * API's `Picture.setImage({ fit })` — which is why it lives outside `gen/` and `read/`.\n * Everything here is synchronous and pure: headers only, never pixel decoding.\n */\n\nimport { decodeBase64ToBytes } from './base64.js'\n\n/**\n * Read the intrinsic dimensions of an image from its header bytes.\n * - synchronous: parses only file-format headers, never decodes pixels\n * - raster: PNG, JPEG, GIF, BMP, and WebP (VP8 / VP8L / VP8X) — natural pixels\n * - vector: SVG — intrinsic size from the root `<svg>` width/height or viewBox\n * - unrecognized formats return `null` (no measurable intrinsic size)\n *\n * Used by image `sizing: 'cover' | 'contain'` to compute an aspect-correct\n * `<a:srcRect>` crop from the *natural* image ratio rather than the displayed box.\n * @param {string} dataB64 - base64 image payload or `data:` URI\n * @returns {{ w: number, h: number } | null} natural size, or `null` when unmeasurable\n */\nexport function getImageSizeFromBase64(dataB64: string): { w: number; h: number } | null {\n\tconst b = decodeBase64ToBytes(dataB64)\n\treturn b ? getImageSizeFromBytes(b) : null\n}\n\n/**\n * Read the intrinsic dimensions of an image from raw header bytes — the\n * byte-level core shared by {@link getImageSizeFromBase64} and the read API's\n * `Picture.setImage({ fit })`, which already holds the media bytes.\n * @param {Uint8Array} b - image bytes\n * @returns {{ w: number, h: number } | null} natural size, or `null` when unmeasurable\n */\nexport function getImageSizeFromBytes(b: Uint8Array): { w: number; h: number } | null {\n\tif (!b || b.length < 24) return null\n\n\t// Bounds-checked byte read: every access below is already guarded by an\n\t// explicit length check, so the `?? 0` fallback is unreachable in practice.\n\tconst u = (n: number): number => b[n] ?? 0\n\n\t// PNG: 8-byte signature, then IHDR with width@16 / height@20 (big-endian uint32)\n\tif (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) {\n\t\tconst w = (u(16) << 24) | (u(17) << 16) | (u(18) << 8) | u(19)\n\t\tconst h = (u(20) << 24) | (u(21) << 16) | (u(22) << 8) | u(23)\n\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t}\n\n\t// GIF: \"GIF87a\"/\"GIF89a\", width@6 / height@8 (little-endian uint16)\n\tif (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46) {\n\t\tconst w = u(6) | (u(7) << 8)\n\t\tconst h = u(8) | (u(9) << 8)\n\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t}\n\n\t// BMP: \"BM\", width@18 / height@22 (little-endian int32; height may be negative for top-down)\n\tif (b[0] === 0x42 && b[1] === 0x4d) {\n\t\tconst w = u(18) | (u(19) << 8) | (u(20) << 16) | (u(21) << 24)\n\t\tconst h = u(22) | (u(23) << 8) | (u(24) << 16) | (u(25) << 24)\n\t\tconst aw = Math.abs(w)\n\t\tconst ah = Math.abs(h)\n\t\treturn aw > 0 && ah > 0 ? { w: aw, h: ah } : null\n\t}\n\n\t// WebP: \"RIFF\"....\"WEBP\" then a VP8 / VP8L / VP8X chunk\n\tif (\n\t\tb[0] === 0x52 &&\n\t\tb[1] === 0x49 &&\n\t\tb[2] === 0x46 &&\n\t\tb[3] === 0x46 &&\n\t\tb[8] === 0x57 &&\n\t\tb[9] === 0x45 &&\n\t\tb[10] === 0x42 &&\n\t\tb[11] === 0x50\n\t) {\n\t\tconst fourCC = String.fromCharCode(u(12), u(13), u(14), u(15))\n\t\tif (fourCC === 'VP8 ' && b.length >= 30) {\n\t\t\t// Lossy: 14-bit width/height at offset 26/28 (little-endian, mask off scale bits)\n\t\t\tconst w = (u(26) | (u(27) << 8)) & 0x3fff\n\t\t\tconst h = (u(28) | (u(29) << 8)) & 0x3fff\n\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t}\n\t\tif (fourCC === 'VP8L' && b.length >= 25) {\n\t\t\t// Lossless: 14-bit width/height packed starting at bit 0 of offset 21\n\t\t\tconst bits = u(21) | (u(22) << 8) | (u(23) << 16) | (u(24) << 24)\n\t\t\tconst w = (bits & 0x3fff) + 1\n\t\t\tconst h = ((bits >> 14) & 0x3fff) + 1\n\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t}\n\t\tif (fourCC === 'VP8X' && b.length >= 30) {\n\t\t\t// Extended: 24-bit canvas width/height minus one at offset 24/27 (little-endian)\n\t\t\tconst w = (u(24) | (u(25) << 8) | (u(26) << 16)) + 1\n\t\t\tconst h = (u(27) | (u(28) << 8) | (u(29) << 16)) + 1\n\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t}\n\t\treturn null\n\t}\n\n\t// JPEG: \"FFD8\", scan segment markers for a Start-Of-Frame (SOFn) and read height@5 / width@7\n\tif (b[0] === 0xff && b[1] === 0xd8) {\n\t\tlet i = 2\n\t\twhile (i + 9 < b.length) {\n\t\t\tif (b[i] !== 0xff) {\n\t\t\t\ti++\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst marker = u(i + 1)\n\t\t\t// SOF0..SOF15 carry frame dimensions, excluding DHT(C4)/JPG(C8)/DAC(CC)\n\t\t\tif (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {\n\t\t\t\tconst h = (u(i + 5) << 8) | u(i + 6)\n\t\t\t\tconst w = (u(i + 7) << 8) | u(i + 8)\n\t\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t\t}\n\t\t\t// Standalone markers (RSTn / SOI / EOI / TEM) have no length payload\n\t\t\tif ((marker >= 0xd0 && marker <= 0xd9) || marker === 0x01) {\n\t\t\t\ti += 2\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\t// Otherwise skip this segment using its 2-byte big-endian length\n\t\t\tconst segLen = (u(i + 2) << 8) | u(i + 3)\n\t\t\tif (segLen < 2) break\n\t\t\ti += 2 + segLen\n\t\t}\n\t\treturn null\n\t}\n\n\t// SVG: text-based vector with no binary signature. When the payload is an\n\t// `<svg>` document, read its intrinsic size from the root element so that\n\t// `sizing: 'cover' | 'contain'` is aspect-correct for SVG, not just rasters.\n\tconst text = utf8Decode(b)\n\tif (/<svg[\\s>]/i.test(text)) return getSvgSizeFromMarkup(text)\n\n\treturn null\n}\n\n/**\n * Compute the `<a:srcRect>` crop percentages (each in 1/1000 of a percent, the\n * OOXML unit) for fitting an image of natural size `img` into a display `box`,\n * assuming the cropped region is then stretched to fill the box (`<a:stretch>`).\n *\n * - `cover`: fill the box, cropping the overflowing axis (positive l/r or t/b)\n * - `contain`: fit inside the box, letterboxing the short axis (negative l/r or t/b)\n *\n * Single source of truth for the crop math shared by the write side\n * (`ImageSizingXml`) and the read API's `Picture.setImage({ fit })`. `l`/`r` and\n * `t`/`b` are symmetric (centered crop).\n * @param {'cover' | 'contain'} type - fit mode\n * @param {{ w: number, h: number }} img - natural image pixel size\n * @param {{ w: number, h: number }} box - displayed frame size (any consistent unit)\n * @returns {{ l: number, r: number, t: number, b: number }} srcRect percentages\n */\nexport function fitSrcRectPercents(\n\ttype: 'cover' | 'contain',\n\timg: { w: number; h: number },\n\tbox: { w: number; h: number }\n): { l: number; r: number; t: number; b: number } {\n\tconst imgRatio = img.h / img.w\n\tconst boxRatio = box.h / box.w\n\tlet width: number\n\tlet height: number\n\tif (type === 'cover') {\n\t\tconst isBoxBased = boxRatio > imgRatio\n\t\twidth = isBoxBased ? box.h / imgRatio : box.w\n\t\theight = isBoxBased ? box.h : box.w * imgRatio\n\t} else {\n\t\tconst widthBased = boxRatio > imgRatio\n\t\twidth = widthBased ? box.w : box.h / imgRatio\n\t\theight = widthBased ? box.w * imgRatio : box.h\n\t}\n\tconst hz = Math.round(1e5 * 0.5 * (1 - box.w / width))\n\tconst vz = Math.round(1e5 * 0.5 * (1 - box.h / height))\n\treturn { l: hz, r: hz, t: vz, b: vz }\n}\n\n/**\n * Read the intrinsic size of an SVG document from its root `<svg>` element.\n * Follows the SVG sizing model: an explicit absolute `width`/`height` pair wins;\n * otherwise the `viewBox` width/height defines the size (and thus aspect ratio).\n * Percentage or missing `width`/`height` fall through to `viewBox`.\n * @param {string} svg - SVG markup\n * @returns {{ w: number, h: number } | null} intrinsic size, or `null` when undeterminable\n */\nfunction getSvgSizeFromMarkup(svg: string): { w: number; h: number } | null {\n\tconst openTag = /<svg\\b[^>]*>/i.exec(svg)?.[0]\n\tif (!openTag) return null\n\tconst attr = (name: string): string | null =>\n\t\tnew RegExp(`\\\\b${name}\\\\s*=\\\\s*[\"']([^\"']*)[\"']`, 'i').exec(openTag)?.[1] ?? null\n\t// Leading number with an optional absolute unit; a percentage is not an intrinsic length.\n\tconst absLength = (val: string | null): number => {\n\t\tif (val == null || /%\\s*$/.test(val)) return NaN\n\t\tconst m = /^\\s*\\+?(\\d*\\.?\\d+)/.exec(val)\n\t\treturn m ? parseFloat(m[1] ?? '') : NaN\n\t}\n\tlet w = absLength(attr('width'))\n\tlet h = absLength(attr('height'))\n\tif (!(w > 0 && h > 0)) {\n\t\tconst vb = attr('viewBox')\n\t\tconst p = vb\n\t\t\t? vb\n\t\t\t\t\t.trim()\n\t\t\t\t\t.split(/[\\s,]+/)\n\t\t\t\t\t.map(Number)\n\t\t\t: []\n\t\tconst vw = p[2]\n\t\tconst vh = p[3]\n\t\tif (p.length === 4 && vw != null && vh != null && vw > 0 && vh > 0) {\n\t\t\tw = vw\n\t\t\th = vh\n\t\t}\n\t}\n\treturn w > 0 && h > 0 ? { w, h } : null\n}\n\n/** Decode UTF-8 bytes to a string, isomorphic across Node and browsers. */\nfunction utf8Decode(bytes: Uint8Array): string {\n\treturn new TextDecoder().decode(bytes)\n}\n","/**\n * OPC relationship type URIs, and the two schema-URI bases they are built from.\n *\n * These are long, near-identical strings that differ in one path segment, which makes a typo\n * both easy to write and invisible on review — a wrong URI does not throw, it silently matches\n * nothing on the read side and produces a part PowerPoint ignores or rejects on the write side.\n *\n * **Why this module is neither `gen/` nor `read/`.** Both halves need the same URIs, and for a\n * while each kept its own copy (`gen/oxml/schema-uris.ts`, `read/api/rel-types.ts`), with a note\n * in both saying a shared home was \"a separate decision\". It is this module: a rel type is a fact\n * about the OOXML package format, not about writing or reading one, so neither side should own it.\n * A divergence between the two copies would mean the writer emitting a rel the reader cannot find\n * — a round-trip bug with no compile-time signal.\n *\n * Only types used by more than one module live here. A rel type exactly one module cares about\n * (`chart`, `hyperlink`, `tags`, the two comments parts, `oleObject`, the MS media rels, …) stays\n * declared next to the code that reads or emits it — hoisting those would trade a definition you\n * can see for one you have to go and find, and buy nothing.\n */\n\n/** Root of every ECMA-376 schema URI. Private: callers want one of the prefixes below. */\nconst SCHEMA_BASE = 'http://schemas.openxmlformats.org/'\n\n/**\n * Prefix for `.rels` `Type` URIs — append the type name (`slide`, `image`, `theme`, …).\n * Exported for the write side, which builds one-off rel types at their call sites.\n */\nexport const OFFICE_REL = SCHEMA_BASE + 'officeDocument/2006/relationships/'\n\n/** `xmlns` of every `<Relationships>` part. Also the prefix of the package-scoped rel types. */\nexport const PACKAGE_REL_NS = SCHEMA_BASE + 'package/2006/relationships'\n\n/** `p:sldIdLst` → a slide part. */\nexport const SLIDE_REL = OFFICE_REL + 'slide'\n/** A slide → its layout; a master → each of its layouts. */\nexport const SLIDE_LAYOUT_REL = OFFICE_REL + 'slideLayout'\n/** A layout → its master; the presentation → each master. */\nexport const SLIDE_MASTER_REL = OFFICE_REL + 'slideMaster'\n/** A slide → its notes slide. */\nexport const NOTES_SLIDE_REL = OFFICE_REL + 'notesSlide'\n/** A notes slide → the notes master; the presentation → the notes master. */\nexport const NOTES_MASTER_REL = OFFICE_REL + 'notesMaster'\n/** A master or notes master → its theme. Layouts and slides inherit it rather than holding one. */\nexport const THEME_REL = OFFICE_REL + 'theme'\n/** The package root → `ppt/presentation.xml`. The entry point to everything above. */\nexport const OFFICE_DOCUMENT_REL = OFFICE_REL + 'officeDocument'\n/** Any part → an image in `ppt/media/`. */\nexport const IMAGE_REL = OFFICE_REL + 'image'\n","/**\n * Validating a value against an `ST_` enumeration, under the two policies the library uses.\n *\n * **Why validate at all.** A value outside its `ST_` union makes the containing part\n * schema-invalid, and PowerPoint reports that as a *corrupt file* rather than as a mis-set\n * option — so the cost of letting one through is a deck that will not open, attributed to\n * nothing in particular. Both halves therefore check before a value reaches the XML.\n *\n * **Why two policies.** They differ deliberately, and the difference is about where the value\n * came from:\n *\n * - {@link checkEnumOrWarn} (write path) reports and **drops** the attribute, leaving the\n *   renderer on the schema default. An option here comes from a deck being built, and losing one\n *   attribute is better than failing an entire build over it.\n * - {@link checkEnumOrThrow} (read/edit path) **throws**. A value here comes from a caller\n *   editing one attribute of a loaded deck, so silently doing nothing would leave them looking at\n *   an unchanged file with no explanation.\n *\n * Before this module the two policies were spread across three near-identical private validators\n * (two in `gen/`, one in `read/`), each with its own wording; adding an enum meant writing a\n * fourth. The policy split is worth keeping — the triplication was not.\n */\n\nimport type { DiagnosticCode, InvalidOptionErrorCode } from '../codes.js'\nimport { warnOnce } from '../diagnostics.js'\nimport { InvalidOptionError } from '../errors.js'\n\n/**\n * Check a value against its `ST_` union, reporting and dropping it when outside (the write-path\n * policy — see the module note).\n *\n * `undefined`/`null` returns `null` without reporting: an unset option is not an invalid one, and\n * it is by far the common case.\n *\n * The offending value is interpolated into the message deliberately. {@link warnOnce} dedups on\n * code **and** message, so keeping the value in the text is what lets a second, *different* bad\n * value under the same code still get reported.\n * @param value - the value the caller supplied, if any\n * @param valid - the enum's members\n * @param code - the condition to report\n * @param label - how to name the offending option in the message, e.g. ``'table cell: cell3D `preset`'``\n * @param detail - extra structured context to merge into the diagnostic's `detail`\n * @returns the value when legal, else `null`\n */\nexport function checkEnumOrWarn<T extends string>(\n\tvalue: string | undefined | null,\n\tvalid: readonly T[],\n\tcode: DiagnosticCode,\n\tlabel: string,\n\tdetail?: Readonly<Record<string, unknown>>\n): T | null {\n\tif (value === undefined || value === null) return null\n\tif ((valid as readonly string[]).includes(value)) return value as T\n\twarnOnce(code, `${label} value \\`${String(value)}\\` is not valid and is ignored — use one of ${valid.join(', ')}.`, {\n\t\treceived: value,\n\t\tvalid,\n\t\t...detail,\n\t})\n\treturn null\n}\n\n/**\n * Check a value against its `ST_` union, throwing when outside (the read/edit-path policy — see\n * the module note).\n * @param value - the value the caller asked for\n * @param valid - the enum's members\n * @param attribute - the attribute's name, for the message\n * @param code - the condition to report\n * @returns `value`, when it is legal\n */\nexport function checkEnumOrThrow<T extends string>(\n\tvalue: string,\n\tvalid: readonly T[],\n\tattribute: string,\n\tcode: InvalidOptionErrorCode\n): T {\n\tif ((valid as readonly string[]).includes(value)) return value as T\n\tthrow new InvalidOptionError(\n\t\tcode,\n\t\t`Invalid ${attribute}: ${JSON.stringify(value)}. Expected one of: ${valid.join(', ')}.`\n\t)\n}\n","/**\n * `ST_` simple-type enumerations from ECMA-376, declared once as the single source of both the\n * TypeScript union a caller is checked against and the runtime list a value is validated against.\n *\n * **The problem this solves.** Each of these used to exist twice: a hand-written string union in\n * `src/types/` (what the compiler enforces) and a hand-written array in `src/gen/` or `src/read/`\n * (what the validator checks at run time). Nothing tied the two together, so adding a member to\n * one and not the other produced either a value TypeScript accepts and the validator drops, or a\n * value the validator passes and the type rejects. Two of them had already diverged in *order*,\n * which is harmless, but nothing would have caught a divergence in *content*.\n *\n * **The shape.** Every entry is a `readonly` tuple declared `as const`, with its union derived via\n * `(typeof X)[number]`. Widening the tuple widens the union in the same edit — they cannot drift.\n * This is the idiom already used for `EMBEDDED_FONT_SLOTS` and `EXTRA_SHAPE_PRESETS`; this module\n * brings the stragglers onto it.\n *\n * **Why this module is neither `gen/` nor `read/`.** `src/types/` needs the unions for the public\n * write API, `src/gen/` needs the tuples to vet a value before emitting it, and `src/read/` needs\n * them to vet a value before writing it into a loaded part. It is a fact about the schema, so it\n * belongs to none of the three.\n *\n * Values are listed in **schema declaration order**, which is the order the diagnostics print\n * when they tell a caller what is legal.\n */\n\n/**\n * `ST_BevelPresetType` — the bevel profile applied to a 3-D edge.\n * @see ECMA-376 Part 1 §20.1.10.9\n */\nexport const BEVEL_PRESETS = [\n\t'relaxedInset',\n\t'circle',\n\t'slope',\n\t'cross',\n\t'angle',\n\t'softRound',\n\t'convex',\n\t'coolSlant',\n\t'divot',\n\t'riblet',\n\t'hardEdge',\n\t'artDeco',\n] as const\nexport type BevelPresetType = (typeof BEVEL_PRESETS)[number]\n\n/**\n * `ST_PresetMaterialType` — how a 3-D surface responds to light.\n * @see ECMA-376 Part 1 §20.1.10.50\n */\nexport const PRESET_MATERIALS = [\n\t'legacyMatte',\n\t'legacyPlastic',\n\t'legacyMetal',\n\t'legacyWireframe',\n\t'matte',\n\t'plastic',\n\t'metal',\n\t'warmMatte',\n\t'translucentPowder',\n\t'powder',\n\t'dkEdge',\n\t'softEdge',\n\t'clear',\n\t'flat',\n\t'softmetal',\n] as const\nexport type PresetMaterialType = (typeof PRESET_MATERIALS)[number]\n\n/**\n * `ST_LightRigType` — the preset lighting scene.\n * @see ECMA-376 Part 1 §20.1.10.35\n */\nexport const LIGHT_RIGS = [\n\t'legacyFlat1',\n\t'legacyFlat2',\n\t'legacyFlat3',\n\t'legacyFlat4',\n\t'legacyNormal1',\n\t'legacyNormal2',\n\t'legacyNormal3',\n\t'legacyNormal4',\n\t'legacyHarsh1',\n\t'legacyHarsh2',\n\t'legacyHarsh3',\n\t'legacyHarsh4',\n\t'threePt',\n\t'balanced',\n\t'soft',\n\t'harsh',\n\t'flood',\n\t'contrasting',\n\t'morning',\n\t'sunrise',\n\t'sunset',\n\t'chilly',\n\t'freezing',\n\t'flat',\n\t'twoPt',\n\t'glow',\n\t'brightRoom',\n] as const\nexport type LightRigType = (typeof LIGHT_RIGS)[number]\n\n/**\n * `ST_LightRigDirection` — where the light rig sits relative to the scene.\n * @see ECMA-376 Part 1 §20.1.10.33\n */\nexport const LIGHT_RIG_DIRECTIONS = ['tl', 't', 'tr', 'l', 'r', 'bl', 'b', 'br'] as const\nexport type LightRigDirection = (typeof LIGHT_RIG_DIRECTIONS)[number]\n\n/**\n * `ST_TextHorzOverflowType` — `a:bodyPr/@horzOverflow` and `a:tcPr/@horzOverflow`.\n * @see ECMA-376 Part 1 §20.1.10.68\n */\nexport const TEXT_HORZ_OVERFLOW = ['clip', 'overflow'] as const\nexport type TextHorzOverflowType = (typeof TEXT_HORZ_OVERFLOW)[number]\n\n/**\n * `ST_TextAnchoringType` — `a:bodyPr/@anchor` and `a:tcPr/@anchor`.\n * @see ECMA-376 Part 1 §20.1.10.60\n */\nexport const TEXT_ANCHORS = ['t', 'ctr', 'b', 'just', 'dist'] as const\nexport type TextAnchoringType = (typeof TEXT_ANCHORS)[number]\n\n/**\n * `ST_TextVerticalType` — `a:bodyPr/@vert` and `a:tcPr/@vert`.\n * @see ECMA-376 Part 1 §20.1.10.83\n */\nexport const TEXT_VERTICAL = [\n\t'horz',\n\t'vert',\n\t'vert270',\n\t'wordArtVert',\n\t'eaVert',\n\t'mongolianVert',\n\t'wordArtVertRtl',\n] as const\nexport type TextVerticalType = (typeof TEXT_VERTICAL)[number]\n\n/**\n * `ST_PresetLineDashVal` — the dash pattern of a line or border (`a:prstDash/@val`).\n *\n * The `sys*` members are the \"system\" dashes whose exact dot/gap ratio the renderer picks; the\n * rest are defined by the spec. Both `BorderProps.dashType` and `ShapeLineProps.dashType` accept\n * this whole set, so a caller who knows one knows the other.\n * @see ECMA-376 Part 1 §20.1.10.49\n */\nexport const PRESET_LINE_DASHES = [\n\t'solid',\n\t'dot',\n\t'dash',\n\t'lgDash',\n\t'dashDot',\n\t'lgDashDot',\n\t'lgDashDotDot',\n\t'sysDash',\n\t'sysDot',\n\t'sysDashDot',\n\t'sysDashDotDot',\n] as const\nexport type PresetLineDashVal = (typeof PRESET_LINE_DASHES)[number]\n"],"mappings":"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"}
+{"version":3,"file":"st-enums-bVnezkMJ.js","names":[],"sources":["../src/media/base64.ts","../src/media/image-size.ts","../src/ooxml/rel-types.ts","../src/ooxml/check-enum.ts","../src/ooxml/st-enums.ts"],"sourcesContent":["/**\n * Base64 payload handling for media parts — isomorphic across Node and browsers\n * (`TextEncoder`/`atob`/`btoa` only, no `Buffer`).\n */\n\n/**\n * Encode raw SVG markup as a base64 `image/svg+xml` data URI.\n * - lets callers pass inline SVG to `addImage({ svg })` without hand-rolling base64\n * - isomorphic and UTF-8 safe: uses the global `TextEncoder`/`btoa` (Node and browsers)\n * @param {string} svg - SVG markup, e.g. `'<svg ...>...</svg>'`\n * @returns {string} a `data:image/svg+xml;base64,...` URI\n */\nexport function svgMarkupToDataUri(svg: string): string {\n\treturn `data:image/svg+xml;base64,${bytesToBase64(new TextEncoder().encode(svg))}`\n}\n\n/**\n * Encode raw bytes as base64 (no `data:` prefix) using only `btoa`, so the result is the same\n * on Node, in a browser, and in a runtime that has neither `Buffer` nor `FileReader`.\n *\n * Chunked because `String.fromCharCode(...spread)` blows the argument-count limit on a payload\n * of any real size — a multi-megabyte video rel would throw rather than encode.\n * @param {Uint8Array} bytes - the payload\n * @returns {string} base64 text\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n\tconst CHUNK = 0x8000\n\tlet binary = ''\n\tfor (let i = 0; i < bytes.length; i += CHUNK) binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK))\n\treturn btoa(binary)\n}\n\n/**\n * Decode a base64 image payload (raw base64 or a `data:` URI) to bytes.\n * - tolerant of the `data:[mime];base64,` prefix and of whitespace in the payload\n * @param {string} b64 - base64 string or data URI\n * @returns {Uint8Array | null} decoded bytes, or `null` when the payload is empty/undecodable\n */\nexport function decodeBase64ToBytes(b64: string): Uint8Array | null {\n\tif (!b64) return null\n\t// Strip any `data:...;base64,` prefix and surrounding whitespace\n\tconst comma = b64.indexOf('base64,')\n\tconst payload = (comma >= 0 ? b64.slice(comma + 'base64,'.length) : b64).replace(/\\s/g, '')\n\tif (!payload) return null\n\ttry {\n\t\tconst binary = atob(payload)\n\t\tconst bytes = new Uint8Array(binary.length)\n\t\tfor (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)\n\t\treturn bytes\n\t} catch {\n\t\treturn null\n\t}\n}\n","/**\n * Intrinsic image geometry: reading a natural pixel size out of header bytes, and the\n * `<a:srcRect>` crop math that fits that natural size into a display box.\n *\n * Shared by both sides of the library — the write path (`addImage({ sizing })`) and the read\n * API's `Picture.setImage({ fit })` — which is why it lives outside `gen/` and `read/`.\n * Everything here is synchronous and pure: headers only, never pixel decoding.\n */\n\nimport { decodeBase64ToBytes } from './base64.js'\n\n/**\n * Read the intrinsic dimensions of an image from its header bytes.\n * - synchronous: parses only file-format headers, never decodes pixels\n * - raster: PNG, JPEG, GIF, BMP, and WebP (VP8 / VP8L / VP8X) — natural pixels\n * - vector: SVG — intrinsic size from the root `<svg>` width/height or viewBox\n * - unrecognized formats return `null` (no measurable intrinsic size)\n *\n * Used by image `sizing: 'cover' | 'contain'` to compute an aspect-correct\n * `<a:srcRect>` crop from the *natural* image ratio rather than the displayed box.\n * @param {string} dataB64 - base64 image payload or `data:` URI\n * @returns {{ w: number, h: number } | null} natural size, or `null` when unmeasurable\n */\nexport function getImageSizeFromBase64(dataB64: string): { w: number; h: number } | null {\n\tconst b = decodeBase64ToBytes(dataB64)\n\treturn b ? getImageSizeFromBytes(b) : null\n}\n\n/**\n * Read the intrinsic dimensions of an image from raw header bytes — the\n * byte-level core shared by {@link getImageSizeFromBase64} and the read API's\n * `Picture.setImage({ fit })`, which already holds the media bytes.\n * @param {Uint8Array} b - image bytes\n * @returns {{ w: number, h: number } | null} natural size, or `null` when unmeasurable\n */\nexport function getImageSizeFromBytes(b: Uint8Array): { w: number; h: number } | null {\n\tif (!b || b.length < 24) return null\n\n\t// Bounds-checked byte read: every access below is already guarded by an\n\t// explicit length check, so the `?? 0` fallback is unreachable in practice.\n\tconst u = (n: number): number => b[n] ?? 0\n\n\t// PNG: 8-byte signature, then IHDR with width@16 / height@20 (big-endian uint32)\n\tif (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) {\n\t\tconst w = (u(16) << 24) | (u(17) << 16) | (u(18) << 8) | u(19)\n\t\tconst h = (u(20) << 24) | (u(21) << 16) | (u(22) << 8) | u(23)\n\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t}\n\n\t// GIF: \"GIF87a\"/\"GIF89a\", width@6 / height@8 (little-endian uint16)\n\tif (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46) {\n\t\tconst w = u(6) | (u(7) << 8)\n\t\tconst h = u(8) | (u(9) << 8)\n\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t}\n\n\t// BMP: \"BM\", width@18 / height@22 (little-endian int32; height may be negative for top-down)\n\tif (b[0] === 0x42 && b[1] === 0x4d) {\n\t\tconst w = u(18) | (u(19) << 8) | (u(20) << 16) | (u(21) << 24)\n\t\tconst h = u(22) | (u(23) << 8) | (u(24) << 16) | (u(25) << 24)\n\t\tconst aw = Math.abs(w)\n\t\tconst ah = Math.abs(h)\n\t\treturn aw > 0 && ah > 0 ? { w: aw, h: ah } : null\n\t}\n\n\t// WebP: \"RIFF\"....\"WEBP\" then a VP8 / VP8L / VP8X chunk\n\tif (\n\t\tb[0] === 0x52 &&\n\t\tb[1] === 0x49 &&\n\t\tb[2] === 0x46 &&\n\t\tb[3] === 0x46 &&\n\t\tb[8] === 0x57 &&\n\t\tb[9] === 0x45 &&\n\t\tb[10] === 0x42 &&\n\t\tb[11] === 0x50\n\t) {\n\t\tconst fourCC = String.fromCharCode(u(12), u(13), u(14), u(15))\n\t\tif (fourCC === 'VP8 ' && b.length >= 30) {\n\t\t\t// Lossy: 14-bit width/height at offset 26/28 (little-endian, mask off scale bits)\n\t\t\tconst w = (u(26) | (u(27) << 8)) & 0x3fff\n\t\t\tconst h = (u(28) | (u(29) << 8)) & 0x3fff\n\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t}\n\t\tif (fourCC === 'VP8L' && b.length >= 25) {\n\t\t\t// Lossless: 14-bit width/height packed starting at bit 0 of offset 21\n\t\t\tconst bits = u(21) | (u(22) << 8) | (u(23) << 16) | (u(24) << 24)\n\t\t\tconst w = (bits & 0x3fff) + 1\n\t\t\tconst h = ((bits >> 14) & 0x3fff) + 1\n\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t}\n\t\tif (fourCC === 'VP8X' && b.length >= 30) {\n\t\t\t// Extended: 24-bit canvas width/height minus one at offset 24/27 (little-endian)\n\t\t\tconst w = (u(24) | (u(25) << 8) | (u(26) << 16)) + 1\n\t\t\tconst h = (u(27) | (u(28) << 8) | (u(29) << 16)) + 1\n\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t}\n\t\treturn null\n\t}\n\n\t// JPEG: \"FFD8\", scan segment markers for a Start-Of-Frame (SOFn) and read height@5 / width@7\n\tif (b[0] === 0xff && b[1] === 0xd8) {\n\t\tlet i = 2\n\t\twhile (i + 9 < b.length) {\n\t\t\tif (b[i] !== 0xff) {\n\t\t\t\ti++\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst marker = u(i + 1)\n\t\t\t// SOF0..SOF15 carry frame dimensions, excluding DHT(C4)/JPG(C8)/DAC(CC)\n\t\t\tif (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {\n\t\t\t\tconst h = (u(i + 5) << 8) | u(i + 6)\n\t\t\t\tconst w = (u(i + 7) << 8) | u(i + 8)\n\t\t\t\treturn w > 0 && h > 0 ? { w, h } : null\n\t\t\t}\n\t\t\t// Standalone markers (RSTn / SOI / EOI / TEM) have no length payload\n\t\t\tif ((marker >= 0xd0 && marker <= 0xd9) || marker === 0x01) {\n\t\t\t\ti += 2\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\t// Otherwise skip this segment using its 2-byte big-endian length\n\t\t\tconst segLen = (u(i + 2) << 8) | u(i + 3)\n\t\t\tif (segLen < 2) break\n\t\t\ti += 2 + segLen\n\t\t}\n\t\treturn null\n\t}\n\n\t// SVG: text-based vector with no binary signature. When the payload is an\n\t// `<svg>` document, read its intrinsic size from the root element so that\n\t// `sizing: 'cover' | 'contain'` is aspect-correct for SVG, not just rasters.\n\tconst text = utf8Decode(b)\n\tif (/<svg[\\s>]/i.test(text)) return getSvgSizeFromMarkup(text)\n\n\treturn null\n}\n\n/**\n * Compute the `<a:srcRect>` crop percentages (each in 1/1000 of a percent, the\n * OOXML unit) for fitting an image of natural size `img` into a display `box`,\n * assuming the cropped region is then stretched to fill the box (`<a:stretch>`).\n *\n * - `cover`: fill the box, cropping the overflowing axis (positive l/r or t/b)\n * - `contain`: fit inside the box, letterboxing the short axis (negative l/r or t/b)\n *\n * Single source of truth for the crop math shared by the write side\n * (`ImageSizingXml`) and the read API's `Picture.setImage({ fit })`. `l`/`r` and\n * `t`/`b` are symmetric (centered crop).\n * @param {'cover' | 'contain'} type - fit mode\n * @param {{ w: number, h: number }} img - natural image pixel size\n * @param {{ w: number, h: number }} box - displayed frame size (any consistent unit)\n * @returns {{ l: number, r: number, t: number, b: number }} srcRect percentages\n */\nexport function fitSrcRectPercents(\n\ttype: 'cover' | 'contain',\n\timg: { w: number; h: number },\n\tbox: { w: number; h: number }\n): { l: number; r: number; t: number; b: number } {\n\tconst imgRatio = img.h / img.w\n\tconst boxRatio = box.h / box.w\n\tlet width: number\n\tlet height: number\n\tif (type === 'cover') {\n\t\tconst isBoxBased = boxRatio > imgRatio\n\t\twidth = isBoxBased ? box.h / imgRatio : box.w\n\t\theight = isBoxBased ? box.h : box.w * imgRatio\n\t} else {\n\t\tconst widthBased = boxRatio > imgRatio\n\t\twidth = widthBased ? box.w : box.h / imgRatio\n\t\theight = widthBased ? box.w * imgRatio : box.h\n\t}\n\tconst hz = Math.round(1e5 * 0.5 * (1 - box.w / width))\n\tconst vz = Math.round(1e5 * 0.5 * (1 - box.h / height))\n\treturn { l: hz, r: hz, t: vz, b: vz }\n}\n\n/**\n * Read the intrinsic size of an SVG document from its root `<svg>` element.\n * Follows the SVG sizing model: an explicit absolute `width`/`height` pair wins;\n * otherwise the `viewBox` width/height defines the size (and thus aspect ratio).\n * Percentage or missing `width`/`height` fall through to `viewBox`.\n * @param {string} svg - SVG markup\n * @returns {{ w: number, h: number } | null} intrinsic size, or `null` when undeterminable\n */\nfunction getSvgSizeFromMarkup(svg: string): { w: number; h: number } | null {\n\tconst openTag = /<svg\\b[^>]*>/i.exec(svg)?.[0]\n\tif (!openTag) return null\n\tconst attr = (name: string): string | null =>\n\t\tnew RegExp(`\\\\b${name}\\\\s*=\\\\s*[\"']([^\"']*)[\"']`, 'i').exec(openTag)?.[1] ?? null\n\t// Leading number with an optional absolute unit; a percentage is not an intrinsic length.\n\tconst absLength = (val: string | null): number => {\n\t\tif (val == null || /%\\s*$/.test(val)) return NaN\n\t\tconst m = /^\\s*\\+?(\\d*\\.?\\d+)/.exec(val)\n\t\treturn m ? parseFloat(m[1] ?? '') : NaN\n\t}\n\tlet w = absLength(attr('width'))\n\tlet h = absLength(attr('height'))\n\tif (!(w > 0 && h > 0)) {\n\t\tconst vb = attr('viewBox')\n\t\tconst p = vb\n\t\t\t? vb\n\t\t\t\t\t.trim()\n\t\t\t\t\t.split(/[\\s,]+/)\n\t\t\t\t\t.map(Number)\n\t\t\t: []\n\t\tconst vw = p[2]\n\t\tconst vh = p[3]\n\t\tif (p.length === 4 && vw != null && vh != null && vw > 0 && vh > 0) {\n\t\t\tw = vw\n\t\t\th = vh\n\t\t}\n\t}\n\treturn w > 0 && h > 0 ? { w, h } : null\n}\n\n/** Decode UTF-8 bytes to a string, isomorphic across Node and browsers. */\nfunction utf8Decode(bytes: Uint8Array): string {\n\treturn new TextDecoder().decode(bytes)\n}\n","/**\n * OPC relationship type URIs, and the two schema-URI bases they are built from.\n *\n * These are long, near-identical strings that differ in one path segment, which makes a typo\n * both easy to write and invisible on review — a wrong URI does not throw, it silently matches\n * nothing on the read side and produces a part PowerPoint ignores or rejects on the write side.\n *\n * **Why this module is neither `gen/` nor `read/`.** Both halves need the same URIs, and for a\n * while each kept its own copy (`gen/oxml/schema-uris.ts`, `read/api/rel-types.ts`), with a note\n * in both saying a shared home was \"a separate decision\". It is this module: a rel type is a fact\n * about the OOXML package format, not about writing or reading one, so neither side should own it.\n * A divergence between the two copies would mean the writer emitting a rel the reader cannot find\n * — a round-trip bug with no compile-time signal.\n *\n * Only types used by more than one module live here. A rel type exactly one module cares about\n * (`chart`, `hyperlink`, `tags`, the two comments parts, `oleObject`, the MS media rels, …) stays\n * declared next to the code that reads or emits it — hoisting those would trade a definition you\n * can see for one you have to go and find, and buy nothing.\n */\n\n/** Root of every ECMA-376 schema URI. Private: callers want one of the prefixes below. */\nconst SCHEMA_BASE = 'http://schemas.openxmlformats.org/'\n\n/**\n * Prefix for `.rels` `Type` URIs — append the type name (`slide`, `image`, `theme`, …).\n * Exported for the write side, which builds one-off rel types at their call sites.\n */\nexport const OFFICE_REL = SCHEMA_BASE + 'officeDocument/2006/relationships/'\n\n/** `xmlns` of every `<Relationships>` part. Also the prefix of the package-scoped rel types. */\nexport const PACKAGE_REL_NS = SCHEMA_BASE + 'package/2006/relationships'\n\n/** `p:sldIdLst` → a slide part. */\nexport const SLIDE_REL = OFFICE_REL + 'slide'\n/** A slide → its layout; a master → each of its layouts. */\nexport const SLIDE_LAYOUT_REL = OFFICE_REL + 'slideLayout'\n/** A layout → its master; the presentation → each master. */\nexport const SLIDE_MASTER_REL = OFFICE_REL + 'slideMaster'\n/** A slide → its notes slide. */\nexport const NOTES_SLIDE_REL = OFFICE_REL + 'notesSlide'\n/** A notes slide → the notes master; the presentation → the notes master. */\nexport const NOTES_MASTER_REL = OFFICE_REL + 'notesMaster'\n/** A master or notes master → its theme. Layouts and slides inherit it rather than holding one. */\nexport const THEME_REL = OFFICE_REL + 'theme'\n/** The package root → `ppt/presentation.xml`. The entry point to everything above. */\nexport const OFFICE_DOCUMENT_REL = OFFICE_REL + 'officeDocument'\n/** Any part → an image in `ppt/media/`. */\nexport const IMAGE_REL = OFFICE_REL + 'image'\n","/**\n * Validating a value against an `ST_` enumeration, under the two policies the library uses.\n *\n * **Why validate at all.** A value outside its `ST_` union makes the containing part\n * schema-invalid, and PowerPoint reports that as a *corrupt file* rather than as a mis-set\n * option — so the cost of letting one through is a deck that will not open, attributed to\n * nothing in particular. Both halves therefore check before a value reaches the XML.\n *\n * **Why two policies.** They differ deliberately, and the difference is about where the value\n * came from:\n *\n * - {@link checkEnumOrWarn} (write path) reports and **drops** the attribute, leaving the\n *   renderer on the schema default. An option here comes from a deck being built, and losing one\n *   attribute is better than failing an entire build over it.\n * - {@link checkEnumOrThrow} (read/edit path) **throws**. A value here comes from a caller\n *   editing one attribute of a loaded deck, so silently doing nothing would leave them looking at\n *   an unchanged file with no explanation.\n *\n * Before this module the two policies were spread across three near-identical private validators\n * (two in `gen/`, one in `read/`), each with its own wording; adding an enum meant writing a\n * fourth. The policy split is worth keeping — the triplication was not.\n */\n\nimport type { DiagnosticCode, InvalidOptionErrorCode } from '../codes.js'\nimport { warnOnce } from '../diagnostics.js'\nimport { InvalidOptionError } from '../errors.js'\n\n/**\n * Check a value against its `ST_` union, reporting and dropping it when outside (the write-path\n * policy — see the module note).\n *\n * `undefined`/`null` returns `null` without reporting: an unset option is not an invalid one, and\n * it is by far the common case.\n *\n * The offending value is interpolated into the message deliberately. {@link warnOnce} dedups on\n * code **and** message, so keeping the value in the text is what lets a second, *different* bad\n * value under the same code still get reported.\n * @param value - the value the caller supplied, if any\n * @param valid - the enum's members\n * @param code - the condition to report\n * @param label - how to name the offending option in the message, e.g. ``'table cell: cell3D `preset`'``\n * @param detail - extra structured context to merge into the diagnostic's `detail`\n * @returns the value when legal, else `null`\n */\nexport function checkEnumOrWarn<T extends string>(\n\tvalue: string | undefined | null,\n\tvalid: readonly T[],\n\tcode: DiagnosticCode,\n\tlabel: string,\n\tdetail?: Readonly<Record<string, unknown>>\n): T | null {\n\tif (value === undefined || value === null) return null\n\tif ((valid as readonly string[]).includes(value)) return value as T\n\twarnOnce(code, `${label} value \\`${String(value)}\\` is not valid and is ignored — use one of ${valid.join(', ')}.`, {\n\t\treceived: value,\n\t\tvalid,\n\t\t...detail,\n\t})\n\treturn null\n}\n\n/**\n * Check a value against its `ST_` union, throwing when outside (the read/edit-path policy — see\n * the module note).\n * @param value - the value the caller asked for\n * @param valid - the enum's members\n * @param attribute - the attribute's name, for the message\n * @param code - the condition to report\n * @returns `value`, when it is legal\n */\nexport function checkEnumOrThrow<T extends string>(\n\tvalue: string,\n\tvalid: readonly T[],\n\tattribute: string,\n\tcode: InvalidOptionErrorCode\n): T {\n\tif ((valid as readonly string[]).includes(value)) return value as T\n\tthrow new InvalidOptionError(\n\t\tcode,\n\t\t`Invalid ${attribute}: ${JSON.stringify(value)}. Expected one of: ${valid.join(', ')}.`\n\t)\n}\n","/**\n * `ST_` simple-type enumerations from ECMA-376, declared once as the single source of both the\n * TypeScript union a caller is checked against and the runtime list a value is validated against.\n *\n * **The problem this solves.** Each of these used to exist twice: a hand-written string union in\n * `src/types/` (what the compiler enforces) and a hand-written array in `src/gen/` or `src/read/`\n * (what the validator checks at run time). Nothing tied the two together, so adding a member to\n * one and not the other produced either a value TypeScript accepts and the validator drops, or a\n * value the validator passes and the type rejects. Two of them had already diverged in *order*,\n * which is harmless, but nothing would have caught a divergence in *content*.\n *\n * **The shape.** Every entry is a `readonly` tuple declared `as const`, with its union derived via\n * `(typeof X)[number]`. Widening the tuple widens the union in the same edit — they cannot drift.\n * This is the idiom already used for `EMBEDDED_FONT_SLOTS` and `EXTRA_SHAPE_PRESETS`; this module\n * brings the stragglers onto it.\n *\n * **Why this module is neither `gen/` nor `read/`.** `src/types/` needs the unions for the public\n * write API, `src/gen/` needs the tuples to vet a value before emitting it, and `src/read/` needs\n * them to vet a value before writing it into a loaded part. It is a fact about the schema, so it\n * belongs to none of the three.\n *\n * Values are listed in **schema declaration order**, which is the order the diagnostics print\n * when they tell a caller what is legal.\n */\n\n/**\n * `ST_BevelPresetType` — the bevel profile applied to a 3-D edge.\n * @see ECMA-376 Part 1 §20.1.10.9\n */\nexport const BEVEL_PRESETS = [\n\t'relaxedInset',\n\t'circle',\n\t'slope',\n\t'cross',\n\t'angle',\n\t'softRound',\n\t'convex',\n\t'coolSlant',\n\t'divot',\n\t'riblet',\n\t'hardEdge',\n\t'artDeco',\n] as const\nexport type BevelPresetType = (typeof BEVEL_PRESETS)[number]\n\n/**\n * `ST_PresetMaterialType` — how a 3-D surface responds to light.\n * @see ECMA-376 Part 1 §20.1.10.50\n */\nexport const PRESET_MATERIALS = [\n\t'legacyMatte',\n\t'legacyPlastic',\n\t'legacyMetal',\n\t'legacyWireframe',\n\t'matte',\n\t'plastic',\n\t'metal',\n\t'warmMatte',\n\t'translucentPowder',\n\t'powder',\n\t'dkEdge',\n\t'softEdge',\n\t'clear',\n\t'flat',\n\t'softmetal',\n] as const\nexport type PresetMaterialType = (typeof PRESET_MATERIALS)[number]\n\n/**\n * `ST_LightRigType` — the preset lighting scene.\n * @see ECMA-376 Part 1 §20.1.10.35\n */\nexport const LIGHT_RIGS = [\n\t'legacyFlat1',\n\t'legacyFlat2',\n\t'legacyFlat3',\n\t'legacyFlat4',\n\t'legacyNormal1',\n\t'legacyNormal2',\n\t'legacyNormal3',\n\t'legacyNormal4',\n\t'legacyHarsh1',\n\t'legacyHarsh2',\n\t'legacyHarsh3',\n\t'legacyHarsh4',\n\t'threePt',\n\t'balanced',\n\t'soft',\n\t'harsh',\n\t'flood',\n\t'contrasting',\n\t'morning',\n\t'sunrise',\n\t'sunset',\n\t'chilly',\n\t'freezing',\n\t'flat',\n\t'twoPt',\n\t'glow',\n\t'brightRoom',\n] as const\nexport type LightRigType = (typeof LIGHT_RIGS)[number]\n\n/**\n * `ST_LightRigDirection` — where the light rig sits relative to the scene.\n * @see ECMA-376 Part 1 §20.1.10.33\n */\nexport const LIGHT_RIG_DIRECTIONS = ['tl', 't', 'tr', 'l', 'r', 'bl', 'b', 'br'] as const\nexport type LightRigDirection = (typeof LIGHT_RIG_DIRECTIONS)[number]\n\n/**\n * `ST_TextHorzOverflowType` — `a:bodyPr/@horzOverflow` and `a:tcPr/@horzOverflow`.\n * @see ECMA-376 Part 1 §20.1.10.68\n */\nexport const TEXT_HORZ_OVERFLOW = ['clip', 'overflow'] as const\nexport type TextHorzOverflowType = (typeof TEXT_HORZ_OVERFLOW)[number]\n\n/**\n * `ST_TextAnchoringType` — `a:bodyPr/@anchor` and `a:tcPr/@anchor`.\n * @see ECMA-376 Part 1 §20.1.10.60\n */\nexport const TEXT_ANCHORS = ['t', 'ctr', 'b', 'just', 'dist'] as const\nexport type TextAnchoringType = (typeof TEXT_ANCHORS)[number]\n\n/**\n * `ST_TextVerticalType` — `a:bodyPr/@vert` and `a:tcPr/@vert`.\n * @see ECMA-376 Part 1 §20.1.10.83\n */\nexport const TEXT_VERTICAL = [\n\t'horz',\n\t'vert',\n\t'vert270',\n\t'wordArtVert',\n\t'eaVert',\n\t'mongolianVert',\n\t'wordArtVertRtl',\n] as const\nexport type TextVerticalType = (typeof TEXT_VERTICAL)[number]\n\n/**\n * `ST_PresetLineDashVal` — the dash pattern of a line or border (`a:prstDash/@val`).\n *\n * The `sys*` members are the \"system\" dashes whose exact dot/gap ratio the renderer picks; the\n * rest are defined by the spec. Both `BorderProps.dashType` and `ShapeLineProps.dashType` accept\n * this whole set, so a caller who knows one knows the other.\n * @see ECMA-376 Part 1 §20.1.10.49\n */\nexport const PRESET_LINE_DASHES = [\n\t'solid',\n\t'dot',\n\t'dash',\n\t'lgDash',\n\t'dashDot',\n\t'lgDashDot',\n\t'lgDashDotDot',\n\t'sysDash',\n\t'sysDot',\n\t'sysDashDot',\n\t'sysDashDotDot',\n] as const\nexport type PresetLineDashVal = (typeof PRESET_LINE_DASHES)[number]\n"],"mappings":"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"}