pptx-ts 4.0.1 → 4.1.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"slide-Dx2ZeVZ6.d.ts","names":[],"sources":["../src/types/table.ts","../src/types/animation.ts","../src/types/master.ts","../src/types/model3d.ts","../src/types/zoom.ts","../src/types/slide.ts"],"mappings":"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"}

package/dist/units-internal-XJlf-hOl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"units-internal-XJlf-hOl.js","names":[],"sources":["../src/ooxml/ids.ts","../src/constants-internal.ts","../src/units-internal.ts"],"sourcesContent":["/**\n * The bounds of the three id spaces `presentation.xml` numbers its parts in.\n *\n * The write path, the read model's slide and master registries, and the Slide Zoom definer each\n * spelled these as literals or as a private constant of their own. They are facts about the\n * format, so they live here once.\n *\n * Imports nothing, like the rest of `ooxml/`.\n */\n\n/** `ST_SlideId` minimum: `p:sldId/@id` starts at 256. */\nexport const MIN_SLIDE_ID = 256\n\n/** `ST_SlideId` maximum, inclusive. The schema's `maxExclusive` is 2147483648. */\nexport const MAX_SLIDE_ID = 2147483647\n\n/**\n * `ST_SlideMasterId` minimum (0x80000000). `ST_SlideLayoutId` has the same floor, and the two draw\n * from one id space that must be unique across the whole presentation.\n */\nexport const MIN_SLIDE_MASTER_ID = 2147483648\n\n/** `ST_SlideLayoutId` minimum (0x80000000): the same floor as {@link MIN_SLIDE_MASTER_ID}. */\nexport const MIN_SLIDE_LAYOUT_ID = 2147483648\n","/**\n * Generator-internal constants — the non-published half of the enums module.\n *\n * `enums.ts` holds the genuinely public surface (the `ChartType`/`ShapeType`/\n * `SchemeColor`/`AlignH`… enums, the shape-preset sets, and the `*_NAME` unions) and is\n * `export *`-ed by every entrypoint. This module holds the constants only the generators\n * need — default styling, fixed axis/field ids, colour palettes, layout bases, and the\n * base64 placeholder images — none of which are part of the public API. Splitting them out\n * keeps `export *` from leaking them onto the package surface, mirroring the\n * `units-internal.ts` / `types/internal.ts` split. Nothing here is exported from an entrypoint.\n */\n\nimport type { BorderProps, OptsChartGridLine } from './types/index.js'\nimport type { ShadowPropsInternal } from './types/internal.js'\nimport { EMU_PER_INCH, EMU_PER_POINT } from './units.js'\nimport { MIN_SLIDE_LAYOUT_ID } from './ooxml/ids.js'\nimport { TABLE_CELL_MARGIN_DEFAULTS_EMU } from './ooxml/table-cell-margins.js'\n\n// CONST\nexport const CRLF = '\\r\\n' // AKA: Chr(13) & Chr(10)\n// Base for `<p:sldLayoutId id>` (layout N gets BASE + N). One past the ST_SlideLayoutId floor,\n// where PowerPoint conventionally starts layout IDs: the floor itself is the master's id, and the\n// two share one id space. See `makeXmlMaster` in `gen/slide/master.ts`.\nexport const LAYOUT_IDX_SERIES_BASE = MIN_SLIDE_LAYOUT_ID + 1\nexport const LINEH_MODIFIER = 1.67 // AKA: Golden Ratio Typography\n\nexport const DEF_BULLET_MARGIN = 27\n// `satisfies` rather than an annotation: callers read `.type`/`.color`/`.width` off these to *fill\n// in* a side that stated none, so the constant has to be known to state them itself. Annotated as\n// `BorderProps` all three are `T | undefined`, and the fallback is not assignable to the field it\n// is the fallback for.\nexport const DEF_CELL_BORDER = { type: 'solid', color: '666666', width: 1 } as const satisfies BorderProps\n// A table cell's default margins in inches, `[top, right, bottom, left]`: the schema defaults of\n// `a:tcPr`, which are PowerPoint's \"Normal\" margins (\"Narrow\" is `0.05` for all 4). 45720/914400\n// and 91440/914400 are exactly the doubles 0.05 and 0.1.\nexport const DEF_CELL_MARGIN_IN: [number, number, number, number] = [\n\tTABLE_CELL_MARGIN_DEFAULTS_EMU.top / EMU_PER_INCH,\n\tTABLE_CELL_MARGIN_DEFAULTS_EMU.right / EMU_PER_INCH,\n\tTABLE_CELL_MARGIN_DEFAULTS_EMU.bottom / EMU_PER_INCH,\n\tTABLE_CELL_MARGIN_DEFAULTS_EMU.left / EMU_PER_INCH,\n]\n// `satisfies` for the same reason as DEF_CELL_BORDER above.\nexport const DEF_CHART_BORDER = { type: 'solid', color: '363636', width: 1 } as const satisfies BorderProps\nexport const DEF_CHART_GRIDLINE: OptsChartGridLine = { color: '888888', dashType: 'solid', width: 1, cap: 'flat' }\nexport const DEF_FONT_COLOR = '000000'\nexport const DEF_FONT_SIZE = 12\n/**\n * The bounds of `ST_TextFontSize`, in points: the smallest and largest size an `a:rPr@sz` or an\n * `a:defRPr@sz` can carry. PowerPoint reports a package outside them as needing repair.\n *\n * Here rather than beside the clamp that enforces them (`gen/drawingml/clamp.ts`) because the\n * measured-fit pass needs the minimum too, to stop shrinking a cell before it goes out of range,\n * and `measure` is a published entry point: importing the clamp module for one number pulled the\n * whole of it into that bundle. Two plain numbers inline instead, and the clamp derives its own\n * range from them, so there is still one place the bound is stated.\n */\nexport const MIN_FONT_SIZE_PT = 1\nexport const MAX_FONT_SIZE_PT = 4000\nexport const DEF_FONT_TITLE_SIZE = 18\nexport const DEF_PRES_LAYOUT = 'LAYOUT_16x9'\nexport const DEF_PRES_LAYOUT_NAME = 'DEFAULT'\nexport const DEF_SHAPE_LINE_COLOR = '333333'\nexport const DEF_SHAPE_SHADOW: ShadowPropsInternal = {\n\ttype: 'outer',\n\tblur: 3,\n\toffset: 23000 / EMU_PER_POINT,\n\tangle: 90,\n\tcolor: '000000',\n\t_alpha: 0.35,\n\trotateWithShape: true,\n}\nexport const DEF_SLIDE_MARGIN_IN: [number, number, number, number] = [0.5, 0.5, 0.5, 0.5] // TRBL-style\nexport const DEF_TEXT_SHADOW: ShadowPropsInternal = {\n\ttype: 'outer',\n\tblur: 8,\n\toffset: 4,\n\tangle: 270,\n\tcolor: '000000',\n\t_alpha: 0.75,\n}\nexport const DEF_TEXT_GLOW = { size: 8, color: 'FFFFFF', opacity: 0.75 }\n\n// Fixed `<c:axId val>` identifiers that wire each chart's axes together (e.g. a value\n// axis's `<c:crossAx>` points at its category axis by id). ECMA-376 only requires the id\n// be a unique unsigned int within the chart; these stable constants keep the emitted\n// cross-references deterministic across decks. Consumed throughout `gen/chart/`.\nexport const AXIS_ID_VALUE_PRIMARY = '2094734552'\nexport const AXIS_ID_VALUE_SECONDARY = '2094734553'\nexport const AXIS_ID_CATEGORY_PRIMARY = '2094734554'\nexport const AXIS_ID_CATEGORY_SECONDARY = '2094734555'\nexport const AXIS_ID_SERIES_PRIMARY = '2094734556'\n\nexport const LETTERS: string[] = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('')\n// The default series palettes hold their distinct entries once. Every consumer reaches them\n// through `paletteColor()` (`gen/chart/chart-parts.ts`), which wraps back to the start, so a\n// chart with more series or points than the palette has entries repeats it rather than\n// running off the end.\nexport const BARCHART_COLORS: string[] = [\n\t'C0504D',\n\t'4F81BD',\n\t'9BBB59',\n\t'8064A2',\n\t'4BACC6',\n\t'F79646',\n\t'628FC6',\n\t'C86360',\n]\nexport const PIECHART_COLORS: string[] = [\n\t'5DA5DA',\n\t'FAA43A',\n\t'60BD68',\n\t'F17CB0',\n\t'B2912F',\n\t'B276B2',\n\t'DECF3F',\n\t'F15854',\n\t'A7A7A7',\n]\n\n// Fixed GUID PowerPoint stamps on a slide-number field: `<a:fld id=\"{...}\" type=\"slidenum\">`.\n// Microsoft-specific (not defined by ECMA-376); reused verbatim so PowerPoint recognizes the\n// field and auto-updates the page number. Consumed in `gen/slide/object.ts` (`slideObjectToXml`).\nexport const SLDNUMFLDID = '{F7021451-1387-4CA6-816F-3879F97B5CBC}'\n\n// Cached text of a slide-number field on a part that has no slide number of its own — a master\n// or a layout. Guillemets around a hash, which is verbatim what PowerPoint caches there: every\n// en-US master and layout in `test/read/fixtures/` writes `<a:t>‹#›</a:t>`. (A German-locale\n// deck writes `‹Nr.›`; the cache is recomputed on open, so the en-US spelling is the one to\n// emit rather than a per-locale table.) Consumed in `gen/slide/object.ts`.\nexport const SLDNUM_PLACEHOLDER_TEXT = '‹#›'\n\n// The XML prolog every emitted OOXML part begins with. It lives in `ooxml/` so the read side's\n// serializers use the same one; re-exported for the generators that import it from here.\nexport { XML_DECL } from './ooxml/xml-decl.js'\n\n/**\n * The nine list levels' default left margins (`a:lvlNpPr/@marL`), half an inch apart.\n *\n * `p:txStyles`' body and other styles, `p:notesStyle` and the presentation's\n * `p:defaultTextStyle` are four separate ladders in the file and one ladder in fact: the\n * three modules that emit them each carried their own copy of these nine numbers, so a\n * level's margin could only be changed in one of them by accident.\n */\nexport const LEVEL_MARGINS_EMU: readonly number[] = Array.from({ length: 9 }, (_, i) => i * (EMU_PER_INCH / 2))\n\n/**\n * The paragraph-property tail every default `a:lvlNpPr` carries, whatever else it sets.\n *\n * Spread it *after* the level's own attributes: `el()` emits in `Object.entries` order, so\n * where these land in the tag is byte-significant, and every emitting site puts `marL` (and\n * where it has one, `indent` and `algn`) ahead of them.\n *\n * `algn` is deliberately not in here even though three of the four sites write `algn=\"l\"`.\n * The fourth computes it per level — a configured master's title can be centred or right —\n * and a spread that carried `algn` would silently overwrite that: a later key in an object\n * literal replaces the value without moving the key, so the attribute order would still look\n * right while the alignment was wrong. No showcase deck configures a master text style, so\n * `byte-identity` cannot see that path; `master-text-styles.test.js` pins it instead.\n */\nexport const LEVEL_PPR_TAIL = {\n\tdefTabSz: EMU_PER_INCH,\n\trtl: 0,\n\teaLnBrk: 1,\n\tlatinLnBrk: 0,\n\thangingPunct: 1,\n} as const\n","/**\n * Generator-side unit conversion — the lenient layer over `units.ts`.\n *\n * `units.ts` holds the strict, public primitives: one branded `Emu` type and converters that\n * take a number and throw on anything they cannot represent. This module holds what the\n * generators actually need on top of that: converters that accept the loose shapes the\n * authoring API has always accepted (numeric strings, `\"5in\"`, `null`), that clamp to the\n * ranges PowerPoint will load without offering to repair the file, and that warn about legacy\n * inputs instead of failing.\n *\n * The split is deliberate: the leniency and the back-compat warnings are policy, not\n * arithmetic, and policy should not be part of the published API. Nothing here is exported\n * from an entrypoint.\n */\n\nimport { DEF_CELL_MARGIN_IN, DEF_SLIDE_MARGIN_IN, LINEH_MODIFIER } from './constants-internal.js'\nimport { warn, warnOnce } from './diagnostics.js'\nimport { InvalidOptionError } from './errors.js'\nimport {\n\tEMU_PER_INCH,\n\tEMU_PER_POINT,\n\tANGLE_UNITS_PER_DEGREE,\n\tcoordToEmu,\n\tFIXED_PCT_PER_PERCENT,\n\tinchesToEmu,\n\tMAX_COORDINATE_EMU,\n\tPERCENT_SCALE,\n\ttype Emu,\n} from './units.js'\nimport type { DiagnosticCode, InvalidOptionErrorCode } from './codes.js'\nimport type { Coord, PresLayout } from './types/index.js'\n\n/**\n * Resolve a user `Coord` (x/y/w/h) to EMU — the single user-coordinate → EMU boundary.\n * - bare `number` → **inches** (no magnitude guessing); `\"<n>%\"` → percent of the slide axis;\n *   `\"<n>in\"`/`\"<n>pt\"`/`\"<n>emu\"` → explicit units (see {@link Coord} / {@link coordToEmu})\n * - `null`/`undefined` → 0 (callers may omit a coordinate)\n * - throws on a non-finite number rather than silently collapsing the object to zero size\n * @param {Coord|null|undefined} size - user coordinate\n * @param {'X' | 'Y'} xyDir - axis (selects slide width vs height for percentages)\n * @param {PresLayout} layout - presentation layout (EMU dimensions)\n * @returns {Emu} resolved EMU value\n */\nexport function getSmartParseNumber(size: Coord | null | undefined, xyDir: 'X' | 'Y', layout: PresLayout): Emu {\n\tif (size === null || size === undefined) return 0 as Emu\n\n\t// GUARD: A NaN/Infinity coordinate is always a mistake (commonly arithmetic on an\n\t// `undefined` layout dimension). Fail loud with a targeted hint instead of the generic\n\t// converter message, since this is the most common way a deck collapses to zero-size.\n\tif (typeof size === 'number' && !Number.isFinite(size)) {\n\t\tthrow new InvalidOptionError(\n\t\t\t'coord/non-finite',\n\t\t\t`Invalid ${xyDir || 'coordinate'} value: expected a finite number but received ${String(size)}. ` +\n\t\t\t\t'This usually means a layout dimension was read from a missing property (e.g. `layout.width` returning `undefined`). ' +\n\t\t\t\t'Use `slide.width`/`slide.height` or `STANDARD_LAYOUTS.<NAME>.width`/`.height` (inches).'\n\t\t)\n\t}\n\n\treturn coordToEmu(size, xyDir === 'Y' ? layout.height : layout.width)\n}\n\n/**\n * Convert inches into EMU.\n * - accepts a number (inches) or a numeric/`\"<n>in\"` string\n * - no magnitude guessing: values are always treated as inches (use {@link coordToEmu} for\n *   user coordinates that may carry other units)\n * @param {number|string} inches - inches as number or string\n * @returns {Emu} EMU value\n */\nexport function inch2Emu(inches: number | string): Emu {\n\tif (typeof inches === 'string') inches = Number(inches.replace(/in*/gi, ''))\n\treturn inchesToEmu(inches)\n}\n\n/**\n * Convert a single `margin` component (table cell/table margin, or text-box/placeholder body\n * inset) to EMU.\n *\n * Margins are INCHES, consistent with the positional API (`x`/`y`/`w`/`h`) and the value\n * PowerPoint's own dialog shows (both the table cell-margin and the text-box internal-margin\n * fields are inches). Historically the library read these as POINTS (table cells used a magnitude\n * heuristic — `>= 1` points, `< 1` inches; text-box margins were straight points), so a legitimate\n * fraction-of-an-inch value entered from the PowerPoint dialog became a tiny points value. Every\n * value is now inches. A `>= 1` value is honored as inches but warns once, because it is almost\n * certainly a legacy points value that should be divided by 72 (e.g. `10` points → `0.139` inches).\n *\n * Shared by every margin site so they stay in lockstep: the cell XML emitter and text-box/slide-\n * number insets (`gen/slide/object.ts`), the autoPage row-height pass (`gen/table/autopage.ts`), and the measured-fit pass\n * (`measure-fit`).\n * @param {number} inches - margin component in inches\n * @returns {Emu} EMU value\n */\nexport function marginToEmu(inches: number): Emu {\n\tif (inches >= 1)\n\t\twarnOnce(\n\t\t\t'margin/legacy-points',\n\t\t\t'margins (table cell and text-box) are interpreted as inches (matching the rest of the API and the ' +\n\t\t\t\t'PowerPoint dialog); a value >= 1 is likely a legacy points value — divide by 72 to convert (e.g. 10pt => 0.139in).'\n\t\t)\n\treturn inch2Emu(inches)\n}\n\n/**\n * A `[Top, Right, Bottom, Left]` margin (inches) as the four text insets in EMU, or `null` when\n * the caller stated no margin.\n *\n * A scalar broadcasts to all four sides. The index order is the whole point of naming this:\n * the arrays are CSS order while `a:bodyPr`/`a:tcPr` name their insets left-first, so every\n * site that mapped it by hand spelled the same 3/0/1/2 shuffle — the text box's `_bodyProp`,\n * the slide-number placeholder's `a:bodyPr`, and a table cell's `marL/R/T/B`.\n *\n * Each component goes through {@link marginToEmu}, so the legacy-points warning still fires\n * once for a value of an inch or more.\n * @param margin - the caller's `margin`, a scalar or a `[T, R, B, L]` array of inches\n */\nexport function resolveInsetsEmu(margin: number | number[] | undefined | null): {\n\tl: number\n\tt: number\n\tr: number\n\tb: number\n} | null {\n\tif (typeof margin === 'number') {\n\t\tconst all = marginToEmu(margin)\n\t\treturn { l: all, t: all, r: all, b: all }\n\t}\n\tif (!Array.isArray(margin)) return null\n\tconst at = (idx: number): number => marginToEmu(margin[idx] ?? 0)\n\treturn { l: at(3), t: at(0), r: at(1), b: at(2) }\n}\n\n/**\n * One line of table text, in EMU: `fontSizePt * (LINEH_MODIFIER + lineWeight) / 100`.\n *\n * The auto-pager prices a row by counting lines and multiplying by this, and the measured-fit\n * pass estimates a cell's height with the same product. Three sites wrote the expression by\n * hand and one of them left the caller's `autoPageLineWeight` out, so the pager guarded a row\n * against a line it then measured at a different height.\n *\n * @param fontSizePt - the resolved font size in points\n * @param lineWeight - the caller's `autoPageLineWeight`, an addend on the modifier\n */\nexport function autoPageLineHeightEmu(fontSizePt: number, lineWeight = 0): number {\n\treturn inch2Emu((fontSizePt * (LINEH_MODIFIER + lineWeight)) / 100)\n}\n\n/**\n * The four slide margins in inches, `[top, right, bottom, left]`, from the master's own margin\n * and the caller's `slideMargin`.\n *\n * Precedence is caller, then master, then {@link DEF_SLIDE_MARGIN_IN}. A scalar broadcasts to\n * all four sides; an array is taken as-is.\n *\n * Three sites derived this and they already disagreed. Two gated the master on\n * `typeof !== 'undefined'` and coerced with `Number.isFinite(Number(m))`; the HTML path gated\n * on truthiness and tested `Number.isFinite(m)` with no coercion. So a master with\n * `_margin: 0` took the master branch in two of them and the caller branch in the third, and\n * a master with `_margin: \"0.25\"` resolved in two and was ignored in the third.\n *\n * **The caller-first order was decided, the master-first one it replaced was not.** All three\n * pre-consolidation sites read the master first, inherited from upstream, and the consolidation\n * kept that order rather than deciding it -- so on a deck whose master defined a `margin`,\n * `addTable(rows, { slideMargin: 2 })` was discarded with nothing said, which is the reverse of\n * the rule stated everywhere else here: an explicit option beats an inherited one. The master's\n * `margin` is now the deck-wide default a per-table `slideMargin` overrides. A master margin as\n * a *floor* rather than a ceiling is a third reading, and if anyone needs it, it wants a stated\n * option rather than a precedence accident.\n *\n * @param masterMargin - the master/layout's `_margin`, in inches\n * @param slideMargin - the caller's `slideMargin`, in inches\n */\nexport function resolveSlideMarginsInches(\n\tmasterMargin: number | number[] | string | undefined | null,\n\tslideMargin?: number | number[] | string | null\n): [number, number, number, number] {\n\tconst broadcast = (value: number | number[] | string): [number, number, number, number] | null => {\n\t\tif (Array.isArray(value)) {\n\t\t\tconst [t = 0, r = 0, b = 0, l = 0] = value\n\t\t\treturn [t, r, b, l]\n\t\t}\n\t\tconst n = Number(value)\n\t\treturn Number.isFinite(n) ? [n, n, n, n] : null\n\t}\n\tif (slideMargin !== undefined && slideMargin !== null) {\n\t\tconst resolved = broadcast(slideMargin)\n\t\tif (resolved) return resolved\n\t}\n\tif (masterMargin !== undefined && masterMargin !== null) {\n\t\tconst resolved = broadcast(masterMargin)\n\t\tif (resolved) return resolved\n\t}\n\treturn [...DEF_SLIDE_MARGIN_IN]\n}\n\n/**\n * Resolve a table's column widths to EMU, the single source of truth shared by the\n * table XML emitter and the measured-fit pass (so a fitted cell sees the same grid\n * the renderer draws).\n * - an explicit `colW` **array** is per-column inches (`inch2Emu`); a non-finite slot\n *   falls back to the even-distribution width\n * - otherwise the table's already-resolved width (`totalWidthEmu`, EMU) is split evenly\n *   across `colCount` columns. (A scalar `colW` never reaches here — `addTableDefinition`\n *   converts it to `w` and clears `colW`.)\n *\n * IMPORTANT: the even path divides an **EMU** width. Passing the raw inches `options.w`\n * instead (the historical bug) produced ~0-EMU columns (e.g. `w=9` → `gridCol w=\"3\"`),\n * collapsing auto-width tables to a sliver in PowerPoint/LibreOffice.\n * @param {Coord[]|Coord|undefined} colW - explicit per-column inches, or scalar/undefined\n * @param {number} totalWidthEmu - the table's resolved width in EMU\n * @param {number} colCount - number of grid columns (counting colspans)\n * @returns {number[]} per-column widths in EMU (length `colCount`)\n */\nexport function resolveTableColWidthsEmu(\n\tcolW: Coord[] | Coord | undefined,\n\ttotalWidthEmu: number,\n\tcolCount: number\n): number[] {\n\tif (!(colCount > 0)) return []\n\tconst even = totalWidthEmu > 0 ? Math.round(totalWidthEmu / colCount) : EMU_PER_INCH\n\tif (Array.isArray(colW)) {\n\t\treturn Array.from({ length: colCount }, (_, i) => {\n\t\t\t// Guard before inch2Emu: it throws on non-finite input. A slot that is present but\n\t\t\t// unusable falls back to the even-distribution width AND says so, for the reason\n\t\t\t// `pinnedRowHeightInches` gives about the analogous `rowH` entry: it is something the\n\t\t\t// caller wrote on purpose and the even split is not what they meant. An absent slot is\n\t\t\t// not that — a sparse array is how a caller spells \"distribute this one\" — so it is\n\t\t\t// silent, which is the same line that helper draws.\n\t\t\tconst n = colW[i]\n\t\t\tif (typeof n === 'number' && Number.isFinite(n)) return Math.round(inch2Emu(n))\n\t\t\tif (n !== undefined && n !== null)\n\t\t\t\twarnOnce(\n\t\t\t\t\t'table/invalid-col-width',\n\t\t\t\t\t`colW entry ${String(n)} is not a number of inches; that column takes an even share of the table width instead.`\n\t\t\t\t)\n\t\t\treturn even\n\t\t})\n\t}\n\treturn new Array<number>(colCount).fill(even)\n}\n\n/**\n * The slide width a table may occupy, in EMU: the slide, less the table's own left\n * edge and the right slide margin.\n *\n * The width twin of the auto-pager's `calcSlideTabH`, and the same reading\n * `addTableDefinition` applies when a table states neither `w` nor `colW`. The pager\n * used to *add* the two margins here instead of subtracting them, which made its\n * fallback width about one inch however wide the slide was, and every column a sliver.\n *\n * @param presLayout - the presentation layout, for the slide width\n * @param xEmu - the table's resolved left edge in EMU; `0`/absent falls back to the left slide margin\n * @param marginsIn - the four slide margins in inches, as the pager holds them\n * @returns the usable width in EMU, never below zero\n */\nexport function usableTableWidthEmu(\n\tpresLayout: PresLayout,\n\txEmu: number,\n\tmarginsIn: readonly [number, number, number, number]\n): number {\n\t// `marginsIn` is TRBL, so the left margin is index 3 and the right one index 1. Both were\n\t// read one index off, which cancels out for a symmetric margin -- the default, and what every\n\t// gate deck sets -- and is wrong by their difference for anything else. `define/table.ts` had\n\t// already found and fixed this exact swap at its own sibling site.\n\tconst startIn = xEmu ? xEmu / EMU_PER_INCH : marginsIn[3]\n\treturn Math.max(0, presLayout.width - inch2Emu(startIn) - inch2Emu(marginsIn[1]))\n}\n\n/**\n * The single rule for whether one `rowH` entry pins a table row, in inches.\n *\n * An entry pins its row when it reads as a **finite number greater than zero**. Everything\n * else returns `null` — the row is sized from the table's own height, or grows to fit — and\n * an entry that is present but unusable warns, because `rowH: [0, …]` and `rowH: [-1, …]`\n * are things a caller wrote on purpose and none of the readings this replaced was what they\n * meant. A missing slot is not that: an array with holes is how the auto-pager spells\n * \"this row is auto-height\", so `undefined` is silent.\n *\n * Three call sites read `rowH` and they disagreed. The writer and the export-time fit pass\n * both used a truthiness test, so `0` fell through to the even split of `h`;\n * `pptx.tableLayout()` used `typeof === 'number'`, so `0` pinned the row at zero inches and\n * was then rescued by a default-line fallback — reporting 0.2in against the file's 2.0in,\n * and flagging it `heightExact`. A negative entry reached `<a:tr h=\"-914400\">`.\n *\n * @param entry - one `rowH` array slot, or the scalar `rowH`\n * @returns the pinned height in inches, or `null` when the row is not pinned by `rowH`\n */\nexport function pinnedRowHeightInches(entry: unknown): number | null {\n\tif (entry === undefined || entry === null) return null\n\tconst inches = Number(entry)\n\tif (Number.isFinite(inches) && inches > 0) return inches\n\twarnOnce(\n\t\t'table/invalid-row-height',\n\t\t`rowH entry ${String(entry)} is not a positive number of inches; the row is sized from the table height instead.`\n\t)\n\treturn null\n}\n\n/**\n * A table cell's `[Top, Right, Bottom, Left]` margins in inches, defaulted and validated.\n *\n * Three sites spelled this out -- two of them character-identical, the third self-described as\n * \"mirroring\" one of them -- and a fourth in the auto-pager gated each side on truthiness, so a\n * cell stating `margin: [0, …]` fell through to the table's margin instead of taking its own\n * zero. All of them swapped an unusable margin for the default in silence, while every sibling\n * resolver in this file warns for the same class of input.\n *\n * `resolveInsetsEmu` above is deliberately NOT a fifth copy: it resolves a text box's\n * `a:bodyPr` insets, where stating nothing means writing no attribute at all rather than\n * taking a cell default, so its absent case has a different answer.\n * @param margin - the caller's `margin`: a scalar, a `[T, R, B, L]` array, or nothing\n * @returns four finite inch measures\n */\nexport function resolveCellMarginsInches(\n\tmargin: number | number[] | undefined | null\n): [number, number, number, number] {\n\tif (margin === undefined || margin === null) return [...DEF_CELL_MARGIN_IN]\n\tconst usable = (value: unknown): boolean => typeof value === 'number' && Number.isFinite(value)\n\tif (typeof margin === 'number') {\n\t\tif (usable(margin)) return [margin, margin, margin, margin]\n\t} else if (Array.isArray(margin) && margin.length === 4 && margin.every(usable)) {\n\t\treturn [margin[0] as number, margin[1] as number, margin[2] as number, margin[3] as number]\n\t}\n\twarnOnce(\n\t\t'table/invalid-margin',\n\t\t`table margin ${JSON.stringify(margin)} is not a number of inches or a [top, right, bottom, left] array of four; using the default.`\n\t)\n\treturn [...DEF_CELL_MARGIN_IN]\n}\n\n/**\n * Resolve one table row's height to EMU — the row-height twin of\n * {@link resolveTableColWidthsEmu}, shared by the table XML emitter, the export-time\n * measured-fit pass and `pptx.tableLayout()` so a prediction cannot disagree with what the\n * export bakes.\n *\n * - a `rowH` entry that {@link pinnedRowHeightInches} accepts pins the row\n * - otherwise the table's already-resolved height (`totalHeightEmu`, EMU) is split evenly\n *   across `rowCount` rows\n * - otherwise `null`: the row is auto-height and grows to fit its content\n *\n * @param rowH - the caller's `rowH`, scalar or per-row array\n * @param rowIndex - which row is being resolved\n * @param totalHeightEmu - the table's resolved height in EMU, or 0 when it has none\n * @param rowCount - number of rows to split that height across\n * @returns the row height in EMU, or `null` for an auto-height row\n */\nexport function resolveTableRowHeightEmu(\n\trowH: number | Array<number | null> | undefined,\n\trowIndex: number,\n\ttotalHeightEmu: number,\n\trowCount: number\n): number | null {\n\tconst pinned = pinnedRowHeightInches(Array.isArray(rowH) ? rowH[rowIndex] : rowH)\n\tif (pinned !== null) return Math.round(inch2Emu(pinned))\n\treturn totalHeightEmu > 0 && rowCount > 0 ? Math.round(totalHeightEmu / rowCount) : null\n}\n\n/**\n * Convert points to EMU, leniently: anything that does not read as a finite number — a `NaN`,\n * an `Infinity`, a non-numeric string, `null` — becomes `0` rather than throwing.\n *\n * That is the whole difference from {@link pointsToEmu} in `units.ts`, which throws on the same\n * input. Emitters use this one for the many optional size/width/offset options where a missing\n * or malformed value should collapse the feature (a zero-width line, no shadow offset) rather\n * than take the whole deck down.\n *\n * @param pt - points, as a number or a numeric string\n * @returns the value in EMU, or `0` if it does not read as a finite number\n */\nexport function ptsToEmuLenient(pt: number | string): number {\n\tconst points = Number(pt)\n\treturn Number.isFinite(points) ? Math.round(points * EMU_PER_POINT) : 0\n}\n\n/**\n * `fn(value)` for a numeric option the caller stated, `undefined` for one they did not.\n *\n * `null`, `undefined` and `0` are \"not stated\": an absent option and a zero one emit the same\n * thing (no `rot` for `rotate: 0`, the default width for `width: 0`). Every other value reaches\n * `fn`, `NaN` included, so the converter behind it decides what a value it cannot represent\n * means. The same test used to be spelled as truthiness, and `NaN` is falsy: it was dropped or\n * replaced by the default before the converter could refuse it, while `Infinity` on the same\n * option threw.\n * @param value - the caller's option\n * @param fn - the conversion to apply when the option is stated\n * @returns `fn(value)`, or `undefined` when the option is not stated\n */\nexport function mapStated<T extends number | string, R>(\n\tvalue: T | null | undefined,\n\tfn: (value: T) => R\n): R | undefined {\n\treturn value === null || value === undefined || value === 0 ? undefined : fn(value)\n}\n\n/**\n * Clamp a caller-supplied number into the range its schema type allows, warning when it had to\n * move. Returns the value in the caller's own unit — each helper below applies its own\n * arithmetic afterwards, because the inverting and non-inverting forms do not round alike.\n *\n * `NaN` throws rather than clamping: there is no nearest in-range value for it, and\n * `Math.min`/`Math.max` propagate it straight through to the attribute (`val=\"NaN\"`), which is\n * exactly the degenerate output the range check exists to prevent. `Infinity` is not in that\n * category — it clamps to the bound like any other out-of-range number, and warns.\n *\n * **This is the one policy for an out-of-range number**, and it is the policy\n * `docs/contributing/development.md` (\"Warn or throw?\") describes: a finite value has a nearest legal\n * neighbour, so the deck still comes out recognisable and the move is a warning; a value that\n * is not a number at all has no neighbour, so the request is discarded and that throws.\n * Rejecting a finite out-of-range value and emitting nothing is neither: it discards the request\n * and reports it as a warning, which is the combination the rule exists to rule out.\n *\n * Most of what passes through here is a percentage, which is why the throw names one by\n * default; `nonFiniteCode` is for the callers whose option is not one, such as a shadow's\n * angle in degrees.\n *\n * @param value - the caller's value\n * @param min - inclusive lower bound, in the caller's unit\n * @param max - inclusive upper bound, in the caller's unit\n * @param code - diagnostic code raised when the value is clamped\n * @param label - option name as the caller spells it, opening the warning\n * @param nonFiniteCode - error code thrown when the value is not a number at all\n * @param report - how a clamp is reported: `once` dedupes the warning on its code and message, as\n *   a measure repeated across every run of a deck needs, and `range` states the range in the\n *   caller's wording (`'1-4000pt'`) rather than as the two bare bounds\n */\nexport function clampRangedInput(\n\tvalue: number,\n\tmin: number,\n\tmax: number,\n\tcode: DiagnosticCode,\n\tlabel: string,\n\tnonFiniteCode: InvalidOptionErrorCode = 'percent/non-finite',\n\treport: { readonly once?: boolean; readonly range?: string } = {}\n): number {\n\tif (typeof value !== 'number' || Number.isNaN(value))\n\t\tthrow new InvalidOptionError(\n\t\t\tnonFiniteCode,\n\t\t\t`${label} must be a number from ${min} to ${max}; received ${String(value)}.`\n\t\t)\n\tconst clamped = Math.min(max, Math.max(min, value))\n\tif (clamped !== value) {\n\t\tconst message = `${label} ${value} is outside the valid range ${report.range ?? `${min}-${max}`}; using ${clamped}.`\n\t\tif (report.once) warnOnce(code, message)\n\t\telse warn(code, message)\n\t}\n\treturn clamped\n}\n\n/**\n * Convert a transparency percentage (0-100) into a schema-valid `<a:alpha>` value\n * (ST_PositiveFixedPercentage, 0-100000). Out-of-range transparency yields an\n * alpha that PowerPoint rejects as needing repair, so clamp into range and warn.\n *\n * This is the **inverting** form: 0 transparency is full opacity (`val=\"100000\"`). Use\n * {@link percentToFixedPercent} where the option already reads as opacity.\n */\nexport function transparencyToAlpha(transparency: number): number {\n\tconst pct = clampRangedInput(transparency, 0, 100, 'transparency/out-of-range', 'transparency')\n\treturn Math.round((100 - pct) * FIXED_PCT_PER_PERCENT)\n}\n\n/** Convert an opacity (0-1) into a schema-valid `<a:alpha>` value (0-100000); clamps + warns on out-of-range input. */\nexport function opacityToAlpha(opacity: number): number {\n\treturn fractionToFixedPercent(opacity, 'opacity/out-of-range', 'opacity')\n}\n\n/**\n * Convert a percentage into a schema-valid fixed-percentage value (thousandths of a percent) —\n * the **non-inverting** sibling of {@link transparencyToAlpha}, for options the caller already\n * states as \"how much\", such as a chart series' fill opacity.\n *\n * `min`/`max` default to the 0-100 nearly every such option allows. They are parameters because\n * the fixed-percentage attributes do not all share one range: `<a:buSzPct>` is\n * ST_TextBulletSizePercent (25-400), so the bullet-size option needs its own bounds while\n * keeping this function's policy.\n * @param value - the caller's percentage\n * @param code - diagnostic code raised when the value is clamped\n * @param label - option name as the caller spells it, opening the warning\n * @param min - inclusive lower bound in percent\n * @param max - inclusive upper bound in percent\n */\nexport function percentToFixedPercent(value: number, code: DiagnosticCode, label: string, min = 0, max = 100): number {\n\treturn Math.round(clampRangedInput(value, min, max, code, label) * FIXED_PCT_PER_PERCENT)\n}\n\n/**\n * Convert a 0-1 fraction into a schema-valid fixed-percentage value (0-100000), for the options\n * spelled as a fraction rather than a percentage (an opacity, a luminance threshold).\n * @param value - the caller's fraction\n * @param code - diagnostic code raised when the value is clamped\n * @param label - option name as the caller spells it, opening the warning\n */\nexport function fractionToFixedPercent(value: number, code: DiagnosticCode, label: string): number {\n\treturn Math.round(clampRangedInput(value, 0, 1, code, label) * PERCENT_SCALE)\n}\n\n/**\n * Convert a length stated in points to EMU, clamped into the schema range of the attribute it is\n * headed for.\n *\n * A number goes through {@link clampRangedInput}, the one policy for an out-of-range number: a\n * value past either bound clamps to it and warns, `Infinity` included, and `NaN` throws\n * `coord/non-finite`. Both of those used to collapse to `0` without a word, so `width: Infinity`\n * became a zero-width line while `width: 5000` clamped and warned.\n *\n * A value that does not read as a number at all, a string such as `'wide'`, still collapses the\n * feature to `0` via {@link ptsToEmuLenient}, because these are optional decorations on an object\n * that still has to be emitted. A numeric string past the range clamps and warns as before.\n *\n * @param pts - the caller's length in points, or any of the loose shapes `ptsToEmuLenient` takes\n * @param maxEmu - inclusive upper bound of the attribute's schema type, in EMU\n * @param code - diagnostic code raised when the value is clamped\n * @param label - option name as the caller spells it, opening the warning\n * @param range - the valid range in points, as the warning states it\n */\nfunction clampLengthEmu(\n\tpts: number | string,\n\tmaxEmu: number,\n\tcode: DiagnosticCode,\n\tlabel: string,\n\trange: string\n): number {\n\tif (typeof pts === 'number')\n\t\treturn Math.round(clampRangedInput(pts, 0, maxEmu / EMU_PER_POINT, code, label, 'coord/non-finite') * EMU_PER_POINT)\n\tconst raw = ptsToEmuLenient(pts)\n\tconst clamped = Math.min(maxEmu, Math.max(0, raw))\n\tif (clamped !== raw)\n\t\twarn(code, `${label} ${pts} is outside the valid range ${range}; using ${clamped / EMU_PER_POINT}.`)\n\treturn clamped\n}\n\n/**\n * Convert a line width (points) to EMU clamped into ST_LineWidth (0..20116800 EMU,\n * i.e. 0-1584pt). Out-of-range widths make PowerPoint report the package as needing\n * repair, so clamp into range and warn.\n *\n * `label` is what the refusal quotes back, the way {@link clampFontSizeSz} already names the nine\n * options that reach it. Every caller used to be reported as `line width`, so a `NaN` error-bar\n * `width` or a series `lineSize` threw \"line width must be a number from 0 to 1584\" and named\n * nothing the caller had written.\n * @param widthPts - the caller's width in points\n * @param label - the option as the caller spells it, e.g. `errorBars.width`\n */\nexport function lineWidthToEmu(widthPts: number | string, label = 'line width'): number {\n\treturn clampLengthEmu(widthPts, 20116800, 'line/width-out-of-range', label, '0-1584pt')\n}\n\n/**\n * Convert a shadow's blur radius or offset distance (points) to EMU clamped into\n * ST_PositiveCoordinate (0..27273042316900 EMU, i.e. 0-2147483647pt) — the type both\n * `blurRad` and `dist` carry on `a:outerShdw`/`a:innerShdw`.\n *\n * **The bound is the schema's, not the `0-100` / `0-200` those options document.** Those two\n * numbers are the limits of PowerPoint's own spinners, and a blur past them is unusual rather\n * than invalid: the file loads and paints. The one input that genuinely breaks the package is a\n * *negative* one, because the type is unsigned — so that is what this moves, on the same\n * reasoning `clampLineSpacingMultiplePct` in `gen/drawingml/clamp.ts` clamps to\n * ST_TextSpacingPercent rather than to the `0.0-9.99` its own option describes. Only values\n * PowerPoint reports as needing repair are worth moving.\n */\nexport function positiveCoordinateEmu(pts: number | string, code: DiagnosticCode, label: string): number {\n\treturn clampLengthEmu(pts, MAX_COORDINATE_EMU, code, label, '0-2147483647pt')\n}\n\n/**\n * Convert degrees to a DrawingML angle (60000ths of a degree), **without** wrapping.\n *\n * Most angles in the format are not modular: a connection site at 400 degrees, a polar adjust\n * handle whose range runs to 540, an arc that sweeps 400 degrees — each means something a\n * reduction into 0..360 would destroy. Use this for those, and {@link convertRotationDegrees}\n * for the ones that genuinely are a rotation.\n *\n * Non-finite input throws rather than reaching the attribute: `Math.round(Infinity * 60000)` is\n * `Infinity`, which serializes as `ang=\"Infinity\"` and makes PowerPoint offer to repair the file.\n *\n * @param d - degrees\n * @param what - what is being converted, for the error message\n * @param code - diagnostic code to throw under, where a caller has a more specific one\n */\nexport function convertAngleUnits(d: number, what: string, code: AngleErrorCode = 'coord/non-finite'): number {\n\tassertFiniteDegrees(d, what, code)\n\treturn Math.round(d * ANGLE_UNITS_PER_DEGREE)\n}\n\n/** The codes {@link convertAngleUnits} may throw under, each declared in `codes.ts`. */\ntype AngleErrorCode = 'coord/non-finite' | 'geometry/arc-angle-non-finite'\n\nfunction assertFiniteDegrees(d: number, what: string, code: AngleErrorCode): void {\n\tif (typeof d !== 'number' || !Number.isFinite(d))\n\t\tthrow new InvalidOptionError(code, `${what} must be a finite number of degrees; received ${String(d)}.`)\n}\n\n/**\n * Convert a shape or gradient rotation (degrees) to a DrawingML angle (60000ths of a degree).\n *\n * A rotation *is* modular — 800 degrees and 80 degrees point the same way — so the value is\n * reduced with `% 360`. The reduction keeps the sign: `-45` stays `-45` rather than becoming\n * `315`, because both are valid `ST_Angle`, PowerPoint writes negative rotations itself, and\n * the read side reports back what was authored. Only an input outside -360..360 moves.\n *\n * @param d - degrees\n * @returns the `rot` value in 60000ths of a degree\n */\nexport function convertRotationDegrees(d: number): number {\n\t// Guard before reducing, so `Infinity` is reported as itself rather than as the `NaN` that\n\t// `Infinity % 360` would hand on. No `d || 0` in front of it: that turned `NaN` into 0.\n\tassertFiniteDegrees(d, 'rotation', 'coord/non-finite')\n\treturn Math.round((d % 360) * ANGLE_UNITS_PER_DEGREE)\n}\n\n/**\n * Convert a freeform arc angle (degrees) to an `<a:arcTo>` ST_AdjAngle value (60000ths).\n * Unlike a shape rotation, a sweep is not modular: a 400 degree swAng draws a different\n * arc than a 40 degree one, so the value is never wrapped into 0..360.\n * @param {number} d degrees\n * @param {'stAng' | 'swAng'} attr - attribute being emitted, for the error message\n * @returns {number} ST_AdjAngle value (60000ths of a degree)\n */\nexport function convertArcAngle(d: number, attr: 'stAng' | 'swAng'): number {\n\treturn convertAngleUnits(d, `Arc ${attr}`, 'geometry/arc-angle-non-finite')\n}\n"],"mappings":"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"}