pptx-ts 0.0.1 → 4.0.0

package/dist/text-anchor-CrYXAfUu.js

@@ -0,0 +1,176 @@
+import { mn as imageFormatForExtension, pn as imageFormatForContentType } from "./image-size-CvN2iCA4.js";
+//#region src/media/content-type.ts
+/**
+* OPC content types for embedded media parts, keyed by file extension.
+*
+* Both mappings reproduce what PowerPoint itself authors rather than the IANA-preferred
+* spelling — a package that disagrees (e.g. `audio/mp3` for an `.mp3`) is the kind of thing
+* PowerPoint offers to repair.
+*/
+/**
+* Map an image file extension to its OOXML content type, through the format registry in
+* `media/image-formats.ts`. An extension the registry does not carry falls through to
+* `image/<extn>`, which is right for any format whose content type is its extension.
+* Only the content type is derived here; the file extension (used for the media Target
+* filename) is left to the caller.
+* @param {string} extn - image file extension (e.g. `png`, `jpg`, `emf`)
+* @returns {string} OOXML content type (e.g. `image/png`, `image/x-emf`)
+*/
+function imageContentType(extn) {
+	return imageFormatForExtension(extn)?.contentType ?? "image/" + (extn || "").toLowerCase();
+}
+/**
+* The media type an inline payload states in its header, lower-cased, or `null` when it states none.
+*
+* Takes a `data:` URI or the same header without its `data:` scheme (`image/png;base64,…`), the
+* two forms the definers accept. It is the one reading of that header: the patterns it replaces
+* each stopped short somewhere, `image\/(\w+);` at `-`, `.` and `+`, so `data:image/x-emf;…` named
+* no type and its EMF bytes were written into a `.png` part declared `image/png`.
+* @param data - a `data:` URI, a header-first base64 payload, or anything else
+* @returns the `type/subtype`, e.g. `image/x-emf`, or `null`
+*/
+function dataUriMediaType(data) {
+	return /^(?:data:)?([a-z]+\/[\w.+-]+)[;,]/i.exec(data || "")?.[1]?.toLowerCase() ?? null;
+}
+/**
+* Resolve the file extension an embedded image part should carry, from the caller's source.
+*
+* A `data:` URI states its mime type outright, so it wins over `path`: the bytes are the thing
+* being embedded, and a caller may supply them with no path at all (or with a path whose
+* extension disagrees with the payload). The extension chosen here names the media part *and*,
+* via {@link imageContentType}, decides the `<Default>` the package declares for it — so
+* getting it from a placeholder path is how a deck ends up declaring `image/png` over SVG
+* bytes, which is exactly the mismatch PowerPoint offers to "repair".
+*
+* A type the format registry carries names its part by the registry's extension (`image/x-emf` is
+* `emf`, `image/svg+xml` is `svg`). Any other type names it by its subtype, so `image/jpg` keeps
+* `jpg`. The result is always lower-cased, so a `data:image/PNG;` source names its part the same
+* way a `photo.PNG` path does.
+* @param {string} path - caller-supplied path/URL (may be empty); query and fragment are stripped
+* @param {string} data - caller-supplied `data:`/base64 payload (may be empty)
+* @returns {string} file extension, no dot (e.g. `png`, `jpeg`, `svg`)
+*/
+function imageExtensionForSource(path, data) {
+	const strPath = path || "";
+	const pathExtn = (((strPath.slice(strPath.lastIndexOf("/") + 1).split("?")[0] || "").split(".").pop() || "png").split("#")[0] || "png").toLowerCase();
+	const mime = dataUriMediaType(data);
+	if (mime?.startsWith("image/")) return imageFormatForContentType(mime)?.ext ?? mime.slice(6);
+	return pathExtn;
+}
+/**
+* Map an audio content type's subtype back to the file extension a media part should use.
+*
+* Needed because a caller supplying sound bytes as a `data:` URI states a *content type*
+* (`data:audio/x-wav;base64,…`), while the media part needs a *filename*. Taking the subtype
+* verbatim produces `audio1.x-wav` — legal, since the package would then declare a matching
+* `<Default Extension="x-wav"/>`, but a file type that does not exist and that no other tool
+* recognises. `audio/x-wav` in particular is not an edge case: it is exactly what PowerPoint
+* authors for an embedded transition sound, so it arrives on any deck read back in.
+*
+* Only the spellings that are *not* already an extension are listed; anything else (`ogg`,
+* `flac`, `aac`, …) is its own extension and falls through. Read against {@link avContentType},
+* which maps the same pairs in the other direction.
+*/
+function audioExtensionForSubtype(subtype) {
+	switch ((subtype || "").toLowerCase()) {
+		case "x-wav":
+		case "wave":
+		case "vnd.wave": return "wav";
+		case "mpeg": return "mp3";
+		case "x-ms-wma": return "wma";
+		case "mp4": return "m4a";
+		default: return (subtype || "").toLowerCase();
+	}
+}
+/**
+* Resolve the OPC content type for an embedded audio/video part by file extension,
+* matching what PowerPoint authors (e.g. `mp3` → `audio/mpeg`, not `audio/mp3`).
+* The `mtype` disambiguates extensions Office maps differently per kind and seeds
+* the `mtype/extn` fallback for anything unlisted.
+* @param {string} extn - media file extension (no dot), case-insensitive
+* @param {'audio' | 'video'} mtype - whether the item is audio or video
+*/
+function avContentType(extn, mtype) {
+	switch ((extn || "").toLowerCase()) {
+		case "mp4": return mtype === "audio" ? "audio/mp4" : "video/mp4";
+		case "m4v": return "video/mp4";
+		case "mov": return "video/quicktime";
+		case "avi": return "video/avi";
+		case "wmv": return "video/x-ms-wmv";
+		case "mpg":
+		case "mpeg": return mtype === "audio" ? "audio/mpeg" : "video/mpeg";
+		case "ogv": return "video/ogg";
+		case "webm": return "video/webm";
+		case "mp3": return "audio/mpeg";
+		case "m4a": return "audio/mp4";
+		case "wav": return "audio/x-wav";
+		case "wma": return "audio/x-ms-wma";
+		case "aac": return "audio/aac";
+		case "oga":
+		case "ogg": return "audio/ogg";
+		case "flac": return "audio/flac";
+		default: return mtype + "/" + (extn || "").toLowerCase();
+	}
+}
+/**
+* The extension an emitted *asset filename* should carry for a media content type, or `null`
+* when nothing here names one and the caller should fall back to the source part's own suffix.
+*
+* This is the on-disk spelling, not the media part's: `image/jpeg` is `jpg` and `image/tiff` is
+* `tif` here, because an asset directory is read by people and opened by desktop viewers. See the
+* `filenameExt` column in `media/image-formats.ts`. Audio goes through {@link audioExtensionForSubtype}, which is
+* already the one table for that direction.
+*/
+function assetFilenameExtension(contentType) {
+	const image = imageFormatForContentType(contentType);
+	if (image) return image.filenameExt;
+	const ct = (contentType || "").toLowerCase();
+	return ct.startsWith("audio/") ? audioExtensionForSubtype(ct.slice(6)) : null;
+}
+//#endregion
+//#region src/ooxml/text-anchor.ts
+/**
+* Every `valign` the write API accepts, the anchor token it means, and the other spellings the
+* definers between them have always taken.
+*
+* The three definers read `valign` three ways — `startsWith('b'|'m'|'t')`, a chain of
+* `.replace('top','t')…` that let any other string through *verbatim* into `anchor=`, and a
+* longer chain that also took `btm` and `center`. This table is the union of what they named;
+* anything else is a warning and an omitted attribute rather than an invalid one.
+*
+* `valign` leads each row because it is the direction with a preferred answer: several spellings
+* mean one anchor, and only one of them is what a generated script should write back.
+*/
+const VALIGN_TABLE = [
+	{
+		valign: "top",
+		anchor: "t",
+		aliases: ["t"]
+	},
+	{
+		valign: "middle",
+		anchor: "ctr",
+		aliases: [
+			"c",
+			"ctr",
+			"center",
+			"m"
+		]
+	},
+	{
+		valign: "bottom",
+		anchor: "b",
+		aliases: ["b", "btm"]
+	}
+];
+/** Every spelling of `valign` the definers accept, mapped to the one anchor token it means. */
+const TEXT_ANCHOR_BY_VALIGN = Object.fromEntries(VALIGN_TABLE.flatMap((row) => [row.valign, ...row.aliases].map((spelling) => [spelling, row.anchor])));
+/**
+* An anchor token back to the `valign` a generated script writes — the preferred spelling of the
+* row, never one of its aliases.
+*/
+const VALIGN_BY_ANCHOR = Object.fromEntries(VALIGN_TABLE.map((row) => [row.anchor, row.valign]));
+//#endregion
+export { avContentType as a, imageExtensionForSource as c, audioExtensionForSubtype as i, VALIGN_BY_ANCHOR as n, dataUriMediaType as o, assetFilenameExtension as r, imageContentType as s, TEXT_ANCHOR_BY_VALIGN as t };
+
+//# sourceMappingURL=text-anchor-CrYXAfUu.js.map

