json2pptx-schema 0.1.0

package/dist/index.js

@@ -0,0 +1,818 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_HEIGHT: () => DEFAULT_HEIGHT,
+  DEFAULT_SCHEMA_VERSION: () => DEFAULT_SCHEMA_VERSION,
+  DEFAULT_SLIDE_REMARK: () => DEFAULT_SLIDE_REMARK,
+  DEFAULT_SLIDE_TYPE: () => DEFAULT_SLIDE_TYPE,
+  DEFAULT_THEME: () => DEFAULT_THEME,
+  DEFAULT_THEME_OUTLINE: () => DEFAULT_THEME_OUTLINE,
+  DEFAULT_THEME_SHADOW: () => DEFAULT_THEME_SHADOW,
+  DEFAULT_TITLE: () => DEFAULT_TITLE,
+  DEFAULT_WIDTH: () => DEFAULT_WIDTH,
+  SchemaValidationError: () => SchemaValidationError,
+  UnsupportedSchemaVersionError: () => UnsupportedSchemaVersionError,
+  V1_DEFAULTS: () => V1_DEFAULTS,
+  V1_SCHEMA_VERSION: () => V1_SCHEMA_VERSION,
+  migrateDocument: () => migrateDocument,
+  normalizeDocument: () => normalizeDocument,
+  parseDocument: () => parseDocument,
+  validateDocument: () => validateDocument
+});
+module.exports = __toCommonJS(index_exports);
+
+// versions/v1/defaults.ts
+var DEFAULT_SCHEMA_VERSION = "1.0.0";
+var DEFAULT_TITLE = "\u672A\u547D\u540D\u6F14\u793A\u6587\u7A3F";
+var DEFAULT_WIDTH = 1e3;
+var DEFAULT_HEIGHT = 562.5;
+var DEFAULT_THEME_SHADOW = {
+  h: 3,
+  v: 3,
+  blur: 2,
+  color: "#808080"
+};
+var DEFAULT_THEME_OUTLINE = {
+  width: 2,
+  color: "#525252",
+  style: "solid"
+};
+var DEFAULT_THEME = {
+  themeColors: [],
+  fontColor: "#333",
+  fontName: "",
+  backgroundColor: "#fff",
+  shadow: DEFAULT_THEME_SHADOW,
+  outline: DEFAULT_THEME_OUTLINE
+};
+var DEFAULT_SLIDE_TYPE = "content";
+var DEFAULT_SLIDE_REMARK = "";
+var DEFAULT_TEXT_COLOR = "#333";
+var DEFAULT_ELEMENT_ROTATE = 0;
+var DEFAULT_IMAGE_FIXED_RATIO = true;
+var DEFAULT_SHAPE_FIXED_RATIO = false;
+var DEFAULT_LINE_STYLE = "solid";
+var DEFAULT_LINE_WIDTH = 2;
+var LEGACY_SLIDE_TYPE_MAP = {
+  agenda: "contents",
+  section: "transition",
+  ending: "end"
+};
+var V1_DEFAULTS = {
+  schemaVersion: DEFAULT_SCHEMA_VERSION,
+  title: DEFAULT_TITLE,
+  width: DEFAULT_WIDTH,
+  height: DEFAULT_HEIGHT,
+  theme: DEFAULT_THEME
+};
+
+// runtime/errors.ts
+var SchemaValidationError = class extends Error {
+  constructor(issues, message = "Schema validation failed") {
+    super(message);
+    this.name = "SchemaValidationError";
+    this.issues = issues;
+  }
+};
+var UnsupportedSchemaVersionError = class extends Error {
+  constructor(receivedVersion, supportedVersion) {
+    const received = receivedVersion === void 0 || receivedVersion === null ? void 0 : String(receivedVersion);
+    super(
+      received ? `Unsupported schema version: ${received}. Supported version: ${supportedVersion}.` : `Unsupported schema version. Supported version: ${supportedVersion}.`
+    );
+    this.code = "UNSUPPORTED_SCHEMA_VERSION";
+    this.name = "UnsupportedSchemaVersionError";
+    this.supportedVersion = supportedVersion;
+    this.receivedVersion = received;
+  }
+};
+
+// runtime/migrate.ts
+var V1_VERSION_EQUIVALENTS = /* @__PURE__ */ new Set(["1", "1.0", "1.0.0"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function normalizeVersion(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value === 1) return DEFAULT_SCHEMA_VERSION;
+    return null;
+  }
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (V1_VERSION_EQUIVALENTS.has(trimmed)) return DEFAULT_SCHEMA_VERSION;
+  return null;
+}
+function migrateSlideType(type) {
+  if (typeof type !== "string") return type;
+  const normalized = type.trim().toLowerCase();
+  return LEGACY_SLIDE_TYPE_MAP[normalized] ?? type;
+}
+function migrateDocument(input, toVersion = DEFAULT_SCHEMA_VERSION) {
+  if (!isRecord(input)) return input;
+  const migrated = cloneValue(input);
+  const incomingVersion = migrated.schemaVersion ?? migrated.version;
+  if (incomingVersion === void 0) {
+    migrated.schemaVersion = toVersion;
+  } else {
+    const normalizedVersion = normalizeVersion(incomingVersion);
+    if (!normalizedVersion || normalizedVersion !== toVersion) {
+      throw new UnsupportedSchemaVersionError(incomingVersion, toVersion);
+    }
+    migrated.schemaVersion = toVersion;
+  }
+  delete migrated.version;
+  if (isRecord(migrated.theme)) {
+    const theme = migrated.theme;
+    if (typeof theme.fontname === "string" && theme.fontName === void 0) {
+      theme.fontName = theme.fontname;
+      delete theme.fontname;
+    }
+  }
+  if (Array.isArray(migrated.slides)) {
+    migrated.slides = migrated.slides.map((slide) => {
+      if (!isRecord(slide)) return slide;
+      const nextSlide = cloneValue(slide);
+      nextSlide.type = migrateSlideType(nextSlide.type);
+      return nextSlide;
+    });
+  }
+  return migrated;
+}
+
+// runtime/normalize.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneValue2(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function asString(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asPair(value, fallback) {
+  if (!Array.isArray(value) || value.length < 2) return fallback;
+  return [asNumber(value[0], fallback[0]), asNumber(value[1], fallback[1])];
+}
+function asLinePoints(value) {
+  if (!Array.isArray(value)) return ["", ""];
+  const first = typeof value[0] === "string" ? value[0] : "";
+  const second = typeof value[1] === "string" ? value[1] : "";
+  return [first, second];
+}
+function normalizeShadow(value) {
+  const source = isRecord2(value) ? value : {};
+  return {
+    ...source,
+    h: asNumber(source.h, DEFAULT_THEME_SHADOW.h),
+    v: asNumber(source.v, DEFAULT_THEME_SHADOW.v),
+    blur: asNumber(source.blur, DEFAULT_THEME_SHADOW.blur),
+    color: asString(source.color, DEFAULT_THEME_SHADOW.color)
+  };
+}
+function normalizeOutline(value) {
+  const source = isRecord2(value) ? value : {};
+  return {
+    ...source,
+    width: asNumber(source.width, DEFAULT_THEME_OUTLINE.width),
+    color: asString(source.color, DEFAULT_THEME_OUTLINE.color),
+    style: asString(source.style, DEFAULT_THEME_OUTLINE.style)
+  };
+}
+function normalizeTheme(value) {
+  const source = isRecord2(value) ? value : {};
+  const themeColors = Array.isArray(source.themeColors) ? source.themeColors.filter((item) => typeof item === "string") : DEFAULT_THEME.themeColors.slice();
+  return {
+    ...source,
+    themeColors,
+    fontColor: asString(source.fontColor, DEFAULT_THEME.fontColor),
+    fontName: asString(source.fontName, DEFAULT_THEME.fontName),
+    backgroundColor: asString(source.backgroundColor, DEFAULT_THEME.backgroundColor),
+    shadow: normalizeShadow(source.shadow),
+    outline: normalizeOutline(source.outline)
+  };
+}
+function normalizeBackground(value, fallbackColor) {
+  if (!isRecord2(value)) return void 0;
+  const type = typeof value.type === "string" && value.type.trim().length > 0 ? value.type : "solid";
+  const normalized = {
+    ...value,
+    type
+  };
+  if (type === "solid" && typeof normalized.color !== "string") {
+    normalized.color = fallbackColor;
+  }
+  return normalized;
+}
+function normalizeElement(value, slideIndex, elementIndex, theme) {
+  const fallbackId = `slide-${slideIndex + 1}-element-${elementIndex + 1}`;
+  if (!isRecord2(value)) {
+    return {
+      type: "unknown",
+      id: fallbackId,
+      left: 0,
+      top: 0,
+      rotate: DEFAULT_ELEMENT_ROTATE
+    };
+  }
+  const type = typeof value.type === "string" && value.type.trim().length > 0 ? value.type : "unknown";
+  const base = {
+    ...value,
+    type,
+    id: asString(value.id, fallbackId),
+    left: asNumber(value.left, 0),
+    top: asNumber(value.top, 0),
+    rotate: asNumber(value.rotate, DEFAULT_ELEMENT_ROTATE)
+  };
+  if (type === "text") {
+    const textElement = {
+      ...base,
+      type: "text",
+      width: asNumber(value.width, 0),
+      height: asNumber(value.height, 0),
+      content: asString(value.content, ""),
+      defaultColor: asString(value.defaultColor, theme.fontColor || DEFAULT_TEXT_COLOR),
+      defaultFontName: asString(value.defaultFontName, theme.fontName),
+      vertical: asBoolean(value.vertical, false)
+    };
+    return textElement;
+  }
+  if (type === "shape") {
+    const width = asNumber(value.width, 0);
+    const height = asNumber(value.height, 0);
+    const shapeElement = {
+      ...base,
+      type: "shape",
+      width,
+      height,
+      path: asString(value.path, ""),
+      viewBox: asPair(value.viewBox, [width, height]),
+      fill: asString(value.fill, ""),
+      fixedRatio: asBoolean(value.fixedRatio, DEFAULT_SHAPE_FIXED_RATIO)
+    };
+    return shapeElement;
+  }
+  if (type === "line") {
+    const lineElement = {
+      ...base,
+      type: "line",
+      width: asNumber(value.width, DEFAULT_LINE_WIDTH),
+      start: asPair(value.start, [0, 0]),
+      end: asPair(value.end, [0, 0]),
+      points: asLinePoints(value.points),
+      color: asString(value.color, "#000000"),
+      style: asString(value.style, DEFAULT_LINE_STYLE)
+    };
+    return lineElement;
+  }
+  if (type === "image") {
+    const imageElement = {
+      ...base,
+      type: "image",
+      width: asNumber(value.width, 0),
+      height: asNumber(value.height, 0),
+      src: asString(value.src, ""),
+      fixedRatio: asBoolean(value.fixedRatio, DEFAULT_IMAGE_FIXED_RATIO)
+    };
+    return imageElement;
+  }
+  return base;
+}
+function normalizeSlide(value, index, theme) {
+  if (!isRecord2(value)) {
+    return {
+      id: `slide-${index + 1}`,
+      type: DEFAULT_SLIDE_TYPE,
+      remark: DEFAULT_SLIDE_REMARK,
+      elements: []
+    };
+  }
+  const rawType = typeof value.type === "string" ? value.type.trim() : "";
+  const normalizedType = rawType && LEGACY_SLIDE_TYPE_MAP[rawType.toLowerCase()] ? LEGACY_SLIDE_TYPE_MAP[rawType.toLowerCase()] : rawType || DEFAULT_SLIDE_TYPE;
+  const sourceElements = Array.isArray(value.elements) ? value.elements : [];
+  const elements = sourceElements.map(
+    (element, elementIndex) => normalizeElement(element, index, elementIndex, theme)
+  );
+  const background = normalizeBackground(value.background, theme.backgroundColor);
+  return {
+    ...value,
+    id: asString(value.id, `slide-${index + 1}`),
+    type: normalizedType,
+    remark: asString(value.remark, DEFAULT_SLIDE_REMARK),
+    background,
+    elements
+  };
+}
+function normalizeDocument(input) {
+  const source = cloneValue2(input);
+  if (!isRecord2(source)) {
+    return {
+      schemaVersion: DEFAULT_SCHEMA_VERSION,
+      title: DEFAULT_TITLE,
+      width: DEFAULT_WIDTH,
+      height: DEFAULT_HEIGHT,
+      theme: normalizeTheme(void 0),
+      slides: []
+    };
+  }
+  const theme = normalizeTheme(source.theme);
+  const sourceSlides = Array.isArray(source.slides) ? source.slides : [];
+  const slides = sourceSlides.map((slide, index) => normalizeSlide(slide, index, theme));
+  const normalized = {
+    ...source,
+    schemaVersion: DEFAULT_SCHEMA_VERSION,
+    title: asString(source.title, DEFAULT_TITLE),
+    width: asNumber(source.width, DEFAULT_WIDTH),
+    height: asNumber(source.height, DEFAULT_HEIGHT),
+    theme,
+    slides
+  };
+  delete normalized.version;
+  return normalized;
+}
+
+// runtime/validate.ts
+var import_ajv = __toESM(require("ajv"));
+
+// versions/v1/schema.json
+var schema_default = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  $id: "https://json2pptx.dev/schema/v1",
+  title: "json2pptx document schema v1",
+  type: "object",
+  required: ["slides"],
+  properties: {
+    schemaVersion: {
+      const: "1.0.0"
+    },
+    version: {
+      oneOf: [
+        { type: "string" },
+        { type: "number" }
+      ]
+    },
+    title: {
+      type: "string"
+    },
+    width: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    height: {
+      type: "number",
+      exclusiveMinimum: 0
+    },
+    theme: {
+      $ref: "#/definitions/theme"
+    },
+    slides: {
+      type: "array",
+      items: {
+        $ref: "#/definitions/slide"
+      }
+    }
+  },
+  additionalProperties: true,
+  definitions: {
+    shadow: {
+      type: "object",
+      required: ["h", "v", "blur", "color"],
+      properties: {
+        h: { type: "number" },
+        v: { type: "number" },
+        blur: { type: "number" },
+        color: { type: "string" }
+      },
+      additionalProperties: true
+    },
+    outline: {
+      type: "object",
+      required: ["width", "color", "style"],
+      properties: {
+        width: { type: "number" },
+        color: { type: "string" },
+        style: { type: "string" }
+      },
+      additionalProperties: true
+    },
+    gradientStop: {
+      type: "object",
+      required: ["pos", "color"],
+      properties: {
+        pos: { type: "number" },
+        color: { type: "string" }
+      },
+      additionalProperties: true
+    },
+    gradient: {
+      type: "object",
+      required: ["type", "rotate", "colors"],
+      properties: {
+        type: { type: "string" },
+        rotate: { type: "number" },
+        colors: {
+          type: "array",
+          minItems: 2,
+          items: {
+            $ref: "#/definitions/gradientStop"
+          }
+        }
+      },
+      additionalProperties: true
+    },
+    theme: {
+      type: "object",
+      properties: {
+        themeColors: {
+          type: "array",
+          items: { type: "string" }
+        },
+        fontColor: { type: "string" },
+        fontName: { type: "string" },
+        backgroundColor: { type: "string" },
+        shadow: { $ref: "#/definitions/shadow" },
+        outline: { $ref: "#/definitions/outline" }
+      },
+      additionalProperties: true
+    },
+    pair: {
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: { type: "number" }
+    },
+    linePoints: {
+      type: "array",
+      minItems: 2,
+      maxItems: 2,
+      items: { type: "string" }
+    },
+    shapeText: {
+      type: "object",
+      required: ["content"],
+      properties: {
+        content: { type: "string" },
+        defaultColor: { type: "string" },
+        defaultFontName: { type: "string" },
+        align: { type: "string" },
+        lineHeight: { type: "number" },
+        type: { type: "string" }
+      },
+      additionalProperties: true
+    },
+    clip: {
+      type: "object",
+      required: ["shape", "range"],
+      properties: {
+        shape: { type: "string" },
+        range: {
+          type: "array",
+          minItems: 2,
+          maxItems: 2,
+          items: {
+            $ref: "#/definitions/pair"
+          }
+        }
+      },
+      additionalProperties: true
+    },
+    filters: {
+      type: "object",
+      properties: {
+        opacity: {
+          oneOf: [
+            { type: "string" },
+            { type: "number" }
+          ]
+        },
+        grayscale: {
+          oneOf: [
+            { type: "string" },
+            { type: "number" }
+          ]
+        },
+        blur: {
+          oneOf: [
+            { type: "string" },
+            { type: "number" }
+          ]
+        },
+        sepia: {
+          oneOf: [
+            { type: "string" },
+            { type: "number" }
+          ]
+        },
+        saturate: {
+          oneOf: [
+            { type: "string" },
+            { type: "number" }
+          ]
+        }
+      },
+      additionalProperties: true
+    },
+    tableCellStyle: {
+      type: "object",
+      properties: {
+        fontname: { type: "string" },
+        color: { type: "string" },
+        align: { type: "string" },
+        fontsize: { type: "string" },
+        backcolor: { type: "string" }
+      },
+      additionalProperties: true
+    },
+    tableCell: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        colspan: { type: "number" },
+        rowspan: { type: "number" },
+        text: { type: "string" },
+        style: { $ref: "#/definitions/tableCellStyle" }
+      },
+      additionalProperties: true
+    },
+    element: {
+      type: "object",
+      required: ["type"],
+      properties: {
+        type: { type: "string" },
+        id: { type: "string" },
+        groupId: { type: "string" },
+        left: { type: "number" },
+        top: { type: "number" },
+        width: { type: "number" },
+        height: { type: "number" },
+        rotate: { type: "number" },
+        lock: { type: "boolean" },
+        opacity: { type: "number" },
+        flipH: { type: "boolean" },
+        flipV: { type: "boolean" },
+        shadow: { $ref: "#/definitions/shadow" },
+        outline: { $ref: "#/definitions/outline" }
+      },
+      allOf: [
+        {
+          if: {
+            required: ["type"],
+            properties: {
+              type: { const: "text" }
+            }
+          },
+          then: {
+            required: ["content", "left", "top", "width", "height"],
+            properties: {
+              content: { type: "string" },
+              defaultColor: { type: "string" },
+              defaultFontName: { type: "string" },
+              fill: { type: "string" },
+              lineHeight: { type: "number" },
+              paragraphSpace: { type: "number" },
+              textType: { type: "string" },
+              vertical: { type: "boolean" },
+              wordSpace: { type: "number" }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["type"],
+            properties: {
+              type: { const: "shape" }
+            }
+          },
+          then: {
+            required: [
+              "path",
+              "viewBox",
+              "fill",
+              "left",
+              "top",
+              "width",
+              "height"
+            ],
+            properties: {
+              path: { type: "string" },
+              viewBox: { $ref: "#/definitions/pair" },
+              fill: { type: "string" },
+              fixedRatio: { type: "boolean" },
+              keypoints: {
+                type: "array",
+                items: { type: "number" }
+              },
+              pathFormula: { type: "string" },
+              gradient: { $ref: "#/definitions/gradient" },
+              special: { type: "boolean" },
+              text: { $ref: "#/definitions/shapeText" }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["type"],
+            properties: {
+              type: { const: "line" }
+            }
+          },
+          then: {
+            required: [
+              "start",
+              "end",
+              "points",
+              "color",
+              "width",
+              "left",
+              "top"
+            ],
+            properties: {
+              start: { $ref: "#/definitions/pair" },
+              end: { $ref: "#/definitions/pair" },
+              points: { $ref: "#/definitions/linePoints" },
+              broken: { $ref: "#/definitions/pair" },
+              color: { type: "string" },
+              style: { type: "string" },
+              width: { type: "number" }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["type"],
+            properties: {
+              type: { const: "image" }
+            }
+          },
+          then: {
+            required: ["src", "left", "top", "width", "height"],
+            properties: {
+              src: { type: "string" },
+              fixedRatio: { type: "boolean" },
+              clip: { $ref: "#/definitions/clip" },
+              filters: { $ref: "#/definitions/filters" },
+              imageType: { type: "string" },
+              radius: { type: "number" },
+              colorMask: { type: "string" }
+            }
+          }
+        },
+        {
+          if: {
+            required: ["type"],
+            properties: {
+              type: { const: "table" }
+            }
+          },
+          then: {
+            required: ["left", "top", "width", "height"],
+            properties: {
+              colWidths: {
+                type: "array",
+                items: { type: "number" }
+              },
+              data: {
+                type: "array",
+                items: {
+                  type: "array",
+                  items: {
+                    $ref: "#/definitions/tableCell"
+                  }
+                }
+              },
+              cellMinHeight: { type: "number" }
+            }
+          }
+        }
+      ],
+      additionalProperties: true
+    },
+    slideBackground: {
+      type: "object",
+      properties: {
+        type: { type: "string" },
+        color: { type: "string" },
+        src: { type: "string" },
+        gradient: { $ref: "#/definitions/gradient" }
+      },
+      additionalProperties: true
+    },
+    slide: {
+      type: "object",
+      required: ["elements"],
+      properties: {
+        id: { type: "string" },
+        type: { type: "string" },
+        remark: { type: "string" },
+        background: { $ref: "#/definitions/slideBackground" },
+        elements: {
+          type: "array",
+          items: {
+            $ref: "#/definitions/element"
+          }
+        }
+      },
+      additionalProperties: true
+    }
+  }
+};
+
+// runtime/validate.ts
+var ajv = new import_ajv.default({
+  allErrors: true,
+  strict: false,
+  allowUnionTypes: true
+});
+var validateV1 = ajv.compile(schema_default);
+function mapError(error) {
+  return {
+    code: "SCHEMA_VALIDATION_ERROR",
+    path: error.instancePath || "/",
+    message: error.message ?? "Invalid value",
+    keyword: error.keyword,
+    params: error.params && typeof error.params === "object" ? error.params : void 0
+  };
+}
+function validateDocument(input) {
+  const valid = validateV1(input);
+  if (!valid) {
+    const issues = (validateV1.errors ?? []).map(mapError);
+    throw new SchemaValidationError(issues);
+  }
+  return input;
+}
+
+// runtime/parse.ts
+function parseDocument(input) {
+  const migrated = migrateDocument(input);
+  const validated = validateDocument(migrated);
+  return normalizeDocument(validated);
+}
+
+// versions/v1/types.ts
+var V1_SCHEMA_VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_HEIGHT,
+  DEFAULT_SCHEMA_VERSION,
+  DEFAULT_SLIDE_REMARK,
+  DEFAULT_SLIDE_TYPE,
+  DEFAULT_THEME,
+  DEFAULT_THEME_OUTLINE,
+  DEFAULT_THEME_SHADOW,
+  DEFAULT_TITLE,
+  DEFAULT_WIDTH,
+  SchemaValidationError,
+  UnsupportedSchemaVersionError,
+  V1_DEFAULTS,
+  V1_SCHEMA_VERSION,
+  migrateDocument,
+  normalizeDocument,
+  parseDocument,
+  validateDocument
+});
+//# sourceMappingURL=index.js.map