pptx-ts 3.7.0 → 4.0.1

package/dist/entry-compose-DCnvBZz2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-compose-DCnvBZz2.d.ts","names":[],"sources":["../src/runtime/types.ts","../src/units.ts","../src/gen/oxml/el.ts","../src/gen/slide/objects/shared.ts","../src/gen/opc/content-types.ts","../src/package/parts/shared.ts","../src/slide.ts","../src/families/shared.ts","../src/presentation.ts","../src/gen/slide/objects/text.ts","../src/gen/slide/objects/image.ts","../src/families/core.ts","../src/entry-compose.ts"],"mappings":";;;;;;;;;KAIY;WACF,qBAAqB;;;;;;;;;;;;EAY9B,YAAY,KAAK;IAAkB;QAAmB;;;;;;;;;EAStD,sBAAsB,KAAK,kBAAkB,QAAQ;EACrD,YAAY,kBAAkB,eAAe,cAAc,OAAO,eAAe;;;;;;;EAOjF,eAAe,mBAAmB,QAAQ;;;;;;;;;cClB9B;;;;;;cAOA;;;;;;;cAQA;;;;;;cAOA;;;;;iBAMG,eAAe;;;;;;;;;KAanB;WAA0B;;;;cASzB;;;;;cAMA;;cAGA;KAED;UAEK;;WAEP,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;WAEA;;iBAGM,YAAY,iBAAiB;iBAK7B,YAAY,iBAAiB;iBAK7B,YAAY,gBAAgB,cAAc;;;;;;;;;;;;;iBAkB1C,aAAa,iBAAiB,kBAAkB;;;;;;;;;;;;;;;iBAoBhD,WAAW,wBAAwB,kBAAkB;iBAoCrD,YAAY;;;;;;;;;;;;;;;;;;;;iBAwBZ,YAAY;;;;;;;;;iBAaZ,YAAY,aAAa;cAiB5B,kBAAkB,SAAS,OAAO,oBAAoB;;;;KC7LvD,WAAW;;;;;;;;;;;;;;;;;;;;;UCDN;;EAEhB,KAAK;;;;;;;;;EASL;;;;;;;;EAQA,UAAU,YAAY;;EAEtB,OAAO,oBAAoB,sBAAsB;;EAEjD;IAAS;IAAW;IAAW;IAAY;;;EAE3C,aAAa;;EAEb,eAAe;;;;;;EAMf,UAAU;;;;;;;;;;;KAYC,qBACT,gBAAgB,QAChB,gBAAgB,YAChB,gBAAgB,QAChB,gBAAgB,QAChB,gBAAgB,UAChB,gBAAgB,YAChB,gBAAgB,cAChB,gBAAgB,QAChB,gBAAgB,OAChB,gBAAgB;;KAGP,kBAAkB,KAAK;;;;;;;;;;;;;;;;;KAkBvB,gBAAgB,QAAQ,OAAO,oBAAoB;;;;UCtE9C;WACP;WACA;;;;;;;UAQO;WACP;WACA;WACA;;;;;KC/BE,aAAa,oBAAoB,sBAAsB;;;;;;;;UASlD;;;;;;;WAOP;;WAEA,QAAQ;;WAER,eAAe;;;UAIR;;WAEP,iBAAiB,OAAO,mBAAmB,qBAAqB,KAAK;;WAErE,eAAe,MAAM,2BAA2B,KAAK;;;;;;WAMrD,kBAAkB,QAAQ,YAAY,KAAK,cAAc;;;;;;UAOlD;WACP,YAAY,MAAM,8BAA8B;WAChD,gBAAgB,MAAM,8BAA8B;WACpD,YAAY,OAAO,mBAAmB,wBAAwB;WAC9D,aAAa,QAAQ,qBAAqB,yBAAyB;WACnE,YAAY,MAAM,8BAA8B;;;;cCRrC;;mBACH;EAEV,WAAW,QAAQ,+BAA+B;EAClD,WAAW,qBAAqB;EAChC,mBAAmB;EACnB;EACA,aAAa;EACb,OAAO;EACP,YAAY;EACZ,YAAY;EACZ;EACA;EACA,cAAc;EACd;EACA,mBAAmB;EACnB,eAAe;EACf,WAAW;EACX,qBAAqB;EACrB,aAAa;;;;;;WAOJ,eAAe;;;;;;;;EAShB,cAAc;EACd,UAAU;EACV,YAAY;EACZ,cAAc;EACd,UAAU;EACV,UAAU;EACV,UAAU;EACV,YAAY;EACZ,UAAU;EACV,cAAc;EACd,gBAAgB;EAChB,UAAU;EACV,cAAc;EACd,gBAAgB;EAChB,UAAU;EACV,SAAS;EACT,cAAc;EAE7B,YAAY;IACX,WAAW,QAAQ,+BAA+B;IAClD,WAAW,qBAAqB;IAChC,oBAAoB;IACpB,YAAY;IACZ,cAAc,OAAO;IACrB;IACA;IACA;IACA,cAAc;IACd,SAAS;IACT,cAAc;;;;;;;;;;UAwDP;MACG,WAAW,OAAO;MASlB,cAAc;;;;;UAQjB;MACG,MAAM,OAAO;MAIb,SAAS;;;;UAOZ;MACG,OAAO;MAIP;;;;;UAUH;MACG,WAAW,OAAO;MAIlB,cAAc;;;;MAOd,YAAY,OAAO;MAMnB,eAAe;;;;;;;;;;MAaf,sBAAsB;;;;;;;;;MAYtB,oBAAoB;;MAOpB;;MAKA;;;;;;;;KC5OA;;KAkBA;;;;;;KAwBP,OAAO,UAAU,sBAAsB,OAAO,iBAAiB,MAAM,WAAW,MAAM;;;;;;;;;;KAW/E,kBAAkB,KAAK,QAAQ,kCAAkC,OAAO;EACnF,YACC,OAAO,cACP,MAAM,kBAAkB,cACxB,OAAO;IAAc,OAAO;;;;;;;UA6Bb;WACP,MAAM;WACN,aAAa;;;;;;;;;UAUN;EAChB,eACC,KAAK,2BACL,eAAe,aACf,MAAM,uBACF;EACL,gBAAgB,KAAK,2BAA2B,eAAe,aAAa,MAAM;EAClF,eAAe,KAAK,2BAA2B,MAAM,YAAY,MAAM,eAAe;EACtF,iBAAiB,KAAK,2BAA2B,eAAe,SAAS;;;;;;;KAgB9D;;KAqBP,gBAAgB,UAAU,sBAAsB,QAAQ,mBAAmB,OAAO,aAAa;;;;;;;KAQxF,kBACV,KAAK,uBAAuB,QAAQ,mBAAmB,OAAO,gBAAgB;;;;;;;;;UAW/D;WACP,UAAU,OAAO,sBAAsB;;;UAIhC;;WAEP,MAAM;;WAEN,UAAU;;WAEV,WAAW;;WAEX,YAAY;;WAEZ,QAAQ;;WAER,sBAAsB;;WAEtB,UAAU;;;;;;KAgER,wBAAwB,KAAK,YAAW,KAAK,8BAA8B,YAAY,YAAY,SACxG,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;cCrKE;;;;;;;;;;;;;;UAeZ;MACG,OAAO,gBAAgB;MAgBvB;;;;mBAOM;MACN;;;;UAeH;MACG,OAAO;MAIP;;;;UAOH;MACG,QAAQ;MAIR;;;;;UAQH;MACG,SAAS;MAIT;;;;UAOH;MACG,QAAQ;MAIR;;;;UAOH;MACG,MAAM,OAAO;MAIb,SAAS;;;;UAOZ;MACG,MAAM;MAIN;;;;;UAQH;MACG,cAAc;MASd;;;;;UAQH;MACG,QAAQ;MAIR;;mBAKM;;mBAGA;MACN,UAAU;;mBAKJ;MACN,YAAY;;UAKf;;;;;;;qBAQW,eAAe;MACvB,gBAAgB;cAIf;UAoBJ;UAiBA;MACG,cAAc;mBAIR;;mBAaA;;mBAGA;EAEjB,YAAY,SAAS,gBAAgB,mBAAmB;;;;;;mBA6DvC;;;;;;mBAoBA;;;;;;mBAQA;;;;;mBAMA;;;;;UAaT;;;;;;;;;;;;;;;EAyBR,gBAAa;IAAkB;QAAgD,QAAQ;;;;;;;;;YAsB7E,aAAa,gBAAgB,qBACtC,QAAQ,IACN,wBAAwB,YAAY,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCrD,oBACL,cACA,iBAAiB,aAAa,aAC9B;IAAS;IAAgB;IAAkB;MACzC;;;;;;;;;;;;;;;;;;;;;;;;EAmCG,UAAU;IACf;IACA,OAAO,cAAc;IACrB;IACA,QAAQ;MACL;;;;;;;;;;;;;;;;EAoDJ,YAAY,eAAe,aAAa,MAAM,qBAAqB;;;;;;;;;;;EAcnE,aAAa,eAAe,aAAa,MAAM;;;;;;;;;;;;;;;;;;;EAsB/C,YAAY,MAAM,YAAY,MAAM,aAAa;;;;;;;;;EAc3C,QAAQ,QAAQ,iBAAiB,QAAQ;;;;;;EAYzC,MAAM,QAAQ,aAAa,iBAAiB,cAAc,OAAO;;;;;;;;;;;;;;;;;EAuBjE,QAAQ,QAAQ,aAAa,QAAQ;;;;;;;EAYrC,UAAU,QAAQ,iBAAiB;;;;;;;EAqBzC,kBAAkB,cAAc,OAAO;;;;;;EAUvC,WAAW,SAAS;;;;;;EA6CpB,SAAS,UAAU,gBAAgB;;;;;;EAqFnC,aAAa,QAAQ;;;;;EAgDrB,kBAAkB,OAAO;;;;;;;iBCz7BV,iBAAiB,KAAK;;;;;;iBCEtB,kBAAkB,KAAK;;;;;;;;;;;;;;;;cCL1B;;;mBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KCSR,oBAAoB,MAAM,qBAAqB,GAAG,8BAA6B,SAAS,cAAa;;KAGrG,QAAQ,GAAG,KAAK,eAAc,YAAY,qBAAoB,MAAM,MAAM;;;;;;;;UASrE,iBAAiB;EAC1B;KACE,MAAM,iBAAiB,SAAS;MAAc,MAAM;QAAe;KACnE,QAAQ,cAAc,UAAU,YAAY;;;;KAKnC,eAAe,oBAAoB,qBAAqB,cAC7D,oBAAoB,QAAQ;EAAc;gBAChD;;KAIW,sBAAsB,oBAAoB,qBAAqB,cACpE,oBAAoB,QAAQ;EAAc;kCAC1C;;;;;;;;;KAWK,cAAc,UAAU,qBAAqB,KAAK,OAAO,wBACnE,KAAK,IAAI,gBAAgB,4BACvB,iBAAiB,cAAc,IAAI,KACnC,QAAQ,MAAM,IAAI,cAAc;;KAI/B,+BACH,WAAW,wBAAwB,wBAAwB,YAAY,oBAAoB;;;;;KAOjF,qBAAqB,UAAU,mBAAmB,gBAAgB,uBAAuB,KACpG,qCACmB,uBAEnB,KAAK,2BAA2B;EAAO,WAAW,UAAU,kBAAkB,cAAc;;;UAG5E,eAAe,oBAAoB;;EAEnD,MAAM;;;KAIK,SAAS,oBAAoB,qBAAqB,qBAC7D,0BAA0B,4BAA4B,MACtD,iCAAiC,4BAA4B"}

