@shbernal/ts-pptx 1.0.0 → 3.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"slide-YuSCGa45.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/{image-size-C5Z1sKof.js → st-enums-CgadEyPM.js}

@@ -1,3 +1,5 @@
+import { r as warnOnce } from "./diagnostics-DYQC7xLV.js";
+import { n as InvalidOptionError } from "./errors-DGE9zh3U.js";
 //#region src/media/base64.ts
 /**
 * Base64 payload handling for media parts — isomorphic across Node and browsers
@@ -199,8 +201,8 @@ function fitSrcRectPercents(type, img, box) {
 		width = widthBased ? box.w : box.h / imgRatio;
 		height = widthBased ? box.w * imgRatio : box.h;
 	}
-	const hz = Math.round(1e5 * .5 * (1 - box.w / width));
-	const vz = Math.round(1e5 * .5 * (1 - box.h / height));
+	const hz = Math.round(5e4 * (1 - box.w / width));
+	const vz = Math.round(5e4 * (1 - box.h / height));
 	return {
 		l: hz,
 		r: hz,
@@ -247,6 +249,235 @@ function utf8Decode(bytes) {
 	return new TextDecoder().decode(bytes);
 }
 //#endregion
-export { decodeBase64ToBytes as a, bytesToBase64 as i, getImageSizeFromBase64 as n, svgMarkupToDataUri as o, getImageSizeFromBytes as r, fitSrcRectPercents as t };
+//#region src/ooxml/rel-types.ts
+/**
+* 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/";
+/** `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";
+/** `p:sldIdLst` → a slide part. */
+const SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+/** A slide → its layout; a master → each of its layouts. */
+const SLIDE_LAYOUT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout";
+/** A layout → its master; the presentation → each master. */
+const SLIDE_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
+/** A slide → its notes slide. */
+const NOTES_SLIDE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+/** A notes slide → the notes master; the presentation → the notes master. */
+const NOTES_MASTER_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/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";
+/** The package root → `ppt/presentation.xml`. The entry point to everything above. */
+const OFFICE_DOCUMENT_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+/** Any part → an image in `ppt/media/`. */
+const IMAGE_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+//#endregion
+//#region src/ooxml/check-enum.ts
+/**
+* Check a value against its `ST_` union, reporting and dropping it when outside (the write-path
+* policy — see the module note).
+*
+* `undefined`/`null` returns `null` without reporting: an unset option is not an invalid one, and
+* it is by far the common case.
+*
+* The offending value is interpolated into the message deliberately. {@link warnOnce} dedups on
+* code **and** message, so keeping the value in the text is what lets a second, *different* bad
+* value under the same code still get reported.
+* @param value - the value the caller supplied, if any
+* @param valid - the enum's members
+* @param code - the condition to report
+* @param label - how to name the offending option in the message, e.g. ``'table cell: cell3D `preset`'``
+* @param detail - extra structured context to merge into the diagnostic's `detail`
+* @returns the value when legal, else `null`
+*/
+function checkEnumOrWarn(value, valid, code, label, detail) {
+	if (value === void 0 || value === null) return null;
+	if (valid.includes(value)) return value;
+	warnOnce(code, `${label} value \`${String(value)}\` is not valid and is ignored — use one of ${valid.join(", ")}.`, {
+		received: value,
+		valid,
+		...detail
+	});
+	return null;
+}
+/**
+* Check a value against its `ST_` union, throwing when outside (the read/edit-path policy — see
+* the module note).
+* @param value - the value the caller asked for
+* @param valid - the enum's members
+* @param attribute - the attribute's name, for the message
+* @param code - the condition to report
+* @returns `value`, when it is legal
+*/
+function checkEnumOrThrow(value, valid, attribute, code) {
+	if (valid.includes(value)) return value;
+	throw new InvalidOptionError(code, `Invalid ${attribute}: ${JSON.stringify(value)}. Expected one of: ${valid.join(", ")}.`);
+}
+//#endregion
+//#region src/ooxml/st-enums.ts
+/**
+* `ST_` simple-type enumerations from ECMA-376, declared once as the single source of both the
+* TypeScript union a caller is checked against and the runtime list a value is validated against.
+*
+* **The problem this solves.** Each of these used to exist twice: a hand-written string union in
+* `src/types/` (what the compiler enforces) and a hand-written array in `src/gen/` or `src/read/`
+* (what the validator checks at run time). Nothing tied the two together, so adding a member to
+* one and not the other produced either a value TypeScript accepts and the validator drops, or a
+* value the validator passes and the type rejects. Two of them had already diverged in *order*,
+* which is harmless, but nothing would have caught a divergence in *content*.
+*
+* **The shape.** Every entry is a `readonly` tuple declared `as const`, with its union derived via
+* `(typeof X)[number]`. Widening the tuple widens the union in the same edit — they cannot drift.
+* This is the idiom already used for `EMBEDDED_FONT_SLOTS` and `EXTRA_SHAPE_PRESETS`; this module
+* brings the stragglers onto it.
+*
+* **Why this module is neither `gen/` nor `read/`.** `src/types/` needs the unions for the public
+* write API, `src/gen/` needs the tuples to vet a value before emitting it, and `src/read/` needs
+* them to vet a value before writing it into a loaded part. It is a fact about the schema, so it
+* belongs to none of the three.
+*
+* Values are listed in **schema declaration order**, which is the order the diagnostics print
+* when they tell a caller what is legal.
+*/
+/**
+* `ST_BevelPresetType` — the bevel profile applied to a 3-D edge.
+* @see ECMA-376 Part 1 §20.1.10.9
+*/
+const BEVEL_PRESETS = [
+	"relaxedInset",
+	"circle",
+	"slope",
+	"cross",
+	"angle",
+	"softRound",
+	"convex",
+	"coolSlant",
+	"divot",
+	"riblet",
+	"hardEdge",
+	"artDeco"
+];
+/**
+* `ST_PresetMaterialType` — how a 3-D surface responds to light.
+* @see ECMA-376 Part 1 §20.1.10.50
+*/
+const PRESET_MATERIALS = [
+	"legacyMatte",
+	"legacyPlastic",
+	"legacyMetal",
+	"legacyWireframe",
+	"matte",
+	"plastic",
+	"metal",
+	"warmMatte",
+	"translucentPowder",
+	"powder",
+	"dkEdge",
+	"softEdge",
+	"clear",
+	"flat",
+	"softmetal"
+];
+/**
+* `ST_LightRigType` — the preset lighting scene.
+* @see ECMA-376 Part 1 §20.1.10.35
+*/
+const LIGHT_RIGS = [
+	"legacyFlat1",
+	"legacyFlat2",
+	"legacyFlat3",
+	"legacyFlat4",
+	"legacyNormal1",
+	"legacyNormal2",
+	"legacyNormal3",
+	"legacyNormal4",
+	"legacyHarsh1",
+	"legacyHarsh2",
+	"legacyHarsh3",
+	"legacyHarsh4",
+	"threePt",
+	"balanced",
+	"soft",
+	"harsh",
+	"flood",
+	"contrasting",
+	"morning",
+	"sunrise",
+	"sunset",
+	"chilly",
+	"freezing",
+	"flat",
+	"twoPt",
+	"glow",
+	"brightRoom"
+];
+/**
+* `ST_LightRigDirection` — where the light rig sits relative to the scene.
+* @see ECMA-376 Part 1 §20.1.10.33
+*/
+const LIGHT_RIG_DIRECTIONS = [
+	"tl",
+	"t",
+	"tr",
+	"l",
+	"r",
+	"bl",
+	"b",
+	"br"
+];
+/**
+* `ST_TextHorzOverflowType` — `a:bodyPr/@horzOverflow` and `a:tcPr/@horzOverflow`.
+* @see ECMA-376 Part 1 §20.1.10.68
+*/
+const TEXT_HORZ_OVERFLOW = ["clip", "overflow"];
+/**
+* `ST_TextAnchoringType` — `a:bodyPr/@anchor` and `a:tcPr/@anchor`.
+* @see ECMA-376 Part 1 §20.1.10.60
+*/
+const TEXT_ANCHORS = [
+	"t",
+	"ctr",
+	"b",
+	"just",
+	"dist"
+];
+/**
+* `ST_TextVerticalType` — `a:bodyPr/@vert` and `a:tcPr/@vert`.
+* @see ECMA-376 Part 1 §20.1.10.83
+*/
+const TEXT_VERTICAL = [
+	"horz",
+	"vert",
+	"vert270",
+	"wordArtVert",
+	"eaVert",
+	"mongolianVert",
+	"wordArtVertRtl"
+];
+/**
+* `ST_PresetLineDashVal` — the dash pattern of a line or border (`a:prstDash/@val`).
+*
+* The `sys*` members are the "system" dashes whose exact dot/gap ratio the renderer picks; the
+* rest are defined by the spec. Both `BorderProps.dashType` and `ShapeLineProps.dashType` accept
+* this whole set, so a caller who knows one knows the other.
+* @see ECMA-376 Part 1 §20.1.10.49
+*/
+const PRESET_LINE_DASHES = [
+	"solid",
+	"dot",
+	"dash",
+	"lgDash",
+	"dashDot",
+	"lgDashDot",
+	"lgDashDotDot",
+	"sysDash",
+	"sysDot",
+	"sysDashDot",
+	"sysDashDotDot"
+];
+//#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=image-size-C5Z1sKof.js.map
+//# sourceMappingURL=st-enums-CgadEyPM.js.map

package/dist/st-enums-CgadEyPM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"st-enums-CgadEyPM.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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"}