@shbernal/ts-pptx 4.1.0 → 5.0.0

package/dist/index.d.ts

@@ -1,29 +1,34 @@
-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";
-//#region src/index.d.ts
+/**
+ * The runtime-agnostic authoring entry, which the bare `pptx-ts` specifier resolves to when
+ * neither the `node` nor the `browser` export condition applies.
+ *
+ * @module
+ */
+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-PcXr3o3J.js";
+import { $ as ChartExBinning, $t as ImageBaseProps, A as PositionProps, At as ObjectLockProps, B as HyperlinkActionJump, Bt as ResolvedCommentAuthor, C as HexColor, Ct as ChartPropsLegend, D as PatternFillProps, Dt as OptsChartData, E as Margin, En as RadarStyleAlias, Et as LineCap, F as ActionHyperlinkProps, Ft as CommentProps, G as ShapeLineProps, Gt as TextBulletProps, H as HyperlinkProps, Ht as TableCellLayout, I as BorderProps, It as MeasureTextOptions, J as UrlHyperlinkProps, Jt as TextMeasurement, K as SlideHyperlinkProps, Kt as TextFitShrinkProps, L as ConnectorProps, Lt as NotesProps, M as TextVertType, Mn as TimeUnit, Mt as PlaceholderBinding, N as ThemeColor, Nt as PlaceholderOption, O as PatternPreset, Ot as OptsChartGridLine, P as VAlign, Pt as PlaceholderProps, Q as ChartErrorBarOptions, Qt as textRuns, R as ConnectorType, Rt as NotesTextOptions, S as HAlign, Sn as LineDataSymbol, St as ChartPropsFillLine, T as LinearGradientFillProps, Tn as RadarStyle, Tt as ChartSeriesOpts, U as ShadowProps, Ut as TableLayoutResult, V as HyperlinkBaseProps, Vt as SlideComment, W as ShapeFillProps, Wt as TextBaseProps, X as ChartAxisTickMark, Xt as TextPropsOptions, Y as ChartAreaProps, Yt as TextProps, Z as ChartDataPointStyle, Zt as textRun, _ as DataOrPathProps, _n as DisplayBlanksAs, _t as ChartPropsChartStock, a as PresentationProps, an as ShapeAdjustHandlePolar, at as ChartPropsAxisCat, b as GradientFillProps, bn as LightRigDirection, bt as ChartPropsDataLabel, c as WriteFileProps, cn as ShapeConnectionSite, ct as ChartPropsBase, d as ThemeColorScheme, dn as Bar3DShape, dt as ChartPropsChartDoughnut, en as ImageProps, et as ChartExGeography, f as ThemeProps, fn as BarDirection, ft as ChartPropsChartHistogram, g as Coord, gn as DataLabelPosition, gt as ChartPropsChartRegionMap, h as Color, ht as ChartPropsChartRadar, i as PresLayout, in as ShapeAdjustHandle, it as ChartOpts, j as RadialGradientFillProps, jt as ObjectNameProps, k as PlaceholderPositionProps, kt as CommonObjectDescriptor, l as WriteOutputMap, ln as ShapeGuide, lt as ChartPropsChartBar, m as BackgroundProps, mn as BevelPresetType, mt as ChartPropsChartPie, n as PackagePart, nn as MediaType, nt as ChartLineDash, o as SectionProps, on as ShapeAdjustHandleXY, ot as ChartPropsAxisSer, p as BackgroundOption, pn as BarGrouping, pt as ChartPropsChartLine, q as StrokeProps, qt as TextGlowProps, r as PartsProps, rn as OleObjectProps, rt as ChartMulti, s as WriteBaseProps, sn as ShapeAdjustValue, st as ChartPropsAxisVal, t as CustomPropertyValue, tn as MediaProps, tt as ChartExStatistics, u as WriteProps, un as ShapeProps, ut as ChartPropsChartBoxWhisker, v as DataOrPathRequiredProps, vt as ChartPropsChartSurface, w as ImageFillProps, wn as PresetMaterialType, wt as ChartPropsTitle, x as GradientStopProps, xn as LightRigType, xt as ChartPropsDataTable, y as GeometryPoint, yn as LegendPosition, yt as ChartPropsChartWaterfall, z as FillOption, zt as OverflowBoxOptions } from "./pres-BkEkUAEM.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-BmT4kMoO.js";
+import { S as UnsupportedFeatureErrorCode, _ as InternalErrorCode, a as TsPptxCode, b as PackageReadErrorCode, c as InternalError, d as PackageReadError, f as PptxTsError, g as ErrorCode, h as DiagnosticCode, i as setDiagnosticHandler, l as InvalidOptionError, m as UnsupportedFeatureError, n as DiagnosticHandler, o as TsPptxError, p as PptxTsErrorOptions, r as resetDiagnosticState, s as TsPptxErrorOptions, t as Diagnostic, u as MediaError, v as InvalidOptionErrorCode, x as PptxTsCode, y as MediaErrorCode } from "./diagnostics-MoA4MBq5.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-CiakSt-f.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-ISfCMtWA.js";
 /**
  * The runtime-agnostic entry: what a consumer gets from the bare `pptx-ts` specifier
- * when neither the `node` nor the `browser` export condition resolves — Deno, Bun, edge workers.
+ * when neither the `node` nor the `browser` export condition resolves: Deno, Bun, edge workers.
  * Node and browser consumers reach `pptx-ts/node` and `pptx-ts/browser` through those conditions
  * without naming them, and get the same class backed by an adapter that can reach their host.
  *
  * Authoring is identical on all three. The difference is only where the finished deck can go:
  * `write`, `stream` and `toParts` hand the bytes back here as everywhere, while `writeFile`
  * throws `runtime/file-output-unavailable` because there is no filesystem and no DOM to write
- * to. Live-DOM `tableToSlides` is likewise absent — it is defined on the browser entry, and the
+ * to. Live-DOM `tableToSlides` is likewise absent. It is defined on the browser entry, and the
  * DOM-agnostic form is the free `tableToSlides` on `pptx-ts/html`.
  */
-export declare class TsPptx extends PresentationCore {
+export declare class PptxTs extends PresentationCore {
   constructor();
 }
 /**
  * Compose a presentation from the construct families it needs, on the runtime-agnostic adapter.
  *
- * The counterpart to {@link TsPptx}, which is composed with every family there is. This one costs
+ * The counterpart to {@link PptxTs}, which is composed with every family there is. This one costs
  * what it carries: the core tier (text, shapes, images, groups, speaker notes) plus whatever
  * `use` names, and nothing else reaches the bundle.
  * @param {ComposeOptions} opts - the families to compose in, from `pptx-ts/families`
@@ -33,6 +38,9 @@ export declare class TsPptx extends PresentationCore {
  * const pres = createPresentation({ use: [charts] })
  */
 export declare function createPresentation<const Fs extends readonly ConstructFamily[] = []>(opts?: ComposeOptions<Fs>): Composed<Fs>;
-//#endregion
-export { ANGLE_UNITS_PER_DEGREE, AddSlideProps, AlignH, AlignV, AnimationProps, AnimationTrigger, BackgroundOption, BackgroundProps, type Bar3DShape, type BarDirection, type BarGrouping, type BevelPresetType, BorderProps, BulletType, CHART_NAME, CONNECTOR_PRESET_NAME, ChartAreaProps, ChartAxisTickMark, ChartDataPointStyle, ChartErrorBarOptions, ChartExBinning, ChartExGeography, ChartExStatistics, ChartLineDash, ChartMulti, ChartOpts, ChartPropsAxisCat, ChartPropsAxisSer, ChartPropsAxisVal, ChartPropsBase, ChartPropsChartBar, ChartPropsChartBoxWhisker, ChartPropsChartDoughnut, ChartPropsChartHistogram, ChartPropsChartLine, ChartPropsChartPie, ChartPropsChartRadar, ChartPropsChartRegionMap, ChartPropsChartStock, ChartPropsChartSurface, ChartPropsChartWaterfall, ChartPropsDataLabel, ChartPropsDataTable, ChartPropsFillLine, ChartPropsLegend, ChartPropsTitle, ChartSeriesOpts, ChartType, ClipShape, Color, CommentProps, CommonObjectDescriptor, type ComposeOptions, type Composed, type ComposedPresentation, type ComposedSlide, ConnectorProps, ConnectorType, type ConstructFamily, Coord, CustomPropertyValue, DEFAULT_PX_PER_INCH, type DataLabelPosition, DataOrPathProps, DataOrPathRequiredProps, type Diagnostic, type DiagnosticCode, type DiagnosticHandler, type DisplayBlanksAs, EMU_PER_INCH, EMU_PER_POINT, Emu, type ErrorCode, FIXED_PCT_PER_PERCENT, FillOption, FlatSide, GeometryPoint, GradientFillProps, GradientStopProps, GroupChildProps, GroupProps, HAlign, HUNDREDTHS_PER_POINT, HalfDiscPreset, HexColor, HyperlinkActionJump, HyperlinkProps, ImageBaseProps, ImageFillProps, ImageProps, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, type LegendPosition, type LightRigDirection, type LightRigType, LineCap, type LineDataSymbol, LinearGradientFillProps, MAX_COORDINATE_EMU, MIN_COORDINATE_EMU, Margin, MasterBulletProps, MasterTextStyleLevel, MasterTextStyleProps, MeasureTextOptions, MediaError, type MediaErrorCode, MediaProps, MediaType, Model3dCameraProps, Model3dPoint, Model3dProps, NotesProps, NotesTextOptions, ObjectLockProps, ObjectNameProps, ObjectOptions, OleObjectProps, OptsChartData, OptsChartGridLine, OutputType, OverflowBoxOptions, PERCENT_SCALE, PLACEHOLDER_TYPE, POINTS_PER_INCH, PackagePart, PackageReadError, type PackageReadErrorCode, PartsProps, PatternFillProps, PatternPreset, PlaceholderProps, PlaceholderType, PositionProps, PresLayout, PresentationProps, PresetEffect, type PresetMaterialType, type RadarStyle, type RadarStyleAlias, RadialGradientFillProps, ResolvedCommentAuthor, SCHEME_COLORS, SHAPE_NAME, STANDARD_LAYOUTS, SchemeColor, SectionProps, SectionZoomProps, ShadowProps, ShapeAdjustHandle, ShapeAdjustHandlePolar, ShapeAdjustHandleXY, ShapeAdjustValue, ShapeConnectionSite, ShapeFillProps, ShapeGuide, ShapeLineProps, ShapeProps, ShapeType, Slide, SlideComment, SlideLayout, SlideMasterChartProps, SlideMasterObject, SlideMasterProps, SlideNumberProps, SlideObjectInfo, SlideObjectType, SlideZoomProps, StandardLayout, StandardLayoutName, StrokeProps, SummaryZoomProps, TableCell, TableCell3DProps, TableCellDiagonals, TableCellLayout, TableCellProps, TableLayoutResult, TableProps, TableRow, TableRowSlide, TableStyle, TableToSlidesDocument, TableToSlidesElement, TableToSlidesProps, TextAnchor, TextBaseProps, TextBulletProps, TextFitShrinkProps, TextGlowProps, TextMeasurement, TextProps, TextPropsOptions, TextVertType, ThemeColor, ThemeColorScheme, ThemeProps, type TimeUnit, TransitionProps, TransitionSoundProps, TransitionType, TsPptx as default, type TsPptxCode, TsPptxError, type TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, VALID_SHAPE_PRESETS, VAlign, WRITE_OUTPUT_TYPE, WriteBaseProps, WriteFileProps, WriteOutputMap, WriteProps, ZIP_OUTPUT_TYPE, ZoomBaseProps, asChartType, clipPath, connectorPresetFor, coordToEmu, emuToInches, emuToPixels, emuToPoints, inchesToEmu, isChartExType, isChartType, percentToEmu, pixelsToEmu, pointsToEmu, ptToHundredths, resetDiagnosticState, setDiagnosticHandler, textRun, textRuns };
+/** @deprecated Renamed to {@link PptxTs}. This alias is removed in v5. */
+export declare const TsPptx: typeof PptxTs;
+/** @deprecated Renamed to {@link PptxTs}. This alias is removed in v5. */
+export type TsPptx = PptxTs;
+export { ANGLE_UNITS_PER_DEGREE, ActionHyperlinkProps, AddSlideProps, AlignH, AlignV, AnimationProps, AnimationTrigger, BackgroundOption, BackgroundProps, type Bar3DShape, type BarDirection, type BarGrouping, type BevelPresetType, BorderProps, BulletType, CHART_NAME, CONNECTOR_PRESET_NAME, ChartAreaProps, ChartAxisTickMark, ChartDataPointStyle, ChartErrorBarOptions, ChartExBinning, ChartExGeography, ChartExStatistics, ChartLineDash, ChartMulti, ChartOpts, ChartPropsAxisCat, ChartPropsAxisSer, ChartPropsAxisVal, ChartPropsBase, ChartPropsChartBar, ChartPropsChartBoxWhisker, ChartPropsChartDoughnut, ChartPropsChartHistogram, ChartPropsChartLine, ChartPropsChartPie, ChartPropsChartRadar, ChartPropsChartRegionMap, ChartPropsChartStock, ChartPropsChartSurface, ChartPropsChartWaterfall, ChartPropsDataLabel, ChartPropsDataTable, ChartPropsFillLine, ChartPropsLegend, ChartPropsTitle, ChartSeriesOpts, ChartType, ClipShape, Color, CommentProps, CommonObjectDescriptor, type ComposeOptions, type Composed, type ComposedPresentation, type ComposedSlide, ConnectorProps, ConnectorType, type ConstructFamily, Coord, CustomPropertyValue, DEFAULT_PX_PER_INCH, type DataLabelPosition, DataOrPathProps, DataOrPathRequiredProps, type Diagnostic, type DiagnosticCode, type DiagnosticHandler, type DisplayBlanksAs, EMU_PER_INCH, EMU_PER_POINT, Emu, type ErrorCode, FIXED_PCT_PER_PERCENT, FillOption, FlatSide, GeometryPoint, GradientFillProps, GradientStopProps, GroupChildProps, GroupProps, HAlign, HUNDREDTHS_PER_POINT, HalfDiscPreset, HexColor, HyperlinkActionJump, HyperlinkBaseProps, HyperlinkProps, ImageBaseProps, ImageFillProps, ImageProps, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, type LegendPosition, type LightRigDirection, type LightRigType, LineCap, type LineDataSymbol, LinearGradientFillProps, MAX_COORDINATE_EMU, MIN_COORDINATE_EMU, Margin, MasterBulletProps, MasterTextStyleLevel, MasterTextStyleProps, MeasureTextOptions, MediaError, type MediaErrorCode, MediaProps, MediaType, Model3dCameraProps, Model3dPoint, Model3dProps, NotesProps, NotesTextOptions, ObjectLockProps, ObjectNameProps, ObjectOptions, OleObjectProps, OptsChartData, OptsChartGridLine, OutputType, OverflowBoxOptions, PERCENT_SCALE, PLACEHOLDER_TYPE, POINTS_PER_INCH, PackagePart, PackageReadError, type PackageReadErrorCode, PartsProps, PatternFillProps, PatternPreset, PlaceholderBinding, PlaceholderOption, PlaceholderPositionProps, PlaceholderProps, PlaceholderType, PositionProps, PptxTs as default, type PptxTsCode, PptxTsError, type PptxTsErrorOptions, PresLayout, PresentationProps, PresetEffect, type PresetMaterialType, type RadarStyle, type RadarStyleAlias, RadialGradientFillProps, ResolvedCommentAuthor, SCHEME_COLORS, SHAPE_NAME, STANDARD_LAYOUTS, SchemeColor, SectionProps, SectionZoomProps, ShadowProps, ShapeAdjustHandle, ShapeAdjustHandlePolar, ShapeAdjustHandleXY, ShapeAdjustValue, ShapeConnectionSite, ShapeFillProps, ShapeGuide, ShapeLineProps, ShapeProps, ShapeType, Slide, SlideComment, SlideHyperlinkProps, SlideLayout, SlideMasterChartProps, SlideMasterObject, SlideMasterProps, SlideNumberProps, SlideObjectInfo, SlideObjectType, SlideZoomProps, StandardLayout, StandardLayoutName, StrokeProps, SummaryZoomProps, TableCell, TableCell3DProps, TableCellDiagonals, TableCellLayout, TableCellProps, TableLayoutResult, TableProps, TableRow, TableRowSlide, TableStyle, TableToSlidesDocument, TableToSlidesElement, TableToSlidesProps, TextAnchor, TextBaseProps, TextBulletProps, TextFitShrinkProps, TextGlowProps, TextMeasurement, TextProps, TextPropsOptions, TextVertType, ThemeColor, ThemeColorScheme, ThemeProps, type TimeUnit, TransitionProps, TransitionSoundProps, TransitionType, TsPptxCode, TsPptxError, TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, UrlHyperlinkProps, VALID_SHAPE_PRESETS, VAlign, WRITE_OUTPUT_TYPE, WriteBaseProps, WriteFileProps, WriteOutputMap, WriteProps, ZIP_OUTPUT_TYPE, ZoomBaseProps, asChartType, clipPath, connectorPresetFor, coordToEmu, emuToInches, emuToPixels, emuToPoints, inchesToEmu, isChartExType, isChartType, percentToEmu, pixelsToEmu, pointsToEmu, ptToHundredths, resetDiagnosticState, setDiagnosticHandler, textRun, textRuns };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAwBa,eAAe;EAC3B;;;;;;;;;;;;;;wBAiBe,yBAAyB,oBAAoB,wBAC5D,OAAO,eAAe,MACpB,SAAS"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;qBAwBa,eAAe;EAC3B;;;;;;;;;;;;;;wBAiBe,yBAAyB,oBAAoB,wBAC5D,OAAO,eAAe,MACpB,SAAS;;qBAOC,eAAM;;YAEP,SAAS"}

