@opengeni/artifact-tool 0.2.2

package/dist/chunk-PI2AZVGK.js

@@ -0,0 +1,2074 @@
+import {
+  RasterImageValidationError,
+  canonicalizeRasterDataUrl,
+  encodeRasterBase64,
+  normalizeRasterContentType,
+  validateRasterImageBytes
+} from "./chunk-FGZM4FQ6.js";
+import {
+  FileBlob
+} from "./chunk-4BSENMAE.js";
+import {
+  boundInspectionRecords,
+  defineHelpEntries,
+  filterHelpEntries
+} from "./chunk-Q2FFHEY7.js";
+
+// src/presentation-pptx-state.ts
+var lossState = /* @__PURE__ */ new WeakMap();
+function presentationLossState(presentation) {
+  return lossState.get(presentation);
+}
+function setPresentationLossState(presentation, envelope) {
+  if (envelope) lossState.set(presentation, envelope);
+  else lossState.delete(presentation);
+}
+
+// src/presentation-pptx-api.ts
+var PPTX_MEDIA_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+var PresentationFidelityError = class extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "PresentationFidelityError";
+    this.issues = issues;
+  }
+};
+var PresentationSecurityError = class extends Error {
+  constructor(message, code, entryName) {
+    super(message);
+    this.code = code;
+    this.entryName = entryName;
+    this.name = "PresentationSecurityError";
+  }
+};
+
+// src/presentation.ts
+var UnsupportedPresentationFeatureError = class extends Error {
+  code = "UNSUPPORTED_PRESENTATION_FEATURE";
+  constructor(feature, detail) {
+    super(`Unsupported presentation feature: ${feature}${detail ? `. ${detail}` : ""}`);
+    this.name = "UnsupportedPresentationFeatureError";
+  }
+};
+var InvalidPresentationInputError = class extends Error {
+  constructor(field, detail) {
+    super(`Invalid presentation ${field}: ${detail}`);
+    this.field = field;
+    this.name = "InvalidPresentationInputError";
+  }
+  code = "INVALID_PRESENTATION_INPUT";
+};
+var PRESENTATION_HELP_ENTRIES = defineHelpEntries([
+  ["Presentation.create", "Create editable deck", "Presentation.create()"],
+  ["deck.slides.add", "Add slide", "deck.slides.add()"],
+  [
+    "slide.shapes.add",
+    "Add positioned text or shape",
+    'slide.shapes.add({ geometry: "textbox", text, position })'
+  ],
+  [
+    "slide.charts.add",
+    "Add chart data",
+    'slide.charts.add("bar", { categories, series: [{ name, values }] })'
+  ],
+  ["slide.tables.add", "Add table", "slide.tables.add({ rows, position })"],
+  ["slide.images.add", "Add image", "slide.images.add({ dataUrl, name, position })"],
+  [
+    "deck.inspect",
+    "Inspect deck records",
+    'await deck.inspect({ kind: "slide,textbox,chart,table" })'
+  ],
+  [
+    "deck.export",
+    "Export SVG, PNG, WebP, or layout",
+    'await deck.export({ format: "png", montage: true })'
+  ],
+  [
+    "PresentationFile.importPptx",
+    "Import editable PPTX",
+    "await PresentationFile.importPptx(blob)"
+  ],
+  ["PresentationFile.exportPptx", "Export PPTX", "await PresentationFile.exportPptx(deck)"]
+]);
+var Presentation = class _Presentation {
+  slides;
+  masters;
+  layouts;
+  slideSize;
+  objects = /* @__PURE__ */ new Map();
+  imageResolver;
+  allowedImageUriSchemes;
+  nextId = 1;
+  constructor(options = {}) {
+    this.slideSize = options.slideSize ?? { width: 1280, height: 720 };
+    validatePosition(
+      { left: 0, top: 0, width: this.slideSize.width, height: this.slideSize.height },
+      "slideSize"
+    );
+    this.imageResolver = options.imageResolver;
+    this.allowedImageUriSchemes = validateImageUriPolicy(
+      options.imageResolver,
+      options.allowedImageUriSchemes
+    );
+    this.slides = new SlideCollection(this);
+    this.masters = new PresentationMasterCollection(this);
+    this.layouts = new PresentationLayoutCollection(this);
+    this.register("pr", this);
+  }
+  static create(options = {}) {
+    return new _Presentation(options);
+  }
+  assertImageUriAccepted(uri) {
+    assertSafeText(uri, "image uri", MAX_IMAGE_URI_LENGTH);
+    const scheme = imageUriScheme(uri);
+    if (!this.imageResolver || !this.allowedImageUriSchemes.has(scheme)) {
+      throw new InvalidPresentationInputError(
+        "image uri",
+        "requires an injected resolver and an explicitly allowed URI scheme"
+      );
+    }
+  }
+  async resolveImageUri(reference) {
+    this.assertImageUriAccepted(reference.uri);
+    if (!this.imageResolver) {
+      throw new InvalidPresentationInputError("image resolver", "is not configured");
+    }
+    return await this.imageResolver(reference);
+  }
+  allocateId(prefix, value) {
+    return this.register(prefix, value);
+  }
+  resolve(id) {
+    const value = this.objects.get(id);
+    if (value === void 0) throw new Error(`Unknown presentation object id: ${id}`);
+    return value;
+  }
+  async inspect(options = {}) {
+    const requested = new Set(
+      (options.kind ?? "deck,master,layout,slide,textbox,shape,image,chart,table,group,notes").split(",").map((value) => value.trim()).filter(Boolean).map((value) => value === "comments" ? "thread" : value)
+    );
+    const records = [];
+    if (requested.has("deck")) {
+      records.push({
+        kind: "deck",
+        id: "pr/1",
+        slides: this.slides.items.length,
+        width: this.slideSize.width,
+        height: this.slideSize.height
+      });
+    }
+    if (requested.has("master")) {
+      for (const master of this.masters.items) records.push(master.inspectRecord());
+    }
+    if (requested.has("layout")) {
+      for (const layout of this.layouts.items) records.push(layout.inspectRecord());
+    }
+    for (const [index, slide] of this.slides.items.entries()) {
+      if (requested.has("slide")) records.push(slide.inspectRecord(index));
+      for (const shape of slide.shapes.items) {
+        const kind = shape.geometry === "textbox" ? "textbox" : "shape";
+        if (requested.has(kind) || kind === "textbox" && requested.has("shape")) {
+          records.push(shape.inspectRecord(index));
+        }
+      }
+      if (requested.has("chart")) {
+        for (const chart of slide.charts.items) records.push(chart.inspectRecord(index));
+      }
+      if (requested.has("image")) {
+        for (const image of slide.images.items) records.push(image.inspectRecord(index));
+      }
+      if (requested.has("table")) {
+        for (const table of slide.tables.items) records.push(table.inspectRecord(index));
+      }
+      if (requested.has("group")) {
+        for (const group of slide.groups.items) records.push(group.inspectRecord(index));
+      }
+      if (requested.has("notes") && slide.notes.toString().length > 0) {
+        records.push({
+          kind: "notes",
+          id: `${slide.id}/notes`,
+          slide: index + 1,
+          text: slide.notes.toString()
+        });
+      }
+    }
+    const search = options.search?.toLocaleLowerCase();
+    let filtered = search ? records.filter((record) => JSON.stringify(record).toLocaleLowerCase().includes(search)) : records;
+    if (options.target) filtered = filtered.filter((record) => record.id === options.target.id);
+    filtered = filtered.map((record) => projectRecord(record, options.include, options.exclude));
+    return boundPresentationRecords(filtered, options.maxChars ?? 2e4);
+  }
+  help(query, options = {}) {
+    if (typeof query !== "string") {
+      throw new InvalidPresentationInputError("help query", "must be a string");
+    }
+    const records = filterHelpEntries(PRESENTATION_HELP_ENTRIES, query, options.search);
+    return boundPresentationRecords(records, options.maxChars ?? 6e3);
+  }
+  async export(options) {
+    if (!options || typeof options !== "object") {
+      throw new InvalidPresentationInputError("export options", "must be an object");
+    }
+    if (!["svg", "png", "layout", "webp"].includes(options.format)) {
+      throw new InvalidPresentationInputError("export format", "is not supported");
+    }
+    validatePresentation(this, options.format !== "layout");
+    if (options.format === "layout") {
+      if (options.slide) {
+        this.assertOwns(options.slide);
+        return jsonBlob(
+          options.slide.layoutSnapshot(this.slides.items.indexOf(options.slide)),
+          `slide-${this.slides.items.indexOf(options.slide) + 1}.layout.json`
+        );
+      }
+      return jsonBlob(this.layoutSnapshot(), "presentation.layout.json");
+    }
+    const scale = options.scale ?? 1;
+    validateRenderScale(scale);
+    if (options.montage) {
+      const dimensions = montageDimensions(this, options.columns, options.gap);
+      if (options.format !== "svg") {
+        assertRenderPixelBudget(dimensions.width, dimensions.height, scale);
+      }
+      const { executePresentationRender: executePresentationRender2 } = await import("@opengeni/artifact-tool/presentation/render");
+      return await executePresentationRender2({
+        kind: "montage",
+        presentation: this,
+        format: options.format,
+        scale,
+        name: `presentation-montage.${options.format}`,
+        dimensions
+      });
+    }
+    const slide = options.slide ?? (this.slides.items.length === 1 ? this.slides.items[0] : void 0);
+    if (!slide) {
+      throw new Error(
+        "A slide is required when exporting a multi-slide presentation without montage: true"
+      );
+    }
+    this.assertOwns(slide);
+    if (options.format !== "svg") {
+      assertRenderPixelBudget(this.slideSize.width, this.slideSize.height, scale);
+    }
+    const { executePresentationRender } = await import("@opengeni/artifact-tool/presentation/render");
+    return await executePresentationRender({
+      kind: "slide",
+      slide,
+      format: options.format,
+      scale,
+      name: `slide-${this.slides.items.indexOf(slide) + 1}.${options.format}`,
+      dimensions: this.slideSize
+    });
+  }
+  layoutSnapshot() {
+    return {
+      kind: "presentation-layout",
+      slideSize: { ...this.slideSize },
+      masters: this.masters.items.map((master) => master.toProto()),
+      layouts: this.layouts.items.map((layout) => layout.toProto()),
+      slides: this.slides.items.map((slide, index) => slide.layoutSnapshot(index))
+    };
+  }
+  register(prefix, value) {
+    const id = `${prefix}/${this.nextId++}`;
+    this.objects.set(id, value);
+    return id;
+  }
+  assertOwns(slide) {
+    if (slide.presentation !== this) throw new Error("Slide belongs to another presentation");
+  }
+};
+var PresentationPlaceholderCollection = class {
+  constructor(elements) {
+    this.elements = elements;
+  }
+  summary() {
+    const names = this.elements.filter(
+      (element) => element.kind === "shape" && element.config.placeholder !== void 0
+    ).map((element) => element.config.name ?? element.config.placeholder?.type ?? "Placeholder");
+    return { count: names.length, names };
+  }
+};
+var PresentationMaster = class {
+  constructor(presentation, config = {}) {
+    this.presentation = presentation;
+    this.id = presentation.allocateId("mt", this);
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "master name", 512);
+    this.background = config.background ?? "white";
+    colorValue(this.background);
+    this.elements = (config.elements ?? []).map(cloneTemplateElement);
+    this.placeholders = new PresentationPlaceholderCollection(this.elements);
+  }
+  id;
+  name;
+  background;
+  elements;
+  placeholders;
+  inspectRecord() {
+    return {
+      kind: "master",
+      id: this.id,
+      name: this.name,
+      elements: this.elements.length,
+      placeholders: this.placeholders.summary()
+    };
+  }
+  toProto() {
+    return {
+      id: this.id,
+      type: "master",
+      name: this.name,
+      background: this.background,
+      elements: this.elements.map(cloneTemplateElement)
+    };
+  }
+};
+var PresentationLayout = class {
+  constructor(presentation, config = {}) {
+    this.presentation = presentation;
+    this.id = presentation.allocateId("ly", this);
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "layout name", 512);
+    if (config.masterId !== void 0 && config.parentLayoutId !== void 0 && config.masterId !== config.parentLayoutId) {
+      throw new InvalidPresentationInputError(
+        "layout masterId",
+        "conflicts with the parentLayoutId compatibility alias"
+      );
+    }
+    this.masterId = config.masterId ?? config.parentLayoutId;
+    if (this.masterId !== void 0) assertSafeText(this.masterId, "layout master id", 512);
+    this.background = config.background ?? "white";
+    colorValue(this.background);
+    this.elements = (config.elements ?? []).map(cloneTemplateElement);
+    this.placeholders = new PresentationPlaceholderCollection(this.elements);
+  }
+  id;
+  name;
+  masterId;
+  background;
+  elements;
+  placeholders;
+  get parentLayoutId() {
+    return this.masterId;
+  }
+  inspectRecord() {
+    return {
+      kind: "layout",
+      id: this.id,
+      name: this.name,
+      masterId: this.masterId,
+      parentLayoutId: this.masterId,
+      elements: this.elements.length,
+      placeholders: this.placeholders.summary()
+    };
+  }
+  toProto() {
+    return {
+      id: this.id,
+      type: "layout",
+      name: this.name,
+      masterId: this.masterId,
+      parentLayoutId: this.masterId,
+      background: this.background,
+      elements: this.elements.map(cloneTemplateElement)
+    };
+  }
+};
+var PresentationMasterCollection = class {
+  constructor(presentation) {
+    this.presentation = presentation;
+  }
+  items = [];
+  add(config = {}) {
+    const master = new PresentationMaster(this.presentation, config);
+    this.items.push(master);
+    return master;
+  }
+  getItem(index) {
+    const master = this.items[index];
+    if (!master) throw new Error(`Presentation master index out of range: ${index}`);
+    return master;
+  }
+};
+var PresentationLayoutCollection = class {
+  constructor(presentation) {
+    this.presentation = presentation;
+  }
+  items = [];
+  add(config = {}) {
+    if ((config.masterId ?? config.parentLayoutId) !== void 0 && !this.presentation.masters.items.some(
+      (master) => master.id === (config.masterId ?? config.parentLayoutId)
+    )) {
+      throw new InvalidPresentationInputError(
+        "layout parentLayoutId",
+        "must reference a master in the same presentation"
+      );
+    }
+    const layout = new PresentationLayout(this.presentation, config);
+    this.items.push(layout);
+    return layout;
+  }
+  getItem(index) {
+    const layout = this.items[index];
+    if (!layout) throw new Error(`Presentation layout index out of range: ${index}`);
+    return layout;
+  }
+};
+var SlideCollection = class {
+  constructor(presentation) {
+    this.presentation = presentation;
+  }
+  items = [];
+  add() {
+    const slide = new Slide(this.presentation);
+    this.items.push(slide);
+    return slide;
+  }
+  getItem(index) {
+    const slide = this.items[index];
+    if (!slide) throw new Error(`Slide index out of range: ${index}`);
+    return slide;
+  }
+};
+var Slide = class {
+  constructor(presentation) {
+    this.presentation = presentation;
+    this.id = presentation.allocateId("sl", this);
+    this.shapes = new PresentationShapeCollection(this);
+    this.charts = new PresentationChartCollection(this);
+    this.images = new PresentationImageCollection(this);
+    this.tables = new PresentationTableCollection(this);
+    this.groups = new PresentationGroupCollection(this);
+    this.placeholders = new SlidePlaceholderCollection(this);
+  }
+  id;
+  shapes;
+  charts;
+  images;
+  tables;
+  groups;
+  notes = new PresentationText();
+  placeholders;
+  /** Canonical cross-type z-order. Typed collections are filtered indexes over this list. */
+  elements = [];
+  background = { fill: "white" };
+  title = "";
+  layout;
+  get speakerNotes() {
+    return this.notes;
+  }
+  setLayout(layout) {
+    if (layout && layout.presentation !== this.presentation) {
+      throw new InvalidPresentationInputError("slide layout", "belongs to another presentation");
+    }
+    this.layout = layout;
+  }
+  appendElement(element) {
+    if (element.slide !== this) {
+      throw new InvalidPresentationInputError("slide element", "belongs to another slide");
+    }
+    this.elements.push(element);
+  }
+  async export(options) {
+    return await this.presentation.export({ ...options, slide: this });
+  }
+  inspectRecord(index) {
+    const textShapes = this.shapes.items.filter((shape) => shape.text.toString().length > 0);
+    return {
+      kind: "slide",
+      id: this.id,
+      slide: index + 1,
+      title: this.title,
+      textShapes: textShapes.length,
+      charts: this.charts.items.length,
+      images: this.images.items.length,
+      tables: this.tables.items.length,
+      groups: this.groups.items.length,
+      layoutId: this.layout?.id,
+      notesChars: this.notes.toString().length
+    };
+  }
+  layoutSnapshot(index) {
+    return {
+      id: this.id,
+      slide: index + 1,
+      background: { ...this.background },
+      layoutId: this.layout?.id,
+      notes: this.notes.toString(),
+      elements: [...this.elements.map((element) => element.layoutSnapshot())]
+    };
+  }
+};
+var SlidePlaceholderCollection = class {
+  constructor(slide) {
+    this.slide = slide;
+  }
+  get items() {
+    return this.slide.shapes.items.filter((shape) => shape.placeholder !== void 0);
+  }
+  summary() {
+    const types = {};
+    for (const shape of this.items) {
+      const type = shape.placeholder?.type ?? "unknown";
+      types[type] = (types[type] ?? 0) + 1;
+    }
+    return { count: this.items.length, types };
+  }
+};
+var PresentationText = class {
+  value = "";
+  styleValue = {};
+  constructor(initialValue = "", style = {}) {
+    this.set(initialValue);
+    this.style = style;
+  }
+  get style() {
+    return this.styleValue;
+  }
+  set style(value) {
+    validateTextStyle(value, "textStyle");
+    this.styleValue = { ...value };
+  }
+  set(value) {
+    assertSafeText(value, "text");
+    this.value = value;
+  }
+  replace(searchValue, replaceValue) {
+    const before = this.value;
+    let next;
+    if (typeof searchValue === "string") {
+      if (searchValue.length === 0) throw new Error("Text replacement search cannot be empty");
+      next = this.value.split(searchValue).join(replaceValue);
+    } else {
+      next = this.value.replace(searchValue, replaceValue);
+    }
+    assertSafeText(next, "text");
+    this.value = next;
+    return before === next ? 0 : 1;
+  }
+  toString() {
+    return this.value;
+  }
+  toJSON() {
+    return this.value;
+  }
+};
+var PresentationShape = class {
+  constructor(slide, config) {
+    this.slide = slide;
+    if (!PRESENTATION_GEOMETRIES.has(config.geometry)) {
+      throw new InvalidPresentationInputError("shape geometry", "is not supported");
+    }
+    this.id = slide.presentation.allocateId("sh", this);
+    this.geometry = config.geometry;
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "shape name");
+    this.position = normalizePosition(config.position);
+    this.fill = config.fill ?? (config.geometry === "textbox" || config.geometry === "line" ? "none" : "white");
+    this.line = {
+      style: "solid",
+      fill: config.geometry === "textbox" ? "none" : "slate-900",
+      width: 1,
+      ...config.line
+    };
+    colorValue(this.fill);
+    validateLine(this.line, "shape line");
+    this.rotation = finiteOr(config.rotation, 0);
+    validateRotation(this.rotation, "shape rotation");
+    this.borderRadius = config.borderRadius;
+    validateBorderRadius(this.borderRadius, "shape borderRadius");
+    this.placeholder = normalizePlaceholder(config.placeholder);
+    this.textValue = new PresentationText(config.text, config.textStyle);
+  }
+  id;
+  geometry;
+  name;
+  position;
+  fill;
+  line;
+  rotation;
+  borderRadius;
+  placeholder;
+  textValue;
+  get text() {
+    return this.textValue;
+  }
+  set text(value) {
+    this.textValue.set(value.toString());
+    if (value instanceof PresentationText) this.textValue.style = value.style;
+  }
+  inspectRecord(slideIndex) {
+    const text = this.text.toString();
+    return {
+      kind: this.geometry === "textbox" ? "textbox" : "shape",
+      id: this.id,
+      slide: slideIndex + 1,
+      name: this.name,
+      geometry: this.geometry,
+      text,
+      textPreview: truncate(text, 240),
+      textChars: text.length,
+      textLines: text.length === 0 ? 0 : text.split("\n").length,
+      bbox: positionTuple(this.position),
+      bboxUnit: "px"
+    };
+  }
+  layoutSnapshot() {
+    return {
+      kind: this.geometry === "textbox" ? "textbox" : "shape",
+      id: this.id,
+      name: this.name,
+      geometry: this.geometry,
+      position: { ...this.position },
+      fill: this.fill,
+      line: { ...this.line },
+      rotation: this.rotation,
+      text: this.text.toString(),
+      textStyle: { ...this.text.style },
+      placeholder: this.placeholder ? { ...this.placeholder } : void 0
+    };
+  }
+};
+var PresentationShapeCollection = class {
+  constructor(slide) {
+    this.slide = slide;
+  }
+  items = [];
+  add(config) {
+    const shape = new PresentationShape(this.slide, config);
+    this.items.push(shape);
+    this.slide.appendElement(shape);
+    return shape;
+  }
+};
+var PresentationChartSeries = class {
+  name;
+  categories;
+  values;
+  xValues;
+  bubbleSizes;
+  fill;
+  line;
+  constructor(config) {
+    this.name = config.name;
+    assertSafeText(this.name, "chart series name");
+    this.categories = [...config.categories ?? []];
+    for (const category of this.categories) assertSafeText(category, "chart series category");
+    this.values = [...config.values ?? []];
+    this.xValues = [...config.xValues ?? []];
+    this.bubbleSizes = [...config.bubbleSizes ?? []];
+    this.fill = config.fill;
+    this.line = config.line ? { ...config.line } : void 0;
+    validateFiniteArray(this.values, "chart series values");
+    validateFiniteArray(this.xValues, "chart series xValues");
+    validateFiniteArray(this.bubbleSizes, "chart series bubbleSizes");
+    if (this.fill !== void 0) colorValue(this.fill);
+    if (this.line !== void 0) validateLine(this.line, "chart series line");
+  }
+};
+var PresentationChartSeriesCollection = class {
+  items;
+  constructor(series) {
+    this.items = series.map((config) => new PresentationChartSeries(config));
+  }
+  getItemAt(index) {
+    const series = this.items[index];
+    if (!series) throw new Error(`Chart series index out of range: ${index}`);
+    return series;
+  }
+};
+var PresentationChart = class {
+  constructor(slide, type, config) {
+    this.slide = slide;
+    if (!CHART_TYPES.has(type)) {
+      throw new InvalidPresentationInputError("chart type", "is not supported");
+    }
+    this.id = slide.presentation.allocateId("ch", this);
+    this.type = type;
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "chart name");
+    this.position = normalizePosition(config.position, {
+      left: 72,
+      top: 120,
+      width: 640,
+      height: 360
+    });
+    this.title = config.title ?? "";
+    assertSafeText(this.title, "chart title");
+    this.categories = [...config.categories ?? []];
+    for (const category of this.categories) assertSafeText(category, "chart category");
+    this.series = new PresentationChartSeriesCollection(config.series ?? []);
+    this.hasLegend = config.hasLegend ?? this.series.items.length > 1;
+    this.legend = config.legend ? { ...config.legend } : void 0;
+    this.xAxis = config.xAxis ? { ...config.xAxis } : void 0;
+    this.yAxis = config.yAxis ? { ...config.yAxis } : void 0;
+    validateOptionalFinite(this.xAxis?.min, "chart xAxis.min");
+    validateOptionalFinite(this.xAxis?.max, "chart xAxis.max");
+    validateOptionalFinite(this.yAxis?.min, "chart yAxis.min");
+    validateOptionalFinite(this.yAxis?.max, "chart yAxis.max");
+    this.dataLabels = config.dataLabels ? { ...config.dataLabels } : void 0;
+  }
+  id;
+  type;
+  name;
+  position;
+  title;
+  categories;
+  series;
+  hasLegend;
+  legend;
+  xAxis;
+  yAxis;
+  dataLabels;
+  inspectRecord(slideIndex) {
+    return {
+      kind: "chart",
+      id: this.id,
+      slide: slideIndex + 1,
+      name: this.name,
+      chartType: this.type,
+      title: this.title,
+      series: this.series.items.map((series) => ({ name: series.name, values: series.values })),
+      bbox: positionTuple(this.position),
+      bboxUnit: "px"
+    };
+  }
+  layoutSnapshot() {
+    return {
+      kind: "chart",
+      id: this.id,
+      name: this.name,
+      chartType: this.type,
+      title: this.title,
+      position: { ...this.position },
+      categories: [...this.categories],
+      series: this.series.items.map((series) => ({
+        name: series.name,
+        categories: [...series.categories],
+        values: [...series.values],
+        xValues: [...series.xValues],
+        bubbleSizes: [...series.bubbleSizes],
+        fill: series.fill,
+        line: series.line
+      }))
+    };
+  }
+};
+var PresentationChartCollection = class {
+  constructor(slide) {
+    this.slide = slide;
+  }
+  items = [];
+  add(type, config = {}) {
+    const chart = new PresentationChart(this.slide, type, config);
+    this.items.push(chart);
+    this.slide.appendElement(chart);
+    return chart;
+  }
+};
+var PresentationTableCell = class {
+  text;
+  fill;
+  rowSpan;
+  colSpan;
+  constructor(config, defaults) {
+    const normalized = typeof config === "string" ? { text: config } : config;
+    this.text = new PresentationText(normalized.text, normalized.textStyle ?? defaults.textStyle);
+    this.fill = normalized.fill ?? defaults.fill ?? "white";
+    colorValue(this.fill);
+    this.rowSpan = normalized.rowSpan ?? 1;
+    this.colSpan = normalized.colSpan ?? 1;
+    for (const [field, value] of [
+      ["rowSpan", this.rowSpan],
+      ["colSpan", this.colSpan]
+    ]) {
+      if (!Number.isSafeInteger(value) || value <= 0 || value > MAX_TABLE_SPAN) {
+        throw new InvalidPresentationInputError(
+          `table cell ${field}`,
+          `must be 1-${MAX_TABLE_SPAN}`
+        );
+      }
+    }
+  }
+  toConfig() {
+    return {
+      text: this.text.toString(),
+      fill: this.fill,
+      textStyle: { ...this.text.style },
+      rowSpan: this.rowSpan,
+      colSpan: this.colSpan
+    };
+  }
+};
+var PresentationTable = class {
+  constructor(slide, config) {
+    this.slide = slide;
+    if (!Array.isArray(config.rows) || config.rows.length === 0 || config.rows.length > MAX_TABLE_ROWS) {
+      throw new InvalidPresentationInputError(
+        "table rows",
+        `must contain 1-${MAX_TABLE_ROWS} rows`
+      );
+    }
+    const columns = config.rows[0]?.length ?? 0;
+    if (columns === 0 || columns > MAX_TABLE_COLUMNS) {
+      throw new InvalidPresentationInputError(
+        "table columns",
+        `must contain 1-${MAX_TABLE_COLUMNS} columns`
+      );
+    }
+    if (config.rows.some((row) => !Array.isArray(row) || row.length !== columns)) {
+      throw new InvalidPresentationInputError("table rows", "must form a rectangular matrix");
+    }
+    this.id = slide.presentation.allocateId("tb", this);
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "table name", 512);
+    this.position = normalizePosition(config.position, {
+      left: 72,
+      top: 120,
+      width: 640,
+      height: Math.max(48, config.rows.length * 36)
+    });
+    this.fill = config.fill ?? "white";
+    colorValue(this.fill);
+    this.line = { style: "solid", fill: "slate-300", width: 1, ...config.line };
+    validateLine(this.line, "table line");
+    this.textStyle = { fontSize: 16, ...config.textStyle };
+    validateTextStyle(this.textStyle, "table textStyle");
+    this.rows = config.rows.map(
+      (row) => row.map(
+        (cell) => cell === null ? null : new PresentationTableCell(cell, this)
+      )
+    );
+    validateTableOccupancy(this.rows);
+    this.columnWidths = normalizeTableDimensions(config.columnWidths, columns, "columnWidths");
+    this.rowHeights = normalizeTableDimensions(config.rowHeights, config.rows.length, "rowHeights");
+  }
+  id;
+  name;
+  position;
+  rows;
+  columnWidths;
+  rowHeights;
+  fill;
+  line;
+  textStyle;
+  inspectRecord(slideIndex) {
+    return {
+      kind: "table",
+      id: this.id,
+      slide: slideIndex + 1,
+      name: this.name,
+      rows: this.rows.length,
+      columns: this.rows[0]?.length ?? 0,
+      textPreview: truncate(
+        this.rows.map((row) => row.map((cell) => cell?.text.toString() ?? "").join(" | ")).join("\n"),
+        240
+      ),
+      bbox: positionTuple(this.position),
+      bboxUnit: "px"
+    };
+  }
+  layoutSnapshot() {
+    return {
+      kind: "table",
+      id: this.id,
+      name: this.name,
+      position: { ...this.position },
+      rows: this.rows.map((row) => row.map((cell) => cell?.toConfig() ?? null)),
+      columnWidths: [...this.columnWidths],
+      rowHeights: [...this.rowHeights],
+      fill: this.fill,
+      line: { ...this.line },
+      textStyle: { ...this.textStyle }
+    };
+  }
+};
+var PresentationTableCollection = class {
+  constructor(slide) {
+    this.slide = slide;
+  }
+  items = [];
+  add(config) {
+    const table = new PresentationTable(this.slide, config);
+    this.items.push(table);
+    this.slide.appendElement(table);
+    return table;
+  }
+};
+var PresentationGroup = class _PresentationGroup {
+  constructor(slide, config = {}, depth = 1) {
+    this.slide = slide;
+    if (depth > MAX_GROUP_DEPTH) {
+      throw new InvalidPresentationInputError("group nesting", `exceeds ${MAX_GROUP_DEPTH} levels`);
+    }
+    this.id = slide.presentation.allocateId("gp", this);
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "group name", 512);
+    this.position = normalizePosition(config.position);
+    this.childOffset = config.childOffset ? { ...config.childOffset } : { left: this.position.left, top: this.position.top };
+    this.childExtent = config.childExtent ? { ...config.childExtent } : { width: this.position.width, height: this.position.height };
+    validatePosition(
+      {
+        left: this.childOffset.left,
+        top: this.childOffset.top,
+        width: this.childExtent.width,
+        height: this.childExtent.height
+      },
+      "group child coordinate system"
+    );
+    this.rotation = finiteOr(config.rotation, 0);
+    validateRotation(this.rotation, "group rotation");
+    this.flipHorizontal = config.flipHorizontal ?? false;
+    this.flipVertical = config.flipVertical ?? false;
+    for (const child of config.children ?? []) {
+      if (this.children.length >= MAX_GROUP_CHILDREN) {
+        throw new InvalidPresentationInputError(
+          "group children",
+          `exceeds ${MAX_GROUP_CHILDREN} children`
+        );
+      }
+      switch (child.kind) {
+        case "shape":
+          this.children.push(new PresentationShape(slide, child.config));
+          break;
+        case "chart":
+          this.children.push(new PresentationChart(slide, child.type, child.config ?? {}));
+          break;
+        case "image":
+          this.children.push(new PresentationImage(slide, child.config));
+          break;
+        case "table":
+          this.children.push(new PresentationTable(slide, child.config));
+          break;
+        case "group":
+          this.children.push(new _PresentationGroup(slide, child.config, depth + 1));
+          break;
+      }
+    }
+  }
+  id;
+  name;
+  position;
+  childOffset;
+  childExtent;
+  rotation;
+  flipHorizontal;
+  flipVertical;
+  children = [];
+  inspectRecord(slideIndex) {
+    return {
+      kind: "group",
+      id: this.id,
+      slide: slideIndex + 1,
+      name: this.name,
+      children: this.children.length,
+      bbox: positionTuple(this.position),
+      bboxUnit: "px"
+    };
+  }
+  layoutSnapshot() {
+    return {
+      kind: "group",
+      id: this.id,
+      name: this.name,
+      position: { ...this.position },
+      childOffset: { ...this.childOffset },
+      childExtent: { ...this.childExtent },
+      rotation: this.rotation,
+      flipHorizontal: this.flipHorizontal,
+      flipVertical: this.flipVertical,
+      children: this.children.map((child) => child.layoutSnapshot())
+    };
+  }
+};
+var PresentationGroupCollection = class {
+  constructor(slide) {
+    this.slide = slide;
+  }
+  items = [];
+  add(config = {}) {
+    const group = new PresentationGroup(this.slide, config);
+    this.items.push(group);
+    this.slide.appendElement(group);
+    return group;
+  }
+};
+var PresentationImage = class {
+  constructor(slide, config) {
+    this.slide = slide;
+    this.id = slide.presentation.allocateId("im", this);
+    this.name = config.name ?? this.id;
+    assertSafeText(this.name, "image name");
+    this.position = normalizePosition(config.position ?? config.frame, {
+      left: 72,
+      top: 120,
+      width: 480,
+      height: 270
+    });
+    this.fit = config.fit ?? "contain";
+    if (this.fit !== "contain" && this.fit !== "cover") {
+      throw new InvalidPresentationInputError("image fit", "must be contain or cover");
+    }
+    this.contentType = config.contentType;
+    this.alt = config.alt ?? "";
+    assertSafeText(this.alt, "image alt");
+    this.prompt = config.prompt;
+    if (this.prompt !== void 0) assertSafeText(this.prompt, "image prompt");
+    this.crop = config.crop ? normalizeCrop(config.crop) : void 0;
+    this.geometry = config.geometry ?? "rect";
+    if (!["rect", "roundRect", "ellipse"].includes(this.geometry)) {
+      throw new InvalidPresentationInputError("image geometry", "is not supported");
+    }
+    this.borderRadius = config.borderRadius;
+    validateBorderRadius(this.borderRadius, "image borderRadius");
+    this.rotation = finiteOr(config.rotation, 0);
+    validateRotation(this.rotation, "image rotation");
+    this.flipHorizontal = config.flipHorizontal ?? false;
+    this.flipVertical = config.flipVertical ?? false;
+    this.lockAspectRatio = config.lockAspectRatio ?? false;
+    this.assignSource(config);
+  }
+  id;
+  name;
+  position;
+  fit;
+  contentType;
+  alt;
+  prompt;
+  crop;
+  geometry;
+  borderRadius;
+  rotation;
+  flipHorizontal;
+  flipVertical;
+  lockAspectRatio;
+  blob;
+  dataUrl;
+  uri;
+  validatedContentType;
+  cachedCanonicalDataUrl;
+  get frame() {
+    return this.position;
+  }
+  set frame(value) {
+    this.position = normalizePosition(value);
+  }
+  replace(config) {
+    if (config.alt !== void 0) assertSafeText(config.alt, "image alt");
+    if (config.prompt !== void 0) assertSafeText(config.prompt, "image prompt");
+    if (config.fit !== void 0 && config.fit !== "contain" && config.fit !== "cover") {
+      throw new InvalidPresentationInputError("image fit", "must be contain or cover");
+    }
+    this.assignSource(config);
+    if (config.alt !== void 0) this.alt = config.alt;
+    if (config.fit !== void 0) this.fit = config.fit;
+    if (config.prompt !== void 0) this.prompt = config.prompt;
+  }
+  /**
+   * Explicitly materializes a host-owned URI into trusted raster bytes.
+   *
+   * Render and file export never invoke resolvers, fetch, or read files. A host
+   * must call this method deliberately, and returned bytes still pass the same
+   * MIME/signature validation as direct `blob` input.
+   */
+  async resolveUri() {
+    if (!this.uri) {
+      throw new InvalidPresentationInputError(
+        "image uri",
+        `Image ${this.id} has no URI to resolve`
+      );
+    }
+    const uri = this.uri;
+    assertSafeText(this.name, `image ${this.id} name`);
+    let resolution;
+    try {
+      resolution = await this.slide.presentation.resolveImageUri({
+        uri,
+        imageId: this.id,
+        name: this.name
+      });
+    } catch (error) {
+      const failure = new InvalidPresentationInputError(
+        "image resolver",
+        `failed to resolve image ${this.id}`
+      );
+      Object.defineProperty(failure, "cause", { value: error, enumerable: false });
+      throw failure;
+    }
+    if (!resolution || typeof resolution !== "object" || !("blob" in resolution)) {
+      throw new InvalidPresentationInputError(
+        "image resolver",
+        "must return { blob, contentType? }"
+      );
+    }
+    this.assignSource({
+      blob: resolution.blob,
+      ...resolution.contentType ? { contentType: resolution.contentType } : {}
+    });
+  }
+  sourceForSvg() {
+    if (this.uri) throw unresolvedImageUriError(this.id);
+    if (this.dataUrl) {
+      if (!this.contentType) {
+        throw new InvalidPresentationInputError(
+          "image contentType",
+          `Image ${this.id} has no validated raster MIME type`
+        );
+      }
+      const contentType = normalizeRasterMime(this.contentType);
+      if (contentType !== this.validatedContentType || !this.dataUrl.startsWith(`data:${contentType};base64,`)) {
+        throw new InvalidPresentationInputError(
+          "image contentType",
+          `Image ${this.id} MIME type no longer matches its data URL`
+        );
+      }
+      return this.cachedCanonicalDataUrl ??= this.dataUrl;
+    }
+    if (this.blob) {
+      if (!this.contentType) {
+        throw new InvalidPresentationInputError(
+          "image contentType",
+          `Image ${this.id} has no validated raster MIME type`
+        );
+      }
+      const contentType = normalizeRasterMime(this.contentType);
+      if (contentType !== this.validatedContentType) {
+        throw new InvalidPresentationInputError(
+          "image contentType",
+          `Image ${this.id} MIME type no longer matches its validated bytes`
+        );
+      }
+      return this.cachedCanonicalDataUrl ??= `data:${contentType};base64,${encodeRasterBase64(this.blob)}`;
+    }
+    return void 0;
+  }
+  sourceForPptx() {
+    const source = this.sourceForSvg();
+    if (!source) {
+      throw new UnsupportedPresentationFeatureError(
+        "prompt-only image PPTX export",
+        `Image ${this.id} must be regenerated to validated raster bytes or a raster data URL before export`
+      );
+    }
+    return { data: source };
+  }
+  inspectRecord(slideIndex) {
+    return {
+      kind: "image",
+      id: this.id,
+      slide: slideIndex + 1,
+      name: this.name,
+      alt: this.alt,
+      prompt: this.prompt,
+      fit: this.fit,
+      geometry: this.geometry,
+      source: this.blob ? "blob" : this.dataUrl ? "dataUrl" : this.uri ? "uri" : "prompt",
+      bbox: positionTuple(this.position),
+      bboxUnit: "px"
+    };
+  }
+  layoutSnapshot() {
+    return {
+      kind: "image",
+      id: this.id,
+      name: this.name,
+      alt: this.alt,
+      prompt: this.prompt,
+      fit: this.fit,
+      geometry: this.geometry,
+      position: { ...this.position },
+      crop: this.crop ? { ...this.crop } : void 0,
+      rotation: this.rotation
+    };
+  }
+  assignSource(config) {
+    const concrete = [
+      "blob" in config && config.blob !== void 0,
+      "dataUrl" in config && config.dataUrl !== void 0,
+      "uri" in config && config.uri !== void 0
+    ].filter(Boolean).length;
+    if (concrete > 1)
+      throw new InvalidPresentationInputError(
+        "image source",
+        "accepts exactly one concrete source: blob, dataUrl, or uri"
+      );
+    if (concrete === 0 && !config.prompt)
+      throw new InvalidPresentationInputError(
+        "image source",
+        "requires blob, dataUrl, uri, or prompt"
+      );
+    let blob;
+    let dataUrl;
+    let uri;
+    let contentType;
+    if ("blob" in config && config.blob !== void 0) {
+      const bytes = copyImageBytes(config.blob);
+      blob = bytes;
+      contentType = validateRasterBytes(bytes, config.contentType, "image blob");
+    } else if ("dataUrl" in config && config.dataUrl !== void 0) {
+      const parsed = parseRasterDataUrl(config.dataUrl);
+      if (config.contentType !== void 0 && normalizeRasterMime(config.contentType) !== parsed.type) {
+        throw new InvalidPresentationInputError(
+          "image contentType",
+          "does not match the data URL MIME type"
+        );
+      }
+      dataUrl = parsed.canonical;
+      contentType = parsed.type;
+    } else if ("uri" in config && config.uri !== void 0) {
+      this.slide.presentation.assertImageUriAccepted(config.uri);
+      uri = config.uri;
+    }
+    this.blob = blob;
+    this.dataUrl = dataUrl;
+    this.uri = uri;
+    this.contentType = contentType;
+    this.validatedContentType = contentType;
+    this.cachedCanonicalDataUrl = void 0;
+  }
+};
+var PresentationImageCollection = class {
+  constructor(slide) {
+    this.slide = slide;
+  }
+  items = [];
+  add(config) {
+    const image = new PresentationImage(this.slide, config);
+    this.items.push(image);
+    this.slide.appendElement(image);
+    return image;
+  }
+};
+var PresentationFile = class {
+  static async exportPptx(presentation, options = {}) {
+    validatePresentation(presentation, true);
+    const { exportPresentationPptx } = await import("@opengeni/artifact-tool/presentation/pptx");
+    return await exportPresentationPptx(presentation, options);
+  }
+  static async importPptx(input, options = {}) {
+    const { importPresentationPptx } = await import("@opengeni/artifact-tool/presentation/pptx");
+    return await importPresentationPptx(input, options);
+  }
+  static fidelityReport(presentation) {
+    const issues = [];
+    if (presentation.masters.items.length > 1 || presentation.masters.items.some((master) => master.elements.length > 0)) {
+      issues.push({
+        code: "content-preserved-in-source",
+        severity: "warning",
+        feature: "master",
+        message: "Master hierarchy is editable but requires the package-native PPTX writer for regeneration"
+      });
+    }
+    if (presentation.layouts.items.length > 1 || presentation.layouts.items.some((layout) => layout.elements.length > 0)) {
+      issues.push({
+        code: "content-preserved-in-source",
+        severity: "warning",
+        feature: "layout",
+        message: "Layout inheritance is editable but requires the package-native PPTX writer for regeneration"
+      });
+    }
+    if (presentation.slides.items.some((slide) => slide.groups.items.length > 0)) {
+      issues.push({
+        code: "group-will-be-flattened",
+        severity: "warning",
+        feature: "group",
+        message: "PptxGenJS cannot emit group scene nodes; explicit lossy export flattens their children"
+      });
+    }
+    for (const slide of presentation.slides.items) {
+      for (const chart of slide.charts.items) {
+        if ((chart.type === "scatter" || chart.type === "bubble") && !chartSeriesShareXValues(chart)) {
+          issues.push({
+            code: "style-approximated",
+            severity: "warning",
+            feature: "unsupported-chart",
+            message: `Chart ${chart.id} has different X values per series; the fallback PPTX writer only supports one shared X vector`
+          });
+        }
+      }
+    }
+    const provenance = presentationLossState(presentation);
+    if (provenance?.unsupportedParts.length) {
+      issues.push({
+        code: "content-preserved-in-source",
+        severity: "warning",
+        feature: "theme",
+        message: "Validated source-only OOXML parts cannot be regenerated after model edits",
+        parts: [...provenance.unsupportedParts]
+      });
+    }
+    return issues;
+  }
+  static lossPreservationEnvelope(presentation) {
+    const envelope = presentationLossState(presentation);
+    return envelope ? {
+      ...envelope,
+      sourceBytes: envelope.sourceBytes.slice(),
+      unsupportedParts: [...envelope.unsupportedParts]
+    } : null;
+  }
+};
+function chartSeriesShareXValues(chart) {
+  const reference = chart.series.items[0]?.xValues ?? [];
+  if (reference.length === 0) return false;
+  return chart.series.items.every(
+    (series) => series.xValues.length === reference.length && series.xValues.every((value, index) => Object.is(value, reference[index]))
+  );
+}
+function montageDimensions(presentation, requestedColumns, requestedGap) {
+  const count = presentation.slides.items.length;
+  if (count === 0) {
+    throw new InvalidPresentationInputError("montage", "cannot export an empty presentation");
+  }
+  const columns = requestedColumns ?? Math.ceil(Math.sqrt(count));
+  if (!Number.isInteger(columns) || columns <= 0) {
+    throw new InvalidPresentationInputError("montage columns", "must be a positive integer");
+  }
+  const gap = requestedGap ?? 24;
+  if (!Number.isFinite(gap) || gap < 0) {
+    throw new InvalidPresentationInputError("montage gap", "must be a non-negative number");
+  }
+  const rows = Math.ceil(count / columns);
+  const width = columns * presentation.slideSize.width + (columns + 1) * gap;
+  const height = rows * presentation.slideSize.height + (rows + 1) * gap;
+  if (!Number.isFinite(width) || !Number.isFinite(height)) {
+    throw new InvalidPresentationInputError("montage geometry", "exceeds finite numeric bounds");
+  }
+  return { columns, rows, gap, width, height };
+}
+function validateRenderScale(scale) {
+  if (!Number.isFinite(scale) || scale <= 0 || scale > 8) {
+    throw new InvalidPresentationInputError("export scale", "must be greater than 0 and at most 8");
+  }
+}
+function assertRenderPixelBudget(width, height, scale) {
+  const scaledWidth = Math.ceil(width * scale);
+  const scaledHeight = Math.ceil(height * scale);
+  if (!Number.isSafeInteger(scaledWidth) || !Number.isSafeInteger(scaledHeight) || scaledWidth <= 0 || scaledHeight <= 0) {
+    throw new InvalidPresentationInputError(
+      "render geometry",
+      "scaled dimensions must be positive safe integers"
+    );
+  }
+  if (scaledWidth > MAX_RENDER_DIMENSION || scaledHeight > MAX_RENDER_DIMENSION) {
+    throw new InvalidPresentationInputError(
+      "render dimension limit",
+      `${scaledWidth}x${scaledHeight} exceeds maximum dimension ${MAX_RENDER_DIMENSION}`
+    );
+  }
+  if (scaledWidth > Math.floor(MAX_RENDER_PIXELS / scaledHeight)) {
+    throw new InvalidPresentationInputError(
+      "render pixel limit",
+      `${scaledWidth}x${scaledHeight} exceeds maximum ${MAX_RENDER_PIXELS} pixels`
+    );
+  }
+}
+var MAX_GEOMETRY_VALUE = 1e6;
+var MAX_TEXT_LENGTH = 1e6;
+var MAX_FONT_SIZE = 4096;
+var MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+var MAX_IMAGE_URI_LENGTH = 4096;
+var MAX_RENDER_DIMENSION = 32768;
+var MAX_RENDER_PIXELS = 67108864;
+var MAX_TABLE_ROWS = 1e4;
+var MAX_TABLE_COLUMNS = 1024;
+var MAX_TABLE_SPAN = 1024;
+var MAX_GROUP_DEPTH = 32;
+var MAX_GROUP_CHILDREN = 1e5;
+var PRESENTATION_GEOMETRIES = /* @__PURE__ */ new Set([
+  "textbox",
+  "rect",
+  "roundRect",
+  "ellipse",
+  "triangle",
+  "rightArrow",
+  "line"
+]);
+var CHART_TYPES = /* @__PURE__ */ new Set([
+  "bar",
+  "line",
+  "area",
+  "pie",
+  "doughnut",
+  "scatter",
+  "bubble",
+  "radar"
+]);
+var LINE_STYLES = /* @__PURE__ */ new Set(["solid", "dash", "dot", "none"]);
+var TEXT_ALIGNMENTS = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
+var VERTICAL_ALIGNMENTS = /* @__PURE__ */ new Set(["top", "middle", "bottom"]);
+var BORDER_RADIUS_TOKENS = {
+  rounded: 4,
+  "rounded-lg": 8,
+  "rounded-xl": 12,
+  "rounded-2xl": 16,
+  "rounded-3xl": 24
+};
+var FORBIDDEN_IMAGE_URI_SCHEMES = /* @__PURE__ */ new Set([
+  "blob",
+  "data",
+  "file",
+  "ftp",
+  "ftps",
+  "http",
+  "https",
+  "javascript"
+]);
+function cloneTemplateElement(element) {
+  if (!element || typeof element !== "object") {
+    throw new InvalidPresentationInputError("template element", "must be an object");
+  }
+  switch (element.kind) {
+    case "shape":
+      return {
+        kind: "shape",
+        config: {
+          ...element.config,
+          ...element.config.position ? { position: { ...element.config.position } } : {},
+          ...element.config.line ? { line: { ...element.config.line } } : {},
+          ...element.config.textStyle ? { textStyle: { ...element.config.textStyle } } : {}
+        }
+      };
+    case "chart":
+      return {
+        kind: "chart",
+        type: element.type,
+        ...element.config ? {
+          config: {
+            ...element.config,
+            ...element.config.position ? { position: { ...element.config.position } } : {},
+            ...element.config.categories ? { categories: [...element.config.categories] } : {},
+            ...element.config.series ? {
+              series: element.config.series.map((series) => ({
+                ...series,
+                ...series.categories ? { categories: [...series.categories] } : {},
+                ...series.values ? { values: [...series.values] } : {},
+                ...series.xValues ? { xValues: [...series.xValues] } : {},
+                ...series.bubbleSizes ? { bubbleSizes: [...series.bubbleSizes] } : {},
+                ...series.line ? { line: { ...series.line } } : {}
+              }))
+            } : {},
+            ...element.config.legend ? { legend: { ...element.config.legend } } : {},
+            ...element.config.xAxis ? { xAxis: { ...element.config.xAxis } } : {},
+            ...element.config.yAxis ? { yAxis: { ...element.config.yAxis } } : {},
+            ...element.config.dataLabels ? { dataLabels: { ...element.config.dataLabels } } : {}
+          }
+        } : {}
+      };
+    case "image": {
+      const config = element.config;
+      return {
+        kind: "image",
+        config: {
+          ...config,
+          ...config.blob !== void 0 ? {
+            blob: config.blob instanceof Uint8Array ? config.blob.slice() : config.blob.slice(0)
+          } : {},
+          ...config.position ? { position: { ...config.position } } : {},
+          ...config.frame ? { frame: { ...config.frame } } : {},
+          ...config.crop ? { crop: { ...config.crop } } : {}
+        }
+      };
+    }
+    case "table":
+      return {
+        kind: "table",
+        config: {
+          ...element.config,
+          ...element.config.position ? { position: { ...element.config.position } } : {},
+          rows: element.config.rows.map(
+            (row) => row.map(
+              (cell) => cell === null || typeof cell === "string" ? cell : {
+                ...cell,
+                ...cell.textStyle ? { textStyle: { ...cell.textStyle } } : {}
+              }
+            )
+          ),
+          ...element.config.columnWidths ? { columnWidths: [...element.config.columnWidths] } : {},
+          ...element.config.rowHeights ? { rowHeights: [...element.config.rowHeights] } : {},
+          ...element.config.line ? { line: { ...element.config.line } } : {},
+          ...element.config.textStyle ? { textStyle: { ...element.config.textStyle } } : {}
+        }
+      };
+  }
+}
+function normalizeTableDimensions(values, expected, field) {
+  if (values === void 0) return [];
+  if (!Array.isArray(values) || values.length !== expected) {
+    throw new InvalidPresentationInputError(`table ${field}`, `must contain ${expected} values`);
+  }
+  const output = [...values];
+  if (output.some((value) => !Number.isFinite(value) || value <= 0 || value > MAX_GEOMETRY_VALUE)) {
+    throw new InvalidPresentationInputError(
+      `table ${field}`,
+      "must contain bounded positive numbers"
+    );
+  }
+  return output;
+}
+function validateTableOccupancy(rows) {
+  const rowCount = rows.length;
+  const columnCount = rows[0]?.length ?? 0;
+  const covered = Array.from({ length: rowCount }, () => new Uint8Array(columnCount));
+  for (let row = 0; row < rowCount; row += 1) {
+    for (let column = 0; column < columnCount; column += 1) {
+      const cell = rows[row][column];
+      if (cell === void 0) {
+        throw new InvalidPresentationInputError("table rows", "must form a rectangular matrix");
+      }
+      if (cell === null) {
+        if (covered[row][column] === 0) {
+          throw new InvalidPresentationInputError(
+            "table cell occupancy",
+            `uncovered null at row ${row + 1}, column ${column + 1}`
+          );
+        }
+        continue;
+      }
+      if (covered[row][column] !== 0) {
+        throw new InvalidPresentationInputError(
+          "table cell occupancy",
+          `spanned position at row ${row + 1}, column ${column + 1} must be null`
+        );
+      }
+      if (row + cell.rowSpan > rowCount || column + cell.colSpan > columnCount) {
+        throw new InvalidPresentationInputError(
+          "table cell span",
+          `cell at row ${row + 1}, column ${column + 1} extends outside the table`
+        );
+      }
+      for (let coveredRow = row; coveredRow < row + cell.rowSpan; coveredRow += 1) {
+        for (let coveredColumn = column; coveredColumn < column + cell.colSpan; coveredColumn += 1) {
+          if (coveredRow === row && coveredColumn === column) continue;
+          if (covered[coveredRow][coveredColumn] !== 0) {
+            throw new InvalidPresentationInputError("table cell span", "overlaps another span");
+          }
+          covered[coveredRow][coveredColumn] = 1;
+        }
+      }
+    }
+  }
+}
+function normalizePlaceholder(value) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object") {
+    throw new InvalidPresentationInputError("shape placeholder", "must be an object");
+  }
+  assertSafeText(value.type, "shape placeholder type", 128);
+  if (!/^[A-Za-z][A-Za-z0-9]*$/.test(value.type)) {
+    throw new InvalidPresentationInputError("shape placeholder type", "is invalid");
+  }
+  if (value.index !== void 0 && (!Number.isSafeInteger(value.index) || value.index < 0)) {
+    throw new InvalidPresentationInputError(
+      "shape placeholder index",
+      "must be a non-negative safe integer"
+    );
+  }
+  return value.index === void 0 ? { type: value.type } : { type: value.type, index: value.index };
+}
+function validateImageUriPolicy(resolver, schemes) {
+  if (schemes !== void 0 && !Array.isArray(schemes)) {
+    throw new InvalidPresentationInputError("allowedImageUriSchemes", "must be an array");
+  }
+  const normalized = /* @__PURE__ */ new Set();
+  for (const value of schemes ?? []) {
+    if (typeof value !== "string" || !/^[a-z][a-z0-9+.-]*$/i.test(value)) {
+      throw new InvalidPresentationInputError(
+        "allowedImageUriSchemes",
+        "contains an invalid URI scheme"
+      );
+    }
+    const scheme = value.toLowerCase();
+    if (FORBIDDEN_IMAGE_URI_SCHEMES.has(scheme)) {
+      throw new InvalidPresentationInputError(
+        "allowedImageUriSchemes",
+        `${scheme}: is reserved for active, local, or remote resources`
+      );
+    }
+    normalized.add(scheme);
+  }
+  if (!resolver && normalized.size > 0) {
+    throw new InvalidPresentationInputError(
+      "allowedImageUriSchemes",
+      "requires an injected imageResolver"
+    );
+  }
+  return normalized;
+}
+function imageUriScheme(uri) {
+  const match = /^([a-z][a-z0-9+.-]*):/i.exec(uri);
+  if (!match) {
+    throw new InvalidPresentationInputError(
+      "image uri",
+      "must use a host-owned, explicitly allowed URI scheme"
+    );
+  }
+  return match[1].toLowerCase();
+}
+function validatePresentation(presentation, requireResolvedImages) {
+  validatePosition(
+    {
+      left: 0,
+      top: 0,
+      width: presentation.slideSize.width,
+      height: presentation.slideSize.height
+    },
+    "slideSize"
+  );
+  for (const master of presentation.masters.items) {
+    assertSafeText(master.name, `master ${master.id} name`, 512);
+    colorValue(master.background);
+  }
+  for (const layout of presentation.layouts.items) {
+    assertSafeText(layout.name, `layout ${layout.id} name`, 512);
+    colorValue(layout.background);
+    if (layout.masterId !== void 0 && !presentation.masters.items.some((master) => master.id === layout.masterId)) {
+      throw new InvalidPresentationInputError(
+        `layout ${layout.id} masterId`,
+        "must reference a master in this presentation"
+      );
+    }
+  }
+  for (const [slideIndex, slide] of presentation.slides.items.entries()) {
+    assertSafeText(slide.title, `slides[${slideIndex}].title`);
+    assertSafeText(slide.notes.toString(), `slides[${slideIndex}].notes`);
+    colorValue(slide.background.fill);
+    for (const shape of slide.shapes.items) {
+      if (!PRESENTATION_GEOMETRIES.has(shape.geometry)) {
+        throw new InvalidPresentationInputError("shape geometry", "is not supported");
+      }
+      assertSafeText(shape.name, `shape ${shape.id} name`);
+      validatePosition(shape.position, `shape ${shape.id} position`);
+      colorValue(shape.fill);
+      validateLine(shape.line, `shape ${shape.id} line`);
+      validateRotation(shape.rotation, `shape ${shape.id} rotation`);
+      validateBorderRadius(shape.borderRadius, `shape ${shape.id} borderRadius`);
+      normalizePlaceholder(shape.placeholder);
+      assertSafeText(shape.text.toString(), `shape ${shape.id} text`);
+      validateTextStyle(shape.text.style, `shape ${shape.id} textStyle`);
+    }
+    for (const chart of slide.charts.items) {
+      if (!CHART_TYPES.has(chart.type)) {
+        throw new InvalidPresentationInputError("chart type", "is not supported");
+      }
+      assertSafeText(chart.name, `chart ${chart.id} name`);
+      assertSafeText(chart.title, `chart ${chart.id} title`);
+      validatePosition(chart.position, `chart ${chart.id} position`);
+      for (const [index, category] of chart.categories.entries()) {
+        assertSafeText(category, `chart ${chart.id} categories[${index}]`);
+      }
+      validateOptionalFinite(chart.xAxis?.min, `chart ${chart.id} xAxis.min`);
+      validateOptionalFinite(chart.xAxis?.max, `chart ${chart.id} xAxis.max`);
+      validateOptionalFinite(chart.yAxis?.min, `chart ${chart.id} yAxis.min`);
+      validateOptionalFinite(chart.yAxis?.max, `chart ${chart.id} yAxis.max`);
+      for (const [seriesIndex, series] of chart.series.items.entries()) {
+        assertSafeText(series.name, `chart ${chart.id} series[${seriesIndex}].name`);
+        for (const [index, category] of series.categories.entries()) {
+          assertSafeText(category, `chart ${chart.id} series[${seriesIndex}].categories[${index}]`);
+        }
+        validateFiniteArray(series.values, `chart ${chart.id} series[${seriesIndex}].values`);
+        validateFiniteArray(series.xValues, `chart ${chart.id} series[${seriesIndex}].xValues`);
+        validateFiniteArray(
+          series.bubbleSizes,
+          `chart ${chart.id} series[${seriesIndex}].bubbleSizes`
+        );
+        if (series.fill !== void 0) colorValue(series.fill);
+        if (series.line !== void 0) {
+          validateLine(series.line, `chart ${chart.id} series[${seriesIndex}].line`);
+        }
+      }
+    }
+    for (const image of slide.images.items) {
+      assertSafeText(image.name, `image ${image.id} name`);
+      assertSafeText(image.alt, `image ${image.id} alt`);
+      if (image.prompt !== void 0) assertSafeText(image.prompt, `image ${image.id} prompt`);
+      validatePosition(image.position, `image ${image.id} position`);
+      if (image.fit !== "contain" && image.fit !== "cover") {
+        throw new InvalidPresentationInputError(
+          `image ${image.id} fit`,
+          "must be contain or cover"
+        );
+      }
+      if (!["rect", "roundRect", "ellipse"].includes(image.geometry)) {
+        throw new InvalidPresentationInputError(`image ${image.id} geometry`, "is not supported");
+      }
+      validateRotation(image.rotation, `image ${image.id} rotation`);
+      validateBorderRadius(image.borderRadius, `image ${image.id} borderRadius`);
+      if (image.crop !== void 0) normalizeCrop(image.crop);
+      for (const [key, value] of [
+        ["flipHorizontal", image.flipHorizontal],
+        ["flipVertical", image.flipVertical],
+        ["lockAspectRatio", image.lockAspectRatio]
+      ]) {
+        if (typeof value !== "boolean") {
+          throw new InvalidPresentationInputError(`image ${image.id} ${key}`, "must be boolean");
+        }
+      }
+      if (requireResolvedImages) image.sourceForSvg();
+    }
+    for (const table of slide.tables.items) validatePresentationTable(table);
+    for (const group of slide.groups.items) {
+      validatePresentationGroup(group, requireResolvedImages, /* @__PURE__ */ new Set());
+    }
+    const indexedElements = [
+      ...slide.shapes.items,
+      ...slide.charts.items,
+      ...slide.images.items,
+      ...slide.tables.items,
+      ...slide.groups.items
+    ];
+    if (slide.elements.length !== indexedElements.length || new Set(slide.elements).size !== slide.elements.length || indexedElements.some((element) => !slide.elements.includes(element))) {
+      throw new InvalidPresentationInputError(
+        `slides[${slideIndex}].elements`,
+        "must contain each typed top-level element exactly once"
+      );
+    }
+  }
+}
+function validatePresentationTable(table) {
+  assertSafeText(table.name, `table ${table.id} name`, 512);
+  validatePosition(table.position, `table ${table.id} position`);
+  colorValue(table.fill);
+  validateLine(table.line, `table ${table.id} line`);
+  validateTextStyle(table.textStyle, `table ${table.id} textStyle`);
+  validateTableOccupancy(table.rows);
+  for (const row of table.rows) {
+    for (const cell of row) {
+      if (!cell) continue;
+      assertSafeText(cell.text.toString(), `table ${table.id} cell text`);
+      validateTextStyle(cell.text.style, `table ${table.id} cell textStyle`);
+      colorValue(cell.fill);
+    }
+  }
+  normalizeTableDimensions(
+    table.columnWidths.length === 0 ? void 0 : table.columnWidths,
+    table.rows[0]?.length ?? 0,
+    "columnWidths"
+  );
+  normalizeTableDimensions(
+    table.rowHeights.length === 0 ? void 0 : table.rowHeights,
+    table.rows.length,
+    "rowHeights"
+  );
+}
+function validatePresentationGroup(group, requireResolvedImages, ancestors) {
+  if (ancestors.has(group)) {
+    throw new InvalidPresentationInputError(`group ${group.id}`, "contains a cycle");
+  }
+  ancestors.add(group);
+  assertSafeText(group.name, `group ${group.id} name`, 512);
+  validatePosition(group.position, `group ${group.id} position`);
+  validatePosition(
+    {
+      left: group.childOffset.left,
+      top: group.childOffset.top,
+      width: group.childExtent.width,
+      height: group.childExtent.height
+    },
+    `group ${group.id} child coordinate system`
+  );
+  validateRotation(group.rotation, `group ${group.id} rotation`);
+  for (const child of group.children) {
+    if (child.slide !== group.slide) {
+      throw new InvalidPresentationInputError(
+        `group ${group.id}`,
+        "contains an element from another slide"
+      );
+    }
+    if (child instanceof PresentationGroup) {
+      validatePresentationGroup(child, requireResolvedImages, ancestors);
+    } else if (child instanceof PresentationTable) {
+      validatePresentationTable(child);
+    } else if (child instanceof PresentationShape) {
+      validatePosition(child.position, `shape ${child.id} position`);
+      assertSafeText(child.text.toString(), `shape ${child.id} text`);
+      validateTextStyle(child.text.style, `shape ${child.id} textStyle`);
+      colorValue(child.fill);
+      validateLine(child.line, `shape ${child.id} line`);
+    } else if (child instanceof PresentationChart) {
+      validatePosition(child.position, `chart ${child.id} position`);
+      for (const series of child.series.items)
+        validateFiniteArray(series.values, `chart ${child.id} values`);
+    } else if (child instanceof PresentationImage) {
+      validatePosition(child.position, `image ${child.id} position`);
+      if (requireResolvedImages) child.sourceForSvg();
+    }
+  }
+  ancestors.delete(group);
+}
+function validatePosition(position, field) {
+  const values = [position.left, position.top, position.width, position.height];
+  if (!values.every((value) => typeof value === "number" && Number.isFinite(value))) {
+    throw new InvalidPresentationInputError(field, "values must be finite numbers");
+  }
+  if (position.width <= 0 || position.height <= 0) {
+    throw new InvalidPresentationInputError(field, "width and height must be positive");
+  }
+  if (values.some((value) => Math.abs(value) > MAX_GEOMETRY_VALUE)) {
+    throw new InvalidPresentationInputError(field, "values exceed the supported geometry bounds");
+  }
+}
+function validateRotation(value, field) {
+  if (!Number.isFinite(value) || Math.abs(value) > MAX_GEOMETRY_VALUE) {
+    throw new InvalidPresentationInputError(field, "must be a bounded finite number");
+  }
+}
+function validateBorderRadius(value, field) {
+  if (value === void 0) return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0 || value > MAX_GEOMETRY_VALUE) {
+      throw new InvalidPresentationInputError(field, "must be a bounded non-negative number");
+    }
+    return;
+  }
+  if (value !== "rounded-full" && !Object.hasOwn(BORDER_RADIUS_TOKENS, value)) {
+    throw new InvalidPresentationInputError(field, "uses an unsupported radius token");
+  }
+}
+function validateLine(line, field) {
+  if (!line || typeof line !== "object") {
+    throw new InvalidPresentationInputError(field, "must be an object");
+  }
+  if (line.style !== void 0 && !LINE_STYLES.has(line.style)) {
+    throw new InvalidPresentationInputError(field, "uses an unsupported line style");
+  }
+  if (line.fill !== void 0) colorValue(line.fill);
+  if (line.width !== void 0 && (!Number.isFinite(line.width) || line.width < 0 || line.width > MAX_GEOMETRY_VALUE)) {
+    throw new InvalidPresentationInputError(field, "width must be a bounded non-negative number");
+  }
+}
+function validateTextStyle(style, field) {
+  if (!style || typeof style !== "object") {
+    throw new InvalidPresentationInputError(field, "must be an object");
+  }
+  if (style.fontFamily !== void 0) assertSafeText(style.fontFamily, `${field}.fontFamily`, 512);
+  if (style.fontSize !== void 0 && (!Number.isFinite(style.fontSize) || style.fontSize <= 0 || style.fontSize > MAX_FONT_SIZE)) {
+    throw new InvalidPresentationInputError(
+      `${field}.fontSize`,
+      `must be greater than 0 and at most ${MAX_FONT_SIZE}`
+    );
+  }
+  if (style.color !== void 0) colorValue(style.color);
+  if (style.alignment !== void 0 && !TEXT_ALIGNMENTS.has(style.alignment)) {
+    throw new InvalidPresentationInputError(`${field}.alignment`, "is not supported");
+  }
+  if (style.verticalAlignment !== void 0 && !VERTICAL_ALIGNMENTS.has(style.verticalAlignment)) {
+    throw new InvalidPresentationInputError(`${field}.verticalAlignment`, "is not supported");
+  }
+  for (const key of ["bold", "italic", "underline"]) {
+    if (style[key] !== void 0 && typeof style[key] !== "boolean") {
+      throw new InvalidPresentationInputError(`${field}.${key}`, "must be boolean");
+    }
+  }
+}
+function validateOptionalFinite(value, field) {
+  if (value !== void 0 && (!Number.isFinite(value) || Math.abs(value) > MAX_GEOMETRY_VALUE)) {
+    throw new InvalidPresentationInputError(field, "must be a bounded finite number");
+  }
+}
+function validateFiniteArray(values, field) {
+  if (!Array.isArray(values)) {
+    throw new InvalidPresentationInputError(field, "must be an array");
+  }
+  for (const value of values) validateOptionalFinite(value, field);
+}
+function assertSafeText(value, field, maxLength = MAX_TEXT_LENGTH) {
+  if (typeof value !== "string") {
+    throw new InvalidPresentationInputError(field, "must be a string");
+  }
+  if (value.length > maxLength) {
+    throw new InvalidPresentationInputError(field, `exceeds ${maxLength} UTF-16 code units`);
+  }
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint < 32 && codePoint !== 9 && codePoint !== 10 && codePoint !== 13 || codePoint >= 55296 && codePoint <= 57343 || codePoint === 65534 || codePoint === 65535) {
+      throw new InvalidPresentationInputError(field, "contains characters forbidden by XML 1.0");
+    }
+  }
+}
+function copyImageBytes(value) {
+  if (!(value instanceof ArrayBuffer) && !(value instanceof Uint8Array)) {
+    throw new InvalidPresentationInputError("image blob", "must be an ArrayBuffer or Uint8Array");
+  }
+  const bytes = value instanceof Uint8Array ? new Uint8Array(value) : new Uint8Array(value.slice(0));
+  if (bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES) {
+    throw new InvalidPresentationInputError(
+      "image blob",
+      `must contain between 1 and ${MAX_IMAGE_BYTES} bytes`
+    );
+  }
+  return bytes;
+}
+function normalizeRasterMime(value) {
+  try {
+    return normalizeRasterContentType(value);
+  } catch (error) {
+    if (error instanceof RasterImageValidationError) {
+      throw new InvalidPresentationInputError("image contentType", error.detail);
+    }
+    throw error;
+  }
+}
+function validateRasterBytes(bytes, declaredType, field) {
+  try {
+    return validateRasterImageBytes(bytes, declaredType);
+  } catch (error) {
+    if (error instanceof RasterImageValidationError) {
+      throw new InvalidPresentationInputError(field, error.detail);
+    }
+    throw error;
+  }
+}
+function parseRasterDataUrl(value) {
+  try {
+    const result = canonicalizeRasterDataUrl(value, MAX_IMAGE_BYTES);
+    return { type: result.contentType, canonical: result.canonical };
+  } catch (error) {
+    if (error instanceof RasterImageValidationError) {
+      throw new InvalidPresentationInputError("image dataUrl", error.detail);
+    }
+    throw error;
+  }
+}
+function unresolvedImageUriError(id) {
+  return new UnsupportedPresentationFeatureError(
+    "unresolved image URI",
+    `Image ${id} is a host reference. Call image.resolveUri() explicitly before render or export`
+  );
+}
+function normalizePosition(input, defaults = { left: 0, top: 0, width: 100, height: 100 }) {
+  const result = {
+    left: input?.left ?? defaults.left,
+    top: input?.top ?? defaults.top,
+    width: input?.width ?? defaults.width,
+    height: input?.height ?? defaults.height
+  };
+  validatePosition(result, "position");
+  return result;
+}
+function normalizeCrop(crop) {
+  const normalized = { ...crop };
+  if (!Object.values(normalized).every(
+    (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1
+  )) {
+    throw new InvalidPresentationInputError("image crop", "values must be between 0 and 1");
+  }
+  if (normalized.left + normalized.right >= 1 || normalized.top + normalized.bottom >= 1) {
+    throw new InvalidPresentationInputError(
+      "image crop",
+      "cannot remove the complete source image"
+    );
+  }
+  return normalized;
+}
+function colorValue(fill) {
+  if (typeof fill !== "string") {
+    if (!fill || typeof fill !== "object" || fill.type !== void 0 && fill.type !== "solid") {
+      throw new InvalidPresentationInputError("fill", "must be a string or a solid color object");
+    }
+  }
+  const value = typeof fill === "string" ? fill : fill.color;
+  if (typeof value !== "string") {
+    throw new InvalidPresentationInputError("color", "must be a string");
+  }
+  if (value === "none") return "none";
+  const token = COLOR_TOKENS[value];
+  if (token) return token;
+  if (/^#[0-9a-f]{6}$/i.test(value)) return value.toLowerCase();
+  if (/^#[0-9a-f]{3}$/i.test(value)) {
+    return `#${value[1]}${value[1]}${value[2]}${value[2]}${value[3]}${value[3]}`.toLowerCase();
+  }
+  throw new InvalidPresentationInputError("color", "must be a known token, none, #RGB, or #RRGGBB");
+}
+var COLOR_TOKENS = {
+  white: "#ffffff",
+  black: "#000000",
+  accent1: "#2563eb",
+  accent2: "#0f766e",
+  "slate-50": "#f8fafc",
+  "slate-100": "#f1f5f9",
+  "slate-200": "#e2e8f0",
+  "slate-300": "#cbd5e1",
+  "slate-400": "#94a3b8",
+  "slate-500": "#64748b",
+  "slate-600": "#475569",
+  "slate-700": "#334155",
+  "slate-800": "#1e293b",
+  "slate-900": "#0f172a",
+  "slate-950": "#020617"
+};
+function projectRecord(record, includeText, excludeText) {
+  const include = parseProjection(includeText);
+  const exclude = parseProjection(excludeText);
+  if (include.size === 0 && exclude.size === 0) return record;
+  const projected = {};
+  for (const [key, value] of Object.entries(record)) {
+    if ((include.size === 0 || include.has(key)) && !exclude.has(key)) projected[key] = value;
+  }
+  return projected;
+}
+function parseProjection(value) {
+  return new Set(
+    (value ?? "").split(",").map((part) => part.trim()).filter(Boolean)
+  );
+}
+function boundPresentationRecords(records, maxChars) {
+  if (!Number.isInteger(maxChars) || maxChars <= 0)
+    throw new Error("inspect maxChars must be a positive integer");
+  return boundInspectionRecords(records, maxChars);
+}
+function jsonBlob(value, name) {
+  return new FileBlob([JSON.stringify(value, null, 2)], { name, type: "application/json" });
+}
+function positionTuple(position) {
+  return [position.left, position.top, position.width, position.height];
+}
+function finiteOr(value, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isFinite(value)) {
+    throw new InvalidPresentationInputError("number", "must be finite");
+  }
+  return value;
+}
+function truncate(value, max) {
+  return value.length <= max ? value : `${value.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+
+export {
+  presentationLossState,
+  setPresentationLossState,
+  PPTX_MEDIA_TYPE,
+  PresentationFidelityError,
+  PresentationSecurityError,
+  UnsupportedPresentationFeatureError,
+  InvalidPresentationInputError,
+  Presentation,
+  PresentationMaster,
+  PresentationLayout,
+  PresentationMasterCollection,
+  PresentationLayoutCollection,
+  SlideCollection,
+  Slide,
+  SlidePlaceholderCollection,
+  PresentationText,
+  PresentationShape,
+  PresentationShapeCollection,
+  PresentationChartSeries,
+  PresentationChartSeriesCollection,
+  PresentationChart,
+  PresentationChartCollection,
+  PresentationTableCell,
+  PresentationTable,
+  PresentationTableCollection,
+  PresentationGroup,
+  PresentationGroupCollection,
+  PresentationImage,
+  PresentationImageCollection,
+  PresentationFile,
+  assertRenderPixelBudget,
+  colorValue,
+  truncate
+};
+//# sourceMappingURL=chunk-PI2AZVGK.js.map