package/dist/{enums-CvRYniUA.d.ts → enums-BUKTUB6V.d.ts}

@@ -255,12 +255,30 @@ declare enum AlignH {
   right = "right",
   justify = "justify"
 }
+/**
+ * @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.
+ */
 declare enum AlignV {
   top = "top",
   middle = "middle",
   bottom = "bottom"
 }
-type SHAPE_NAME = 'accentBorderCallout1' | 'accentBorderCallout2' | 'accentBorderCallout3' | 'accentCallout1' | 'accentCallout2' | 'accentCallout3' | 'actionButtonBackPrevious' | 'actionButtonBeginning' | 'actionButtonBlank' | 'actionButtonDocument' | 'actionButtonEnd' | 'actionButtonForwardNext' | 'actionButtonHelp' | 'actionButtonHome' | 'actionButtonInformation' | 'actionButtonMovie' | 'actionButtonReturn' | 'actionButtonSound' | 'arc' | 'bentArrow' | 'bentUpArrow' | 'bevel' | 'blockArc' | 'borderCallout1' | 'borderCallout2' | 'borderCallout3' | 'bracePair' | 'bracketPair' | 'callout1' | 'callout2' | 'callout3' | 'can' | 'chartPlus' | 'chartStar' | 'chartX' | 'chevron' | 'chord' | 'circularArrow' | 'cloud' | 'cloudCallout' | 'corner' | 'cornerTabs' | 'cube' | 'curvedDownArrow' | 'curvedLeftArrow' | 'curvedRightArrow' | 'curvedUpArrow' | 'custGeom' | 'decagon' | 'diagStripe' | 'diamond' | 'dodecagon' | 'donut' | 'doubleWave' | 'downArrow' | 'downArrowCallout' | 'ellipse' | 'ellipseRibbon' | 'ellipseRibbon2' | 'flowChartAlternateProcess' | 'flowChartCollate' | 'flowChartConnector' | 'flowChartDecision' | 'flowChartDelay' | 'flowChartDisplay' | 'flowChartDocument' | 'flowChartExtract' | 'flowChartInputOutput' | 'flowChartInternalStorage' | 'flowChartMagneticDisk' | 'flowChartMagneticDrum' | 'flowChartMagneticTape' | 'flowChartManualInput' | 'flowChartManualOperation' | 'flowChartMerge' | 'flowChartMultidocument' | 'flowChartOfflineStorage' | 'flowChartOffpageConnector' | 'flowChartOnlineStorage' | 'flowChartOr' | 'flowChartPredefinedProcess' | 'flowChartPreparation' | 'flowChartProcess' | 'flowChartPunchedCard' | 'flowChartPunchedTape' | 'flowChartSort' | 'flowChartSummingJunction' | 'flowChartTerminator' | 'foldedCorner' | 'frame' | 'funnel' | 'gear6' | 'gear9' | 'halfFrame' | 'heart' | 'heptagon' | 'hexagon' | 'homePlate' | 'horizontalScroll' | 'irregularSeal1' | 'irregularSeal2' | 'leftArrow' | 'leftArrowCallout' | 'leftBrace' | 'leftBracket' | 'leftCircularArrow' | 'leftRightArrow' | 'leftRightArrowCallout' | 'leftRightCircularArrow' | 'leftRightRibbon' | 'leftRightUpArrow' | 'leftUpArrow' | 'lightningBolt' | 'line' | 'lineInv' | 'mathDivide' | 'mathEqual' | 'mathMinus' | 'mathMultiply' | 'mathNotEqual' | 'mathPlus' | 'moon' | 'noSmoking' | 'nonIsoscelesTrapezoid' | 'notchedRightArrow' | 'octagon' | 'parallelogram' | 'pentagon' | 'pie' | 'pieWedge' | 'plaque' | 'plaqueTabs' | 'plus' | 'quadArrow' | 'quadArrowCallout' | 'rect' | 'ribbon' | 'ribbon2' | 'rightArrow' | 'rightArrowCallout' | 'rightBrace' | 'rightBracket' | 'round1Rect' | 'round2DiagRect' | 'round2SameRect' | 'roundRect' | 'rtTriangle' | 'smileyFace' | 'snip1Rect' | 'snip2DiagRect' | 'snip2SameRect' | 'snipRoundRect' | 'squareTabs' | 'star10' | 'star12' | 'star16' | 'star24' | 'star32' | 'star4' | 'star5' | 'star6' | 'star7' | 'star8' | 'stripedRightArrow' | 'sun' | 'swooshArrow' | 'teardrop' | 'trapezoid' | 'triangle' | 'upArrow' | 'upArrowCallout' | 'upDownArrow' | 'upDownArrowCallout' | 'uturnArrow' | 'verticalScroll' | 'wave' | 'wedgeEllipseCallout' | 'wedgeRectCallout' | 'wedgeRoundRectCallout' | CONNECTOR_PRESET_NAME;
+/**
+ * Every shape geometry name `addShape` accepts: the friendly {@link ShapeType} names plus the
+ * connector presets that enum does not surface.
+ *
+ * Derived from `ShapeType` rather than spelled out, for the reason `CHART_NAME`, `SCHEME_COLORS`,
+ * `PLACEHOLDER_TYPE` and `CONNECTOR_PRESET_NAME` are each derived from their runtime source: the
+ * two cannot drift. The hand-written union this replaced had all 179 members in enum order, and
+ * the runtime `VALID_SHAPE_PRESETS` set was already built from `Object.values(ShapeType)`, so the
+ * type and the set it is supposed to describe could disagree on exactly the half nothing checked.
+ * The union this produces is character-for-character the one it replaces.
+ */
+type SHAPE_NAME = `${ShapeType}` | CONNECTOR_PRESET_NAME;
 /**
  * Valid ECMA-376 `ST_ShapeType` presets that are not surfaced with a friendly
  * `ShapeType` name. They are still legal geometries PowerPoint renders, so the
@@ -326,16 +344,6 @@ declare enum SlideObjectType {
   notes = "notes",
   zoom = "zoom"
 }
-/**
- * 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`.
- */
-declare const CONNECTOR_PRESETS: {
-  readonly straight: 'straightConnector1';
-  readonly elbow: 'bentConnector';
-  readonly 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
@@ -459,5 +467,5 @@ declare enum TableStyle {
   DARK_STYLE_2_ACCENT_5_ACCENT_6 = "{46F890A9-2807-4EBB-B81D-B2AA78EC7F39}"
 }
 //#endregion
-export { isChartExType as C, connectorPresetFor as S, TextAnchor as _, CONNECTOR_PRESETS as a, ZIP_OUTPUT_TYPE as b, OutputType as c, SCHEME_COLORS as d, SHAPE_NAME as f, TableStyle as g, SlideObjectType as h, CHART_NAME as i, PLACEHOLDER_TYPE as l, ShapeType as m, AlignV as n, CONNECTOR_PRESET_NAME as o, SchemeColor as p, BulletType as r, ChartType as s, AlignH as t, PlaceholderType as u, VALID_SHAPE_PRESETS as v, isChartType as w, asChartType as x, WRITE_OUTPUT_TYPE as y };
-//# sourceMappingURL=enums-CvRYniUA.d.ts.map
+export { isChartType as C, isChartExType as S, VALID_SHAPE_PRESETS as _, CONNECTOR_PRESET_NAME as a, asChartType as b, PLACEHOLDER_TYPE as c, SHAPE_NAME as d, SchemeColor as f, TextAnchor as g, TableStyle as h, CHART_NAME as i, PlaceholderType as l, SlideObjectType as m, AlignV as n, ChartType as o, ShapeType as p, BulletType as r, OutputType as s, AlignH as t, SCHEME_COLORS as u, WRITE_OUTPUT_TYPE as v, connectorPresetFor as x, ZIP_OUTPUT_TYPE as y };
+//# sourceMappingURL=enums-BUKTUB6V.d.ts.map

package/dist/{enums-CvRYniUA.d.ts.map → enums-BUKTUB6V.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"enums-CvRYniUA.d.ts","names":[],"sources":["../src/enums.ts"],"mappings":";;;;;;;;;;KAUY,qBAAqB;KACrB,oBAAoB;;;;;;KAMpB,gBAAgB;;;;;KAKhB,mBAAmB;aAEnB;EACX;EACA;EACA;;aAIW;EACX;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;;KAGW,8iGAoLT;;;;;;cAOG;;;;;;;;;KAoBM,gCAAgC;;;;;;;;;cAU/B,qBAAqB;;;;;;;;iBAYlB,YAAY,MAAM,aAAa;;;;;;;;;;iBAgB/B,YAAY,gBAAgB,QAAQ;;;;;;iBA4BpC,cAAc;aAIlB;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;cAQY;WACF;WACH;WACC;;;;;;;;;;;iBAYO,mBAAmB,uCAAuC,gBAAgB;aAI9E;EACX;EACA;EACA;EACA;EACA;EACA;;;;;;KAMW,sBAAsB;;;;;aAMtB;EACX;EACA;EACA;EACA;;;;;;;;;;;;aAaW;EAEX;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;;EAEA;;EAEA;;EAEA"}
+{"version":3,"file":"enums-BUKTUB6V.d.ts","names":[],"sources":["../src/enums.ts"],"mappings":";;;;;;;;;;KAUY,qBAAqB;KACrB,oBAAoB;;;;;;KAMpB,gBAAgB;;;;;KAKhB,mBAAmB;aAEnB;EACX;EACA;EACA;;aAIW;EACX;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;aAEW;EACX;EACA;EACA;EACA;;;;;;;;;aASW;EACX;EACA;EACA;;;;;;;;;;;;;KAcW,gBAAgB,cAAc;;;;;;cAOpC;;;;;;;;;KAoBM,gCAAgC;;;;;;;;;cAU/B,qBAAqB;;;;;;;;iBAYlB,YAAY,MAAM,aAAa;;;;;;;;;;iBAgB/B,YAAY,gBAAgB,QAAQ;;;;;;iBA4BpC,cAAc;aAIlB;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;iBA4Be,mBAAmB,uCAAuC,gBAAgB;aAI9E;EACX;EACA;EACA;EACA;EACA;EACA;;;;;;KAMW,sBAAsB;;;;;aAMtB;EACX;EACA;EACA;EACA;;;;;;;;;;;;aAaW;EAEX;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;EACA;EACA;EACA;EACA;EACA;EACA;EAGA;;EAEA;;EAEA;;EAEA"}

package/dist/{errors-Bvln0H-7.js → errors-C4oENPcu.js}

@@ -1,3 +1,93 @@
+//#region src/diagnostics.ts
+/** Prefix stamped on every warning so consumers can attribute console noise to this library. */
+const WARN_PREFIX = "ts-pptx";
+/** The default handler: one `console.warn` line per diagnostic, prefixed. */
+const consoleHandler = (diagnostic) => {
+	console.warn(`${WARN_PREFIX}: ${diagnostic.message}`);
+};
+let handler = consoleHandler;
+/**
+* Route every library diagnostic to `handler`, or pass `null` to restore the default
+* (one prefixed `console.warn` per diagnostic).
+*
+* This is process-global rather than per-presentation, deliberately: the emitting code is a tree
+* of free functions in `gen/**` with no presentation in scope, and threading a handler through
+* every signature would be a far larger and worse change than the problem warrants. The practical
+* consequence is that a process building several decks concurrently cannot attribute a diagnostic
+* to one of them. If that matters, correlate on `code`, or build the decks one at a time with the
+* handler set around each build: a handler set around concurrent builds sees all of their
+* diagnostics.
+*
+* A throwing handler propagates out of whatever library call emitted the diagnostic, which is the
+* supported way to make a specific condition fatal:
+*
+* ```ts
+* setDiagnosticHandler((d) => {
+*   if (d.code === 'coord/bare-number-is-inches') throw new Error(d.message)
+* })
+* ```
+* @param next - the receiver, or `null` to restore the console default
+*/
+function setDiagnosticHandler(next) {
+	handler = next ?? consoleHandler;
+}
+/**
+* Emit a library diagnostic.
+* @param code - the stable condition identifier ({@link DiagnosticCode})
+* @param message - explanation, without a `ts-pptx:` prefix (the default handler adds one)
+* @param detail - optional structured context
+*/
+function warn(code, message, detail) {
+	handler(detail === void 0 ? {
+		code,
+		message
+	} : {
+		code,
+		message,
+		detail
+	});
+}
+const seen = /* @__PURE__ */ new Set();
+/**
+* Emit a library diagnostic at most once per distinct code+message.
+*
+* "Once" is **process-global**, the same scope {@link setDiagnosticHandler} has and for the
+* same reason: the emitting code is a tree of free functions in `gen/**` with no presentation
+* in scope. The consequence is different, though, and worth stating on its own — a process that
+* builds several decks does not get a second report of a condition an earlier deck already
+* tripped, so the second deck's diagnostics are incomplete rather than merely unattributed.
+* {@link resetDiagnosticState} is how a host that cares gets each build a clean slate.
+*
+* @param code - the stable condition identifier ({@link DiagnosticCode})
+* @param message - explanation (see {@link warn})
+* @param detail - optional structured context
+*/
+function warnOnce(code, message, detail) {
+	const key = `${code}\0${message}`;
+	if (seen.has(key)) return;
+	seen.add(key);
+	warn(code, message, detail);
+}
+/**
+* Clear the `warnOnce` dedupe set, so a condition already reported reports again. (`warnOnce` is
+* internal and carries no page of its own, so it is named rather than linked.)
+*
+* Call it between builds in a host that builds more than one deck per process and wants each
+* build's diagnostics complete. Without it, deck two is silent about anything deck one already
+* warned for, which reads as "no problems found" rather than as "already mentioned".
+*
+* It also bounds the set. Most `warnOnce` messages interpolate the offending value, so a server
+* building decks from user input accumulates one entry per distinct bad value with no way to
+* release them.
+*
+* This does not touch the handler — {@link setDiagnosticHandler} owns that, and the two are
+* reset independently on purpose: a host usually installs its handler once and wants it to
+* survive.
+*/
+function resetDiagnosticState() {
+	seen.clear();
+}
+//#endregion
 //#region src/errors.ts
 /**
 * Base class for every error ts-pptx throws.
@@ -107,6 +197,6 @@ var InternalError = class extends TsPptxError {
 	}
 };
 //#endregion
-export { TsPptxError as a, PackageReadError as i, InvalidOptionError as n, UnsupportedFeatureError as o, MediaError as r, InternalError as t };
+export { TsPptxError as a, setDiagnosticHandler as c, PackageReadError as i, warn as l, InvalidOptionError as n, UnsupportedFeatureError as o, MediaError as r, resetDiagnosticState as s, InternalError as t, warnOnce as u };
 
-//# sourceMappingURL=errors-Bvln0H-7.js.map
+//# sourceMappingURL=errors-C4oENPcu.js.map

package/dist/errors-C4oENPcu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-C4oENPcu.js","names":[],"sources":["../src/diagnostics.ts","../src/errors.ts"],"sourcesContent":["/**\n * Central sink for library diagnostics.\n *\n * Every user-facing warning is routed through {@link warn} / {@link warnOnce} rather than calling\n * `console.warn` directly, so there is one place to apply a consistent prefix and one place a\n * consumer can take over — see {@link setDiagnosticHandler}. This module has no *runtime* imports\n * so it can be used from anywhere without risking an import cycle; `codes.ts` is types only and is\n * erased at compile time, so it does not cost that property.\n *\n * **A diagnostic's `code` is API; its `message` is not.** The code is a stable identifier a\n * consumer may branch on (`if (d.code === 'chart/non-finite-value')`); the wording behind it is\n * free to improve in any release. The vocabulary lives in `codes.ts` and is shared with the thrown\n * surface (`errors.ts`), so a condition that can both warn and throw reads the same either way.\n */\n\nimport type { DiagnosticCode } from './codes.js'\n\nexport type { DiagnosticCode }\n\n/** One diagnostic emitted by the library. */\nexport interface Diagnostic {\n\t/** Stable condition identifier — see {@link DiagnosticCode}. Branch on this, not on the text. */\n\treadonly code: DiagnosticCode\n\t/** Human-readable explanation. Free to change in any release; do not parse it. */\n\treadonly message: string\n\t/**\n\t * Structured context for the condition, when a site has any to give.\n\t *\n\t * Every rejection of an `ST_` enum value populates it: `checkEnumOrWarn` (`ooxml/check-enum.ts`)\n\t * carries `received` — the value the caller passed — and `valid`, the whole legal list, plus\n\t * whatever the call site adds. That reaches a handler for a line dash type, a table cell's 3-D\n\t * preset and a table's horizontal overflow, among others. Nothing else populates it yet, so a\n\t * handler must still treat the field as optional and must not assume a particular key is there\n\t * for a given code.\n\t */\n\treadonly detail?: Readonly<Record<string, unknown>>\n}\n\n/** Receives every {@link Diagnostic} the library emits. See {@link setDiagnosticHandler}. */\nexport type DiagnosticHandler = (diagnostic: Diagnostic) => void\n\n/** Prefix stamped on every warning so consumers can attribute console noise to this library. */\nconst WARN_PREFIX = 'ts-pptx'\n\n/** The default handler: one `console.warn` line per diagnostic, prefixed. */\nconst consoleHandler: DiagnosticHandler = (diagnostic) => {\n\tconsole.warn(`${WARN_PREFIX}: ${diagnostic.message}`)\n}\n\nlet handler: DiagnosticHandler = consoleHandler\n\n/**\n * Route every library diagnostic to `handler`, or pass `null` to restore the default\n * (one prefixed `console.warn` per diagnostic).\n *\n * This is process-global rather than per-presentation, deliberately: the emitting code is a tree\n * of free functions in `gen/**` with no presentation in scope, and threading a handler through\n * every signature would be a far larger and worse change than the problem warrants. The practical\n * consequence is that a process building several decks concurrently cannot attribute a diagnostic\n * to one of them. If that matters, correlate on `code`, or build the decks one at a time with the\n * handler set around each build: a handler set around concurrent builds sees all of their\n * diagnostics.\n *\n * A throwing handler propagates out of whatever library call emitted the diagnostic, which is the\n * supported way to make a specific condition fatal:\n *\n * ```ts\n * setDiagnosticHandler((d) => {\n *   if (d.code === 'coord/bare-number-is-inches') throw new Error(d.message)\n * })\n * ```\n * @param next - the receiver, or `null` to restore the console default\n */\nexport function setDiagnosticHandler(next: DiagnosticHandler | null): void {\n\thandler = next ?? consoleHandler\n}\n\n/**\n * Emit a library diagnostic.\n * @param code - the stable condition identifier ({@link DiagnosticCode})\n * @param message - explanation, without a `ts-pptx:` prefix (the default handler adds one)\n * @param detail - optional structured context\n */\nexport function warn(code: DiagnosticCode, message: string, detail?: Readonly<Record<string, unknown>>): void {\n\thandler(detail === undefined ? { code, message } : { code, message, detail })\n}\n\n// Track diagnostics already emitted so a recurring condition (e.g. the same out-of-range fontSize\n// on every cell of a table) is reported once instead of flooding the handler. Keyed on code AND\n// message, so a *different* offending value under the same code still reports.\nconst seen = new Set<string>()\n\n/**\n * Emit a library diagnostic at most once per distinct code+message.\n *\n * \"Once\" is **process-global**, the same scope {@link setDiagnosticHandler} has and for the\n * same reason: the emitting code is a tree of free functions in `gen/**` with no presentation\n * in scope. The consequence is different, though, and worth stating on its own — a process that\n * builds several decks does not get a second report of a condition an earlier deck already\n * tripped, so the second deck's diagnostics are incomplete rather than merely unattributed.\n * {@link resetDiagnosticState} is how a host that cares gets each build a clean slate.\n *\n * @param code - the stable condition identifier ({@link DiagnosticCode})\n * @param message - explanation (see {@link warn})\n * @param detail - optional structured context\n */\nexport function warnOnce(code: DiagnosticCode, message: string, detail?: Readonly<Record<string, unknown>>): void {\n\tconst key = `${code}\\0${message}`\n\tif (seen.has(key)) return\n\tseen.add(key)\n\twarn(code, message, detail)\n}\n\n/**\n * Clear the `warnOnce` dedupe set, so a condition already reported reports again. (`warnOnce` is\n * internal and carries no page of its own, so it is named rather than linked.)\n *\n * Call it between builds in a host that builds more than one deck per process and wants each\n * build's diagnostics complete. Without it, deck two is silent about anything deck one already\n * warned for, which reads as \"no problems found\" rather than as \"already mentioned\".\n *\n * It also bounds the set. Most `warnOnce` messages interpolate the offending value, so a server\n * building decks from user input accumulates one entry per distinct bad value with no way to\n * release them.\n *\n * This does not touch the handler — {@link setDiagnosticHandler} owns that, and the two are\n * reset independently on purpose: a host usually installs its handler once and wants it to\n * survive.\n */\nexport function resetDiagnosticState(): void {\n\tseen.clear()\n}\n","/**\n * The library's error taxonomy.\n *\n * Every failure ts-pptx raises is a {@link TsPptxError} carrying a stable {@link ErrorCode}, so a\n * consumer can tell *\"you passed a bad coordinate\"* from *\"this font file is corrupt\"* from\n * *\"these bytes are not a package\"* without matching on message substrings. The classes are a\n * deliberately flat, coarse bucket — five of them — and the code carries the specificity. Do not\n * add a class per throw site; add a code.\n *\n * **The class and the code are API. The message is not.** Branch on `instanceof` and on `code`;\n * the wording behind them is free to improve in any release. Every error remains an\n * `instanceof Error`, so existing `catch` blocks keep working.\n *\n * Which class to reach for:\n *\n * | class | the failure is | who fixes it |\n * |---|---|---|\n * | {@link InvalidOptionError} | the caller passed something unusable | the caller's code |\n * | {@link UnsupportedFeatureError} | a well-formed request this build/runtime/shape cannot express | the caller's expectations, or the environment |\n * | {@link PackageReadError} | the input bytes are not a readable package | the input file |\n * | {@link MediaError} | a referenced image/font/AV resource would not load or decode | the resource |\n * | {@link InternalError} | an invariant of the library itself did not hold | ts-pptx (file a bug) |\n *\n * **Which of these is worth reporting upstream.** `InternalError` always is, and says so at\n * runtime. The middle three are worth reporting when the environment disagrees with us:\n * a `PackageReadError` on a file that opens cleanly in PowerPoint, a `MediaError` on an asset every\n * other tool loads, an `UnsupportedFeatureError` for something PowerPoint can plainly express.\n * `InvalidOptionError` is worth reporting only if the deck it refused is one PowerPoint can\n * express. See `skills/ts-pptx-upstream` for how to file one.\n *\n * @see `docs/errors-and-warnings.md` for the consumer-facing contract.\n * @see `codes.ts` for the code vocabulary, which is shared with the diagnostic (warning) surface.\n */\n\nimport type {\n\tErrorCode,\n\tInternalErrorCode,\n\tInvalidOptionErrorCode,\n\tMediaErrorCode,\n\tPackageReadErrorCode,\n\tUnsupportedFeatureErrorCode,\n} from './codes.js'\n\n/** Extra context accepted by every {@link TsPptxError} constructor. */\nexport interface TsPptxErrorOptions extends ErrorOptions {\n\t/**\n\t * Structured context for the condition, when a site has any to give. Mirrors `Diagnostic.detail`\n\t * so the same condition looks the same whether it was warned or thrown.\n\t */\n\treadonly detail?: Readonly<Record<string, unknown>>\n}\n\n/**\n * Base class for every error ts-pptx throws.\n *\n * Catch this to catch anything from the library; narrow with `instanceof` on a subclass, or branch\n * on {@link TsPptxError.code}, to react to something specific. It is never thrown directly — every\n * site picks one of the five subclasses.\n */\nexport class TsPptxError extends Error {\n\t/** Stable condition identifier — see {@link ErrorCode}. Branch on this, not on the text. */\n\treadonly code: ErrorCode\n\n\t/** Structured context for the condition, when the throwing site had any to give. */\n\treadonly detail?: Readonly<Record<string, unknown>>\n\n\t/**\n\t * @param code - the stable condition identifier\n\t * @param message - explanation for a human reading a stack trace; not part of the contract\n\t * @param options - standard `cause`, plus optional structured `detail`\n\t */\n\tconstructor(code: ErrorCode, message: string, options?: TsPptxErrorOptions) {\n\t\tsuper(message, options)\n\t\t// `name` drives how a stack trace and `console.log` label the error, and the default from\n\t\t// `Error` would say \"Error\" for every subclass. Derive it from the constructor so a subclass\n\t\t// never has to remember to set it.\n\t\tthis.name = new.target.name\n\t\tthis.code = code\n\t\tif (options?.detail !== undefined) this.detail = options.detail\n\t}\n}\n\n/**\n * The caller passed something the library cannot use — a non-finite coordinate, an unknown enum\n * value, a required option left out, a value outside its legal range.\n *\n * This is the error behind the project's throw-rather-than-coerce policy: emitting a degenerate\n * result (a zero-size shape, a silently dropped option) hides the mistake, so the library refuses\n * instead. Reaching one means the calling code needs to change.\n */\nexport class InvalidOptionError extends TsPptxError {\n\tdeclare readonly code: InvalidOptionErrorCode\n\tconstructor(code: InvalidOptionErrorCode, message: string, options?: TsPptxErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * The request is well-formed but cannot be expressed here: an optional peer dependency is not\n * installed, the runtime lacks a capability, or the shape/feature has no OOXML representation the\n * library emits.\n *\n * Distinct from {@link InvalidOptionError} because the caller did nothing wrong — the answer is\n * \"not here\", not \"not like that\" — and the fix is usually to install something or pick a different\n * approach rather than to correct a value.\n */\nexport class UnsupportedFeatureError extends TsPptxError {\n\tdeclare readonly code: UnsupportedFeatureErrorCode\n\tconstructor(code: UnsupportedFeatureErrorCode, message: string, options?: TsPptxErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * The bytes handed to the library are not a package it can read, or a part inside one is\n * structurally malformed — a missing `[Content_Types].xml`, a relationship pointing at nothing, a\n * slide part with no root element.\n *\n * Always about *input*. A problem with something the library is being asked to produce is an\n * {@link InvalidOptionError}.\n */\nexport class PackageReadError extends TsPptxError {\n\tdeclare readonly code: PackageReadErrorCode\n\tconstructor(code: PackageReadErrorCode, message: string, options?: TsPptxErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * A referenced image, font, or audio/video resource could not be fetched, read, or decoded.\n *\n * Kept apart from {@link PackageReadError} because the failure is in a resource the deck *points\n * at*, not in the package structure — a broken URL, an unreadable path, a corrupt font file — and\n * a consumer typically retries or substitutes rather than rejecting the deck.\n */\nexport class MediaError extends TsPptxError {\n\tdeclare readonly code: MediaErrorCode\n\tconstructor(code: MediaErrorCode, message: string, options?: TsPptxErrorOptions) {\n\t\tsuper(code, message, options)\n\t}\n}\n\n/**\n * Where a report of an `InternalError` should go. Appended to the message rather than left to the\n * docs, because a stack trace is the only artefact of the failure that reaches whoever (or\n * whatever) is debugging it — a pointer anywhere else is a pointer they have to already be looking\n * for. Most code that calls this library is written by an agent in a repository that is not this\n * one, and an agent that hits a library defect routes around it silently unless something in front\n * of it says the report is worth making.\n */\nconst REPORT_NOTICE =\n\t'This is a bug in ts-pptx, not in your deck or your code. Please report it:\\n' +\n\t'https://github.com/shbernal/ts-pptx/issues/new?template=agent-report.yml'\n\n/**\n * An invariant the library maintains itself did not hold.\n *\n * No consumer input should be able to produce one, which is the whole reason it is a separate\n * class: seeing it means the bug is in ts-pptx, and the useful response is to file it rather than\n * to keep adjusting the input.\n *\n * It is the one class in the taxonomy that extends its own message, appending `REPORT_NOTICE`\n * below the invariant that broke. The constructor is where that lives so a throw site added later\n * inherits it — the alternative, a notice pasted at each of the sites, is one every future site can\n * forget. Every other class leaves `message` exactly as given: a malformed package is the routine\n * outcome for a library that reads untrusted files, and a \"report this\" banner on each corrupt\n * input would train callers to ignore the one banner that always means something.\n *\n * This does not make the message API — see the class doc on {@link TsPptxError}. Branch on\n * `instanceof` or on {@link InternalError.code}, never on the text.\n */\nexport class InternalError extends TsPptxError {\n\tdeclare readonly code: InternalErrorCode\n\tconstructor(code: InternalErrorCode, message: string, options?: TsPptxErrorOptions) {\n\t\tsuper(code, `${message}\\n\\n${REPORT_NOTICE}`, options)\n\t}\n}\n"],"mappings":";;AA0CA,MAAM,cAAc;;AAGpB,MAAM,kBAAqC,eAAe;CACzD,QAAQ,KAAK,GAAG,YAAY,IAAI,WAAW,SAAS;AACrD;AAEA,IAAI,UAA6B;;;;;;;;;;;;;;;;;;;;;;;AAwBjC,SAAgB,qBAAqB,MAAsC;CAC1E,UAAU,QAAQ;AACnB;;;;;;;AAQA,SAAgB,KAAK,MAAsB,SAAiB,QAAkD;CAC7G,QAAQ,WAAW,KAAA,IAAY;EAAE;EAAM;CAAQ,IAAI;EAAE;EAAM;EAAS;CAAO,CAAC;AAC7E;AAKA,MAAM,uBAAO,IAAI,IAAY;;;;;;;;;;;;;;;AAgB7B,SAAgB,SAAS,MAAsB,SAAiB,QAAkD;CACjH,MAAM,MAAM,GAAG,KAAK,IAAI;CACxB,IAAI,KAAK,IAAI,GAAG,GAAG;CACnB,KAAK,IAAI,GAAG;CACZ,KAAK,MAAM,SAAS,MAAM;AAC3B;;;;;;;;;;;;;;;;;AAkBA,SAAgB,uBAA6B;CAC5C,KAAK,MAAM;AACZ;;;;;;;;;;ACxEA,IAAa,cAAb,cAAiC,MAAM;;CAEtC;;CAGA;;;;;;CAOA,YAAY,MAAiB,SAAiB,SAA8B;EAC3E,MAAM,SAAS,OAAO;EAItB,KAAK,OAAO,WAAW;EACvB,KAAK,OAAO;EACZ,IAAI,SAAS,WAAW,KAAA,GAAW,KAAK,SAAS,QAAQ;CAC1D;AACD;;;;;;;;;AAUA,IAAa,qBAAb,cAAwC,YAAY;CAEnD,YAAY,MAA8B,SAAiB,SAA8B;EACxF,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;;;AAWA,IAAa,0BAAb,cAA6C,YAAY;CAExD,YAAY,MAAmC,SAAiB,SAA8B;EAC7F,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;;AAUA,IAAa,mBAAb,cAAsC,YAAY;CAEjD,YAAY,MAA4B,SAAiB,SAA8B;EACtF,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;AASA,IAAa,aAAb,cAAgC,YAAY;CAE3C,YAAY,MAAsB,SAAiB,SAA8B;EAChF,MAAM,MAAM,SAAS,OAAO;CAC7B;AACD;;;;;;;;;AAUA,MAAM,gBACL;;;;;;;;;;;;;;;;;;AAoBD,IAAa,gBAAb,cAAmC,YAAY;CAE9C,YAAY,MAAyB,SAAiB,SAA8B;EACnF,MAAM,MAAM,GAAG,QAAQ,MAAM,iBAAiB,OAAO;CACtD;AACD"}

package/dist/families.d.ts

@@ -0,0 +1,260 @@
+import { d as SHAPE_NAME, i as CHART_NAME } from "./enums-BUKTUB6V.js";
+import { Bt as TextMeasurement, Dt as CommentProps, Ft as TableLayoutResult, Ht as TextPropsOptions, Kt as ImageProps, Ot as MeasureTextOptions, P as ConnectorProps, Q as ChartOpts, Vt as TextProps, Yt as OleObjectProps, Z as ChartMulti, jt as OverflowBoxOptions, kt as NotesProps, nn as ShapeProps, qt as MediaProps, xt as OptsChartData } from "./pres-C6qgOFAa.js";
+import { L as TableToSlidesProps, M as TableProps, N as TableRow, S as AnimationProps, c as SectionZoomProps, d as ZoomBaseProps, l as SlideZoomProps, m as Model3dProps, n as GroupChildProps, r as GroupProps, v as SlideMasterChartProps } from "./slide-Dx2ZeVZ6.js";
+import { T as PresSlideInternal } from "./font-metrics-v5fn7s7e.js";
+import { a as renderImageObject, c as ConstructFamily, d as PartContributor, f as RenderContext, l as PresentationAuthorContext, o as renderTextObject, u as SlideBuilder } from "./entry-compose-DCnvBZz2.js";
+import { s as ExtractedSlide } from "./presentation-types-8jLQHI4M.js";
+//#region src/gen/slide/objects/chart.d.ts
+/**
+ * Render a `chart` slide object to its `<p:graphicFrame>` XML referencing the chart part.
+ *
+ * Classic charts emit a bare `<p:graphicFrame>` pointing at a `<c:chart>`. chartEx charts
+ * (waterfall, …) instead wrap that graphicFrame in `<mc:AlternateContent>`: an `<mc:Choice>`
+ * carrying the `<cx:chart>` reference (rendered by PowerPoint 2016+/Microsoft 365) and an
+ * `<mc:Fallback>` placeholder shape shown by every other consumer.
+ */
+declare function renderChartObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/extract-charts.d.ts
+/**
+ * Charts: the chart part XML plus its embedded workbook bytes. The chart part's own `.rels`
+ * (workbook reference) is rebuilt on injection.
+ *
+ * chartEx charts are a different part behind a different rel type and content type, and
+ * PowerPoint reports one as corrupt without its style/colors sidecars (see
+ * gen/chart/chartex-style.ts). Both ride in the descriptor's `chartEx` slot, which is what tells
+ * `appendSlides` the two shapes apart: it cannot be inferred from the XML. `chartPartBodies` makes
+ * the classic-or-chartEx choice for the package writer too.
+ */
+declare function chartsOf(slide: PresSlideInternal): ExtractedSlide['charts'];
+//#endregion
+//#region src/gen/slide/objects/table.d.ts
+/**
+ * Render a `table` slide object to its `<p:graphicFrame>` XML (merge-grid, row/col spans, per-cell styling).
+ */
+declare function renderTableObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/slide/objects/media.d.ts
+/**
+ * Render a `media` (audio/video/online) slide object to its `<p:pic>` XML.
+ */
+declare function renderMediaObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/slide/objects/connector.d.ts
+/**
+ * Render a `connector` slide object to its `<p:cxnSp>` XML (start/end shape bindings via shapeIds).
+ */
+declare function renderConnectorObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/slide/objects/ole.d.ts
+/**
+ * Render an `oleObject` slide object to its `<p:graphicFrame>` XML.
+ *
+ * Mirrors what PowerPoint authors for Insert ▸ Object: a graphicFrame in the `.../ole` graphicData
+ * namespace holding an `<mc:AlternateContent>`. The `mc:Choice` carries the bare `<p:oleObj>` (which
+ * PowerPoint renders by drawing the live embedded document); the `mc:Fallback` repeats it with a
+ * `<p:pic>` preview so every other consumer shows the cached picture.
+ *
+ * Note `mc:Choice Requires="v"` only *declares* the VML namespace — modern PowerPoint writes no
+ * `spid` and no `vmlDrawing` part, so neither is emitted here.
+ */
+declare function renderOleObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/slide/objects/model3d.d.ts
+/**
+ * Render a `model3d` slide object to its `<mc:AlternateContent>` XML. The `mc:Choice` carries the
+ * real `<p:graphicFrame>` (the `am3d:model3d` graphicData PowerPoint 2019+ renders live); the
+ * `mc:Fallback` carries the cached preview picture. See `gen/define/model3d.ts`.
+ */
+declare function renderModel3dObject(ctx: RenderContext): string;
+//#endregion
+//#region src/gen/slide/objects/zoom.d.ts
+/**
+ * Render a `zoom` slide object to its `<mc:AlternateContent>` XML. The `mc:Choice` carries the real
+ * `<p:graphicFrame>` (Slide/Section/Summary Zoom in the 2016 zoom namespaces, read by PowerPoint
+ * 2016+); the `mc:Fallback` carries a hyperlinked picture — or, for a Summary Zoom, a group of them —
+ * so pre-2016 consumers still get a clickable navigation thumbnail. See `gen/define/zoom.ts`.
+ */
+declare function renderZoomObject(ctx: RenderContext): string;
+//#endregion
+//#region src/families.d.ts
+/** Text boxes. Core: composed whether you ask for it or not. */
+export declare const text: {
+  name: "text";
+  authors: {
+    addText(slide: SlideBuilder, text: string | number | TextProps[], options: TextPropsOptions | undefined): void;
+  };
+  children: {
+    text(target: PresSlideInternal, child: {
+      text: string | number | TextProps[];
+      options?: TextPropsOptions;
+    }): void;
+  };
+  renderers: {
+    placeholder: typeof renderTextObject;
+    text: typeof renderTextObject;
+  };
+};
+/** Preset shapes (`addShape`), and the `rect`/`line`/`roundRect` descriptors. Core. */
+export declare const shapes: {
+  name: "shape";
+  authors: {
+    addShape(slide: SlideBuilder, shapeName: SHAPE_NAME, options: ShapeProps | undefined): void;
+  };
+  children: {
+    line(target: PresSlideInternal, child: ShapeProps): void;
+    rect(target: PresSlideInternal, child: ShapeProps): void;
+    roundRect(target: PresSlideInternal, child: ShapeProps): void;
+    shape(target: PresSlideInternal, child: {
+      type: SHAPE_NAME;
+      options?: ShapeProps;
+    }): void;
+  };
+};
+/** Raster and SVG pictures. Core. */
+export declare const images: {
+  name: "image";
+  authors: {
+    addImage(slide: SlideBuilder, options: ImageProps): void;
+  };
+  children: {
+    image(target: PresSlideInternal, child: ImageProps): void;
+  };
+  renderers: {
+    image: typeof renderImageObject;
+  };
+};
+/** Groups, from descriptors (`addGroup`) or from objects already on the slide (`groupObjects`). Core. */
+export declare const groups: {
+  name: "group";
+  authors: {
+    addGroup(slide: SlideBuilder, children: GroupChildProps[], options: GroupProps | undefined): void;
+    groupObjects(slide: SlideBuilder, objectNames: string[], options: GroupProps | undefined): void;
+  };
+};
+/** Speaker notes, and the notes slides they are written to. Core. */
+export declare const notes: {
+  name: "notes";
+  authors: {
+    addNotes(slide: SlideBuilder, notes: string | NotesProps[] | NotesProps): void;
+  };
+  parts: PartContributor;
+};
+/** Charts of every type, their embedded workbooks, and the chartEx sidecars. The expensive one. */
+export declare const charts: {
+  name: "chart";
+  authors: {
+    addChart(slide: SlideBuilder, arg1: ChartMulti[] | OptsChartData[], arg2: (ChartOpts & {
+      type?: CHART_NAME;
+    }) | undefined): void;
+  };
+  children: {
+    chart(target: PresSlideInternal, child: SlideMasterChartProps): void;
+  };
+  renderers: {
+    chart: typeof renderChartObject;
+  };
+  parts: PartContributor;
+  extract: {
+    charts: typeof chartsOf;
+  };
+};
+/** Tables, including auto-paging onto continuation slides. */
+export declare const tables: {
+  name: "table";
+  authors: {
+    addTable(slide: SlideBuilder, tableRows: TableRow[], options: TableProps | undefined): void;
+  };
+  renderers: {
+    table: typeof renderTableObject;
+  };
+};
+/**
+ * `tableToSlides`: reproducing a rendered HTML `<table>`. Needs a live DOM, so it belongs to a
+ * program that has one; the same conversion is a free function on `pptx-ts/html`.
+ */
+export declare const domTables: {
+  name: "table";
+  presentationAuthors: {
+    tableToSlides(ctx: PresentationAuthorContext, eleId: string, options: TableToSlidesProps): void;
+  };
+};
+/** Embedded and online audio/video. */
+export declare const media: {
+  name: "media";
+  authors: {
+    addMedia(slide: SlideBuilder, options: MediaProps): void;
+  };
+  renderers: {
+    media: typeof renderMediaObject;
+  };
+};
+/** Connectors: lines drawn between two points. */
+export declare const connectors: {
+  name: "connector";
+  authors: {
+    addConnector(slide: SlideBuilder, options: ConnectorProps): void;
+  };
+  renderers: {
+    connector: typeof renderConnectorObject;
+  };
+};
+/** Embedded OLE objects, whose payload travels inside the `.pptx`. */
+export declare const oleObjects: {
+  name: "ole";
+  authors: {
+    addOleObject(slide: SlideBuilder, options: OleObjectProps): void;
+  };
+  renderers: {
+    oleObject: typeof renderOleObject;
+  };
+};
+/** Embedded 3D models (`.glb`) with their preview picture. */
+export declare const models3d: {
+  name: "model3d";
+  authors: {
+    addModel3d(slide: SlideBuilder, options: Model3dProps): void;
+  };
+  renderers: {
+    model3d: typeof renderModel3dObject;
+  };
+};
+/** Slide, Section and Summary Zoom tiles. */
+export declare const zooms: {
+  name: "zoom";
+  authors: {
+    addSlideZoom(slide: SlideBuilder, options: SlideZoomProps): void;
+    addSectionZoom(slide: SlideBuilder, options: SectionZoomProps): void;
+    addSummaryZoom(slide: SlideBuilder, options: ZoomBaseProps): void;
+  };
+  renderers: {
+    zoom: typeof renderZoomObject;
+  };
+};
+/** Review comments and the deck-wide author list. */
+export declare const comments: {
+  name: "comments";
+  authors: {
+    addComment(slide: SlideBuilder, options: CommentProps): void;
+  };
+  parts: PartContributor;
+};
+/** Preset build animations. */
+export declare const animations: {
+  name: "animations";
+  authors: {
+    addAnimation(slide: SlideBuilder, options: AnimationProps): void;
+  };
+};
+/** `measureText`, `overflowsBox` and `tableLayout` on the presentation. */
+export declare const measure: {
+  name: "measure";
+  presentationAuthors: {
+    measureText(ctx: PresentationAuthorContext, text: string | TextProps[], opts: MeasureTextOptions): TextMeasurement;
+    overflowsBox(ctx: PresentationAuthorContext, text: string | TextProps[], opts: OverflowBoxOptions): boolean;
+    tableLayout(ctx: PresentationAuthorContext, rows: TableRow[], opts: TableProps): TableLayoutResult;
+  };
+};
+//#endregion
+export type { ConstructFamily };
+//# sourceMappingURL=families.d.ts.map

package/dist/families.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"families.d.ts","names":[],"sources":["../src/gen/slide/objects/chart.ts","../src/gen/extract-charts.ts","../src/gen/slide/objects/table.ts","../src/gen/slide/objects/media.ts","../src/gen/slide/objects/connector.ts","../src/gen/slide/objects/ole.ts","../src/gen/slide/objects/model3d.ts","../src/gen/slide/objects/zoom.ts","../src/families.ts"],"mappings":";;;;;;;;;;;;;;;iBAwDgB,kBAAkB,KAAK;;;;;;;;;;;;;iBClCvB,SAAS,OAAO,oBAAoB;;;;;;iBC4LpC,kBAAkB,KAAK;;;;;;iBC/LvB,kBAAkB,KAAK;;;;;;iBCHvB,sBAAsB,KAAK;;;;;;;;;;;;;;iBCU3B,gBAAgB,KAAK;;;;;;;;iBCyHrB,oBAAoB,KAAK;;;;;;;;;iBCtBzB,iBAAiB,KAAK;;;;qBCzFzB;;;mBAAA;;;;;;;;;;;;;;qBAEA;;;oBAAA;;;;;;;;;;;;;qBAEA;;;oBAAA;;;;;;;;;;qBAEA;;;oBAAA;;;;;qBAEA;;;oBAAA;;;;;qBAGA;;;oBAAA;;;;;;;;;;;;;;;;qBAEA;;;oBAAA;;;;;;;;;;qBAKA;;;uBAAA,mDAAA;;;;qBAEA;;;oBAAA;;;;;;;qBAEA;;;wBAAA;;;;;;;qBAEA;;;wBAAA;;;;;;;qBAEA;;;sBAAA;;;;;;;qBAEA;;;wBAAA;;;;;;;;;qBAEA;;;sBAAA;;;;;qBAEA;;;wBAAA,uBAAA;;;;qBAEA;;;qBAAA"}