package/dist/index.js

@@ -1,19 +1,19 @@
-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 { a as fetchMediaBase64, c as ALL_CONSTRUCT_FAMILIES, i as fetchFontBytes, l as composePresentation, n as textRuns, r as clipPath, s as placeholderSvgPreview, t as textRun, u as PresentationCore } from "./text-BvFFMMFQ.js";
-//#region src/runtime/neutral.ts
+import { a as fetchMediaBase64, c as ALL_CONSTRUCT_FAMILIES, i as fetchFontBytes, l as composePresentation, n as textRuns, r as clipPath, s as placeholderSvgPreview, t as textRun, u as PresentationCore } from "./text-Dz0ArGIp.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, a as OutputType, b as FIXED_PCT_PER_PERCENT, c as ShapeType, d as TextAnchor, f as VALID_SHAPE_PRESETS, g as isChartType, h as isChartExType, i as ChartType, j as percentToEmu, k as emuToPoints, l as SlideObjectType, m as connectorPresetFor, n as AlignV, o as PlaceholderType, p as asChartType, r as BulletType, s as SchemeColor, t as AlignH, u as TableStyle, v as ANGLE_UNITS_PER_DEGREE, w as PERCENT_SCALE, x as HUNDREDTHS_PER_POINT, y as DEFAULT_PX_PER_INCH } from "./enums-BP9wsb9Q.js";
+import { a as PackageReadError, c as resetDiagnosticState, i as MediaError, l as setDiagnosticHandler, n as InternalError, o as PptxTsError, r as InvalidOptionError, s as UnsupportedFeatureError, t as TsPptxError } from "./entry-errors-JMthgJ2g.js";
+// src/runtime/neutral.ts
 /**
-* The adapter for a runtime that is neither Node nor a browser — Deno, Bun, an edge worker,
+* The adapter for a runtime that is neither Node nor a browser: Deno, Bun, an edge worker,
 * anything that imports the bare `pptx-ts` specifier without resolving the `node` or
 * `browser` export condition.
 *
 * It implements everything that is genuinely host-neutral and refuses only what is not.
 * `fetch`, `btoa` and `TextEncoder` exist in all of these runtimes, so remote media and fonts
-* load here exactly as they do in a browser — which is why every method but `writeFile` is now
+* load here exactly as they do in a browser, which is why every method but `writeFile` is now
 * the shared implementation in {@link ./fetch-media} rather than a copy of it. What is missing
 * is a *destination*: there is no `node:fs` to write to and no `document` to hand a download to,
 * so {@link RuntimeAdapter.writeFile} throws a named error rather than guessing. Everything that
-* returns bytes to the caller — `write`, `stream`, `toParts` — works normally, which is the
+* returns bytes to the caller (`write`, `stream`, `toParts`) works normally, which is the
 * shape that suits a worker anyway.
 *
 * Media loading is fetch-only here: a bare filesystem path has no meaning without a filesystem,
@@ -31,8 +31,7 @@ function createNeutralRuntime() {
 async function writeFile(fileName) {
 	throw new UnsupportedFeatureError("runtime/file-output-unavailable", `Cannot write "${fileName}": this runtime has neither a filesystem nor a DOM. Import "pptx-ts/node" to write to disk or "pptx-ts/browser" to trigger a download; anywhere else, use write() and persist the bytes yourself.`);
 }
-//#endregion
-//#region src/index.ts
+// src/index.ts
 /**
 * The runtime-agnostic authoring entry, which the bare `pptx-ts` specifier resolves to when
 * neither the `node` nor the `browser` export condition applies.
@@ -41,17 +40,17 @@ async function writeFile(fileName) {
 */
 /**
 * The runtime-agnostic entry: what a consumer gets from the bare `pptx-ts` specifier
-* when neither the `node` nor the `browser` export condition resolves — Deno, Bun, edge workers.
+* when neither the `node` nor the `browser` export condition resolves: Deno, Bun, edge workers.
 * Node and browser consumers reach `pptx-ts/node` and `pptx-ts/browser` through those conditions
 * without naming them, and get the same class backed by an adapter that can reach their host.
 *
 * Authoring is identical on all three. The difference is only where the finished deck can go:
 * `write`, `stream` and `toParts` hand the bytes back here as everywhere, while `writeFile`
 * throws `runtime/file-output-unavailable` because there is no filesystem and no DOM to write
-* to. Live-DOM `tableToSlides` is likewise absent — it is defined on the browser entry, and the
+* to. Live-DOM `tableToSlides` is likewise absent. It is defined on the browser entry, and the
 * DOM-agnostic form is the free `tableToSlides` on `pptx-ts/html`.
 */
