pptx-ts 0.0.1 → 4.0.0

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

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

package/dist/slide-size-BalTjFuv.js

@@ -0,0 +1,88 @@
+//#region src/ooxml/slide-size.ts
+/**
+* The slide size a presentation has when `presentation.xml` declares none.
+*
+* `p:sldSz` is optional in `CT_Presentation` (`minOccurs="0"`), and the schema says nothing about
+* what its absence means: `cx` and `cy` are required only when the element is there. So the answer
+* is PowerPoint's. A deck with `p:sldSz` removed opens at 720 × 540 pt, the 10in × 7.5in on-screen
+* 4:3 size (`ppSlideSizeOnScreen`), measured over COM against a control copy that kept its
+* 960 × 540 pt declaration. That is `LAYOUT_4x3`, not the write path's `LAYOUT_16x9` default and
+* not `LAYOUT_WIDE`.
+*
+* Anything that has to name a size for such a deck takes this one. The script converter and
+* `inspect` each had their own, and they disagreed.
+*/
+const ABSENT_SLIDE_SIZE_EMU = Object.freeze({
+	widthEmu: 9144e3,
+	heightEmu: 6858e3
+});
+/**
+* The standard slide sizes, each with the label PowerPoint shows for it, as `docProps/app.xml`'s
+* `<PresentationFormat>` spells it, and the `p:sldSz/@type` PowerPoint writes for it.
+*
+* The labels are PowerPoint's own, read back from decks it re-saved, and three of them follow
+* `@type` rather than the dimensions: a deck re-saved from `type="screen16x9"` comes back
+* `On-screen Show (16:9)`, while the same dimensions set through `PageSetup`, which writes no type,
+* come back `Custom`. `LAYOUT_WIDE`'s 13.333in × 7.5in is recognised as `Widescreen` from its
+* dimensions alone, and PowerPoint writes it with no `type` at all. Anything else is `Custom`.
+*
+* One table for both, so the label `app.xml` states and the type `presentation.xml` declares
+* cannot disagree about a deck.
+*
+* Matched on exact EMU rather than on aspect ratio: the ratio of 10in × 7.5in and of
+* 13.333in × 10in is the same, and PowerPoint labels only the first of them 4:3.
+*/
+const STANDARD_SLIDE_SIZES = Object.freeze([
+	{
+		cx: 9144e3,
+		cy: 6858e3,
+		label: "On-screen Show (4:3)",
+		type: "screen4x3"
+	},
+	{
+		cx: 9144e3,
+		cy: 5143500,
+		label: "On-screen Show (16:9)",
+		type: "screen16x9"
+	},
+	{
+		cx: 9144e3,
+		cy: 5715e3,
+		label: "On-screen Show (16:10)",
+		type: "screen16x10"
+	},
+	{
+		cx: 12192e3,
+		cy: 6858e3,
+		label: "Widescreen",
+		type: void 0
+	}
+]);
+function standardSlideSize(widthEmu, heightEmu) {
+	return STANDARD_SLIDE_SIZES.find(({ cx, cy }) => cx === widthEmu && cy === heightEmu);
+}
+/**
+* `<PresentationFormat>` for a deck of this size, or `Custom` for one that matches no standard
+* size. `app.xml` used to say `On-screen Show (16:9)` whatever the deck.
+* @param widthEmu - the deck's slide width in EMU
+* @param heightEmu - the deck's slide height in EMU
+*/
+function presentationFormatLabel(widthEmu, heightEmu) {
+	return standardSlideSize(widthEmu, heightEmu)?.label ?? "Custom";
+}
+/**
+* `p:sldSz/@type` for a deck of this size, or `undefined` where PowerPoint writes none: at the
+* widescreen size, and at any size that is not standard.
+*
+* Taken from the dimensions, not from the layout's name, so a `defineLayout` at exactly
+* 10in × 5.625in is typed as the on-screen 16:9 size it is, as its `app.xml` label already says.
+* @param widthEmu - the deck's slide width in EMU
+* @param heightEmu - the deck's slide height in EMU
+*/
+function slideSizeType(widthEmu, heightEmu) {
+	return standardSlideSize(widthEmu, heightEmu)?.type;
+}
+//#endregion
+export { presentationFormatLabel as n, slideSizeType as r, ABSENT_SLIDE_SIZE_EMU as t };
+
+//# sourceMappingURL=slide-size-BalTjFuv.js.map

