pptx-ts 0.0.1

package/dist/units-internal-Dg95w_YD.js

@@ -0,0 +1,753 @@
+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";
+//#region src/enums.ts
+let TextAnchor = /* @__PURE__ */ function(TextAnchor) {
+	TextAnchor["b"] = "b";
+	TextAnchor["ctr"] = "ctr";
+	TextAnchor["t"] = "t";
+	return TextAnchor;
+}({});
+let OutputType = /* @__PURE__ */ function(OutputType) {
+	OutputType["arraybuffer"] = "arraybuffer";
+	OutputType["base64"] = "base64";
+	OutputType["binarystring"] = "binarystring";
+	OutputType["blob"] = "blob";
+	OutputType["nodebuffer"] = "nodebuffer";
+	OutputType["uint8array"] = "uint8array";
+	return OutputType;
+}({});
+let ChartType = /* @__PURE__ */ function(ChartType) {
+	ChartType["area"] = "area";
+	ChartType["bar"] = "bar";
+	ChartType["bar3d"] = "bar3D";
+	ChartType["bubble"] = "bubble";
+	ChartType["bubble3d"] = "bubble3D";
+	ChartType["doughnut"] = "doughnut";
+	ChartType["line"] = "line";
+	ChartType["pie"] = "pie";
+	ChartType["radar"] = "radar";
+	ChartType["scatter"] = "scatter";
+	ChartType["stock"] = "stock";
+	ChartType["surface"] = "surface";
+	ChartType["waterfall"] = "waterfall";
+	ChartType["funnel"] = "funnel";
+	ChartType["treemap"] = "treemap";
+	ChartType["sunburst"] = "sunburst";
+	ChartType["histogram"] = "histogram";
+	ChartType["pareto"] = "pareto";
+	ChartType["boxWhisker"] = "boxWhisker";
+	ChartType["regionMap"] = "regionMap";
+	return ChartType;
+}({});
+let ShapeType = /* @__PURE__ */ function(ShapeType) {
+	ShapeType["accentBorderCallout1"] = "accentBorderCallout1";
+	ShapeType["accentBorderCallout2"] = "accentBorderCallout2";
+	ShapeType["accentBorderCallout3"] = "accentBorderCallout3";
+	ShapeType["accentCallout1"] = "accentCallout1";
+	ShapeType["accentCallout2"] = "accentCallout2";
+	ShapeType["accentCallout3"] = "accentCallout3";
+	ShapeType["actionButtonBackPrevious"] = "actionButtonBackPrevious";
+	ShapeType["actionButtonBeginning"] = "actionButtonBeginning";
+	ShapeType["actionButtonBlank"] = "actionButtonBlank";
+	ShapeType["actionButtonDocument"] = "actionButtonDocument";
+	ShapeType["actionButtonEnd"] = "actionButtonEnd";
+	ShapeType["actionButtonForwardNext"] = "actionButtonForwardNext";
+	ShapeType["actionButtonHelp"] = "actionButtonHelp";
+	ShapeType["actionButtonHome"] = "actionButtonHome";
+	ShapeType["actionButtonInformation"] = "actionButtonInformation";
+	ShapeType["actionButtonMovie"] = "actionButtonMovie";
+	ShapeType["actionButtonReturn"] = "actionButtonReturn";
+	ShapeType["actionButtonSound"] = "actionButtonSound";
+	ShapeType["arc"] = "arc";
+	ShapeType["bentArrow"] = "bentArrow";
+	ShapeType["bentUpArrow"] = "bentUpArrow";
+	ShapeType["bevel"] = "bevel";
+	ShapeType["blockArc"] = "blockArc";
+	ShapeType["borderCallout1"] = "borderCallout1";
+	ShapeType["borderCallout2"] = "borderCallout2";
+	ShapeType["borderCallout3"] = "borderCallout3";
+	ShapeType["bracePair"] = "bracePair";
+	ShapeType["bracketPair"] = "bracketPair";
+	ShapeType["callout1"] = "callout1";
+	ShapeType["callout2"] = "callout2";
+	ShapeType["callout3"] = "callout3";
+	ShapeType["can"] = "can";
+	ShapeType["chartPlus"] = "chartPlus";
+	ShapeType["chartStar"] = "chartStar";
+	ShapeType["chartX"] = "chartX";
+	ShapeType["chevron"] = "chevron";
+	ShapeType["chord"] = "chord";
+	ShapeType["circularArrow"] = "circularArrow";
+	ShapeType["cloud"] = "cloud";
+	ShapeType["cloudCallout"] = "cloudCallout";
+	ShapeType["corner"] = "corner";
+	ShapeType["cornerTabs"] = "cornerTabs";
+	ShapeType["cube"] = "cube";
+	ShapeType["curvedDownArrow"] = "curvedDownArrow";
+	ShapeType["curvedLeftArrow"] = "curvedLeftArrow";
+	ShapeType["curvedRightArrow"] = "curvedRightArrow";
+	ShapeType["curvedUpArrow"] = "curvedUpArrow";
+	ShapeType["custGeom"] = "custGeom";
+	ShapeType["decagon"] = "decagon";
+	ShapeType["diagStripe"] = "diagStripe";
+	ShapeType["diamond"] = "diamond";
+	ShapeType["dodecagon"] = "dodecagon";
+	ShapeType["donut"] = "donut";
+	ShapeType["doubleWave"] = "doubleWave";
+	ShapeType["downArrow"] = "downArrow";
+	ShapeType["downArrowCallout"] = "downArrowCallout";
+	ShapeType["ellipse"] = "ellipse";
+	ShapeType["ellipseRibbon"] = "ellipseRibbon";
+	ShapeType["ellipseRibbon2"] = "ellipseRibbon2";
+	ShapeType["flowChartAlternateProcess"] = "flowChartAlternateProcess";
+	ShapeType["flowChartCollate"] = "flowChartCollate";
+	ShapeType["flowChartConnector"] = "flowChartConnector";
+	ShapeType["flowChartDecision"] = "flowChartDecision";
+	ShapeType["flowChartDelay"] = "flowChartDelay";
+	ShapeType["flowChartDisplay"] = "flowChartDisplay";
+	ShapeType["flowChartDocument"] = "flowChartDocument";
+	ShapeType["flowChartExtract"] = "flowChartExtract";
+	ShapeType["flowChartInputOutput"] = "flowChartInputOutput";
+	ShapeType["flowChartInternalStorage"] = "flowChartInternalStorage";
+	ShapeType["flowChartMagneticDisk"] = "flowChartMagneticDisk";
+	ShapeType["flowChartMagneticDrum"] = "flowChartMagneticDrum";
+	ShapeType["flowChartMagneticTape"] = "flowChartMagneticTape";
+	ShapeType["flowChartManualInput"] = "flowChartManualInput";
+	ShapeType["flowChartManualOperation"] = "flowChartManualOperation";
+	ShapeType["flowChartMerge"] = "flowChartMerge";
+	ShapeType["flowChartMultidocument"] = "flowChartMultidocument";
+	ShapeType["flowChartOfflineStorage"] = "flowChartOfflineStorage";
+	ShapeType["flowChartOffpageConnector"] = "flowChartOffpageConnector";
+	ShapeType["flowChartOnlineStorage"] = "flowChartOnlineStorage";
+	ShapeType["flowChartOr"] = "flowChartOr";
+	ShapeType["flowChartPredefinedProcess"] = "flowChartPredefinedProcess";
+	ShapeType["flowChartPreparation"] = "flowChartPreparation";
+	ShapeType["flowChartProcess"] = "flowChartProcess";
+	ShapeType["flowChartPunchedCard"] = "flowChartPunchedCard";
+	ShapeType["flowChartPunchedTape"] = "flowChartPunchedTape";
+	ShapeType["flowChartSort"] = "flowChartSort";
+	ShapeType["flowChartSummingJunction"] = "flowChartSummingJunction";
+	ShapeType["flowChartTerminator"] = "flowChartTerminator";
+	ShapeType["foldedCorner"] = "foldedCorner";
+	ShapeType["frame"] = "frame";
+	ShapeType["funnel"] = "funnel";
+	ShapeType["gear6"] = "gear6";
+	ShapeType["gear9"] = "gear9";
+	ShapeType["halfFrame"] = "halfFrame";
+	ShapeType["heart"] = "heart";
+	ShapeType["heptagon"] = "heptagon";
+	ShapeType["hexagon"] = "hexagon";
+	ShapeType["homePlate"] = "homePlate";
+	ShapeType["horizontalScroll"] = "horizontalScroll";
+	ShapeType["irregularSeal1"] = "irregularSeal1";
+	ShapeType["irregularSeal2"] = "irregularSeal2";
+	ShapeType["leftArrow"] = "leftArrow";
+	ShapeType["leftArrowCallout"] = "leftArrowCallout";
+	ShapeType["leftBrace"] = "leftBrace";
+	ShapeType["leftBracket"] = "leftBracket";
+	ShapeType["leftCircularArrow"] = "leftCircularArrow";
+	ShapeType["leftRightArrow"] = "leftRightArrow";
+	ShapeType["leftRightArrowCallout"] = "leftRightArrowCallout";
+	ShapeType["leftRightCircularArrow"] = "leftRightCircularArrow";
+	ShapeType["leftRightRibbon"] = "leftRightRibbon";
+	ShapeType["leftRightUpArrow"] = "leftRightUpArrow";
+	ShapeType["leftUpArrow"] = "leftUpArrow";
+	ShapeType["lightningBolt"] = "lightningBolt";
+	ShapeType["line"] = "line";
+	ShapeType["lineInv"] = "lineInv";
+	ShapeType["mathDivide"] = "mathDivide";
+	ShapeType["mathEqual"] = "mathEqual";
+	ShapeType["mathMinus"] = "mathMinus";
+	ShapeType["mathMultiply"] = "mathMultiply";
+	ShapeType["mathNotEqual"] = "mathNotEqual";
+	ShapeType["mathPlus"] = "mathPlus";
+	ShapeType["moon"] = "moon";
+	ShapeType["noSmoking"] = "noSmoking";
+	ShapeType["nonIsoscelesTrapezoid"] = "nonIsoscelesTrapezoid";
+	ShapeType["notchedRightArrow"] = "notchedRightArrow";
+	ShapeType["octagon"] = "octagon";
+	ShapeType["parallelogram"] = "parallelogram";
+	ShapeType["pentagon"] = "pentagon";
+	ShapeType["pie"] = "pie";
+	ShapeType["pieWedge"] = "pieWedge";
+	ShapeType["plaque"] = "plaque";
+	ShapeType["plaqueTabs"] = "plaqueTabs";
+	ShapeType["plus"] = "plus";
+	ShapeType["quadArrow"] = "quadArrow";
+	ShapeType["quadArrowCallout"] = "quadArrowCallout";
+	ShapeType["rect"] = "rect";
+	ShapeType["ribbon"] = "ribbon";
+	ShapeType["ribbon2"] = "ribbon2";
+	ShapeType["rightArrow"] = "rightArrow";
+	ShapeType["rightArrowCallout"] = "rightArrowCallout";
+	ShapeType["rightBrace"] = "rightBrace";
+	ShapeType["rightBracket"] = "rightBracket";
+	ShapeType["round1Rect"] = "round1Rect";
+	ShapeType["round2DiagRect"] = "round2DiagRect";
+	ShapeType["round2SameRect"] = "round2SameRect";
+	ShapeType["roundRect"] = "roundRect";
+	ShapeType["rtTriangle"] = "rtTriangle";
+	ShapeType["smileyFace"] = "smileyFace";
+	ShapeType["snip1Rect"] = "snip1Rect";
+	ShapeType["snip2DiagRect"] = "snip2DiagRect";
+	ShapeType["snip2SameRect"] = "snip2SameRect";
+	ShapeType["snipRoundRect"] = "snipRoundRect";
+	ShapeType["squareTabs"] = "squareTabs";
+	ShapeType["star10"] = "star10";
+	ShapeType["star12"] = "star12";
+	ShapeType["star16"] = "star16";
+	ShapeType["star24"] = "star24";
+	ShapeType["star32"] = "star32";
+	ShapeType["star4"] = "star4";
+	ShapeType["star5"] = "star5";
+	ShapeType["star6"] = "star6";
+	ShapeType["star7"] = "star7";
+	ShapeType["star8"] = "star8";
+	ShapeType["stripedRightArrow"] = "stripedRightArrow";
+	ShapeType["sun"] = "sun";
+	ShapeType["swooshArrow"] = "swooshArrow";
+	ShapeType["teardrop"] = "teardrop";
+	ShapeType["trapezoid"] = "trapezoid";
+	ShapeType["triangle"] = "triangle";
+	ShapeType["upArrow"] = "upArrow";
+	ShapeType["upArrowCallout"] = "upArrowCallout";
+	ShapeType["upDownArrow"] = "upDownArrow";
+	ShapeType["upDownArrowCallout"] = "upDownArrowCallout";
+	ShapeType["uturnArrow"] = "uturnArrow";
+	ShapeType["verticalScroll"] = "verticalScroll";
+	ShapeType["wave"] = "wave";
+	ShapeType["wedgeEllipseCallout"] = "wedgeEllipseCallout";
+	ShapeType["wedgeRectCallout"] = "wedgeRectCallout";
+	ShapeType["wedgeRoundRectCallout"] = "wedgeRoundRectCallout";
+	return ShapeType;
+}({});
+let SchemeColor = /* @__PURE__ */ function(SchemeColor) {
+	SchemeColor["text1"] = "tx1";
+	SchemeColor["text2"] = "tx2";
+	SchemeColor["background1"] = "bg1";
+	SchemeColor["background2"] = "bg2";
+	SchemeColor["accent1"] = "accent1";
+	SchemeColor["accent2"] = "accent2";
+	SchemeColor["accent3"] = "accent3";
+	SchemeColor["accent4"] = "accent4";
+	SchemeColor["accent5"] = "accent5";
+	SchemeColor["accent6"] = "accent6";
+	return SchemeColor;
+}({});
+let AlignH = /* @__PURE__ */ function(AlignH) {
+	AlignH["left"] = "left";
+	AlignH["center"] = "center";
+	AlignH["right"] = "right";
+	AlignH["justify"] = "justify";
+	return AlignH;
+}({});
+let AlignV = /* @__PURE__ */ function(AlignV) {
+	AlignV["top"] = "top";
+	AlignV["middle"] = "middle";
+	AlignV["bottom"] = "bottom";
+	return AlignV;
+}({});
+/**
+* Valid ECMA-376 `ST_ShapeType` presets that are not surfaced with a friendly
+* `ShapeType` name. They are still legal geometries PowerPoint renders, so the
+* preset-validation set must accept them.
+*/
+const EXTRA_SHAPE_PRESETS = [
+	"straightConnector1",
+	"bentConnector2",
+	"bentConnector3",
+	"bentConnector4",
+	"bentConnector5",
+	"curvedConnector2",
+	"curvedConnector3",
+	"curvedConnector4",
+	"curvedConnector5"
+];
+/**
+* Every shape geometry name ts-pptx can serialize without corrupting the
+* package: the OOXML preset geometries (`ST_ShapeType` — `ShapeType` values
+* plus the unexposed connectors above) and `custGeom` (freeform paths, emitted
+* as `<a:custGeom>` rather than `<a:prstGeom>`). Used to reject bogus presets
+* before they become an invalid `<a:prstGeom prst="...">` that triggers
+* PowerPoint's "needs repair" dialog and drops the shape.
+*/
+const VALID_SHAPE_PRESETS = /* @__PURE__ */ new Set([...Object.values(ShapeType), ...EXTRA_SHAPE_PRESETS]);
+/**
+* Narrow a public `CHART_NAME` to the internal `ChartType` enum. Because
+* `CHART_NAME` is derived from `ChartType`, every `CHART_NAME` value is by
+* construction a valid enum value, so this conversion is total and safe — it is
+* the single boundary cast that lets internal code compare against the enum
+* (enum-to-enum) instead of enum-to-string.
+*/
+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
+* the `http://schemas.microsoft.com/office/drawing/2014/chartex` namespace, are referenced from
+* the slide through `<mc:AlternateContent>`, and render only in PowerPoint 2016+/Microsoft 365
+* (older Office, Google Slides, Keynote and LibreOffice show the `<mc:Fallback>` shape instead).
+* See `gen/chart/chartex-xml.ts`.
+*/
+const CHARTEX_TYPES = /* @__PURE__ */ new Set([
+	"waterfall",
+	"funnel",
+	"treemap",
+	"sunburst",
+	"histogram",
+	"pareto",
+	"boxWhisker",
+	"regionMap"
+]);
+/**
+* Is `type` a chartEx (cx:) chart? Accepts a `ChartType`/`CHART_NAME` string; anything else —
+* including a combo-chart `ChartMulti[]` array or `undefined` — is not a chartEx type (combos are
+* classic-only), so those return `false`.
+*/
+function isChartExType(type) {
+	return typeof type === "string" && CHARTEX_TYPES.has(type);
+}
+let SlideObjectType = /* @__PURE__ */ function(SlideObjectType) {
+	SlideObjectType["chart"] = "chart";
+	SlideObjectType["connector"] = "connector";
+	SlideObjectType["group"] = "group";
+	SlideObjectType["hyperlink"] = "hyperlink";
+	SlideObjectType["image"] = "image";
+	SlideObjectType["media"] = "media";
+	SlideObjectType["model3d"] = "model3d";
+	SlideObjectType["oleObject"] = "oleObject";
+	SlideObjectType["online"] = "online";
+	SlideObjectType["placeholder"] = "placeholder";
+	SlideObjectType["table"] = "table";
+	SlideObjectType["tablecell"] = "tablecell";
+	SlideObjectType["text"] = "text";
+	SlideObjectType["notes"] = "notes";
+	SlideObjectType["zoom"] = "zoom";
+	return 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`.
+*/
+const CONNECTOR_PRESETS = {
+	straight: "straightConnector1",
+	elbow: "bentConnector",
+	curved: "curvedConnector"
+};
+/**
+* Resolve the concrete connector preset geometry name for a `type` + bend count.
+* `straight` ignores `bends` (it has no adjustable jog). For `elbow` / `curved`, the
+* preset suffix is `bends + 2`, so `bends` of 1/2/3 maps to `…Connector3/4/5`, each
+* of which exposes exactly `bends` adjustable guides (`adj1…adjN`).
+* @param {'straight' | 'elbow' | 'curved'} type - friendly connector routing style
+* @param {number} bends - number of adjustable bends (1–3); ignored for `straight`
+* @return {CONNECTOR_PRESET_NAME} OOXML preset geometry name (e.g. `bentConnector4`)
+*/
+function connectorPresetFor(type, bends) {
+	if (type === "straight") return CONNECTOR_PRESETS.straight;
+	return `${CONNECTOR_PRESETS[type]}${bends + 2}`;
+}
+let PlaceholderType = /* @__PURE__ */ function(PlaceholderType) {
+	PlaceholderType["title"] = "title";
+	PlaceholderType["body"] = "body";
+	PlaceholderType["image"] = "pic";
+	PlaceholderType["chart"] = "chart";
+	PlaceholderType["table"] = "tbl";
+	PlaceholderType["media"] = "media";
+	return PlaceholderType;
+}({});
+/**
+* Bullet glyph presets. Only `DEFAULT` is currently wired through to output; the remaining entries are
+* reserved and not yet selectable via options.
+*/
+let BulletType = /* @__PURE__ */ function(BulletType) {
+	BulletType["DEFAULT"] = "&#x2022;";
+	BulletType["CHECK"] = "&#x2713;";
+	BulletType["STAR"] = "&#x2605;";
+	BulletType["TRIANGLE"] = "&#x25B6;";
+	return BulletType;
+}({});
+/**
+* Built-in PowerPoint table style IDs.
+*
+* Each value is the GUID that goes into `<a:tableStyleId>` inside `<a:tblPr>`.
+* These 74 GUIDs are the complete set defined in [MS-OE376] §5.1.6.10 and are
+* resolved by PowerPoint without embedding any style definition in the file.
+*
+* Only these enum members are supported. Raw GUID strings are not accepted;
+* use `TableStyle` members exclusively.
+*/
+let TableStyle = /* @__PURE__ */ function(TableStyle) {
+	TableStyle["NO_STYLE_NO_GRID"] = "{2D5ABB26-0587-4C30-8999-92F81FD0307C}";
+	TableStyle["NO_STYLE_TABLE_GRID"] = "{5940675A-B579-460E-94D1-54222C63F5DA}";
+	TableStyle["THEMED_STYLE_1_ACCENT_1"] = "{3C2FFA5D-87B4-456A-9821-1D502468CF0F}";
+	TableStyle["THEMED_STYLE_1_ACCENT_2"] = "{284E427A-3D55-4303-BF80-6455036E1DE7}";
+	TableStyle["THEMED_STYLE_1_ACCENT_3"] = "{69C7853C-536D-4A76-A0AE-DD22124D55A5}";
+	TableStyle["THEMED_STYLE_1_ACCENT_4"] = "{775DCB02-9BB8-47FD-8907-85C794F793BA}";
+	TableStyle["THEMED_STYLE_1_ACCENT_5"] = "{35758FB7-9AC5-4552-8A53-C91805E547FA}";
+	TableStyle["THEMED_STYLE_1_ACCENT_6"] = "{08FB837D-C827-4EFA-A057-4D05807E0F7C}";
+	TableStyle["THEMED_STYLE_2_ACCENT_1"] = "{D113A9D2-9D6B-4929-AA2D-F23B5EE8CBE7}";
+	TableStyle["THEMED_STYLE_2_ACCENT_2"] = "{18603FDC-E32A-4AB5-989C-0864C3EAD2B8}";
+	TableStyle["THEMED_STYLE_2_ACCENT_3"] = "{306799F8-075E-4A3A-A7F6-7FBC6576F1A4}";
+	TableStyle["THEMED_STYLE_2_ACCENT_4"] = "{E269D01E-BC32-4049-B463-5C60D7B0CCD2}";
+	TableStyle["THEMED_STYLE_2_ACCENT_5"] = "{327F97BB-C833-4FB7-BDE5-3F7075034690}";
+	TableStyle["THEMED_STYLE_2_ACCENT_6"] = "{638B1855-1B75-4FBE-930C-398BA8C253C6}";
+	TableStyle["LIGHT_STYLE_1"] = "{9D7B26C5-4107-4FEC-AEDC-1716B250A1EF}";
+	TableStyle["LIGHT_STYLE_1_ACCENT_1"] = "{3B4B98B0-60AC-42C2-AFA5-B58CD77FA1E5}";
+	TableStyle["LIGHT_STYLE_1_ACCENT_2"] = "{0E3FDE45-AF77-4B5C-9715-49D594BDF05E}";
+	TableStyle["LIGHT_STYLE_1_ACCENT_3"] = "{C083E6E3-FA7D-4D7B-A595-EF9225AFEA82}";
+	TableStyle["LIGHT_STYLE_1_ACCENT_4"] = "{D27102A9-8310-4765-A935-A1911B00CA55}";
+	TableStyle["LIGHT_STYLE_1_ACCENT_5"] = "{5FD0F851-EC5A-4D38-B0AD-8093EC10F338}";
+	TableStyle["LIGHT_STYLE_1_ACCENT_6"] = "{68D230F3-CF80-4859-8CE7-A43EE81993B5}";
+	TableStyle["LIGHT_STYLE_2"] = "{7E9639D4-E3E2-4D34-9284-5A2195B3D0D7}";
+	TableStyle["LIGHT_STYLE_2_ACCENT_1"] = "{69012ECD-51FC-41F1-AA8D-1B2483CD663E}";
+	TableStyle["LIGHT_STYLE_2_ACCENT_2"] = "{72833802-FEF1-4C79-8D5D-14CF1EAF98D9}";
+	TableStyle["LIGHT_STYLE_2_ACCENT_3"] = "{F2DE63D5-997A-4646-A377-4702673A728D}";
+	TableStyle["LIGHT_STYLE_2_ACCENT_4"] = "{17292A2E-F333-43FB-9621-5CBBE7FDCDCB}";
+	TableStyle["LIGHT_STYLE_2_ACCENT_5"] = "{5A111915-BE36-4E01-A7E5-04B1672EAD32}";
+	TableStyle["LIGHT_STYLE_2_ACCENT_6"] = "{912C8C85-51F0-491E-9774-3900AFEF0FD7}";
+	TableStyle["LIGHT_STYLE_3"] = "{616DA210-FB5B-4158-B5E0-FEB733F419BA}";
+	TableStyle["LIGHT_STYLE_3_ACCENT_1"] = "{BC89EF96-8CEA-46FF-86C4-4CE0E7609802}";
+	TableStyle["LIGHT_STYLE_3_ACCENT_2"] = "{5DA37D80-6434-44D0-A028-1B22A696006F}";
+	TableStyle["LIGHT_STYLE_3_ACCENT_3"] = "{8799B23B-EC83-4686-B30A-512413B5E67A}";
+	TableStyle["LIGHT_STYLE_3_ACCENT_4"] = "{ED083AE6-46FA-4A59-8FB0-9F97EB10719F}";
+	TableStyle["LIGHT_STYLE_3_ACCENT_5"] = "{BDBED569-4797-4DF1-A0F4-6AAB3CD982D8}";
+	TableStyle["LIGHT_STYLE_3_ACCENT_6"] = "{E8B1032C-EA38-4F05-BA0D-38AFFFC7BED3}";
+	TableStyle["MEDIUM_STYLE_1"] = "{793D81CF-94F2-401A-BA57-92F5A7B2D0C5}";
+	TableStyle["MEDIUM_STYLE_1_ACCENT_1"] = "{B301B821-A1FF-4177-AEE7-76D212191A09}";
+	TableStyle["MEDIUM_STYLE_1_ACCENT_2"] = "{9DCAF9ED-07DC-4A11-8D7F-57B35C25682E}";
+	TableStyle["MEDIUM_STYLE_1_ACCENT_3"] = "{1FECB4D8-DB02-4DC6-A0A2-4F2EBAE1DC90}";
+	TableStyle["MEDIUM_STYLE_1_ACCENT_4"] = "{1E171933-4619-4E11-9A3F-F7608DF75F80}";
+	TableStyle["MEDIUM_STYLE_1_ACCENT_5"] = "{FABFCF23-3B69-468F-B69F-88F6DE6A72F2}";
+	TableStyle["MEDIUM_STYLE_1_ACCENT_6"] = "{10A1B5D5-9B99-4C35-A422-299274C87663}";
+	TableStyle["MEDIUM_STYLE_2"] = "{073A0DAA-6AF3-43AB-8588-CEC1D06C72B9}";
+	TableStyle["MEDIUM_STYLE_2_ACCENT_1"] = "{5C22544A-7EE6-4342-B048-85BDC9FD1C3A}";
+	TableStyle["MEDIUM_STYLE_2_ACCENT_2"] = "{21E4AEA4-8DFA-4A89-87EB-49C32662AFE0}";
+	TableStyle["MEDIUM_STYLE_2_ACCENT_3"] = "{F5AB1C69-6EDB-4FF4-983F-18BD219EF322}";
+	TableStyle["MEDIUM_STYLE_2_ACCENT_4"] = "{00A15C55-8517-42AA-B614-E9B94910E393}";
+	TableStyle["MEDIUM_STYLE_2_ACCENT_5"] = "{7DF18680-E054-41AD-8BC1-D1AEF772440D}";
+	TableStyle["MEDIUM_STYLE_2_ACCENT_6"] = "{93296810-A885-4BE3-A3E7-6D5BEEA58F35}";
+	TableStyle["MEDIUM_STYLE_3"] = "{8EC20E35-A176-4012-BC5E-935CFFF8708E}";
+	TableStyle["MEDIUM_STYLE_3_ACCENT_1"] = "{6E25E649-3F16-4E02-A733-19D2CDBF48F0}";
+	TableStyle["MEDIUM_STYLE_3_ACCENT_2"] = "{85BE263C-DBD7-4A20-BB59-AAB30ACAA65A}";
+	TableStyle["MEDIUM_STYLE_3_ACCENT_3"] = "{EB344D84-9AFB-497E-A393-DC336BA19D2E}";
+	TableStyle["MEDIUM_STYLE_3_ACCENT_4"] = "{EB9631B5-78F2-41C9-869B-9F39066F8104}";
+	TableStyle["MEDIUM_STYLE_3_ACCENT_5"] = "{74C1A8A3-306A-4EB7-A6B1-4F7E0EB9C5D6}";
+	TableStyle["MEDIUM_STYLE_3_ACCENT_6"] = "{2A488322-F2BA-4B5B-9748-0D474271808F}";
+	TableStyle["MEDIUM_STYLE_4"] = "{D7AC3CCA-C797-4891-BE02-D94E43425B78}";
+	TableStyle["MEDIUM_STYLE_4_ACCENT_1"] = "{69CF1AB2-1976-4502-BF36-3FF5EA218861}";
+	TableStyle["MEDIUM_STYLE_4_ACCENT_2"] = "{8A107856-5554-42FB-B03E-39F5DBC370BA}";
+	TableStyle["MEDIUM_STYLE_4_ACCENT_3"] = "{0505E3EF-67EA-436B-97B2-0124C06EBD24}";
+	TableStyle["MEDIUM_STYLE_4_ACCENT_4"] = "{C4B1156A-380E-4F78-BDF5-A606A8083BF9}";
+	TableStyle["MEDIUM_STYLE_4_ACCENT_5"] = "{22838BEF-8BB2-4498-84A7-C5851F593DF1}";
+	TableStyle["MEDIUM_STYLE_4_ACCENT_6"] = "{16D9F66E-5EB9-4882-86FB-DCBF35E3C3E4}";
+	TableStyle["DARK_STYLE_1"] = "{E8034E78-7F5D-4C2E-B375-FC64B27BC917}";
+	TableStyle["DARK_STYLE_1_ACCENT_1"] = "{125E5076-3810-47DD-B79F-674D7AD40C01}";
+	TableStyle["DARK_STYLE_1_ACCENT_2"] = "{37CE84F3-28C3-443E-9E96-99CF82512B78}";
+	TableStyle["DARK_STYLE_1_ACCENT_3"] = "{D03447BB-5D67-496B-8E87-E561075AD55C}";
+	TableStyle["DARK_STYLE_1_ACCENT_4"] = "{E929F9F4-4A8F-4326-A1B4-22849713DDAB}";
+	TableStyle["DARK_STYLE_1_ACCENT_5"] = "{8FD4443E-F989-4FC4-A0C8-D5A2AF1F390B}";
+	TableStyle["DARK_STYLE_1_ACCENT_6"] = "{AF606853-7671-496A-8E4F-DF71F8EC918B}";
+	TableStyle["DARK_STYLE_2"] = "{5202B0CA-FC54-4496-8BCA-5EF66A818D29}";
+	/** Header uses Accent 2, body rows use Accent 1 */
+	TableStyle["DARK_STYLE_2_ACCENT_1_ACCENT_2"] = "{0660B408-B3CF-4A94-85FC-2B1E0A45F4A2}";
+	/** Header uses Accent 4, body rows use Accent 3 */
+	TableStyle["DARK_STYLE_2_ACCENT_3_ACCENT_4"] = "{91EBBBCC-DAD2-459C-BE2E-F6DE35CF9A28}";
+	/** Header uses Accent 6, body rows use Accent 5 */
+	TableStyle["DARK_STYLE_2_ACCENT_5_ACCENT_6"] = "{46F890A9-2807-4EBB-B81D-B2AA78EC7F39}";
+	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
+/**
+* Generator-side unit conversion — the lenient layer over `units.ts`.
+*
+* `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.
+*
+* 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
+*/
+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");
+}
+//#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 };
+
+//# sourceMappingURL=units-internal-Dg95w_YD.js.map