pptx-ts 4.1.0 → 4.1.1-next.18.gd1f716c

package/dist/browser.d.ts

@@ -1,9 +1,9 @@
 import { C as isChartType, S as isChartExType, _ as VALID_SHAPE_PRESETS, a as CONNECTOR_PRESET_NAME, b as asChartType, c as PLACEHOLDER_TYPE, d as SHAPE_NAME, f as SchemeColor, g as TextAnchor, h as TableStyle, i as CHART_NAME, l as PlaceholderType, m as SlideObjectType, n as AlignV, o as ChartType, p as ShapeType, r as BulletType, s as OutputType, t as AlignH, u as SCHEME_COLORS, v as WRITE_OUTPUT_TYPE, x as connectorPresetFor, y as ZIP_OUTPUT_TYPE } from "./enums-DQRpVOLh.js";
-import { $ as ChartOpts, $t as ShapeAdjustHandleXY, A as RadialGradientFillProps, At as NotesProps, B as ShadowProps, Bt as TextGlowProps, C as HexColor, Ct as OptsChartGridLine, D as PatternFillProps, Dt as PlaceholderProps, E as Margin, Et as ObjectNameProps, F as ConnectorProps, Ft as TableCellLayout, G as ChartAxisTickMark, Gt as textRuns, H as ShapeLineProps, Ht as TextProps, I as ConnectorType, It as TableLayoutResult, J as ChartExBinning, Jt as MediaProps, K as ChartDataPointStyle, Kt as ImageBaseProps, L as FillOption, Lt as TextBaseProps, M as ThemeColor, Mt as OverflowBoxOptions, N as VAlign, Nt as ResolvedCommentAuthor, O as PatternPreset, Ot as CommentProps, P as BorderProps, Pt as SlideComment, Q as ChartMulti, Qt as ShapeAdjustHandlePolar, R as HyperlinkActionJump, Rt as TextBulletProps, S as HAlign, St as OptsChartData, T as LinearGradientFillProps, Tt as ObjectLockProps, U as StrokeProps, Ut as TextPropsOptions, V as ShapeFillProps, Vt as TextMeasurement, W as ChartAreaProps, Wt as textRun, X as ChartExStatistics, Xt as OleObjectProps, Y as ChartExGeography, Yt as MediaType, Z as ChartLineDash, Zt as ShapeAdjustHandle, _ as DataOrPathProps, _n as RadarStyle, _t as ChartPropsFillLine, a as PresentationProps, an as BarDirection, at as ChartPropsChartBoxWhisker, b as GradientFillProps, bt as ChartSeriesOpts, c as WriteFileProps, ct as ChartPropsChartLine, d as ThemeColorScheme, dt as ChartPropsChartRegionMap, en as ShapeAdjustValue, et as ChartPropsAxisCat, f as ThemeProps, fn as LegendPosition, ft as ChartPropsChartStock, g as Coord, gn as PresetMaterialType, gt as ChartPropsDataTable, h as Color, hn as LineDataSymbol, ht as ChartPropsDataLabel, i as PresLayout, in as Bar3DShape, it as ChartPropsChartBar, j as TextVertType, jt as NotesTextOptions, k as PositionProps, kt as MeasureTextOptions, l as WriteOutputMap, ln as DataLabelPosition, lt as ChartPropsChartPie, m as BackgroundProps, mn as LightRigType, mt as ChartPropsChartWaterfall, n as PackagePart, nn as ShapeGuide, nt as ChartPropsAxisVal, o as SectionProps, on as BarGrouping, ot as ChartPropsChartDoughnut, p as BackgroundOption, pn as LightRigDirection, pt as ChartPropsChartSurface, q as ChartErrorBarOptions, qt as ImageProps, r as PartsProps, rn as ShapeProps, rt as ChartPropsBase, s as WriteBaseProps, sn as BevelPresetType, st as ChartPropsChartHistogram, t as CustomPropertyValue, tn as ShapeConnectionSite, tt as ChartPropsAxisSer, u as WriteProps, un as DisplayBlanksAs, ut as ChartPropsChartRadar, v as DataOrPathRequiredProps, vn as RadarStyleAlias, vt as ChartPropsLegend, w as ImageFillProps, wn as TimeUnit, wt as CommonObjectDescriptor, x as GradientStopProps, xt as LineCap, y as GeometryPoint, yt as ChartPropsTitle, z as HyperlinkProps, zt as TextFitShrinkProps } from "./pres-BA9_lJbY.js";
-import { A as TableCellDiagonals, C as AnimationTrigger, D as TransitionType, E as TransitionSoundProps, F as TableToSlidesDocument, I as TableToSlidesElement, L as TableToSlidesProps, M as TableProps, N as TableRow, O as TableCell, P as TableRowSlide, S as AnimationProps, T as TransitionProps, _ as MasterTextStyleProps, a as Slide, b as SlideMasterProps, c as SectionZoomProps, d as ZoomBaseProps, f as Model3dCameraProps, g as MasterTextStyleLevel, h as MasterBulletProps, i as ObjectOptions, j as TableCellProps, k as TableCell3DProps, l as SlideZoomProps, m as Model3dProps, n as GroupChildProps, o as SlideLayout, p as Model3dPoint, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, u as SummaryZoomProps, v as SlideMasterChartProps, w as PresetEffect, x as SlideNumberProps, y as SlideMasterObject } from "./slide-BqPtyKmb.js";
-import { _ as PackageReadErrorCode, a as InternalError, c as PackageReadError, d as UnsupportedFeatureError, f as DiagnosticCode, g as MediaErrorCode, h as InvalidOptionErrorCode, i as setDiagnosticHandler, l as TsPptxError, m as InternalErrorCode, n as DiagnosticHandler, o as InvalidOptionError, p as ErrorCode, r as resetDiagnosticState, s as MediaError, t as Diagnostic, u as TsPptxErrorOptions, v as TsPptxCode, y as UnsupportedFeatureErrorCode } from "./diagnostics-DiMmBU8P.js";
-import { A as pixelsToEmu, C as StandardLayoutName, D as emuToPoints, E as emuToPixels, M as ptToHundredths, O as inchesToEmu, S as StandardLayout, T as emuToInches, _ as HUNDREDTHS_PER_POINT, b as PERCENT_SCALE, c as ConstructFamily, g as FIXED_PCT_PER_PERCENT, h as Emu, i as ComposedSlide, j as pointsToEmu, k as percentToEmu, m as DEFAULT_PX_PER_INCH, n as Composed, p as ANGLE_UNITS_PER_DEGREE, r as ComposedPresentation, s as PresentationCore, t as ComposeOptions, v as MAX_COORDINATE_EMU, w as coordToEmu, x as STANDARD_LAYOUTS, y as MIN_COORDINATE_EMU } from "./entry-compose-6hF9aTmT.js";
-import { a as EMU_PER_INCH, i as clipPath, n as FlatSide, o as EMU_PER_POINT, r as HalfDiscPreset, s as POINTS_PER_INCH, t as ClipShape } from "./clip-DHDlnHUq.js";
+import { $ as ChartOpts, $t as ShapeAdjustHandleXY, A as RadialGradientFillProps, At as NotesProps, B as ShadowProps, Bt as TextGlowProps, C as HexColor, Ct as OptsChartGridLine, D as PatternFillProps, Dt as PlaceholderProps, E as Margin, Et as ObjectNameProps, F as ConnectorProps, Ft as TableCellLayout, G as ChartAxisTickMark, Gt as textRuns, H as ShapeLineProps, Ht as TextProps, I as ConnectorType, It as TableLayoutResult, J as ChartExBinning, Jt as MediaProps, K as ChartDataPointStyle, Kt as ImageBaseProps, L as FillOption, Lt as TextBaseProps, M as ThemeColor, Mt as OverflowBoxOptions, N as VAlign, Nt as ResolvedCommentAuthor, O as PatternPreset, Ot as CommentProps, P as BorderProps, Pt as SlideComment, Q as ChartMulti, Qt as ShapeAdjustHandlePolar, R as HyperlinkActionJump, Rt as TextBulletProps, S as HAlign, St as OptsChartData, T as LinearGradientFillProps, Tt as ObjectLockProps, U as StrokeProps, Ut as TextPropsOptions, V as ShapeFillProps, Vt as TextMeasurement, W as ChartAreaProps, Wt as textRun, X as ChartExStatistics, Xt as OleObjectProps, Y as ChartExGeography, Yt as MediaType, Z as ChartLineDash, Zt as ShapeAdjustHandle, _ as DataOrPathProps, _n as RadarStyle, _t as ChartPropsFillLine, a as PresentationProps, an as BarDirection, at as ChartPropsChartBoxWhisker, b as GradientFillProps, bt as ChartSeriesOpts, c as WriteFileProps, ct as ChartPropsChartLine, d as ThemeColorScheme, dt as ChartPropsChartRegionMap, en as ShapeAdjustValue, et as ChartPropsAxisCat, f as ThemeProps, fn as LegendPosition, ft as ChartPropsChartStock, g as Coord, gn as PresetMaterialType, gt as ChartPropsDataTable, h as Color, hn as LineDataSymbol, ht as ChartPropsDataLabel, i as PresLayout, in as Bar3DShape, it as ChartPropsChartBar, j as TextVertType, jt as NotesTextOptions, k as PositionProps, kt as MeasureTextOptions, l as WriteOutputMap, ln as DataLabelPosition, lt as ChartPropsChartPie, m as BackgroundProps, mn as LightRigType, mt as ChartPropsChartWaterfall, n as PackagePart, nn as ShapeGuide, nt as ChartPropsAxisVal, o as SectionProps, on as BarGrouping, ot as ChartPropsChartDoughnut, p as BackgroundOption, pn as LightRigDirection, pt as ChartPropsChartSurface, q as ChartErrorBarOptions, qt as ImageProps, r as PartsProps, rn as ShapeProps, rt as ChartPropsBase, s as WriteBaseProps, sn as BevelPresetType, st as ChartPropsChartHistogram, t as CustomPropertyValue, tn as ShapeConnectionSite, tt as ChartPropsAxisSer, u as WriteProps, un as DisplayBlanksAs, ut as ChartPropsChartRadar, v as DataOrPathRequiredProps, vn as RadarStyleAlias, vt as ChartPropsLegend, w as ImageFillProps, wn as TimeUnit, wt as CommonObjectDescriptor, x as GradientStopProps, xt as LineCap, y as GeometryPoint, yt as ChartPropsTitle, z as HyperlinkProps, zt as TextFitShrinkProps } from "./pres-C6tEDikt.js";
+import { A as TableCellDiagonals, C as AnimationTrigger, D as TransitionType, E as TransitionSoundProps, F as TableToSlidesDocument, I as TableToSlidesElement, L as TableToSlidesProps, M as TableProps, N as TableRow, O as TableCell, P as TableRowSlide, S as AnimationProps, T as TransitionProps, _ as MasterTextStyleProps, a as Slide, b as SlideMasterProps, c as SectionZoomProps, d as ZoomBaseProps, f as Model3dCameraProps, g as MasterTextStyleLevel, h as MasterBulletProps, i as ObjectOptions, j as TableCellProps, k as TableCell3DProps, l as SlideZoomProps, m as Model3dProps, n as GroupChildProps, o as SlideLayout, p as Model3dPoint, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, u as SummaryZoomProps, v as SlideMasterChartProps, w as PresetEffect, x as SlideNumberProps, y as SlideMasterObject } from "./slide-D1uABOLy.js";
+import { _ as PackageReadErrorCode, a as InternalError, c as PackageReadError, d as UnsupportedFeatureError, f as DiagnosticCode, g as MediaErrorCode, h as InvalidOptionErrorCode, i as setDiagnosticHandler, l as TsPptxError, m as InternalErrorCode, n as DiagnosticHandler, o as InvalidOptionError, p as ErrorCode, r as resetDiagnosticState, s as MediaError, t as Diagnostic, u as TsPptxErrorOptions, v as TsPptxCode, y as UnsupportedFeatureErrorCode } from "./diagnostics-UEnuaGE5.js";
+import { A as pixelsToEmu, C as StandardLayoutName, D as emuToPoints, E as emuToPixels, M as ptToHundredths, O as inchesToEmu, S as StandardLayout, T as emuToInches, _ as HUNDREDTHS_PER_POINT, b as PERCENT_SCALE, c as ConstructFamily, g as FIXED_PCT_PER_PERCENT, h as Emu, i as ComposedSlide, j as pointsToEmu, k as percentToEmu, m as DEFAULT_PX_PER_INCH, n as Composed, p as ANGLE_UNITS_PER_DEGREE, r as ComposedPresentation, s as PresentationCore, t as ComposeOptions, v as MAX_COORDINATE_EMU, w as coordToEmu, x as STANDARD_LAYOUTS, y as MIN_COORDINATE_EMU } from "./entry-compose-BM9vmPPw.js";
+import { a as EMU_PER_INCH, i as clipPath, n as FlatSide, o as EMU_PER_POINT, r as HalfDiscPreset, s as POINTS_PER_INCH, t as ClipShape } from "./clip-BkzLGLTj.js";
 //#region src/browser.d.ts
 /**
  * The browser entry, reached through the `browser` export condition — a bundler resolving the

package/dist/browser.js

@@ -1,6 +1,6 @@
 import { a as TsPptxError, c as setDiagnosticHandler, i as PackageReadError, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, s as resetDiagnosticState, t as InternalError } from "./errors-Da2nXCJm.js";
 import { A as inchesToEmu, C as MIN_COORDINATE_EMU, D as emuToInches, E as coordToEmu, F as EMU_PER_INCH, I as EMU_PER_POINT, L as POINTS_PER_INCH, M as pixelsToEmu, N as pointsToEmu, O as emuToPixels, P as ptToHundredths, S as MAX_COORDINATE_EMU, T as STANDARD_LAYOUTS, _ as isChartType, a as ChartType, b as FIXED_PCT_PER_PERCENT, c as SchemeColor, d as TableStyle, f as TextAnchor, g as isChartExType, h as connectorPresetFor, i as BulletType, j as percentToEmu, k as emuToPoints, l as ShapeType, m as asChartType, n as AlignH, o as OutputType, p as VALID_SHAPE_PRESETS, r as AlignV, s as PlaceholderType, u as SlideObjectType, v as ANGLE_UNITS_PER_DEGREE, w as PERCENT_SCALE, x as HUNDREDTHS_PER_POINT, y as DEFAULT_PX_PER_INCH } from "./table-cell-margins-PDshga8T.js";
-import { c as ALL_CONSTRUCT_FAMILIES, d as IMG_SVG_PLACEHOLDER, i as fetchFontBytes, l as composePresentation, n as textRuns, r as clipPath, t as textRun, u as PresentationCore } from "./text-BvFFMMFQ.js";
+import { c as ALL_CONSTRUCT_FAMILIES, d as IMG_SVG_PLACEHOLDER, i as fetchFontBytes, l as composePresentation, n as textRuns, r as clipPath, t as textRun, u as PresentationCore } from "./text-BNkJjLJh.js";
 import { r as PPTX_CONTENT_TYPE } from "./zip-CYZ0F6BV.js";
 import { t as tableDomFamily } from "./table-dom-CVbvUfgh.js";
 //#region src/runtime/browser.ts

package/dist/{clip-DHDlnHUq.d.ts → clip-BkzLGLTj.d.ts}

@@ -1,4 +1,4 @@
-import { y as GeometryPoint } from "./pres-BA9_lJbY.js";
+import { y as GeometryPoint } from "./pres-C6tEDikt.js";
 //#region src/ooxml/emu.d.ts
 /**
  * The fixed ratios between English Metric Units, points and inches.
@@ -64,4 +64,4 @@ type ClipShape =
 declare function clipPath(shape: ClipShape, w: number, h: number): GeometryPoint[];
 //#endregion
 export { EMU_PER_INCH as a, clipPath as i, FlatSide as n, EMU_PER_POINT as o, HalfDiscPreset as r, POINTS_PER_INCH as s, ClipShape as t };
-//# sourceMappingURL=clip-DHDlnHUq.d.ts.map
+//# sourceMappingURL=clip-BkzLGLTj.d.ts.map

package/dist/{clip-DHDlnHUq.d.ts.map → clip-BkzLGLTj.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"clip-DHDlnHUq.d.ts","names":[],"sources":["../src/ooxml/emu.ts","../src/clip.ts"],"mappings":";;;;;;;;;;;cAUa;;cAEA;;cAEA;;;;;;;KCgBD;;;;;;;KAQA;;KAGA;;;;;;EAKT;EAAmB,MAAM;EAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iBAyH/B,SAAS,OAAO,WAAW,WAAW,YAAY"}
+{"version":3,"file":"clip-BkzLGLTj.d.ts","names":[],"sources":["../src/ooxml/emu.ts","../src/clip.ts"],"mappings":";;;;;;;;;;;cAUa;;cAEA;;cAEA;;;;;;;KCgBD;;;;;;;KAQA;;KAGA;;;;;;EAKT;EAAmB,MAAM;EAAU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;iBAyH/B,SAAS,OAAO,WAAW,WAAW,YAAY"}

package/dist/{diagnostics-DiMmBU8P.d.ts → diagnostics-UEnuaGE5.d.ts}

@@ -30,12 +30,12 @@
  * differs — an image whose natural size cannot be measured reports
  * `image/unmeasurable-natural-size` whether it came from `addImage` or from `Picture.setImage`.
  */