package/dist/families.js

@@ -0,0 +1,57 @@
+import { a as mediaFamily, c as commentsFamily, d as textFamily, f as shapeFamily, h as groupFamily, i as model3dFamily, l as chartFamily, m as imageFamily, n as tableFamily, o as measureFamily, p as notesFamily, r as oleFamily, s as connectorFamily, t as zoomFamily, u as animationsFamily } from "./zoom-DPUHh85d.js";
+import { t as tableDomFamily } from "./table-dom-BTDP3lEP.js";
+//#region src/families.ts
+/**
+* The construct families, as the `pptx-ts/families` subpath publishes them.
+*
+* What a caller hands to `createPresentation({ use: [...] })`. Each value is one family: the
+* methods it adds to a slide, the child descriptors it recognises in a slide master or a group,
+* the renderer that emits its XML, and the parts it puts in the package.
+*
+* Naming one here is what puts its code in your bundle, which is the whole point: a program that
+* composes `charts` pays for charts, and a program that does not, does not.
+*
+* The core tier -- text, shapes, images, groups and speaker notes -- is composed for you. Those
+* five are exported anyway, so a caller can be explicit; listing one changes nothing.
+*
+* @module
+*/
+/** Text boxes. Core: composed whether you ask for it or not. */
+const text = textFamily;
+/** Preset shapes (`addShape`), and the `rect`/`line`/`roundRect` descriptors. Core. */
+const shapes = shapeFamily;
+/** Raster and SVG pictures. Core. */
+const images = imageFamily;
+/** Groups, from descriptors (`addGroup`) or from objects already on the slide (`groupObjects`). Core. */
+const groups = groupFamily;
+/** Speaker notes, and the notes slides they are written to. Core. */
+const notes = notesFamily;
+/** Charts of every type, their embedded workbooks, and the chartEx sidecars. The expensive one. */
+const charts = chartFamily;
+/** Tables, including auto-paging onto continuation slides. */
+const tables = tableFamily;
+/**
+* `tableToSlides`: reproducing a rendered HTML `<table>`. Needs a live DOM, so it belongs to a
+* program that has one; the same conversion is a free function on `pptx-ts/html`.
+*/
+const domTables = tableDomFamily;
+/** Embedded and online audio/video. */
+const media = mediaFamily;
+/** Connectors: lines drawn between two points. */
+const connectors = connectorFamily;
+/** Embedded OLE objects, whose payload travels inside the `.pptx`. */
+const oleObjects = oleFamily;
+/** Embedded 3D models (`.glb`) with their preview picture. */
+const models3d = model3dFamily;
+/** Slide, Section and Summary Zoom tiles. */
+const zooms = zoomFamily;
+/** Review comments and the deck-wide author list. */
+const comments = commentsFamily;
+/** Preset build animations. */
+const animations = animationsFamily;
+/** `measureText`, `overflowsBox` and `tableLayout` on the presentation. */
+const measure = measureFamily;
+//#endregion
+export { animations, charts, comments, connectors, domTables, groups, images, measure, media, models3d, notes, oleObjects, shapes, tables, text, zooms };
+
+//# sourceMappingURL=families.js.map