package/dist/slide-size-BalTjFuv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slide-size-BalTjFuv.js","names":[],"sources":["../src/ooxml/slide-size.ts"],"sourcesContent":["/**\n * The slide size a presentation has when `presentation.xml` declares none.\n *\n * `p:sldSz` is optional in `CT_Presentation` (`minOccurs=\"0\"`), and the schema says nothing about\n * what its absence means: `cx` and `cy` are required only when the element is there. So the answer\n * is PowerPoint's. A deck with `p:sldSz` removed opens at 720 × 540 pt, the 10in × 7.5in on-screen\n * 4:3 size (`ppSlideSizeOnScreen`), measured over COM against a control copy that kept its\n * 960 × 540 pt declaration. That is `LAYOUT_4x3`, not the write path's `LAYOUT_16x9` default and\n * not `LAYOUT_WIDE`.\n *\n * Anything that has to name a size for such a deck takes this one. The script converter and\n * `inspect` each had their own, and they disagreed.\n */\nexport const ABSENT_SLIDE_SIZE_EMU: Readonly<{ widthEmu: number; heightEmu: number }> = Object.freeze({\n\twidthEmu: 9144000,\n\theightEmu: 6858000,\n})\n\n/** The `ST_SlideSizeType` values a written deck can carry; `custom` is the schema default. */\nexport type SlideSizeType = 'screen4x3' | 'screen16x9' | 'screen16x10'\n\n/**\n * The standard slide sizes, each with the label PowerPoint shows for it, as `docProps/app.xml`'s\n * `<PresentationFormat>` spells it, and the `p:sldSz/@type` PowerPoint writes for it.\n *\n * The labels are PowerPoint's own, read back from decks it re-saved, and three of them follow\n * `@type` rather than the dimensions: a deck re-saved from `type=\"screen16x9\"` comes back\n * `On-screen Show (16:9)`, while the same dimensions set through `PageSetup`, which writes no type,\n * come back `Custom`. `LAYOUT_WIDE`'s 13.333in × 7.5in is recognised as `Widescreen` from its\n * dimensions alone, and PowerPoint writes it with no `type` at all. Anything else is `Custom`.\n *\n * One table for both, so the label `app.xml` states and the type `presentation.xml` declares\n * cannot disagree about a deck.\n *\n * Matched on exact EMU rather than on aspect ratio: the ratio of 10in × 7.5in and of\n * 13.333in × 10in is the same, and PowerPoint labels only the first of them 4:3.\n */\nconst STANDARD_SLIDE_SIZES: ReadonlyArray<\n\tReadonly<{ cx: number; cy: number; label: string; type: SlideSizeType | undefined }>\n> = Object.freeze([\n\t{ cx: 9144000, cy: 6858000, label: 'On-screen Show (4:3)', type: 'screen4x3' },\n\t{ cx: 9144000, cy: 5143500, label: 'On-screen Show (16:9)', type: 'screen16x9' },\n\t{ cx: 9144000, cy: 5715000, label: 'On-screen Show (16:10)', type: 'screen16x10' },\n\t{ cx: 12192000, cy: 6858000, label: 'Widescreen', type: undefined },\n])\n\nfunction standardSlideSize(widthEmu: number, heightEmu: number) {\n\treturn STANDARD_SLIDE_SIZES.find(({ cx, cy }) => cx === widthEmu && cy === heightEmu)\n}\n\n/**\n * `<PresentationFormat>` for a deck of this size, or `Custom` for one that matches no standard\n * size. `app.xml` used to say `On-screen Show (16:9)` whatever the deck.\n * @param widthEmu - the deck's slide width in EMU\n * @param heightEmu - the deck's slide height in EMU\n */\nexport function presentationFormatLabel(widthEmu: number, heightEmu: number): string {\n\treturn standardSlideSize(widthEmu, heightEmu)?.label ?? 'Custom'\n}\n\n/**\n * `p:sldSz/@type` for a deck of this size, or `undefined` where PowerPoint writes none: at the\n * widescreen size, and at any size that is not standard.\n *\n * Taken from the dimensions, not from the layout's name, so a `defineLayout` at exactly\n * 10in × 5.625in is typed as the on-screen 16:9 size it is, as its `app.xml` label already says.\n * @param widthEmu - the deck's slide width in EMU\n * @param heightEmu - the deck's slide height in EMU\n */\nexport function slideSizeType(widthEmu: number, heightEmu: number): SlideSizeType | undefined {\n\treturn standardSlideSize(widthEmu, heightEmu)?.type\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAa,wBAA2E,OAAO,OAAO;CACrG,UAAU;CACV,WAAW;AACZ,CAAC;;;;;;;;;;;;;;;;;AAqBD,MAAM,uBAEF,OAAO,OAAO;CACjB;EAAE,IAAI;EAAS,IAAI;EAAS,OAAO;EAAwB,MAAM;CAAY;CAC7E;EAAE,IAAI;EAAS,IAAI;EAAS,OAAO;EAAyB,MAAM;CAAa;CAC/E;EAAE,IAAI;EAAS,IAAI;EAAS,OAAO;EAA0B,MAAM;CAAc;CACjF;EAAE,IAAI;EAAU,IAAI;EAAS,OAAO;EAAc,MAAM,KAAA;CAAU;AACnE,CAAC;AAED,SAAS,kBAAkB,UAAkB,WAAmB;CAC/D,OAAO,qBAAqB,MAAM,EAAE,IAAI,SAAS,OAAO,YAAY,OAAO,SAAS;AACrF;;;;;;;AAQA,SAAgB,wBAAwB,UAAkB,WAA2B;CACpF,OAAO,kBAAkB,UAAU,SAAS,CAAC,EAAE,SAAS;AACzD;;;;;;;;;;AAWA,SAAgB,cAAc,UAAkB,WAA8C;CAC7F,OAAO,kBAAkB,UAAU,SAAS,CAAC,EAAE;AAChD"}

package/dist/{units-internal-Dg95w_YD.js → table-cell-margins-EVg0EwxT.js}

@@ -1,5 +1,209 @@
-import { S as warnOnce, a as FIXED_PCT_PER_PERCENT, i as EMU_PER_POINT, m as inchesToEmu, r as EMU_PER_INCH, s as PERCENT_SCALE, t as ANGLE_UNITS_PER_DEGREE, u as coordToEmu, x as warn } from "./units-1kRzYShk.js";
-import { n as InvalidOptionError } from "./errors-Bvln0H-7.js";
+import { l as warn, n as InvalidOptionError } from "./errors-C4oENPcu.js";
+//#region src/ooxml/emu.ts
+/**
+* The fixed ratios between English Metric Units, points and inches.
+*
+* `units.ts` publishes them, but it also holds the unit converters, which warn and throw, so it
+* imports `diagnostics.ts` and `errors.ts` at run time. A schema fact in `ooxml/` that only needs
+* a ratio (`body-insets.ts`) took both along with it. This module imports nothing, and `units.ts`
+* re-exports it, so the public names are unchanged.
+*/
+/** EMU in one inch. */
+const EMU_PER_INCH = 914400;
+/** EMU in one point. */
+const EMU_PER_POINT = 12700;
+/** Points in one inch. */
+const POINTS_PER_INCH = 72;
+//#endregion
+//#region src/units.ts
+/**
+* DrawingML angle unit. `ST_Angle` (`rot`, shadow `dir`, gradient `ang`, …) is measured in
+* sixtieths-of-a-thousandth of a degree, i.e. 60000 units per degree. Multiply a value in
+* degrees by this to get the OOXML integer.
+*/
+const ANGLE_UNITS_PER_DEGREE = 6e4;
+/**
+* DrawingML fixed-point percentage scale. `ST_Percentage` / `ST_PositiveFixedPercentage` and
+* related types (`<a:alpha>`, `<a:spcPct>`, shape adjustment guides, `<p:tav tm>`, …) encode
+* 100% as the integer 100000. Multiply a 0-1 fraction by this to get the OOXML value.
+*/
+const PERCENT_SCALE = 1e5;
+/**
+* Scale for a percentage supplied as 0-100 (rather than a 0-1 fraction) into the same
+* fixed-point percentage integer as {@link PERCENT_SCALE} (1% = 1000 units, i.e. thousandths
+* of a percent). Use for inputs documented as percents: transparency/alpha, image crop insets,
+* gradient stops, bullet size, connector adjust, etc.
+*/
+const FIXED_PCT_PER_PERCENT = PERCENT_SCALE / 100;
+/**
+* DrawingML text measures font size (`sz`), character spacing (`spc`) and point line/paragraph
+* spacing (`<a:spcPts val>`) in hundredths of a point. Multiply a value in points by this to get
+* the OOXML integer.
+*/
+const HUNDREDTHS_PER_POINT = 100;
+/**
+* Convert a value in points to hundredths of a point (rounded), the integer unit DrawingML uses
+* for `sz`, `spc`, and `<a:spcPts val>`. See {@link HUNDREDTHS_PER_POINT}.
+*/
+function ptToHundredths(pt) {
+	assertFiniteNumber(pt, "points");
+	return Math.round(pt * 100);
+}
+/** A bare number larger than this (in inches) is almost certainly a mistake — likely a raw EMU
+*  value passed where inches are expected. We interpret it as inches (the documented contract) but
+*  warn, pointing at the explicit `"<n>emu"` form. ~1000in is far beyond any real slide. */
+const IMPLAUSIBLE_INCHES = 1e3;
+/** Default pixel density for the `"<n>px"` coordinate unit: CSS reference pixels, also the
+*  density ts-pptx assumes when reading an image header's pixel dimensions. */
+const DEFAULT_PX_PER_INCH = 96;
+/**
+* The largest DrawingML coordinate, in EMU: the `maxInclusive` of `ST_Coordinate`, the type of
+* every shape offset and extent. The range is not symmetric; see {@link MIN_COORDINATE_EMU}.
+*/
+const MAX_COORDINATE_EMU = 27273042316900;
+/** The smallest DrawingML coordinate, in EMU: the `minInclusive` of `ST_Coordinate`. */
+const MIN_COORDINATE_EMU = -27273042329600;
+function inchesToEmu(inches) {
+	assertFiniteNumber(inches, "inches");
+	return inCoordinateRange(Math.round(inches * EMU_PER_INCH), inches, "inches");
+}
+function pointsToEmu(points) {
+	assertFiniteNumber(points, "points");
+	return inCoordinateRange(Math.round(points * EMU_PER_POINT), points, "points");
+}
+function pixelsToEmu(pixels, dpi) {
+	assertFiniteNumber(pixels, "pixels");
+	assertPositiveFiniteNumber(dpi, "dpi");
+	return inchesToEmu(pixels / dpi);
+}
+/**
+* Resolve a percentage of an axis length to EMU.
+*
+* **Published for consumers, and reached from one place inside `src/` on purpose.** Internally
+* only `parseCoord` needs it, because every `'50%'` a caller writes comes through there; it is
+* exported because a consumer computing its own geometry against a slide axis needs the same
+* arithmetic, and it belongs with the rest of the conversion set beside it rather than hidden
+* behind the one caller. Left exported deliberately rather than by oversight — this note is the
+* difference between the two, as it is on {@link emuToPixels}.
+* @param percent - percentage value (e.g. `50` for 50%)
+* @param axisEmu - the axis length in EMU (slide width for x/w, height for y/h)
+*/
+function percentToEmu(percent, axisEmu) {
+	assertFiniteNumber(percent, "percent");
+	assertFiniteNumber(axisEmu, "axisEmu");
+	return inCoordinateRange(Math.round(percent / 100 * axisEmu), percent, "percent");
+}
+/**
+* The single user-coordinate → EMU boundary. Convert each user-supplied coordinate exactly once.
+*
+* Accepts (see {@link Coord}):
+* - a bare `number` → **always inches** (the documented unit); no magnitude guessing
+* - `"<n>%"` → percentage of `axisEmu`
+* - `"<n>in"` / `"<n>pt"` / `"<n>px"` / `"<n>emu"` → explicit units (the escape hatch for non-inch
+*   values). `px` is resolved at {@link DEFAULT_PX_PER_INCH} (96), for authoring against a known
+*   web/source canvas size.
+*
+* Throws on non-finite or unparseable input rather than silently emitting a degenerate 0-size.
+* @param value - user coordinate
+* @param axisEmu - axis length in EMU, used only to resolve percentages
+*/
+function coordToEmu(value, axisEmu) {
+	if (typeof value === "number") {
+		assertFiniteNumber(value, "coordinate");
+		if (Math.abs(value) > IMPLAUSIBLE_INCHES) warn("coord/bare-number-is-inches", `coordinate ${value} interpreted as ${value} inches. A bare number is always inches; if you meant EMU, pass it as a string like "${Math.round(value)}emu".`);
+		return inchesToEmu(value);
+	}
+	const match = /^\s*(-?\d*\.?\d+)\s*(%|in|pt|px|emu)\s*$/.exec(value);
+	if (!match) throw new InvalidOptionError("coord/invalid-format", `Invalid coordinate "${value}". Expected a number (inches) or a string like "50%", "5in", "72pt", "96px", or "914400emu".`);
+	const n = Number(match[1]);
+	switch (match[2]) {
+		case "%": return percentToEmu(n, axisEmu);
+		case "in": return inchesToEmu(n);
+		case "pt": return pointsToEmu(n);
+		case "px": return pixelsToEmu(n, 96);
+		default:
+			assertFiniteNumber(n, "coordinate");
+			return inCoordinateRange(Math.round(n), n, "EMU");
+	}
+}
+function emuToInches(emu) {
+	assertFiniteNumber(emu, "emu");
+	return emu / EMU_PER_INCH;
+}
+/**
+* EMU → points, the unit the write API states line widths, font sizes and text insets in.
+*
+* The one conversion, for the library as well as for a consumer: three private forms of
+* `emu / EMU_PER_POINT` had grown around it — the read model's `null`-propagating `ptFromEmu`,
+* the script mapper's `points`, and a dozen inline divisions — while this stayed published and
+* uncalled.
+*
+* **The policy, and its one exception.** Every EMU→points conversion goes through here or through
+* `ptFromEmu` in `src/read/api/coords.ts`, which is this with a `null` passed along. (Named rather
+* than linked: it is internal, so a reference link to it resolves to nothing in the published
+* reference.) The exception is
+* `measure/*` — `fit.ts`, `paragraphs.ts`, `table-fit.ts` — where an inner box is computed as
+* `(extent - inset - inset) / EMU_PER_POINT` and then guarded with `!(x > 0)`. That guard is
+* written NaN-first on purpose: a box that cannot be measured is skipped, not reported. This
+* function asserts a finite input and throws instead, which is the right answer for a caller
+* stating a value and the wrong one for a pass whose whole job is to degrade quietly. Those
+* sites keep the division; nothing else may.
+*/
+function emuToPoints(emu) {
+	assertFiniteNumber(emu, "emu");
+	return emu / EMU_PER_POINT;
+}
+/**
+* EMU → whole pixels at a stated DPI.
+*
+* **Published for consumers, and used nowhere in `src/` on purpose.** Nothing inside the
+* library thinks in pixels: it is the unit a caller placing library output on a canvas or in a
+* `<img>` needs, and the DPI is theirs to choose. Left exported deliberately rather than by
+* oversight — this note is the difference between the two.
+*/
+function emuToPixels(emu, dpi) {
+	assertFiniteNumber(emu, "emu");
+	assertPositiveFiniteNumber(dpi, "dpi");
+	return Math.round(emuToInches(emu) * dpi);
+}
+function standardLayout(layout, name, widthIn, heightIn) {
+	return Object.freeze({
+		layout,
+		name,
+		widthIn,
+		heightIn,
+		widthEmu: inchesToEmu(widthIn),
+		heightEmu: inchesToEmu(heightIn)
+	});
+}
+const STANDARD_LAYOUTS = Object.freeze({
+	LAYOUT_4x3: standardLayout("LAYOUT_4x3", "screen4x3", 10, 7.5),
+	LAYOUT_16x9: standardLayout("LAYOUT_16x9", "screen16x9", 10, 5.625),
+	LAYOUT_16x10: standardLayout("LAYOUT_16x10", "screen16x10", 10, 6.25),
+	LAYOUT_WIDE: standardLayout("LAYOUT_WIDE", "custom", 40 / 3, 7.5)
+});
+/**
+* `emu` as an `Emu`, or a `coord/out-of-range` throw when it falls outside `ST_Coordinate`.
+*
+* A finite input is not enough on its own. `1e16` inches is finite and converts to `9.144e+21`,
+* which serializes in exponent notation and is not an `xsd:long` at all; `4e7` inches converts to
+* a long, but one past the bound. Neither is a coordinate PowerPoint can hold.
+* @param emu - the converted value
+* @param value - the caller's value, for the message
+* @param unit - the unit `value` was stated in, for the message
+*/
+function inCoordinateRange(emu, value, unit) {
+	if (emu < -27273042329600 || emu > 27273042316900) throw new InvalidOptionError("coord/out-of-range", `${value} ${unit} is ${emu} EMU, outside the DrawingML coordinate range ${MIN_COORDINATE_EMU} to ${MAX_COORDINATE_EMU} EMU.`);
+	return emu;
+}
+function assertFiniteNumber(value, name) {
+	if (!Number.isFinite(value)) throw new InvalidOptionError("coord/non-finite", `${name} must be a finite number`);
+}
+function assertPositiveFiniteNumber(value, name) {
+	assertFiniteNumber(value, name);
+	if (value <= 0) throw new InvalidOptionError("coord/not-positive", `${name} must be greater than 0`);
+}
+//#endregion
 //#region src/enums.ts
 let TextAnchor = /* @__PURE__ */ function(TextAnchor) {
 	TextAnchor["b"] = "b";
@@ -241,6 +445,13 @@ let AlignH = /* @__PURE__ */ function(AlignH) {
 	AlignH["justify"] = "justify";
 	return AlignH;
 }({});
+/**
+* @deprecated The enum form of `VAlign`, which no option actually takes. Use the `VAlign`
+* string union (`'top' | 'middle' | 'bottom'`) or, for a text body's own anchoring,
+* {@link TextAnchor}. Unlike its sibling {@link AlignH} — which `TextPropsOptions.align`
+* really is typed as — nothing in the library reads this, so it is a third spelling of a
+* two-spelling fact. It will be removed in the next major.
+*/
 let AlignV = /* @__PURE__ */ function(AlignV) {
 	AlignV["top"] = "top";
 	AlignV["middle"] = "middle";
@@ -344,6 +555,11 @@ let SlideObjectType = /* @__PURE__ */ function(SlideObjectType) {
 * Maps a friendly `ConnectorType` to its OOXML connector preset *family*. `straight`
 * has a single fixed preset; `elbow` and `curved` select a member by bend count
 * (`bentConnector{3,4,5}` / `curvedConnector{3,4,5}`) — see `connectorPresetFor`.
+*
+* Not exported: `connectorPresetFor`, eleven lines below, is its only reader, and
+* `docs/contributing/architecture.md` puts internal OOXML generators off the published surface unless
+* deliberately exposed. Callers name a connector by its `ConnectorType`, or by the
+* {@link CONNECTOR_PRESET_NAME} the function returns.
 */
 const CONNECTOR_PRESETS = {
 	straight: "straightConnector1",
@@ -474,280 +690,26 @@ let TableStyle = /* @__PURE__ */ function(TableStyle) {
 	return TableStyle;
 }({});
 //#endregion
-//#region src/constants-internal.ts
-const LAYOUT_IDX_SERIES_BASE = 2147483649;
-const REGEX_HEX_COLOR = /^[0-9a-fA-F]{6}$/;
-const LINEH_MODIFIER = 1.67;
-const DEF_CELL_BORDER = {
-	type: "solid",
-	color: "666666",
-	width: 1
-};
-const DEF_CELL_MARGIN_IN = [
-	.05,
-	.1,
-	.05,
-	.1
-];
-const DEF_CHART_BORDER = {
-	type: "solid",
-	color: "363636",
-	width: 1
-};
-const DEF_CHART_GRIDLINE = {
-	color: "888888",
-	style: "solid",
-	size: 1,
-	cap: "flat"
-};
-const DEF_FONT_COLOR = "000000";
-const DEF_PRES_LAYOUT = "LAYOUT_16x9";
-const DEF_PRES_LAYOUT_NAME = "DEFAULT";
-const DEF_SHAPE_LINE_COLOR = "333333";
-const DEF_SHAPE_SHADOW = {
-	type: "outer",
-	blur: 3,
-	offset: 23e3 / 12700,
-	angle: 90,
-	color: "000000",
-	_alpha: .35,
-	rotateWithShape: true
-};
-const DEF_SLIDE_MARGIN_IN = [
-	.5,
-	.5,
-	.5,
-	.5
-];
-const DEF_TEXT_SHADOW = {
-	type: "outer",
-	blur: 8,
-	offset: 4,
-	angle: 270,
-	color: "000000",
-	_alpha: .75
-};
-const DEF_TEXT_GLOW = {
-	size: 8,
-	color: "FFFFFF",
-	opacity: .75
-};
-const AXIS_ID_VALUE_PRIMARY = "2094734552";
-const AXIS_ID_VALUE_SECONDARY = "2094734553";
-const AXIS_ID_CATEGORY_PRIMARY = "2094734554";
-const AXIS_ID_CATEGORY_SECONDARY = "2094734555";
-const AXIS_ID_SERIES_PRIMARY = "2094734556";
-const LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
-const BARCHART_COLORS = [
-	"C0504D",
-	"4F81BD",
-	"9BBB59",
-	"8064A2",
-	"4BACC6",
-	"F79646",
-	"628FC6",
-	"C86360"
-];
-const PIECHART_COLORS = [
-	"5DA5DA",
-	"FAA43A",
-	"60BD68",
-	"F17CB0",
-	"B2912F",
-	"B276B2",
-	"DECF3F",
-	"F15854",
-	"A7A7A7"
-];
-const SLDNUMFLDID = "{F7021451-1387-4CA6-816F-3879F97B5CBC}";
-const SLDNUM_PLACEHOLDER_TEXT = "‹#›";
-const XML_DECL = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
-//#endregion
-//#region src/units-internal.ts
+//#region src/ooxml/table-cell-margins.ts
 /**
-* Generator-side unit conversion — the lenient layer over `units.ts`.
+* A table cell's default text insets in EMU: the schema defaults of `a:tcPr/@marL`, `@marR`
+* (91440, 0.1in) and `@marT`, `@marB` (45720, 0.05in) on `CT_TableCellProperties`.
 *
-* `units.ts` holds the strict, public primitives: one branded `Emu` type and converters that
-* take a number and throw on anything they cannot represent. This module holds what the
-* generators actually need on top of that: converters that accept the loose shapes the
-* authoring API has always accepted (numeric strings, `"5in"`, `null`), that clamp to the
-* ranges PowerPoint will load without offering to repair the file, and that warn about legacy
-* inputs instead of failing.
+* Unlike the body insets in `body-insets.ts` these are real XSD defaults, so they are transcribed
+* from the schema rather than derived. A cell that states one side leaves the other three at these
+* values, not at zero.
 *
-* The split is deliberate: the leniency and the back-compat warnings are policy, not
-* arithmetic, and policy should not be part of the published API. Nothing here is exported
-* from an entrypoint.
-*/
-/**
-* Resolve a user `Coord` (x/y/w/h) to EMU — the single user-coordinate → EMU boundary.
-* - bare `number` → **inches** (no magnitude guessing); `"<n>%"` → percent of the slide axis;
-*   `"<n>in"`/`"<n>pt"`/`"<n>emu"` → explicit units (see {@link Coord} / {@link coordToEmu})
-* - `null`/`undefined` → 0 (callers may omit a coordinate)
-* - throws on a non-finite number rather than silently collapsing the object to zero size
-* @param {Coord|null|undefined} size - user coordinate
-* @param {'X' | 'Y'} xyDir - axis (selects slide width vs height for percentages)
-* @param {PresLayout} layout - presentation layout (EMU dimensions)
-* @returns {Emu} resolved EMU value
-*/
-function getSmartParseNumber(size, xyDir, layout) {
-	if (size === null || size === void 0) return 0;
-	if (typeof size === "number" && !isFinite(size)) throw new InvalidOptionError("coord/non-finite", `Invalid ${xyDir || "coordinate"} value: expected a finite number but received ${String(size)}. This usually means a layout dimension was read from a missing property (e.g. \`layout.width\` returning \`undefined\`). Use \`slide.width\`/\`slide.height\` or \`STANDARD_LAYOUTS.<NAME>.width\`/\`.height\` (inches).`);
-	return coordToEmu(size, xyDir === "Y" ? layout.height : layout.width);
-}
-/**
-* Convert inches into EMU.
-* - accepts a number (inches) or a numeric/`"<n>in"` string
-* - no magnitude guessing: values are always treated as inches (use {@link coordToEmu} for
-*   user coordinates that may carry other units)
-* @param {number|string} inches - inches as number or string
-* @returns {Emu} EMU value
+* A module of its own, importing nothing, because `constants-internal.ts` derives the write path's
+* inch defaults from it and is reached by every entry. Taken from `body-insets.ts`, the record
+* brought that module's other exports into the read entry with it.
 */
-function inch2Emu(inches) {
-	if (typeof inches === "string") inches = Number(inches.replace(/in*/gi, ""));
-	return inchesToEmu(inches);
-}
-/**
-* Convert a single `margin` component (table cell/table margin, or text-box/placeholder body
-* inset) to EMU.
-*
-* Margins are INCHES, consistent with the positional API (`x`/`y`/`w`/`h`) and the value
-* PowerPoint's own dialog shows (both the table cell-margin and the text-box internal-margin
-* fields are inches). Historically the library read these as POINTS (table cells used a magnitude
-* heuristic — `>= 1` points, `< 1` inches; text-box margins were straight points), so a legitimate
-* fraction-of-an-inch value entered from the PowerPoint dialog became a tiny points value. Every
-* value is now inches. A `>= 1` value is honored as inches but warns once, because it is almost
-* certainly a legacy points value that should be divided by 72 (e.g. `10` points → `0.139` inches).
-*
-* Shared by every margin site so they stay in lockstep: the cell XML emitter and text-box/slide-
-* number insets (`gen/slide/object.ts`), the autoPage row-height pass (`gen/table/autopage.ts`), and the measured-fit pass
-* (`measure-fit`).
-* @param {number} inches - margin component in inches
-* @returns {Emu} EMU value
-*/
-function marginToEmu(inches) {
-	if (inches >= 1) warnOnce("margin/legacy-points", "margins (table cell and text-box) are interpreted as inches (matching the rest of the API and the PowerPoint dialog); a value >= 1 is likely a legacy points value — divide by 72 to convert (e.g. 10pt => 0.139in).");
-	return inch2Emu(inches);
-}
-/**
-* Resolve a table's column widths to EMU, the single source of truth shared by the
-* table XML emitter and the measured-fit pass (so a fitted cell sees the same grid
-* the renderer draws).
-* - an explicit `colW` **array** is per-column inches (`inch2Emu`); a non-finite slot
-*   falls back to the even-distribution width
-* - otherwise the table's already-resolved width (`totalWidthEmu`, EMU) is split evenly
-*   across `colCount` columns. (A scalar `colW` never reaches here — `addTableDefinition`
-*   converts it to `w` and clears `colW`.)
-*
-* IMPORTANT: the even path divides an **EMU** width. Passing the raw inches `options.w`
-* instead (the historical bug) produced ~0-EMU columns (e.g. `w=9` → `gridCol w="3"`),
-* collapsing auto-width tables to a sliver in PowerPoint/LibreOffice.
-* @param {Coord[]|Coord|undefined} colW - explicit per-column inches, or scalar/undefined
-* @param {number} totalWidthEmu - the table's resolved width in EMU
-* @param {number} colCount - number of grid columns (counting colspans)
-* @returns {number[]} per-column widths in EMU (length `colCount`)
-*/
-function resolveTableColWidthsEmu(colW, totalWidthEmu, colCount) {
-	if (!(colCount > 0)) return [];
-	const even = totalWidthEmu > 0 ? Math.round(totalWidthEmu / colCount) : EMU_PER_INCH;
-	if (Array.isArray(colW)) return Array.from({ length: colCount }, (_, i) => {
-		const n = colW[i];
-		return typeof n === "number" && Number.isFinite(n) ? Math.round(inch2Emu(n)) : even;
-	});
-	return new Array(colCount).fill(even);
-}
-/**
-* Convert points to EMU, leniently: anything that does not read as a finite number — a `NaN`,
-* an `Infinity`, a non-numeric string, `null` — becomes `0` rather than throwing.
-*
-* That is the whole difference from {@link pointsToEmu} in `units.ts`, which throws on the same
-* input. Emitters use this one for the many optional size/width/offset options where a missing
-* or malformed value should collapse the feature (a zero-width line, no shadow offset) rather
-* than take the whole deck down.
-*
-* @param pt - points, as a number or a numeric string
-* @returns the value in EMU, or `0` if it does not read as a finite number
-*/
-function ptsToEmuLenient(pt) {
-	const points = Number(pt);
-	return Number.isFinite(points) ? Math.round(points * EMU_PER_POINT) : 0;
-}
-/**
-* Convert a transparency percentage (0-100) into a schema-valid `<a:alpha>` value
-* (ST_PositiveFixedPercentage, 0-100000). Out-of-range transparency yields an
-* alpha that PowerPoint rejects as needing repair, so clamp into range and warn.
-*/
-function transparencyToAlpha(transparency) {
-	const pct = Math.min(100, Math.max(0, transparency));
-	if (pct !== transparency) warn("transparency/out-of-range", `transparency ${transparency} is outside the valid range 0-100; using ${pct}.`);
-	return Math.round((100 - pct) * FIXED_PCT_PER_PERCENT);
-}
-/** Convert an opacity (0-1) into a schema-valid `<a:alpha>` value (0-100000); clamps + warns on out-of-range input. */
-function opacityToAlpha(opacity) {
-	const o = Math.min(1, Math.max(0, opacity));
-	if (o !== opacity) warn("opacity/out-of-range", `opacity ${opacity} is outside the valid range 0-1; using ${o}.`);
-	return Math.round(o * PERCENT_SCALE);
-}
-/**
-* Convert a line width (points) to EMU clamped into ST_LineWidth (0..20116800 EMU,
-* i.e. 0-1584pt). Out-of-range widths make PowerPoint report the package as needing
-* repair, so clamp into range and warn.
-*/
-function lineWidthToEmu(widthPts) {
-	const raw = ptsToEmuLenient(widthPts);
-	const clamped = Math.min(20116800, Math.max(0, raw));
-	if (clamped !== raw) warn("line/width-out-of-range", `line width ${widthPts} is outside the valid range 0-1584pt; using ${clamped / EMU_PER_POINT}.`);
-	return clamped;
-}
-/**
-* Convert degrees to a DrawingML angle (60000ths of a degree), **without** wrapping.
-*
-* Most angles in the format are not modular: a connection site at 400 degrees, a polar adjust
-* handle whose range runs to 540, an arc that sweeps 400 degrees — each means something a
-* reduction into 0..360 would destroy. Use this for those, and {@link convertRotationDegrees}
-* for the ones that genuinely are a rotation.
-*
-* Non-finite input throws rather than reaching the attribute: `Math.round(Infinity * 60000)` is
-* `Infinity`, which serializes as `ang="Infinity"` and makes PowerPoint offer to repair the file.
-*
-* @param d - degrees
-* @param what - what is being converted, for the error message
-* @param code - diagnostic code to throw under, where a caller has a more specific one
-*/
-function convertAngleUnits(d, what, code = "coord/non-finite") {
-	assertFiniteDegrees(d, what, code);
-	return Math.round(d * ANGLE_UNITS_PER_DEGREE);
-}
-function assertFiniteDegrees(d, what, code) {
-	if (typeof d !== "number" || !Number.isFinite(d)) throw new InvalidOptionError(code, `${what} must be a finite number of degrees; received ${String(d)}.`);
-}
-/**
-* Convert a shape or gradient rotation (degrees) to a DrawingML angle (60000ths of a degree).
-*
-* A rotation *is* modular — 800 degrees and 80 degrees point the same way — so the value is
-* reduced with `% 360`. The reduction keeps the sign: `-45` stays `-45` rather than becoming
-* `315`, because both are valid `ST_Angle`, PowerPoint writes negative rotations itself, and
-* the read side reports back what was authored. Only an input outside -360..360 moves.
-*
-* @param d - degrees
-* @returns the `rot` value in 60000ths of a degree
-*/
-function convertRotationDegrees(d) {
-	const degrees = d || 0;
-	assertFiniteDegrees(degrees, "rotation", "coord/non-finite");
-	return Math.round(degrees % 360 * ANGLE_UNITS_PER_DEGREE);
-}
-/**
-* Convert a freeform arc angle (degrees) to an `<a:arcTo>` ST_AdjAngle value (60000ths).
-* Unlike a shape rotation, a sweep is not modular: a 400 degree swAng draws a different
-* arc than a 40 degree one, so the value is never wrapped into 0..360.
-* @param {number} d degrees
-* @param {'stAng' | 'swAng'} attr - attribute being emitted, for the error message
-* @returns {number} ST_AdjAngle value (60000ths of a degree)
-*/
-function convertArcAngle(d, attr) {
-	return convertAngleUnits(d, `Arc ${attr}`, "geometry/arc-angle-non-finite");
-}
+const TABLE_CELL_MARGIN_DEFAULTS_EMU = {
+	left: 91440,
+	right: 91440,
+	top: 45720,
+	bottom: 45720
+};
 //#endregion
-export { isChartExType as $, LAYOUT_IDX_SERIES_BASE as A, BulletType as B, DEF_PRES_LAYOUT as C, DEF_SLIDE_MARGIN_IN as D, DEF_SHAPE_SHADOW as E, SLDNUMFLDID as F, SchemeColor as G, ChartType as H, SLDNUM_PLACEHOLDER_TEXT as I, TableStyle as J, ShapeType as K, XML_DECL as L, LINEH_MODIFIER as M, PIECHART_COLORS as N, DEF_TEXT_GLOW as O, REGEX_HEX_COLOR as P, connectorPresetFor as Q, AlignH as R, DEF_FONT_COLOR as S, DEF_SHAPE_LINE_COLOR as T, OutputType as U, CONNECTOR_PRESETS as V, PlaceholderType as W, VALID_SHAPE_PRESETS as X, TextAnchor as Y, asChartType as Z, BARCHART_COLORS as _, inch2Emu as a, DEF_CHART_BORDER as b, opacityToAlpha as c, transparencyToAlpha as d, isChartType as et, AXIS_ID_CATEGORY_PRIMARY as f, AXIS_ID_VALUE_SECONDARY as g, AXIS_ID_VALUE_PRIMARY as h, getSmartParseNumber as i, LETTERS as j, DEF_TEXT_SHADOW as k, ptsToEmuLenient as l, AXIS_ID_SERIES_PRIMARY as m, convertArcAngle as n, lineWidthToEmu as o, AXIS_ID_CATEGORY_SECONDARY as p, SlideObjectType as q, convertRotationDegrees as r, marginToEmu as s, convertAngleUnits as t, resolveTableColWidthsEmu as u, DEF_CELL_BORDER as v, DEF_PRES_LAYOUT_NAME as w, DEF_CHART_GRIDLINE as x, DEF_CELL_MARGIN_IN as y, AlignV as z };
+export { inchesToEmu as A, MIN_COORDINATE_EMU as C, emuToInches as D, coordToEmu as E, EMU_PER_INCH as F, EMU_PER_POINT as I, POINTS_PER_INCH as L, pixelsToEmu as M, pointsToEmu as N, emuToPixels as O, ptToHundredths as P, MAX_COORDINATE_EMU as S, STANDARD_LAYOUTS as T, isChartType as _, ChartType as a, FIXED_PCT_PER_PERCENT as b, SchemeColor as c, TableStyle as d, TextAnchor as f, isChartExType as g, connectorPresetFor as h, BulletType as i, percentToEmu as j, emuToPoints as k, ShapeType as l, asChartType as m, AlignH as n, OutputType as o, VALID_SHAPE_PRESETS as p, AlignV as r, PlaceholderType as s, TABLE_CELL_MARGIN_DEFAULTS_EMU as t, SlideObjectType as u, ANGLE_UNITS_PER_DEGREE as v, PERCENT_SCALE as w, HUNDREDTHS_PER_POINT as x, DEFAULT_PX_PER_INCH as y };
 
-//# sourceMappingURL=units-internal-Dg95w_YD.js.map
+//# sourceMappingURL=table-cell-margins-EVg0EwxT.js.map