-type DiagnosticCode = 'object-name/empty' | 'object-name/control-characters' | 'object-name/too-long' | 'object-name/duplicate' | 'animation/target-index-out-of-range' | 'animation/target-not-found' | 'animation/target-missing' | 'animation/unknown-preset' | 'chart/invalid-axis-time-unit' | 'chart/non-finite-value' | 'chart/error-bars-missing-values' | 'chart/axis-type-conflict' | 'chart/invalid-metadata' | 'chart/invalid-metadata-key' | 'chart/invalid-metadata-value' | 'chart/option-out-of-range' | 'chart/option-not-on-axis' | 'chart/option-not-supported' | 'chart/invalid-option-value' | 'chart/invalid-subtotal-index' | 'chart/symbol-size-out-of-range' | 'chart/invalid-grid-line-size' | 'chart/invalid-grid-line-style' | 'chart/invalid-grid-line-cap' | 'chart/layout-out-of-range' | 'chart/stock-series-count' | 'chart/point-count-mismatch' | 'chart/point-index-out-of-range' | 'comment/missing-author' | 'comment/missing-text' | 'connector/bends-ignored-for-straight' | 'connector/adj-out-of-range' | 'connector/unresolved-binding' | 'group/unsupported-child' | 'group/unrecognized-child' | 'group/no-children' | 'group/partial-frame' | 'family/child-not-composed' | 'image-fill/missing-source' | 'image-fill/missing-base64-header' | 'image-fill/svg-unsupported' | 'image-fill/unresolved-media' | 'preview-image/missing-base64-header' | 'background/missing-base64-header' | 'image/crop-and-sizing-conflict' | 'image/unmeasurable-natural-size' | 'image/bilevel-threshold-out-of-range' | 'table/invalid-border' | 'table/invalid-outer-border' | 'table/invalid-horz-overflow' | 'table/invalid-cell3d' | 'table/col-width-count-mismatch' | 'table/invalid-col-width' | 'table/span-out-of-range' | 'table/cell-past-grid' | 'table/autopage-height-too-small' | 'table/autopage-rowspan-too-tall' | 'table/invalid-row-height' | 'table/invalid-margin' | 'table/invalid-header-row-count' | 'text/invalid-valign' | 'text/invalid-vertical' | 'text/invalid-warp' | 'text/invalid-columns' | 'text/invalid-column-spacing' | 'text/invalid-indent-level' | 'text/invalid-fit-percentage' | 'text/invalid-strike' | 'text/invalid-caps' | 'text/invalid-underline' | 'text/invalid-tab-alignment' | 'text/char-spacing-out-of-range' | 'text/line-spacing-out-of-range' | 'text/paragraph-margin-out-of-range' | 'text/paragraph-indent-out-of-range' | 'font/size-out-of-range' | 'bullet/size-out-of-range' | 'bullet/image-missing-base64-header' | 'bullet/image-embed-failed' | 'bullet/invalid-character-code' | 'bullet/start-at-out-of-range' | 'bullet/invalid-number-type' | 'transition/unknown-type' | 'transition/unknown-variant' | 'zoom/missing-target' | 'zoom/unresolved-target' | 'zoom/missing-section-title' | 'zoom/section-not-found' | 'zoom/section-empty' | 'zoom/no-sections-to-summarize' | 'zoom/transition-duration-out-of-range' | 'color/not-a-string' | 'color/invalid-value' | 'color/empty-string' | 'shadow/invalid-type' | 'shadow/angle-out-of-range' | 'glow/size-out-of-range' | 'shadow/blur-out-of-range' | 'shadow/offset-out-of-range' | 'shadow/transparency-out-of-range' | 'shadow/color-has-hash' | 'geometry/invalid-shape-adjust' | 'geometry/shape-adjust-overridden' | 'geometry/arc-node-point-ignored' | 'shape/degenerate-extent' | 'frame/zero-extent' | 'geometry/invalid-guide' | 'geometry/unknown-guide-operation' | 'geometry/invalid-connection-site' | 'border/unknown-key' | 'border/invalid-dash-type' | 'line/invalid-arrow-type' | 'object-lock/unsupported-on-shape' | 'media/load-failed' | 'media/svg-preview-failed' | 'model3d/preview-missing' | 'media/invalid-loop-count' | 'theme/invalid-color-override' | 'master/invalid-text-style-font-size' | 'master/invalid-text-style-length' | 'master/too-many-text-style-levels' | 'notes/hyperlink-slide-unsupported' | 'html/image-missing-source' | 'section/missing-argument' | 'section/missing-title' | 'section/duplicate-title' | 'section/invalid-order' | 'slide/section-not-found' | 'slide/master-not-found' | 'slide/removed-link-target' | 'layout/invalid-definition' | 'core/revision-not-a-whole-number' | 'diagram/drawing-cache-not-updated' | 'diagram/point-has-no-text-body' | 'inspect/group-transform-missing' | 'inspect/group-transform-degenerate' | 'measure/shrink-unmeasured' | 'measure/resize-unmeasured' | 'measure/heuristic-metrics' | 'measure/uncovered-codepoints' | 'margin/legacy-points' | 'gradient/center-out-of-range' | 'transparency/out-of-range' | 'opacity/out-of-range' | 'line/width-out-of-range' | 'coord/bare-number-is-inches' | 'layout/size-out-of-range';
+type DiagnosticCode = 'object-name/empty' | 'object-name/control-characters' | 'object-name/too-long' | 'object-name/duplicate' | 'animation/target-index-out-of-range' | 'animation/target-not-found' | 'animation/target-missing' | 'animation/unknown-preset' | 'chart/invalid-axis-time-unit' | 'chart/non-finite-value' | 'chart/error-bars-missing-values' | 'chart/axis-type-conflict' | 'chart/invalid-metadata' | 'chart/invalid-metadata-key' | 'chart/invalid-metadata-value' | 'chart/option-out-of-range' | 'chart/option-not-on-axis' | 'chart/option-not-supported' | 'chart/invalid-option-value' | 'chart/invalid-subtotal-index' | 'chart/symbol-size-out-of-range' | 'chart/invalid-grid-line-size' | 'chart/invalid-grid-line-style' | 'chart/invalid-grid-line-cap' | 'chart/layout-out-of-range' | 'chart/stock-series-count' | 'chart/point-count-mismatch' | 'chart/point-index-out-of-range' | 'comment/missing-author' | 'comment/missing-text' | 'connector/bends-ignored-for-straight' | 'connector/adj-out-of-range' | 'connector/unresolved-binding' | 'group/unsupported-child' | 'group/unrecognized-child' | 'group/no-children' | 'group/partial-frame' | 'family/child-not-composed' | 'image-fill/missing-source' | 'image-fill/missing-base64-header' | 'image-fill/svg-unsupported' | 'image-fill/unresolved-media' | 'preview-image/missing-base64-header' | 'background/missing-base64-header' | 'image/crop-and-sizing-conflict' | 'image/unmeasurable-natural-size' | 'image/bilevel-threshold-out-of-range' | 'table/invalid-border' | 'table/invalid-outer-border' | 'table/invalid-horz-overflow' | 'table/invalid-cell3d' | 'table/col-width-count-mismatch' | 'table/invalid-col-width' | 'table/span-out-of-range' | 'table/cell-past-grid' | 'table/autopage-height-too-small' | 'table/autopage-rowspan-too-tall' | 'table/invalid-row-height' | 'table/invalid-margin' | 'table/invalid-header-row-count' | 'text/invalid-valign' | 'text/invalid-vertical' | 'text/invalid-warp' | 'text/invalid-columns' | 'text/invalid-column-spacing' | 'text/invalid-indent-level' | 'text/invalid-fit-percentage' | 'text/invalid-strike' | 'text/invalid-caps' | 'text/invalid-underline' | 'text/invalid-tab-alignment' | 'text/char-spacing-out-of-range' | 'text/kerning-out-of-range' | 'text/line-spacing-out-of-range' | 'text/paragraph-margin-out-of-range' | 'text/paragraph-indent-out-of-range' | 'font/size-out-of-range' | 'bullet/size-out-of-range' | 'bullet/image-missing-base64-header' | 'bullet/image-embed-failed' | 'bullet/invalid-character-code' | 'bullet/start-at-out-of-range' | 'bullet/invalid-number-type' | 'transition/unknown-type' | 'transition/unknown-variant' | 'zoom/missing-target' | 'zoom/unresolved-target' | 'zoom/missing-section-title' | 'zoom/section-not-found' | 'zoom/section-empty' | 'zoom/no-sections-to-summarize' | 'zoom/transition-duration-out-of-range' | 'color/not-a-string' | 'color/invalid-value' | 'color/empty-string' | 'shadow/invalid-type' | 'shadow/angle-out-of-range' | 'glow/size-out-of-range' | 'shadow/blur-out-of-range' | 'shadow/offset-out-of-range' | 'shadow/transparency-out-of-range' | 'shadow/color-has-hash' | 'geometry/invalid-shape-adjust' | 'geometry/shape-adjust-overridden' | 'geometry/arc-node-point-ignored' | 'shape/degenerate-extent' | 'frame/zero-extent' | 'geometry/invalid-guide' | 'geometry/unknown-guide-operation' | 'geometry/invalid-connection-site' | 'border/unknown-key' | 'border/invalid-dash-type' | 'line/invalid-arrow-type' | 'object-lock/unsupported-on-shape' | 'media/load-failed' | 'media/svg-preview-failed' | 'model3d/preview-missing' | 'media/invalid-loop-count' | 'theme/invalid-color-override' | 'master/invalid-text-style-font-size' | 'master/invalid-text-style-length' | 'master/too-many-text-style-levels' | 'notes/hyperlink-slide-unsupported' | 'html/image-missing-source' | 'section/missing-argument' | 'section/missing-title' | 'section/duplicate-title' | 'section/invalid-order' | 'slide/section-not-found' | 'slide/master-not-found' | 'slide/removed-link-target' | 'layout/invalid-definition' | 'core/revision-not-a-whole-number' | 'diagram/drawing-cache-not-updated' | 'diagram/point-has-no-text-body' | 'inspect/group-transform-missing' | 'inspect/group-transform-degenerate' | 'measure/shrink-unmeasured' | 'measure/resize-unmeasured' | 'measure/heuristic-metrics' | 'measure/uncovered-codepoints' | 'margin/legacy-points' | 'gradient/center-out-of-range' | 'transparency/out-of-range' | 'opacity/out-of-range' | 'line/width-out-of-range' | 'coord/bare-number-is-inches' | 'layout/size-out-of-range';
 /**
  * Conditions carried by `InvalidOptionError`: the caller passed something the library cannot use.
  *
  * This is the largest group by design — the project's stated policy is to throw rather than coerce
- * (`AGENTS.md` → "Silent coercion of invalid input is a footgun"), so most throws are here.
+ * (`docs/contributing/development.md` → "Warn or throw?"), so most throws are here.
  */
 type InvalidOptionErrorCode = 'coord/non-finite' | 'percent/non-finite' | 'coord/not-positive' | 'coord/invalid-format' | 'coord/out-of-range' | 'bullet/start-at-not-a-number' | 'presentation/first-slide-num-not-an-integer' | 'geometry/arc-angle-non-finite' | 'shadow/angle-non-finite' | 'chart/missing-type' | 'chart/option-non-finite' | 'chart/unknown-type' | 'chart/secondary-axis-unused' | 'chart/axis-count-mismatch' | 'chart/too-many-columns' | 'chart/bubble-in-combo' | 'shape/missing-type' | 'shape/unknown-preset' | 'connector/missing-endpoints' | 'connector/invalid-type' | 'connector/invalid-bends' | 'connector/adj-count-mismatch' | 'connector/adj-non-finite' | 'connector/invalid-binding-name' | 'connector/invalid-connection-site' | 'line/invalid-cap' | 'group/missing-object-names' | 'group/invalid-object-name' | 'group/duplicate-object-name' | 'group/unresolved-object-name' | 'group/ambiguous-object-name' | 'gradient/angle-non-finite' | 'gradient/too-few-stops' | 'gradient/stop-position-non-finite' | 'gradient/stop-position-out-of-range' | 'gradient/rotate-with-shape-not-boolean' | 'gradient/scaled-not-boolean' | 'pattern-fill/missing-pattern' | 'pattern-fill/invalid-preset' | 'image/missing-source' | 'image/path-not-a-string' | 'image/data-not-a-string' | 'image/missing-base64-header' | 'image/crop-window-overflows' | 'image/crop-inset-out-of-range' | 'image/crop-insets-exceed-extent' | 'media/missing-source' | 'media/missing-base64-header' | 'media/cover-missing-base64-header' | 'media/online-missing-link' | 'ole/missing-source' | 'ole/invalid-image-size' | 'zoom/invalid-transition-duration' | 'transition/invalid-time' | 'transition/sound-unsupported' | 'model3d/missing-source' | 'model3d/invalid-camera' | 'model3d/invalid-fov' | 'model3d/invalid-scale' | 'layout/invalid-definition' | 'table/rows-not-an-array' | 'table/rows-not-nested' | 'table/invalid-style-id' | 'table/invalid-cell-anchor' | 'table/invalid-cell-vert' | 'table/invalid-cell-overflow' | 'table/invalid-cell-margin' | 'table/invalid-cell-border' | 'table/row-index-out-of-range' | 'table/column-index-out-of-range' | 'table/merge-range-invalid' | 'hyperlink/not-an-object' | 'hyperlink/missing-target' | 'hyperlink/conflicting-targets' | 'hyperlink/invalid-slide' | 'slide/link-past-last-slide' | 'text/invalid-text' | 'clip/invalid-shape' | 'html/no-document' | 'html/table-not-found' | 'html/table-has-no-cells' | 'color/invalid-hex' | 'color/invalid-scheme-token' | 'text/invalid-underline' | 'slide/index-out-of-range' | 'slide/foreign-target' | 'slide/id-space-exhausted' | 'shape/index-out-of-range' | 'layout/ambiguous-name' | 'layout/not-found' | 'layout/foreign-handle' | 'import/slide-size-mismatch' | 'import/slide-size-unknown' | 'import/unresolved-slide-link' | 'import/destination-missing-master' | 'import/destination-missing-layout' | 'import/output-index-conflict' | 'import/output-index-out-of-range' | 'import/rescale-conflict' | 'image/undeterminable-extension' | 'image/undeterminable-type' | 'image/missing-content-type' | 'image/fit-needs-extent' | 'font/size-not-positive' | 'script/unresolved-asset-reference' | 'script/non-finite-literal' | 'package/duplicate-part-name' | 'part/not-xml' | 'relationship/duplicate-id' | 'relationship/not-found' | 'relationship/external-has-no-partname' | 'oxml/unknown-namespace-prefix' | 'oxml/invalid-qname' | 'font/missing-typeface' | 'font/invalid-style-slot' | 'font/invalid-base64' | 'font/missing-source' | 'font/collection-index-out-of-range' | 'font/collection-face-not-found' | 'layout/unknown' | 'master/missing-title' | 'math/invalid-latex' | 'math/invalid-mathml' | 'zip/unsupported-input' | 'zip/unsupported-output';
 /**
@@ -241,4 +241,4 @@ declare function setDiagnosticHandler(next: DiagnosticHandler | null): void;
 declare function resetDiagnosticState(): void;
 //#endregion
 export { PackageReadErrorCode as _, InternalError as a, PackageReadError as c, UnsupportedFeatureError as d, DiagnosticCode as f, MediaErrorCode as g, InvalidOptionErrorCode as h, setDiagnosticHandler as i, TsPptxError as l, InternalErrorCode as m, DiagnosticHandler as n, InvalidOptionError as o, ErrorCode as p, resetDiagnosticState as r, MediaError as s, Diagnostic as t, TsPptxErrorOptions as u, TsPptxCode as v, UnsupportedFeatureErrorCode as y };
-//# sourceMappingURL=diagnostics-DiMmBU8P.d.ts.map
+//# sourceMappingURL=diagnostics-UEnuaGE5.d.ts.map

package/dist/{diagnostics-DiMmBU8P.d.ts.map → diagnostics-UEnuaGE5.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"diagnostics-DiMmBU8P.d.ts","names":[],"sources":["../src/codes.ts","../src/errors.ts","../src/diagnostics.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCY;;;;;;;KA8KA;;;;;;KA0KA;;;;;;KAwBA;;;;;;;KAkCA;;;;;;KAwBA;;;;;;;;;;;;;;KAiEA,YACT,yBACA,8BACA,uBACA,iBACA;;KAGS,aAAa,iBAAiB;;;;UCvezB,2BAA2B;;;;;WAKlC,SAAS,SAAS;;;;;;;;;cAUf,oBAAoB;;WAEvB,MAAM;;WAGN,SAAS,SAAS;;;;;;EAO3B,YAAY,MAAM,WAAW,iBAAiB,UAAU;;;;;;;;;;cAmB5C,2BAA2B;WACtB,MAAM;EACvB,YAAY,MAAM,wBAAwB,iBAAiB,UAAU;;;;;;;;;;;cAczD,gCAAgC;WAC3B,MAAM;EACvB,YAAY,MAAM,6BAA6B,iBAAiB,UAAU;;;;;;;;;;cAa9D,yBAAyB;WACpB,MAAM;EACvB,YAAY,MAAM,sBAAsB,iBAAiB,UAAU;;;;;;;;;cAYvD,mBAAmB;WACd,MAAM;EACvB,YAAY,MAAM,gBAAgB,iBAAiB,UAAU;;;;;;;;;;;;;;;;;;;cAkCjD,sBAAsB;WACjB,MAAM;EACvB,YAAY,MAAM,mBAAmB,iBAAiB,UAAU;;;;;UCzJhD;;WAEP,MAAM;;WAEN;;;;;;;;;;;WAWA,SAAS,SAAS;;;KAIhB,qBAAqB,YAAY;;;;;;;;;;;;;;;;;;;;;;;iBAkC7B,qBAAqB,MAAM;;;;;;;;;;;;;;;;;iBAwD3B"}
+{"version":3,"file":"diagnostics-UEnuaGE5.d.ts","names":[],"sources":["../src/codes.ts","../src/errors.ts","../src/diagnostics.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgCY;;;;;;;KA+KA;;;;;;KA0KA;;;;;;KAwBA;;;;;;;KAkCA;;;;;;KAwBA;;;;;;;;;;;;;;KAiEA,YACT,yBACA,8BACA,uBACA,iBACA;;KAGS,aAAa,iBAAiB;;;;UCxezB,2BAA2B;;;;;WAKlC,SAAS,SAAS;;;;;;;;;cAUf,oBAAoB;;WAEvB,MAAM;;WAGN,SAAS,SAAS;;;;;;EAO3B,YAAY,MAAM,WAAW,iBAAiB,UAAU;;;;;;;;;;cAmB5C,2BAA2B;WACtB,MAAM;EACvB,YAAY,MAAM,wBAAwB,iBAAiB,UAAU;;;;;;;;;;;cAczD,gCAAgC;WAC3B,MAAM;EACvB,YAAY,MAAM,6BAA6B,iBAAiB,UAAU;;;;;;;;;;cAa9D,yBAAyB;WACpB,MAAM;EACvB,YAAY,MAAM,sBAAsB,iBAAiB,UAAU;;;;;;;;;cAYvD,mBAAmB;WACd,MAAM;EACvB,YAAY,MAAM,gBAAgB,iBAAiB,UAAU;;;;;;;;;;;;;;;;;;;cAkCjD,sBAAsB;WACjB,MAAM;EACvB,YAAY,MAAM,mBAAmB,iBAAiB,UAAU;;;;;UCzJhD;;WAEP,MAAM;;WAEN;;;;;;;;;;;WAWA,SAAS,SAAS;;;KAIhB,qBAAqB,YAAY;;;;;;;;;;;;;;;;;;;;;;;iBAkC7B,qBAAqB,MAAM;;;;;;;;;;;;;;;;;iBAwD3B"}

package/dist/{embedded-fonts-CI_YGW2d.d.ts → embedded-fonts-DQaUrNYv.d.ts}

@@ -1,4 +1,4 @@
-import { dn as EMBEDDED_FONT_SLOTS } from "./pres-BA9_lJbY.js";
+import { dn as EMBEDDED_FONT_SLOTS } from "./pres-C6tEDikt.js";
 //#region src/embedded-fonts.d.ts
 type EmbeddedFontSlot = (typeof EMBEDDED_FONT_SLOTS)[number];
 /** One embeddable face: a slot plus the raw font bytes (absent in pure read-side merges). */
@@ -17,4 +17,4 @@ interface EmbeddedFont {
 }
 //#endregion
 export { EmbeddedFontFace as n, EmbeddedFontSlot as r, EmbeddedFont as t };
-//# sourceMappingURL=embedded-fonts-CI_YGW2d.d.ts.map
+//# sourceMappingURL=embedded-fonts-DQaUrNYv.d.ts.map

package/dist/{embedded-fonts-CI_YGW2d.d.ts.map → embedded-fonts-DQaUrNYv.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"embedded-fonts-CI_YGW2d.d.ts","names":[],"sources":["../src/embedded-fonts.ts"],"mappings":";;KAyCY,2BAA2B;;UAGtB;EAChB,MAAM;EACN,QAAQ;;;UAIQ;;EAEhB;EACA;EACA;EACA;EACA,OAAO"}
+{"version":3,"file":"embedded-fonts-DQaUrNYv.d.ts","names":[],"sources":["../src/embedded-fonts.ts"],"mappings":";;KAyCY,2BAA2B;;UAGtB;EAChB,MAAM;EACN,QAAQ;;;UAIQ;;EAEhB;EACA;EACA;EACA;EACA,OAAO"}

package/dist/{entry-compose-6hF9aTmT.d.ts → entry-compose-BM9vmPPw.d.ts}

@@ -1,10 +1,10 @@
 import { d as SHAPE_NAME, i as CHART_NAME, m as SlideObjectType, v as WRITE_OUTPUT_TYPE } from "./enums-DQRpVOLh.js";
