@json-to-office/shared-pptx 0.3.0 → 0.8.0

package/dist/chunk-WY5GF6HO.js

@@ -1,1171 +0,0 @@
-import {
-  ColorValueSchema,
-  GridConfigSchema,
-  StyleNameSchema
-} from "./chunk-MZ3TEFYH.js";
-
-// src/schemas/component-registry.ts
-import { Type as Type11 } from "@sinclair/typebox";
-
-// src/schemas/components/presentation.ts
-import { Type as Type9 } from "@sinclair/typebox";
-
-// src/schemas/components/template.ts
-import { Type as Type8 } from "@sinclair/typebox";
-
-// src/schemas/components/common.ts
-import { Type } from "@sinclair/typebox";
-var PositionSchema = Type.Object(
-  {
-    x: Type.Optional(
-      Type.Union([
-        Type.Number({ description: "X position in inches" }),
-        Type.String({
-          pattern: "^\\d+(\\.\\d+)?%$",
-          description: 'X position as percentage (e.g., "10%")'
-        })
-      ])
-    ),
-    y: Type.Optional(
-      Type.Union([
-        Type.Number({ description: "Y position in inches" }),
-        Type.String({
-          pattern: "^\\d+(\\.\\d+)?%$",
-          description: 'Y position as percentage (e.g., "10%")'
-        })
-      ])
-    ),
-    w: Type.Optional(
-      Type.Union([
-        Type.Number({ description: "Width in inches" }),
-        Type.String({
-          pattern: "^\\d+(\\.\\d+)?%$",
-          description: 'Width as percentage (e.g., "80%")'
-        })
-      ])
-    ),
-    h: Type.Optional(
-      Type.Union([
-        Type.Number({ description: "Height in inches" }),
-        Type.String({
-          pattern: "^\\d+(\\.\\d+)?%$",
-          description: 'Height as percentage (e.g., "20%")'
-        })
-      ])
-    )
-  },
-  {
-    description: "Position and size in inches or percentages",
-    additionalProperties: false
-  }
-);
-var SlideBackgroundSchema = Type.Object(
-  {
-    color: Type.Optional(ColorValueSchema),
-    image: Type.Optional(
-      Type.Object(
-        {
-          path: Type.Optional(Type.String({ description: "Image file path or URL" })),
-          base64: Type.Optional(
-            Type.String({ description: "Base64-encoded image data" })
-          )
-        },
-        { description: "Background image", additionalProperties: false }
-      )
-    )
-  },
-  {
-    description: "Slide background configuration",
-    additionalProperties: false
-  }
-);
-var TransitionSchema = Type.Object(
-  {
-    type: Type.Optional(
-      Type.Union(
-        [
-          Type.Literal("fade"),
-          Type.Literal("push"),
-          Type.Literal("wipe"),
-          Type.Literal("zoom"),
-          Type.Literal("none")
-        ],
-        { description: "Transition effect type" }
-      )
-    ),
-    speed: Type.Optional(
-      Type.Union(
-        [Type.Literal("slow"), Type.Literal("medium"), Type.Literal("fast")],
-        { description: "Transition speed" }
-      )
-    )
-  },
-  {
-    description: "Slide transition configuration",
-    additionalProperties: false
-  }
-);
-var PptxAlignmentSchema = Type.Union(
-  [Type.Literal("left"), Type.Literal("center"), Type.Literal("right")],
-  { description: "Horizontal alignment options" }
-);
-var VerticalAlignmentSchema = Type.Union(
-  [Type.Literal("top"), Type.Literal("middle"), Type.Literal("bottom")],
-  { description: "Vertical alignment options" }
-);
-var ShadowSchema = Type.Object(
-  {
-    type: Type.Optional(
-      Type.Union([Type.Literal("outer"), Type.Literal("inner")], {
-        description: "Shadow type"
-      })
-    ),
-    color: Type.Optional(ColorValueSchema),
-    blur: Type.Optional(Type.Number({ description: "Shadow blur radius in points" })),
-    offset: Type.Optional(Type.Number({ description: "Shadow offset in points" })),
-    angle: Type.Optional(Type.Number({ description: "Shadow angle in degrees" })),
-    opacity: Type.Optional(
-      Type.Number({
-        minimum: 0,
-        maximum: 1,
-        description: "Shadow opacity (0-1)"
-      })
-    )
-  },
-  {
-    description: "Shadow configuration",
-    additionalProperties: false
-  }
-);
-var GridPositionSchema = Type.Object(
-  {
-    column: Type.Number({ minimum: 0, description: "Starting column (0-indexed)" }),
-    row: Type.Number({ minimum: 0, description: "Starting row (0-indexed)" }),
-    columnSpan: Type.Optional(Type.Number({ minimum: 1, description: "Number of columns to span (default: 1)" })),
-    rowSpan: Type.Optional(Type.Number({ minimum: 1, description: "Number of rows to span (default: 1)" }))
-  },
-  { additionalProperties: false, description: "Grid-based positioning" }
-);
-
-// src/schemas/components/text.ts
-import { Type as Type2 } from "@sinclair/typebox";
-var TextPropsSchema = Type2.Object(
-  {
-    text: Type2.String({ description: "Text content to display" }),
-    x: Type2.Optional(
-      Type2.Union([
-        Type2.Number({ description: "X position in inches" }),
-        Type2.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
-      ])
-    ),
-    y: Type2.Optional(
-      Type2.Union([
-        Type2.Number({ description: "Y position in inches" }),
-        Type2.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
-      ])
-    ),
-    w: Type2.Optional(
-      Type2.Union([
-        Type2.Number({ description: "Width in inches" }),
-        Type2.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
-      ])
-    ),
-    h: Type2.Optional(
-      Type2.Union([
-        Type2.Number({ description: "Height in inches" }),
-        Type2.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
-      ])
-    ),
-    fontSize: Type2.Optional(
-      Type2.Number({ minimum: 1, description: "Font size in points" })
-    ),
-    fontFace: Type2.Optional(Type2.String({ description: "Font family name" })),
-    color: Type2.Optional(
-      Type2.String({ description: 'Text color (hex without #, e.g., "FF0000")' })
-    ),
-    bold: Type2.Optional(Type2.Boolean({ description: "Bold text" })),
-    italic: Type2.Optional(Type2.Boolean({ description: "Italic text" })),
-    underline: Type2.Optional(
-      Type2.Union([
-        Type2.Boolean({ description: "Simple underline toggle" }),
-        Type2.Object(
-          {
-            style: Type2.Optional(
-              Type2.Union([
-                Type2.Literal("sng"),
-                Type2.Literal("dbl"),
-                Type2.Literal("dash"),
-                Type2.Literal("dotted")
-              ])
-            ),
-            color: Type2.Optional(Type2.String({ description: "Underline color (hex)" }))
-          },
-          { additionalProperties: false }
-        )
-      ])
-    ),
-    strike: Type2.Optional(Type2.Boolean({ description: "Strikethrough text" })),
-    align: Type2.Optional(PptxAlignmentSchema),
-    valign: Type2.Optional(VerticalAlignmentSchema),
-    breakLine: Type2.Optional(
-      Type2.Boolean({ description: "Add line break after text" })
-    ),
-    bullet: Type2.Optional(
-      Type2.Union([
-        Type2.Boolean({ description: "Enable default bullet" }),
-        Type2.Object(
-          {
-            type: Type2.Optional(
-              Type2.Union([Type2.Literal("bullet"), Type2.Literal("number")])
-            ),
-            style: Type2.Optional(Type2.String({ description: "Bullet character or style" })),
-            startAt: Type2.Optional(Type2.Number({ description: "Starting number for numbered lists" }))
-          },
-          { additionalProperties: false }
-        )
-      ])
-    ),
-    margin: Type2.Optional(
-      Type2.Union([
-        Type2.Number({ description: "Margin in points (all sides)" }),
-        Type2.Array(Type2.Number(), {
-          description: "Margins as [top, right, bottom, left] in points",
-          minItems: 4,
-          maxItems: 4
-        })
-      ])
-    ),
-    rotate: Type2.Optional(Type2.Number({ description: "Rotation angle in degrees" })),
-    shadow: Type2.Optional(ShadowSchema),
-    fill: Type2.Optional(
-      Type2.Object(
-        {
-          color: Type2.String({ description: "Fill color (hex without #)" }),
-          transparency: Type2.Optional(
-            Type2.Number({ minimum: 0, maximum: 100, description: "Fill transparency (0-100)" })
-          )
-        },
-        { additionalProperties: false }
-      )
-    ),
-    hyperlink: Type2.Optional(
-      Type2.Object(
-        {
-          url: Type2.Optional(Type2.String({ description: "Hyperlink URL" })),
-          slide: Type2.Optional(Type2.Number({ description: "Slide number to link to" })),
-          tooltip: Type2.Optional(Type2.String({ description: "Hyperlink tooltip" }))
-        },
-        { additionalProperties: false }
-      )
-    ),
-    lineSpacing: Type2.Optional(Type2.Number({ description: "Line spacing in points" })),
-    charSpacing: Type2.Optional(Type2.Number({ description: "Character spacing in points (positive = wider, negative = tighter)" })),
-    paraSpaceBefore: Type2.Optional(Type2.Number({ description: "Space before paragraph in points" })),
-    paraSpaceAfter: Type2.Optional(Type2.Number({ description: "Space after paragraph in points" })),
-    grid: Type2.Optional(GridPositionSchema),
-    style: Type2.Optional(StyleNameSchema)
-  },
-  {
-    description: "Text component props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/image.ts
-import { Type as Type3 } from "@sinclair/typebox";
-var PptxImagePropsSchema = Type3.Object(
-  {
-    path: Type3.Optional(
-      Type3.String({
-        description: "Image file path or URL (mutually exclusive with base64)"
-      })
-    ),
-    base64: Type3.Optional(
-      Type3.String({
-        description: "Base64-encoded image data in data URI format (mutually exclusive with path)"
-      })
-    ),
-    x: Type3.Optional(
-      Type3.Union([
-        Type3.Number({ description: "X position in inches" }),
-        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
-      ])
-    ),
-    y: Type3.Optional(
-      Type3.Union([
-        Type3.Number({ description: "Y position in inches" }),
-        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
-      ])
-    ),
-    w: Type3.Optional(
-      Type3.Union([
-        Type3.Number({ description: "Width in inches" }),
-        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
-      ])
-    ),
-    h: Type3.Optional(
-      Type3.Union([
-        Type3.Number({ description: "Height in inches" }),
-        Type3.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
-      ])
-    ),
-    sizing: Type3.Optional(
-      Type3.Object(
-        {
-          type: Type3.Union(
-            [
-              Type3.Literal("contain"),
-              Type3.Literal("cover"),
-              Type3.Literal("crop")
-            ],
-            { description: "Image sizing strategy" }
-          ),
-          w: Type3.Optional(Type3.Number({ description: "Target width in inches" })),
-          h: Type3.Optional(Type3.Number({ description: "Target height in inches" }))
-        },
-        { description: "Image sizing options", additionalProperties: false }
-      )
-    ),
-    rotate: Type3.Optional(
-      Type3.Number({ description: "Rotation angle in degrees" })
-    ),
-    rounding: Type3.Optional(
-      Type3.Boolean({ description: "Apply rounded corners to image" })
-    ),
-    shadow: Type3.Optional(ShadowSchema),
-    hyperlink: Type3.Optional(
-      Type3.Object(
-        {
-          url: Type3.Optional(Type3.String({ description: "Hyperlink URL" })),
-          slide: Type3.Optional(Type3.Number({ description: "Slide number to link to" })),
-          tooltip: Type3.Optional(Type3.String({ description: "Hyperlink tooltip" }))
-        },
-        { additionalProperties: false }
-      )
-    ),
-    alt: Type3.Optional(
-      Type3.String({ description: "Alternative text for accessibility" })
-    ),
-    grid: Type3.Optional(GridPositionSchema)
-  },
-  {
-    description: "PPTX image component props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/shape.ts
-import { Type as Type4 } from "@sinclair/typebox";
-var ShapeTypeSchema = Type4.Union(
-  [
-    Type4.Literal("rect"),
-    Type4.Literal("roundRect"),
-    Type4.Literal("ellipse"),
-    Type4.Literal("triangle"),
-    Type4.Literal("diamond"),
-    Type4.Literal("pentagon"),
-    Type4.Literal("hexagon"),
-    Type4.Literal("star5"),
-    Type4.Literal("star6"),
-    Type4.Literal("line"),
-    Type4.Literal("arrow"),
-    Type4.Literal("chevron"),
-    Type4.Literal("cloud"),
-    Type4.Literal("heart"),
-    Type4.Literal("lightning")
-  ],
-  { description: "Shape type" }
-);
-var TextSegmentSchema = Type4.Object(
-  {
-    text: Type4.String(),
-    fontSize: Type4.Optional(Type4.Number({ minimum: 1 })),
-    fontFace: Type4.Optional(Type4.String()),
-    color: Type4.Optional(Type4.String({ description: "Segment color (hex without # or semantic name)" })),
-    bold: Type4.Optional(Type4.Boolean()),
-    italic: Type4.Optional(Type4.Boolean()),
-    breakLine: Type4.Optional(Type4.Boolean({ description: "Insert line break after this segment" })),
-    spaceBefore: Type4.Optional(Type4.Number({ minimum: 0, description: "Space before paragraph in points" })),
-    spaceAfter: Type4.Optional(Type4.Number({ minimum: 0, description: "Space after paragraph in points" })),
-    charSpacing: Type4.Optional(Type4.Number({ description: "Character spacing in points" }))
-  },
-  { additionalProperties: false }
-);
-var ShapePropsSchema = Type4.Object(
-  {
-    type: ShapeTypeSchema,
-    x: Type4.Optional(
-      Type4.Union([
-        Type4.Number({ description: "X position in inches" }),
-        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
-      ])
-    ),
-    y: Type4.Optional(
-      Type4.Union([
-        Type4.Number({ description: "Y position in inches" }),
-        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
-      ])
-    ),
-    w: Type4.Optional(
-      Type4.Union([
-        Type4.Number({ description: "Width in inches" }),
-        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
-      ])
-    ),
-    h: Type4.Optional(
-      Type4.Union([
-        Type4.Number({ description: "Height in inches" }),
-        Type4.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
-      ])
-    ),
-    fill: Type4.Optional(
-      Type4.Object(
-        {
-          color: Type4.String({ description: "Fill color (hex without #)" }),
-          transparency: Type4.Optional(
-            Type4.Number({ minimum: 0, maximum: 100, description: "Fill transparency (0-100)" })
-          )
-        },
-        { additionalProperties: false }
-      )
-    ),
-    line: Type4.Optional(
-      Type4.Object(
-        {
-          color: Type4.Optional(Type4.String({ description: "Line color (hex without #)" })),
-          width: Type4.Optional(Type4.Number({ minimum: 0, description: "Line width in points" })),
-          dashType: Type4.Optional(
-            Type4.Union([
-              Type4.Literal("solid"),
-              Type4.Literal("dash"),
-              Type4.Literal("dot"),
-              Type4.Literal("dashDot")
-            ])
-          )
-        },
-        { additionalProperties: false }
-      )
-    ),
-    text: Type4.Optional(Type4.Union([
-      Type4.String({ description: "Plain text" }),
-      Type4.Array(TextSegmentSchema, { description: "Rich text segments with per-segment formatting" })
-    ], { description: "Text content inside the shape" })),
-    fontSize: Type4.Optional(Type4.Number({ minimum: 1, description: "Font size for shape text" })),
-    fontFace: Type4.Optional(Type4.String({ description: "Font family for shape text" })),
-    fontColor: Type4.Optional(Type4.String({ description: "Font color for shape text (hex without #)" })),
-    charSpacing: Type4.Optional(Type4.Number({ description: "Character spacing in points for shape text" })),
-    bold: Type4.Optional(Type4.Boolean({ description: "Bold shape text" })),
-    italic: Type4.Optional(Type4.Boolean({ description: "Italic shape text" })),
-    align: Type4.Optional(PptxAlignmentSchema),
-    valign: Type4.Optional(VerticalAlignmentSchema),
-    rotate: Type4.Optional(Type4.Number({ description: "Rotation angle in degrees" })),
-    shadow: Type4.Optional(ShadowSchema),
-    rectRadius: Type4.Optional(
-      Type4.Number({
-        minimum: 0,
-        description: "Corner radius for roundRect shape in inches"
-      })
-    ),
-    grid: Type4.Optional(GridPositionSchema),
-    style: Type4.Optional(StyleNameSchema)
-  },
-  {
-    description: "Shape component props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/table.ts
-import { Type as Type5 } from "@sinclair/typebox";
-var PptxTableCellSchema = Type5.Union([
-  Type5.String({ description: "Simple text cell" }),
-  Type5.Object(
-    {
-      text: Type5.String({ description: "Cell text content" }),
-      color: Type5.Optional(Type5.String({ description: "Text color (hex without #)" })),
-      fill: Type5.Optional(Type5.String({ description: "Cell background color (hex without #)" })),
-      fontSize: Type5.Optional(Type5.Number({ description: "Font size in points" })),
-      fontFace: Type5.Optional(Type5.String({ description: "Font family" })),
-      bold: Type5.Optional(Type5.Boolean({ description: "Bold text" })),
-      italic: Type5.Optional(Type5.Boolean({ description: "Italic text" })),
-      align: Type5.Optional(PptxAlignmentSchema),
-      valign: Type5.Optional(VerticalAlignmentSchema),
-      colspan: Type5.Optional(Type5.Number({ minimum: 1, description: "Column span" })),
-      rowspan: Type5.Optional(Type5.Number({ minimum: 1, description: "Row span" })),
-      margin: Type5.Optional(
-        Type5.Union([
-          Type5.Number({ description: "Margin in points (all sides)" }),
-          Type5.Array(Type5.Number(), { minItems: 4, maxItems: 4 })
-        ])
-      )
-    },
-    { additionalProperties: false }
-  )
-]);
-var PptxTablePropsSchema = Type5.Object(
-  {
-    rows: Type5.Array(
-      Type5.Array(PptxTableCellSchema, { description: "Row of cells" }),
-      { description: "Table rows (array of arrays)", minItems: 1 }
-    ),
-    x: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "X position in inches" }),
-        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
-      ])
-    ),
-    y: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "Y position in inches" }),
-        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
-      ])
-    ),
-    w: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "Width in inches" }),
-        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
-      ])
-    ),
-    h: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "Height in inches" }),
-        Type5.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
-      ])
-    ),
-    colW: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "Uniform column width in inches" }),
-        Type5.Array(Type5.Number(), { description: "Individual column widths in inches" })
-      ])
-    ),
-    rowH: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "Uniform row height in inches" }),
-        Type5.Array(Type5.Number(), { description: "Individual row heights in inches" })
-      ])
-    ),
-    border: Type5.Optional(
-      Type5.Object(
-        {
-          type: Type5.Optional(
-            Type5.Union([
-              Type5.Literal("solid"),
-              Type5.Literal("dash"),
-              Type5.Literal("dot"),
-              Type5.Literal("none")
-            ])
-          ),
-          pt: Type5.Optional(Type5.Number({ minimum: 0, description: "Border width in points" })),
-          color: Type5.Optional(Type5.String({ description: "Border color (hex without #)" }))
-        },
-        { additionalProperties: false }
-      )
-    ),
-    fill: Type5.Optional(Type5.String({ description: "Table background color (hex without #)" })),
-    fontSize: Type5.Optional(Type5.Number({ minimum: 1, description: "Default font size for all cells" })),
-    fontFace: Type5.Optional(Type5.String({ description: "Default font family for all cells" })),
-    color: Type5.Optional(Type5.String({ description: "Default text color for all cells (hex without #)" })),
-    align: Type5.Optional(PptxAlignmentSchema),
-    valign: Type5.Optional(VerticalAlignmentSchema),
-    autoPage: Type5.Optional(
-      Type5.Boolean({ description: "Auto-paginate table across multiple slides when content overflows" })
-    ),
-    autoPageRepeatHeader: Type5.Optional(
-      Type5.Boolean({ description: "Repeat first row as header on each auto-paged slide" })
-    ),
-    margin: Type5.Optional(
-      Type5.Union([
-        Type5.Number({ description: "Cell margin in points (all sides)" }),
-        Type5.Array(Type5.Number(), { minItems: 4, maxItems: 4 })
-      ])
-    ),
-    borderRadius: Type5.Optional(
-      Type5.Number({ minimum: 0, description: "Rounded corner radius in inches. Renders a roundRect shape behind the table." })
-    ),
-    grid: Type5.Optional(GridPositionSchema)
-  },
-  {
-    description: "PPTX table component props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/chart.ts
-import { Type as Type6 } from "@sinclair/typebox";
-var PositionValue = Type6.Union([
-  Type6.Number(),
-  Type6.String({ pattern: "^\\d+(\\.\\d+)?%$" })
-]);
-var ChartTypeSchema = Type6.Union(
-  [
-    Type6.Literal("area"),
-    Type6.Literal("bar"),
-    Type6.Literal("bar3D"),
-    Type6.Literal("bubble"),
-    Type6.Literal("doughnut"),
-    Type6.Literal("line"),
-    Type6.Literal("pie"),
-    Type6.Literal("radar"),
-    Type6.Literal("scatter")
-  ],
-  { description: "Chart type" }
-);
-var ChartDataSeriesSchema = Type6.Object(
-  {
-    name: Type6.Optional(Type6.String({ description: "Series name" })),
-    labels: Type6.Optional(Type6.Array(Type6.String(), { description: "Category labels" })),
-    values: Type6.Optional(Type6.Array(Type6.Number(), { description: "Data values" })),
-    sizes: Type6.Optional(Type6.Array(Type6.Number(), { description: "Bubble sizes (bubble charts only)" }))
-  },
-  { additionalProperties: false }
-);
-var PptxChartPropsSchema = Type6.Object(
-  {
-    type: ChartTypeSchema,
-    data: Type6.Array(ChartDataSeriesSchema, {
-      description: "Chart data series",
-      minItems: 1
-    }),
-    // Display toggles
-    showLegend: Type6.Optional(Type6.Boolean({ description: "Show chart legend" })),
-    showTitle: Type6.Optional(Type6.Boolean({ description: "Show chart title" })),
-    showValue: Type6.Optional(Type6.Boolean({ description: "Show data values" })),
-    showPercent: Type6.Optional(Type6.Boolean({ description: "Show percentages (pie/doughnut)" })),
-    showLabel: Type6.Optional(Type6.Boolean({ description: "Show category labels on data points" })),
-    showSerName: Type6.Optional(Type6.Boolean({ description: "Show series name on data points" })),
-    // Title
-    title: Type6.Optional(Type6.String({ description: "Chart title text" })),
-    titleFontSize: Type6.Optional(Type6.Number({ description: "Title font size (points)" })),
-    titleColor: Type6.Optional(Type6.String({ description: "Title color (hex or semantic)" })),
-    titleFontFace: Type6.Optional(Type6.String({ description: "Title font face" })),
-    // Chart colors
-    chartColors: Type6.Optional(
-      Type6.Array(Type6.String(), {
-        description: "Series colors (hex or semantic theme names). Defaults to theme palette."
-      })
-    ),
-    // Legend
-    legendPos: Type6.Optional(
-      Type6.Union(
-        [Type6.Literal("b"), Type6.Literal("l"), Type6.Literal("r"), Type6.Literal("t"), Type6.Literal("tr")],
-        { description: "Legend position" }
-      )
-    ),
-    legendFontSize: Type6.Optional(Type6.Number({ description: "Legend font size" })),
-    legendFontFace: Type6.Optional(Type6.String({ description: "Legend font face" })),
-    legendColor: Type6.Optional(Type6.String({ description: "Legend text color" })),
-    // Category axis
-    catAxisTitle: Type6.Optional(Type6.String({ description: "Category axis title" })),
-    catAxisHidden: Type6.Optional(Type6.Boolean({ description: "Hide category axis" })),
-    catAxisLabelRotate: Type6.Optional(Type6.Number({ description: "Category axis label rotation (degrees)" })),
-    catAxisLabelFontSize: Type6.Optional(Type6.Number({ description: "Category axis label font size" })),
-    catAxisLabelColor: Type6.Optional(Type6.String({ description: "Category axis label color (hex or semantic)" })),
-    // Value axis
-    valAxisTitle: Type6.Optional(Type6.String({ description: "Value axis title" })),
-    valAxisHidden: Type6.Optional(Type6.Boolean({ description: "Hide value axis" })),
-    valAxisMinVal: Type6.Optional(Type6.Number({ description: "Value axis minimum" })),
-    valAxisMaxVal: Type6.Optional(Type6.Number({ description: "Value axis maximum" })),
-    valAxisLabelFormatCode: Type6.Optional(Type6.String({ description: 'Value axis label format (e.g. "$0.00", "#%")' })),
-    valAxisMajorUnit: Type6.Optional(Type6.Number({ description: "Value axis major unit / tick interval" })),
-    valAxisLabelColor: Type6.Optional(Type6.String({ description: "Value axis label color (hex or semantic)" })),
-    // Bar-specific
-    barDir: Type6.Optional(
-      Type6.Union([Type6.Literal("bar"), Type6.Literal("col")], {
-        description: 'Bar direction: "bar" (horizontal) or "col" (vertical, default)'
-      })
-    ),
-    barGrouping: Type6.Optional(
-      Type6.Union(
-        [Type6.Literal("clustered"), Type6.Literal("stacked"), Type6.Literal("percentStacked")],
-        { description: "Bar grouping style" }
-      )
-    ),
-    barGapWidthPct: Type6.Optional(
-      Type6.Number({ minimum: 0, maximum: 500, description: "Bar gap width (0-500%)" })
-    ),
-    // Line-specific
-    lineSmooth: Type6.Optional(Type6.Boolean({ description: "Smooth lines" })),
-    lineDataSymbol: Type6.Optional(
-      Type6.Union(
-        [
-          Type6.Literal("circle"),
-          Type6.Literal("dash"),
-          Type6.Literal("diamond"),
-          Type6.Literal("dot"),
-          Type6.Literal("none"),
-          Type6.Literal("square"),
-          Type6.Literal("triangle")
-        ],
-        { description: "Line data point marker symbol" }
-      )
-    ),
-    lineSize: Type6.Optional(Type6.Number({ description: "Line width (points)" })),
-    // Pie/doughnut-specific
-    firstSliceAng: Type6.Optional(Type6.Number({ minimum: 0, maximum: 359, description: "Angle of first slice (degrees)" })),
-    holeSize: Type6.Optional(Type6.Number({ minimum: 10, maximum: 90, description: "Doughnut hole size (%)" })),
-    // Radar-specific
-    radarStyle: Type6.Optional(
-      Type6.Union(
-        [Type6.Literal("standard"), Type6.Literal("marker"), Type6.Literal("filled")],
-        { description: "Radar chart style" }
-      )
-    ),
-    // Data labels
-    dataLabelColor: Type6.Optional(Type6.String({ description: "Data label text color" })),
-    dataLabelFontSize: Type6.Optional(Type6.Number({ description: "Data label font size" })),
-    dataLabelFontFace: Type6.Optional(Type6.String({ description: "Data label font face" })),
-    dataLabelFontBold: Type6.Optional(Type6.Boolean({ description: "Bold data labels" })),
-    dataLabelPosition: Type6.Optional(
-      Type6.Union(
-        [
-          Type6.Literal("b"),
-          Type6.Literal("bestFit"),
-          Type6.Literal("ctr"),
-          Type6.Literal("l"),
-          Type6.Literal("r"),
-          Type6.Literal("t"),
-          Type6.Literal("inEnd"),
-          Type6.Literal("outEnd")
-        ],
-        { description: "Data label position" }
-      )
-    ),
-    // Positioning
-    x: Type6.Optional(PositionValue),
-    y: Type6.Optional(PositionValue),
-    w: Type6.Optional(PositionValue),
-    h: Type6.Optional(PositionValue),
-    grid: Type6.Optional(GridPositionSchema)
-  },
-  {
-    description: "Native PowerPoint chart component props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/highcharts.ts
-import { Type as Type7 } from "@sinclair/typebox";
-var PptxHighchartsPropsSchema = Type7.Object(
-  {
-    options: Type7.Intersect([
-      Type7.Record(Type7.String(), Type7.Unknown()),
-      Type7.Object({
-        chart: Type7.Object({
-          width: Type7.Number(),
-          height: Type7.Number()
-        })
-      })
-    ]),
-    scale: Type7.Optional(Type7.Number()),
-    serverUrl: Type7.Optional(Type7.String({ description: "Highcharts Export Server URL (default: http://localhost:7801)" })),
-    x: Type7.Optional(
-      Type7.Union([
-        Type7.Number({ description: "X position in inches" }),
-        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "X as percentage" })
-      ])
-    ),
-    y: Type7.Optional(
-      Type7.Union([
-        Type7.Number({ description: "Y position in inches" }),
-        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Y as percentage" })
-      ])
-    ),
-    w: Type7.Optional(
-      Type7.Union([
-        Type7.Number({ description: "Width in inches" }),
-        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Width as percentage" })
-      ])
-    ),
-    h: Type7.Optional(
-      Type7.Union([
-        Type7.Number({ description: "Height in inches" }),
-        Type7.String({ pattern: "^\\d+(\\.\\d+)?%$", description: "Height as percentage" })
-      ])
-    ),
-    grid: Type7.Optional(GridPositionSchema)
-  },
-  {
-    description: "PPTX Highcharts component props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/template.ts
-var Coord = Type8.Union([
-  Type8.Number({ description: "Position/size in inches" }),
-  Type8.String({
-    pattern: "^\\d+(\\.\\d+)?%$",
-    description: 'Position/size as percentage of slide dimension (e.g., "50%")'
-  })
-]);
-function contentComponent(name, propsSchema) {
-  return Type8.Object({
-    name: Type8.Literal(name),
-    id: Type8.Optional(Type8.String()),
-    enabled: Type8.Optional(Type8.Boolean({
-      default: true,
-      description: "When false, this component is filtered out and not rendered. Defaults to true."
-    })),
-    props: propsSchema
-  }, { additionalProperties: false });
-}
-var TemplateObjectComponentSchema = Type8.Union([
-  contentComponent("text", TextPropsSchema),
-  contentComponent("image", PptxImagePropsSchema),
-  contentComponent("shape", ShapePropsSchema),
-  contentComponent("table", PptxTablePropsSchema),
-  contentComponent("chart", PptxChartPropsSchema),
-  contentComponent("highcharts", PptxHighchartsPropsSchema)
-], {
-  discriminator: { propertyName: "name" },
-  description: "Fixed component on a template slide (same format as slide children)"
-});
-function defaultsComponent(name, propsSchema) {
-  return Type8.Object({
-    name: Type8.Literal(name),
-    props: Type8.Partial(propsSchema, { description: "Default props inherited by the component placed in this placeholder" })
-  }, { additionalProperties: false });
-}
-var PlaceholderDefaultsSchema = Type8.Union([
-  defaultsComponent("text", TextPropsSchema),
-  defaultsComponent("image", PptxImagePropsSchema),
-  defaultsComponent("shape", ShapePropsSchema),
-  defaultsComponent("table", PptxTablePropsSchema),
-  defaultsComponent("chart", PptxChartPropsSchema),
-  defaultsComponent("highcharts", PptxHighchartsPropsSchema)
-], {
-  discriminator: { propertyName: "name" },
-  description: "Partial component stub \u2014 styling defaults only"
-});
-var PlaceholderDefinitionSchema = Type8.Object({
-  name: Type8.String({ description: "Unique placeholder name" }),
-  x: Type8.Optional(Coord),
-  y: Type8.Optional(Coord),
-  w: Type8.Optional(Coord),
-  h: Type8.Optional(Coord),
-  grid: Type8.Optional(GridPositionSchema),
-  defaults: Type8.Optional(PlaceholderDefaultsSchema)
-}, { additionalProperties: false, description: "Placeholder on a template slide \u2014 defaults is a component stub whose props are inherited by the actual component" });
-var TemplateSlideDefinitionSchema = Type8.Object({
-  name: Type8.String({ description: "Unique template slide name" }),
-  background: Type8.Optional(SlideBackgroundSchema),
-  margin: Type8.Optional(Type8.Union([
-    Type8.Number({ description: "Margin in inches (all sides)" }),
-    Type8.Array(Type8.Number(), { minItems: 4, maxItems: 4, description: "Margin [top, right, bottom, left] in inches" })
-  ])),
-  slideNumber: Type8.Optional(Type8.Object({
-    x: Coord,
-    y: Coord,
-    w: Type8.Optional(Coord),
-    h: Type8.Optional(Coord),
-    color: Type8.Optional(ColorValueSchema),
-    fontSize: Type8.Optional(Type8.Number({ description: "Slide number font size in points" }))
-  }, { additionalProperties: false, description: "Slide number position and styling" })),
-  objects: Type8.Optional(Type8.Array(TemplateObjectComponentSchema, { description: "Fixed components (logos, footers, decorations) \u2014 same { name, props } format as slide children" })),
-  placeholders: Type8.Optional(Type8.Array(PlaceholderDefinitionSchema, { description: "Placeholder regions for slide content" })),
-  grid: Type8.Optional(GridConfigSchema)
-}, { additionalProperties: false, description: "Template slide definition (reusable slide template)" });
-
-// src/schemas/components/presentation.ts
-var PresentationPropsSchema = Type9.Object(
-  {
-    title: Type9.Optional(
-      Type9.String({ description: "Presentation title metadata" })
-    ),
-    author: Type9.Optional(
-      Type9.String({ description: "Presentation author metadata" })
-    ),
-    subject: Type9.Optional(
-      Type9.String({ description: "Presentation subject metadata" })
-    ),
-    company: Type9.Optional(
-      Type9.String({ description: "Company name metadata" })
-    ),
-    theme: Type9.Optional(
-      Type9.String({
-        description: 'Theme name to apply (default: "default")',
-        default: "default"
-      })
-    ),
-    slideWidth: Type9.Optional(
-      Type9.Number({
-        description: "Slide width in inches (default: 10)",
-        default: 10
-      })
-    ),
-    slideHeight: Type9.Optional(
-      Type9.Number({
-        description: "Slide height in inches (default: 7.5)",
-        default: 7.5
-      })
-    ),
-    rtlMode: Type9.Optional(
-      Type9.Boolean({ description: "Right-to-left text direction" })
-    ),
-    pageNumberFormat: Type9.Optional(
-      Type9.Union([Type9.Literal("9"), Type9.Literal("09")], {
-        description: 'Format for {PAGE_NUMBER} placeholders: "9" = bare number (default), "09" = zero-padded',
-        default: "9"
-      })
-    ),
-    grid: Type9.Optional(GridConfigSchema),
-    templates: Type9.Optional(
-      Type9.Array(TemplateSlideDefinitionSchema, {
-        description: "Template slide definitions (reusable slide templates)"
-      })
-    )
-  },
-  {
-    description: "Presentation container props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/components/slide.ts
-import { Type as Type10 } from "@sinclair/typebox";
-var SlidePropsSchema = Type10.Object(
-  {
-    background: Type10.Optional(SlideBackgroundSchema),
-    transition: Type10.Optional(TransitionSchema),
-    notes: Type10.Optional(
-      Type10.String({ description: "Speaker notes for this slide" })
-    ),
-    layout: Type10.Optional(
-      Type10.String({
-        description: 'Slide layout name (e.g., "Title Slide", "Blank")'
-      })
-    ),
-    hidden: Type10.Optional(
-      Type10.Boolean({ description: "Hide this slide from presentation" })
-    ),
-    template: Type10.Optional(
-      Type10.String({ description: "Template slide name to apply" })
-    )
-    // Note: `placeholders` is added dynamically by the component registry
-    // with the recursive component ref, to avoid circular imports.
-  },
-  {
-    description: "Slide container props",
-    additionalProperties: false
-  }
-);
-
-// src/schemas/component-registry.ts
-var PPTX_STANDARD_COMPONENTS_REGISTRY = [
-  // ========================================================================
-  // Container Components (can contain children)
-  // ========================================================================
-  {
-    name: "pptx",
-    propsSchema: PresentationPropsSchema,
-    hasChildren: true,
-    allowedChildren: ["slide"],
-    category: "container",
-    description: "Main presentation container - defines the overall presentation structure. Required as the root component.",
-    special: {
-      hasSchemaField: true
-    }
-  },
-  {
-    name: "slide",
-    propsSchema: SlidePropsSchema,
-    hasChildren: true,
-    allowedChildren: [
-      "text",
-      "image",
-      "shape",
-      "table",
-      "highcharts",
-      "chart"
-    ],
-    hasPlaceholders: true,
-    category: "container",
-    description: "Slide container - groups content elements on a single slide."
-  },
-  // ========================================================================
-  // Content Components (leaf nodes, no children)
-  // ========================================================================
-  {
-    name: "text",
-    propsSchema: TextPropsSchema,
-    hasChildren: false,
-    category: "content",
-    description: "Text element - displays text with formatting, positioning and styling options."
-  },
-  {
-    name: "image",
-    propsSchema: PptxImagePropsSchema,
-    hasChildren: false,
-    category: "content",
-    description: "Image element - displays images from file path, URL, or base64 data."
-  },
-  {
-    name: "shape",
-    propsSchema: ShapePropsSchema,
-    hasChildren: false,
-    category: "content",
-    description: "Shape element - draws geometric shapes with optional text, fill, and line styling."
-  },
-  {
-    name: "table",
-    propsSchema: PptxTablePropsSchema,
-    hasChildren: false,
-    category: "content",
-    description: "Table element - displays tabular data with rows and columns."
-  },
-  {
-    name: "highcharts",
-    propsSchema: PptxHighchartsPropsSchema,
-    hasChildren: false,
-    category: "content",
-    description: "Highcharts element - renders charts via Highcharts Export Server."
-  },
-  {
-    name: "chart",
-    propsSchema: PptxChartPropsSchema,
-    hasChildren: false,
-    category: "content",
-    description: "Native PowerPoint chart - editable, scalable, no external server needed."
-  }
-];
-function getPptxStandardComponent(name) {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.find((c) => c.name === name);
-}
-function getAllPptxComponentNames() {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.map((c) => c.name);
-}
-function getPptxComponentsByCategory(category) {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.filter(
-    (c) => c.category === category
-  );
-}
-function getPptxContainerComponents() {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.filter((c) => c.hasChildren);
-}
-function getPptxContentComponents() {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.filter((c) => !c.hasChildren);
-}
-function isPptxStandardComponent(name) {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.some((c) => c.name === name);
-}
-function createPptxComponentSchemaObject(component, recursiveRef, placeholderRef) {
-  const schema = {
-    name: Type11.Literal(component.name),
-    id: Type11.Optional(Type11.String()),
-    enabled: Type11.Optional(
-      Type11.Boolean({
-        default: true,
-        description: "When false, this component is filtered out and not rendered. Defaults to true."
-      })
-    )
-  };
-  if (component.special?.hasSchemaField) {
-    schema.$schema = Type11.Optional(Type11.String({ format: "uri" }));
-  }
-  schema.props = component.propsSchema;
-  if (component.hasChildren && recursiveRef) {
-    schema.children = Type11.Optional(Type11.Array(recursiveRef));
-  }
-  if (component.hasPlaceholders && (placeholderRef ?? recursiveRef)) {
-    const baseProperties = component.propsSchema.properties ?? {};
-    const phRef = placeholderRef ?? recursiveRef;
-    schema.props = Type11.Object(
-      {
-        ...baseProperties,
-        placeholders: Type11.Optional(
-          Type11.Record(Type11.String(), phRef, {
-            description: 'Content for named placeholders: { "title": { "name": "text", ... } }'
-          })
-        )
-      },
-      {
-        additionalProperties: false,
-        description: component.propsSchema.description
-      }
-    );
-  }
-  return Type11.Object(schema, { additionalProperties: false });
-}
-function createAllPptxComponentSchemas(recursiveRef) {
-  return PPTX_STANDARD_COMPONENTS_REGISTRY.map(
-    (component) => createPptxComponentSchemaObject(component, recursiveRef)
-  );
-}
-function createAllPptxComponentSchemasNarrowed(selfRef, pluginSchemas = []) {
-  const leafSchemas = /* @__PURE__ */ new Map();
-  for (const comp of PPTX_STANDARD_COMPONENTS_REGISTRY) {
-    if (!comp.hasChildren) {
-      leafSchemas.set(
-        comp.name,
-        createPptxComponentSchemaObject(comp, void 0, selfRef)
-      );
-    }
-  }
-  const containers = PPTX_STANDARD_COMPONENTS_REGISTRY.filter(
-    (c) => c.hasChildren
-  );
-  const resolved = /* @__PURE__ */ new Map();
-  const pending = [...containers];
-  while (pending.length > 0) {
-    const before = pending.length;
-    for (let i = pending.length - 1; i >= 0; i--) {
-      const comp = pending[i];
-      if (!comp.allowedChildren) {
-        resolved.set(
-          comp.name,
-          createPptxComponentSchemaObject(comp, selfRef, selfRef)
-        );
-        pending.splice(i, 1);
-        continue;
-      }
-      const containerDeps = comp.allowedChildren.filter(
-        (name) => containers.some((c) => c.name === name)
-      );
-      if (!containerDeps.every((d) => resolved.has(d))) continue;
-      const childSchemas = comp.allowedChildren.map((name) => resolved.get(name) ?? leafSchemas.get(name)).filter((s) => s !== void 0);
-      const allChildSchemas = [...childSchemas, ...pluginSchemas];
-      const childrenType = allChildSchemas.length === 1 ? allChildSchemas[0] : Type11.Union(allChildSchemas);
-      resolved.set(
-        comp.name,
-        createPptxComponentSchemaObject(comp, childrenType, selfRef)
-      );
-      pending.splice(i, 1);
-    }
-    if (pending.length === before) {
-      throw new Error(
-        `Circular allowedChildren among: ${pending.map((c) => c.name).join(", ")}`
-      );
-    }
-  }
-  return [...resolved.values(), ...leafSchemas.values()];
-}
-
-export {
-  PositionSchema,
-  SlideBackgroundSchema,
-  TransitionSchema,
-  PptxAlignmentSchema,
-  VerticalAlignmentSchema,
-  ShadowSchema,
-  GridPositionSchema,
-  TextPropsSchema,
-  PptxImagePropsSchema,
-  ShapeTypeSchema,
-  TextSegmentSchema,
-  ShapePropsSchema,
-  PptxTablePropsSchema,
-  PptxHighchartsPropsSchema,
-  PresentationPropsSchema,
-  SlidePropsSchema,
-  PPTX_STANDARD_COMPONENTS_REGISTRY,
-  getPptxStandardComponent,
-  getAllPptxComponentNames,
-  getPptxComponentsByCategory,
-  getPptxContainerComponents,
-  getPptxContentComponents,
-  isPptxStandardComponent,
-  createPptxComponentSchemaObject,
-  createAllPptxComponentSchemas,
-  createAllPptxComponentSchemasNarrowed
-};
-//# sourceMappingURL=chunk-WY5GF6HO.js.map