pptx-ts 0.0.1 → 4.0.0

package/dist/image-size-CvN2iCA4.js

@@ -0,0 +1,1611 @@
+import { n as InvalidOptionError, u as warnOnce } from "./errors-C4oENPcu.js";
+import { w as PERCENT_SCALE } from "./table-cell-margins-EVg0EwxT.js";
+import { t as bytesToBinaryString } from "./binary-string-CKVAYI3M.js";
+//#region src/media/image-formats.ts
+/**
+* Every recognised format, keyed by its canonical extension. Iteration order is sniffing order;
+* no two signatures overlap, so it only has to be stable, not carefully chosen.
+*/
+const IMAGE_FORMATS = Object.freeze({
+	png: {
+		ext: "png",
+		contentType: "image/png",
+		altExts: [],
+		filenameExt: "png",
+		magic: (b) => b.length >= 8 && b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71
+	},
+	jpeg: {
+		ext: "jpeg",
+		contentType: "image/jpeg",
+		altExts: ["jpg"],
+		filenameExt: "jpg",
+		magic: (b) => b.length >= 3 && b[0] === 255 && b[1] === 216 && b[2] === 255
+	},
+	gif: {
+		ext: "gif",
+		contentType: "image/gif",
+		altExts: [],
+		filenameExt: "gif",
+		magic: (b) => b.length >= 4 && b[0] === 71 && b[1] === 73 && b[2] === 70 && b[3] === 56
+	},
+	bmp: {
+		ext: "bmp",
+		contentType: "image/bmp",
+		altExts: [],
+		filenameExt: "bmp",
+		magic: (b) => b.length >= 2 && b[0] === 66 && b[1] === 77
+	},
+	tiff: {
+		ext: "tiff",
+		contentType: "image/tiff",
+		altExts: ["tif"],
+		filenameExt: "tif",
+		magic: (b) => b.length >= 4 && (b[0] === 73 && b[1] === 73 && b[2] === 42 && b[3] === 0 || b[0] === 77 && b[1] === 77 && b[2] === 0 && b[3] === 42)
+	},
+	webp: {
+		ext: "webp",
+		contentType: "image/webp",
+		altExts: [],
+		filenameExt: "webp",
+		magic: (b) => b.length >= 12 && b[0] === 82 && b[1] === 73 && b[2] === 70 && b[3] === 70 && b[8] === 87 && b[9] === 69 && b[10] === 66 && b[11] === 80
+	},
+	svg: {
+		ext: "svg",
+		contentType: "image/svg+xml",
+		altExts: [],
+		filenameExt: "svg",
+		magic: null
+	},
+	emf: {
+		ext: "emf",
+		contentType: "image/x-emf",
+		altExts: [],
+		filenameExt: "emf",
+		magic: null
+	},
+	wmf: {
+		ext: "wmf",
+		contentType: "image/x-wmf",
+		altExts: [],
+		filenameExt: "wmf",
+		magic: null
+	}
+});
+const BY_EXTENSION = new Map(Object.values(IMAGE_FORMATS).flatMap((f) => [f.ext, ...f.altExts].map((e) => [e, f])));
+const BY_CONTENT_TYPE = new Map(Object.values(IMAGE_FORMATS).map((f) => [f.contentType, f]));
+/** The format a caller's file extension names, or `null` for one the registry does not carry. */
+function imageFormatForExtension(extn) {
+	return BY_EXTENSION.get((extn || "").toLowerCase()) ?? null;
+}
+/** The format a content type names, or `null` for one the registry does not carry. */
+function imageFormatForContentType(contentType) {
+	return BY_CONTENT_TYPE.get((contentType || "").toLowerCase()) ?? null;
+}
+/** The format these leading bytes are the header of, or `null` when nothing matches. */
+function imageFormatForBytes(bytes) {
+	if (!bytes) return null;
+	for (const format of Object.values(IMAGE_FORMATS)) if (format.magic?.(bytes)) return format;
+	return null;
+}
+//#endregion
+//#region src/media/base64.ts
+/**
+* Base64 payload handling for media parts — isomorphic across Node and browsers
+* (`TextEncoder`/`atob`/`btoa` only, no `Buffer`).
+*/
+/**
+* Encode raw SVG markup as a base64 `image/svg+xml` data URI.
+* - lets callers pass inline SVG to `addImage({ svg })` without hand-rolling base64
+* - isomorphic and UTF-8 safe: uses the global `TextEncoder`/`btoa` (Node and browsers)
+* @param {string} svg - SVG markup, e.g. `'<svg ...>...</svg>'`
+* @returns {string} a `data:image/svg+xml;base64,...` URI
+*/
+function svgMarkupToDataUri(svg) {
+	return `data:image/svg+xml;base64,${bytesToBase64(new TextEncoder().encode(svg))}`;
+}
+/**
+* Encode raw bytes as base64 (no `data:` prefix) using only `btoa`, so the result is the same
+* on Node, in a browser, and in a runtime that has neither `Buffer` nor `FileReader`.
+* @param {Uint8Array} bytes - the payload
+* @returns {string} base64 text
+*/
+function bytesToBase64(bytes) {
+	return btoa(bytesToBinaryString(bytes));
+}
+/**
+* Present a freshly loaded media payload as a `data:` URI.
+*
+* A {@link RuntimeAdapter.loadMedia} implementation returns whichever encoding its host
+* makes cheap — the browser adapter a full URI, because `FileReader.readAsDataURL` is what
+* decodes a blob without blocking; Node and the neutral adapter raw base64, because neither
+* has a `FileReader`. This is where the two become one, so nothing downstream of the load
+* has to ask which it got.
+*
+* The mime label is documentary: {@link decodeBase64ToBytes} ignores it, and the one consumer
+* that needs a real URI (`image.src`, in the browser adapter's SVG preview) is handed the
+* adapter's own. It is taken from the rel anyway rather than hard-coded, so an already-correct
+* label is not overwritten with a wrong one.
+* @param {string} payload - what the adapter returned: raw base64, or an already-formed URI
+* @param {string} contentType - the rel's content type, e.g. `image/png`
+* @returns {string} a `data:` URI
+*/
+function toMediaDataUri(payload, contentType) {
+	return payload.startsWith("data:") ? payload : `data:${contentType};base64,${payload}`;
+}
+/**
+* Where the payload begins in an inline `data:` URI, or `-1` when the value carries no
+* `base64,` header and is therefore raw base64 already.
+*
+* The one reading of that header, because the two functions below used to spell it separately and
+* disagree: {@link hasBase64Header} lower-cased before looking, {@link decodeBase64ToBytes} did
+* not. RFC 2397 does not case the `;base64` token, so `data:image/png;BASE64,…` passed every
+* definer's check and then decoded from index 0, which `atob` rejects. The media part was written
+* empty, with nothing said. One search means the two can no longer answer differently.
+*
+* Matched with a regular expression rather than by lower-casing and indexing, because
+* `toLowerCase` is not length-preserving for every code point and a shifted index would slice the
+* payload apart.
+*/
+function base64PayloadStart(data) {
+	const match = /base64,/i.exec(data);
+	return match ? match.index + match[0].length : -1;
+}
+/**
+* Decode a base64 image payload (raw base64 or a `data:` URI) to bytes.
+* - tolerant of the `data:[mime];base64,` prefix and of whitespace in the payload
+* @param {string} b64 - base64 string or data URI
+* @returns {Uint8Array | null} decoded bytes, or `null` when the payload is empty/undecodable
+*/
+function decodeBase64ToBytes(b64) {
+	if (!b64) return null;
+	const start = base64PayloadStart(b64);
+	const payload = (start >= 0 ? b64.slice(start) : b64).replace(/\s/g, "");
+	if (!payload) return null;
+	try {
+		const binary = atob(payload);
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	} catch {
+		return null;
+	}
+}
+/**
+* Whether an inline payload carries the `base64,` header the definers ask image and media bytes
+* to arrive with. A value that is not a string has none.
+* @param data - the caller's `data`
+*/
+function hasBase64Header(data) {
+	return typeof data === "string" && base64PayloadStart(data) >= 0;
+}
+//#endregion
+//#region src/ooxml/namespaces.ts
+/**
+* OOXML namespace URIs, by their canonical prefix.
+*
+* A namespace URI is a fact about the format, not about reading or writing one, so it belongs
+* here rather than on either side — the same reasoning `rel-types.ts` states at length, and for
+* the same failure mode: these are long, near-identical strings, and a typo does not throw. It
+* silently matches nothing on the read side and produces a part PowerPoint ignores on the write
+* side.
+*
+* The table lived in `read/oxml/dom.ts` and could not be reached from `gen/`, because that
+* module imports `@xmldom/xmldom` at module scope and pulling an XML DOM into the write-only
+* bundle is a real cost. So the write side hand-wrote the URIs instead: three separate `A_NS`
+* constants and seven copies of the same `xmlns:a`/`xmlns:r`/`xmlns:p` triple. This module has
+* **no runtime imports**, and no module beside it imports from `gen/` or `read/`, so both sides can
+* reach it and neither pays for the other's dependencies. The two that fail loudly reach outside
+* `ooxml/` for that alone: `sequence.ts` for `errors.ts`, and `check-enum.ts` for `errors.ts` and
+* `diagnostics.ts`. `read/oxml/dom.ts` re-exports it, so no read-side import path changed.
+*/
+/** Canonical OOXML prefix → namespace URI registry. */
+const OOXML_NS = Object.freeze({
+	a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+	a14: "http://schemas.microsoft.com/office/drawing/2010/main",
+	asvg: "http://schemas.microsoft.com/office/drawing/2016/SVG/main",
+	c: "http://schemas.openxmlformats.org/drawingml/2006/chart",
+	c15: "http://schemas.microsoft.com/office/drawing/2012/chart",
+	cp: "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
+	ct: "http://schemas.openxmlformats.org/package/2006/content-types",
+	cx: "http://schemas.microsoft.com/office/drawing/2014/chartex",
+	dc: "http://purl.org/dc/elements/1.1/",
+	dcterms: "http://purl.org/dc/terms/",
+	dgm: "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+	dsp: "http://schemas.microsoft.com/office/drawing/2008/diagram",
+	ep: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
+	m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
+	mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
+	p: "http://schemas.openxmlformats.org/presentationml/2006/main",
+	p14: "http://schemas.microsoft.com/office/powerpoint/2010/main",
+	p15: "http://schemas.microsoft.com/office/powerpoint/2012/main",
+	p159: "http://schemas.microsoft.com/office/powerpoint/2015/9/main",
+	p188: "http://schemas.microsoft.com/office/powerpoint/2018/8/main",
+	pr: "http://schemas.openxmlformats.org/package/2006/relationships",
+	r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+	vt: "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes"
+});
+/**
+* `a:graphicData/@uri` for a DrawingML table.
+*
+* The other three payloads a `p:graphicFrame` can hold name a URI that is also a namespace, so
+* they read it off {@link OOXML_NS} (`c`, `cx`, `dgm`). A table's does not: nothing binds a
+* prefix to it, and the table elements themselves are in the `a` namespace. So it lives beside
+* the registry rather than in it, which keeps every entry there a prefix a document can declare.
+*/
+const TABLE_GRAPHIC_DATA_URI = "http://schemas.openxmlformats.org/drawingml/2006/table";
+/**
+* The `xmlns` declarations every PresentationML part root carries, in the order the emitters
+* have always written them.
+*
+* Spread this **first** in a root element's attribute map: `el()` serializes attributes in
+* object-key order, so the three keys have to keep the positions the literals occupied or the
+* emitted bytes move. A root with extra attributes (`show` on `p:sld`, `def` on `a:tblStyleLst`)
+* lists them after the spread, which is where they already were.
+*/
+const PML_ROOT_NS = Object.freeze({
+	"xmlns:a": OOXML_NS.a,
+	"xmlns:r": OOXML_NS.r,
+	"xmlns:p": OOXML_NS.p
+});
+//#endregion
+//#region src/ooxml/rel-types.ts
+/**
+* OPC relationship type URIs and part content types, and the 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
+* (`tags`, `oleObject`, the modern comments part, …) 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. A writer and a reader of the same part count as two modules even when each
+* names the string once: that pair is exactly the divergence this module exists to prevent.
+*
+* The same reasoning covers **part content types**, which are the same kind of fact and fail the
+* same silent way, including every entry the writer's `[Content_Types].xml` declares.
+*/
+/**
+* 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 = OOXML_NS.pr;
+/**
+* Prefix for the Microsoft rel types this library emits and reads. Exported for the same reason
+* as {@link OFFICE_REL}: a rel type only one module names is built from it at that module's call site.
+*/
+const MS_REL = "http://schemas.microsoft.com/office/";
+/** `p:sldIdLst` → a slide part. */
+const SLIDE_REL = OFFICE_REL + "slide";
+/** A slide → its layout; a master → each of its layouts. */
+const SLIDE_LAYOUT_REL = OFFICE_REL + "slideLayout";
+/** A layout → its master; the presentation → each master. */
+const SLIDE_MASTER_REL = OFFICE_REL + "slideMaster";
+/** A slide → its notes slide. */
+const NOTES_SLIDE_REL = OFFICE_REL + "notesSlide";
+/** A notes slide → the notes master; the presentation → the notes master. */
+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 = OFFICE_REL + "theme";
+/** The package root → `ppt/presentation.xml`. The entry point to everything above. */
+const OFFICE_DOCUMENT_REL = OFFICE_REL + "officeDocument";
+/** Any part → an image in `ppt/media/`. */
+const IMAGE_REL = OFFICE_REL + "image";
+/** Any part → an external or internal jump target. External ones carry `TargetMode="External"`. */
+const HYPERLINK_REL = OFFICE_REL + "hyperlink";
+/** The presentation → `ppt/tableStyles.xml`. */
+const TABLE_STYLES_REL = OFFICE_REL + "tableStyles";
+/** The package root → `docProps/core.xml`. Package-scoped, so not under {@link OFFICE_REL}. */
+const CORE_PROPS_REL = PACKAGE_REL_NS + "/metadata/core-properties";
+/** The package root → `docProps/app.xml`. */
+const EXTENDED_PROPS_REL = OFFICE_REL + "extended-properties";
+/** The package root → `docProps/custom.xml`. */
+const CUSTOM_PROPS_REL = OFFICE_REL + "custom-properties";
+/** A slide → its legacy comments part (`ppt/comments/commentN.xml`). */
+const COMMENTS_REL = OFFICE_REL + "comments";
+/** The presentation → the deck-wide legacy comment-author registry (`ppt/commentAuthors.xml`). */
+const COMMENT_AUTHORS_REL = OFFICE_REL + "commentAuthors";
+/** The presentation → the 2018 comment-author registry (`ppt/authors.xml`), a Microsoft rel type. */
+const MODERN_COMMENT_AUTHORS_REL = MS_REL + "2018/10/relationships/authors";
+/** The presentation → `ppt/presProps.xml`. */
+const PRES_PROPS_REL = OFFICE_REL + "presProps";
+/** The presentation → `ppt/viewProps.xml`. */
+const VIEW_PROPS_REL = OFFICE_REL + "viewProps";
+/** The presentation → the handout master. */
+const HANDOUT_MASTER_REL = OFFICE_REL + "handoutMaster";
+/** A part → a theme override, which replaces the deck theme for that part alone. */
+const THEME_OVERRIDE_REL = OFFICE_REL + "themeOverride";
+/** The presentation → an embedded font part, one per face. */
+const FONT_REL = OFFICE_REL + "font";
+/** A slide → an audio blob in `ppt/media/`. Paired with {@link MS_MEDIA_REL} on the same target. */
+const AUDIO_REL = OFFICE_REL + "audio";
+/** A slide → a video blob in `ppt/media/`, or an online-video placeholder. Paired with {@link MS_MEDIA_REL}. */
+const VIDEO_REL = OFFICE_REL + "video";
+/**
+* The MS-2007 `media` rel every audio/video shape carries alongside the ECMA one, pointing at the
+* same target. It is what `<p14:media r:embed>` resolves, so a media shape needs both.
+*/
+const MS_MEDIA_REL = MS_REL + "2007/relationships/media";
+/** A slide → an embedded 3D model (`.glb`). Note `2017/06`, not the `2017` of the model3d namespace. */
+const MODEL3D_REL = MS_REL + "2017/06/relationships/model3d";
+/** A slide → a classic (`c:`) chart part. */
+const CHART_REL = OFFICE_REL + "chart";
+/** A slide → a chartEx (`cx:`, Office 2016) chart part — an MS rel, not the ECMA `chart` one. */
+const CHARTEX_REL = MS_REL + "2014/relationships/chartEx";
+/** A chart part → its mandatory style sidecar. */
+const CHART_STYLE_REL = MS_REL + "2011/relationships/chartStyle";
+/** A chart part → its mandatory colour-style sidecar. */
+const CHART_COLOR_STYLE_REL = MS_REL + "2011/relationships/chartColorStyle";
+/** Any part → an embedded OPC package (an Office file, itself a zip): a chart's workbook, an OLE payload. */
+const PACKAGE_REL = OFFICE_REL + "package";
+/**
+* Root of the ECMA-376 content types. Exported for a content type only one module names, which is
+* built from it at that module's call site; a shared one is a constant below.
+*/
+const OD_CONTENT = "application/vnd.openxmlformats-officedocument.";
+/** Root of the OPC package-level content types. Private: callers want one of the constants below. */
+const PACKAGE_CONTENT = "application/vnd.openxmlformats-package.";
+/** Root of the Microsoft Office content types the chartEx family uses. Private. */
+const MS_OFFICE_CONTENT = "application/vnd.ms-office.";
+/** Root of the PowerPoint-specific Microsoft content types. Exported for the same reason as {@link OD_CONTENT}. */
+const MS_POWERPOINT_CONTENT = "application/vnd.ms-powerpoint.";
+/** `ppt/slides/slideN.xml`. */
+const SLIDE_CONTENT_TYPE = OD_CONTENT + "presentationml.slide+xml";
+/** `ppt/slideMasters/slideMasterN.xml`. */
+const SLIDE_MASTER_CONTENT_TYPE = OD_CONTENT + "presentationml.slideMaster+xml";
+/** `ppt/slideLayouts/slideLayoutN.xml`. */
+const SLIDE_LAYOUT_CONTENT_TYPE = OD_CONTENT + "presentationml.slideLayout+xml";
+/** `ppt/notesSlides/notesSlideN.xml`. */
+const NOTES_SLIDE_CONTENT_TYPE = OD_CONTENT + "presentationml.notesSlide+xml";
+/** `ppt/notesMasters/notesMasterN.xml`. */
+const NOTES_MASTER_CONTENT_TYPE = OD_CONTENT + "presentationml.notesMaster+xml";
+/** `ppt/theme/themeN.xml`. Not `presentationml.`: a theme is a DrawingML part. */
+const THEME_CONTENT_TYPE = OD_CONTENT + "theme+xml";
+/** `ppt/tableStyles.xml`. */
+const TABLE_STYLES_CONTENT_TYPE = OD_CONTENT + "presentationml.tableStyles+xml";
+/** `ppt/presentation.xml` in an editable `.pptx`. A `.potx` template's main part is a different one. */
+const PRESENTATION_MAIN_CONTENT_TYPE = OD_CONTENT + "presentationml.presentation.main+xml";
+/** Every `.rels` part. Declared once as a `Default` for the `rels` extension, never as an Override. */
+const RELATIONSHIPS_CONTENT_TYPE = PACKAGE_CONTENT + "relationships+xml";
+/** `ppt/presProps.xml`. */
+const PRES_PROPS_CONTENT_TYPE = OD_CONTENT + "presentationml.presProps+xml";
+/** `ppt/viewProps.xml`. */
+const VIEW_PROPS_CONTENT_TYPE = OD_CONTENT + "presentationml.viewProps+xml";
+/** `ppt/comments/commentN.xml`, a legacy comments part. */
+const COMMENTS_CONTENT_TYPE = OD_CONTENT + "presentationml.comments+xml";
+/** `ppt/commentAuthors.xml`. */
+const COMMENT_AUTHORS_CONTENT_TYPE = OD_CONTENT + "presentationml.commentAuthors+xml";
+/** `docProps/core.xml`. Package-scoped, so not under the officedocument prefix. */
+const CORE_PROPS_CONTENT_TYPE = PACKAGE_CONTENT + "core-properties+xml";
+/** `docProps/app.xml`. */
+const EXTENDED_PROPS_CONTENT_TYPE = OD_CONTENT + "extended-properties+xml";
+/** `docProps/custom.xml`. */
+const CUSTOM_PROPS_CONTENT_TYPE = OD_CONTENT + "custom-properties+xml";
+/** `ppt/charts/chartN.xml`, a classic (`c:`) chart. */
+const CHART_CONTENT_TYPE = OD_CONTENT + "drawingml.chart+xml";
+/** `ppt/charts/chartExN.xml`. A chartEx part carries a Microsoft content type, not an `openxmlformats` one. */
+const CHARTEX_CONTENT_TYPE = MS_OFFICE_CONTENT + "chartex+xml";
+/** A chart's mandatory `style{N}.xml` sidecar. */
+const CHART_STYLE_CONTENT_TYPE = MS_OFFICE_CONTENT + "chartstyle+xml";
+/** A chart's mandatory `colors{N}.xml` sidecar. */
+const CHART_COLOR_STYLE_CONTENT_TYPE = MS_OFFICE_CONTENT + "chartcolorstyle+xml";
+/** An embedded `.xlsx` workbook: a chart's data, or an OLE payload. */
+const XLSX_CONTENT_TYPE = OD_CONTENT + "spreadsheetml.sheet";
+/**
+* Every kind of part a page points at without owning it.
+*
+* Two questions read this table, under different keys. Copying a page asks whether a relationship's
+* target may be shared by the copies rather than copied (every row, by `relType`). Pruning after a
+* slide is removed asks whether a part is deck chrome that stays even while nothing reaches it (the
+* `deck` rows, by `contentType`). They were two hand-kept lists, and the two author registries were
+* on the first and missing from the second.
+*/
+const SHARED_PARTS = [
+	{
+		relType: SLIDE_LAYOUT_REL,
+		contentType: SLIDE_LAYOUT_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: SLIDE_MASTER_REL,
+		contentType: SLIDE_MASTER_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: NOTES_MASTER_REL,
+		contentType: NOTES_MASTER_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: THEME_REL,
+		contentType: THEME_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: THEME_OVERRIDE_REL,
+		contentType: OD_CONTENT + "themeOverride+xml",
+		scope: "deck"
+	},
+	{
+		relType: HANDOUT_MASTER_REL,
+		contentType: OD_CONTENT + "presentationml.handoutMaster+xml",
+		scope: "deck"
+	},
+	{
+		relType: PRES_PROPS_REL,
+		contentType: PRES_PROPS_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: VIEW_PROPS_REL,
+		contentType: VIEW_PROPS_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: TABLE_STYLES_REL,
+		contentType: TABLE_STYLES_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: OFFICE_DOCUMENT_REL,
+		contentType: PRESENTATION_MAIN_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: COMMENT_AUTHORS_REL,
+		contentType: COMMENT_AUTHORS_CONTENT_TYPE,
+		scope: "deck"
+	},
+	{
+		relType: MODERN_COMMENT_AUTHORS_REL,
+		contentType: "application/vnd.ms-powerpoint.authors+xml",
+		scope: "deck"
+	},
+	{
+		relType: IMAGE_REL,
+		contentType: null,
+		scope: "media"
+	},
+	{
+		relType: AUDIO_REL,
+		contentType: null,
+		scope: "media"
+	},
+	{
+		relType: VIDEO_REL,
+		contentType: null,
+		scope: "media"
+	},
+	{
+		relType: MS_MEDIA_REL,
+		contentType: null,
+		scope: "media"
+	},
+	{
+		relType: MODEL3D_REL,
+		contentType: null,
+		scope: "media"
+	},
+	{
+		relType: FONT_REL,
+		contentType: null,
+		scope: "media"
+	},
+	{
+		relType: SLIDE_REL,
+		contentType: null,
+		scope: "page"
+	},
+	{
+		relType: HYPERLINK_REL,
+		contentType: null,
+		scope: "page"
+	}
+];
+//#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 `EXTRA_SHAPE_PRESETS` already used; this module brings the stragglers onto it,
+* and holds a few closed schema lists that are not `ST_` types, such as `EMBEDDED_FONT_SLOTS`.
+*
+* **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.
+*
+* **The chart option bag reads its enumerations from here**: `BarDirection`, `BarGrouping`,
+* `Bar3DShape`, `LegendPosition`, `DisplayBlanksAs`, `DataLabelPosition` and `LineDataSymbol`
+* first, then the axis and error-bar ones. They were the half of this consolidation that went
+* unfinished for a while. `src/types/chart.ts`
+* hand-wrote four of those unions beside the option that takes them and typed the other three as
+* bare `string`, so `barDir` carried no compile-time check at all, and `dataLabelPosition`'s
+* hand-written union was missing `inBase` — a value the validator accepts on a stacked bar, so
+* the two spellings had already diverged in content. Both are gone: for every option here, the
+* type a caller is checked against and the tuple the validator checks are one declaration.
+*/
+/** `ST_TextAutonumberScheme` — the numbering an auto-numbered bullet counts in (`a:buAutoNum/@type`). */
+const TEXT_AUTONUM_SCHEMES = [
+	"alphaLcParenBoth",
+	"alphaUcParenBoth",
+	"alphaLcParenR",
+	"alphaUcParenR",
+	"alphaLcPeriod",
+	"alphaUcPeriod",
+	"arabicParenBoth",
+	"arabicParenR",
+	"arabicPeriod",
+	"arabicPlain",
+	"romanLcParenBoth",
+	"romanUcParenBoth",
+	"romanLcParenR",
+	"romanUcParenR",
+	"romanLcPeriod",
+	"romanUcPeriod",
+	"circleNumDbPlain",
+	"circleNumWdBlackPlain",
+	"circleNumWdWhitePlain",
+	"arabicDbPeriod",
+	"arabicDbPlain",
+	"ea1ChsPeriod",
+	"ea1ChsPlain",
+	"ea1ChtPeriod",
+	"ea1ChtPlain",
+	"ea1JpnChsDbPeriod",
+	"ea1JpnKorPlain",
+	"ea1JpnKorPeriod",
+	"arabic1Minus",
+	"arabic2Minus",
+	"hebrew2Minus",
+	"thaiAlphaPeriod",
+	"thaiAlphaParenR",
+	"thaiAlphaParenBoth",
+	"thaiNumPeriod",
+	"thaiNumParenR",
+	"thaiNumParenBoth",
+	"hindiAlphaPeriod",
+	"hindiNumPeriod",
+	"hindiNumParenR",
+	"hindiAlpha1Period"
+];
+/** `ST_TextStrikeType` — a run's strikethrough (`a:rPr/@strike`). */
+const TEXT_STRIKE_TYPES = [
+	"noStrike",
+	"sngStrike",
+	"dblStrike"
+];
+/** `ST_TextCapsType` — a run's capitalization (`a:rPr/@cap`). */
+const TEXT_CAPS_TYPES = [
+	"none",
+	"small",
+	"all"
+];
+/** `ST_TextUnderlineType` — a run's underline (`a:rPr/@u`). */
+const TEXT_UNDERLINE_TYPES = [
+	"none",
+	"words",
+	"sng",
+	"dbl",
+	"heavy",
+	"dotted",
+	"dottedHeavy",
+	"dash",
+	"dashHeavy",
+	"dashLong",
+	"dashLongHeavy",
+	"dotDash",
+	"dotDashHeavy",
+	"dotDotDash",
+	"dotDotDashHeavy",
+	"wavy",
+	"wavyHeavy",
+	"wavyDbl"
+];
+/** `ST_TextTabAlignType` — a tab stop's alignment (`a:tab/@algn`). */
+const TEXT_TAB_ALIGN_TYPES = [
+	"l",
+	"ctr",
+	"r",
+	"dec"
+];
+/**
+* `ST_SchemeColorVal` — a theme colour reference (`a:schemeClr/@val`). Wider than
+* {@link THEME_COLOR_SLOTS}: it adds the `bg1`/`tx1`/`bg2`/`tx2` aliases the colour map resolves,
+* and `phClr`, the colour a theme style-matrix entry is applied in.
+*/
+const SCHEME_COLOR_VALUES = [
+	"bg1",
+	"tx1",
+	"bg2",
+	"tx2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink",
+	"phClr",
+	"dk1",
+	"lt1",
+	"dk2",
+	"lt2"
+];
+/**
+* The base slide transitions: the `p:` type elements of `CT_SlideTransition`'s choice, in its
+* declaration order. The writer emits the type as `<p:TYPE/>`, so this is also the list a type is
+* checked against before it becomes an element name, and the list the script converter uses to
+* decide which read transitions the write API can express. PowerPoint's modern transitions live in
+* other namespaces and are not here.
+*/
+const TRANSITION_TYPES = [
+	"blinds",
+	"checker",
+	"circle",
+	"dissolve",
+	"comb",
+	"cover",
+	"cut",
+	"diamond",
+	"fade",
+	"newsflash",
+	"plus",
+	"pull",
+	"push",
+	"random",
+	"randomBar",
+	"split",
+	"strips",
+	"wedge",
+	"wheel",
+	"wipe",
+	"zoom"
+];
+/**
+* The attributes each of {@link TRANSITION_TYPES} declares, which is every key a transition's
+* `variant` can write. Seven are `CT_Empty` and take none.
+*/
+const TRANSITION_VARIANT_ATTRIBUTES = {
+	blinds: ["dir"],
+	checker: ["dir"],
+	circle: [],
+	dissolve: [],
+	comb: ["dir"],
+	cover: ["dir"],
+	cut: ["thruBlk"],
+	diamond: [],
+	fade: ["thruBlk"],
+	newsflash: [],
+	plus: [],
+	pull: ["dir"],
+	push: ["dir"],
+	random: [],
+	randomBar: ["dir"],
+	split: ["orient", "dir"],
+	strips: ["dir"],
+	wedge: [],
+	wheel: ["spokes"],
+	wipe: ["dir"],
+	zoom: ["dir"]
+};
+/**
+* `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_LineEndType` — the arrowhead at either end of a stroke (`a:headEnd/@type`,
+* `a:tailEnd/@type`).
+* @see ECMA-376 Part 1 §20.1.10.33
+*/
+const LINE_END_TYPES = [
+	"none",
+	"triangle",
+	"stealth",
+	"diamond",
+	"oval",
+	"arrow"
+];
+/**
+* The four face slots of `CT_EmbeddedFontListEntry`, in schema child order (`p:font` first, then
+* these). Not an `ST_` type, but a closed, ordered set the schema declares, like
+* {@link THEME_COLOR_SLOTS}. The read and write sides iterate it so their emitters agree on
+* element order, and `sequence.ts` derives `EMBEDDED_FONT_ENTRY_SEQUENCE` from it, so the order
+* the serializer writes and the order the insertion points are computed from are one fact.
+* `embedded-fonts.ts` re-exports it.
+*/
+const EMBEDDED_FONT_SLOTS = [
+	"regular",
+	"bold",
+	"italic",
+	"boldItalic"
+];
+/**
+* `ST_TextShapeType` — the preset path text is bent along (`a:prstTxWarp/@prst`), which
+* PowerPoint calls WordArt.
+*
+* `textNoShape` is the identity member: it is legal, and it warps nothing. The library does not
+* narrow this set — every member is a shape PowerPoint draws.
+* @see ECMA-376 Part 1 §20.1.10.76
+*/
+const TEXT_SHAPE_TYPES = [
+	"textNoShape",
+	"textPlain",
+	"textStop",
+	"textTriangle",
+	"textTriangleInverted",
+	"textChevron",
+	"textChevronInverted",
+	"textRingInside",
+	"textRingOutside",
+	"textArchUp",
+	"textArchDown",
+	"textCircle",
+	"textButton",
+	"textArchUpPour",
+	"textArchDownPour",
+	"textCirclePour",
+	"textButtonPour",
+	"textCurveUp",
+	"textCurveDown",
+	"textCanUp",
+	"textCanDown",
+	"textWave1",
+	"textWave2",
+	"textDoubleWave1",
+	"textWave4",
+	"textInflate",
+	"textDeflate",
+	"textInflateBottom",
+	"textDeflateBottom",
+	"textInflateTop",
+	"textDeflateTop",
+	"textDeflateInflate",
+	"textDeflateInflateDeflate",
+	"textFadeRight",
+	"textFadeLeft",
+	"textFadeUp",
+	"textFadeDown",
+	"textSlantUp",
+	"textSlantDown",
+	"textCascadeUp",
+	"textCascadeDown"
+];
+/**
+* `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"
+];
+/**
+* `ST_BarDir` — whether a bar/column plot runs horizontally or vertically (`c:barDir/@val`).
+* @see ECMA-376 Part 1 §21.2.3.3
+*/
+const BAR_DIRECTIONS = ["bar", "col"];
+/**
+* `ST_BarGrouping` — how a bar/column plot stacks its series (`c:grouping/@val` inside
+* `c:barChart`/`c:bar3DChart`).
+* @see ECMA-376 Part 1 §21.2.3.4
+*/
+const BAR_GROUPINGS = [
+	"percentStacked",
+	"clustered",
+	"standard",
+	"stacked"
+];
+/**
+* `ST_Grouping` — the same decision for the plots that have no clustered form
+* (`c:areaChart`, `c:lineChart`).
+* @see ECMA-376 Part 1 §21.2.3.17
+*/
+const GROUPINGS = [
+	"percentStacked",
+	"standard",
+	"stacked"
+];
+/**
+* `ST_Shape` — the solid a 3-D bar is drawn as (`c:shape/@val`).
+* @see ECMA-376 Part 1 §21.2.3.35
+*/
+const BAR_3D_SHAPES = [
+	"cone",
+	"coneToMax",
+	"box",
+	"cylinder",
+	"pyramid",
+	"pyramidToMax"
+];
+/**
+* `ST_RadarStyle` — how a radar plot is drawn (`c:radarStyle/@val`).
+* @see ECMA-376 Part 1 §21.2.3.33
+*/
+const RADAR_STYLES = [
+	"standard",
+	"marker",
+	"filled"
+];
+/**
+* This library's own names for two of the three radar styles, mapped to the wire spelling each
+* one means. They are the PowerPoint UI's words ("Radar", "Radar with Markers"), which is why
+* they were chosen; `filled` needed no rename and is already the schema's own spelling, which is
+* what made the other two read as typos rather than as a second vocabulary.
+*
+* Both spellings are accepted on the public option and normalized to the wire one at definition
+* time. Before that, `radarStyle: 'marker'` — the schema's word, and the obvious guess for anyone
+* reading a chart part — failed the enum check and silently fell back to `standard`, so a caller
+* asking for markers got a plain radar.
+*/
+const RADAR_STYLE_ALIASES = {
+	radar: "standard",
+	markers: "marker"
+};
+/**
+* The alias spellings alone, for the definer's enum check. Derived from the map rather than
+* written out again — the whole point of this module is that the list a value is validated
+* against and the union it is typed against cannot drift apart.
+*/
+const RADAR_STYLE_ALIAS_NAMES = Object.keys(RADAR_STYLE_ALIASES);
+/**
+* `ST_LegendPos` — where the legend sits relative to the plot area (`c:legendPos/@val`).
+* @see ECMA-376 Part 1 §21.2.3.24
+*/
+const LEGEND_POSITIONS = [
+	"b",
+	"tr",
+	"l",
+	"r",
+	"t"
+];
+/**
+* `ST_DispBlanksAs` — what a plot draws where a value is missing (`c:dispBlanksAs/@val`).
+* @see ECMA-376 Part 1 §21.2.3.10
+*/
+const DISPLAY_BLANKS_AS = [
+	"span",
+	"gap",
+	"zero"
+];
+/**
+* `ST_MarkerStyle`, **narrowed** to what the library authors (`c:symbol/@val`).
+*
+* The schema also has `plus`, `star`, `x`, `picture` and `auto`. Neither PowerPoint 2013 nor
+* PowerPoint Online draws the first three, `picture` needs a `c:spPr` blip this API has no
+* spelling for, and `auto` is what leaving the option off already means — so the accepted set is
+* deliberately smaller than the type. Widen it only with evidence that the member renders.
+* @see ECMA-376 Part 1 §21.2.3.27
+*/
+const LINE_DATA_SYMBOLS = [
+	"circle",
+	"dash",
+	"diamond",
+	"dot",
+	"none",
+	"square",
+	"triangle"
+];
+/** `ST_TickLblPos` — where an axis draws its tick labels (`c:tickLblPos/@val`). */
+const TICK_LABEL_POSITIONS = [
+	"high",
+	"low",
+	"nextTo",
+	"none"
+];
+/** `ST_Orientation` — which way an axis runs (`c:orientation/@val`). */
+const AXIS_ORIENTATIONS = ["maxMin", "minMax"];
+/** `ST_TickMark` — an axis' major or minor tick marks (`c:majorTickMark/@val`, `c:minorTickMark/@val`). */
+const TICK_MARKS = [
+	"cross",
+	"in",
+	"none",
+	"out"
+];
+/** `ST_CrossBetween` — whether a value axis crosses its category axis between or on categories (`c:crossBetween/@val`). */
+const CROSS_BETWEEN = ["between", "midCat"];
+/** `ST_BuiltInUnit` — the unit a value axis displays its labels in (`c:builtInUnit/@val`). */
+const BUILT_IN_UNITS = [
+	"hundreds",
+	"thousands",
+	"tenThousands",
+	"hundredThousands",
+	"millions",
+	"tenMillions",
+	"hundredMillions",
+	"billions",
+	"trillions"
+];
+/** `ST_TimeUnit` — a date axis' base, major or minor time unit (`c:baseTimeUnit/@val` and its two siblings). */
+const TIME_UNITS = [
+	"days",
+	"months",
+	"years"
+];
+/** `ST_ErrDir` — the axis an error bar measures along (`c:errDir/@val`). */
+const ERROR_BAR_DIRECTIONS = ["x", "y"];
+/** `ST_ErrBarType` — which sides of a point draw an error bar (`c:errBarType/@val`). */
+const ERROR_BAR_TYPES = [
+	"both",
+	"minus",
+	"plus"
+];
+/** `ST_ErrValType` — how an error bar's amount is read (`c:errValType/@val`). */
+const ERROR_BAR_VALUE_TYPES = [
+	"cust",
+	"fixedVal",
+	"percentage",
+	"stdDev",
+	"stdErr"
+];
+/**
+* The twelve theme colour slots (`a:clrScheme` children) a `p:clrMap` token can point at.
+*
+* Not an `ST_` type — these are element names inside `a:CT_ColorScheme`, which the schema
+* declares as a fixed sequence rather than an enumeration. The effect is the same: a closed,
+* ordered set of twelve names, in the order the scheme declares them.
+* @see ECMA-376 Part 1 §20.1.6.2
+*/
+const THEME_COLOR_SLOTS = [
+	"dk1",
+	"lt1",
+	"dk2",
+	"lt2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+];
+/**
+* The twelve colour-map tokens (`p:clrMap` attributes), in schema attribute order.
+*
+* A slide's `schemeClr val="tx1"` names a *token*, not a slot: the master's `p:clrMap` is the
+* indirection that sends it to a {@link ThemeColorSlot}. Which is why the two lists look alike
+* and are not the same list — `bg1`/`tx1` are tokens, `lt1`/`dk1` are slots.
+* @see ECMA-376 Part 1 §19.3.1.6
+*/
+const COLOR_MAP_TOKENS = [
+	"bg1",
+	"tx1",
+	"bg2",
+	"tx2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+];
+/**
+* The identity colour map: the `p:clrMap` this library emits on every master and notes master,
+* and the one the script printer recognises so it can skip printing a map that is the default.
+*
+* "Identity" up to the light/dark naming: each token points at the slot of the same name, with
+* `bg`/`tx` reading as light/dark. A deck that maps them anywhere else — swapping the light and
+* dark slots is the usual case — resolves every `schemeClr` in the deck differently.
+*
+* Typed `Record<ColorMapToken, ThemeColorSlot>` so a token added to {@link COLOR_MAP_TOKENS}
+* without a mapping, or a slot misspelled, is a compile error rather than a theme that opens
+* fine and paints one script in the wrong colour. Declared in the same order as the tokens,
+* because it is emitted by iterating this object and the attribute order is part of the bytes.
+*/
+const DEFAULT_COLOR_MAP = {
+	bg1: "lt1",
+	tx1: "dk1",
+	bg2: "lt2",
+	tx2: "dk2",
+	accent1: "accent1",
+	accent2: "accent2",
+	accent3: "accent3",
+	accent4: "accent4",
+	accent5: "accent5",
+	accent6: "accent6",
+	hlink: "hlink",
+	folHlink: "folHlink"
+};
+//#endregion
+//#region src/hex-color.ts
+/**
+* ts-pptx: hex colour text, in the one spelling both halves use.
+*
+* A caller may write a colour with or without a leading `#`, and the library accepts both
+* everywhere — which means every site that validates or parses one strips it first. Those
+* strips had drifted into three spellings across six sites, and one of them was not
+* anchored: `.replace('#', '')` takes the `#` out of `'FF00#0'` and hands `'FF000'` on, which
+* then fails the six-digit test and takes a different branch than the anchored forms would.
+* No caller is known to reach that, which is exactly why it wants one spelling rather than a
+* test at each site.
+*
+* This lives at the root rather than under `gen/` or `read/` because both halves need it:
+* the emitters strip on the way in, the readers strip on the way back out — and for the same
+* reason the *validation* belongs here too. `REGEX_HEX_COLOR` used to live in
+* `constants-internal.ts`, which is a write-side module the read path cannot import, so the read
+* path re-spelled the regex; so did one write-side site. Six sites, three spellings of one fact.
+*/
+/**
+* A colour written as six hex digits, `#` already stripped.
+*
+* Not exported: {@link isHexColor} is the whole of what the call sites want, and a shared mutable
+* `RegExp` object is a worse export than a predicate.
+*/
+const REGEX_HEX_COLOR = /^[0-9a-fA-F]{6}$/;
+/** An 8-hex RGBA colour, `#` already stripped — {@link splitRgbaHex}'s test. */
+const REGEX_ARGB_HEX = /^[0-9a-fA-F]{8}$/;
+/** Strip a single leading `#` from a colour, leaving any other character alone. */
+function stripHash(value) {
+	return value.startsWith("#") ? value.slice(1) : value;
+}
+/**
+* Is `value` a 6-hex RGB colour? A leading `#` is stripped first, so both spellings agree.
+*
+* This is the *shape* test only. Whether the caller may also name a scheme colour there is the
+* call site's question, and each still asks it: `createColorElement` falls back to the default
+* font colour, `makeXmlTheme` keeps the Office default and warns, `normalizeHex` throws.
+* @param value - the caller's colour, with or without a leading `#`
+*/
+function isHexColor(value) {
+	return REGEX_HEX_COLOR.test(stripHash(value));
+}
+/**
+* Is `value` an 8-hex RGBA colour? A leading `#` is stripped first.
+*
+* The 8-digit form is RGB followed by one alpha byte; {@link splitRgbaHex} is what takes it apart.
+* @param value - the caller's colour, with or without a leading `#`
+*/
+function isArgbHex(value) {
+	return REGEX_ARGB_HEX.test(stripHash(value));
+}
+/**
+* Split an 8-hex RGBA colour into its 6-hex RGB and a 0–1 alpha; anything else passes through
+* unchanged with no alpha.
+*
+* `#` is stripped first, so both spellings reach the same answer. Two sites parsed this by
+* hand — `createColorElement`, which turns the alpha into an `<a:alpha>` sibling, and
+* `normalizeShadowOptions`, which turns it into a shadow's `_alpha` — and they divided by 255 at
+* different points in their arithmetic.
+* @param value - the caller's colour, with or without a leading `#`
+*/
+function splitRgbaHex(value) {
+	const hex = stripHash(value);
+	if (!isArgbHex(hex)) return { rgb: hex };
+	return {
+		rgb: hex.slice(0, 6),
+		alpha: parseInt(hex.slice(6, 8), 16) / 255
+	};
+}
+//#endregion
+//#region src/ooxml/xsd-boolean.ts
+/**
+* Parsing an `xsd:boolean` attribute value.
+*
+* **Why a function at all.** `xsd:boolean` has four lexical forms — `1`, `0`, `true`, `false` —
+* and OOXML attributes typed with it accept every one of them. PowerPoint writes only `1` and
+* `0`, so a hand-rolled `=== '1'` test passes against every deck this library produces and
+* against every deck PowerPoint produces, and silently misreads the other producers. That is the
+* worst shape a bug can have: invisible to the fixtures, visible only on a customer's file.
+*
+* **Why this module is neither `gen/` nor `read/`.** The lexical space of a schema type is a fact
+* about the schema, like `sequence.ts`'s document order and `body-insets.ts`'s defaults. The
+* parser lived in `read/oxml/dom.ts` because reading is where most of the demand is, and three
+* private copies had collapsed into it — but `read/oxml/dom.ts` imports `@xmldom/xmldom`, so
+* anything outside `read/` that wants this five-line function has to take a DOM dependency to get
+* it, or write a fourth copy. `script/from-read/detect.ts` hit exactly that and wrote the copy.
+*
+* The DOM-typed convenience wrapper stays behind in `read/oxml/dom.ts` as `boolAttr`, because
+* *that* one really is about reading an element.
+*
+* **The write direction is here too**, and it is where the interesting distinction lives: an
+* emitter writing a boolean has THREE useful shapes, not one — see {@link xsdBool} and
+* {@link xsdBoolIfTrue}. Sixty-odd inline ternaries spelled them in three ways with nothing
+* naming which was which.
+*/
+/**
+* Parse an `xsd:boolean` OOXML attribute (`1`/`0`/`true`/`false`); else `null`.
+*
+* `null` for an absent *or* unparseable value is deliberate and load-bearing at the call sites:
+* several attributes have a schema default of `true`, so they test `!== false` rather than
+* `=== true` and an unset attribute has to be distinguishable from an explicit `0`.
+*/
+function boolValue(value) {
+	if (value === "1" || value === "true") return true;
+	if (value === "0" || value === "false") return false;
+	return null;
+}
+/**
+* A boolean as the `1`/`0` an `xsd:boolean` attribute takes.
+*
+* Writes the attribute either way, so `false` is *stated*. Use this wherever the schema
+* default is `true`, or wherever the absence of the attribute would mean something other
+* than `false` — a value inherited from a list style, a layout or the theme.
+* @param value - the resolved boolean
+*/
+function xsdBool(value) {
+	return value ? "1" : "0";
+}
+/**
+* A boolean as `1`, or `null` so the attribute is left out entirely.
+*
+* **Correct only where the schema default is `false`.** It collapses "false" and "unset" into
+* one output, which is the two-spellings-for-three-states shape the API policy warns about: the
+* next attribute with a `true` default written this way reads as correct and is wrong. Every
+* current caller is on a `false`-defaulting attribute, so the collapse costs nothing today —
+* naming it is what makes the next one visible.
+* @param value - the resolved boolean
+*/
+function xsdBoolIfTrue(value) {
+	return value ? "1" : null;
+}
+//#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/line-cap.ts
+/**
+* Every `cap` the write API names and the token it writes. `satisfies` over `Record<LineCap, …>`
+* makes a member added to `LineCap` without a token a compile error, and `ST_LineCap` has exactly
+* these three members, so the inverse covers every token too.
+*/
+const TOKEN_BY_LINE_CAP = {
+	flat: "flat",
+	square: "sq",
+	round: "rnd"
+};
+/** The `cap` token a `LineCap` writes, or `undefined` for a value the write API does not name. */
+function lineCapToken(cap) {
+	return Object.hasOwn(TOKEN_BY_LINE_CAP, cap) ? TOKEN_BY_LINE_CAP[cap] : void 0;
+}
+/** A `cap` token back to the `LineCap` that authors it. */
+const LINE_CAP_BY_TOKEN = Object.fromEntries(Object.entries(TOKEN_BY_LINE_CAP).map(([cap, token]) => [token, cap]));
+//#endregion
+//#region src/ooxml/text-align.ts
+/**
+* Every `align` the write API names and the token it writes. `satisfies` over `Record<HAlign, …>`
+* makes a member added to `HAlign` without a token a compile error. `justLow`, `dist` and
+* `thaiDist` have no `align` spelling.
+*/
+const ALGN_BY_ALIGN = {
+	left: "l",
+	center: "ctr",
+	right: "r",
+	justify: "just"
+};
+/** The `algn` token an `align` value writes, or `undefined` for a value the write API does not name. */
+function textAlignToken(align) {
+	return Object.hasOwn(ALGN_BY_ALIGN, align) ? ALGN_BY_ALIGN[align] : void 0;
+}
+/** An `algn` token back to the `align` a generated script writes. */
+const HALIGN_BY_TEXT_ALIGN = Object.fromEntries(Object.entries(ALGN_BY_ALIGN).map(([align, token]) => [token, align]));
+//#endregion
+//#region src/media/image-size.ts
+/**
+* Intrinsic image geometry: reading a natural pixel size out of header bytes, and the
+* `<a:srcRect>` crop math that fits that natural size into a display box.
+*
+* Shared by both sides of the library — the write path (`addImage({ sizing })`) and the read
+* API's `Picture.setImage({ fit })` — which is why it lives outside `gen/` and `read/`.
+* Everything here is synchronous and pure: headers only, never pixel decoding.
+*/
+/**
+* Read the intrinsic dimensions of an image from its header bytes.
+* - synchronous: parses only file-format headers, never decodes pixels
+* - raster: PNG, JPEG, GIF, BMP, TIFF, and WebP (VP8 / VP8L / VP8X) — natural pixels
+* - vector: SVG — intrinsic size from the root `<svg>` width/height or viewBox
+* - unrecognized formats return `null` (no measurable intrinsic size)
+*
+* Used by image `sizing: 'cover' | 'contain'` to compute an aspect-correct
+* `<a:srcRect>` crop from the *natural* image ratio rather than the displayed box.
+* @param {string} dataB64 - base64 image payload or `data:` URI
+* @returns {{ w: number, h: number } | null} natural size, or `null` when unmeasurable
+*/
+function getImageSizeFromBase64(dataB64) {
+	const b = decodeBase64ToBytes(dataB64);
+	return b ? getImageSizeFromBytes(b) : null;
+}
+/**
+* Read the intrinsic dimensions of an image from raw header bytes — the
+* byte-level core shared by {@link getImageSizeFromBase64} and the read API's
+* `Picture.setImage({ fit })`, which already holds the media bytes.
+* @param {Uint8Array} b - image bytes
+* @returns {{ w: number, h: number } | null} natural size, or `null` when unmeasurable
+*/
+function getImageSizeFromBytes(b) {
+	if (!b || b.length < 24) return null;
+	const u = (n) => b[n] ?? 0;
+	if (IMAGE_FORMATS.png.magic?.(b)) {
+		const w = u(16) << 24 | u(17) << 16 | u(18) << 8 | u(19);
+		const h = u(20) << 24 | u(21) << 16 | u(22) << 8 | u(23);
+		return w > 0 && h > 0 ? {
+			w,
+			h
+		} : null;
+	}
+	if (IMAGE_FORMATS.gif.magic?.(b)) {
+		const w = u(6) | u(7) << 8;
+		const h = u(8) | u(9) << 8;
+		return w > 0 && h > 0 ? {
+			w,
+			h
+		} : null;
+	}
+	if (IMAGE_FORMATS.bmp.magic?.(b)) {
+		if ((u(14) | u(15) << 8 | u(16) << 16 | u(17) << 24) === 12) {
+			const w = u(18) | u(19) << 8;
+			const h = u(20) | u(21) << 8;
+			return w > 0 && h > 0 ? {
+				w,
+				h
+			} : null;
+		}
+		if (b.length < 26) return null;
+		const w = u(18) | u(19) << 8 | u(20) << 16 | u(21) << 24;
+		const h = u(22) | u(23) << 8 | u(24) << 16 | u(25) << 24;
+		const aw = Math.abs(w);
+		const ah = Math.abs(h);
+		return aw > 0 && ah > 0 ? {
+			w: aw,
+			h: ah
+		} : null;
+	}
+	if (IMAGE_FORMATS.webp.magic?.(b)) {
+		const fourCC = String.fromCharCode(u(12), u(13), u(14), u(15));
+		if (fourCC === "VP8 " && b.length >= 30) {
+			const w = (u(26) | u(27) << 8) & 16383;
+			const h = (u(28) | u(29) << 8) & 16383;
+			return w > 0 && h > 0 ? {
+				w,
+				h
+			} : null;
+		}
+		if (fourCC === "VP8L" && b.length >= 25) {
+			const bits = u(21) | u(22) << 8 | u(23) << 16 | u(24) << 24;
+			const w = (bits & 16383) + 1;
+			const h = (bits >> 14 & 16383) + 1;
+			return w > 0 && h > 0 ? {
+				w,
+				h
+			} : null;
+		}
+		if (fourCC === "VP8X" && b.length >= 30) {
+			const w = (u(24) | u(25) << 8 | u(26) << 16) + 1;
+			const h = (u(27) | u(28) << 8 | u(29) << 16) + 1;
+			return w > 0 && h > 0 ? {
+				w,
+				h
+			} : null;
+		}
+		return null;
+	}
+	if (IMAGE_FORMATS.jpeg.magic?.(b)) {
+		let i = 2;
+		while (i + 9 < b.length) {
+			if (b[i] !== 255) {
+				i++;
+				continue;
+			}
+			const marker = u(i + 1);
+			if (marker === 255) {
+				i++;
+				continue;
+			}
+			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+				const h = u(i + 5) << 8 | u(i + 6);
+				const w = u(i + 7) << 8 | u(i + 8);
+				return w > 0 && h > 0 ? {
+					w,
+					h
+				} : null;
+			}
+			if (marker >= 208 && marker <= 217 || marker === 1) {
+				i += 2;
+				continue;
+			}
+			const segLen = u(i + 2) << 8 | u(i + 3);
+			if (segLen < 2) break;
+			i += 2 + segLen;
+		}
+		return null;
+	}
+	if (IMAGE_FORMATS.tiff.magic(b)) {
+		const little = b[0] === 73;
+		const u16 = (n) => little ? u(n) | u(n + 1) << 8 : u(n) << 8 | u(n + 1);
+		const u32 = (n) => little ? (u(n) | u(n + 1) << 8 | u(n + 2) << 16 | u(n + 3) << 24) >>> 0 : (u(n) << 24 | u(n + 1) << 16 | u(n + 2) << 8 | u(n + 3)) >>> 0;
+		const ifd = u32(4);
+		if (ifd + 2 > b.length) return null;
+		const entries = u16(ifd);
+		let w = 0;
+		let h = 0;
+		for (let i = 0; i < entries; i++) {
+			const entry = ifd + 2 + i * 12;
+			if (entry + 12 > b.length) return null;
+			const tag = u16(entry);
+			if (tag !== 256 && tag !== 257) continue;
+			const value = u16(entry + 2) === 3 ? u16(entry + 8) : u32(entry + 8);
+			if (tag === 256) w = value;
+			else h = value;
+		}
+		return w > 0 && h > 0 ? {
+			w,
+			h
+		} : null;
+	}
+	const text = utf8Decode(b);
+	if (/<svg[\s>]/i.test(text)) return getSvgSizeFromMarkup(text);
+	return null;
+}
+/**
+* Compute the `<a:srcRect>` crop percentages (each in 1/1000 of a percent, the
+* OOXML unit) for fitting an image of natural size `img` into a display `box`,
+* assuming the cropped region is then stretched to fill the box (`<a:stretch>`).
+*
+* - `cover`: fill the box, cropping the overflowing axis (positive l/r or t/b)
+* - `contain`: fit inside the box, letterboxing the short axis (negative l/r or t/b)
+*
+* Single source of truth for the crop math shared by the write side
+* (`ImageSizingXml`) and the read API's `Picture.setImage({ fit })`. `l`/`r` and
+* `t`/`b` are symmetric (centered crop).
+*
+* There is no fit for a side that is not greater than zero: a zero-size box gave every percentage
+* as `NaN`, and a zero-width one gave `-Infinity`, both written straight into the part.
+* @param {'cover' | 'contain'} type - fit mode
+* @param {{ w: number, h: number }} img - natural image pixel size
+* @param {{ w: number, h: number }} box - displayed frame size (any consistent unit)
+* @returns {{ l: number, r: number, t: number, b: number } | null} srcRect percentages, or `null`
+*   when any of the four sizes is not greater than zero
+*/
+function fitSrcRectPercents(type, img, box) {
+	if (!(img.w > 0 && img.h > 0 && box.w > 0 && box.h > 0)) return null;
+	const imgRatio = img.h / img.w;
+	const boxRatio = box.h / box.w;
+	let width;
+	let height;
+	if (type === "cover") {
+		const isBoxBased = boxRatio > imgRatio;
+		width = isBoxBased ? box.h / imgRatio : box.w;
+		height = isBoxBased ? box.h : box.w * imgRatio;
+	} else {
+		const widthBased = boxRatio > imgRatio;
+		width = widthBased ? box.w : box.h / imgRatio;
+		height = widthBased ? box.w * imgRatio : box.h;
+	}
+	const hz = Math.round(PERCENT_SCALE * .5 * (1 - box.w / width));
+	const vz = Math.round(PERCENT_SCALE * .5 * (1 - box.h / height));
+	return {
+		l: hz,
+		r: hz,
+		t: vz,
+		b: vz
+	};
+}
+/**
+* Read the intrinsic size of an SVG document from its root `<svg>` element.
+* Follows the SVG sizing model: an explicit absolute `width`/`height` pair wins;
+* otherwise the `viewBox` width/height defines the size (and thus aspect ratio).
+* Percentage or missing `width`/`height` fall through to `viewBox`.
+* @param {string} svg - SVG markup
+* @returns {{ w: number, h: number } | null} intrinsic size, or `null` when undeterminable
+*/
+function getSvgSizeFromMarkup(svg) {
+	const openTag = /<svg\b[^>]*>/i.exec(svg)?.[0];
+	if (!openTag) return null;
+	const attr = (name) => new RegExp(`(?:^|\\s)${name}\\s*=\\s*(["'])(.*?)\\1`, "i").exec(openTag)?.[2] ?? null;
+	const absLength = (val) => {
+		if (val == null || /%\s*$/.test(val)) return NaN;
+		const m = /^\s*\+?(\d*\.?\d+)/.exec(val);
+		return m ? parseFloat(m[1] ?? "") : NaN;
+	};
+	let w = absLength(attr("width"));
+	let h = absLength(attr("height"));
+	if (!(w > 0 && h > 0)) {
+		const vb = attr("viewBox");
+		const p = vb ? vb.trim().split(/[\s,]+/).map(Number) : [];
+		const vw = p[2];
+		const vh = p[3];
+		if (p.length === 4 && vw != null && vh != null && vw > 0 && vh > 0) {
+			w = vw;
+			h = vh;
+		}
+	}
+	return w > 0 && h > 0 ? {
+		w,
+		h
+	} : null;
+}
+/** Decode UTF-8 bytes to a string, isomorphic across Node and browsers. */
+function utf8Decode(bytes) {
+	return new TextDecoder().decode(bytes);
+}
+//#endregion
+export { TICK_MARKS as $, THEME_REL as $t, GROUPINGS as A, NOTES_MASTER_CONTENT_TYPE as At, RADAR_STYLE_ALIAS_NAMES as B, PRES_PROPS_CONTENT_TYPE as Bt, CROSS_BETWEEN as C, HYPERLINK_REL as Ct, ERROR_BAR_DIRECTIONS as D, MS_MEDIA_REL as Dt, EMBEDDED_FONT_SLOTS as E, MODERN_COMMENT_AUTHORS_REL as Et, LINE_END_TYPES as F, OFFICE_DOCUMENT_REL as Ft, TEXT_HORZ_OVERFLOW as G, SLIDE_LAYOUT_CONTENT_TYPE as Gt, TEXT_ANCHORS as H, RELATIONSHIPS_CONTENT_TYPE as Ht, PRESET_LINE_DASHES as I, OFFICE_REL as It, TEXT_TAB_ALIGN_TYPES as J, SLIDE_MASTER_REL as Jt, TEXT_SHAPE_TYPES as K, SLIDE_LAYOUT_REL as Kt, PRESET_MATERIALS as L, PACKAGE_REL as Lt, LIGHT_RIGS as M, NOTES_SLIDE_CONTENT_TYPE as Mt, LIGHT_RIG_DIRECTIONS as N, NOTES_SLIDE_REL as Nt, ERROR_BAR_TYPES as O, MS_POWERPOINT_CONTENT as Ot, LINE_DATA_SYMBOLS as P, OD_CONTENT as Pt, TICK_LABEL_POSITIONS as Q, THEME_CONTENT_TYPE as Qt, RADAR_STYLES as R, PACKAGE_REL_NS as Rt, COLOR_MAP_TOKENS as S, FONT_REL as St, DISPLAY_BLANKS_AS as T, MODEL3D_REL as Tt, TEXT_AUTONUM_SCHEMES as U, SHARED_PARTS as Ut, SCHEME_COLOR_VALUES as V, PRES_PROPS_REL as Vt, TEXT_CAPS_TYPES as W, SLIDE_CONTENT_TYPE as Wt, TEXT_VERTICAL as X, TABLE_STYLES_CONTENT_TYPE as Xt, TEXT_UNDERLINE_TYPES as Y, SLIDE_REL as Yt, THEME_COLOR_SLOTS as Z, TABLE_STYLES_REL as Zt, BAR_3D_SHAPES as _, CORE_PROPS_REL as _t, textAlignToken as a, PML_ROOT_NS as an, CHARTEX_REL as at, BEVEL_PRESETS as b, EXTENDED_PROPS_CONTENT_TYPE as bt, checkEnumOrThrow as c, decodeBase64ToBytes as cn, CHART_CONTENT_TYPE as ct, xsdBool as d, toMediaDataUri as dn, CHART_STYLE_REL as dt, VIDEO_REL as en, TIME_UNITS as et, xsdBoolIfTrue as f, imageFormatForBytes as fn, COMMENTS_CONTENT_TYPE as ft, AXIS_ORIENTATIONS as g, CORE_PROPS_CONTENT_TYPE as gt, stripHash as h, COMMENT_AUTHORS_REL as ht, HALIGN_BY_TEXT_ALIGN as i, OOXML_NS as in, CHARTEX_CONTENT_TYPE as it, LEGEND_POSITIONS as j, NOTES_MASTER_REL as jt, ERROR_BAR_VALUE_TYPES as k, MS_REL as kt, checkEnumOrWarn as l, hasBase64Header as ln, CHART_REL as lt, splitRgbaHex as m, imageFormatForExtension as mn, COMMENT_AUTHORS_CONTENT_TYPE as mt, getImageSizeFromBase64 as n, VIEW_PROPS_REL as nn, TRANSITION_VARIANT_ATTRIBUTES as nt, LINE_CAP_BY_TOKEN as o, TABLE_GRAPHIC_DATA_URI as on, CHART_COLOR_STYLE_CONTENT_TYPE as ot, isHexColor as p, imageFormatForContentType as pn, COMMENTS_REL as pt, TEXT_STRIKE_TYPES as q, SLIDE_MASTER_CONTENT_TYPE as qt, getImageSizeFromBytes as r, XLSX_CONTENT_TYPE as rn, AUDIO_REL as rt, lineCapToken as s, bytesToBase64 as sn, CHART_COLOR_STYLE_REL as st, fitSrcRectPercents as t, VIEW_PROPS_CONTENT_TYPE as tn, TRANSITION_TYPES as tt, boolValue as u, svgMarkupToDataUri as un, CHART_STYLE_CONTENT_TYPE as ut, BAR_DIRECTIONS as v, CUSTOM_PROPS_CONTENT_TYPE as vt, DEFAULT_COLOR_MAP as w, IMAGE_REL as wt, BUILT_IN_UNITS as x, EXTENDED_PROPS_REL as xt, BAR_GROUPINGS as y, CUSTOM_PROPS_REL as yt, RADAR_STYLE_ALIASES as z, PRESENTATION_MAIN_CONTENT_TYPE as zt };
+
+//# sourceMappingURL=image-size-CvN2iCA4.js.map