@shbernal/ts-pptx 3.2.0 → 3.4.0

package/dist/{units-internal-CR8s8YQa.js → units-internal-DNvK2I6o.js}

@@ -1,6 +1,145 @@
-import { n as warn, r as warnOnce } from "./diagnostics-DYQC7xLV.js";
+import { i as warnOnce, r as warn } from "./diagnostics-CPVADSL1.js";
 import { n as InvalidOptionError } from "./errors-Bvln0H-7.js";
-import { 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 } from "./units-C7QM1KgH.js";
+//#region src/units.ts
+/**
+* Public unit conversion helpers and standard PowerPoint slide-layout constants.
+*/
+const EMU_PER_INCH = 914400;
+const EMU_PER_POINT = 12700;
+const POINTS_PER_INCH = 72;
+/**
+* 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;
+function inchesToEmu(inches) {
+	assertFiniteNumber(inches, "inches");
+	return Math.round(inches * EMU_PER_INCH);
+}
+function pointsToEmu(points) {
+	assertFiniteNumber(points, "points");
+	return Math.round(points * EMU_PER_POINT);
+}
+function pixelsToEmu(pixels, dpi) {
+	assertFiniteNumber(pixels, "pixels");
+	assertPositiveFiniteNumber(dpi, "dpi");
+	return inchesToEmu(pixels / dpi);
+}
+/**
+* Resolve a percentage of an axis length to EMU.
+* @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 Math.round(percent / 100 * axisEmu);
+}
+/**
+* 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 Math.round(n);
+	}
+}
+function emuToInches(emu) {
+	assertFiniteNumber(emu, "emu");
+	return emu / EMU_PER_INCH;
+}
+function emuToPoints(emu) {
+	assertFiniteNumber(emu, "emu");
+	return emu / EMU_PER_POINT;
+}
+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)
+});
+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";
@@ -283,6 +422,20 @@ const VALID_SHAPE_PRESETS = /* @__PURE__ */ new Set([...Object.values(ShapeType)
 function asChartType(name) {
 	return name;
 }
+/** Every {@link ChartType} value, for validating a caller-supplied `type` at the API boundary. */
+const CHART_TYPES = new Set(Object.values(ChartType));
+/**
+* Is `name` a chart type this library emits?
+*
+* `CHART_NAME` constrains TypeScript callers, but `addChart` is reachable from plain JavaScript
+* where nothing enforces the union — and the two emitters partition the catalog between them by
+* `switch`, so an off-catalog string has no arm in either and cannot produce a plot. Checked once
+* at define time (`gen/define/chart.ts`) so the caller hears about it at the call that was wrong,
+* rather than getting a chart-shaped hole in the deck.
+*/
+function isChartType(name) {
+	return typeof name === "string" && CHART_TYPES.has(name);
+}
 /**
 * The chartEx (`cx:` / Office 2016 chart-extension) chart types. Unlike the classic 2007 catalog
 * these do NOT emit a `<c:chartSpace>` chart part: they emit a separate `chartEx{N}.xml` part in
@@ -526,14 +679,6 @@ 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",
 	"C0504D",
 	"4F81BD",
 	"9BBB59",
@@ -544,15 +689,6 @@ const BARCHART_COLORS = [
 	"C86360"
 ];
 const PIECHART_COLORS = [
-	"5DA5DA",
-	"FAA43A",
-	"60BD68",
-	"F17CB0",
-	"B2912F",
-	"B276B2",
-	"DECF3F",
-	"F15854",
-	"A7A7A7",
 	"5DA5DA",
 	"FAA43A",
 	"60BD68",
@@ -564,6 +700,7 @@ const PIECHART_COLORS = [
 	"A7A7A7"
 ];
 const SLDNUMFLDID = "{F7021451-1387-4CA6-816F-3879F97B5CBC}";
+const SLDNUM_PLACEHOLDER_TEXT = "‹#›";
 const XML_DECL = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
 const IMG_BROKEN = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAAB3CAYAAAD1oOVhAAAGAUlEQVR4Xu2dT0xcRRzHf7tAYSsc0EBSIq2xEg8mtTGebVzEqOVIolz0siRE4gGTStqKwdpWsXoyGhMuyAVJOHBgqyvLNgonDkabeCBYW/8kTUr0wsJC+Wfm0bfuvn37Znbem9mR9303mJnf/Pb7ed95M7PDI5JIJPYJV5EC7e3t1N/fT62trdqViQCIu+bVgpIHEo/Hqbe3V/sdYVKHyWSSZmZm8ilVA0oeyNjYmEnaVC2Xvr6+qg5fAOJAz4DU1dURGzFSqZRVqtMpAFIGyMjICC0vL9PExIRWKADiAYTNshYWFrRCARAOEFZcCKWtrY0GBgaUTYkBRACIE4rKZwqACALR5RQAqQCIDqcASIVAVDsFQCSAqHQKgEgCUeUUAPEBRIVTAMQnEBvK5OQkbW9vk991CoAEAMQJxc86BUACAhKUUwAkQCBBOAVAAgbi1ykAogCIH6cAiCIgsk4BEIVAZJwCIIqBVLqiBxANQFgXS0tLND4+zl08AogmIG5OSSQS1gGKwgtANAIRcQqAaAbCe6YASBWA2E6xDyeyDUl7+AKQMkDYYevm5mZHabA/Li4uUiaTsYLau8QA4gLE/hU7wajyYtv1hReDAiAOxQcHBymbzark4BkbQKom/X8dp9Npmpqasn4BIAYAYSnYp+4BBEAMUcCwNOCQsAKZnp62NtQOw8WmwT09PUo+ijaHsOMx7GppaaH6+nolH0Z10K2tLVpdXbW6UfV3mNqBdHd3U1NTk2rtlMRfW1uj2dlZAFGirkRQAJEQTWUTAFGprkRsAJEQTWUTAFGprkRsAJEQTWUTAFGprkRsAJEQTWUTAFGprkRsAJEQTWUTAFGprkRsAJEQTWUTAGHqrm8caPzQ0WC1logbeiC7X3xJm0PvUmRzh45cuki1588FAmVn9BO6P3yF9utrqGH0MtW82S8UN9RA9v/4k7InjhcJFTs/TLVXLwmJV67S7vD7tHF5pKi46fYdosdOcOOGG8j1OcqefbFEJD9Q3GCwDhqT31HklS4A8VRgfYM2Op6k3bt/BQJl58J7lPvwg5JYNccepaMry0LPqFA7hCm39+NNyp2J0172b19QysGINj5CsRtpij57musOViH0QPJQXn6J9u7dlYJSFkbrMYolrwvDAJAC+WWdEpQz7FTgECeUCpzi6YxvvqXoM6eEhqnCSgDikEzUKUE7Aw7xuHctKB5OYU3dZlNR9syQdAaAcAYTC0pXF+39c09o2Ik+3EqxVKqiB7hbYAxZkk4pbBaEM+AQofv+wTrFwylBOQNABIGwavdfe4O2pg5elO+86l99nY58/VUF0byrYsjiSFluNlXYrOHcBar7+EogUADEQ0YRGHbzoKAASBkg2+9cpM1rV0tK2QOcXW7bLEFAARAXIF4w2DrDWoeUWaf4hQIgDiA8GPZ2iNfi0Q8UACkAIgrDbrJ385eDxaPLLrEsFAB5oG6lMPJQPLZZZKAACBGVhcG2Q+bmuLu2nk55e4jqPv1IeEoceiBeX7s2zCa5MAqdstl91vfXwaEGsv/rb5TtOFk6tWXOuJGh6KmnhO9sayrMninPx103JBtXblHkice58cINZP4Hyr5wpkgkdiChEmc4FWazLzenNKa/p0jncwDiqcD6BuWePk07t1asatZGoYQzSqA4nFJ7soNiP/+EUyfc25GI2GG53dHPrKo1g/1Cw4pIXLrzO+1c+/wg7tBbFDle/EbQcjFCPWQJCau5EoBoFpzXHYDwFNJcDiCaBed1ByA8hTSXA4hmwXndAQhPIc3lAKJZcF53AMJTSHM5gGgWnNcdgPAU0lwOIJoF53UHIDyFNJcfSiCdnZ0Ui8U0SxlMd7lcjubn561gh+Y1scFIU/0o/3sgeLO12E2k7UXKYumgFoAYdg8ACIAYpoBh6cAhAGKYAoalA4cAiGEKGJYOHAIghilgWDpwCIAYpoBh6cAhAGKYAoalA4cAiGEKGJYOHAIghilgWDpwCIAYpoBh6ZQ4JB6PKzviYthnNy4d9h+1M5mMlVckkUjsG5dhiBMCEMPg/wuOfrZZ/RSywQAAAABJRU5ErkJggg==";
 const IMG_SVG_PLACEHOLDER = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
@@ -662,13 +799,20 @@ function resolveTableColWidthsEmu(colW, totalWidthEmu, colCount) {
 	return new Array(colCount).fill(even);
 }
 /**
-* Convert `pt` into points (using `ONEPT`)
-* @param {number|string} pt
-* @returns {number} value in points (`ONEPT`)
+* 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 valToPts(pt) {
-	const points = Number(pt) || 0;
-	return isNaN(points) ? 0 : Math.round(points * EMU_PER_POINT);
+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
@@ -692,19 +836,48 @@ function opacityToAlpha(opacity) {
 * repair, so clamp into range and warn.
 */
 function lineWidthToEmu(widthPts) {
-	const raw = valToPts(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 (0..360) to PowerPoint `rot` value
-* @param {number} d degrees
-* @returns {number} calculated `rot` value
+* 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) {
-	d = d || 0;
-	return Math.round((d > 360 ? d - 360 : d) * ANGLE_UNITS_PER_DEGREE);
+	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).
@@ -715,10 +888,9 @@ function convertRotationDegrees(d) {
 * @returns {number} ST_AdjAngle value (60000ths of a degree)
 */
 function convertArcAngle(d, attr) {
-	if (typeof d !== "number" || !Number.isFinite(d)) throw new InvalidOptionError("geometry/arc-angle-non-finite", `Arc ${attr} must be a finite number of degrees; received ${String(d)}.`);
-	return Math.round(d * ANGLE_UNITS_PER_DEGREE);
+	return convertAngleUnits(d, `Arc ${attr}`, "geometry/arc-angle-non-finite");
 }
 //#endregion
-export { connectorPresetFor as $, IMG_PLAYBTN as A, AlignV as B, DEF_PRES_LAYOUT_NAME as C, DEF_TEXT_GLOW as D, DEF_SLIDE_MARGIN_IN as E, PIECHART_COLORS as F, PlaceholderType as G, CONNECTOR_PRESETS as H, REGEX_HEX_COLOR as I, SlideObjectType as J, SchemeColor as K, SLDNUMFLDID as L, LAYOUT_IDX_SERIES_BASE as M, LETTERS as N, DEF_TEXT_SHADOW as O, LINEH_MODIFIER as P, asChartType as Q, XML_DECL as R, DEF_PRES_LAYOUT as S, DEF_SHAPE_SHADOW as T, ChartType as U, BulletType as V, OutputType as W, TextAnchor as X, TableStyle as Y, VALID_SHAPE_PRESETS as Z, DEF_CELL_BORDER as _, lineWidthToEmu as a, DEF_CHART_GRIDLINE as b, resolveTableColWidthsEmu as c, AXIS_ID_CATEGORY_PRIMARY as d, isChartExType as et, AXIS_ID_CATEGORY_SECONDARY as f, BARCHART_COLORS as g, AXIS_ID_VALUE_SECONDARY as h, inch2Emu as i, IMG_SVG_PLACEHOLDER as j, IMG_BROKEN as k, transparencyToAlpha as l, AXIS_ID_VALUE_PRIMARY as m, convertRotationDegrees as n, marginToEmu as o, AXIS_ID_SERIES_PRIMARY as p, ShapeType as q, getSmartParseNumber as r, opacityToAlpha as s, convertArcAngle as t, valToPts as u, DEF_CELL_MARGIN_IN as v, DEF_SHAPE_LINE_COLOR as w, DEF_FONT_COLOR as x, DEF_CHART_BORDER as y, AlignH as z };
+export { VALID_SHAPE_PRESETS as $, IMG_BROKEN as A, XML_DECL as B, DEF_PRES_LAYOUT as C, DEF_SLIDE_MARGIN_IN as D, DEF_SHAPE_SHADOW as E, LINEH_MODIFIER as F, ChartType as G, AlignV as H, PIECHART_COLORS as I, SchemeColor as J, OutputType as K, REGEX_HEX_COLOR as L, IMG_SVG_PLACEHOLDER as M, LAYOUT_IDX_SERIES_BASE as N, DEF_TEXT_GLOW as O, LETTERS as P, TextAnchor as Q, SLDNUMFLDID as R, DEF_FONT_COLOR as S, DEF_SHAPE_LINE_COLOR as T, BulletType as U, AlignH as V, CONNECTOR_PRESETS as W, SlideObjectType as X, ShapeType as Y, TableStyle as Z, BARCHART_COLORS as _, inchesToEmu as _t, inch2Emu as a, DEFAULT_PX_PER_INCH as at, DEF_CHART_BORDER as b, pointsToEmu as bt, opacityToAlpha as c, FIXED_PCT_PER_PERCENT as ct, transparencyToAlpha as d, POINTS_PER_INCH as dt, asChartType as et, AXIS_ID_CATEGORY_PRIMARY as f, STANDARD_LAYOUTS as ft, AXIS_ID_VALUE_SECONDARY as g, emuToPoints as gt, AXIS_ID_VALUE_PRIMARY as h, emuToPixels as ht, getSmartParseNumber as i, ANGLE_UNITS_PER_DEGREE as it, IMG_PLAYBTN as j, DEF_TEXT_SHADOW as k, ptsToEmuLenient as l, HUNDREDTHS_PER_POINT as lt, AXIS_ID_SERIES_PRIMARY as m, emuToInches as mt, convertArcAngle as n, isChartExType as nt, lineWidthToEmu as o, EMU_PER_INCH as ot, AXIS_ID_CATEGORY_SECONDARY as p, coordToEmu as pt, PlaceholderType as q, convertRotationDegrees as r, isChartType as rt, marginToEmu as s, EMU_PER_POINT as st, convertAngleUnits as t, connectorPresetFor as tt, resolveTableColWidthsEmu as u, PERCENT_SCALE as ut, DEF_CELL_BORDER as v, percentToEmu as vt, DEF_PRES_LAYOUT_NAME as w, DEF_CHART_GRIDLINE as x, ptToHundredths as xt, DEF_CELL_MARGIN_IN as y, pixelsToEmu as yt, SLDNUM_PLACEHOLDER_TEXT as z };
 
-//# sourceMappingURL=units-internal-CR8s8YQa.js.map
+//# sourceMappingURL=units-internal-DNvK2I6o.js.map