-import { $ as ChartOpts, At as NotesProps, C as HexColor, Ht as TextProps, It as TableLayoutResult, Mt as OverflowBoxOptions, Pt as SlideComment, Q as ChartMulti, St as OptsChartData, Ut as TextPropsOptions, Vt as TextMeasurement, c as WriteFileProps, f as ThemeProps, i as PresLayout, kt as MeasureTextOptions, l as WriteOutputMap, n as PackagePart, o as SectionProps, p as BackgroundOption, qt as ImageProps, r as PartsProps, rn as ShapeProps, s as WriteBaseProps, t as CustomPropertyValue, u as WriteProps } from "./pres-BA9_lJbY.js";
-import { L as TableToSlidesProps, M as TableProps, N as TableRow, S as AnimationProps, T as TransitionProps, a as Slide, b as SlideMasterProps, n as GroupChildProps, o as SlideLayout, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, x as SlideNumberProps, y as SlideMasterObject } from "./slide-BqPtyKmb.js";
-import { r as EmbeddedFontSlot } from "./embedded-fonts-CI_YGW2d.js";
-import { A as SlideObject, D as SectionInternalProps, E as PresentationPropsInternal, M as SlideRelChart, N as SlideRelMedia, O as SlideLayoutInternal, T as PresSlideInternal, j as SlideRel, k as SlideMasterInternal, n as FontMetricsRegistry, w as ObjectOptionsInternal } from "./font-metrics-CBGmhLo0.js";
-import { s as MediaError } from "./diagnostics-DiMmBU8P.js";
-import { c as ExtractedSlides, s as ExtractedSlide } from "./presentation-types-B3VQH4Bz.js";
+import { $ as ChartOpts, At as NotesProps, C as HexColor, Ht as TextProps, It as TableLayoutResult, Mt as OverflowBoxOptions, Pt as SlideComment, Q as ChartMulti, St as OptsChartData, Ut as TextPropsOptions, Vt as TextMeasurement, c as WriteFileProps, f as ThemeProps, i as PresLayout, kt as MeasureTextOptions, l as WriteOutputMap, n as PackagePart, o as SectionProps, p as BackgroundOption, qt as ImageProps, r as PartsProps, rn as ShapeProps, s as WriteBaseProps, t as CustomPropertyValue, u as WriteProps } from "./pres-C6tEDikt.js";
+import { L as TableToSlidesProps, M as TableProps, N as TableRow, S as AnimationProps, T as TransitionProps, a as Slide, b as SlideMasterProps, n as GroupChildProps, o as SlideLayout, r as GroupProps, s as SlideObjectInfo, t as AddSlideProps, x as SlideNumberProps, y as SlideMasterObject } from "./slide-D1uABOLy.js";
+import { r as EmbeddedFontSlot } from "./embedded-fonts-DQaUrNYv.js";
+import { A as SlideObject, D as SectionInternalProps, E as PresentationPropsInternal, M as SlideRelChart, N as SlideRelMedia, O as SlideLayoutInternal, T as PresSlideInternal, j as SlideRel, k as SlideMasterInternal, n as FontMetricsRegistry, w as ObjectOptionsInternal } from "./font-metrics-CUnCHR3S.js";
+import { s as MediaError } from "./diagnostics-UEnuaGE5.js";
+import { c as ExtractedSlides, s as ExtractedSlide } from "./presentation-types-NkPl7zfU.js";
 import { r as ZipWriter } from "./zip-CTll_dr0.js";
 //#region src/runtime/types.d.ts
 type RuntimeAdapter = {
@@ -1045,4 +1045,4 @@ interface ComposeOptions<Fs extends readonly ConstructFamily[]> {
 type Composed<Fs extends readonly ConstructFamily[]> = ComposedPresentation<SlideMethodsOf<[...typeof CORE_CONSTRUCT_FAMILIES, ...Fs]>, PresentationMethodsOf<[...typeof CORE_CONSTRUCT_FAMILIES, ...Fs]>>;
 //#endregion
 export { pixelsToEmu as A, StandardLayoutName as C, emuToPoints as D, emuToPixels as E, ptToHundredths as M, inchesToEmu as O, StandardLayout as S, emuToInches as T, HUNDREDTHS_PER_POINT as _, renderImageObject as a, PERCENT_SCALE as b, ConstructFamily as c, PartContributor as d, RenderContext as f, FIXED_PCT_PER_PERCENT as g, Emu as h, ComposedSlide as i, pointsToEmu as j, percentToEmu as k, PresentationAuthorContext as l, DEFAULT_PX_PER_INCH as m, Composed as n, renderTextObject as o, ANGLE_UNITS_PER_DEGREE as p, ComposedPresentation as r, PresentationCore as s, ComposeOptions as t, SlideBuilder as u, MAX_COORDINATE_EMU as v, coordToEmu as w, STANDARD_LAYOUTS as x, MIN_COORDINATE_EMU as y };
-//# sourceMappingURL=entry-compose-6hF9aTmT.d.ts.map
+//# sourceMappingURL=entry-compose-BM9vmPPw.d.ts.map

package/dist/{entry-compose-6hF9aTmT.d.ts.map → entry-compose-BM9vmPPw.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"entry-compose-6hF9aTmT.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;;;;;;;;;;;;;;;;;;;;;;cCnKE;;;;;;;;;;;;;;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;;;;;;;;EAczC,MAAM,UAAU,4BAA4B,QAAQ,WAAW,KAAK,QAAQ,eAAe;;;;;;;;;;;;;;;;;EAyB3F,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;;;;;;;iBC/7BV,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"}
+{"version":3,"file":"entry-compose-BM9vmPPw.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":"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"}

package/dist/families.d.ts

@@ -1,9 +1,9 @@
 import { d as SHAPE_NAME, i as CHART_NAME } from "./enums-DQRpVOLh.js";
-import { $ as ChartOpts, At as NotesProps, F as ConnectorProps, Ht as TextProps, It as TableLayoutResult, Jt as MediaProps, Mt as OverflowBoxOptions, Ot as CommentProps, Q as ChartMulti, St as OptsChartData, Ut as TextPropsOptions, Vt as TextMeasurement, Xt as OleObjectProps, kt as MeasureTextOptions, qt as ImageProps, rn as ShapeProps } from "./pres-BA9_lJbY.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-BqPtyKmb.js";
-import { T as PresSlideInternal } from "./font-metrics-CBGmhLo0.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-6hF9aTmT.js";
-import { s as ExtractedSlide } from "./presentation-types-B3VQH4Bz.js";
+import { $ as ChartOpts, At as NotesProps, F as ConnectorProps, Ht as TextProps, It as TableLayoutResult, Jt as MediaProps, Mt as OverflowBoxOptions, Ot as CommentProps, Q as ChartMulti, St as OptsChartData, Ut as TextPropsOptions, Vt as TextMeasurement, Xt as OleObjectProps, kt as MeasureTextOptions, qt as ImageProps, rn as ShapeProps } from "./pres-C6tEDikt.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-D1uABOLy.js";
+import { T as PresSlideInternal } from "./font-metrics-CUnCHR3S.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-BM9vmPPw.js";
+import { s as ExtractedSlide } from "./presentation-types-NkPl7zfU.js";
 //#region src/gen/slide/objects/chart.d.ts
 /**
  * Render a `chart` slide object to its `<p:graphicFrame>` XML referencing the chart part.

package/dist/families.js

@@ -1,4 +1,4 @@
-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-BoNyOlPm.js";
+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-Bjd8B4U8.js";
 import { t as tableDomFamily } from "./table-dom-CVbvUfgh.js";
 //#region src/families.ts
 /**

package/dist/{font-metrics-CBGmhLo0.d.ts → font-metrics-CUnCHR3S.d.ts}

@@ -1,7 +1,7 @@
 import { c as PLACEHOLDER_TYPE, d as SHAPE_NAME, g as TextAnchor, i as CHART_NAME, m as SlideObjectType, o as ChartType, t as AlignH } from "./enums-DQRpVOLh.js";
-import { $ as ChartOpts, E as Margin, Ht as TextProps, Jt as MediaProps, Pt as SlideComment, Q as ChartMulti, Sn as TextShapeType, St as OptsChartData, Ut as TextPropsOptions, Yt as MediaType, a as PresentationProps, i as PresLayout, j as TextVertType, o as SectionProps, p as BackgroundOption, q as ChartErrorBarOptions, z as HyperlinkProps } from "./pres-BA9_lJbY.js";
-import { O as TableCell, S as AnimationProps, _ as MasterTextStyleProps, a as Slide, i as ObjectOptions, o as SlideLayout, x as SlideNumberProps } from "./slide-BqPtyKmb.js";
-import { t as EmbeddedFont } from "./embedded-fonts-CI_YGW2d.js";
+import { $ as ChartOpts, E as Margin, Ht as TextProps, Jt as MediaProps, Pt as SlideComment, Q as ChartMulti, Sn as TextShapeType, St as OptsChartData, Ut as TextPropsOptions, Yt as MediaType, a as PresentationProps, i as PresLayout, j as TextVertType, o as SectionProps, p as BackgroundOption, q as ChartErrorBarOptions, z as HyperlinkProps } from "./pres-C6tEDikt.js";
+import { O as TableCell, S as AnimationProps, _ as MasterTextStyleProps, a as Slide, i as ObjectOptions, o as SlideLayout, x as SlideNumberProps } from "./slide-D1uABOLy.js";
+import { t as EmbeddedFont } from "./embedded-fonts-DQaUrNYv.js";
 //#region src/types/internal.d.ts
 /** The keys of `T` that are declared optional. */
 type OptionalKeysOf<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never; }[keyof T];
@@ -610,4 +610,4 @@ declare class FontMetricsRegistry {
 declare function makeRegistryResolver(registry: FontMetricsRegistry, onHeuristic?: (face: string) => void): MetricsResolver;
 //#endregion
 export { SlideObject as A, solveShrink as C, SectionInternalProps as D, PresentationPropsInternal as E, SlideRelChart as M, SlideRelMedia as N, SlideLayoutInternal as O, solveResize as S, PresSlideInternal as T, ShrinkOutcome as _, makeRegistryResolver as a, measureHeightPt as b, FitBox as c, HEIGHT_SAFETY_FACTOR as d, LayoutResult as f, SINGLE_LINE_PITCH as g, ResizeOutcome as h, getHeuristicFontMetrics as i, SlideRel as j, SlideMasterInternal as k, FitParagraph as l, MetricsResolver as m, FontMetricsRegistry as n, parseFontMetrics as o, MIN_FONT_SCALE_PCT as p, ParseFontMetricsOptions as r, FONT_SCALE_STEP_PCT as s, FontMetrics as t, FitRun as u, ShrinkResult as v, ObjectOptionsInternal as w, measureLayout as x, WIDTH_SAFETY_FACTOR as y };
-//# sourceMappingURL=font-metrics-CBGmhLo0.d.ts.map
+//# sourceMappingURL=font-metrics-CUnCHR3S.d.ts.map

package/dist/{font-metrics-CBGmhLo0.d.ts.map → font-metrics-CUnCHR3S.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"font-metrics-CBGmhLo0.d.ts","names":[],"sources":["../src/types/internal.ts","../src/measure/text-fit.ts","../src/measure/font-metrics.ts"],"mappings":"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"}
+{"version":3,"file":"font-metrics-CUnCHR3S.d.ts","names":[],"sources":["../src/types/internal.ts","../src/measure/text-fit.ts","../src/measure/font-metrics.ts"],"mappings":"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"}

package/dist/html-dom-DvJmuHt2.js.map

@@ -1 +1 @@
-{"version":3,"file":"html-dom-DvJmuHt2.js","names":[],"sources":["../src/gen/table/html-dom.ts"],"sourcesContent":["/**\n * pptx-ts: HTML-table → slides (browser DOM path)\n *\n * The tableToSlides() flow: reproduce an HTML table as a PowerPoint table across as many\n * slides as needed. The DOM-independent parts are factored into pure helpers\n * (`resolveHtmlColWidth`, `pickColWidthBasis`, `htmlBorderToProps`, `cssColorToHex`) that\n * are unit-tested directly, and the whole flow runs anywhere there is a DOM.\n *\n * Only real *measurement* is out of active scope (see AGENTS.md): without a layout engine\n * `offsetWidth` is `0`, so widths fall back to computed CSS then to an equal split. A fallback\n * rather than a degradation, and the distinction is load-bearing — see {@link pickColWidthBasis},\n * whose two bases measure different boxes.\n *\n * **Coverage.** This file used to be excluded from the report, on the grounds that only the\n * browser entry imported it and the `dist/browser*.js` globs therefore swallowed it. Both\n * halves of that are stale: `pptx-ts/html` imports it too, so tsdown emits it as its own\n * `dist/html-dom-*.js` chunk, and those globs are gone from `vitest.config.ts` entirely. It\n * is covered code now — against happy-dom by the Node suite\n * (test/regression/html/html-to-slides-node.test.ts) and, for the measured width basis that no\n * Node DOM can produce, in a real Chromium (test/browser/table-widths.spec.ts).\n */\n\nimport { SlideObjectType } from '../../enums.js'\nimport type {\n\tAddSlideProps,\n\tBorderProps,\n\tHAlign,\n\tPositionProps,\n\tPresLayout,\n\tTableProps,\n\tTableToSlidesDocument,\n\tTableToSlidesElement,\n\tTableToSlidesProps,\n\tTableCellProps,\n\tVAlign,\n} from '../../types/index.js'\nimport type { Slide } from '../../types/slide.js'\nimport type { SlideLayoutInternal, TableCellInternal, TableToSlidesPropsInternal } from '../../types/internal.js'\nimport { getSmartParseNumber, inch2Emu, resolveSlideMarginsInches, usableTableWidthEmu } from '../../units-internal.js'\nimport { warn } from '../../diagnostics.js'\nimport { DEFAULT_PX_PER_INCH, EMU_PER_INCH, POINTS_PER_INCH } from '../../units.js'\nimport { createRowSpanOccupancy } from './grid.js'\nimport { MAX_TABLE_SPAN, resolveSpan } from './spans.js'\nimport { getSlidesForTableRows } from './autopage.js'\nimport { InvalidOptionError } from '../../errors.js'\n\n/**\n * CSS `text-align` / `vertical-align` values this converter can express as a table cell's own\n * alignment. The two logical values map onto the physical pair; everything else — `justify`,\n * `initial`, a value the browser did not resolve — is absent here and so leaves the cell's\n * alignment alone.\n */\nconst CSS_TEXT_ALIGN: Record<string, HAlign> = {\n\tleft: 'left',\n\tcenter: 'center',\n\tright: 'right',\n\tstart: 'left',\n\tend: 'right',\n}\nconst CSS_VERTICAL_ALIGN: Record<string, VAlign> = { top: 'top', middle: 'middle', bottom: 'bottom' }\n\ntype MarginTuple = [number, number, number, number]\ntype BorderTuple = [BorderProps, BorderProps, BorderProps, BorderProps]\n/**\n * What `tableToSlides` needs a presentation to be: somewhere to put slides, and a layout to\n * size them against. Structural on purpose — stating the two members rather than naming the\n * class is what lets the free function on `pptx-ts/html` take any presentation instance\n * (Node, browser, or standalone) without the entry importing one.\n */\nexport type TableToSlidesHost = {\n\taddSlide: (options?: AddSlideProps) => Slide\n\tpresLayout: PresLayout\n}\n\n/**\n * The whole DOM surface `genTableToSlides` needs: the table element, and a way to read a\n * cell's computed style.\n *\n * Resolving this once up front is what decouples the flow from `window`/`document`. Given the\n * element itself, both halves come from the element's own `ownerDocument`/`defaultView`, so no\n * global is read at all — which is what lets the same implementation run outside a browser.\n */\ntype DomContext = {\n\ttable: Element\n\tgetComputedStyle: (el: Element) => CSSStyleDeclaration\n}\n\n/**\n * Stand-in for `getComputedStyle` on a document that has no view — a document produced by\n * parsing rather than by a browsing context has a `null` `defaultView` and therefore no\n * cascade to compute against. Every property reads as `''`, which every consumer below\n * already treats as \"not set\", so styling degrades to defaults instead of throwing.\n */\nconst NO_COMPUTED_STYLE = {\n\tgetPropertyValue: () => '',\n} as unknown as CSSStyleDeclaration\n\n/**\n * Bind a style reader to the document's own view, falling back to {@link NO_COMPUTED_STYLE}.\n * @param {Document | null} doc - the table's owner document\n * @returns {(el: Element) => CSSStyleDeclaration} computed-style reader\n */\nfunction resolveStyleReader(doc: Document | null): (el: Element) => CSSStyleDeclaration {\n\tconst view = doc?.defaultView\n\treturn view ? view.getComputedStyle.bind(view) : () => NO_COMPUTED_STYLE\n}\n\n/**\n * Resolve the table element and its style reader from whatever the caller passed.\n *\n * An **element** needs no ambient DOM: the document and its view are reached through\n * `ownerDocument`/`defaultView`. A **string id** does need one, taken from `options.document`\n * when supplied and otherwise from `globalThis.document`; with neither, the error names both\n * remedies rather than surfacing a bare `document is not defined`.\n *\n * This is the one place the public structural element type ({@link TableToSlidesElement},\n * which any DOM satisfies) is narrowed to `lib.dom`'s `Element`, so the rest of the flow can\n * be written against ordinary DOM types. The cast is safe in the only sense that matters here:\n * everything downstream reads standard members and tolerates them being absent — that is what\n * makes the conversion portable in the first place.\n * @param {TableToSlidesElement | string} target - the table element, or the id of one\n * @param {TableToSlidesProps} options - generation options (may carry an explicit `document`)\n * @returns {DomContext} resolved DOM context\n */\nfunction resolveDomContext(target: TableToSlidesElement | string, options: TableToSlidesProps): DomContext {\n\tconst asElement = (element: TableToSlidesElement): Element => element as unknown as Element\n\n\tif (typeof target !== 'string') {\n\t\tconst table = asElement(target)\n\t\treturn { table, getComputedStyle: resolveStyleReader(table.ownerDocument) }\n\t}\n\n\tconst doc = options.document ?? (globalThis as { document?: TableToSlidesDocument }).document\n\tif (!doc) {\n\t\tthrow new InvalidOptionError(\n\t\t\t'html/no-document',\n\t\t\t'tableToSlides: no DOM available to resolve the table id \"' +\n\t\t\t\ttarget +\n\t\t\t\t'\" — pass the <table> element itself, or supply a document via `options.document`.'\n\t\t)\n\t}\n\tconst found = doc.getElementById(target)\n\tif (!found)\n\t\tthrow new InvalidOptionError('html/table-not-found', 'tableToSlides: Table ID \"' + target + '\" does not exist!')\n\tconst table = asElement(found)\n\treturn { table, getComputedStyle: resolveStyleReader(table.ownerDocument) }\n}\n\n// ===== DOM-table helpers (browser path) =====\n// DOM-independent helpers factored out of the browser-only tableToSlides() flow\n// so they can be unit-tested without a rendered page (see AGENTS.md scope note).\n\n/**\n * Convert one 0-255 RGB component to its two-digit hex form.\n *\n * Lives here rather than beside the other color code in `gen/drawingml/color.ts` because\n * `getComputedStyle` colors are the only thing in the package that arrives as RGB\n * components — nothing else in the library calls this.\n * @param {number} c - component color\n * @returns {string} hex string\n */\nfunction componentToHex(c: number): string {\n\tconst hex = c.toString(16)\n\treturn hex.length === 1 ? '0' + hex : hex\n}\n\n/**\n * Converts RGB colors from css selectors to Hex for Presentation colors\n * @param {number} r - red value\n * @param {number} g - green value\n * @param {number} b - blue value\n * @returns {string} XML string\n */\nfunction rgbToHex(r: number, g: number, b: number): string {\n\treturn (componentToHex(r) + componentToHex(g) + componentToHex(b)).toUpperCase()\n}\n\n/**\n * Convert a computed CSS border (width string + color string) from `getComputedStyle` into a\n * pptx `BorderProps`.\n *\n * `StrokeProps.width` is in **points**, so the px magnitude is converted through\n * {@link htmlCssPxToPoints} rather than copied across: a `1px` CSS border is 0.75pt, not 1pt.\n * This was the third read in this file to make that mistake and the last one left — the font\n * size and the cell padding were each corrected against `DEFAULT_PX_PER_INCH` on their own, and\n * routing this one through the same converter is what stops a fourth from drifting apart again.\n *\n * Preserves *fractional* widths: a hairline CSS border such as `0.5px` must not be rounded to\n * `0pt` and silently vanish — the table serializer (`ptsToEmuLenient`) emits fractional points just\n * fine, so there is no reason to integer-round here. A\n * computed width of `0` (or a non-finite value) yields `{ type: 'none' }` so we never emit a\n * zero-width line. `''`, `auto` and `3em` are non-finite for the same reason\n * {@link parseCssPx} says they are, and take the same exit.\n * @param {string} widthStr - computed `border-<side>-width`, e.g. `\"0.5px\"`\n * @param {string} colorStr - computed `border-<side>-color`, e.g. `\"rgb(102, 102, 102)\"`\n * @returns {BorderProps} border props for the cell side\n */\nexport function htmlBorderToProps(widthStr: string, colorStr: string): BorderProps {\n\tconst pt = htmlCssPxToPoints(widthStr)\n\tif (!Number.isFinite(pt) || pt <= 0) return { type: 'none' }\n\treturn { width: pt, color: cssColorToHex(colorStr) ?? '000000' }\n}\n\n/**\n * Convert a computed CSS color to a pptx hex color, or report that it has none.\n *\n * A browser normalizes every computed color to `rgb()`/`rgba()`, which is why the flow below\n * originally only parsed that form. Outside a browser there is no normalization step, so a\n * computed color comes back however the stylesheet wrote it — `#ff0000` is what happy-dom\n * returns. Feeding that to the `rgb()` parser produced `Number('#ff0000')` → `NaN` → the\n * literal color string `\"NANNANNAN\"`, an invalid value emitted without complaint.\n *\n * Handles `rgb()`/`rgba()` and `#rgb`/`#rrggbb`. Everything else — a named color, a `color()`\n * function, an empty string — returns `undefined` rather than a guess, so the caller can\n * apply its own default instead of emitting nonsense.\n *\n * A fully transparent color (`alpha === 0`) also returns `undefined`: it states the absence of\n * a color, and pptx has no way to say \"transparent\" in a solid fill.\n * @param {string | null | undefined} value - computed CSS color, e.g. `\"rgb(255, 0, 0)\"` or `\"#ff0000\"`; nullish reads as absent\n * @returns {string | undefined} six-digit uppercase hex, or `undefined` when unparseable\n */\nexport function cssColorToHex(value: string | null | undefined): string | undefined {\n\tconst raw = String(value ?? '').trim()\n\n\tconst rgbMatch = /^rgba?\\(([^)]*)\\)$/i.exec(raw)\n\tif (rgbMatch) {\n\t\tconst parts = (rgbMatch[1] ?? '').split(/[,/\\s]+/).filter((part) => part.length > 0)\n\t\tif (parts.length < 3) return undefined\n\t\tconst channels = parts.slice(0, 3).map((part) => Number(part.replace('%', '')))\n\t\tif (channels.some((channel) => !Number.isFinite(channel))) return undefined\n\t\tif (parts.length > 3 && Number(parts[3]) === 0) return undefined\n\t\t// Clamp and round before hex conversion: a browser always computes whole 0-255\n\t\t// channels, but nothing guarantees another DOM does, and `(255.5).toString(16)`\n\t\t// is `\"ff.8\"` — a malformed color rather than a wrong one.\n\t\tconst [r = 0, g = 0, b = 0] = channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))))\n\t\treturn rgbToHex(r, g, b)\n\t}\n\n\tconst hexMatch = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(raw)\n\tif (hexMatch) {\n\t\tconst digits = hexMatch[1] ?? ''\n\t\tconst full =\n\t\t\tdigits.length === 3\n\t\t\t\t? digits\n\t\t\t\t\t\t.split('')\n\t\t\t\t\t\t.map((digit) => digit + digit)\n\t\t\t\t\t\t.join('')\n\t\t\t\t: digits\n\t\treturn full.toUpperCase()\n\t}\n\n\treturn undefined\n}\n\n/**\n * Resolve a single HTML-table column width for `tableToSlides`.\n *\n * Precedence: an explicit `data-pptx-width` wins outright; otherwise the proportional width\n * derived from the live table is used, raised to `data-pptx-min-width` when that floor is larger.\n *\n * Hidden tables report `offsetWidth` 0 for every cell, which makes `calcWidth` non-finite (a 0/0\n * proportional calc). Fall back to `0` there so an explicit `data-pptx-width` / `data-pptx-min-width`\n * override still drives the column instead of emitting a `NaN` width.\n * @param {number} calcWidth - proportional width derived from `offsetWidth` (may be `NaN` for hidden tables)\n * @param {number} setWidth - `data-pptx-width` override (`0`/`NaN` when absent or invalid)\n * @param {number} minWidth - `data-pptx-min-width` floor (`0`/`NaN` when absent or invalid)\n * @returns {number} resolved column width\n */\nexport function resolveHtmlColWidth(calcWidth: number, setWidth: number, minWidth: number): number {\n\tconst safeCalc = Number.isFinite(calcWidth) ? calcWidth : 0\n\tif (Number.isFinite(setWidth) && setWidth > 0) return setWidth\n\treturn Number.isFinite(minWidth) && minWidth > safeCalc ? minWidth : safeCalc\n}\n\n/** A CSS value that is a bare number, or a number with a `px`/`%` unit. Nothing else parses. */\nconst CSS_LENGTH = /^\\s*(-?(?:\\d+\\.?\\d*|\\.\\d+))\\s*(px|%)?\\s*$/i\n\n/**\n * Parse a single computed CSS length in **px** to its numeric magnitude.\n *\n * A bare number is read as px (computed styles do not emit one, but an inline `style` read\n * back by a non-browser DOM can). Everything else — `''`, `auto`, `3em`, and deliberately\n * `30%` — is `NaN`: a percentage is meaningful only relative to something, so it cannot be\n * turned into an absolute length here. (Percentages *are* usable as a proportional column\n * basis; that is {@link parseCssWidthBasis}'s job, not this one's.) Callers decide what a\n * `NaN` means for them.\n * @param {string | null | undefined} value - computed CSS value, e.g. `\"1.5px\"`; nullish reads as absent\n * @returns {number} magnitude in px, or `NaN` when the value is not an absolute px length\n */\nexport function parseCssPx(value: string | null | undefined): number {\n\tconst match = CSS_LENGTH.exec(String(value ?? ''))\n\tif (!match || match[2] === '%') return NaN\n\treturn Number(match[1])\n}\n\n/**\n * A computed CSS px length as the points every `pt`-measured table property is in, or `NaN` when\n * the value is not an absolute px length.\n *\n * This is the file's **one** px→pt conversion, and it is one because the same mistake was made\n * three separate times under the same stale \"px to pt 1:1\" note. A default `16px` cell emitted\n * `sz=\"1600\"` — 16pt, a third larger than the 12pt the browser rendered; the cell padding read\n * a px magnitude as the inches `TableCellProps.margin` wants, until 2026-07-31; and a `1px`\n * border was emitted as 1pt, a third too thick. Each was found and corrected on its own, and\n * the next went on being wrong, because there was no shared converter for a sweep to land on.\n * Now there is, for the two properties measured in points. The padding is not one of them --\n * it resolves to inches -- so it divides by `DEFAULT_PX_PER_INCH` at its own site and this\n * comment is the link between them.\n *\n * CSS defines the reference pixel as 1/96in, so the conversion is the same density the `\"<n>px\"`\n * coordinate unit uses. An `em`, a `%` or a keyword has no absolute size here and comes back\n * `NaN`, which each caller reads as its own kind of absence — the font size is left off the\n * cell, and a border becomes `{ type: 'none' }`.\n * @param value - computed CSS value, e.g. `\"16px\"`\n * @returns the length in points, or `NaN` when the value is not an absolute px length\n */\nfunction htmlCssPxToPoints(value: string): number {\n\treturn (parseCssPx(value) * POINTS_PER_INCH) / DEFAULT_PX_PER_INCH\n}\n\n/**\n * Parse a whole row of computed CSS widths into a column basis, or reject the set.\n *\n * The result is only ever used *proportionally* (each column's share of the total), so the\n * unit does not have to be absolute — it only has to be the same for every column. Hence:\n *\n * - all `px` (or bare numbers) → their magnitudes\n * - all `%` → their magnitudes; `[25%, 25%, 50%]` is a perfectly good 1:1:2 basis\n * - anything else, or a **mix** of units, or a single unparseable entry (`auto`, `''`,\n *   `3em`) → `[]`, meaning \"no usable basis\"\n *\n * Rejecting the whole set on one bad entry is deliberate: a partial basis would silently\n * give the unparseable columns zero width, which is worse than falling back to an equal\n * split. Negative magnitudes reject for the same reason.\n * @param {readonly string[]} values - computed `width` per column, in column order\n * @returns {number[]} per-column basis, or `[]` when the set is not usable\n */\nexport function parseCssWidthBasis(values: readonly string[]): number[] {\n\tconst basis: number[] = []\n\tlet unit = ''\n\tfor (const value of values) {\n\t\tconst match = CSS_LENGTH.exec(String(value ?? ''))\n\t\tif (!match) return []\n\t\tconst magnitude = Number(match[1])\n\t\tif (!Number.isFinite(magnitude) || magnitude < 0) return []\n\t\tconst valueUnit = (match[2] ?? 'px').toLowerCase()\n\t\tif (!unit) unit = valueUnit\n\t\telse if (unit !== valueUnit) return []\n\t\tbasis.push(magnitude)\n\t}\n\treturn basis\n}\n\n/**\n * Choose which vector the proportional column math runs on, falling back as bases run out.\n *\n * `offsetWidth` is the ideal basis — it is the width the table actually rendered at — but it\n * requires a layout engine, and reports `0` for every cell both in a hidden table and on any\n * DOM outside a browser. So:\n *\n * 1. **measured** (`offsetWidth`) when it carries any width at all — the browser path, unchanged\n * 2. **CSS widths** when the stylesheet states them (see {@link parseCssWidthBasis})\n * 3. **equal split** otherwise — a basis of all-ones, which the existing proportional math\n *    turns into equal columns for free\n *\n * Only the basis changes; `data-pptx-width` / `data-pptx-min-width` overrides still apply\n * downstream via {@link resolveHtmlColWidth} and still win outright.\n *\n * **The first two bases do not measure the same box, and the docs used to imply they did.**\n * `offsetWidth` is the border box; a computed `width` is the content box. Padding alone\n * separates them — `test/browser/harness/table.html` is built so it does, giving 1:1 measured\n * against 2:1 from CSS on one table — so choosing arm 2 over arm 1 can change a table's column\n * *proportions*, not just their precision. That is why the fixture discriminates at all, and why\n * \"degrades to computed CSS\" was the wrong word for it everywhere it appeared.\n *\n * Left as-is rather than reconciled. Normalizing arm 2 to the border box would need the computed\n * padding and border widths, which the DOMs that reach arm 2 need not resolve either (a `%`\n * padding computes to nothing usable without layout), so it would converge the two only\n * sometimes — and it would collapse the one discriminator the browser lane has, turning\n * `table-widths.spec.ts` back into a test that passes whether or not the measured arm ran.\n * A caller who needs both runtimes to agree on a column states it with `data-pptx-width`.\n * @param {readonly number[]} measured - per-column `offsetWidth`\n * @param {readonly number[]} cssWidths - per-column CSS width basis (`[]` when unusable)\n * @returns {number[]} the basis vector to run the proportional calc on\n */\nexport function pickColWidthBasis(measured: readonly number[], cssWidths: readonly number[]): number[] {\n\tconst sum = (arr: readonly number[]): number => arr.reduce((acc, n) => acc + (Number.isFinite(n) ? n : 0), 0)\n\tif (sum(measured) > 0) return [...measured]\n\tif (cssWidths.length === measured.length && sum(cssWidths) > 0) return [...cssWidths]\n\treturn measured.map(() => 1)\n}\n\n/** One cell's span attributes, as far as the grid walk cares. */\ntype GridCellSpans = { colspan?: number; rowspan?: number }\n\n/**\n * Read a `colspan`/`rowspan` as the number of grid tracks it covers.\n *\n * Lenient on purpose: `0`, a negative, a fraction, an unparseable attribute and an absent one all\n * mean `1`. A bad span attribute should cost its own cell nothing and the rest of the grid nothing\n * — the alternative, propagating a `NaN` or a negative into the column walk, shifts every\n * subsequent column.\n * @param {unknown} value - the raw attribute value\n * @returns {number} tracks covered, at least 1\n */\nfunction gridSpan(value: unknown, kind: 'colspan' | 'rowspan'): number {\n\tconst num = Math.floor(Number(value))\n\tif (!Number.isFinite(num) || num <= 1) return 1\n\t// Past `MAX_TABLE_SPAN` is not lenient ground: `resolveSpan` reports it and reads 1, the value\n\t// the pager's own span check would set. Without this ceiling the grid was measured and padded\n\t// for `colspan=\"1500\"` while the same cell was paged and written as one column wide.\n\treturn num > MAX_TABLE_SPAN ? resolveSpan(num, kind) : num\n}\n\n/**\n * Measure the column grid a set of table rows actually occupies.\n *\n * An HTML table is not a rectangle of cells — a row states only the cells it *starts*, so its\n * length says nothing about how many grid columns it fills: a `colspan` fills several, and a\n * `rowspan` started higher up fills one without the row mentioning it. The pptx side has no such\n * model: `<a:tblGrid>` declares N columns and every `<a:tr>` must carry N `<a:tc>`. Something has\n * to translate, and that is a walk of the standard HTML table model — cells pack left to right,\n * skipping columns still held by a rowspan above.\n *\n * Returns the grid width and, per row, how many columns that row reaches. The difference between\n * the two is exactly the padding a ragged row needs; the merge cells for `colspan`/`rowspan` are\n * *not* padding — the table emitter synthesizes those itself, so they are counted as filled here.\n *\n * Spans are read through {@link gridSpan}, so a bad attribute cannot shift the whole grid. The\n * occupancy bookkeeping underneath is {@link createRowSpanOccupancy}, shared with\n * `walkTableGrid` -- the same rowspan rule, asked a different question: that one places authored\n * cells into a grid whose width is already declared, this one measures how wide the grid *is*.\n * @param {readonly (readonly GridCellSpans[])[]} rows - per-row cell spans, in emission order\n * @returns {{ columns: number, filled: number[] }} grid width, and columns reached per row\n */\nexport function measureGridColumns(rows: readonly (readonly GridCellSpans[])[]): { columns: number; filled: number[] } {\n\tconst occupancy = createRowSpanOccupancy()\n\tconst filled: number[] = []\n\n\tfor (const row of rows) {\n\t\tlet col = 0\n\t\tfor (const cell of row) {\n\t\t\tcol = occupancy.nextFree(col)\n\t\t\tconst colspan = gridSpan(cell?.colspan, 'colspan')\n\t\t\t// Held now, aged at the end of this row, so it leaves `rowspan - 1` behind.\n\t\t\toccupancy.hold(col, colspan, gridSpan(cell?.rowspan, 'rowspan'))\n\t\t\tcol += colspan\n\t\t}\n\t\t// Trailing columns held from above count too: a row whose last cells are all rowspan\n\t\t// continuations reaches past its own final cell.\n\t\tfilled.push(occupancy.nextFree(col))\n\t\toccupancy.endRow()\n\t}\n\n\treturn { columns: filled.reduce((max, reached) => (reached > max ? reached : max), 0), filled }\n}\n\n/**\n * Widen a column-width basis to cover a grid wider than the row it was derived from.\n *\n * The basis comes from one row — the first with cells — but the grid is as wide as the *widest*\n * row, and those need not agree (a single spanning header over a wider body is the common shape).\n * The columns the source row never described get the average of the ones it did, so they read as\n * ordinary columns rather than as a zero-width sliver; with no usable basis at all they get `1`,\n * which the proportional calc downstream turns into an equal split.\n * @param {readonly number[]} basis - per-column basis derived from the width-source row\n * @param {number} columns - the full grid width\n * @returns {number[]} basis covering every grid column\n */\nexport function extendColBasis(basis: readonly number[], columns: number): number[] {\n\tconst extended = [...basis]\n\tconst total = extended.reduce((acc, width) => acc + (Number.isFinite(width) ? width : 0), 0)\n\tconst share = extended.length > 0 && total > 0 ? total / extended.length : 1\n\twhile (extended.length < columns) extended.push(share)\n\treturn extended\n}\n\n/**\n * The minimum a cell has to look like for {@link readCellText}. Any DOM's element satisfies it;\n * stating it structurally is what lets the fallback walk be unit-tested without a DOM at all.\n */\ntype TextCell = {\n\tinnerText?: string\n\tnodeType?: number\n\tnodeValue?: string | null\n\tnodeName?: string\n\tchildNodes?: ArrayLike<TextCell>\n}\n\n/**\n * Read a cell's text, with `<br>` surviving as a newline.\n *\n * `innerText` is the right answer in a browser — it is the *rendered* text, so it already\n * collapses whitespace, honors `display: none`, and turns `<br>` into `\"\\n\"`. But it is an\n * HTML-spec extra tied to rendering, and outside a browser it is either absent (jsdom does not\n * implement it, so every cell would come out empty) or present but not actually rendered\n * (happy-dom returns `\"ab\"` for `a<br>b`, so every cell would come out on one line).\n *\n * So both are computed and the better one wins: a `childNodes` walk that maps `<br>` to a line\n * break and collapses whitespace per line, and `innerText`. `innerText` is preferred unless it\n * dropped a line break the walk found — the one thing that provably makes it not the rendered\n * text. Neither can know about `text-transform` without a browser.\n * @param {TextCell} cell - the table cell element\n * @returns {string} cell text, `<br>`-separated lines joined by `\"\\n\"`\n */\nexport function readCellText(cell: TextCell): string {\n\t// Accumulate one bucket per line rather than one string with \"\\n\" separators: the source's\n\t// own indentation contains newlines, and only a `<br>` may actually start a new line. A\n\t// separator character could not tell those two apart; separate buckets never have to.\n\tconst lines: string[] = ['']\n\tconst append = (text: string): void => {\n\t\tlines[lines.length - 1] = (lines[lines.length - 1] ?? '') + text\n\t}\n\tconst walk = (node: TextCell): void => {\n\t\tif (node.nodeType === 3) {\n\t\t\tappend(node.nodeValue ?? '')\n\t\t\treturn\n\t\t}\n\t\tif (node.nodeType !== 1) return\n\t\tif ((node.nodeName ?? '').toUpperCase() === 'BR') {\n\t\t\tlines.push('')\n\t\t\treturn\n\t\t}\n\t\tconst children = node.childNodes\n\t\tfor (let idx = 0; idx < (children?.length ?? 0); idx++) {\n\t\t\tconst child = children?.[idx]\n\t\t\tif (child) walk(child)\n\t\t}\n\t}\n\n\t// Walk from the cell's children: the cell itself is an element, and can never be a BR.\n\tconst children = cell.childNodes\n\tfor (let idx = 0; idx < (children?.length ?? 0); idx++) {\n\t\tconst child = children?.[idx]\n\t\tif (child) walk(child)\n\t}\n\tconst walked = lines.map((line) => line.replace(/\\s+/g, ' ').trim()).join('\\n')\n\n\t// Prefer `innerText` — except when the walk found line breaks it dropped. A DOM that does\n\t// not render can still expose an `innerText` property that is really just `textContent`\n\t// (happy-dom returns `\"ab\"` for `a<br>b`), and that one is not the rendered text this\n\t// wants: it has silently lost the cell's line structure. Where it kept the breaks, it is\n\t// the better answer, because it also knows about `display:none` and `text-transform`.\n\tconst rendered = cell.innerText\n\tif (typeof rendered !== 'string') return walked\n\treturn walked.includes('\\n') && !rendered.includes('\\n') ? walked : rendered\n}\n\n// ===== Live-DOM tableToSlides() flow =====\n// Browser-only entry (reads a rendered table via getComputedStyle/offsetWidth);\n// out of active scope — see AGENTS.md. Internally signposted by `// STEP 1..5`.\n\n/**\n * Resolve `options.masterTitle` to the slide layout it names, so the auto-pager can take that\n * master's margins.\n *\n * The layout registry is a presentation *internal* — it is not on {@link TableToSlidesHost},\n * and the public `slideLayouts` getter deliberately hides the `_name` this matches on. Rather\n * than widen either, read it defensively: a host that has no registry simply resolves no\n * master, which is what a caller passing a bare `{ addSlide, presLayout }` object should get.\n * The alternative — dropping the lookup on the free-function path — would make `masterTitle`\n * silently do nothing there, which is a trap.\n * @param {TableToSlidesHost} pptx - the presentation the slides are being added to\n * @param {string} masterTitle - the `title` passed to `defineSlideMaster`\n * @returns {SlideLayoutInternal | undefined} the named layout, if this host has one\n */\nfunction resolveMasterSlide(pptx: TableToSlidesHost, masterTitle?: string): SlideLayoutInternal | undefined {\n\tif (!masterTitle) return undefined\n\tconst layouts = (pptx as { _slideLayouts?: SlideLayoutInternal[] })._slideLayouts\n\tif (!Array.isArray(layouts)) return undefined\n\treturn layouts.find((layout) => layout._name === masterTitle)\n}\n\n/** Which of the three logical sections a row belongs to. A section-less row counts as body. */\ntype TablePart = 'thead' | 'tbody' | 'tfoot'\n\n/**\n * A row's cells, via `HTMLTableRowElement.cells`.\n *\n * Read off the structural shape rather than the `lib.dom` type so a DOM that does not implement\n * the collection degrades to \"this row has no cells\" instead of throwing — the same tolerance\n * every other DOM read in this file has.\n * @param {Element} row - a `<tr>`\n * @returns {HTMLTableCellElement[]} the row's cells, in document order\n */\nfunction rowCells(row: Element): HTMLTableCellElement[] {\n\tconst cells = (row as { cells?: ArrayLike<Element> }).cells\n\treturn cells ? (Array.from(cells) as HTMLTableCellElement[]) : []\n}\n\n/**\n * Collect every row of the table, bucketed head → body → foot.\n *\n * `HTMLTableElement.rows` is the right source and a `thead tr`/`tbody tr`/`tfoot tr` query is not,\n * for two reasons the query cannot fix:\n *\n * - **A row need not be in a section.** `<table><tr>…` is valid authored markup, and a table built\n *   with `createElement`/`appendChild` has no `<tbody>` at all — the HTML *parser* inserts one, the\n *   DOM API does not. Those rows matched none of the three selectors and were silently dropped,\n *   which is how a perfectly good table reached `addTable` with zero rows and threw\n *   `addTable: Array expected!` (upstream gitbrent/PptxGenJS#1005).\n * - **A descendant query reaches into nested tables.** `tbody tr` matches the rows of a table\n *   inside a cell of this one, folding them into the outer table as extra rows.\n *\n * Each row's own parentage settles both questions: it names the section the row belongs to (the\n * head/body/foot split still matters downstream, for repeating header rows on auto-paged slides),\n * and it says whether the row is this table's at all. The ownership check is not redundant with\n * using `rows` — happy-dom's `rows` is itself a descendant walk, so a nested table's rows arrive\n * there too. Checking is what makes the answer the same on every DOM.\n * @param {Element} table - the `<table>` being converted\n * @returns {Array<{ row: Element, part: TablePart }>} rows in emission order\n */\nfunction collectTableRows(table: Element): Array<{ row: Element; part: TablePart }> {\n\tconst head: Array<{ row: Element; part: TablePart }> = []\n\tconst body: Array<{ row: Element; part: TablePart }> = []\n\tconst foot: Array<{ row: Element; part: TablePart }> = []\n\tconst place = (row: Element): void => {\n\t\tconst parent = row.parentElement\n\t\tconst section = (parent?.nodeName ?? '').toUpperCase()\n\t\tconst sectioned = section === 'THEAD' || section === 'TBODY' || section === 'TFOOT'\n\t\tif ((sectioned ? parent?.parentElement : parent) !== table) return\n\t\tif (section === 'THEAD') head.push({ row, part: 'thead' })\n\t\telse if (section === 'TFOOT') foot.push({ row, part: 'tfoot' })\n\t\telse body.push({ row, part: 'tbody' })\n\t}\n\n\tconst rows = (table as { rows?: ArrayLike<Element> }).rows\n\tif (rows) {\n\t\tfor (let idx = 0; idx < rows.length; idx++) {\n\t\t\tconst row = rows[idx]\n\t\t\tif (row) place(row)\n\t\t}\n\t} else {\n\t\t// A DOM without `rows` is not one this library has ever run on, but the section query is\n\t\t// still a truthful fallback for the sectioned tables it can see.\n\t\tfor (const part of ['thead', 'tbody', 'tfoot']) {\n\t\t\ttable.querySelectorAll(`${part} tr`).forEach(place)\n\t\t}\n\t}\n\n\treturn [...head, ...body, ...foot]\n}\n\n/**\n * Reproduces an HTML table as a PowerPoint table - including column widths, style, etc. - creates 1 or more slides as needed\n * @param {TableToSlidesHost} pptx - pptx-ts instance\n * @param {TableToSlidesElement | string} target - the table element, or the HTMLElementID of the table\n * @param {TableToSlidesProps} options - array of options (e.g.: tabsize)\n */\nexport function genTableToSlides(\n\tpptx: TableToSlidesHost,\n\ttarget: TableToSlidesElement | string,\n\toptions: TableToSlidesProps = {}\n): void {\n\t// Own the options before touching them, the way `addTextDefinition`, `addShapeDefinition`\n\t// and `addTableDefinition` each do. This function resolves the slide margin, the column\n\t// widths, the head rows and the per-page `y` into its working bag; writing those into the\n\t// caller's object made a reused bag change the next call's output — most visibly `y`, left\n\t// holding the continuation start, so the second call's first table began where the first\n\t// call's *second* page did.\n\tconst opts: TableToSlidesPropsInternal = { ...options }\n\tconst masterSlide = resolveMasterSlide(pptx, opts.masterTitle)\n\tconst arrObjTabHeadRows: TableCellInternal[][] = []\n\tconst arrObjTabBodyRows: TableCellInternal[][] = []\n\tconst arrObjTabFootRows: TableCellInternal[][] = []\n\tconst arrColW: number[] = []\n\tconst arrTabColW: number[] = []\n\tconst arrTabColCssW: string[] = []\n\tlet arrInchMargins: [number, number, number, number] = [0.5, 0.5, 0.5, 0.5] // TRBL-style\n\tlet intTabW = 0\n\n\t// REALITY-CHECK: resolve the table (and its style reader) before anything else — this is\n\t// also where a missing/unresolvable table id fails.\n\tconst ctx = resolveDomContext(target, opts)\n\n\t// STEP 1: Set margins. The caller's `slideMargin` is passed as given, absent included:\n\t// `resolveSlideMarginsInches` owns the caller/master/default tiers, and substituting 0.5\n\t// for an unstated one here made every deck look like it had asked for the default margin,\n\t// which outranks and so suppresses the master's own.\n\tarrInchMargins = resolveSlideMarginsInches(masterSlide?._margin, opts.slideMargin)\n\t// A stated `w` is the table's width, as given. Otherwise the table runs from its own left edge to\n\t// the right slide margin: `usableTableWidthEmu`, the reading `addTable` applies. This took the\n\t// slide width (or `w`) less BOTH margins, so it ignored `x` -- `{ x: 3 }` on a 10in slide was\n\t// 9in wide and ran to 12in -- and shrank a stated `w: 8` to 7in.\n\tconst tableXEmu =\n\t\topts.x === undefined || opts.x === null\n\t\t\t? inch2Emu(arrInchMargins[3])\n\t\t\t: getSmartParseNumber(opts.x, 'X', pptx.presLayout)\n\tconst emuSlideTabW =\n\t\topts.w === undefined || opts.w === null\n\t\t\t? usableTableWidthEmu(pptx.presLayout, tableXEmu, arrInchMargins)\n\t\t\t: getSmartParseNumber(opts.w, 'X', pptx.presLayout)\n\n\tif (opts.verbose) {\n\t\tconsole.log('[[VERBOSE MODE]]')\n\t\tconsole.log('|-- `tableToSlides` ----------------------------------------------------|')\n\t\tconsole.log(`| tableProps.h .................................... = ${opts.h}`)\n\t\tconsole.log(`| tableProps.w .................................... = ${opts.w}`)\n\t\tconsole.log(\n\t\t\t`| pptx.presLayout.width ........................... = ${(pptx.presLayout.width / EMU_PER_INCH).toFixed(1)}`\n\t\t)\n\t\tconsole.log(\n\t\t\t`| pptx.presLayout.height .......................... = ${(pptx.presLayout.height / EMU_PER_INCH).toFixed(1)}`\n\t\t)\n\t\tconsole.log(`| emuSlideTabW .................................... = ${(emuSlideTabW / EMU_PER_INCH).toFixed(1)}`)\n\t}\n\n\t// STEP 2: Resolve the rows and the grid they occupy, then take the column widths from the\n\t// first row that has any cells (others may have colspans, who cares, we only need col widths from 1).\n\t// Two bases are collected in the same pass: the rendered `offsetWidth` (what a browser\n\t// reports) and the computed CSS `width` (the only width statement available where nothing\n\t// laid the table out). `pickColWidthBasis` decides which one STEP 3 runs on.\n\tconst domRows = collectTableRows(ctx.table)\n\t// Each cell's spans, read once per conversion. The grid measure, the column widths and the cell\n\t// options all need them, and reading the attributes once is what makes those three agree and\n\t// reports a span past the ceiling once rather than once per reader.\n\tconst spansByCell = new Map<Element, { colspan: number; rowspan: number }>()\n\tconst spansOf = (cell: Element): { colspan: number; rowspan: number } => {\n\t\tlet spans = spansByCell.get(cell)\n\t\tif (!spans) {\n\t\t\tspans = {\n\t\t\t\tcolspan: gridSpan(cell.getAttribute('colspan'), 'colspan'),\n\t\t\t\trowspan: gridSpan(cell.getAttribute('rowspan'), 'rowspan'),\n\t\t\t}\n\t\t\tspansByCell.set(cell, spans)\n\t\t}\n\t\treturn spans\n\t}\n\tconst { columns: intColCnt, filled: arrRowFilled } = measureGridColumns(\n\t\tdomRows.map(({ row }) => rowCells(row).map(spansOf))\n\t)\n\t// A table with no rows — or only empty ones — has nothing to convert. Say so here: the failure\n\t// used to surface far downstream as `Reduce of empty array with no initial value` out of the\n\t// auto-pager, or as `addTable: Array expected!`, neither of which names the table.\n\tconst srcRow = domRows.find(({ row }) => rowCells(row).length > 0)\n\tif (!srcRow) {\n\t\tthrow new InvalidOptionError(\n\t\t\t'html/table-has-no-cells',\n\t\t\t'tableToSlides: the table has no cells to convert - expected at least one <tr> with a <td>/<th>.'\n\t\t)\n\t}\n\n\t// Per grid column, the width-source cell it came from and that cell's colspan. Built here so\n\t// STEP 3 can read a column's overrides off the *right* cell: with a colspan in play, column\n\t// index and cell index part ways, and indexing the row by column silently applied one cell's\n\t// `data-pptx-width` to the next column along (upstream gitbrent/PptxGenJS#1244).\n\tconst arrColSrc: Array<{ cell: HTMLTableCellElement; span: number }> = []\n\tconst arrCellSpans: number[] = []\n\trowCells(srcRow.row).forEach((cell) => {\n\t\tconst offsetW = Number(cell.offsetWidth)\n\t\tconst measured = Number.isFinite(offsetW) ? offsetW : 0\n\t\tarrTabColCssW.push(ctx.getComputedStyle(cell).getPropertyValue('width'))\n\t\t// Guesstimate (divide evenly) col widths across a spanned cell.\n\t\t// NOTE: both j$query and vanilla selectors return {0} when table is not visible)\n\t\tconst span = spansOf(cell).colspan\n\t\tarrCellSpans.push(span)\n\t\tfor (let idxc = 0; idxc < span; idxc++) {\n\t\t\tarrTabColW.push(Math.round(measured / span))\n\t\t\tarrColSrc.push({ cell, span })\n\t\t}\n\t})\n\n\t// The CSS basis is parsed per *cell* (unit uniformity is a property of the row as authored),\n\t// then expanded across each cell's colspan the same way `offsetWidth` is.\n\tconst parsedCellCssW = parseCssWidthBasis(arrTabColCssW)\n\tconst arrCssColW: number[] = []\n\tif (parsedCellCssW.length === arrCellSpans.length) {\n\t\tparsedCellCssW.forEach((cssW, idxC) => {\n\t\t\tconst span = arrCellSpans[idxC] ?? 1\n\t\t\tfor (let idxc = 0; idxc < span; idxc++) arrCssColW.push(cssW / span)\n\t\t})\n\t}\n\n\t// The width-source row can be narrower than the grid (one spanning header over a wider body),\n\t// so widen the basis to the full grid before the proportional calc — that way the calc still\n\t// divides the slide across *every* column instead of overflowing it by the missing ones.\n\tconst arrBasisColW = extendColBasis(pickColWidthBasis(arrTabColW, arrCssColW), intColCnt)\n\tarrBasisColW.forEach((colW) => {\n\t\tintTabW += colW\n\t})\n\n\t// STEP 3: Calc/Set column widths by using same column width percent from HTML table\n\tarrBasisColW.forEach((colW, idxW) => {\n\t\tconst intCalcWidth = Number(((Number(emuSlideTabW) * ((colW / intTabW) * 100)) / 100 / EMU_PER_INCH).toFixed(2))\n\t\t// A `data-pptx-width` on a spanning cell states that *cell's* width, so it divides across\n\t\t// the columns the cell covers — exactly as its `offsetWidth` and its CSS width do above.\n\t\t// A column past the source row's reach has no cell to be overridden by.\n\t\tconst src = arrColSrc[idxW]\n\t\tconst intSetWidth = src ? Number(src.cell.getAttribute('data-pptx-width')) / src.span : 0\n\t\tconst intMinWidth = src ? Number(src.cell.getAttribute('data-pptx-min-width')) / src.span : 0\n\t\tarrColW.push(resolveHtmlColWidth(intCalcWidth, intSetWidth, intMinWidth))\n\t})\n\tif (opts.verbose) {\n\t\tconsole.log(`| arrColW ......................................... = [${arrColW.join(', ')}]`)\n\t}\n\n\t// STEP 4: Iterate over each table element and create data arrays (text and opts)\n\t// NOTE: We create 3 arrays instead of one so we can loop over body then show header/footer rows on first and last page\n\tdomRows.forEach(({ row, part }, idxRow) => {\n\t\tconst arrObjTabCells: TableCellInternal[] = []\n\t\trowCells(row).forEach((cell) => {\n\t\t\t// The computed style is read a dozen times below; resolve it once per cell.\n\t\t\tconst style = ctx.getComputedStyle(cell)\n\n\t\t\t// A: Get text/bkgd colors\n\t\t\t// NOTE: an unparseable or fully transparent background is the default for an\n\t\t\t// unstyled table; pptx has no \"transparent\" solid fill, so use white instead.\n\t\t\tconst textColor = cssColorToHex(style.getPropertyValue('color')) ?? '000000'\n\t\t\tconst fillColor = cssColorToHex(style.getPropertyValue('background-color')) ?? 'FFFFFF'\n\n\t\t\t// B: Create option object\n\t\t\tconst cellOpts: TableCellProps = {\n\t\t\t\tbold: !!(\n\t\t\t\t\tstyle.getPropertyValue('font-weight') === 'bold' || Number(style.getPropertyValue('font-weight')) >= 500\n\t\t\t\t),\n\t\t\t\tcolor: textColor,\n\t\t\t\tfill: { color: fillColor },\n\t\t\t}\n\t\t\t// A relative or keyword font size has no absolute magnitude here, so the key stays off\n\t\t\t// the cell and the size inherits, rather than arriving as `NaN` in `sz`.\n\t\t\tconst fontSizePt = htmlCssPxToPoints(style.getPropertyValue('font-size'))\n\t\t\tif (Number.isFinite(fontSizePt)) cellOpts.fontSize = fontSizePt\n\t\t\tconst fontFace = ((style.getPropertyValue('font-family') || '').split(',')[0] ?? '')\n\t\t\t\t.replace(/\"/g, '')\n\t\t\t\t.replace('inherit', '')\n\t\t\t\t.replace('initial', '')\n\t\t\t// The same spans the grid walk measured, so what is emitted and what was measured cannot\n\t\t\t// disagree: a `colspan=\"-2\"` counted as one column above must not reach the table\n\t\t\t// definition as `-2` and corrupt its own column count.\n\t\t\tconst { colspan, rowspan } = spansOf(cell)\n\t\t\tif (fontFace) cellOpts.fontFace = fontFace\n\t\t\tif (colspan > 1) cellOpts.colspan = colspan\n\t\t\tif (rowspan > 1) cellOpts.rowspan = rowspan\n\n\t\t\t// A CSS value this table has no spelling for leaves the key off rather than writing an\n\t\t\t// `undefined` into it, so the cell keeps whatever alignment it inherits. The guard and\n\t\t\t// the ternary chain they replace could not disagree, but only because every value the\n\t\t\t// guard admitted had an arm — the `: undefined` tail was unreachable, and a sixth CSS\n\t\t\t// value added to one list and not the other would have made it reachable and silent.\n\t\t\tconst align = CSS_TEXT_ALIGN[style.getPropertyValue('text-align')]\n\t\t\tif (align) cellOpts.align = align\n\t\t\tconst valign = CSS_VERTICAL_ALIGN[style.getPropertyValue('vertical-align')]\n\t\t\tif (valign) cellOpts.valign = valign\n\n\t\t\t// C: Add padding [margin] (if any)\n\t\t\t// NOTE: `TableCellProps.margin` is INCHES, so computed px must be converted, not copied.\n\t\t\t// CSS defines the reference pixel as 1/96in, and mirroring what the browser rendered is\n\t\t\t// this conversion's whole job — so resolve at `DEFAULT_PX_PER_INCH`, the same density the\n\t\t\t// `\"<n>px\"` coordinate unit uses. (Until 2026-07-31 the px magnitude was assigned straight\n\t\t\t// through under a stale \"px->pt 1:1\" note left from when cell margin was points; that made\n\t\t\t// a 4px pad a *4 inch* inset and tripped the legacy-points warning on any pad >= 1px.)\n\t\t\t// No rounding to whole px: the browser's computed value can be fractional, and `inch2Emu`\n\t\t\t// already does the one rounding that matters, at EMU precision.\n\t\t\tif (style.getPropertyValue('padding-left')) {\n\t\t\t\tconst cellMargin: MarginTuple = [0, 0, 0, 0]\n\t\t\t\tconst sidesPad = ['padding-top', 'padding-right', 'padding-bottom', 'padding-left']\n\t\t\t\tsidesPad.forEach((val, idxs) => {\n\t\t\t\t\t// Anything that is not an absolute px length (a `%` padding, a keyword) has no\n\t\t\t\t\t// meaning as a fixed inset, so it insets by nothing rather than by its digits.\n\t\t\t\t\tconst pad = parseCssPx(style.getPropertyValue(val))\n\t\t\t\t\tcellMargin[idxs] = Number.isFinite(pad) ? pad / DEFAULT_PX_PER_INCH : 0\n\t\t\t\t})\n\t\t\t\tcellOpts.margin = cellMargin\n\t\t\t}\n\n\t\t\t// D: Add border (if any)\n\t\t\tif (\n\t\t\t\tstyle.getPropertyValue('border-top-width') ||\n\t\t\t\tstyle.getPropertyValue('border-right-width') ||\n\t\t\t\tstyle.getPropertyValue('border-bottom-width') ||\n\t\t\t\tstyle.getPropertyValue('border-left-width')\n\t\t\t) {\n\t\t\t\tconst cellBorder: BorderTuple = [{ type: 'none' }, { type: 'none' }, { type: 'none' }, { type: 'none' }]\n\t\t\t\tconst sidesBor = ['top', 'right', 'bottom', 'left']\n\t\t\t\tsidesBor.forEach((val, idxb) => {\n\t\t\t\t\tcellBorder[idxb] = htmlBorderToProps(\n\t\t\t\t\t\tstyle.getPropertyValue('border-' + val + '-width'),\n\t\t\t\t\t\tstyle.getPropertyValue('border-' + val + '-color')\n\t\t\t\t\t)\n\t\t\t\t})\n\t\t\t\tcellOpts.border = cellBorder\n\t\t\t}\n\n\t\t\t// LAST: Add cell\n\t\t\tarrObjTabCells.push({\n\t\t\t\t_type: SlideObjectType.tablecell,\n\t\t\t\ttext: readCellText(cell), // <br> must survive as \"\\n\", so linebreak etc. work later!\n\t\t\t\toptions: cellOpts,\n\t\t\t})\n\t\t})\n\n\t\t// Normalize a ragged row up to the grid width. HTML tolerates a short row and just leaves\n\t\t// the tail of the grid empty; pptx does not — `<a:tblGrid>` declares the column count and a\n\t\t// row with fewer `<a:tc>` is a malformed table PowerPoint has to repair. The missing cells\n\t\t// are blank rather than a copy of a neighbour: the source table never stated them, so there\n\t\t// is nothing to carry over. Columns held by a `rowspan` from above are already counted as\n\t\t// filled — the table emitter synthesizes those merge cells itself.\n\t\tfor (let idxPad = arrRowFilled[idxRow] ?? 0; idxPad < intColCnt; idxPad++) {\n\t\t\tarrObjTabCells.push({ _type: SlideObjectType.tablecell, text: '', options: {} })\n\t\t}\n\n\t\tif (part === 'thead') arrObjTabHeadRows.push(arrObjTabCells)\n\t\telse if (part === 'tfoot') arrObjTabFootRows.push(arrObjTabCells)\n\t\telse arrObjTabBodyRows.push(arrObjTabCells)\n\t})\n\n\t// STEP 5: Break table into Slides as needed\n\t// Pass head-rows as there is an option to add to each table and the parse func needs this data to fulfill that option\n\topts._arrObjTabHeadRows = arrObjTabHeadRows\n\topts.colW = arrColW\n\tgetSlidesForTableRows(\n\t\t[...arrObjTabHeadRows, ...arrObjTabBodyRows, ...arrObjTabFootRows],\n\t\topts,\n\t\tpptx.presLayout,\n\t\tmasterSlide\n\t).forEach((slide) => {\n\t\t// A: Create new Slide\n\t\tconst newSlide = pptx.addSlide(opts.masterTitle ? { masterTitle: opts.masterTitle } : {})\n\n\t\t// B: DESIGN: Reset `y` to startY or margin after first Slide.\n\t\t// Every page goes where the pager started it when it budgeted the page's height\n\t\t// (`slide.y`). This used to restate that rule, and the copy had drifted three times:\n\t\t// `autoPageSlideStartY: 0` read as unset, a `y` above the top margin was pushed back down,\n\t\t// and a first page stated at `y: 0` was moved down to the margin.\n\t\tif (slide.y !== undefined) opts.y = slide.y\n\t\tif (opts.verbose)\n\t\t\tconsole.log(\n\t\t\t\t`| opts.autoPageSlideStartY: ${opts.autoPageSlideStartY} / arrInchMargins[0]: ${arrInchMargins[0]} => opts.y = ${opts.y}`\n\t\t\t)\n\n\t\t// C: Add table to Slide\n\t\tconst slideTableProps: TableProps = {\n\t\t\t// `??`: a stated `x: 0` is the left edge of the slide, not a missing `x`.\n\t\t\tx: opts.x ?? arrInchMargins[3],\n\t\t\tw: Number(emuSlideTabW) / EMU_PER_INCH,\n\t\t\tcolW: arrColW,\n\t\t\tautoPage: false,\n\t\t}\n\t\t// `y` is set on `opts` a few lines up on every branch, but only where the caller stated one\n\t\t// does it belong on the table's own props — an absent `y` is what lets `addTable` apply its\n\t\t// own default.\n\t\tif (opts.y !== undefined) slideTableProps.y = opts.y\n\t\tnewSlide.addTable(slide.rows, slideTableProps)\n\n\t\t// D: Add any additional objects\n\t\tif (opts.addImage) {\n\t\t\topts.addImage.options = opts.addImage.options || {}\n\t\t\tif (!opts.addImage.image || (!opts.addImage.image.path && !opts.addImage.image.data)) {\n\t\t\t\twarn('html/image-missing-source', 'tableToSlides.addImage requires either `path` or `data`')\n\t\t\t} else {\n\t\t\t\tconst imageProps = opts.addImage.image.path\n\t\t\t\t\t? { path: opts.addImage.image.path }\n\t\t\t\t\t: { data: opts.addImage.image.data as string }\n\t\t\t\t// Geometry is copied only where the caller stated it, so an omitted axis keeps\n\t\t\t\t// `addImage`'s own default rather than arriving as an explicit `undefined`.\n\t\t\t\tconst imageOptions = opts.addImage.options\n\t\t\t\tconst geometry: PositionProps = {}\n\t\t\t\tif (imageOptions.x !== undefined) geometry.x = imageOptions.x\n\t\t\t\tif (imageOptions.y !== undefined) geometry.y = imageOptions.y\n\t\t\t\tif (imageOptions.w !== undefined) geometry.w = imageOptions.w\n\t\t\t\tif (imageOptions.h !== undefined) geometry.h = imageOptions.h\n\t\t\t\tnewSlide.addImage({ ...imageProps, ...geometry })\n\t\t\t}\n\t\t}\n\t\tif (opts.addShape) newSlide.addShape(opts.addShape.shapeName, opts.addShape.options || {})\n\t\tif (opts.addTable) newSlide.addTable(opts.addTable.rows, opts.addTable.options || {})\n\t\tif (opts.addText) newSlide.addText(opts.addText.text, opts.addText.options || {})\n\t})\n}\n"],"mappings":"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"}
+{"version":3,"file":"html-dom-DvJmuHt2.js","names":[],"sources":["../src/gen/table/html-dom.ts"],"sourcesContent":["/**\n * pptx-ts: HTML-table → slides (browser DOM path)\n *\n * The tableToSlides() flow: reproduce an HTML table as a PowerPoint table across as many\n * slides as needed. The DOM-independent parts are factored into pure helpers\n * (`resolveHtmlColWidth`, `pickColWidthBasis`, `htmlBorderToProps`, `cssColorToHex`) that\n * are unit-tested directly, and the whole flow runs anywhere there is a DOM.\n *\n * Only real *measurement* is out of active scope (see `docs/contributing/scope-and-policy.md`): without a layout engine\n * `offsetWidth` is `0`, so widths fall back to computed CSS then to an equal split. A fallback\n * rather than a degradation, and the distinction is load-bearing — see {@link pickColWidthBasis},\n * whose two bases measure different boxes.\n *\n * **Coverage.** This file used to be excluded from the report, on the grounds that only the\n * browser entry imported it and the `dist/browser*.js` globs therefore swallowed it. Both\n * halves of that are stale: `pptx-ts/html` imports it too, so tsdown emits it as its own\n * `dist/html-dom-*.js` chunk, and those globs are gone from `vitest.config.ts` entirely. It\n * is covered code now — against happy-dom by the Node suite\n * (test/regression/html/html-to-slides-node.test.ts) and, for the measured width basis that no\n * Node DOM can produce, in a real Chromium (test/browser/table-widths.spec.ts).\n */\n\nimport { SlideObjectType } from '../../enums.js'\nimport type {\n\tAddSlideProps,\n\tBorderProps,\n\tHAlign,\n\tPositionProps,\n\tPresLayout,\n\tTableProps,\n\tTableToSlidesDocument,\n\tTableToSlidesElement,\n\tTableToSlidesProps,\n\tTableCellProps,\n\tVAlign,\n} from '../../types/index.js'\nimport type { Slide } from '../../types/slide.js'\nimport type { SlideLayoutInternal, TableCellInternal, TableToSlidesPropsInternal } from '../../types/internal.js'\nimport { getSmartParseNumber, inch2Emu, resolveSlideMarginsInches, usableTableWidthEmu } from '../../units-internal.js'\nimport { warn } from '../../diagnostics.js'\nimport { DEFAULT_PX_PER_INCH, EMU_PER_INCH, POINTS_PER_INCH } from '../../units.js'\nimport { createRowSpanOccupancy } from './grid.js'\nimport { MAX_TABLE_SPAN, resolveSpan } from './spans.js'\nimport { getSlidesForTableRows } from './autopage.js'\nimport { InvalidOptionError } from '../../errors.js'\n\n/**\n * CSS `text-align` / `vertical-align` values this converter can express as a table cell's own\n * alignment. The two logical values map onto the physical pair; everything else — `justify`,\n * `initial`, a value the browser did not resolve — is absent here and so leaves the cell's\n * alignment alone.\n */\nconst CSS_TEXT_ALIGN: Record<string, HAlign> = {\n\tleft: 'left',\n\tcenter: 'center',\n\tright: 'right',\n\tstart: 'left',\n\tend: 'right',\n}\nconst CSS_VERTICAL_ALIGN: Record<string, VAlign> = { top: 'top', middle: 'middle', bottom: 'bottom' }\n\ntype MarginTuple = [number, number, number, number]\ntype BorderTuple = [BorderProps, BorderProps, BorderProps, BorderProps]\n/**\n * What `tableToSlides` needs a presentation to be: somewhere to put slides, and a layout to\n * size them against. Structural on purpose — stating the two members rather than naming the\n * class is what lets the free function on `pptx-ts/html` take any presentation instance\n * (Node, browser, or standalone) without the entry importing one.\n */\nexport type TableToSlidesHost = {\n\taddSlide: (options?: AddSlideProps) => Slide\n\tpresLayout: PresLayout\n}\n\n/**\n * The whole DOM surface `genTableToSlides` needs: the table element, and a way to read a\n * cell's computed style.\n *\n * Resolving this once up front is what decouples the flow from `window`/`document`. Given the\n * element itself, both halves come from the element's own `ownerDocument`/`defaultView`, so no\n * global is read at all — which is what lets the same implementation run outside a browser.\n */\ntype DomContext = {\n\ttable: Element\n\tgetComputedStyle: (el: Element) => CSSStyleDeclaration\n}\n\n/**\n * Stand-in for `getComputedStyle` on a document that has no view — a document produced by\n * parsing rather than by a browsing context has a `null` `defaultView` and therefore no\n * cascade to compute against. Every property reads as `''`, which every consumer below\n * already treats as \"not set\", so styling degrades to defaults instead of throwing.\n */\nconst NO_COMPUTED_STYLE = {\n\tgetPropertyValue: () => '',\n} as unknown as CSSStyleDeclaration\n\n/**\n * Bind a style reader to the document's own view, falling back to {@link NO_COMPUTED_STYLE}.\n * @param {Document | null} doc - the table's owner document\n * @returns {(el: Element) => CSSStyleDeclaration} computed-style reader\n */\nfunction resolveStyleReader(doc: Document | null): (el: Element) => CSSStyleDeclaration {\n\tconst view = doc?.defaultView\n\treturn view ? view.getComputedStyle.bind(view) : () => NO_COMPUTED_STYLE\n}\n\n/**\n * Resolve the table element and its style reader from whatever the caller passed.\n *\n * An **element** needs no ambient DOM: the document and its view are reached through\n * `ownerDocument`/`defaultView`. A **string id** does need one, taken from `options.document`\n * when supplied and otherwise from `globalThis.document`; with neither, the error names both\n * remedies rather than surfacing a bare `document is not defined`.\n *\n * This is the one place the public structural element type ({@link TableToSlidesElement},\n * which any DOM satisfies) is narrowed to `lib.dom`'s `Element`, so the rest of the flow can\n * be written against ordinary DOM types. The cast is safe in the only sense that matters here:\n * everything downstream reads standard members and tolerates them being absent — that is what\n * makes the conversion portable in the first place.\n * @param {TableToSlidesElement | string} target - the table element, or the id of one\n * @param {TableToSlidesProps} options - generation options (may carry an explicit `document`)\n * @returns {DomContext} resolved DOM context\n */\nfunction resolveDomContext(target: TableToSlidesElement | string, options: TableToSlidesProps): DomContext {\n\tconst asElement = (element: TableToSlidesElement): Element => element as unknown as Element\n\n\tif (typeof target !== 'string') {\n\t\tconst table = asElement(target)\n\t\treturn { table, getComputedStyle: resolveStyleReader(table.ownerDocument) }\n\t}\n\n\tconst doc = options.document ?? (globalThis as { document?: TableToSlidesDocument }).document\n\tif (!doc) {\n\t\tthrow new InvalidOptionError(\n\t\t\t'html/no-document',\n\t\t\t'tableToSlides: no DOM available to resolve the table id \"' +\n\t\t\t\ttarget +\n\t\t\t\t'\" — pass the <table> element itself, or supply a document via `options.document`.'\n\t\t)\n\t}\n\tconst found = doc.getElementById(target)\n\tif (!found)\n\t\tthrow new InvalidOptionError('html/table-not-found', 'tableToSlides: Table ID \"' + target + '\" does not exist!')\n\tconst table = asElement(found)\n\treturn { table, getComputedStyle: resolveStyleReader(table.ownerDocument) }\n}\n\n// ===== DOM-table helpers (browser path) =====\n// DOM-independent helpers factored out of the browser-only tableToSlides() flow\n// so they can be unit-tested without a rendered page (see the scope policy).\n\n/**\n * Convert one 0-255 RGB component to its two-digit hex form.\n *\n * Lives here rather than beside the other color code in `gen/drawingml/color.ts` because\n * `getComputedStyle` colors are the only thing in the package that arrives as RGB\n * components — nothing else in the library calls this.\n * @param {number} c - component color\n * @returns {string} hex string\n */\nfunction componentToHex(c: number): string {\n\tconst hex = c.toString(16)\n\treturn hex.length === 1 ? '0' + hex : hex\n}\n\n/**\n * Converts RGB colors from css selectors to Hex for Presentation colors\n * @param {number} r - red value\n * @param {number} g - green value\n * @param {number} b - blue value\n * @returns {string} XML string\n */\nfunction rgbToHex(r: number, g: number, b: number): string {\n\treturn (componentToHex(r) + componentToHex(g) + componentToHex(b)).toUpperCase()\n}\n\n/**\n * Convert a computed CSS border (width string + color string) from `getComputedStyle` into a\n * pptx `BorderProps`.\n *\n * `StrokeProps.width` is in **points**, so the px magnitude is converted through\n * {@link htmlCssPxToPoints} rather than copied across: a `1px` CSS border is 0.75pt, not 1pt.\n * This was the third read in this file to make that mistake and the last one left — the font\n * size and the cell padding were each corrected against `DEFAULT_PX_PER_INCH` on their own, and\n * routing this one through the same converter is what stops a fourth from drifting apart again.\n *\n * Preserves *fractional* widths: a hairline CSS border such as `0.5px` must not be rounded to\n * `0pt` and silently vanish — the table serializer (`ptsToEmuLenient`) emits fractional points just\n * fine, so there is no reason to integer-round here. A\n * computed width of `0` (or a non-finite value) yields `{ type: 'none' }` so we never emit a\n * zero-width line. `''`, `auto` and `3em` are non-finite for the same reason\n * {@link parseCssPx} says they are, and take the same exit.\n * @param {string} widthStr - computed `border-<side>-width`, e.g. `\"0.5px\"`\n * @param {string} colorStr - computed `border-<side>-color`, e.g. `\"rgb(102, 102, 102)\"`\n * @returns {BorderProps} border props for the cell side\n */\nexport function htmlBorderToProps(widthStr: string, colorStr: string): BorderProps {\n\tconst pt = htmlCssPxToPoints(widthStr)\n\tif (!Number.isFinite(pt) || pt <= 0) return { type: 'none' }\n\treturn { width: pt, color: cssColorToHex(colorStr) ?? '000000' }\n}\n\n/**\n * Convert a computed CSS color to a pptx hex color, or report that it has none.\n *\n * A browser normalizes every computed color to `rgb()`/`rgba()`, which is why the flow below\n * originally only parsed that form. Outside a browser there is no normalization step, so a\n * computed color comes back however the stylesheet wrote it — `#ff0000` is what happy-dom\n * returns. Feeding that to the `rgb()` parser produced `Number('#ff0000')` → `NaN` → the\n * literal color string `\"NANNANNAN\"`, an invalid value emitted without complaint.\n *\n * Handles `rgb()`/`rgba()` and `#rgb`/`#rrggbb`. Everything else — a named color, a `color()`\n * function, an empty string — returns `undefined` rather than a guess, so the caller can\n * apply its own default instead of emitting nonsense.\n *\n * A fully transparent color (`alpha === 0`) also returns `undefined`: it states the absence of\n * a color, and pptx has no way to say \"transparent\" in a solid fill.\n * @param {string | null | undefined} value - computed CSS color, e.g. `\"rgb(255, 0, 0)\"` or `\"#ff0000\"`; nullish reads as absent\n * @returns {string | undefined} six-digit uppercase hex, or `undefined` when unparseable\n */\nexport function cssColorToHex(value: string | null | undefined): string | undefined {\n\tconst raw = String(value ?? '').trim()\n\n\tconst rgbMatch = /^rgba?\\(([^)]*)\\)$/i.exec(raw)\n\tif (rgbMatch) {\n\t\tconst parts = (rgbMatch[1] ?? '').split(/[,/\\s]+/).filter((part) => part.length > 0)\n\t\tif (parts.length < 3) return undefined\n\t\tconst channels = parts.slice(0, 3).map((part) => Number(part.replace('%', '')))\n\t\tif (channels.some((channel) => !Number.isFinite(channel))) return undefined\n\t\tif (parts.length > 3 && Number(parts[3]) === 0) return undefined\n\t\t// Clamp and round before hex conversion: a browser always computes whole 0-255\n\t\t// channels, but nothing guarantees another DOM does, and `(255.5).toString(16)`\n\t\t// is `\"ff.8\"` — a malformed color rather than a wrong one.\n\t\tconst [r = 0, g = 0, b = 0] = channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))))\n\t\treturn rgbToHex(r, g, b)\n\t}\n\n\tconst hexMatch = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(raw)\n\tif (hexMatch) {\n\t\tconst digits = hexMatch[1] ?? ''\n\t\tconst full =\n\t\t\tdigits.length === 3\n\t\t\t\t? digits\n\t\t\t\t\t\t.split('')\n\t\t\t\t\t\t.map((digit) => digit + digit)\n\t\t\t\t\t\t.join('')\n\t\t\t\t: digits\n\t\treturn full.toUpperCase()\n\t}\n\n\treturn undefined\n}\n\n/**\n * Resolve a single HTML-table column width for `tableToSlides`.\n *\n * Precedence: an explicit `data-pptx-width` wins outright; otherwise the proportional width\n * derived from the live table is used, raised to `data-pptx-min-width` when that floor is larger.\n *\n * Hidden tables report `offsetWidth` 0 for every cell, which makes `calcWidth` non-finite (a 0/0\n * proportional calc). Fall back to `0` there so an explicit `data-pptx-width` / `data-pptx-min-width`\n * override still drives the column instead of emitting a `NaN` width.\n * @param {number} calcWidth - proportional width derived from `offsetWidth` (may be `NaN` for hidden tables)\n * @param {number} setWidth - `data-pptx-width` override (`0`/`NaN` when absent or invalid)\n * @param {number} minWidth - `data-pptx-min-width` floor (`0`/`NaN` when absent or invalid)\n * @returns {number} resolved column width\n */\nexport function resolveHtmlColWidth(calcWidth: number, setWidth: number, minWidth: number): number {\n\tconst safeCalc = Number.isFinite(calcWidth) ? calcWidth : 0\n\tif (Number.isFinite(setWidth) && setWidth > 0) return setWidth\n\treturn Number.isFinite(minWidth) && minWidth > safeCalc ? minWidth : safeCalc\n}\n\n/** A CSS value that is a bare number, or a number with a `px`/`%` unit. Nothing else parses. */\nconst CSS_LENGTH = /^\\s*(-?(?:\\d+\\.?\\d*|\\.\\d+))\\s*(px|%)?\\s*$/i\n\n/**\n * Parse a single computed CSS length in **px** to its numeric magnitude.\n *\n * A bare number is read as px (computed styles do not emit one, but an inline `style` read\n * back by a non-browser DOM can). Everything else — `''`, `auto`, `3em`, and deliberately\n * `30%` — is `NaN`: a percentage is meaningful only relative to something, so it cannot be\n * turned into an absolute length here. (Percentages *are* usable as a proportional column\n * basis; that is {@link parseCssWidthBasis}'s job, not this one's.) Callers decide what a\n * `NaN` means for them.\n * @param {string | null | undefined} value - computed CSS value, e.g. `\"1.5px\"`; nullish reads as absent\n * @returns {number} magnitude in px, or `NaN` when the value is not an absolute px length\n */\nexport function parseCssPx(value: string | null | undefined): number {\n\tconst match = CSS_LENGTH.exec(String(value ?? ''))\n\tif (!match || match[2] === '%') return NaN\n\treturn Number(match[1])\n}\n\n/**\n * A computed CSS px length as the points every `pt`-measured table property is in, or `NaN` when\n * the value is not an absolute px length.\n *\n * This is the file's **one** px→pt conversion, and it is one because the same mistake was made\n * three separate times under the same stale \"px to pt 1:1\" note. A default `16px` cell emitted\n * `sz=\"1600\"` — 16pt, a third larger than the 12pt the browser rendered; the cell padding read\n * a px magnitude as the inches `TableCellProps.margin` wants, until 2026-07-31; and a `1px`\n * border was emitted as 1pt, a third too thick. Each was found and corrected on its own, and\n * the next went on being wrong, because there was no shared converter for a sweep to land on.\n * Now there is, for the two properties measured in points. The padding is not one of them --\n * it resolves to inches -- so it divides by `DEFAULT_PX_PER_INCH` at its own site and this\n * comment is the link between them.\n *\n * CSS defines the reference pixel as 1/96in, so the conversion is the same density the `\"<n>px\"`\n * coordinate unit uses. An `em`, a `%` or a keyword has no absolute size here and comes back\n * `NaN`, which each caller reads as its own kind of absence — the font size is left off the\n * cell, and a border becomes `{ type: 'none' }`.\n * @param value - computed CSS value, e.g. `\"16px\"`\n * @returns the length in points, or `NaN` when the value is not an absolute px length\n */\nfunction htmlCssPxToPoints(value: string): number {\n\treturn (parseCssPx(value) * POINTS_PER_INCH) / DEFAULT_PX_PER_INCH\n}\n\n/**\n * Parse a whole row of computed CSS widths into a column basis, or reject the set.\n *\n * The result is only ever used *proportionally* (each column's share of the total), so the\n * unit does not have to be absolute — it only has to be the same for every column. Hence:\n *\n * - all `px` (or bare numbers) → their magnitudes\n * - all `%` → their magnitudes; `[25%, 25%, 50%]` is a perfectly good 1:1:2 basis\n * - anything else, or a **mix** of units, or a single unparseable entry (`auto`, `''`,\n *   `3em`) → `[]`, meaning \"no usable basis\"\n *\n * Rejecting the whole set on one bad entry is deliberate: a partial basis would silently\n * give the unparseable columns zero width, which is worse than falling back to an equal\n * split. Negative magnitudes reject for the same reason.\n * @param {readonly string[]} values - computed `width` per column, in column order\n * @returns {number[]} per-column basis, or `[]` when the set is not usable\n */\nexport function parseCssWidthBasis(values: readonly string[]): number[] {\n\tconst basis: number[] = []\n\tlet unit = ''\n\tfor (const value of values) {\n\t\tconst match = CSS_LENGTH.exec(String(value ?? ''))\n\t\tif (!match) return []\n\t\tconst magnitude = Number(match[1])\n\t\tif (!Number.isFinite(magnitude) || magnitude < 0) return []\n\t\tconst valueUnit = (match[2] ?? 'px').toLowerCase()\n\t\tif (!unit) unit = valueUnit\n\t\telse if (unit !== valueUnit) return []\n\t\tbasis.push(magnitude)\n\t}\n\treturn basis\n}\n\n/**\n * Choose which vector the proportional column math runs on, falling back as bases run out.\n *\n * `offsetWidth` is the ideal basis — it is the width the table actually rendered at — but it\n * requires a layout engine, and reports `0` for every cell both in a hidden table and on any\n * DOM outside a browser. So:\n *\n * 1. **measured** (`offsetWidth`) when it carries any width at all — the browser path, unchanged\n * 2. **CSS widths** when the stylesheet states them (see {@link parseCssWidthBasis})\n * 3. **equal split** otherwise — a basis of all-ones, which the existing proportional math\n *    turns into equal columns for free\n *\n * Only the basis changes; `data-pptx-width` / `data-pptx-min-width` overrides still apply\n * downstream via {@link resolveHtmlColWidth} and still win outright.\n *\n * **The first two bases do not measure the same box, and the docs used to imply they did.**\n * `offsetWidth` is the border box; a computed `width` is the content box. Padding alone\n * separates them — `test/browser/harness/table.html` is built so it does, giving 1:1 measured\n * against 2:1 from CSS on one table — so choosing arm 2 over arm 1 can change a table's column\n * *proportions*, not just their precision. That is why the fixture discriminates at all, and why\n * \"degrades to computed CSS\" was the wrong word for it everywhere it appeared.\n *\n * Left as-is rather than reconciled. Normalizing arm 2 to the border box would need the computed\n * padding and border widths, which the DOMs that reach arm 2 need not resolve either (a `%`\n * padding computes to nothing usable without layout), so it would converge the two only\n * sometimes — and it would collapse the one discriminator the browser lane has, turning\n * `table-widths.spec.ts` back into a test that passes whether or not the measured arm ran.\n * A caller who needs both runtimes to agree on a column states it with `data-pptx-width`.\n * @param {readonly number[]} measured - per-column `offsetWidth`\n * @param {readonly number[]} cssWidths - per-column CSS width basis (`[]` when unusable)\n * @returns {number[]} the basis vector to run the proportional calc on\n */\nexport function pickColWidthBasis(measured: readonly number[], cssWidths: readonly number[]): number[] {\n\tconst sum = (arr: readonly number[]): number => arr.reduce((acc, n) => acc + (Number.isFinite(n) ? n : 0), 0)\n\tif (sum(measured) > 0) return [...measured]\n\tif (cssWidths.length === measured.length && sum(cssWidths) > 0) return [...cssWidths]\n\treturn measured.map(() => 1)\n}\n\n/** One cell's span attributes, as far as the grid walk cares. */\ntype GridCellSpans = { colspan?: number; rowspan?: number }\n\n/**\n * Read a `colspan`/`rowspan` as the number of grid tracks it covers.\n *\n * Lenient on purpose: `0`, a negative, a fraction, an unparseable attribute and an absent one all\n * mean `1`. A bad span attribute should cost its own cell nothing and the rest of the grid nothing\n * — the alternative, propagating a `NaN` or a negative into the column walk, shifts every\n * subsequent column.\n * @param {unknown} value - the raw attribute value\n * @returns {number} tracks covered, at least 1\n */\nfunction gridSpan(value: unknown, kind: 'colspan' | 'rowspan'): number {\n\tconst num = Math.floor(Number(value))\n\tif (!Number.isFinite(num) || num <= 1) return 1\n\t// Past `MAX_TABLE_SPAN` is not lenient ground: `resolveSpan` reports it and reads 1, the value\n\t// the pager's own span check would set. Without this ceiling the grid was measured and padded\n\t// for `colspan=\"1500\"` while the same cell was paged and written as one column wide.\n\treturn num > MAX_TABLE_SPAN ? resolveSpan(num, kind) : num\n}\n\n/**\n * Measure the column grid a set of table rows actually occupies.\n *\n * An HTML table is not a rectangle of cells — a row states only the cells it *starts*, so its\n * length says nothing about how many grid columns it fills: a `colspan` fills several, and a\n * `rowspan` started higher up fills one without the row mentioning it. The pptx side has no such\n * model: `<a:tblGrid>` declares N columns and every `<a:tr>` must carry N `<a:tc>`. Something has\n * to translate, and that is a walk of the standard HTML table model — cells pack left to right,\n * skipping columns still held by a rowspan above.\n *\n * Returns the grid width and, per row, how many columns that row reaches. The difference between\n * the two is exactly the padding a ragged row needs; the merge cells for `colspan`/`rowspan` are\n * *not* padding — the table emitter synthesizes those itself, so they are counted as filled here.\n *\n * Spans are read through {@link gridSpan}, so a bad attribute cannot shift the whole grid. The\n * occupancy bookkeeping underneath is {@link createRowSpanOccupancy}, shared with\n * `walkTableGrid` -- the same rowspan rule, asked a different question: that one places authored\n * cells into a grid whose width is already declared, this one measures how wide the grid *is*.\n * @param {readonly (readonly GridCellSpans[])[]} rows - per-row cell spans, in emission order\n * @returns {{ columns: number, filled: number[] }} grid width, and columns reached per row\n */\nexport function measureGridColumns(rows: readonly (readonly GridCellSpans[])[]): { columns: number; filled: number[] } {\n\tconst occupancy = createRowSpanOccupancy()\n\tconst filled: number[] = []\n\n\tfor (const row of rows) {\n\t\tlet col = 0\n\t\tfor (const cell of row) {\n\t\t\tcol = occupancy.nextFree(col)\n\t\t\tconst colspan = gridSpan(cell?.colspan, 'colspan')\n\t\t\t// Held now, aged at the end of this row, so it leaves `rowspan - 1` behind.\n\t\t\toccupancy.hold(col, colspan, gridSpan(cell?.rowspan, 'rowspan'))\n\t\t\tcol += colspan\n\t\t}\n\t\t// Trailing columns held from above count too: a row whose last cells are all rowspan\n\t\t// continuations reaches past its own final cell.\n\t\tfilled.push(occupancy.nextFree(col))\n\t\toccupancy.endRow()\n\t}\n\n\treturn { columns: filled.reduce((max, reached) => (reached > max ? reached : max), 0), filled }\n}\n\n/**\n * Widen a column-width basis to cover a grid wider than the row it was derived from.\n *\n * The basis comes from one row — the first with cells — but the grid is as wide as the *widest*\n * row, and those need not agree (a single spanning header over a wider body is the common shape).\n * The columns the source row never described get the average of the ones it did, so they read as\n * ordinary columns rather than as a zero-width sliver; with no usable basis at all they get `1`,\n * which the proportional calc downstream turns into an equal split.\n * @param {readonly number[]} basis - per-column basis derived from the width-source row\n * @param {number} columns - the full grid width\n * @returns {number[]} basis covering every grid column\n */\nexport function extendColBasis(basis: readonly number[], columns: number): number[] {\n\tconst extended = [...basis]\n\tconst total = extended.reduce((acc, width) => acc + (Number.isFinite(width) ? width : 0), 0)\n\tconst share = extended.length > 0 && total > 0 ? total / extended.length : 1\n\twhile (extended.length < columns) extended.push(share)\n\treturn extended\n}\n\n/**\n * The minimum a cell has to look like for {@link readCellText}. Any DOM's element satisfies it;\n * stating it structurally is what lets the fallback walk be unit-tested without a DOM at all.\n */\ntype TextCell = {\n\tinnerText?: string\n\tnodeType?: number\n\tnodeValue?: string | null\n\tnodeName?: string\n\tchildNodes?: ArrayLike<TextCell>\n}\n\n/**\n * Read a cell's text, with `<br>` surviving as a newline.\n *\n * `innerText` is the right answer in a browser — it is the *rendered* text, so it already\n * collapses whitespace, honors `display: none`, and turns `<br>` into `\"\\n\"`. But it is an\n * HTML-spec extra tied to rendering, and outside a browser it is either absent (jsdom does not\n * implement it, so every cell would come out empty) or present but not actually rendered\n * (happy-dom returns `\"ab\"` for `a<br>b`, so every cell would come out on one line).\n *\n * So both are computed and the better one wins: a `childNodes` walk that maps `<br>` to a line\n * break and collapses whitespace per line, and `innerText`. `innerText` is preferred unless it\n * dropped a line break the walk found — the one thing that provably makes it not the rendered\n * text. Neither can know about `text-transform` without a browser.\n * @param {TextCell} cell - the table cell element\n * @returns {string} cell text, `<br>`-separated lines joined by `\"\\n\"`\n */\nexport function readCellText(cell: TextCell): string {\n\t// Accumulate one bucket per line rather than one string with \"\\n\" separators: the source's\n\t// own indentation contains newlines, and only a `<br>` may actually start a new line. A\n\t// separator character could not tell those two apart; separate buckets never have to.\n\tconst lines: string[] = ['']\n\tconst append = (text: string): void => {\n\t\tlines[lines.length - 1] = (lines[lines.length - 1] ?? '') + text\n\t}\n\tconst walk = (node: TextCell): void => {\n\t\tif (node.nodeType === 3) {\n\t\t\tappend(node.nodeValue ?? '')\n\t\t\treturn\n\t\t}\n\t\tif (node.nodeType !== 1) return\n\t\tif ((node.nodeName ?? '').toUpperCase() === 'BR') {\n\t\t\tlines.push('')\n\t\t\treturn\n\t\t}\n\t\tconst children = node.childNodes\n\t\tfor (let idx = 0; idx < (children?.length ?? 0); idx++) {\n\t\t\tconst child = children?.[idx]\n\t\t\tif (child) walk(child)\n\t\t}\n\t}\n\n\t// Walk from the cell's children: the cell itself is an element, and can never be a BR.\n\tconst children = cell.childNodes\n\tfor (let idx = 0; idx < (children?.length ?? 0); idx++) {\n\t\tconst child = children?.[idx]\n\t\tif (child) walk(child)\n\t}\n\tconst walked = lines.map((line) => line.replace(/\\s+/g, ' ').trim()).join('\\n')\n\n\t// Prefer `innerText` — except when the walk found line breaks it dropped. A DOM that does\n\t// not render can still expose an `innerText` property that is really just `textContent`\n\t// (happy-dom returns `\"ab\"` for `a<br>b`), and that one is not the rendered text this\n\t// wants: it has silently lost the cell's line structure. Where it kept the breaks, it is\n\t// the better answer, because it also knows about `display:none` and `text-transform`.\n\tconst rendered = cell.innerText\n\tif (typeof rendered !== 'string') return walked\n\treturn walked.includes('\\n') && !rendered.includes('\\n') ? walked : rendered\n}\n\n// ===== Live-DOM tableToSlides() flow =====\n// Browser-only entry (reads a rendered table via getComputedStyle/offsetWidth);\n// out of active scope, see the scope policy. Internally signposted by `// STEP 1..5`.\n\n/**\n * Resolve `options.masterTitle` to the slide layout it names, so the auto-pager can take that\n * master's margins.\n *\n * The layout registry is a presentation *internal* — it is not on {@link TableToSlidesHost},\n * and the public `slideLayouts` getter deliberately hides the `_name` this matches on. Rather\n * than widen either, read it defensively: a host that has no registry simply resolves no\n * master, which is what a caller passing a bare `{ addSlide, presLayout }` object should get.\n * The alternative — dropping the lookup on the free-function path — would make `masterTitle`\n * silently do nothing there, which is a trap.\n * @param {TableToSlidesHost} pptx - the presentation the slides are being added to\n * @param {string} masterTitle - the `title` passed to `defineSlideMaster`\n * @returns {SlideLayoutInternal | undefined} the named layout, if this host has one\n */\nfunction resolveMasterSlide(pptx: TableToSlidesHost, masterTitle?: string): SlideLayoutInternal | undefined {\n\tif (!masterTitle) return undefined\n\tconst layouts = (pptx as { _slideLayouts?: SlideLayoutInternal[] })._slideLayouts\n\tif (!Array.isArray(layouts)) return undefined\n\treturn layouts.find((layout) => layout._name === masterTitle)\n}\n\n/** Which of the three logical sections a row belongs to. A section-less row counts as body. */\ntype TablePart = 'thead' | 'tbody' | 'tfoot'\n\n/**\n * A row's cells, via `HTMLTableRowElement.cells`.\n *\n * Read off the structural shape rather than the `lib.dom` type so a DOM that does not implement\n * the collection degrades to \"this row has no cells\" instead of throwing — the same tolerance\n * every other DOM read in this file has.\n * @param {Element} row - a `<tr>`\n * @returns {HTMLTableCellElement[]} the row's cells, in document order\n */\nfunction rowCells(row: Element): HTMLTableCellElement[] {\n\tconst cells = (row as { cells?: ArrayLike<Element> }).cells\n\treturn cells ? (Array.from(cells) as HTMLTableCellElement[]) : []\n}\n\n/**\n * Collect every row of the table, bucketed head → body → foot.\n *\n * `HTMLTableElement.rows` is the right source and a `thead tr`/`tbody tr`/`tfoot tr` query is not,\n * for two reasons the query cannot fix:\n *\n * - **A row need not be in a section.** `<table><tr>…` is valid authored markup, and a table built\n *   with `createElement`/`appendChild` has no `<tbody>` at all — the HTML *parser* inserts one, the\n *   DOM API does not. Those rows matched none of the three selectors and were silently dropped,\n *   which is how a perfectly good table reached `addTable` with zero rows and threw\n *   `addTable: Array expected!` (upstream gitbrent/PptxGenJS#1005).\n * - **A descendant query reaches into nested tables.** `tbody tr` matches the rows of a table\n *   inside a cell of this one, folding them into the outer table as extra rows.\n *\n * Each row's own parentage settles both questions: it names the section the row belongs to (the\n * head/body/foot split still matters downstream, for repeating header rows on auto-paged slides),\n * and it says whether the row is this table's at all. The ownership check is not redundant with\n * using `rows` — happy-dom's `rows` is itself a descendant walk, so a nested table's rows arrive\n * there too. Checking is what makes the answer the same on every DOM.\n * @param {Element} table - the `<table>` being converted\n * @returns {Array<{ row: Element, part: TablePart }>} rows in emission order\n */\nfunction collectTableRows(table: Element): Array<{ row: Element; part: TablePart }> {\n\tconst head: Array<{ row: Element; part: TablePart }> = []\n\tconst body: Array<{ row: Element; part: TablePart }> = []\n\tconst foot: Array<{ row: Element; part: TablePart }> = []\n\tconst place = (row: Element): void => {\n\t\tconst parent = row.parentElement\n\t\tconst section = (parent?.nodeName ?? '').toUpperCase()\n\t\tconst sectioned = section === 'THEAD' || section === 'TBODY' || section === 'TFOOT'\n\t\tif ((sectioned ? parent?.parentElement : parent) !== table) return\n\t\tif (section === 'THEAD') head.push({ row, part: 'thead' })\n\t\telse if (section === 'TFOOT') foot.push({ row, part: 'tfoot' })\n\t\telse body.push({ row, part: 'tbody' })\n\t}\n\n\tconst rows = (table as { rows?: ArrayLike<Element> }).rows\n\tif (rows) {\n\t\tfor (let idx = 0; idx < rows.length; idx++) {\n\t\t\tconst row = rows[idx]\n\t\t\tif (row) place(row)\n\t\t}\n\t} else {\n\t\t// A DOM without `rows` is not one this library has ever run on, but the section query is\n\t\t// still a truthful fallback for the sectioned tables it can see.\n\t\tfor (const part of ['thead', 'tbody', 'tfoot']) {\n\t\t\ttable.querySelectorAll(`${part} tr`).forEach(place)\n\t\t}\n\t}\n\n\treturn [...head, ...body, ...foot]\n}\n\n/**\n * Reproduces an HTML table as a PowerPoint table - including column widths, style, etc. - creates 1 or more slides as needed\n * @param {TableToSlidesHost} pptx - pptx-ts instance\n * @param {TableToSlidesElement | string} target - the table element, or the HTMLElementID of the table\n * @param {TableToSlidesProps} options - array of options (e.g.: tabsize)\n */\nexport function genTableToSlides(\n\tpptx: TableToSlidesHost,\n\ttarget: TableToSlidesElement | string,\n\toptions: TableToSlidesProps = {}\n): void {\n\t// Own the options before touching them, the way `addTextDefinition`, `addShapeDefinition`\n\t// and `addTableDefinition` each do. This function resolves the slide margin, the column\n\t// widths, the head rows and the per-page `y` into its working bag; writing those into the\n\t// caller's object made a reused bag change the next call's output — most visibly `y`, left\n\t// holding the continuation start, so the second call's first table began where the first\n\t// call's *second* page did.\n\tconst opts: TableToSlidesPropsInternal = { ...options }\n\tconst masterSlide = resolveMasterSlide(pptx, opts.masterTitle)\n\tconst arrObjTabHeadRows: TableCellInternal[][] = []\n\tconst arrObjTabBodyRows: TableCellInternal[][] = []\n\tconst arrObjTabFootRows: TableCellInternal[][] = []\n\tconst arrColW: number[] = []\n\tconst arrTabColW: number[] = []\n\tconst arrTabColCssW: string[] = []\n\tlet arrInchMargins: [number, number, number, number] = [0.5, 0.5, 0.5, 0.5] // TRBL-style\n\tlet intTabW = 0\n\n\t// REALITY-CHECK: resolve the table (and its style reader) before anything else — this is\n\t// also where a missing/unresolvable table id fails.\n\tconst ctx = resolveDomContext(target, opts)\n\n\t// STEP 1: Set margins. The caller's `slideMargin` is passed as given, absent included:\n\t// `resolveSlideMarginsInches` owns the caller/master/default tiers, and substituting 0.5\n\t// for an unstated one here made every deck look like it had asked for the default margin,\n\t// which outranks and so suppresses the master's own.\n\tarrInchMargins = resolveSlideMarginsInches(masterSlide?._margin, opts.slideMargin)\n\t// A stated `w` is the table's width, as given. Otherwise the table runs from its own left edge to\n\t// the right slide margin: `usableTableWidthEmu`, the reading `addTable` applies. This took the\n\t// slide width (or `w`) less BOTH margins, so it ignored `x` -- `{ x: 3 }` on a 10in slide was\n\t// 9in wide and ran to 12in -- and shrank a stated `w: 8` to 7in.\n\tconst tableXEmu =\n\t\topts.x === undefined || opts.x === null\n\t\t\t? inch2Emu(arrInchMargins[3])\n\t\t\t: getSmartParseNumber(opts.x, 'X', pptx.presLayout)\n\tconst emuSlideTabW =\n\t\topts.w === undefined || opts.w === null\n\t\t\t? usableTableWidthEmu(pptx.presLayout, tableXEmu, arrInchMargins)\n\t\t\t: getSmartParseNumber(opts.w, 'X', pptx.presLayout)\n\n\tif (opts.verbose) {\n\t\tconsole.log('[[VERBOSE MODE]]')\n\t\tconsole.log('|-- `tableToSlides` ----------------------------------------------------|')\n\t\tconsole.log(`| tableProps.h .................................... = ${opts.h}`)\n\t\tconsole.log(`| tableProps.w .................................... = ${opts.w}`)\n\t\tconsole.log(\n\t\t\t`| pptx.presLayout.width ........................... = ${(pptx.presLayout.width / EMU_PER_INCH).toFixed(1)}`\n\t\t)\n\t\tconsole.log(\n\t\t\t`| pptx.presLayout.height .......................... = ${(pptx.presLayout.height / EMU_PER_INCH).toFixed(1)}`\n\t\t)\n\t\tconsole.log(`| emuSlideTabW .................................... = ${(emuSlideTabW / EMU_PER_INCH).toFixed(1)}`)\n\t}\n\n\t// STEP 2: Resolve the rows and the grid they occupy, then take the column widths from the\n\t// first row that has any cells (others may have colspans, who cares, we only need col widths from 1).\n\t// Two bases are collected in the same pass: the rendered `offsetWidth` (what a browser\n\t// reports) and the computed CSS `width` (the only width statement available where nothing\n\t// laid the table out). `pickColWidthBasis` decides which one STEP 3 runs on.\n\tconst domRows = collectTableRows(ctx.table)\n\t// Each cell's spans, read once per conversion. The grid measure, the column widths and the cell\n\t// options all need them, and reading the attributes once is what makes those three agree and\n\t// reports a span past the ceiling once rather than once per reader.\n\tconst spansByCell = new Map<Element, { colspan: number; rowspan: number }>()\n\tconst spansOf = (cell: Element): { colspan: number; rowspan: number } => {\n\t\tlet spans = spansByCell.get(cell)\n\t\tif (!spans) {\n\t\t\tspans = {\n\t\t\t\tcolspan: gridSpan(cell.getAttribute('colspan'), 'colspan'),\n\t\t\t\trowspan: gridSpan(cell.getAttribute('rowspan'), 'rowspan'),\n\t\t\t}\n\t\t\tspansByCell.set(cell, spans)\n\t\t}\n\t\treturn spans\n\t}\n\tconst { columns: intColCnt, filled: arrRowFilled } = measureGridColumns(\n\t\tdomRows.map(({ row }) => rowCells(row).map(spansOf))\n\t)\n\t// A table with no rows — or only empty ones — has nothing to convert. Say so here: the failure\n\t// used to surface far downstream as `Reduce of empty array with no initial value` out of the\n\t// auto-pager, or as `addTable: Array expected!`, neither of which names the table.\n\tconst srcRow = domRows.find(({ row }) => rowCells(row).length > 0)\n\tif (!srcRow) {\n\t\tthrow new InvalidOptionError(\n\t\t\t'html/table-has-no-cells',\n\t\t\t'tableToSlides: the table has no cells to convert - expected at least one <tr> with a <td>/<th>.'\n\t\t)\n\t}\n\n\t// Per grid column, the width-source cell it came from and that cell's colspan. Built here so\n\t// STEP 3 can read a column's overrides off the *right* cell: with a colspan in play, column\n\t// index and cell index part ways, and indexing the row by column silently applied one cell's\n\t// `data-pptx-width` to the next column along (upstream gitbrent/PptxGenJS#1244).\n\tconst arrColSrc: Array<{ cell: HTMLTableCellElement; span: number }> = []\n\tconst arrCellSpans: number[] = []\n\trowCells(srcRow.row).forEach((cell) => {\n\t\tconst offsetW = Number(cell.offsetWidth)\n\t\tconst measured = Number.isFinite(offsetW) ? offsetW : 0\n\t\tarrTabColCssW.push(ctx.getComputedStyle(cell).getPropertyValue('width'))\n\t\t// Guesstimate (divide evenly) col widths across a spanned cell.\n\t\t// NOTE: both j$query and vanilla selectors return {0} when table is not visible)\n\t\tconst span = spansOf(cell).colspan\n\t\tarrCellSpans.push(span)\n\t\tfor (let idxc = 0; idxc < span; idxc++) {\n\t\t\tarrTabColW.push(Math.round(measured / span))\n\t\t\tarrColSrc.push({ cell, span })\n\t\t}\n\t})\n\n\t// The CSS basis is parsed per *cell* (unit uniformity is a property of the row as authored),\n\t// then expanded across each cell's colspan the same way `offsetWidth` is.\n\tconst parsedCellCssW = parseCssWidthBasis(arrTabColCssW)\n\tconst arrCssColW: number[] = []\n\tif (parsedCellCssW.length === arrCellSpans.length) {\n\t\tparsedCellCssW.forEach((cssW, idxC) => {\n\t\t\tconst span = arrCellSpans[idxC] ?? 1\n\t\t\tfor (let idxc = 0; idxc < span; idxc++) arrCssColW.push(cssW / span)\n\t\t})\n\t}\n\n\t// The width-source row can be narrower than the grid (one spanning header over a wider body),\n\t// so widen the basis to the full grid before the proportional calc — that way the calc still\n\t// divides the slide across *every* column instead of overflowing it by the missing ones.\n\tconst arrBasisColW = extendColBasis(pickColWidthBasis(arrTabColW, arrCssColW), intColCnt)\n\tarrBasisColW.forEach((colW) => {\n\t\tintTabW += colW\n\t})\n\n\t// STEP 3: Calc/Set column widths by using same column width percent from HTML table\n\tarrBasisColW.forEach((colW, idxW) => {\n\t\tconst intCalcWidth = Number(((Number(emuSlideTabW) * ((colW / intTabW) * 100)) / 100 / EMU_PER_INCH).toFixed(2))\n\t\t// A `data-pptx-width` on a spanning cell states that *cell's* width, so it divides across\n\t\t// the columns the cell covers — exactly as its `offsetWidth` and its CSS width do above.\n\t\t// A column past the source row's reach has no cell to be overridden by.\n\t\tconst src = arrColSrc[idxW]\n\t\tconst intSetWidth = src ? Number(src.cell.getAttribute('data-pptx-width')) / src.span : 0\n\t\tconst intMinWidth = src ? Number(src.cell.getAttribute('data-pptx-min-width')) / src.span : 0\n\t\tarrColW.push(resolveHtmlColWidth(intCalcWidth, intSetWidth, intMinWidth))\n\t})\n\tif (opts.verbose) {\n\t\tconsole.log(`| arrColW ......................................... = [${arrColW.join(', ')}]`)\n\t}\n\n\t// STEP 4: Iterate over each table element and create data arrays (text and opts)\n\t// NOTE: We create 3 arrays instead of one so we can loop over body then show header/footer rows on first and last page\n\tdomRows.forEach(({ row, part }, idxRow) => {\n\t\tconst arrObjTabCells: TableCellInternal[] = []\n\t\trowCells(row).forEach((cell) => {\n\t\t\t// The computed style is read a dozen times below; resolve it once per cell.\n\t\t\tconst style = ctx.getComputedStyle(cell)\n\n\t\t\t// A: Get text/bkgd colors\n\t\t\t// NOTE: an unparseable or fully transparent background is the default for an\n\t\t\t// unstyled table; pptx has no \"transparent\" solid fill, so use white instead.\n\t\t\tconst textColor = cssColorToHex(style.getPropertyValue('color')) ?? '000000'\n\t\t\tconst fillColor = cssColorToHex(style.getPropertyValue('background-color')) ?? 'FFFFFF'\n\n\t\t\t// B: Create option object\n\t\t\tconst cellOpts: TableCellProps = {\n\t\t\t\tbold: !!(\n\t\t\t\t\tstyle.getPropertyValue('font-weight') === 'bold' || Number(style.getPropertyValue('font-weight')) >= 500\n\t\t\t\t),\n\t\t\t\tcolor: textColor,\n\t\t\t\tfill: { color: fillColor },\n\t\t\t}\n\t\t\t// A relative or keyword font size has no absolute magnitude here, so the key stays off\n\t\t\t// the cell and the size inherits, rather than arriving as `NaN` in `sz`.\n\t\t\tconst fontSizePt = htmlCssPxToPoints(style.getPropertyValue('font-size'))\n\t\t\tif (Number.isFinite(fontSizePt)) cellOpts.fontSize = fontSizePt\n\t\t\tconst fontFace = ((style.getPropertyValue('font-family') || '').split(',')[0] ?? '')\n\t\t\t\t.replace(/\"/g, '')\n\t\t\t\t.replace('inherit', '')\n\t\t\t\t.replace('initial', '')\n\t\t\t// The same spans the grid walk measured, so what is emitted and what was measured cannot\n\t\t\t// disagree: a `colspan=\"-2\"` counted as one column above must not reach the table\n\t\t\t// definition as `-2` and corrupt its own column count.\n\t\t\tconst { colspan, rowspan } = spansOf(cell)\n\t\t\tif (fontFace) cellOpts.fontFace = fontFace\n\t\t\tif (colspan > 1) cellOpts.colspan = colspan\n\t\t\tif (rowspan > 1) cellOpts.rowspan = rowspan\n\n\t\t\t// A CSS value this table has no spelling for leaves the key off rather than writing an\n\t\t\t// `undefined` into it, so the cell keeps whatever alignment it inherits. The guard and\n\t\t\t// the ternary chain they replace could not disagree, but only because every value the\n\t\t\t// guard admitted had an arm — the `: undefined` tail was unreachable, and a sixth CSS\n\t\t\t// value added to one list and not the other would have made it reachable and silent.\n\t\t\tconst align = CSS_TEXT_ALIGN[style.getPropertyValue('text-align')]\n\t\t\tif (align) cellOpts.align = align\n\t\t\tconst valign = CSS_VERTICAL_ALIGN[style.getPropertyValue('vertical-align')]\n\t\t\tif (valign) cellOpts.valign = valign\n\n\t\t\t// C: Add padding [margin] (if any)\n\t\t\t// NOTE: `TableCellProps.margin` is INCHES, so computed px must be converted, not copied.\n\t\t\t// CSS defines the reference pixel as 1/96in, and mirroring what the browser rendered is\n\t\t\t// this conversion's whole job — so resolve at `DEFAULT_PX_PER_INCH`, the same density the\n\t\t\t// `\"<n>px\"` coordinate unit uses. (Until 2026-07-31 the px magnitude was assigned straight\n\t\t\t// through under a stale \"px->pt 1:1\" note left from when cell margin was points; that made\n\t\t\t// a 4px pad a *4 inch* inset and tripped the legacy-points warning on any pad >= 1px.)\n\t\t\t// No rounding to whole px: the browser's computed value can be fractional, and `inch2Emu`\n\t\t\t// already does the one rounding that matters, at EMU precision.\n\t\t\tif (style.getPropertyValue('padding-left')) {\n\t\t\t\tconst cellMargin: MarginTuple = [0, 0, 0, 0]\n\t\t\t\tconst sidesPad = ['padding-top', 'padding-right', 'padding-bottom', 'padding-left']\n\t\t\t\tsidesPad.forEach((val, idxs) => {\n\t\t\t\t\t// Anything that is not an absolute px length (a `%` padding, a keyword) has no\n\t\t\t\t\t// meaning as a fixed inset, so it insets by nothing rather than by its digits.\n\t\t\t\t\tconst pad = parseCssPx(style.getPropertyValue(val))\n\t\t\t\t\tcellMargin[idxs] = Number.isFinite(pad) ? pad / DEFAULT_PX_PER_INCH : 0\n\t\t\t\t})\n\t\t\t\tcellOpts.margin = cellMargin\n\t\t\t}\n\n\t\t\t// D: Add border (if any)\n\t\t\tif (\n\t\t\t\tstyle.getPropertyValue('border-top-width') ||\n\t\t\t\tstyle.getPropertyValue('border-right-width') ||\n\t\t\t\tstyle.getPropertyValue('border-bottom-width') ||\n\t\t\t\tstyle.getPropertyValue('border-left-width')\n\t\t\t) {\n\t\t\t\tconst cellBorder: BorderTuple = [{ type: 'none' }, { type: 'none' }, { type: 'none' }, { type: 'none' }]\n\t\t\t\tconst sidesBor = ['top', 'right', 'bottom', 'left']\n\t\t\t\tsidesBor.forEach((val, idxb) => {\n\t\t\t\t\tcellBorder[idxb] = htmlBorderToProps(\n\t\t\t\t\t\tstyle.getPropertyValue('border-' + val + '-width'),\n\t\t\t\t\t\tstyle.getPropertyValue('border-' + val + '-color')\n\t\t\t\t\t)\n\t\t\t\t})\n\t\t\t\tcellOpts.border = cellBorder\n\t\t\t}\n\n\t\t\t// LAST: Add cell\n\t\t\tarrObjTabCells.push({\n\t\t\t\t_type: SlideObjectType.tablecell,\n\t\t\t\ttext: readCellText(cell), // <br> must survive as \"\\n\", so linebreak etc. work later!\n\t\t\t\toptions: cellOpts,\n\t\t\t})\n\t\t})\n\n\t\t// Normalize a ragged row up to the grid width. HTML tolerates a short row and just leaves\n\t\t// the tail of the grid empty; pptx does not — `<a:tblGrid>` declares the column count and a\n\t\t// row with fewer `<a:tc>` is a malformed table PowerPoint has to repair. The missing cells\n\t\t// are blank rather than a copy of a neighbour: the source table never stated them, so there\n\t\t// is nothing to carry over. Columns held by a `rowspan` from above are already counted as\n\t\t// filled — the table emitter synthesizes those merge cells itself.\n\t\tfor (let idxPad = arrRowFilled[idxRow] ?? 0; idxPad < intColCnt; idxPad++) {\n\t\t\tarrObjTabCells.push({ _type: SlideObjectType.tablecell, text: '', options: {} })\n\t\t}\n\n\t\tif (part === 'thead') arrObjTabHeadRows.push(arrObjTabCells)\n\t\telse if (part === 'tfoot') arrObjTabFootRows.push(arrObjTabCells)\n\t\telse arrObjTabBodyRows.push(arrObjTabCells)\n\t})\n\n\t// STEP 5: Break table into Slides as needed\n\t// Pass head-rows as there is an option to add to each table and the parse func needs this data to fulfill that option\n\topts._arrObjTabHeadRows = arrObjTabHeadRows\n\topts.colW = arrColW\n\tgetSlidesForTableRows(\n\t\t[...arrObjTabHeadRows, ...arrObjTabBodyRows, ...arrObjTabFootRows],\n\t\topts,\n\t\tpptx.presLayout,\n\t\tmasterSlide\n\t).forEach((slide) => {\n\t\t// A: Create new Slide\n\t\tconst newSlide = pptx.addSlide(opts.masterTitle ? { masterTitle: opts.masterTitle } : {})\n\n\t\t// B: DESIGN: Reset `y` to startY or margin after first Slide.\n\t\t// Every page goes where the pager started it when it budgeted the page's height\n\t\t// (`slide.y`). This used to restate that rule, and the copy had drifted three times:\n\t\t// `autoPageSlideStartY: 0` read as unset, a `y` above the top margin was pushed back down,\n\t\t// and a first page stated at `y: 0` was moved down to the margin.\n\t\tif (slide.y !== undefined) opts.y = slide.y\n\t\tif (opts.verbose)\n\t\t\tconsole.log(\n\t\t\t\t`| opts.autoPageSlideStartY: ${opts.autoPageSlideStartY} / arrInchMargins[0]: ${arrInchMargins[0]} => opts.y = ${opts.y}`\n\t\t\t)\n\n\t\t// C: Add table to Slide\n\t\tconst slideTableProps: TableProps = {\n\t\t\t// `??`: a stated `x: 0` is the left edge of the slide, not a missing `x`.\n\t\t\tx: opts.x ?? arrInchMargins[3],\n\t\t\tw: Number(emuSlideTabW) / EMU_PER_INCH,\n\t\t\tcolW: arrColW,\n\t\t\tautoPage: false,\n\t\t}\n\t\t// `y` is set on `opts` a few lines up on every branch, but only where the caller stated one\n\t\t// does it belong on the table's own props — an absent `y` is what lets `addTable` apply its\n\t\t// own default.\n\t\tif (opts.y !== undefined) slideTableProps.y = opts.y\n\t\tnewSlide.addTable(slide.rows, slideTableProps)\n\n\t\t// D: Add any additional objects\n\t\tif (opts.addImage) {\n\t\t\topts.addImage.options = opts.addImage.options || {}\n\t\t\tif (!opts.addImage.image || (!opts.addImage.image.path && !opts.addImage.image.data)) {\n\t\t\t\twarn('html/image-missing-source', 'tableToSlides.addImage requires either `path` or `data`')\n\t\t\t} else {\n\t\t\t\tconst imageProps = opts.addImage.image.path\n\t\t\t\t\t? { path: opts.addImage.image.path }\n\t\t\t\t\t: { data: opts.addImage.image.data as string }\n\t\t\t\t// Geometry is copied only where the caller stated it, so an omitted axis keeps\n\t\t\t\t// `addImage`'s own default rather than arriving as an explicit `undefined`.\n\t\t\t\tconst imageOptions = opts.addImage.options\n\t\t\t\tconst geometry: PositionProps = {}\n\t\t\t\tif (imageOptions.x !== undefined) geometry.x = imageOptions.x\n\t\t\t\tif (imageOptions.y !== undefined) geometry.y = imageOptions.y\n\t\t\t\tif (imageOptions.w !== undefined) geometry.w = imageOptions.w\n\t\t\t\tif (imageOptions.h !== undefined) geometry.h = imageOptions.h\n\t\t\t\tnewSlide.addImage({ ...imageProps, ...geometry })\n\t\t\t}\n\t\t}\n\t\tif (opts.addShape) newSlide.addShape(opts.addShape.shapeName, opts.addShape.options || {})\n\t\tif (opts.addTable) newSlide.addTable(opts.addTable.rows, opts.addTable.options || {})\n\t\tif (opts.addText) newSlide.addText(opts.addText.text, opts.addText.options || {})\n\t})\n}\n"],"mappings":"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"}