-var TsPptx = class extends PresentationCore {
+var PptxTs = class extends PresentationCore {
 	constructor() {
 		super(createNeutralRuntime(), ALL_CONSTRUCT_FAMILIES);
 	}
@@ -59,7 +58,7 @@ var TsPptx = class extends PresentationCore {
 /**
 * Compose a presentation from the construct families it needs, on the runtime-agnostic adapter.
 *
-* The counterpart to {@link TsPptx}, which is composed with every family there is. This one costs
+* The counterpart to {@link PptxTs}, which is composed with every family there is. This one costs
 * what it carries: the core tier (text, shapes, images, groups, speaker notes) plus whatever
 * `use` names, and nothing else reaches the bundle.
 * @param {ComposeOptions} opts - the families to compose in, from `pptx-ts/families`
@@ -71,7 +70,8 @@ var TsPptx = class extends PresentationCore {
 function createPresentation(opts) {
 	return composePresentation(createNeutralRuntime(), opts);
 }
-//#endregion
-export { ANGLE_UNITS_PER_DEGREE, AlignH, AlignV, BulletType, ChartType, DEFAULT_PX_PER_INCH, EMU_PER_INCH, EMU_PER_POINT, FIXED_PCT_PER_PERCENT, HUNDREDTHS_PER_POINT, InternalError, InvalidOptionError, MAX_COORDINATE_EMU, MIN_COORDINATE_EMU, MediaError, OutputType, PERCENT_SCALE, POINTS_PER_INCH, PackageReadError, PlaceholderType, STANDARD_LAYOUTS, SchemeColor, ShapeType, SlideObjectType, TableStyle, TextAnchor, TsPptx, TsPptx as default, TsPptxError, UnsupportedFeatureError, VALID_SHAPE_PRESETS, asChartType, clipPath, connectorPresetFor, coordToEmu, createPresentation, emuToInches, emuToPixels, emuToPoints, inchesToEmu, isChartExType, isChartType, percentToEmu, pixelsToEmu, pointsToEmu, ptToHundredths, resetDiagnosticState, setDiagnosticHandler, textRun, textRuns };
+/** @deprecated Renamed to {@link PptxTs}. This alias is removed in v5. */
+const TsPptx = PptxTs;
+export { ANGLE_UNITS_PER_DEGREE, AlignH, AlignV, BulletType, ChartType, DEFAULT_PX_PER_INCH, EMU_PER_INCH, EMU_PER_POINT, FIXED_PCT_PER_PERCENT, HUNDREDTHS_PER_POINT, InternalError, InvalidOptionError, MAX_COORDINATE_EMU, MIN_COORDINATE_EMU, MediaError, OutputType, PERCENT_SCALE, POINTS_PER_INCH, PackageReadError, PlaceholderType, PptxTs, PptxTs as default, PptxTsError, STANDARD_LAYOUTS, SchemeColor, ShapeType, SlideObjectType, TableStyle, TextAnchor, TsPptx, TsPptxError, UnsupportedFeatureError, VALID_SHAPE_PRESETS, asChartType, clipPath, connectorPresetFor, coordToEmu, createPresentation, emuToInches, emuToPixels, emuToPoints, inchesToEmu, isChartExType, isChartType, percentToEmu, pixelsToEmu, pointsToEmu, ptToHundredths, resetDiagnosticState, setDiagnosticHandler, textRun, textRuns };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/runtime/neutral.ts","../src/index.ts"],"sourcesContent":["import { UnsupportedFeatureError } from '../errors.js'\nimport type { RuntimeAdapter } from './types.js'\nimport { fetchFontBytes, fetchMediaBase64, placeholderSvgPreview } from './fetch-media.js'\n\n/**\n * The adapter for a runtime that is neither Node nor a browser — Deno, Bun, an edge worker,\n * anything that imports the bare `pptx-ts` specifier without resolving the `node` or\n * `browser` export condition.\n *\n * It implements everything that is genuinely host-neutral and refuses only what is not.\n * `fetch`, `btoa` and `TextEncoder` exist in all of these runtimes, so remote media and fonts\n * load here exactly as they do in a browser — which is why every method but `writeFile` is now\n * the shared implementation in {@link ./fetch-media} rather than a copy of it. What is missing\n * is a *destination*: there is no `node:fs` to write to and no `document` to hand a download to,\n * so {@link RuntimeAdapter.writeFile} throws a named error rather than guessing. Everything that\n * returns bytes to the caller — `write`, `stream`, `toParts` — works normally, which is the\n * shape that suits a worker anyway.\n *\n * Media loading is fetch-only here: a bare filesystem path has no meaning without a filesystem,\n * and `fetch` rejecting it is reported by the caller as a load failure naming the path.\n */\nexport function createNeutralRuntime(): RuntimeAdapter {\n\treturn {\n\t\twriteFileOutputType: null,\n\t\tloadMedia: (rel) => fetchMediaBase64(rel.path),\n\t\tcreateSvgPngPreview: placeholderSvgPreview,\n\t\twriteFile,\n\t\tloadFontData: fetchFontBytes,\n\t}\n}\n\nasync function writeFile(fileName: string): Promise<string> {\n\tthrow new UnsupportedFeatureError(\n\t\t'runtime/file-output-unavailable',\n\t\t`Cannot write \"${fileName}\": this runtime has neither a filesystem nor a DOM. ` +\n\t\t\t'Import \"pptx-ts/node\" to write to disk or \"pptx-ts/browser\" to trigger a ' +\n\t\t\t'download; anywhere else, use write() and persist the bytes yourself.'\n\t)\n}\n","/**\n * The runtime-agnostic authoring entry, which the bare `pptx-ts` specifier resolves to when\n * neither the `node` nor the `browser` export condition applies.\n *\n * @module\n */\nimport PresentationCore from './presentation.js'\nimport { composePresentation, type ComposeOptions, type Composed } from './entry-compose.js'\nimport type { ConstructFamily } from './families/shared.js'\nimport { ALL_CONSTRUCT_FAMILIES } from './entry-families.js'\nimport { createNeutralRuntime } from './runtime/neutral.js'\n\n/**\n * The runtime-agnostic entry: what a consumer gets from the bare `pptx-ts` specifier\n * when neither the `node` nor the `browser` export condition resolves — Deno, Bun, edge workers.\n * Node and browser consumers reach `pptx-ts/node` and `pptx-ts/browser` through those conditions\n * without naming them, and get the same class backed by an adapter that can reach their host.\n *\n * Authoring is identical on all three. The difference is only where the finished deck can go:\n * `write`, `stream` and `toParts` hand the bytes back here as everywhere, while `writeFile`\n * throws `runtime/file-output-unavailable` because there is no filesystem and no DOM to write\n * to. Live-DOM `tableToSlides` is likewise absent — it is defined on the browser entry, and the\n * DOM-agnostic form is the free `tableToSlides` on `pptx-ts/html`.\n */\nexport class TsPptx extends PresentationCore {\n\tconstructor() {\n\t\tsuper(createNeutralRuntime(), ALL_CONSTRUCT_FAMILIES)\n\t}\n}\n\n/**\n * Compose a presentation from the construct families it needs, on the runtime-agnostic adapter.\n *\n * The counterpart to {@link TsPptx}, which is composed with every family there is. This one costs\n * what it carries: the core tier (text, shapes, images, groups, speaker notes) plus whatever\n * `use` names, and nothing else reaches the bundle.\n * @param {ComposeOptions} opts - the families to compose in, from `pptx-ts/families`\n * @example\n * import { createPresentation } from 'pptx-ts'\n * import { charts } from 'pptx-ts/families'\n * const pres = createPresentation({ use: [charts] })\n */\nexport function createPresentation<const Fs extends readonly ConstructFamily[] = []>(\n\topts?: ComposeOptions<Fs>\n): Composed<Fs> {\n\treturn composePresentation(createNeutralRuntime(), opts)\n}\n\nexport { TsPptx as default }\nexport * from './entry-surface.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,uBAAuC;CACtD,OAAO;EACN,qBAAqB;EACrB,YAAY,QAAQ,iBAAiB,IAAI,IAAI;EAC7C,qBAAqB;EACrB;EACA,cAAc;CACf;AACD;AAEA,eAAe,UAAU,UAAmC;CAC3D,MAAM,IAAI,wBACT,mCACA,iBAAiB,SAAS,kMAG3B;AACD;;;;;;;;;;;;;;;;;;;;;ACdA,IAAa,SAAb,cAA4B,iBAAiB;CAC5C,cAAc;EACb,MAAM,qBAAqB,GAAG,sBAAsB;CACrD;AACD;;;;;;;;;;;;;AAcA,SAAgB,mBACf,MACe;CACf,OAAO,oBAAoB,qBAAqB,GAAG,IAAI;AACxD"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/runtime/neutral.ts","../src/index.ts"],"sourcesContent":["import { UnsupportedFeatureError } from '../errors.js'\nimport type { RuntimeAdapter } from './types.js'\nimport { fetchFontBytes, fetchMediaBase64, placeholderSvgPreview } from './fetch-media.js'\n\n/**\n * The adapter for a runtime that is neither Node nor a browser: Deno, Bun, an edge worker,\n * anything that imports the bare `pptx-ts` specifier without resolving the `node` or\n * `browser` export condition.\n *\n * It implements everything that is genuinely host-neutral and refuses only what is not.\n * `fetch`, `btoa` and `TextEncoder` exist in all of these runtimes, so remote media and fonts\n * load here exactly as they do in a browser, which is why every method but `writeFile` is now\n * the shared implementation in {@link ./fetch-media} rather than a copy of it. What is missing\n * is a *destination*: there is no `node:fs` to write to and no `document` to hand a download to,\n * so {@link RuntimeAdapter.writeFile} throws a named error rather than guessing. Everything that\n * returns bytes to the caller (`write`, `stream`, `toParts`) works normally, which is the\n * shape that suits a worker anyway.\n *\n * Media loading is fetch-only here: a bare filesystem path has no meaning without a filesystem,\n * and `fetch` rejecting it is reported by the caller as a load failure naming the path.\n */\nexport function createNeutralRuntime(): RuntimeAdapter {\n\treturn {\n\t\twriteFileOutputType: null,\n\t\tloadMedia: (rel) => fetchMediaBase64(rel.path),\n\t\tcreateSvgPngPreview: placeholderSvgPreview,\n\t\twriteFile,\n\t\tloadFontData: fetchFontBytes,\n\t}\n}\n\nasync function writeFile(fileName: string): Promise<string> {\n\tthrow new UnsupportedFeatureError(\n\t\t'runtime/file-output-unavailable',\n\t\t`Cannot write \"${fileName}\": this runtime has neither a filesystem nor a DOM. ` +\n\t\t\t'Import \"pptx-ts/node\" to write to disk or \"pptx-ts/browser\" to trigger a ' +\n\t\t\t'download; anywhere else, use write() and persist the bytes yourself.'\n\t)\n}\n","/**\n * The runtime-agnostic authoring entry, which the bare `pptx-ts` specifier resolves to when\n * neither the `node` nor the `browser` export condition applies.\n *\n * @module\n */\nimport PresentationCore from './presentation.js'\nimport { composePresentation, type ComposeOptions, type Composed } from './entry-compose.js'\nimport type { ConstructFamily } from './families/shared.js'\nimport { ALL_CONSTRUCT_FAMILIES } from './entry-families.js'\nimport { createNeutralRuntime } from './runtime/neutral.js'\n\n/**\n * The runtime-agnostic entry: what a consumer gets from the bare `pptx-ts` specifier\n * when neither the `node` nor the `browser` export condition resolves: Deno, Bun, edge workers.\n * Node and browser consumers reach `pptx-ts/node` and `pptx-ts/browser` through those conditions\n * without naming them, and get the same class backed by an adapter that can reach their host.\n *\n * Authoring is identical on all three. The difference is only where the finished deck can go:\n * `write`, `stream` and `toParts` hand the bytes back here as everywhere, while `writeFile`\n * throws `runtime/file-output-unavailable` because there is no filesystem and no DOM to write\n * to. Live-DOM `tableToSlides` is likewise absent. It is defined on the browser entry, and the\n * DOM-agnostic form is the free `tableToSlides` on `pptx-ts/html`.\n */\nexport class PptxTs extends PresentationCore {\n\tconstructor() {\n\t\tsuper(createNeutralRuntime(), ALL_CONSTRUCT_FAMILIES)\n\t}\n}\n\n/**\n * Compose a presentation from the construct families it needs, on the runtime-agnostic adapter.\n *\n * The counterpart to {@link PptxTs}, which is composed with every family there is. This one costs\n * what it carries: the core tier (text, shapes, images, groups, speaker notes) plus whatever\n * `use` names, and nothing else reaches the bundle.\n * @param {ComposeOptions} opts - the families to compose in, from `pptx-ts/families`\n * @example\n * import { createPresentation } from 'pptx-ts'\n * import { charts } from 'pptx-ts/families'\n * const pres = createPresentation({ use: [charts] })\n */\nexport function createPresentation<const Fs extends readonly ConstructFamily[] = []>(\n\topts?: ComposeOptions<Fs>\n): Composed<Fs> {\n\treturn composePresentation(createNeutralRuntime(), opts)\n}\n\nexport { PptxTs as default }\n\n/** @deprecated Renamed to {@link PptxTs}. This alias is removed in v5. */\nexport const TsPptx = PptxTs\n/** @deprecated Renamed to {@link PptxTs}. This alias is removed in v5. */\nexport type TsPptx = PptxTs\n\nexport * from './entry-surface.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,uBAAuC;CACtD,OAAO;EACN,qBAAqB;EACrB,YAAY,QAAQ,iBAAiB,IAAI,IAAI;EAC7C,qBAAqB;EACrB;EACA,cAAc;CACf;AACD;AAEA,eAAe,UAAU,UAAmC;CAC3D,MAAM,IAAI,wBACT,mCACA,iBAAiB,SAAS,kMAG3B;AACD;;;;;;;;;;;;;;;;;;;;ACdA,IAAa,SAAb,cAA4B,iBAAiB;CAC5C,cAAc;EACb,MAAM,qBAAqB,GAAG,sBAAsB;CACrD;AACD;;;;;;;;;;;;;AAcA,SAAgB,mBACf,MACe;CACf,OAAO,oBAAoB,qBAAqB,GAAG,IAAI;AACxD;;AAKA,MAAa,SAAS"}

package/dist/inspect.d.ts

@@ -1,10 +1,9 @@
-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 { n as OpcPackage } from "./package-KoEgVwII.js";
-//#region src/inspect.d.ts
+import { n as OpcPackage } from "./package-CANBWuSm.js";
+import { S as UnsupportedFeatureErrorCode, _ as InternalErrorCode, a as TsPptxCode, b as PackageReadErrorCode, c as InternalError, d as PackageReadError, f as PptxTsError, g as ErrorCode, h as DiagnosticCode, i as setDiagnosticHandler, l as InvalidOptionError, m as UnsupportedFeatureError, n as DiagnosticHandler, o as TsPptxError, p as PptxTsErrorOptions, r as resetDiagnosticState, s as TsPptxErrorOptions, t as Diagnostic, u as MediaError, v as InvalidOptionErrorCode, x as PptxTsCode, y as MediaErrorCode } from "./diagnostics-MoA4MBq5.js";
 /**
  * Input to the inspect surface. A `string` is a **filesystem path** (Node) read
  * from disk; pass `Uint8Array`/`ArrayBuffer`/`Blob`/`number[]` for an in-memory
- * archive. (A string is a path, not JSZip's latin1 binary content — see
+ * archive. (A string is a path, not JSZip's latin1 binary content; see
  * `ZipInput`.)
  */
 export type PptxInspectInputValue = string | number[] | Uint8Array | ArrayBuffer | Blob;
@@ -38,7 +37,7 @@ export interface PptxTextRun {
 }
 /**
  * One paragraph (`a:p`): its runs in document order. Preserves the paragraph/line
- * boundaries that the flat {@link PptxSlideElement.textRuns} list discards — needed
+ * boundaries that the flat {@link PptxSlideElement.textRuns} list discards, needed
  * to measure a `wrap="none"` frame line-by-line (each paragraph is one unwrapped line).
  */
 export interface PptxParagraph {
@@ -46,7 +45,7 @@ export interface PptxParagraph {
 }
 /**
  * What an element is. `'group'` is a `p:grpSp` container: it has its own identity,
- * box, and fill, but no text of its own — its content is the elements that name it
+ * box, and fill, but no text of its own. Its content is the elements that name it
  * in {@link PptxSlideElement.parentZIndex}. `'graphicFrame'` is a `p:graphicFrame`
  * hosting a table, a chart or a SmartArt graphic; {@link PptxSlideElement.graphicKind}
  * says which, and it keeps that kind even when it carries text (a `'text'` element is
@@ -57,14 +56,14 @@ export type PptxSlideElementKind = 'text' | 'image' | 'shape' | 'group' | 'graph
  * What a `'graphicFrame'` element hosts, read from its `a:graphicData/@uri`:
  * a table (`a:tbl`), a classic chart (`c:chart`), a 2016-family chart
  * (`cx:chartSpace`: waterfall/funnel/treemap/…), or a SmartArt diagram. `'other'`
- * is a frame whose URI matches none of those — an OLE object, an ink part, a 3D
- * model — reported as a box so it is not silently missing from the slide.
+ * is a frame whose URI matches none of those (an OLE object, an ink part, a 3D
+ * model), reported as a box so it is not silently missing from the slide.
  */
 export type PptxGraphicKind = 'table' | 'chart' | 'chartEx' | 'diagram' | 'other';
 /**
  * Vertical-autofit mode of a text frame, read from the `a:bodyPr` child element:
  * - `'none'`: no autofit (`a:noAutofit`, or no autofit child at all). The box has a
- *   fixed height the text must fit inside — a genuine overflow candidate.
+ *   fixed height the text must fit inside: a genuine overflow candidate.
  * - `'normAutofit'`: shrink text to fit (`a:normAutofit`, pptx-ts `fit: 'shrink'`).
  *   Text is downscaled rather than overflowing.
  * - `'spAutoFit'`: resize shape to fit text (`a:spAutoFit`, pptx-ts `fit: 'resize'`).
@@ -102,7 +101,7 @@ export interface PptxSlideElement {
   zIndex: number;
   /**
    * Position and size in **slide-absolute** inches, composing every enclosing
-   * group transform — directly comparable across elements whether or not they are
+   * group transform, so it is directly comparable across elements whether or not they are
    * grouped. For a rotated element this is the unrotated placement box (the box
    * PowerPoint writes after Ungroup); see {@link rotation}.
    */
@@ -125,7 +124,7 @@ export interface PptxSlideElement {
    * this is the text the structure puts on the slide (table cells in row order,
    * SmartArt node text), which is what {@link PptxSlideInspection.text} and
    * `wordCount` then count; a chart contributes nothing, matching `Slide.text` on
-   * the read model. That text has no {@link textRuns} or {@link paragraphs} here —
+   * the read model. That text has no {@link textRuns} or {@link paragraphs} here;
    * per-run formatting inside a structure is what this surface does not flatten.
    */
   text: string;
@@ -169,7 +168,7 @@ export type PptxBoxAnchor = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bo
  */
 export declare const DEFAULT_INSPECT_SLIDE_SIZE: PptxSlideSize;
 /**
- * Load a `.pptx` as an {@link OpcPackage} — the same package model `pptx-ts/read`
+ * Load a `.pptx` as an {@link OpcPackage}, the same package model `pptx-ts/read`
  * uses, so a caller that starts here can hand the result straight to
  * `Presentation.fromPackage()` without re-reading the bytes.
  *
@@ -182,7 +181,7 @@ export declare function listPptxParts(pptxPackage: OpcPackage): string[];
 /** Read a package part as UTF-8 text, or `null` when the part is absent. */
 export declare function readPptxTextPart(pptxPackage: OpcPackage, path: string): Promise<string | null>;
 /**
- * Read a package part as raw bytes — the binary sibling of {@link readPptxTextPart}
+ * Read a package part as raw bytes: the binary sibling of {@link readPptxTextPart}
  * for embedded media (SVG/PNG/EMF blobs, fonts, …) that must not be UTF-8 decoded.
  * Returns `null` when the part is absent. The `Uint8Array` is browser-isomorphic;
  * Node consumers can wrap it with `Buffer.from(...)` if they need Buffer methods.
@@ -194,13 +193,12 @@ export declare function readPptxBinaryPart(pptxPackage: OpcPackage, path: string
 export declare function inspectPptx(input: PptxInspectInput): Promise<PptxInspection>;
 export declare function readPresentationSize(pptxPackage: OpcPackage, fallback?: PptxSlideSize): Promise<PptxSlideSize>;
 /**
- * Every slide in the deck, in **presentation order** (`p:sldIdLst`) — the order
+ * Every slide in the deck, in **presentation order** (`p:sldIdLst`): the order
  * PowerPoint shows them in, which is not the order their parts are named once a
  * deck has been reordered.
  */
 export declare function extractSlides(pptxPackage: OpcPackage, size?: PptxSlideSize): Promise<PptxSlideInspection[]>;
 export declare function overlapArea(a: PptxBox, b: PptxBox): number;
 export declare function boxAnchor(box: PptxBox, anchor: PptxBoxAnchor, axis: PptxBoxAxis): number;
-//#endregion
-export { type Diagnostic, type DiagnosticCode, type DiagnosticHandler, type ErrorCode, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, MediaError, type MediaErrorCode, PackageReadError, type PackageReadErrorCode, type TsPptxCode, TsPptxError, type TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, resetDiagnosticState, setDiagnosticHandler };
+export { type Diagnostic, type DiagnosticCode, type DiagnosticHandler, type ErrorCode, InternalError, type InternalErrorCode, InvalidOptionError, type InvalidOptionErrorCode, MediaError, type MediaErrorCode, PackageReadError, type PackageReadErrorCode, type PptxTsCode, PptxTsError, type PptxTsErrorOptions, TsPptxCode, TsPptxError, TsPptxErrorOptions, UnsupportedFeatureError, type UnsupportedFeatureErrorCode, resetDiagnosticState, setDiagnosticHandler };
 //# sourceMappingURL=inspect.d.ts.map

package/dist/inspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspect.d.ts","names":[],"sources":["../src/inspect.ts"],"mappings":";;;;;;;;;YA0CY,4CAA4C,aAAa,cAAc;YAEvE,mBAAmB,wBAAwB,QAAQ;iBAE9C;EAChB;EACA;;iBAGgB;EAChB;EACA;EACA;EACA;;iBAGgB;EAChB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;iBAQgB;EAChB,MAAM;;;;;;;;;;YAWK;;;;;;;;YASA;;;;;;;;;;YAWA;;;;;;iBAOK;EAChB;EACA;EACA;EACA;;iBAGgB;;EAEhB;EACA;EACA,MAAM;;;;;EAKN,aAAa;;;;;;;;EAQb;;;;;;;EAOA,KAAK;;;;;EAKL;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;EASA;EACA;EACA,SAAS;;;;;;EAMT;EACA,YAAY;EACZ,UAAU;;EAEV,YAAY;EACZ;EACA;EACA;EACA;EACA;;iBAGgB;EAChB;EACA;EACA;EACA,MAAM;EACN,UAAU;EACV;EACA;;iBAGgB;EAChB,WAAW;EACX,QAAQ;;YAGG;YACA;;;;;;qBAOC,4BAA4B;;;;;;;;;wBAsBnB,gBAAgB,OAAO,mBAAmB,QAAQ;;wBAKxD,cAAc,aAAa;;wBAKrB,iBAAiB,aAAa,YAAY,eAAe;;;;;;;;;;wBAczD,mBAAmB,aAAa,YAAY,eAAe,QAAQ;wBAmBnE,YAAY,OAAO,mBAAmB,QAAQ;wBAO9C,qBACrB,aAAa,YACb,WAAU,gBACR,QAAQ;;;;;;wBAWW,cAAc,aAAa,YAAY,OAAO,gBAAgB,QAAQ;wBA2C5E,YAAY,GAAG,SAAS,GAAG;wBAM3B,UAAU,KAAK,SAAS,QAAQ,eAAe,MAAM"}
+{"version":3,"file":"inspect.d.ts","names":[],"sources":["../src/inspect.ts"],"mappings":";;;;;;;;YA0CY,4CAA4C,aAAa,cAAc;YAEvE,mBAAmB,wBAAwB,QAAQ;iBAE9C;EAChB;EACA;;iBAGgB;EAChB;EACA;EACA;EACA;;iBAGgB;EAChB;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;iBAQgB;EAChB,MAAM;;;;;;;;;;YAWK;;;;;;;;YASA;;;;;;;;;;YAWA;;;;;;iBAOK;EAChB;EACA;EACA;EACA;;iBAGgB;;EAEhB;EACA;EACA,MAAM;;;;;EAKN,aAAa;;;;;;;;EAQb;;;;;;;EAOA,KAAK;;;;;EAKL;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;EASA;EACA;EACA,SAAS;;;;;;EAMT;EACA,YAAY;EACZ,UAAU;;EAEV,YAAY;EACZ;EACA;EACA;EACA;EACA;;iBAGgB;EAChB;EACA;EACA;EACA,MAAM;EACN,UAAU;EACV;EACA;;iBAGgB;EAChB,WAAW;EACX,QAAQ;;YAGG;YACA;;;;;;qBAOC,4BAA4B;;;;;;;;;wBAsBnB,gBAAgB,OAAO,mBAAmB,QAAQ;;wBAKxD,cAAc,aAAa;;wBAKrB,iBAAiB,aAAa,YAAY,eAAe;;;;;;;;;;wBAczD,mBAAmB,aAAa,YAAY,eAAe,QAAQ;wBAmBnE,YAAY,OAAO,mBAAmB,QAAQ;wBAO9C,qBACrB,aAAa,YACb,WAAU,gBACR,QAAQ;;;;;;wBAWW,cAAc,aAAa,YAAY,OAAO,gBAAgB,QAAQ;wBA2C5E,YAAY,GAAG,SAAS,GAAG;wBAM3B,UAAU,KAAK,SAAS,QAAQ,eAAe,MAAM"}

package/dist/inspect.js

@@ -1,9 +1,9 @@
-import { a as TsPptxError, c as setDiagnosticHandler, i as PackageReadError, l as warn, n as InvalidOptionError, o as UnsupportedFeatureError, r as MediaError, s as resetDiagnosticState, t as InternalError } from "./errors-Da2nXCJm.js";
-import { D as emuToInches } from "./table-cell-margins-PDshga8T.js";
-import { r as BODY_INSET_DEFAULTS_PT } from "./body-insets-kVHmjGc6.js";
-import { t as ABSENT_SLIDE_SIZE_EMU } from "./slide-size-BalTjFuv.js";
-import { p as OpcPackage, t as Presentation } from "./presentation-Cyl74rq2.js";
-//#region src/inspect.ts
+import { a as PackageReadError, c as resetDiagnosticState, i as MediaError, l as setDiagnosticHandler, n as InternalError, o as PptxTsError, r as InvalidOptionError, s as UnsupportedFeatureError, t as TsPptxError, u as warn } from "./entry-errors-JMthgJ2g.js";
+import { p as OpcPackage, t as Presentation } from "./presentation-4Ggq0_Xa.js";
+import { D as emuToInches } from "./enums-BP9wsb9Q.js";
+import { r as BODY_INSET_DEFAULTS_PT } from "./body-insets-BDHymJvz.js";
+import { t as ABSENT_SLIDE_SIZE_EMU } from "./slide-size-SkScz1ig.js";
+// src/inspect.ts
 /**
 * A cheap, flat snapshot of what a `.pptx` contains: every element on every
 * slide, with its slide-absolute box and the handful of text/fill properties a
@@ -11,8 +11,8 @@ import { p as OpcPackage, t as Presentation } from "./presentation-Cyl74rq2.js";
 *
 * It is a **projection over `pptx-ts/read`**, not a second reader. `read` gives a
 * navigable, mutable model of a package and answers questions in the shape of the
-* OOXML tree; this answers one flat question — "what is on the slides, and where"
-* — in the shape a linter, an overlap check, or a diffing tool wants. The two used
+* OOXML tree; this answers one flat question ("what is on the slides, and where")
+* in the shape a linter, an overlap check, or a diffing tool wants. The two used
 * to be independent implementations over two different XML parsers, which meant
 * every read-side fix had to be made twice and a divergence between them was
 * invisible to every test. Now the model below is the only reader, and this file
@@ -22,7 +22,7 @@ import { p as OpcPackage, t as Presentation } from "./presentation-Cyl74rq2.js";
 * `Presentation` re-exported:
 * - **Only geometry a shape carries itself.** A placeholder that inherits its box
 *   from the layout is omitted rather than resolved (`absoluteFrame`, not
-*   `resolvedFrame`) — the snapshot reports what the slide states.
+*   `resolvedFrame`): the snapshot reports what the slide states.
 * - **A `p:graphicFrame` is a box, not its contents.** A table, chart or SmartArt
 *   graphic is reported as one element with its box, its kind, and the text a
 *   reader sees on the slide, but its structure is not flattened: no per-run
@@ -40,7 +40,7 @@ const DEFAULT_INSPECT_SLIDE_SIZE = Object.freeze({
 	heightIn: round(emuToInches(ABSENT_SLIDE_SIZE_EMU.heightEmu), 3)
 });
 /**
-* Load a `.pptx` as an {@link OpcPackage} — the same package model `pptx-ts/read`
+* Load a `.pptx` as an {@link OpcPackage}, the same package model `pptx-ts/read`
 * uses, so a caller that starts here can hand the result straight to
 * `Presentation.fromPackage()` without re-reading the bytes.
 *
@@ -60,7 +60,7 @@ async function readPptxTextPart(pptxPackage, path) {
 	return bytes ? textDecoder.decode(bytes) : null;
 }
 /**
-* Read a package part as raw bytes — the binary sibling of {@link readPptxTextPart}
+* Read a package part as raw bytes: the binary sibling of {@link readPptxTextPart}
 * for embedded media (SVG/PNG/EMF blobs, fonts, …) that must not be UTF-8 decoded.
 * Returns `null` when the part is absent. The `Uint8Array` is browser-isomorphic;
 * Node consumers can wrap it with `Buffer.from(...)` if they need Buffer methods.
@@ -96,7 +96,7 @@ async function readPresentationSize(pptxPackage, fallback = DEFAULT_INSPECT_SLID
 	};
 }
 /**
-* Every slide in the deck, in **presentation order** (`p:sldIdLst`) — the order
+* Every slide in the deck, in **presentation order** (`p:sldIdLst`): the order
 * PowerPoint shows them in, which is not the order their parts are named once a
 * deck has been reordered.
 */
@@ -126,7 +126,7 @@ async function extractSlides(pptxPackage, size) {
 * `presentation.xml`. Callers here are auditing files they did not author, so a
 * package that is a valid OPC container but not a presentation reports an empty
 * deck rather than throwing. `presentationPart` is the throw site: it rejects a
-* package with no — or more than one — office-document relationship.
+* package with no office-document relationship, or with more than one.
 */
 function presentationOf(pptxPackage) {
 	const presentation = Presentation.fromPackage(pptxPackage);
@@ -172,7 +172,7 @@ function harvest(shapes, parentZIndex, out) {
 }
 /**
 * Turn harvested shapes into elements, dropping the ones with no resolvable slide
-* position. A dropped shape keeps its zIndex — the numbers are positions in the
+* position. A dropped shape keeps its zIndex: the numbers are positions in the
 * shape tree, and renumbering them would silently repoint every `parentZIndex`.
 */
 function flatten(harvested, slidePath) {
@@ -238,7 +238,7 @@ function graphicKindOf(frame) {
 }
 /**
 * The text a graphic frame puts on the slide: table cells in row order, or SmartArt
-* node text. Charts contribute nothing, matching `Slide.text` on the read model — a
+* node text. Charts contribute nothing, matching `Slide.text` on the read model: a
 * chart's strings are data labels and axis titles that PowerPoint itself does not
 * treat as slide body text.
 *
@@ -291,10 +291,10 @@ function reportUnresolvable(shape, zIndex, slidePath) {
 	if (failure === null || failure === "no-own-transform") return;
 	const who = shape.name ? `"${shape.name}"` : `the element at zIndex ${zIndex}`;
 	if (failure === "group-transform-missing") {
-		warn("inspect/group-transform-missing", `inspect: skipped ${who} on ${slidePath} — an enclosing group has no usable a:xfrm, so its slide position cannot be resolved.`);
+		warn("inspect/group-transform-missing", `inspect: skipped ${who} on ${slidePath}: an enclosing group has no usable a:xfrm, so its slide position cannot be resolved.`);
 		return;
 	}
-	warn("inspect/group-transform-degenerate", `inspect: skipped ${who} on ${slidePath} — an enclosing group has a degenerate transform (zero a:chExt), so its slide position cannot be resolved.`);
+	warn("inspect/group-transform-degenerate", `inspect: skipped ${who} on ${slidePath}: an enclosing group has a degenerate transform (zero a:chExt), so its slide position cannot be resolved.`);
 }
 function countWords(text) {
 	return text.split(/\s+/).filter(Boolean).length;
@@ -303,7 +303,6 @@ function round(value, digits) {
 	const factor = 10 ** digits;
 	return Math.round(value * factor) / factor;
 }
-//#endregion
-export { DEFAULT_INSPECT_SLIDE_SIZE, InternalError, InvalidOptionError, MediaError, PackageReadError, TsPptxError, UnsupportedFeatureError, boxAnchor, extractSlides, inspectPptx, listPptxParts, loadPptxPackage, overlapArea, readPptxBinaryPart, readPptxTextPart, readPresentationSize, resetDiagnosticState, setDiagnosticHandler };
+export { DEFAULT_INSPECT_SLIDE_SIZE, InternalError, InvalidOptionError, MediaError, PackageReadError, PptxTsError, TsPptxError, UnsupportedFeatureError, boxAnchor, extractSlides, inspectPptx, listPptxParts, loadPptxPackage, overlapArea, readPptxBinaryPart, readPptxTextPart, readPresentationSize, resetDiagnosticState, setDiagnosticHandler };
 
 //# sourceMappingURL=inspect.js.map

package/dist/inspect.js.map

@@ -1 +1 @@
-{"version":3,"file":"inspect.js","names":[],"sources":["../src/inspect.ts"],"sourcesContent":["/**\n * A cheap, flat snapshot of what a `.pptx` contains: every element on every\n * slide, with its slide-absolute box and the handful of text/fill properties a\n * layout audit asks about.\n *\n * It is a **projection over `pptx-ts/read`**, not a second reader. `read` gives a\n * navigable, mutable model of a package and answers questions in the shape of the\n * OOXML tree; this answers one flat question — \"what is on the slides, and where\"\n * — in the shape a linter, an overlap check, or a diffing tool wants. The two used\n * to be independent implementations over two different XML parsers, which meant\n * every read-side fix had to be made twice and a divergence between them was\n * invisible to every test. Now the model below is the only reader, and this file\n * is the flattening.\n *\n * What it deliberately does NOT do, and why the projection is not just\n * `Presentation` re-exported:\n * - **Only geometry a shape carries itself.** A placeholder that inherits its box\n *   from the layout is omitted rather than resolved (`absoluteFrame`, not\n *   `resolvedFrame`) — the snapshot reports what the slide states.\n * - **A `p:graphicFrame` is a box, not its contents.** A table, chart or SmartArt\n *   graphic is reported as one element with its box, its kind, and the text a\n *   reader sees on the slide, but its structure is not flattened: no per-run\n *   formatting, no cells, no series. Walk `pptx-ts/read` for what is inside one.\n *\n * @module\n */\nimport { warn } from './diagnostics.js'\nimport { OpcPackage } from './read/opc/package.js'\nimport { Presentation } from './read/api/presentation.js'\nimport type { AnyShape } from './read/api/shapes.js'\nimport type { GraphicFrame } from './read/api/shapes/graphic-frame.js'\nimport type { Run, TextFrame } from './read/api/text.js'\nimport { POINTS_PER_INCH, emuToInches } from './units.js'\nimport { BODY_INSET_DEFAULTS_PT } from './ooxml/body-insets.js'\nimport { ABSENT_SLIDE_SIZE_EMU } from './ooxml/slide-size.js'\n\n/**\n * Input to the inspect surface. A `string` is a **filesystem path** (Node) read\n * from disk; pass `Uint8Array`/`ArrayBuffer`/`Blob`/`number[]` for an in-memory\n * archive. (A string is a path, not JSZip's latin1 binary content — see\n * `ZipInput`.)\n */\nexport type PptxInspectInputValue = string | number[] | Uint8Array | ArrayBuffer | Blob\n\nexport type PptxInspectInput = PptxInspectInputValue | Promise<PptxInspectInputValue>\n\nexport interface PptxSlideSize {\n\twidthIn: number\n\theightIn: number\n}\n\nexport interface PptxBox {\n\tx: number\n\ty: number\n\tw: number\n\th: number\n}\n\nexport interface PptxTextRun {\n\ttext: string\n\tfontSizePt: number | null\n\tcolor: string | null\n\t/** Run font face (`a:rPr > a:latin@typeface`), or null when it inherits from the theme/placeholder. */\n\tfontFace: string | null\n\t/** Bold (`a:rPr@b`). */\n\tbold: boolean\n\t/** Italic (`a:rPr@i`). */\n\titalic: boolean\n\t/** Strikethrough token (`a:rPr@strike`: `noStrike`/`sngStrike`/`dblStrike`), or null when unset. */\n\tstrike: string | null\n\t/** Highlight colour hex (`a:rPr > a:highlight`), or null when unset. A theme token is resolved against the slide's theme. */\n\thighlight: string | null\n\t/** Character spacing in points (`a:rPr@spc`, authored in hundredths of a point), or null when unset. */\n\tcharSpacingPt: number | null\n}\n\n/**\n * One paragraph (`a:p`): its runs in document order. Preserves the paragraph/line\n * boundaries that the flat {@link PptxSlideElement.textRuns} list discards — needed\n * to measure a `wrap=\"none\"` frame line-by-line (each paragraph is one unwrapped line).\n */\nexport interface PptxParagraph {\n\truns: PptxTextRun[]\n}\n\n/**\n * What an element is. `'group'` is a `p:grpSp` container: it has its own identity,\n * box, and fill, but no text of its own — its content is the elements that name it\n * in {@link PptxSlideElement.parentZIndex}. `'graphicFrame'` is a `p:graphicFrame`\n * hosting a table, a chart or a SmartArt graphic; {@link PptxSlideElement.graphicKind}\n * says which, and it keeps that kind even when it carries text (a `'text'` element is\n * always a `p:sp`).\n */\nexport type PptxSlideElementKind = 'text' | 'image' | 'shape' | 'group' | 'graphicFrame'\n\n/**\n * What a `'graphicFrame'` element hosts, read from its `a:graphicData/@uri`:\n * a table (`a:tbl`), a classic chart (`c:chart`), a 2016-family chart\n * (`cx:chartSpace`: waterfall/funnel/treemap/…), or a SmartArt diagram. `'other'`\n * is a frame whose URI matches none of those — an OLE object, an ink part, a 3D\n * model — reported as a box so it is not silently missing from the slide.\n */\nexport type PptxGraphicKind = 'table' | 'chart' | 'chartEx' | 'diagram' | 'other'\n\n/**\n * Vertical-autofit mode of a text frame, read from the `a:bodyPr` child element:\n * - `'none'`: no autofit (`a:noAutofit`, or no autofit child at all). The box has a\n *   fixed height the text must fit inside — a genuine overflow candidate.\n * - `'normAutofit'`: shrink text to fit (`a:normAutofit`, pptx-ts `fit: 'shrink'`).\n *   Text is downscaled rather than overflowing.\n * - `'spAutoFit'`: resize shape to fit text (`a:spAutoFit`, pptx-ts `fit: 'resize'`).\n *   The authored height is an output, not a constraint, so the box cannot overflow.\n */\nexport type PptxAutofitMode = 'none' | 'normAutofit' | 'spAutoFit'\n\n/**\n * Text-frame body insets in inches (`a:bodyPr` `lIns`/`tIns`/`rIns`/`bIns`), with\n * PowerPoint defaults applied when an attribute is absent (0.1in left/right,\n * 0.05in top/bottom). Subtract these from {@link PptxBox} to get the inner text box.\n */\nexport interface PptxBodyInsets {\n\tleft: number\n\ttop: number\n\tright: number\n\tbottom: number\n}\n\nexport interface PptxSlideElement {\n\t/** `p:cNvPr/@id`, or `zIndex + 1` when the attribute is missing. */\n\tid: number\n\tname: string\n\tkind: PptxSlideElementKind\n\t/**\n\t * What a `'graphicFrame'` element hosts, or `null` for every other kind. See\n\t * {@link PptxGraphicKind}.\n\t */\n\tgraphicKind: PptxGraphicKind | null\n\t/**\n\t * Paint order on the slide, `0`-based: the element's position in a depth-first\n\t * walk of `p:spTree` in document order. A group is immediately followed by its\n\t * own children, which is also the order PowerPoint paints them, so a higher\n\t * `zIndex` draws on top. Unique within a slide, which is what\n\t * {@link parentZIndex} / {@link childZIndices} key on.\n\t */\n\tzIndex: number\n\t/**\n\t * Position and size in **slide-absolute** inches, composing every enclosing\n\t * group transform — directly comparable across elements whether or not they are\n\t * grouped. For a rotated element this is the unrotated placement box (the box\n\t * PowerPoint writes after Ungroup); see {@link rotation}.\n\t */\n\tbox: PptxBox\n\t/**\n\t * Effective clockwise rotation in degrees, normalised to `[0, 360)`, after\n\t * composing the element's own `a:xfrm@rot` with every enclosing group rotation.\n\t */\n\trotation: number\n\t/** Effective horizontal flip, XOR-composing the element's own `@flipH` with enclosing group flips. */\n\tflipH: boolean\n\t/** Effective vertical flip, XOR-composing the element's own `@flipV` with enclosing group flips. */\n\tflipV: boolean\n\t/** {@link zIndex} of the enclosing `'group'` element, or `null` when the element sits at slide level. */\n\tparentZIndex: number | null\n\t/** {@link zIndex} of each direct child, in document order. Empty unless {@link kind} is `'group'`. */\n\tchildZIndices: number[]\n\t/**\n\t * The element's text, whitespace-collapsed to one line. For a `'graphicFrame'`\n\t * this is the text the structure puts on the slide (table cells in row order,\n\t * SmartArt node text), which is what {@link PptxSlideInspection.text} and\n\t * `wordCount` then count; a chart contributes nothing, matching `Slide.text` on\n\t * the read model. That text has no {@link textRuns} or {@link paragraphs} here —\n\t * per-run formatting inside a structure is what this surface does not flatten.\n\t */\n\ttext: string\n\ttextWrap: string | null\n\tautofit: PptxAutofitMode | null\n\t/**\n\t * Baked shrink scale from `<a:normAutofit@fontScale>` as a percent (62.5 = 62.5%),\n\t * or null when the frame has no `normAutofit` or bakes no scale (a bare\n\t * `<a:normAutofit/>`, which PowerPoint draws at 100% until edited).\n\t */\n\tautofitFontScale: number | null\n\tbodyInsets: PptxBodyInsets | null\n\ttextRuns: PptxTextRun[]\n\t/** Runs grouped by their source paragraph (`a:p`), in document order. */\n\tparagraphs: PptxParagraph[]\n\tfontSizes: number[]\n\tcolors: string[]\n\tfill: string | null\n\tline: string | null\n\tshapeType: string | null\n}\n\nexport interface PptxSlideInspection {\n\tindex: number\n\tname: string\n\tpath: string\n\tsize: PptxSlideSize\n\telements: PptxSlideElement[]\n\ttext: string\n\twordCount: number\n}\n\nexport interface PptxInspection {\n\tslideSize: PptxSlideSize\n\tslides: PptxSlideInspection[]\n}\n\nexport type PptxBoxAxis = 'x' | 'y'\nexport type PptxBoxAnchor = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom'\n\n/**\n * The size reported for a deck that declares no `p:sldSz`: the 10in × 7.5in PowerPoint opens such\n * a deck at, which is also what the script converter assumes. It was the widescreen size, so the\n * two readers disagreed about the same deck. See `ABSENT_SLIDE_SIZE_EMU`.\n */\nexport const DEFAULT_INSPECT_SLIDE_SIZE: PptxSlideSize = Object.freeze({\n\twidthIn: round(emuToInches(ABSENT_SLIDE_SIZE_EMU.widthEmu), 3),\n\theightIn: round(emuToInches(ABSENT_SLIDE_SIZE_EMU.heightEmu), 3),\n})\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Package layer\n *\n * Thin conveniences over `OpcPackage`, kept because this surface speaks zip\n * paths (`ppt/slides/slide1.xml`) while OPC speaks partnames (`/ppt/...`), and\n * because reaching a part's bytes is the one thing a caller of a *flat* surface\n * still routinely needs.\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/**\n * Load a `.pptx` as an {@link OpcPackage} — the same package model `pptx-ts/read`\n * uses, so a caller that starts here can hand the result straight to\n * `Presentation.fromPackage()` without re-reading the bytes.\n *\n * The input must be a real OPC package: a zip that merely contains some slide XML\n * but no `[Content_Types].xml` is rejected with a `PackageReadError`.\n */\nexport async function loadPptxPackage(input: PptxInspectInput): Promise<OpcPackage> {\n\treturn OpcPackage.load(await input)\n}\n\n/** Every part in the package, as zip paths (`ppt/slides/slide1.xml`), sorted. */\nexport function listPptxParts(pptxPackage: OpcPackage): string[] {\n\treturn [...pptxPackage.parts.keys()].map(zipPathOf).sort()\n}\n\n/** Read a package part as UTF-8 text, or `null` when the part is absent. */\nexport async function readPptxTextPart(pptxPackage: OpcPackage, path: string): Promise<string | null> {\n\tconst bytes = await readPptxBinaryPart(pptxPackage, path)\n\treturn bytes ? textDecoder.decode(bytes) : null\n}\n\n/**\n * Read a package part as raw bytes — the binary sibling of {@link readPptxTextPart}\n * for embedded media (SVG/PNG/EMF blobs, fonts, …) that must not be UTF-8 decoded.\n * Returns `null` when the part is absent. The `Uint8Array` is browser-isomorphic;\n * Node consumers can wrap it with `Buffer.from(...)` if they need Buffer methods.\n *\n * The part's current body, so a package also opened as a `Presentation` and edited\n * reads back with its edits.\n */\nexport async function readPptxBinaryPart(pptxPackage: OpcPackage, path: string): Promise<Uint8Array | null> {\n\treturn pptxPackage.part(partNameOf(path))?.serialize() ?? null\n}\n\nconst textDecoder = new TextDecoder('utf-8')\n\n/** OPC partnames are absolute (`/ppt/…`); this surface speaks zip paths (`ppt/…`). */\nfunction zipPathOf(partName: string): string {\n\treturn partName.startsWith('/') ? partName.slice(1) : partName\n}\n\nfunction partNameOf(zipPath: string): string {\n\treturn zipPath.startsWith('/') ? zipPath : `/${zipPath}`\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * The surface\n * ──────────────────────────────────────────────────────────────────────────── */\n\nexport async function inspectPptx(input: PptxInspectInput): Promise<PptxInspection> {\n\tconst pptxPackage = await loadPptxPackage(input)\n\tconst slideSize = await readPresentationSize(pptxPackage)\n\tconst slides = await extractSlides(pptxPackage, slideSize)\n\treturn { slideSize, slides }\n}\n\nexport async function readPresentationSize(\n\tpptxPackage: OpcPackage,\n\tfallback: PptxSlideSize = DEFAULT_INSPECT_SLIDE_SIZE\n): Promise<PptxSlideSize> {\n\tconst size = presentationOf(pptxPackage)?.slideSize\n\tif (!size) return fallback\n\treturn { widthIn: round(size.widthIn, 3), heightIn: round(size.heightIn, 3) }\n}\n\n/**\n * Every slide in the deck, in **presentation order** (`p:sldIdLst`) — the order\n * PowerPoint shows them in, which is not the order their parts are named once a\n * deck has been reordered.\n */\nexport async function extractSlides(pptxPackage: OpcPackage, size?: PptxSlideSize): Promise<PptxSlideInspection[]> {\n\tconst slideSize = size || (await readPresentationSize(pptxPackage))\n\tconst presentation = presentationOf(pptxPackage)\n\tif (!presentation) return []\n\n\treturn presentation.slides.map((slide, index) => {\n\t\tconst path = zipPathOf(slide.partName)\n\t\tconst harvested: HarvestedShape[] = []\n\t\tharvest(slide.shapes, null, harvested) // slide level: no enclosing group\n\t\tconst elements = flatten(harvested, path)\n\t\tconst text = elements\n\t\t\t.map((el) => el.text)\n\t\t\t.filter(Boolean)\n\t\t\t.join(' ')\n\n\t\treturn {\n\t\t\tindex,\n\t\t\tname: slide.name || `Slide ${index + 1}`,\n\t\t\tpath,\n\t\t\tsize: slideSize,\n\t\t\telements,\n\t\t\ttext,\n\t\t\twordCount: countWords(text),\n\t\t}\n\t})\n}\n\n/**\n * The deck's `Presentation`, or `null` when the package holds no readable\n * `presentation.xml`. Callers here are auditing files they did not author, so a\n * package that is a valid OPC container but not a presentation reports an empty\n * deck rather than throwing. `presentationPart` is the throw site: it rejects a\n * package with no — or more than one — office-document relationship.\n */\nfunction presentationOf(pptxPackage: OpcPackage): Presentation | null {\n\tconst presentation = Presentation.fromPackage(pptxPackage)\n\ttry {\n\t\treturn presentation.presentationPart.isXmlPart ? presentation : null\n\t} catch {\n\t\treturn null\n\t}\n}\n\nexport function overlapArea(a: PptxBox, b: PptxBox): number {\n\tconst x = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x))\n\tconst y = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y))\n\treturn x * y\n}\n\nexport function boxAnchor(box: PptxBox, anchor: PptxBoxAnchor, axis: PptxBoxAxis): number {\n\tif (axis === 'x') {\n\t\tif (anchor === 'left') return box.x\n\t\tif (anchor === 'right') return box.x + box.w\n\t\treturn box.x + box.w / 2\n\t}\n\tif (anchor === 'top') return box.y\n\tif (anchor === 'bottom') return box.y + box.h\n\treturn box.y + box.h / 2\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Shape-tree harvest\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/** One harvested shape, before it is flattened into a {@link PptxSlideElement}. */\ninterface HarvestedShape {\n\tshape: AnyShape\n\tparentZIndex: number | null\n\tchildZIndices: number[]\n}\n\n/**\n * Flatten a shape list depth-first in document order: each shape is followed by\n * its descendants, which is both paint order and the order the\n * {@link PptxSlideElement.zIndex} contract promises. Every entry's index in `out`\n * is its zIndex. Returns the zIndices assigned at this level, which is what the\n * enclosing group records as its {@link PptxSlideElement.childZIndices}.\n */\nfunction harvest(shapes: AnyShape[], parentZIndex: number | null, out: HarvestedShape[]): number[] {\n\tconst zIndices: number[] = []\n\tfor (const shape of shapes) {\n\t\tconst entry: HarvestedShape = { shape, parentZIndex, childZIndices: [] }\n\t\tconst zIndex = out.push(entry) - 1\n\t\tzIndices.push(zIndex)\n\t\tif (shape.shapeType === 'group') entry.childZIndices = harvest(shape.shapes, zIndex, out)\n\t}\n\treturn zIndices\n}\n\n/**\n * Turn harvested shapes into elements, dropping the ones with no resolvable slide\n * position. A dropped shape keeps its zIndex — the numbers are positions in the\n * shape tree, and renumbering them would silently repoint every `parentZIndex`.\n */\nfunction flatten(harvested: HarvestedShape[], slidePath: string): PptxSlideElement[] {\n\treturn harvested\n\t\t.map((entry, zIndex) => toElement(entry, zIndex, slidePath))\n\t\t.filter((element): element is PptxSlideElement => Boolean(element))\n}\n\nfunction toElement(entry: HarvestedShape, zIndex: number, slidePath: string): PptxSlideElement | null {\n\tconst { shape } = entry\n\tconst frame = shape.absoluteFrame\n\tif (!frame) {\n\t\treportUnresolvable(shape, zIndex, slidePath)\n\t\treturn null\n\t}\n\n\t// Only `p:sp` holds a text body, so every other kind projects as an empty frame.\n\tconst textFrame = shape.textFrame\n\tconst paragraphs = textFrame ? textFrame.paragraphs.map((p) => ({ runs: p.runs.map(toRun) })) : []\n\tconst textRuns = paragraphs.flatMap((paragraph) => paragraph.runs)\n\t// A graphic frame has no text body of its own; its text comes from the structure\n\t// it hosts, and arrives as a plain string with no runs behind it.\n\t// Paragraphs are joined by a line break, so the last word of one and the first of the next stay\n\t// two words once the whitespace collapses below.\n\tconst runText = paragraphs.map((paragraph) => paragraph.runs.map((run) => run.text).join('')).join('\\n')\n\tconst raw = shape.shapeType === 'graphicFrame' ? graphicFrameText(shape) : runText\n\t// Deliberately not `TextFrame.text`: this is one whitespace-collapsed line for\n\t// matching and word-counting, not the frame's text with its line structure.\n\tconst text = raw.replace(/\\s+/g, ' ').trim()\n\tconst kind: PptxSlideElementKind =\n\t\tshape.shapeType === 'group'\n\t\t\t? 'group'\n\t\t\t: shape.shapeType === 'graphicFrame'\n\t\t\t\t? 'graphicFrame'\n\t\t\t\t: text\n\t\t\t\t\t? 'text'\n\t\t\t\t\t: shape.shapeType === 'picture'\n\t\t\t\t\t\t? 'image'\n\t\t\t\t\t\t: 'shape'\n\n\treturn {\n\t\tid: shape.id ?? zIndex + 1,\n\t\tname: shape.name || `${kind} ${zIndex + 1}`,\n\t\tkind,\n\t\tgraphicKind: shape.shapeType === 'graphicFrame' ? graphicKindOf(shape) : null,\n\t\tzIndex,\n\t\tbox: {\n\t\t\tx: emuToInches(frame.left),\n\t\t\ty: emuToInches(frame.top),\n\t\t\tw: emuToInches(frame.width),\n\t\t\th: emuToInches(frame.height),\n\t\t},\n\t\trotation: frame.rotation,\n\t\tflipH: frame.flipH,\n\t\tflipV: frame.flipV,\n\t\tparentZIndex: entry.parentZIndex,\n\t\tchildZIndices: entry.childZIndices,\n\t\ttext,\n\t\ttextWrap: textFrame?.bodyProperties?.wrap ?? null,\n\t\tautofit: textFrame?.autofit ?? null,\n\t\tautofitFontScale: textFrame?.autofitFontScale ?? null,\n\t\tbodyInsets: readBodyInsets(textFrame),\n\t\ttextRuns,\n\t\tparagraphs,\n\t\tfontSizes: [...new Set(textRuns.map((run) => run.fontSizePt).filter((size): size is number => size !== null))],\n\t\tcolors: [...new Set(textRuns.map((run) => run.color).filter((color): color is string => Boolean(color)))],\n\t\tfill: shape.fillColor,\n\t\tline: shape.lineColor,\n\t\tshapeType: shape.presetGeometry,\n\t}\n}\n\n/**\n * What a graphic frame hosts, from the same `a:graphicData/@uri` the read model's\n * `has*` predicates compare against. A frame that answers none of them is `'other'`\n * rather than dropped: a box the deck's author placed is on the slide whether or not\n * this library models its payload, and an overlap or coverage check that skipped it\n * would report a gap where a 3D model or an OLE object sits.\n */\nfunction graphicKindOf(frame: GraphicFrame): PptxGraphicKind {\n\tif (frame.hasTable) return 'table'\n\tif (frame.hasChart) return 'chart'\n\tif (frame.hasChartEx) return 'chartEx'\n\tif (frame.hasDiagram) return 'diagram'\n\treturn 'other'\n}\n\n/**\n * The text a graphic frame puts on the slide: table cells in row order, or SmartArt\n * node text. Charts contribute nothing, matching `Slide.text` on the read model — a\n * chart's strings are data labels and axis titles that PowerPoint itself does not\n * treat as slide body text.\n *\n * Separators are single spaces rather than the read model's `\t`/`\n`, because the\n * caller collapses whitespace anyway; the point here is only that cells do not run\n * together into one word.\n */\nfunction graphicFrameText(frame: GraphicFrame): string {\n\tconst table = frame.table\n\tif (table) return table.rows.map((row) => row.cells.map((cell) => cell.text).join(' ')).join(' ')\n\treturn frame.diagram?.text ?? ''\n}\n\n/** Project one read-model {@link Run} onto the flat run shape. */\nfunction toRun(run: Run): PptxTextRun {\n\treturn {\n\t\ttext: run.text,\n\t\tfontSizePt: run.fontSizePt,\n\t\tcolor: run.color,\n\t\tfontFace: run.fontName,\n\t\t// The read model distinguishes \"explicitly not bold\" from \"unset, inherits\";\n\t\t// this surface reports what renders, so an unset flag is `false`.\n\t\tbold: run.bold ?? false,\n\t\titalic: run.italic ?? false,\n\t\tstrike: run.strike,\n\t\thighlight: run.highlight?.hex ?? null,\n\t\tcharSpacingPt: run.charSpacingPt,\n\t}\n}\n\nfunction readBodyInsets(textFrame: TextFrame | null): PptxBodyInsets | null {\n\tconst insets = textFrame?.bodyProperties?.insetsPt\n\tif (!insets) return null\n\t// The read model reports only the explicitly-set sides; an omitted one takes PowerPoint's\n\t// own default rather than zero.\n\tconst inches = (pt: number | undefined, fallbackPt: number): number =>\n\t\t(pt === undefined ? fallbackPt : pt) / POINTS_PER_INCH\n\treturn {\n\t\tleft: inches(insets.left, BODY_INSET_DEFAULTS_PT.left),\n\t\ttop: inches(insets.top, BODY_INSET_DEFAULTS_PT.top),\n\t\tright: inches(insets.right, BODY_INSET_DEFAULTS_PT.right),\n\t\tbottom: inches(insets.bottom, BODY_INSET_DEFAULTS_PT.bottom),\n\t}\n}\n\n/**\n * Warn about a shape whose slide position cannot be resolved, unless it never\n * claimed one.\n *\n * `absoluteFrame` is `null` for three different situations and only two of them\n * are worth telling the caller about; `absoluteFrameFailure` is the read model\n * naming which, so this surface does not walk the ancestry a second time to\n * re-derive it.\n */\nfunction reportUnresolvable(shape: AnyShape, zIndex: number, slidePath: string): void {\n\tconst failure = shape.absoluteFrameFailure\n\t// No own `a:xfrm` at all: the shape inherits its geometry from a layout\n\t// placeholder, which this surface deliberately does not resolve. Nothing is\n\t// wrong with the deck, so nothing is reported. (`null` cannot reach here — the\n\t// caller only calls this for a shape whose frame did not resolve.)\n\tif (failure === null || failure === 'no-own-transform') return\n\n\tconst who = shape.name ? `\"${shape.name}\"` : `the element at zIndex ${zIndex}`\n\tif (failure === 'group-transform-missing') {\n\t\twarn(\n\t\t\t'inspect/group-transform-missing',\n\t\t\t`inspect: skipped ${who} on ${slidePath} — an enclosing group has no usable a:xfrm, so its slide position cannot be resolved.`\n\t\t)\n\t\treturn\n\t}\n\twarn(\n\t\t'inspect/group-transform-degenerate',\n\t\t`inspect: skipped ${who} on ${slidePath} — an enclosing group has a degenerate transform (zero a:chExt), so its slide position cannot be resolved.`\n\t)\n}\n\nfunction countWords(text: string): number {\n\treturn text.split(/\\s+/).filter(Boolean).length\n}\n\nfunction round(value: number, digits: number): number {\n\tconst factor = 10 ** digits\n\treturn Math.round(value * factor) / factor\n}\n\n// Error taxonomy — see `entry-errors.ts`. Re-exported from every entry so `instanceof`\n// works whichever subpath a consumer imports.\nexport * from './entry-errors.js'\n\n// Diagnostics — see `entry-diagnostics.ts`. Re-exported from every entry so a consumer of any\n// subpath can install a handler for the warnings that subpath emits.\nexport * from './entry-diagnostics.js'\n"],"mappings":"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"}
+{"version":3,"file":"inspect.js","names":[],"sources":["../src/inspect.ts"],"sourcesContent":["/**\n * A cheap, flat snapshot of what a `.pptx` contains: every element on every\n * slide, with its slide-absolute box and the handful of text/fill properties a\n * layout audit asks about.\n *\n * It is a **projection over `pptx-ts/read`**, not a second reader. `read` gives a\n * navigable, mutable model of a package and answers questions in the shape of the\n * OOXML tree; this answers one flat question (\"what is on the slides, and where\")\n * in the shape a linter, an overlap check, or a diffing tool wants. The two used\n * to be independent implementations over two different XML parsers, which meant\n * every read-side fix had to be made twice and a divergence between them was\n * invisible to every test. Now the model below is the only reader, and this file\n * is the flattening.\n *\n * What it deliberately does NOT do, and why the projection is not just\n * `Presentation` re-exported:\n * - **Only geometry a shape carries itself.** A placeholder that inherits its box\n *   from the layout is omitted rather than resolved (`absoluteFrame`, not\n *   `resolvedFrame`): the snapshot reports what the slide states.\n * - **A `p:graphicFrame` is a box, not its contents.** A table, chart or SmartArt\n *   graphic is reported as one element with its box, its kind, and the text a\n *   reader sees on the slide, but its structure is not flattened: no per-run\n *   formatting, no cells, no series. Walk `pptx-ts/read` for what is inside one.\n *\n * @module\n */\nimport { warn } from './diagnostics.js'\nimport { OpcPackage } from './read/opc/package.js'\nimport { Presentation } from './read/api/presentation.js'\nimport type { AnyShape } from './read/api/shapes.js'\nimport type { GraphicFrame } from './read/api/shapes/graphic-frame.js'\nimport type { Run, TextFrame } from './read/api/text.js'\nimport { POINTS_PER_INCH, emuToInches } from './units.js'\nimport { BODY_INSET_DEFAULTS_PT } from './ooxml/body-insets.js'\nimport { ABSENT_SLIDE_SIZE_EMU } from './ooxml/slide-size.js'\n\n/**\n * Input to the inspect surface. A `string` is a **filesystem path** (Node) read\n * from disk; pass `Uint8Array`/`ArrayBuffer`/`Blob`/`number[]` for an in-memory\n * archive. (A string is a path, not JSZip's latin1 binary content; see\n * `ZipInput`.)\n */\nexport type PptxInspectInputValue = string | number[] | Uint8Array | ArrayBuffer | Blob\n\nexport type PptxInspectInput = PptxInspectInputValue | Promise<PptxInspectInputValue>\n\nexport interface PptxSlideSize {\n\twidthIn: number\n\theightIn: number\n}\n\nexport interface PptxBox {\n\tx: number\n\ty: number\n\tw: number\n\th: number\n}\n\nexport interface PptxTextRun {\n\ttext: string\n\tfontSizePt: number | null\n\tcolor: string | null\n\t/** Run font face (`a:rPr > a:latin@typeface`), or null when it inherits from the theme/placeholder. */\n\tfontFace: string | null\n\t/** Bold (`a:rPr@b`). */\n\tbold: boolean\n\t/** Italic (`a:rPr@i`). */\n\titalic: boolean\n\t/** Strikethrough token (`a:rPr@strike`: `noStrike`/`sngStrike`/`dblStrike`), or null when unset. */\n\tstrike: string | null\n\t/** Highlight colour hex (`a:rPr > a:highlight`), or null when unset. A theme token is resolved against the slide's theme. */\n\thighlight: string | null\n\t/** Character spacing in points (`a:rPr@spc`, authored in hundredths of a point), or null when unset. */\n\tcharSpacingPt: number | null\n}\n\n/**\n * One paragraph (`a:p`): its runs in document order. Preserves the paragraph/line\n * boundaries that the flat {@link PptxSlideElement.textRuns} list discards, needed\n * to measure a `wrap=\"none\"` frame line-by-line (each paragraph is one unwrapped line).\n */\nexport interface PptxParagraph {\n\truns: PptxTextRun[]\n}\n\n/**\n * What an element is. `'group'` is a `p:grpSp` container: it has its own identity,\n * box, and fill, but no text of its own. Its content is the elements that name it\n * in {@link PptxSlideElement.parentZIndex}. `'graphicFrame'` is a `p:graphicFrame`\n * hosting a table, a chart or a SmartArt graphic; {@link PptxSlideElement.graphicKind}\n * says which, and it keeps that kind even when it carries text (a `'text'` element is\n * always a `p:sp`).\n */\nexport type PptxSlideElementKind = 'text' | 'image' | 'shape' | 'group' | 'graphicFrame'\n\n/**\n * What a `'graphicFrame'` element hosts, read from its `a:graphicData/@uri`:\n * a table (`a:tbl`), a classic chart (`c:chart`), a 2016-family chart\n * (`cx:chartSpace`: waterfall/funnel/treemap/…), or a SmartArt diagram. `'other'`\n * is a frame whose URI matches none of those (an OLE object, an ink part, a 3D\n * model), reported as a box so it is not silently missing from the slide.\n */\nexport type PptxGraphicKind = 'table' | 'chart' | 'chartEx' | 'diagram' | 'other'\n\n/**\n * Vertical-autofit mode of a text frame, read from the `a:bodyPr` child element:\n * - `'none'`: no autofit (`a:noAutofit`, or no autofit child at all). The box has a\n *   fixed height the text must fit inside: a genuine overflow candidate.\n * - `'normAutofit'`: shrink text to fit (`a:normAutofit`, pptx-ts `fit: 'shrink'`).\n *   Text is downscaled rather than overflowing.\n * - `'spAutoFit'`: resize shape to fit text (`a:spAutoFit`, pptx-ts `fit: 'resize'`).\n *   The authored height is an output, not a constraint, so the box cannot overflow.\n */\nexport type PptxAutofitMode = 'none' | 'normAutofit' | 'spAutoFit'\n\n/**\n * Text-frame body insets in inches (`a:bodyPr` `lIns`/`tIns`/`rIns`/`bIns`), with\n * PowerPoint defaults applied when an attribute is absent (0.1in left/right,\n * 0.05in top/bottom). Subtract these from {@link PptxBox} to get the inner text box.\n */\nexport interface PptxBodyInsets {\n\tleft: number\n\ttop: number\n\tright: number\n\tbottom: number\n}\n\nexport interface PptxSlideElement {\n\t/** `p:cNvPr/@id`, or `zIndex + 1` when the attribute is missing. */\n\tid: number\n\tname: string\n\tkind: PptxSlideElementKind\n\t/**\n\t * What a `'graphicFrame'` element hosts, or `null` for every other kind. See\n\t * {@link PptxGraphicKind}.\n\t */\n\tgraphicKind: PptxGraphicKind | null\n\t/**\n\t * Paint order on the slide, `0`-based: the element's position in a depth-first\n\t * walk of `p:spTree` in document order. A group is immediately followed by its\n\t * own children, which is also the order PowerPoint paints them, so a higher\n\t * `zIndex` draws on top. Unique within a slide, which is what\n\t * {@link parentZIndex} / {@link childZIndices} key on.\n\t */\n\tzIndex: number\n\t/**\n\t * Position and size in **slide-absolute** inches, composing every enclosing\n\t * group transform, so it is directly comparable across elements whether or not they are\n\t * grouped. For a rotated element this is the unrotated placement box (the box\n\t * PowerPoint writes after Ungroup); see {@link rotation}.\n\t */\n\tbox: PptxBox\n\t/**\n\t * Effective clockwise rotation in degrees, normalised to `[0, 360)`, after\n\t * composing the element's own `a:xfrm@rot` with every enclosing group rotation.\n\t */\n\trotation: number\n\t/** Effective horizontal flip, XOR-composing the element's own `@flipH` with enclosing group flips. */\n\tflipH: boolean\n\t/** Effective vertical flip, XOR-composing the element's own `@flipV` with enclosing group flips. */\n\tflipV: boolean\n\t/** {@link zIndex} of the enclosing `'group'` element, or `null` when the element sits at slide level. */\n\tparentZIndex: number | null\n\t/** {@link zIndex} of each direct child, in document order. Empty unless {@link kind} is `'group'`. */\n\tchildZIndices: number[]\n\t/**\n\t * The element's text, whitespace-collapsed to one line. For a `'graphicFrame'`\n\t * this is the text the structure puts on the slide (table cells in row order,\n\t * SmartArt node text), which is what {@link PptxSlideInspection.text} and\n\t * `wordCount` then count; a chart contributes nothing, matching `Slide.text` on\n\t * the read model. That text has no {@link textRuns} or {@link paragraphs} here;\n\t * per-run formatting inside a structure is what this surface does not flatten.\n\t */\n\ttext: string\n\ttextWrap: string | null\n\tautofit: PptxAutofitMode | null\n\t/**\n\t * Baked shrink scale from `<a:normAutofit@fontScale>` as a percent (62.5 = 62.5%),\n\t * or null when the frame has no `normAutofit` or bakes no scale (a bare\n\t * `<a:normAutofit/>`, which PowerPoint draws at 100% until edited).\n\t */\n\tautofitFontScale: number | null\n\tbodyInsets: PptxBodyInsets | null\n\ttextRuns: PptxTextRun[]\n\t/** Runs grouped by their source paragraph (`a:p`), in document order. */\n\tparagraphs: PptxParagraph[]\n\tfontSizes: number[]\n\tcolors: string[]\n\tfill: string | null\n\tline: string | null\n\tshapeType: string | null\n}\n\nexport interface PptxSlideInspection {\n\tindex: number\n\tname: string\n\tpath: string\n\tsize: PptxSlideSize\n\telements: PptxSlideElement[]\n\ttext: string\n\twordCount: number\n}\n\nexport interface PptxInspection {\n\tslideSize: PptxSlideSize\n\tslides: PptxSlideInspection[]\n}\n\nexport type PptxBoxAxis = 'x' | 'y'\nexport type PptxBoxAnchor = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom'\n\n/**\n * The size reported for a deck that declares no `p:sldSz`: the 10in × 7.5in PowerPoint opens such\n * a deck at, which is also what the script converter assumes. It was the widescreen size, so the\n * two readers disagreed about the same deck. See `ABSENT_SLIDE_SIZE_EMU`.\n */\nexport const DEFAULT_INSPECT_SLIDE_SIZE: PptxSlideSize = Object.freeze({\n\twidthIn: round(emuToInches(ABSENT_SLIDE_SIZE_EMU.widthEmu), 3),\n\theightIn: round(emuToInches(ABSENT_SLIDE_SIZE_EMU.heightEmu), 3),\n})\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Package layer\n *\n * Thin conveniences over `OpcPackage`, kept because this surface speaks zip\n * paths (`ppt/slides/slide1.xml`) while OPC speaks partnames (`/ppt/...`), and\n * because reaching a part's bytes is the one thing a caller of a *flat* surface\n * still routinely needs.\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/**\n * Load a `.pptx` as an {@link OpcPackage}, the same package model `pptx-ts/read`\n * uses, so a caller that starts here can hand the result straight to\n * `Presentation.fromPackage()` without re-reading the bytes.\n *\n * The input must be a real OPC package: a zip that merely contains some slide XML\n * but no `[Content_Types].xml` is rejected with a `PackageReadError`.\n */\nexport async function loadPptxPackage(input: PptxInspectInput): Promise<OpcPackage> {\n\treturn OpcPackage.load(await input)\n}\n\n/** Every part in the package, as zip paths (`ppt/slides/slide1.xml`), sorted. */\nexport function listPptxParts(pptxPackage: OpcPackage): string[] {\n\treturn [...pptxPackage.parts.keys()].map(zipPathOf).sort()\n}\n\n/** Read a package part as UTF-8 text, or `null` when the part is absent. */\nexport async function readPptxTextPart(pptxPackage: OpcPackage, path: string): Promise<string | null> {\n\tconst bytes = await readPptxBinaryPart(pptxPackage, path)\n\treturn bytes ? textDecoder.decode(bytes) : null\n}\n\n/**\n * Read a package part as raw bytes: the binary sibling of {@link readPptxTextPart}\n * for embedded media (SVG/PNG/EMF blobs, fonts, …) that must not be UTF-8 decoded.\n * Returns `null` when the part is absent. The `Uint8Array` is browser-isomorphic;\n * Node consumers can wrap it with `Buffer.from(...)` if they need Buffer methods.\n *\n * The part's current body, so a package also opened as a `Presentation` and edited\n * reads back with its edits.\n */\nexport async function readPptxBinaryPart(pptxPackage: OpcPackage, path: string): Promise<Uint8Array | null> {\n\treturn pptxPackage.part(partNameOf(path))?.serialize() ?? null\n}\n\nconst textDecoder = new TextDecoder('utf-8')\n\n/** OPC partnames are absolute (`/ppt/…`); this surface speaks zip paths (`ppt/…`). */\nfunction zipPathOf(partName: string): string {\n\treturn partName.startsWith('/') ? partName.slice(1) : partName\n}\n\nfunction partNameOf(zipPath: string): string {\n\treturn zipPath.startsWith('/') ? zipPath : `/${zipPath}`\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * The surface\n * ──────────────────────────────────────────────────────────────────────────── */\n\nexport async function inspectPptx(input: PptxInspectInput): Promise<PptxInspection> {\n\tconst pptxPackage = await loadPptxPackage(input)\n\tconst slideSize = await readPresentationSize(pptxPackage)\n\tconst slides = await extractSlides(pptxPackage, slideSize)\n\treturn { slideSize, slides }\n}\n\nexport async function readPresentationSize(\n\tpptxPackage: OpcPackage,\n\tfallback: PptxSlideSize = DEFAULT_INSPECT_SLIDE_SIZE\n): Promise<PptxSlideSize> {\n\tconst size = presentationOf(pptxPackage)?.slideSize\n\tif (!size) return fallback\n\treturn { widthIn: round(size.widthIn, 3), heightIn: round(size.heightIn, 3) }\n}\n\n/**\n * Every slide in the deck, in **presentation order** (`p:sldIdLst`): the order\n * PowerPoint shows them in, which is not the order their parts are named once a\n * deck has been reordered.\n */\nexport async function extractSlides(pptxPackage: OpcPackage, size?: PptxSlideSize): Promise<PptxSlideInspection[]> {\n\tconst slideSize = size || (await readPresentationSize(pptxPackage))\n\tconst presentation = presentationOf(pptxPackage)\n\tif (!presentation) return []\n\n\treturn presentation.slides.map((slide, index) => {\n\t\tconst path = zipPathOf(slide.partName)\n\t\tconst harvested: HarvestedShape[] = []\n\t\tharvest(slide.shapes, null, harvested) // slide level: no enclosing group\n\t\tconst elements = flatten(harvested, path)\n\t\tconst text = elements\n\t\t\t.map((el) => el.text)\n\t\t\t.filter(Boolean)\n\t\t\t.join(' ')\n\n\t\treturn {\n\t\t\tindex,\n\t\t\tname: slide.name || `Slide ${index + 1}`,\n\t\t\tpath,\n\t\t\tsize: slideSize,\n\t\t\telements,\n\t\t\ttext,\n\t\t\twordCount: countWords(text),\n\t\t}\n\t})\n}\n\n/**\n * The deck's `Presentation`, or `null` when the package holds no readable\n * `presentation.xml`. Callers here are auditing files they did not author, so a\n * package that is a valid OPC container but not a presentation reports an empty\n * deck rather than throwing. `presentationPart` is the throw site: it rejects a\n * package with no office-document relationship, or with more than one.\n */\nfunction presentationOf(pptxPackage: OpcPackage): Presentation | null {\n\tconst presentation = Presentation.fromPackage(pptxPackage)\n\ttry {\n\t\treturn presentation.presentationPart.isXmlPart ? presentation : null\n\t} catch {\n\t\treturn null\n\t}\n}\n\nexport function overlapArea(a: PptxBox, b: PptxBox): number {\n\tconst x = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x))\n\tconst y = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y))\n\treturn x * y\n}\n\nexport function boxAnchor(box: PptxBox, anchor: PptxBoxAnchor, axis: PptxBoxAxis): number {\n\tif (axis === 'x') {\n\t\tif (anchor === 'left') return box.x\n\t\tif (anchor === 'right') return box.x + box.w\n\t\treturn box.x + box.w / 2\n\t}\n\tif (anchor === 'top') return box.y\n\tif (anchor === 'bottom') return box.y + box.h\n\treturn box.y + box.h / 2\n}\n\n/* ────────────────────────────────────────────────────────────────────────────\n * Shape-tree harvest\n * ──────────────────────────────────────────────────────────────────────────── */\n\n/** One harvested shape, before it is flattened into a {@link PptxSlideElement}. */\ninterface HarvestedShape {\n\tshape: AnyShape\n\tparentZIndex: number | null\n\tchildZIndices: number[]\n}\n\n/**\n * Flatten a shape list depth-first in document order: each shape is followed by\n * its descendants, which is both paint order and the order the\n * {@link PptxSlideElement.zIndex} contract promises. Every entry's index in `out`\n * is its zIndex. Returns the zIndices assigned at this level, which is what the\n * enclosing group records as its {@link PptxSlideElement.childZIndices}.\n */\nfunction harvest(shapes: AnyShape[], parentZIndex: number | null, out: HarvestedShape[]): number[] {\n\tconst zIndices: number[] = []\n\tfor (const shape of shapes) {\n\t\tconst entry: HarvestedShape = { shape, parentZIndex, childZIndices: [] }\n\t\tconst zIndex = out.push(entry) - 1\n\t\tzIndices.push(zIndex)\n\t\tif (shape.shapeType === 'group') entry.childZIndices = harvest(shape.shapes, zIndex, out)\n\t}\n\treturn zIndices\n}\n\n/**\n * Turn harvested shapes into elements, dropping the ones with no resolvable slide\n * position. A dropped shape keeps its zIndex: the numbers are positions in the\n * shape tree, and renumbering them would silently repoint every `parentZIndex`.\n */\nfunction flatten(harvested: HarvestedShape[], slidePath: string): PptxSlideElement[] {\n\treturn harvested\n\t\t.map((entry, zIndex) => toElement(entry, zIndex, slidePath))\n\t\t.filter((element): element is PptxSlideElement => Boolean(element))\n}\n\nfunction toElement(entry: HarvestedShape, zIndex: number, slidePath: string): PptxSlideElement | null {\n\tconst { shape } = entry\n\tconst frame = shape.absoluteFrame\n\tif (!frame) {\n\t\treportUnresolvable(shape, zIndex, slidePath)\n\t\treturn null\n\t}\n\n\t// Only `p:sp` holds a text body, so every other kind projects as an empty frame.\n\tconst textFrame = shape.textFrame\n\tconst paragraphs = textFrame ? textFrame.paragraphs.map((p) => ({ runs: p.runs.map(toRun) })) : []\n\tconst textRuns = paragraphs.flatMap((paragraph) => paragraph.runs)\n\t// A graphic frame has no text body of its own; its text comes from the structure\n\t// it hosts, and arrives as a plain string with no runs behind it.\n\t// Paragraphs are joined by a line break, so the last word of one and the first of the next stay\n\t// two words once the whitespace collapses below.\n\tconst runText = paragraphs.map((paragraph) => paragraph.runs.map((run) => run.text).join('')).join('\\n')\n\tconst raw = shape.shapeType === 'graphicFrame' ? graphicFrameText(shape) : runText\n\t// Deliberately not `TextFrame.text`: this is one whitespace-collapsed line for\n\t// matching and word-counting, not the frame's text with its line structure.\n\tconst text = raw.replace(/\\s+/g, ' ').trim()\n\tconst kind: PptxSlideElementKind =\n\t\tshape.shapeType === 'group'\n\t\t\t? 'group'\n\t\t\t: shape.shapeType === 'graphicFrame'\n\t\t\t\t? 'graphicFrame'\n\t\t\t\t: text\n\t\t\t\t\t? 'text'\n\t\t\t\t\t: shape.shapeType === 'picture'\n\t\t\t\t\t\t? 'image'\n\t\t\t\t\t\t: 'shape'\n\n\treturn {\n\t\tid: shape.id ?? zIndex + 1,\n\t\tname: shape.name || `${kind} ${zIndex + 1}`,\n\t\tkind,\n\t\tgraphicKind: shape.shapeType === 'graphicFrame' ? graphicKindOf(shape) : null,\n\t\tzIndex,\n\t\tbox: {\n\t\t\tx: emuToInches(frame.left),\n\t\t\ty: emuToInches(frame.top),\n\t\t\tw: emuToInches(frame.width),\n\t\t\th: emuToInches(frame.height),\n\t\t},\n\t\trotation: frame.rotation,\n\t\tflipH: frame.flipH,\n\t\tflipV: frame.flipV,\n\t\tparentZIndex: entry.parentZIndex,\n\t\tchildZIndices: entry.childZIndices,\n\t\ttext,\n\t\ttextWrap: textFrame?.bodyProperties?.wrap ?? null,\n\t\tautofit: textFrame?.autofit ?? null,\n\t\tautofitFontScale: textFrame?.autofitFontScale ?? null,\n\t\tbodyInsets: readBodyInsets(textFrame),\n\t\ttextRuns,\n\t\tparagraphs,\n\t\tfontSizes: [...new Set(textRuns.map((run) => run.fontSizePt).filter((size): size is number => size !== null))],\n\t\tcolors: [...new Set(textRuns.map((run) => run.color).filter((color): color is string => Boolean(color)))],\n\t\tfill: shape.fillColor,\n\t\tline: shape.lineColor,\n\t\tshapeType: shape.presetGeometry,\n\t}\n}\n\n/**\n * What a graphic frame hosts, from the same `a:graphicData/@uri` the read model's\n * `has*` predicates compare against. A frame that answers none of them is `'other'`\n * rather than dropped: a box the deck's author placed is on the slide whether or not\n * this library models its payload, and an overlap or coverage check that skipped it\n * would report a gap where a 3D model or an OLE object sits.\n */\nfunction graphicKindOf(frame: GraphicFrame): PptxGraphicKind {\n\tif (frame.hasTable) return 'table'\n\tif (frame.hasChart) return 'chart'\n\tif (frame.hasChartEx) return 'chartEx'\n\tif (frame.hasDiagram) return 'diagram'\n\treturn 'other'\n}\n\n/**\n * The text a graphic frame puts on the slide: table cells in row order, or SmartArt\n * node text. Charts contribute nothing, matching `Slide.text` on the read model: a\n * chart's strings are data labels and axis titles that PowerPoint itself does not\n * treat as slide body text.\n *\n * Separators are single spaces rather than the read model's `\t`/`\n`, because the\n * caller collapses whitespace anyway; the point here is only that cells do not run\n * together into one word.\n */\nfunction graphicFrameText(frame: GraphicFrame): string {\n\tconst table = frame.table\n\tif (table) return table.rows.map((row) => row.cells.map((cell) => cell.text).join(' ')).join(' ')\n\treturn frame.diagram?.text ?? ''\n}\n\n/** Project one read-model {@link Run} onto the flat run shape. */\nfunction toRun(run: Run): PptxTextRun {\n\treturn {\n\t\ttext: run.text,\n\t\tfontSizePt: run.fontSizePt,\n\t\tcolor: run.color,\n\t\tfontFace: run.fontName,\n\t\t// The read model distinguishes \"explicitly not bold\" from \"unset, inherits\";\n\t\t// this surface reports what renders, so an unset flag is `false`.\n\t\tbold: run.bold ?? false,\n\t\titalic: run.italic ?? false,\n\t\tstrike: run.strike,\n\t\thighlight: run.highlight?.hex ?? null,\n\t\tcharSpacingPt: run.charSpacingPt,\n\t}\n}\n\nfunction readBodyInsets(textFrame: TextFrame | null): PptxBodyInsets | null {\n\tconst insets = textFrame?.bodyProperties?.insetsPt\n\tif (!insets) return null\n\t// The read model reports only the explicitly-set sides; an omitted one takes PowerPoint's\n\t// own default rather than zero.\n\tconst inches = (pt: number | undefined, fallbackPt: number): number =>\n\t\t(pt === undefined ? fallbackPt : pt) / POINTS_PER_INCH\n\treturn {\n\t\tleft: inches(insets.left, BODY_INSET_DEFAULTS_PT.left),\n\t\ttop: inches(insets.top, BODY_INSET_DEFAULTS_PT.top),\n\t\tright: inches(insets.right, BODY_INSET_DEFAULTS_PT.right),\n\t\tbottom: inches(insets.bottom, BODY_INSET_DEFAULTS_PT.bottom),\n\t}\n}\n\n/**\n * Warn about a shape whose slide position cannot be resolved, unless it never\n * claimed one.\n *\n * `absoluteFrame` is `null` for three different situations and only two of them\n * are worth telling the caller about; `absoluteFrameFailure` is the read model\n * naming which, so this surface does not walk the ancestry a second time to\n * re-derive it.\n */\nfunction reportUnresolvable(shape: AnyShape, zIndex: number, slidePath: string): void {\n\tconst failure = shape.absoluteFrameFailure\n\t// No own `a:xfrm` at all: the shape inherits its geometry from a layout\n\t// placeholder, which this surface deliberately does not resolve. Nothing is\n\t// wrong with the deck, so nothing is reported. (`null` cannot reach here; the\n\t// caller only calls this for a shape whose frame did not resolve.)\n\tif (failure === null || failure === 'no-own-transform') return\n\n\tconst who = shape.name ? `\"${shape.name}\"` : `the element at zIndex ${zIndex}`\n\tif (failure === 'group-transform-missing') {\n\t\twarn(\n\t\t\t'inspect/group-transform-missing',\n\t\t\t`inspect: skipped ${who} on ${slidePath}: an enclosing group has no usable a:xfrm, so its slide position cannot be resolved.`\n\t\t)\n\t\treturn\n\t}\n\twarn(\n\t\t'inspect/group-transform-degenerate',\n\t\t`inspect: skipped ${who} on ${slidePath}: an enclosing group has a degenerate transform (zero a:chExt), so its slide position cannot be resolved.`\n\t)\n}\n\nfunction countWords(text: string): number {\n\treturn text.split(/\\s+/).filter(Boolean).length\n}\n\nfunction round(value: number, digits: number): number {\n\tconst factor = 10 ** digits\n\treturn Math.round(value * factor) / factor\n}\n\n// Error taxonomy: see `entry-errors.ts`. Re-exported from every entry so `instanceof`\n// works whichever subpath a consumer imports.\nexport * from './entry-errors.js'\n\n// Diagnostics: see `entry-diagnostics.ts`. Re-exported from every entry so a consumer of any\n// subpath can install a handler for the warnings that subpath emits.\nexport * from './entry-diagnostics.js'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwNA,MAAa,6BAA4C,OAAO,OAAO;CACtE,SAAS,MAAM,YAAY,sBAAsB,QAAQ,GAAG,CAAC;CAC7D,UAAU,MAAM,YAAY,sBAAsB,SAAS,GAAG,CAAC;AAChE,CAAC;;;;;;;;;AAmBD,eAAsB,gBAAgB,OAA8C;CACnF,OAAO,WAAW,KAAK,MAAM,KAAK;AACnC;;AAGA,SAAgB,cAAc,aAAmC;CAChE,OAAO,CAAC,GAAG,YAAY,MAAM,KAAK,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,KAAK;AAC1D;;AAGA,eAAsB,iBAAiB,aAAyB,MAAsC;CACrG,MAAM,QAAQ,MAAM,mBAAmB,aAAa,IAAI;CACxD,OAAO,QAAQ,YAAY,OAAO,KAAK,IAAI;AAC5C;;;;;;;;;;AAWA,eAAsB,mBAAmB,aAAyB,MAA0C;CAC3G,OAAO,YAAY,KAAK,WAAW,IAAI,CAAC,CAAC,EAAE,UAAU,KAAK;AAC3D;AAEA,MAAM,cAAc,IAAI,YAAY,OAAO;;AAG3C,SAAS,UAAU,UAA0B;CAC5C,OAAO,SAAS,WAAW,GAAG,IAAI,SAAS,MAAM,CAAC,IAAI;AACvD;AAEA,SAAS,WAAW,SAAyB;CAC5C,OAAO,QAAQ,WAAW,GAAG,IAAI,UAAU,IAAI;AAChD;AAMA,eAAsB,YAAY,OAAkD;CACnF,MAAM,cAAc,MAAM,gBAAgB,KAAK;CAC/C,MAAM,YAAY,MAAM,qBAAqB,WAAW;CAExD,OAAO;EAAE;EAAW,QAAA,MADC,cAAc,aAAa,SAAS;CAC9B;AAC5B;AAEA,eAAsB,qBACrB,aACA,WAA0B,4BACD;CACzB,MAAM,OAAO,eAAe,WAAW,CAAC,EAAE;CAC1C,IAAI,CAAC,MAAM,OAAO;CAClB,OAAO;EAAE,SAAS,MAAM,KAAK,SAAS,CAAC;EAAG,UAAU,MAAM,KAAK,UAAU,CAAC;CAAE;AAC7E;;;;;;AAOA,eAAsB,cAAc,aAAyB,MAAsD;CAClH,MAAM,YAAY,QAAS,MAAM,qBAAqB,WAAW;CACjE,MAAM,eAAe,eAAe,WAAW;CAC/C,IAAI,CAAC,cAAc,OAAO,CAAC;CAE3B,OAAO,aAAa,OAAO,KAAK,OAAO,UAAU;EAChD,MAAM,OAAO,UAAU,MAAM,QAAQ;EACrC,MAAM,YAA8B,CAAC;EACrC,QAAQ,MAAM,QAAQ,MAAM,SAAS;EACrC,MAAM,WAAW,QAAQ,WAAW,IAAI;EACxC,MAAM,OAAO,SACX,KAAK,OAAO,GAAG,IAAI,CAAC,CACpB,OAAO,OAAO,CAAC,CACf,KAAK,GAAG;EAEV,OAAO;GACN;GACA,MAAM,MAAM,QAAQ,SAAS,QAAQ;GACrC;GACA,MAAM;GACN;GACA;GACA,WAAW,WAAW,IAAI;EAC3B;CACD,CAAC;AACF;;;;;;;;AASA,SAAS,eAAe,aAA8C;CACrE,MAAM,eAAe,aAAa,YAAY,WAAW;CACzD,IAAI;EACH,OAAO,aAAa,iBAAiB,YAAY,eAAe;CACjE,QAAQ;EACP,OAAO;CACR;AACD;AAEA,SAAgB,YAAY,GAAY,GAAoB;CAG3D,OAFU,KAAK,IAAI,GAAG,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,CAAC,CAEjE,IADG,KAAK,IAAI,GAAG,KAAK,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,GAAG,EAAE,CAAC,CAC7D;AACZ;AAEA,SAAgB,UAAU,KAAc,QAAuB,MAA2B;CACzF,IAAI,SAAS,KAAK;EACjB,IAAI,WAAW,QAAQ,OAAO,IAAI;EAClC,IAAI,WAAW,SAAS,OAAO,IAAI,IAAI,IAAI;EAC3C,OAAO,IAAI,IAAI,IAAI,IAAI;CACxB;CACA,IAAI,WAAW,OAAO,OAAO,IAAI;CACjC,IAAI,WAAW,UAAU,OAAO,IAAI,IAAI,IAAI;CAC5C,OAAO,IAAI,IAAI,IAAI,IAAI;AACxB;;;;;;;;AAoBA,SAAS,QAAQ,QAAoB,cAA6B,KAAiC;CAClG,MAAM,WAAqB,CAAC;CAC5B,KAAK,MAAM,SAAS,QAAQ;EAC3B,MAAM,QAAwB;GAAE;GAAO;GAAc,eAAe,CAAC;EAAE;EACvE,MAAM,SAAS,IAAI,KAAK,KAAK,IAAI;EACjC,SAAS,KAAK,MAAM;EACpB,IAAI,MAAM,cAAc,SAAS,MAAM,gBAAgB,QAAQ,MAAM,QAAQ,QAAQ,GAAG;CACzF;CACA,OAAO;AACR;;;;;;AAOA,SAAS,QAAQ,WAA6B,WAAuC;CACpF,OAAO,UACL,KAAK,OAAO,WAAW,UAAU,OAAO,QAAQ,SAAS,CAAC,CAAC,CAC3D,QAAQ,YAAyC,QAAQ,OAAO,CAAC;AACpE;AAEA,SAAS,UAAU,OAAuB,QAAgB,WAA4C;CACrG,MAAM,EAAE,UAAU;CAClB,MAAM,QAAQ,MAAM;CACpB,IAAI,CAAC,OAAO;EACX,mBAAmB,OAAO,QAAQ,SAAS;EAC3C,OAAO;CACR;CAGA,MAAM,YAAY,MAAM;CACxB,MAAM,aAAa,YAAY,UAAU,WAAW,KAAK,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,KAAK,EAAE,EAAE,IAAI,CAAC;CACjG,MAAM,WAAW,WAAW,SAAS,cAAc,UAAU,IAAI;CAKjE,MAAM,UAAU,WAAW,KAAK,cAAc,UAAU,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI;CAIvG,MAAM,QAHM,MAAM,cAAc,iBAAiB,iBAAiB,KAAK,IAAI,QAAA,CAG1D,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;CAC3C,MAAM,OACL,MAAM,cAAc,UACjB,UACA,MAAM,cAAc,iBACnB,iBACA,OACC,SACA,MAAM,cAAc,YACnB,UACA;CAEP,OAAO;EACN,IAAI,MAAM,MAAM,SAAS;EACzB,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,SAAS;EACxC;EACA,aAAa,MAAM,cAAc,iBAAiB,cAAc,KAAK,IAAI;EACzE;EACA,KAAK;GACJ,GAAG,YAAY,MAAM,IAAI;GACzB,GAAG,YAAY,MAAM,GAAG;GACxB,GAAG,YAAY,MAAM,KAAK;GAC1B,GAAG,YAAY,MAAM,MAAM;EAC5B;EACA,UAAU,MAAM;EAChB,OAAO,MAAM;EACb,OAAO,MAAM;EACb,cAAc,MAAM;EACpB,eAAe,MAAM;EACrB;EACA,UAAU,WAAW,gBAAgB,QAAQ;EAC7C,SAAS,WAAW,WAAW;EAC/B,kBAAkB,WAAW,oBAAoB;EACjD,YAAY,eAAe,SAAS;EACpC;EACA;EACA,WAAW,CAAC,GAAG,IAAI,IAAI,SAAS,KAAK,QAAQ,IAAI,UAAU,CAAC,CAAC,QAAQ,SAAyB,SAAS,IAAI,CAAC,CAAC;EAC7G,QAAQ,CAAC,GAAG,IAAI,IAAI,SAAS,KAAK,QAAQ,IAAI,KAAK,CAAC,CAAC,QAAQ,UAA2B,QAAQ,KAAK,CAAC,CAAC,CAAC;EACxG,MAAM,MAAM;EACZ,MAAM,MAAM;EACZ,WAAW,MAAM;CAClB;AACD;;;;;;;;AASA,SAAS,cAAc,OAAsC;CAC5D,IAAI,MAAM,UAAU,OAAO;CAC3B,IAAI,MAAM,UAAU,OAAO;CAC3B,IAAI,MAAM,YAAY,OAAO;CAC7B,IAAI,MAAM,YAAY,OAAO;CAC7B,OAAO;AACR;;;;;;;;;;;;AAaA,SAAS,iBAAiB,OAA6B;CACtD,MAAM,QAAQ,MAAM;CACpB,IAAI,OAAO,OAAO,MAAM,KAAK,KAAK,QAAQ,IAAI,MAAM,KAAK,SAAS,KAAK,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG;CAChG,OAAO,MAAM,SAAS,QAAQ;AAC/B;;AAGA,SAAS,MAAM,KAAuB;CACrC,OAAO;EACN,MAAM,IAAI;EACV,YAAY,IAAI;EAChB,OAAO,IAAI;EACX,UAAU,IAAI;EAGd,MAAM,IAAI,QAAQ;EAClB,QAAQ,IAAI,UAAU;EACtB,QAAQ,IAAI;EACZ,WAAW,IAAI,WAAW,OAAO;EACjC,eAAe,IAAI;CACpB;AACD;AAEA,SAAS,eAAe,WAAoD;CAC3E,MAAM,SAAS,WAAW,gBAAgB;CAC1C,IAAI,CAAC,QAAQ,OAAO;CAGpB,MAAM,UAAU,IAAwB,gBACtC,OAAO,KAAA,IAAY,aAAa,MAAA;CAClC,OAAO;EACN,MAAM,OAAO,OAAO,MAAM,uBAAuB,IAAI;EACrD,KAAK,OAAO,OAAO,KAAK,uBAAuB,GAAG;EAClD,OAAO,OAAO,OAAO,OAAO,uBAAuB,KAAK;EACxD,QAAQ,OAAO,OAAO,QAAQ,uBAAuB,MAAM;CAC5D;AACD;;;;;;;;;;AAWA,SAAS,mBAAmB,OAAiB,QAAgB,WAAyB;CACrF,MAAM,UAAU,MAAM;CAKtB,IAAI,YAAY,QAAQ,YAAY,oBAAoB;CAExD,MAAM,MAAM,MAAM,OAAO,IAAI,MAAM,KAAK,KAAK,yBAAyB;CACtE,IAAI,YAAY,2BAA2B;EAC1C,KACC,mCACA,oBAAoB,IAAI,MAAM,UAAU,qFACzC;EACA;CACD;CACA,KACC,sCACA,oBAAoB,IAAI,MAAM,UAAU,0GACzC;AACD;AAEA,SAAS,WAAW,MAAsB;CACzC,OAAO,KAAK,MAAM,KAAK,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC;AAC1C;AAEA,SAAS,MAAM,OAAe,QAAwB;CACrD,MAAM,SAAS,MAAM;CACrB,OAAO,KAAK,MAAM,QAAQ,MAAM,IAAI;AACrC"}