package/dist/text-anchor-CrYXAfUu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-anchor-CrYXAfUu.js","names":[],"sources":["../src/media/content-type.ts","../src/ooxml/text-anchor.ts"],"sourcesContent":["/**\n * OPC content types for embedded media parts, keyed by file extension.\n *\n * Both mappings reproduce what PowerPoint itself authors rather than the IANA-preferred\n * spelling — a package that disagrees (e.g. `audio/mp3` for an `.mp3`) is the kind of thing\n * PowerPoint offers to repair.\n */\n\nimport { imageFormatForContentType, imageFormatForExtension } from './image-formats.js'\n\n/**\n * Map an image file extension to its OOXML content type, through the format registry in\n * `media/image-formats.ts`. An extension the registry does not carry falls through to\n * `image/<extn>`, which is right for any format whose content type is its extension.\n * Only the content type is derived here; the file extension (used for the media Target\n * filename) is left to the caller.\n * @param {string} extn - image file extension (e.g. `png`, `jpg`, `emf`)\n * @returns {string} OOXML content type (e.g. `image/png`, `image/x-emf`)\n */\nexport function imageContentType(extn: string): string {\n\treturn imageFormatForExtension(extn)?.contentType ?? 'image/' + (extn || '').toLowerCase()\n}\n\n/**\n * The media type an inline payload states in its header, lower-cased, or `null` when it states none.\n *\n * Takes a `data:` URI or the same header without its `data:` scheme (`image/png;base64,…`), the\n * two forms the definers accept. It is the one reading of that header: the patterns it replaces\n * each stopped short somewhere, `image\\/(\\w+);` at `-`, `.` and `+`, so `data:image/x-emf;…` named\n * no type and its EMF bytes were written into a `.png` part declared `image/png`.\n * @param data - a `data:` URI, a header-first base64 payload, or anything else\n * @returns the `type/subtype`, e.g. `image/x-emf`, or `null`\n */\nexport function dataUriMediaType(data: string): string | null {\n\tconst match = /^(?:data:)?([a-z]+\\/[\\w.+-]+)[;,]/i.exec(data || '')\n\treturn match?.[1]?.toLowerCase() ?? null\n}\n\n/**\n * Resolve the file extension an embedded image part should carry, from the caller's source.\n *\n * A `data:` URI states its mime type outright, so it wins over `path`: the bytes are the thing\n * being embedded, and a caller may supply them with no path at all (or with a path whose\n * extension disagrees with the payload). The extension chosen here names the media part *and*,\n * via {@link imageContentType}, decides the `<Default>` the package declares for it — so\n * getting it from a placeholder path is how a deck ends up declaring `image/png` over SVG\n * bytes, which is exactly the mismatch PowerPoint offers to \"repair\".\n *\n * A type the format registry carries names its part by the registry's extension (`image/x-emf` is\n * `emf`, `image/svg+xml` is `svg`). Any other type names it by its subtype, so `image/jpg` keeps\n * `jpg`. The result is always lower-cased, so a `data:image/PNG;` source names its part the same\n * way a `photo.PNG` path does.\n * @param {string} path - caller-supplied path/URL (may be empty); query and fragment are stripped\n * @param {string} data - caller-supplied `data:`/base64 payload (may be empty)\n * @returns {string} file extension, no dot (e.g. `png`, `jpeg`, `svg`)\n */\nexport function imageExtensionForSource(path: string, data: string): string {\n\t// NOTE: Split to address URLs with params (eg: `path/brent.jpg?someParam=true`)\n\tconst strPath = path || ''\n\tconst pathFile = strPath.slice(strPath.lastIndexOf('/') + 1).split('?')[0] || ''\n\tconst pathExtn = ((pathFile.split('.').pop() || 'png').split('#')[0] || 'png').toLowerCase()\n\n\tconst mime = dataUriMediaType(data)\n\tif (mime?.startsWith('image/')) return imageFormatForContentType(mime)?.ext ?? mime.slice('image/'.length)\n\treturn pathExtn\n}\n\n/**\n * Map an audio content type's subtype back to the file extension a media part should use.\n *\n * Needed because a caller supplying sound bytes as a `data:` URI states a *content type*\n * (`data:audio/x-wav;base64,…`), while the media part needs a *filename*. Taking the subtype\n * verbatim produces `audio1.x-wav` — legal, since the package would then declare a matching\n * `<Default Extension=\"x-wav\"/>`, but a file type that does not exist and that no other tool\n * recognises. `audio/x-wav` in particular is not an edge case: it is exactly what PowerPoint\n * authors for an embedded transition sound, so it arrives on any deck read back in.\n *\n * Only the spellings that are *not* already an extension are listed; anything else (`ogg`,\n * `flac`, `aac`, …) is its own extension and falls through. Read against {@link avContentType},\n * which maps the same pairs in the other direction.\n */\nexport function audioExtensionForSubtype(subtype: string): string {\n\tswitch ((subtype || '').toLowerCase()) {\n\t\tcase 'x-wav':\n\t\tcase 'wave':\n\t\tcase 'vnd.wave':\n\t\t\treturn 'wav'\n\t\tcase 'mpeg':\n\t\t\treturn 'mp3'\n\t\tcase 'x-ms-wma':\n\t\t\treturn 'wma'\n\t\tcase 'mp4':\n\t\t\treturn 'm4a'\n\t\tdefault:\n\t\t\treturn (subtype || '').toLowerCase()\n\t}\n}\n\n/**\n * Resolve the OPC content type for an embedded audio/video part by file extension,\n * matching what PowerPoint authors (e.g. `mp3` → `audio/mpeg`, not `audio/mp3`).\n * The `mtype` disambiguates extensions Office maps differently per kind and seeds\n * the `mtype/extn` fallback for anything unlisted.\n * @param {string} extn - media file extension (no dot), case-insensitive\n * @param {'audio' | 'video'} mtype - whether the item is audio or video\n */\nexport function avContentType(extn: string, mtype: 'audio' | 'video'): string {\n\tswitch ((extn || '').toLowerCase()) {\n\t\t// video\n\t\tcase 'mp4':\n\t\t\treturn mtype === 'audio' ? 'audio/mp4' : 'video/mp4'\n\t\tcase 'm4v':\n\t\t\treturn 'video/mp4'\n\t\tcase 'mov':\n\t\t\treturn 'video/quicktime'\n\t\tcase 'avi':\n\t\t\treturn 'video/avi'\n\t\tcase 'wmv':\n\t\t\treturn 'video/x-ms-wmv'\n\t\tcase 'mpg':\n\t\tcase 'mpeg':\n\t\t\treturn mtype === 'audio' ? 'audio/mpeg' : 'video/mpeg'\n\t\tcase 'ogv':\n\t\t\treturn 'video/ogg'\n\t\tcase 'webm':\n\t\t\treturn 'video/webm'\n\t\t// audio\n\t\tcase 'mp3':\n\t\t\treturn 'audio/mpeg'\n\t\tcase 'm4a':\n\t\t\treturn 'audio/mp4'\n\t\tcase 'wav':\n\t\t\treturn 'audio/x-wav' // PowerPoint authors the x- form (e.g. embedded transition sounds)\n\t\tcase 'wma':\n\t\t\treturn 'audio/x-ms-wma'\n\t\tcase 'aac':\n\t\t\treturn 'audio/aac'\n\t\tcase 'oga':\n\t\tcase 'ogg':\n\t\t\treturn 'audio/ogg'\n\t\tcase 'flac':\n\t\t\treturn 'audio/flac'\n\t\tdefault:\n\t\t\treturn mtype + '/' + (extn || '').toLowerCase()\n\t}\n}\n\n/**\n * The extension an emitted *asset filename* should carry for a media content type, or `null`\n * when nothing here names one and the caller should fall back to the source part's own suffix.\n *\n * This is the on-disk spelling, not the media part's: `image/jpeg` is `jpg` and `image/tiff` is\n * `tif` here, because an asset directory is read by people and opened by desktop viewers. See the\n * `filenameExt` column in `media/image-formats.ts`. Audio goes through {@link audioExtensionForSubtype}, which is\n * already the one table for that direction.\n */\nexport function assetFilenameExtension(contentType: string): string | null {\n\tconst image = imageFormatForContentType(contentType)\n\tif (image) return image.filenameExt\n\tconst ct = (contentType || '').toLowerCase()\n\treturn ct.startsWith('audio/') ? audioExtensionForSubtype(ct.slice('audio/'.length)) : null\n}\n","/**\n * `a:bodyPr/@anchor` and `a:tcPr/@anchor`, and the write API's `valign` on the other side of it.\n *\n * Two tables stated the same correspondence in opposite directions and could not see each other:\n * the emitters' spelling table in `gen/drawingml/text-body.ts`, and its hand-written inverse in\n * `script/from-read/values.ts`, which maps a read deck's anchor back to the `valign` a generated\n * script writes. `script/` cannot import `gen/` — it has no such import anywhere, deliberately —\n * so the inverse could not be derived where it stood, and a token added to one table would have\n * meant a script that reads an anchor it cannot write back.\n *\n * The correspondence itself is a fact about the format, so it lives here, as one table with both\n * directions derived from it.\n *\n * This module keeps `ooxml/`'s no-runtime-imports property: {@link TEXT_ANCHORS} is the schema's\n * own list from a module with none either, and the {@link TextAnchor} reference is type-only, so\n * it is erased. That reference is still a real check — it is what ties the enum the write API\n * exposes to the tokens named here.\n */\n\nimport type { TextAnchor } from '../enums.js'\nimport { TEXT_ANCHORS } from './st-enums.js'\n\n/**\n * The `ST_TextAnchoringType` tokens this library writes, checked against both the schema's list\n * and the public {@link TextAnchor} enum.\n *\n * `Extract` is that check twice over: a token here that is not in `ST_TextAnchoringType`, or not\n * in the enum, is dropped from the type and the table below stops compiling. Compile-time on\n * purpose — every value in the table is a literal, so a runtime check could never fail, and a\n * check that cannot fail is worse than none.\n *\n * The library writes three of the schema's five: `just` and `dist` are anchoring modes no\n * option surfaces.\n */\nexport type TextAnchorToken = Extract<`${TextAnchor}`, (typeof TEXT_ANCHORS)[number]>\n\n/**\n * Every `valign` the write API accepts, the anchor token it means, and the other spellings the\n * definers between them have always taken.\n *\n * The three definers read `valign` three ways — `startsWith('b'|'m'|'t')`, a chain of\n * `.replace('top','t')…` that let any other string through *verbatim* into `anchor=`, and a\n * longer chain that also took `btm` and `center`. This table is the union of what they named;\n * anything else is a warning and an omitted attribute rather than an invalid one.\n *\n * `valign` leads each row because it is the direction with a preferred answer: several spellings\n * mean one anchor, and only one of them is what a generated script should write back.\n */\nconst VALIGN_TABLE = [\n\t{ valign: 'top', anchor: 't', aliases: ['t'] },\n\t{ valign: 'middle', anchor: 'ctr', aliases: ['c', 'ctr', 'center', 'm'] },\n\t{ valign: 'bottom', anchor: 'b', aliases: ['b', 'btm'] },\n] as const satisfies ReadonlyArray<{ valign: string; anchor: TextAnchorToken; aliases: readonly string[] }>\n\n/** Every spelling of `valign` the definers accept, mapped to the one anchor token it means. */\nexport const TEXT_ANCHOR_BY_VALIGN: Readonly<Record<string, TextAnchorToken>> = Object.fromEntries(\n\tVALIGN_TABLE.flatMap((row) => [row.valign, ...row.aliases].map((spelling) => [spelling, row.anchor]))\n)\n\n/**\n * An anchor token back to the `valign` a generated script writes — the preferred spelling of the\n * row, never one of its aliases.\n */\nexport const VALIGN_BY_ANCHOR: Readonly<Record<string, string>> = Object.fromEntries(\n\tVALIGN_TABLE.map((row) => [row.anchor, row.valign])\n)\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,SAAgB,iBAAiB,MAAsB;CACtD,OAAO,wBAAwB,IAAI,CAAC,EAAE,eAAe,YAAY,QAAQ,GAAA,CAAI,YAAY;AAC1F;;;;;;;;;;;AAYA,SAAgB,iBAAiB,MAA6B;CAE7D,OADc,qCAAqC,KAAK,QAAQ,EACrD,CAAC,GAAG,EAAE,EAAE,YAAY,KAAK;AACrC;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,wBAAwB,MAAc,MAAsB;CAE3E,MAAM,UAAU,QAAQ;CAExB,MAAM,cADW,QAAQ,MAAM,QAAQ,YAAY,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,GAAA,CAClD,MAAM,GAAG,CAAC,CAAC,IAAI,KAAK,MAAA,CAAO,MAAM,GAAG,CAAC,CAAC,MAAM,MAAA,CAAO,YAAY;CAE3F,MAAM,OAAO,iBAAiB,IAAI;CAClC,IAAI,MAAM,WAAW,QAAQ,GAAG,OAAO,0BAA0B,IAAI,CAAC,EAAE,OAAO,KAAK,MAAM,CAAe;CACzG,OAAO;AACR;;;;;;;;;;;;;;;AAgBA,SAAgB,yBAAyB,SAAyB;CACjE,SAAS,WAAW,GAAA,CAAI,YAAY,GAApC;EACC,KAAK;EACL,KAAK;EACL,KAAK,YACJ,OAAO;EACR,KAAK,QACJ,OAAO;EACR,KAAK,YACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,SACC,QAAQ,WAAW,GAAA,CAAI,YAAY;CACrC;AACD;;;;;;;;;AAUA,SAAgB,cAAc,MAAc,OAAkC;CAC7E,SAAS,QAAQ,GAAA,CAAI,YAAY,GAAjC;EAEC,KAAK,OACJ,OAAO,UAAU,UAAU,cAAc;EAC1C,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK;EACL,KAAK,QACJ,OAAO,UAAU,UAAU,eAAe;EAC3C,KAAK,OACJ,OAAO;EACR,KAAK,QACJ,OAAO;EAER,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK,OACJ,OAAO;EACR,KAAK;EACL,KAAK,OACJ,OAAO;EACR,KAAK,QACJ,OAAO;EACR,SACC,OAAO,QAAQ,OAAO,QAAQ,GAAA,CAAI,YAAY;CAChD;AACD;;;;;;;;;;AAWA,SAAgB,uBAAuB,aAAoC;CAC1E,MAAM,QAAQ,0BAA0B,WAAW;CACnD,IAAI,OAAO,OAAO,MAAM;CACxB,MAAM,MAAM,eAAe,GAAA,CAAI,YAAY;CAC3C,OAAO,GAAG,WAAW,QAAQ,IAAI,yBAAyB,GAAG,MAAM,CAAe,CAAC,IAAI;AACxF;;;;;;;;;;;;;;;ACjHA,MAAM,eAAe;CACpB;EAAE,QAAQ;EAAO,QAAQ;EAAK,SAAS,CAAC,GAAG;CAAE;CAC7C;EAAE,QAAQ;EAAU,QAAQ;EAAO,SAAS;GAAC;GAAK;GAAO;GAAU;EAAG;CAAE;CACxE;EAAE,QAAQ;EAAU,QAAQ;EAAK,SAAS,CAAC,KAAK,KAAK;CAAE;AACxD;;AAGA,MAAa,wBAAmE,OAAO,YACtF,aAAa,SAAS,QAAQ,CAAC,IAAI,QAAQ,GAAG,IAAI,OAAO,CAAC,CAAC,KAAK,aAAa,CAAC,UAAU,IAAI,MAAM,CAAC,CAAC,CACrG;;;;;AAMA,MAAa,mBAAqD,OAAO,YACxE,aAAa,KAAK,QAAQ,CAAC,IAAI,QAAQ,IAAI,MAAM,CAAC,CACnD"}

package/dist/transition-speed-kUEWDWTx.js

@@ -0,0 +1,14 @@
+//#region src/ooxml/transition-speed.ts
+/**
+* Map an exact duration (ms) to the speed bucket it falls in.
+* @param durationMs - the transition's duration, in milliseconds
+*/
+function transitionSpeedForDuration(durationMs) {
+	if (durationMs <= 500) return "fast";
+	if (durationMs <= 1e3) return "med";
+	return "slow";
+}
+//#endregion
+export { transitionSpeedForDuration as t };
+
+//# sourceMappingURL=transition-speed-kUEWDWTx.js.map

package/dist/transition-speed-kUEWDWTx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transition-speed-kUEWDWTx.js","names":[],"sources":["../src/ooxml/transition-speed.ts"],"sourcesContent":["/**\n * PowerPoint's coarse `p:transition/@spd` bucket for an exact duration.\n *\n * The write path (`gen/anim/transition.ts`) and the read model's transition setter\n * (`read/api/transition.ts`) each carried a byte-identical copy. A duration that lands in a\n * different bucket on the two sides would make a transition set through the read model differ\n * from the same transition authored fresh, so the boundaries live here once.\n *\n * This module keeps `ooxml/`'s no-runtime-imports property: the reference below is type-only.\n */\n\nimport type { TRANSITION_SPEEDS } from './st-enums.js'\n\n/** An `ST_TransitionSpeed` token. */\nexport type TransitionSpeedToken = (typeof TRANSITION_SPEEDS)[number]\n\n/**\n * Map an exact duration (ms) to the speed bucket it falls in.\n * @param durationMs - the transition's duration, in milliseconds\n */\nexport function transitionSpeedForDuration(durationMs: number): TransitionSpeedToken {\n\tif (durationMs <= 500) return 'fast'\n\tif (durationMs <= 1000) return 'med'\n\treturn 'slow'\n}\n"],"mappings":";;;;;AAoBA,SAAgB,2BAA2B,YAA0C;CACpF,IAAI,cAAc,KAAK,OAAO;CAC9B,IAAI,cAAc,KAAM,OAAO;CAC/B,OAAO;AACR"}