package/dist/families.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"families.js","names":[],"sources":["../src/families.ts"],"sourcesContent":["/**\n * The construct families, as the `pptx-ts/families` subpath publishes them.\n *\n * What a caller hands to `createPresentation({ use: [...] })`. Each value is one family: the\n * methods it adds to a slide, the child descriptors it recognises in a slide master or a group,\n * the renderer that emits its XML, and the parts it puts in the package.\n *\n * Naming one here is what puts its code in your bundle, which is the whole point: a program that\n * composes `charts` pays for charts, and a program that does not, does not.\n *\n * The core tier -- text, shapes, images, groups and speaker notes -- is composed for you. Those\n * five are exported anyway, so a caller can be explicit; listing one changes nothing.\n *\n * @module\n */\n\nimport { animationsFamily } from './families/animations.js'\nimport { chartFamily } from './families/chart.js'\nimport { commentsFamily } from './families/comments.js'\nimport { connectorFamily } from './families/connector.js'\nimport { groupFamily } from './families/group.js'\nimport { imageFamily } from './families/image.js'\nimport { measureFamily } from './families/measure.js'\nimport { mediaFamily } from './families/media.js'\nimport { model3dFamily } from './families/model3d.js'\nimport { notesFamily } from './families/notes.js'\nimport { oleFamily } from './families/ole.js'\nimport { shapeFamily } from './families/shape.js'\nimport { tableDomFamily } from './families/table-dom.js'\nimport { tableFamily } from './families/table.js'\nimport { textFamily } from './families/text.js'\nimport { zoomFamily } from './families/zoom.js'\n\nexport type { ConstructFamily } from './families/shared.js'\n\n/** Text boxes. Core: composed whether you ask for it or not. */\nexport const text = textFamily\n/** Preset shapes (`addShape`), and the `rect`/`line`/`roundRect` descriptors. Core. */\nexport const shapes = shapeFamily\n/** Raster and SVG pictures. Core. */\nexport const images = imageFamily\n/** Groups, from descriptors (`addGroup`) or from objects already on the slide (`groupObjects`). Core. */\nexport const groups = groupFamily\n/** Speaker notes, and the notes slides they are written to. Core. */\nexport const notes = notesFamily\n\n/** Charts of every type, their embedded workbooks, and the chartEx sidecars. The expensive one. */\nexport const charts = chartFamily\n/** Tables, including auto-paging onto continuation slides. */\nexport const tables = tableFamily\n/**\n * `tableToSlides`: reproducing a rendered HTML `<table>`. Needs a live DOM, so it belongs to a\n * program that has one; the same conversion is a free function on `pptx-ts/html`.\n */\nexport const domTables = tableDomFamily\n/** Embedded and online audio/video. */\nexport const media = mediaFamily\n/** Connectors: lines drawn between two points. */\nexport const connectors = connectorFamily\n/** Embedded OLE objects, whose payload travels inside the `.pptx`. */\nexport const oleObjects = oleFamily\n/** Embedded 3D models (`.glb`) with their preview picture. */\nexport const models3d = model3dFamily\n/** Slide, Section and Summary Zoom tiles. */\nexport const zooms = zoomFamily\n/** Review comments and the deck-wide author list. */\nexport const comments = commentsFamily\n/** Preset build animations. */\nexport const animations = animationsFamily\n/** `measureText`, `overflowsBox` and `tableLayout` on the presentation. */\nexport const measure = measureFamily\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoCA,MAAa,OAAO;;AAEpB,MAAa,SAAS;;AAEtB,MAAa,SAAS;;AAEtB,MAAa,SAAS;;AAEtB,MAAa,QAAQ;;AAGrB,MAAa,SAAS;;AAEtB,MAAa,SAAS;;;;;AAKtB,MAAa,YAAY;;AAEzB,MAAa,QAAQ;;AAErB,MAAa,aAAa;;AAE1B,MAAa,aAAa;;AAE1B,MAAa,WAAW;;AAExB,MAAa,QAAQ;;AAErB,MAAa,WAAW;;AAExB,MAAa,aAAa;;AAE1B,MAAa,UAAU"}