@gramps-connect/story 0.1.3 → 0.3.0

package/dist/editor.js

@@ -0,0 +1,3910 @@
+// src/editor/StoryEditor.tsx
+import { useCallback, useEffect as useEffect6, useMemo as useMemo2, useRef as useRef7, useState as useState7 } from "react";
+import {
+  ActionIcon as ActionIcon2,
+  Badge,
+  Box as Box2,
+  Button as Button3,
+  Divider,
+  Group as Group4,
+  Modal,
+  Popover,
+  Select,
+  Stack as Stack5,
+  Text as Text4,
+  TextInput as TextInput3,
+  Tooltip as Tooltip2,
+  UnstyledButton as UnstyledButton2
+} from "@mantine/core";
+import { useMediaQuery } from "@mantine/hooks";
+
+// src/image.ts
+var DEFAULT_MAX_EDGE = { photo: 1600, overlay: 2048 };
+function fitWithin(width, height, maxEdge) {
+  const longEdge = Math.max(width, height);
+  if (longEdge <= maxEdge) return { width, height };
+  const scale = maxEdge / longEdge;
+  return { width: Math.max(1, Math.round(width * scale)), height: Math.max(1, Math.round(height * scale)) };
+}
+function encodingCandidates(purpose, hasAlpha) {
+  if (hasAlpha) return purpose === "overlay" ? ["image/png"] : ["image/webp", "image/png"];
+  return ["image/webp", "image/jpeg"];
+}
+var EXT = {
+  "image/webp": "webp",
+  "image/jpeg": "jpg",
+  "image/png": "png"
+};
+function canvasHasAlpha(ctx, width, height) {
+  const data = ctx.getImageData(0, 0, width, height).data;
+  for (let i = 3; i < data.length; i += 4) {
+    if (data[i] < 255) return true;
+  }
+  return false;
+}
+async function optimizeImage(input, options = {}) {
+  const purpose = options.purpose ?? "photo";
+  const maxEdge = options.maxEdge ?? DEFAULT_MAX_EDGE[purpose];
+  const quality = options.quality ?? 0.82;
+  const bitmap = await createImageBitmap(input, { imageOrientation: "from-image" });
+  try {
+    const { width, height } = fitWithin(bitmap.width, bitmap.height, maxEdge);
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("No 2D canvas context available.");
+    ctx.imageSmoothingQuality = "high";
+    ctx.drawImage(bitmap, 0, 0, width, height);
+    const hasAlpha = canvasHasAlpha(ctx, width, height);
+    for (const mime of encodingCandidates(purpose, hasAlpha)) {
+      const blob2 = await canvas.convertToBlob({ type: mime, quality });
+      if (blob2.type === mime) return { blob: blob2, mime, ext: EXT[mime], width, height };
+    }
+    const blob = await canvas.convertToBlob({ type: "image/png" });
+    return { blob, mime: "image/png", ext: "png", width, height };
+  } finally {
+    bitmap.close();
+  }
+}
+
+// spec/1.0/story.schema.json
+var story_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://dsblank.github.io/gramps-connect-stories/spec/1.0/story.schema.json",
+  title: "Gramps Connect Story, format 1.0",
+  description: "The story.json at the root of a .story.zip. See spec/1.0/README.md for the rules this schema can't express (every ref resolves, every src exists in the zip, unknown fields are ignored).",
+  type: "object",
+  required: ["format", "version", "title", "slides", "media"],
+  properties: {
+    $schema: { type: "string" },
+    format: { const: "gramps-connect-story" },
+    version: {
+      description: "MAJOR.MINOR. This schema validates any 1.x file: newer minor versions only add optional fields.",
+      type: "string",
+      pattern: "^1\\.(0|[1-9][0-9]*)$"
+    },
+    title: { type: "string", pattern: "\\S" },
+    language: {
+      description: `BCP 47 language tag of the story's text, e.g. "en", "de-CH".`,
+      type: "string",
+      pattern: "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$"
+    },
+    created: {
+      description: "When the file was written, as an RFC 3339 date-time.",
+      type: "string",
+      pattern: "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$"
+    },
+    generator: {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string", pattern: "\\S" },
+        version: { type: "string" },
+        url: { type: "string" }
+      }
+    },
+    authors: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["name"],
+        properties: {
+          name: { type: "string", pattern: "\\S" },
+          url: { type: "string" }
+        }
+      }
+    },
+    license: {
+      description: "License of the story's content (text and media), as an SPDX identifier or free text.",
+      type: "string"
+    },
+    presentation: {
+      type: "object",
+      properties: {
+        basemap: { enum: ["standard", "historical", "auto", "none"] }
+      }
+    },
+    slides: {
+      type: "array",
+      minItems: 1,
+      items: { $ref: "#/$defs/slide" }
+    },
+    media: {
+      description: "Every media file in the story, keyed by an id that slides and overlays refer to.",
+      type: "object",
+      propertyNames: { $ref: "#/$defs/id" },
+      additionalProperties: { $ref: "#/$defs/mediaItem" }
+    },
+    extensions: {
+      description: "Producer-specific data, keyed by namespace. Viewers ignore it.",
+      type: "object",
+      additionalProperties: { type: "object" }
+    }
+  },
+  $defs: {
+    id: {
+      type: "string",
+      pattern: "^[A-Za-z0-9_-]{1,64}$"
+    },
+    storyDate: {
+      type: "object",
+      required: ["text"],
+      properties: {
+        text: {
+          description: "The date as it should be shown, in the story's language.",
+          type: "string",
+          pattern: "\\S"
+        },
+        edtf: {
+          description: "Optional machine-readable form, in Extended Date/Time Format (ISO 8601-2).",
+          type: "string",
+          pattern: "\\S"
+        },
+        sortYear: {
+          description: "Optional year (proleptic Gregorian) that places the slide on the timeline.",
+          type: "integer"
+        }
+      }
+    },
+    slide: {
+      type: "object",
+      required: ["id"],
+      properties: {
+        id: { $ref: "#/$defs/id" },
+        title: { type: "string" },
+        text: {
+          description: "Body text. Markup: **bold**, *italic*, line breaks. Nothing else is interpreted.",
+          type: "string"
+        },
+        date: { $ref: "#/$defs/storyDate" },
+        place: { $ref: "#/$defs/place" },
+        media: {
+          type: "array",
+          items: { $ref: "#/$defs/slideMedia" }
+        },
+        people: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["name"],
+            properties: {
+              name: { type: "string", pattern: "\\S" },
+              role: { type: "string" }
+            }
+          }
+        }
+      }
+    },
+    slideMedia: {
+      type: "object",
+      required: ["ref"],
+      properties: {
+        ref: { $ref: "#/$defs/id" },
+        caption: { type: "string" },
+        credit: { type: "string" }
+      }
+    },
+    place: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        lat: { type: "number", minimum: -90, maximum: 90 },
+        lon: { type: "number", minimum: -180, maximum: 180 },
+        geometry: {
+          description: "Optional GeoJSON (RFC 7946) object drawn under the slide's pin: a FeatureCollection, Feature, or bare geometry.",
+          type: "object",
+          required: ["type"],
+          properties: { type: { type: "string" } },
+          additionalProperties: true
+        },
+        overlays: {
+          type: "array",
+          items: { $ref: "#/$defs/overlay" }
+        }
+      },
+      dependentRequired: {
+        lat: ["lon"],
+        lon: ["lat"]
+      }
+    },
+    lonLat: {
+      type: "array",
+      prefixItems: [
+        { type: "number", minimum: -180, maximum: 180 },
+        { type: "number", minimum: -90, maximum: 90 }
+      ],
+      minItems: 2,
+      maxItems: 2
+    },
+    overlay: {
+      type: "object",
+      required: ["media", "corners"],
+      properties: {
+        media: { $ref: "#/$defs/id" },
+        corners: {
+          description: "[lon, lat] of the image's top-left, top-right, bottom-right and bottom-left corners.",
+          type: "array",
+          items: { $ref: "#/$defs/lonLat" },
+          minItems: 4,
+          maxItems: 4
+        },
+        opacity: { type: "number", minimum: 0, maximum: 1 },
+        order: {
+          description: "Stacking order among a slide's overlays; lower is drawn first.",
+          type: "integer"
+        },
+        date: { $ref: "#/$defs/storyDate" }
+      }
+    },
+    mediaItem: {
+      type: "object",
+      required: ["src", "mime"],
+      properties: {
+        src: {
+          description: 'Path of the file inside the zip, relative to its root. No leading slash, no ".." segments.',
+          type: "string",
+          pattern: "^(?!/)(?!.*(^|/)\\.\\.?(/|$))[^\\\\]+$"
+        },
+        mime: {
+          type: "string",
+          pattern: "^[a-z]+/[A-Za-z0-9.+-]+$"
+        },
+        width: { type: "integer", minimum: 1 },
+        height: { type: "integer", minimum: 1 },
+        alt: { type: "string" }
+      }
+    }
+  }
+};
+
+// src/generated/schemaValidator.js
+var validate = validate20;
+var schema31 = { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://dsblank.github.io/gramps-connect-stories/spec/1.0/story.schema.json", "title": "Gramps Connect Story, format 1.0", "description": "The story.json at the root of a .story.zip. See spec/1.0/README.md for the rules this schema can't express (every ref resolves, every src exists in the zip, unknown fields are ignored).", "type": "object", "required": ["format", "version", "title", "slides", "media"], "properties": { "$schema": { "type": "string" }, "format": { "const": "gramps-connect-story" }, "version": { "description": "MAJOR.MINOR. This schema validates any 1.x file: newer minor versions only add optional fields.", "type": "string", "pattern": "^1\\.(0|[1-9][0-9]*)$" }, "title": { "type": "string", "pattern": "\\S" }, "language": { "description": `BCP 47 language tag of the story's text, e.g. "en", "de-CH".`, "type": "string", "pattern": "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$" }, "created": { "description": "When the file was written, as an RFC 3339 date-time.", "type": "string", "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$" }, "generator": { "type": "object", "required": ["name"], "properties": { "name": { "type": "string", "pattern": "\\S" }, "version": { "type": "string" }, "url": { "type": "string" } } }, "authors": { "type": "array", "items": { "type": "object", "required": ["name"], "properties": { "name": { "type": "string", "pattern": "\\S" }, "url": { "type": "string" } } } }, "license": { "description": "License of the story's content (text and media), as an SPDX identifier or free text.", "type": "string" }, "presentation": { "type": "object", "properties": { "basemap": { "enum": ["standard", "historical", "auto", "none"] } } }, "slides": { "type": "array", "minItems": 1, "items": { "$ref": "#/$defs/slide" } }, "media": { "description": "Every media file in the story, keyed by an id that slides and overlays refer to.", "type": "object", "propertyNames": { "$ref": "#/$defs/id" }, "additionalProperties": { "$ref": "#/$defs/mediaItem" } }, "extensions": { "description": "Producer-specific data, keyed by namespace. Viewers ignore it.", "type": "object", "additionalProperties": { "type": "object" } } }, "$defs": { "id": { "type": "string", "pattern": "^[A-Za-z0-9_-]{1,64}$" }, "storyDate": { "type": "object", "required": ["text"], "properties": { "text": { "description": "The date as it should be shown, in the story's language.", "type": "string", "pattern": "\\S" }, "edtf": { "description": "Optional machine-readable form, in Extended Date/Time Format (ISO 8601-2).", "type": "string", "pattern": "\\S" }, "sortYear": { "description": "Optional year (proleptic Gregorian) that places the slide on the timeline.", "type": "integer" } } }, "slide": { "type": "object", "required": ["id"], "properties": { "id": { "$ref": "#/$defs/id" }, "title": { "type": "string" }, "text": { "description": "Body text. Markup: **bold**, *italic*, line breaks. Nothing else is interpreted.", "type": "string" }, "date": { "$ref": "#/$defs/storyDate" }, "place": { "$ref": "#/$defs/place" }, "media": { "type": "array", "items": { "$ref": "#/$defs/slideMedia" } }, "people": { "type": "array", "items": { "type": "object", "required": ["name"], "properties": { "name": { "type": "string", "pattern": "\\S" }, "role": { "type": "string" } } } } } }, "slideMedia": { "type": "object", "required": ["ref"], "properties": { "ref": { "$ref": "#/$defs/id" }, "caption": { "type": "string" }, "credit": { "type": "string" } } }, "place": { "type": "object", "properties": { "name": { "type": "string" }, "lat": { "type": "number", "minimum": -90, "maximum": 90 }, "lon": { "type": "number", "minimum": -180, "maximum": 180 }, "geometry": { "description": "Optional GeoJSON (RFC 7946) object drawn under the slide's pin: a FeatureCollection, Feature, or bare geometry.", "type": "object", "required": ["type"], "properties": { "type": { "type": "string" } }, "additionalProperties": true }, "overlays": { "type": "array", "items": { "$ref": "#/$defs/overlay" } } }, "dependentRequired": { "lat": ["lon"], "lon": ["lat"] } }, "lonLat": { "type": "array", "prefixItems": [{ "type": "number", "minimum": -180, "maximum": 180 }, { "type": "number", "minimum": -90, "maximum": 90 }], "minItems": 2, "maxItems": 2 }, "overlay": { "type": "object", "required": ["media", "corners"], "properties": { "media": { "$ref": "#/$defs/id" }, "corners": { "description": "[lon, lat] of the image's top-left, top-right, bottom-right and bottom-left corners.", "type": "array", "items": { "$ref": "#/$defs/lonLat" }, "minItems": 4, "maxItems": 4 }, "opacity": { "type": "number", "minimum": 0, "maximum": 1 }, "order": { "description": "Stacking order among a slide's overlays; lower is drawn first.", "type": "integer" }, "date": { "$ref": "#/$defs/storyDate" } } }, "mediaItem": { "type": "object", "required": ["src", "mime"], "properties": { "src": { "description": 'Path of the file inside the zip, relative to its root. No leading slash, no ".." segments.', "type": "string", "pattern": "^(?!/)(?!.*(^|/)\\.\\.?(/|$))[^\\\\]+$" }, "mime": { "type": "string", "pattern": "^[a-z]+/[A-Za-z0-9.+-]+$" }, "width": { "type": "integer", "minimum": 1 }, "height": { "type": "integer", "minimum": 1 }, "alt": { "type": "string" } } } } };
+var pattern4 = new RegExp("^1\\.(0|[1-9][0-9]*)$", "u");
+var pattern5 = new RegExp("\\S", "u");
+var pattern6 = new RegExp("^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$", "u");
+var pattern7 = new RegExp("^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$", "u");
+var pattern10 = new RegExp("^[A-Za-z0-9_-]{1,64}$", "u");
+var pattern19 = new RegExp("^(?!/)(?!.*(^|/)\\.\\.?(/|$))[^\\\\]+$", "u");
+var pattern20 = new RegExp("^[a-z]+/[A-Za-z0-9.+-]+$", "u");
+function validate23(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate23.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.media === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "media" }, message: "must have required property 'media'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.corners === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "corners" }, message: "must have required property 'corners'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.media !== void 0) {
+      let data0 = data.media;
+      if (typeof data0 === "string") {
+        if (!pattern10.test(data0)) {
+          const err2 = { instancePath: instancePath + "/media", schemaPath: "#/$defs/id/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]{1,64}$" }, message: 'must match pattern "^[A-Za-z0-9_-]{1,64}$"' };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+      } else {
+        const err3 = { instancePath: instancePath + "/media", schemaPath: "#/$defs/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.corners !== void 0) {
+      let data1 = data.corners;
+      if (Array.isArray(data1)) {
+        if (data1.length > 4) {
+          const err4 = { instancePath: instancePath + "/corners", schemaPath: "#/properties/corners/maxItems", keyword: "maxItems", params: { limit: 4 }, message: "must NOT have more than 4 items" };
+          if (vErrors === null) {
+            vErrors = [err4];
+          } else {
+            vErrors.push(err4);
+          }
+          errors++;
+        }
+        if (data1.length < 4) {
+          const err5 = { instancePath: instancePath + "/corners", schemaPath: "#/properties/corners/minItems", keyword: "minItems", params: { limit: 4 }, message: "must NOT have fewer than 4 items" };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+        const len0 = data1.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          let data2 = data1[i0];
+          if (Array.isArray(data2)) {
+            if (data2.length > 2) {
+              const err6 = { instancePath: instancePath + "/corners/" + i0, schemaPath: "#/$defs/lonLat/maxItems", keyword: "maxItems", params: { limit: 2 }, message: "must NOT have more than 2 items" };
+              if (vErrors === null) {
+                vErrors = [err6];
+              } else {
+                vErrors.push(err6);
+              }
+              errors++;
+            }
+            if (data2.length < 2) {
+              const err7 = { instancePath: instancePath + "/corners/" + i0, schemaPath: "#/$defs/lonLat/minItems", keyword: "minItems", params: { limit: 2 }, message: "must NOT have fewer than 2 items" };
+              if (vErrors === null) {
+                vErrors = [err7];
+              } else {
+                vErrors.push(err7);
+              }
+              errors++;
+            }
+            const len1 = data2.length;
+            if (len1 > 0) {
+              let data3 = data2[0];
+              if (typeof data3 == "number" && isFinite(data3)) {
+                if (data3 > 180 || isNaN(data3)) {
+                  const err8 = { instancePath: instancePath + "/corners/" + i0 + "/0", schemaPath: "#/$defs/lonLat/prefixItems/0/maximum", keyword: "maximum", params: { comparison: "<=", limit: 180 }, message: "must be <= 180" };
+                  if (vErrors === null) {
+                    vErrors = [err8];
+                  } else {
+                    vErrors.push(err8);
+                  }
+                  errors++;
+                }
+                if (data3 < -180 || isNaN(data3)) {
+                  const err9 = { instancePath: instancePath + "/corners/" + i0 + "/0", schemaPath: "#/$defs/lonLat/prefixItems/0/minimum", keyword: "minimum", params: { comparison: ">=", limit: -180 }, message: "must be >= -180" };
+                  if (vErrors === null) {
+                    vErrors = [err9];
+                  } else {
+                    vErrors.push(err9);
+                  }
+                  errors++;
+                }
+              } else {
+                const err10 = { instancePath: instancePath + "/corners/" + i0 + "/0", schemaPath: "#/$defs/lonLat/prefixItems/0/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                  vErrors = [err10];
+                } else {
+                  vErrors.push(err10);
+                }
+                errors++;
+              }
+            }
+            if (len1 > 1) {
+              let data4 = data2[1];
+              if (typeof data4 == "number" && isFinite(data4)) {
+                if (data4 > 90 || isNaN(data4)) {
+                  const err11 = { instancePath: instancePath + "/corners/" + i0 + "/1", schemaPath: "#/$defs/lonLat/prefixItems/1/maximum", keyword: "maximum", params: { comparison: "<=", limit: 90 }, message: "must be <= 90" };
+                  if (vErrors === null) {
+                    vErrors = [err11];
+                  } else {
+                    vErrors.push(err11);
+                  }
+                  errors++;
+                }
+                if (data4 < -90 || isNaN(data4)) {
+                  const err12 = { instancePath: instancePath + "/corners/" + i0 + "/1", schemaPath: "#/$defs/lonLat/prefixItems/1/minimum", keyword: "minimum", params: { comparison: ">=", limit: -90 }, message: "must be >= -90" };
+                  if (vErrors === null) {
+                    vErrors = [err12];
+                  } else {
+                    vErrors.push(err12);
+                  }
+                  errors++;
+                }
+              } else {
+                const err13 = { instancePath: instancePath + "/corners/" + i0 + "/1", schemaPath: "#/$defs/lonLat/prefixItems/1/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+                if (vErrors === null) {
+                  vErrors = [err13];
+                } else {
+                  vErrors.push(err13);
+                }
+                errors++;
+              }
+            }
+          } else {
+            const err14 = { instancePath: instancePath + "/corners/" + i0, schemaPath: "#/$defs/lonLat/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+            if (vErrors === null) {
+              vErrors = [err14];
+            } else {
+              vErrors.push(err14);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err15 = { instancePath: instancePath + "/corners", schemaPath: "#/properties/corners/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err15];
+        } else {
+          vErrors.push(err15);
+        }
+        errors++;
+      }
+    }
+    if (data.opacity !== void 0) {
+      let data5 = data.opacity;
+      if (typeof data5 == "number" && isFinite(data5)) {
+        if (data5 > 1 || isNaN(data5)) {
+          const err16 = { instancePath: instancePath + "/opacity", schemaPath: "#/properties/opacity/maximum", keyword: "maximum", params: { comparison: "<=", limit: 1 }, message: "must be <= 1" };
+          if (vErrors === null) {
+            vErrors = [err16];
+          } else {
+            vErrors.push(err16);
+          }
+          errors++;
+        }
+        if (data5 < 0 || isNaN(data5)) {
+          const err17 = { instancePath: instancePath + "/opacity", schemaPath: "#/properties/opacity/minimum", keyword: "minimum", params: { comparison: ">=", limit: 0 }, message: "must be >= 0" };
+          if (vErrors === null) {
+            vErrors = [err17];
+          } else {
+            vErrors.push(err17);
+          }
+          errors++;
+        }
+      } else {
+        const err18 = { instancePath: instancePath + "/opacity", schemaPath: "#/properties/opacity/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+    if (data.order !== void 0) {
+      let data6 = data.order;
+      if (!(typeof data6 == "number" && (!(data6 % 1) && !isNaN(data6)) && isFinite(data6))) {
+        const err19 = { instancePath: instancePath + "/order", schemaPath: "#/properties/order/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+        if (vErrors === null) {
+          vErrors = [err19];
+        } else {
+          vErrors.push(err19);
+        }
+        errors++;
+      }
+    }
+    if (data.date !== void 0) {
+      let data7 = data.date;
+      if (data7 && typeof data7 == "object" && !Array.isArray(data7)) {
+        if (data7.text === void 0) {
+          const err20 = { instancePath: instancePath + "/date", schemaPath: "#/$defs/storyDate/required", keyword: "required", params: { missingProperty: "text" }, message: "must have required property 'text'" };
+          if (vErrors === null) {
+            vErrors = [err20];
+          } else {
+            vErrors.push(err20);
+          }
+          errors++;
+        }
+        if (data7.text !== void 0) {
+          let data8 = data7.text;
+          if (typeof data8 === "string") {
+            if (!pattern5.test(data8)) {
+              const err21 = { instancePath: instancePath + "/date/text", schemaPath: "#/$defs/storyDate/properties/text/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+              if (vErrors === null) {
+                vErrors = [err21];
+              } else {
+                vErrors.push(err21);
+              }
+              errors++;
+            }
+          } else {
+            const err22 = { instancePath: instancePath + "/date/text", schemaPath: "#/$defs/storyDate/properties/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err22];
+            } else {
+              vErrors.push(err22);
+            }
+            errors++;
+          }
+        }
+        if (data7.edtf !== void 0) {
+          let data9 = data7.edtf;
+          if (typeof data9 === "string") {
+            if (!pattern5.test(data9)) {
+              const err23 = { instancePath: instancePath + "/date/edtf", schemaPath: "#/$defs/storyDate/properties/edtf/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+              if (vErrors === null) {
+                vErrors = [err23];
+              } else {
+                vErrors.push(err23);
+              }
+              errors++;
+            }
+          } else {
+            const err24 = { instancePath: instancePath + "/date/edtf", schemaPath: "#/$defs/storyDate/properties/edtf/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err24];
+            } else {
+              vErrors.push(err24);
+            }
+            errors++;
+          }
+        }
+        if (data7.sortYear !== void 0) {
+          let data10 = data7.sortYear;
+          if (!(typeof data10 == "number" && (!(data10 % 1) && !isNaN(data10)) && isFinite(data10))) {
+            const err25 = { instancePath: instancePath + "/date/sortYear", schemaPath: "#/$defs/storyDate/properties/sortYear/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+              vErrors = [err25];
+            } else {
+              vErrors.push(err25);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err26 = { instancePath: instancePath + "/date", schemaPath: "#/$defs/storyDate/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err26];
+        } else {
+          vErrors.push(err26);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err27 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err27];
+    } else {
+      vErrors.push(err27);
+    }
+    errors++;
+  }
+  validate23.errors = vErrors;
+  return errors === 0;
+}
+validate23.evaluated = { "props": { "media": true, "corners": true, "opacity": true, "order": true, "date": true }, "dynamicProps": false, "dynamicItems": false };
+function validate22(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate22.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.name !== void 0) {
+      if (typeof data.name !== "string") {
+        const err0 = { instancePath: instancePath + "/name", schemaPath: "#/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err0];
+        } else {
+          vErrors.push(err0);
+        }
+        errors++;
+      }
+    }
+    if (data.lat !== void 0) {
+      let data1 = data.lat;
+      if (typeof data1 == "number" && isFinite(data1)) {
+        if (data1 > 90 || isNaN(data1)) {
+          const err1 = { instancePath: instancePath + "/lat", schemaPath: "#/properties/lat/maximum", keyword: "maximum", params: { comparison: "<=", limit: 90 }, message: "must be <= 90" };
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+        if (data1 < -90 || isNaN(data1)) {
+          const err2 = { instancePath: instancePath + "/lat", schemaPath: "#/properties/lat/minimum", keyword: "minimum", params: { comparison: ">=", limit: -90 }, message: "must be >= -90" };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+      } else {
+        const err3 = { instancePath: instancePath + "/lat", schemaPath: "#/properties/lat/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.lon !== void 0) {
+      let data2 = data.lon;
+      if (typeof data2 == "number" && isFinite(data2)) {
+        if (data2 > 180 || isNaN(data2)) {
+          const err4 = { instancePath: instancePath + "/lon", schemaPath: "#/properties/lon/maximum", keyword: "maximum", params: { comparison: "<=", limit: 180 }, message: "must be <= 180" };
+          if (vErrors === null) {
+            vErrors = [err4];
+          } else {
+            vErrors.push(err4);
+          }
+          errors++;
+        }
+        if (data2 < -180 || isNaN(data2)) {
+          const err5 = { instancePath: instancePath + "/lon", schemaPath: "#/properties/lon/minimum", keyword: "minimum", params: { comparison: ">=", limit: -180 }, message: "must be >= -180" };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+      } else {
+        const err6 = { instancePath: instancePath + "/lon", schemaPath: "#/properties/lon/type", keyword: "type", params: { type: "number" }, message: "must be number" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.geometry !== void 0) {
+      let data3 = data.geometry;
+      if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+        if (data3.type === void 0) {
+          const err7 = { instancePath: instancePath + "/geometry", schemaPath: "#/properties/geometry/required", keyword: "required", params: { missingProperty: "type" }, message: "must have required property 'type'" };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+        if (data3.type !== void 0) {
+          if (typeof data3.type !== "string") {
+            const err8 = { instancePath: instancePath + "/geometry/type", schemaPath: "#/properties/geometry/properties/type/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err8];
+            } else {
+              vErrors.push(err8);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err9 = { instancePath: instancePath + "/geometry", schemaPath: "#/properties/geometry/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err9];
+        } else {
+          vErrors.push(err9);
+        }
+        errors++;
+      }
+    }
+    if (data.overlays !== void 0) {
+      let data5 = data.overlays;
+      if (Array.isArray(data5)) {
+        const len0 = data5.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          if (!validate23(data5[i0], { instancePath: instancePath + "/overlays/" + i0, parentData: data5, parentDataProperty: i0, rootData, dynamicAnchors })) {
+            vErrors = vErrors === null ? validate23.errors : vErrors.concat(validate23.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err10 = { instancePath: instancePath + "/overlays", schemaPath: "#/properties/overlays/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.lat !== void 0) {
+      if (data.lon === void 0) {
+        const err11 = { instancePath, schemaPath: "#/dependentRequired", keyword: "dependentRequired", params: {
+          property: "lat",
+          missingProperty: "lon",
+          depsCount: 1,
+          deps: "lon"
+        }, message: "must have property lon when property lat is present" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.lon !== void 0) {
+      if (data.lat === void 0) {
+        const err12 = { instancePath, schemaPath: "#/dependentRequired", keyword: "dependentRequired", params: {
+          property: "lon",
+          missingProperty: "lat",
+          depsCount: 1,
+          deps: "lat"
+        }, message: "must have property lat when property lon is present" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err13 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err13];
+    } else {
+      vErrors.push(err13);
+    }
+    errors++;
+  }
+  validate22.errors = vErrors;
+  return errors === 0;
+}
+validate22.evaluated = { "props": { "name": true, "lat": true, "lon": true, "geometry": true, "overlays": true }, "dynamicProps": false, "dynamicItems": false };
+function validate26(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate26.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.ref === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "ref" }, message: "must have required property 'ref'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.ref !== void 0) {
+      let data0 = data.ref;
+      if (typeof data0 === "string") {
+        if (!pattern10.test(data0)) {
+          const err1 = { instancePath: instancePath + "/ref", schemaPath: "#/$defs/id/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]{1,64}$" }, message: 'must match pattern "^[A-Za-z0-9_-]{1,64}$"' };
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+      } else {
+        const err2 = { instancePath: instancePath + "/ref", schemaPath: "#/$defs/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.caption !== void 0) {
+      if (typeof data.caption !== "string") {
+        const err3 = { instancePath: instancePath + "/caption", schemaPath: "#/properties/caption/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.credit !== void 0) {
+      if (typeof data.credit !== "string") {
+        const err4 = { instancePath: instancePath + "/credit", schemaPath: "#/properties/credit/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err5 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err5];
+    } else {
+      vErrors.push(err5);
+    }
+    errors++;
+  }
+  validate26.errors = vErrors;
+  return errors === 0;
+}
+validate26.evaluated = { "props": { "ref": true, "caption": true, "credit": true }, "dynamicProps": false, "dynamicItems": false };
+function validate21(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate21.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.id === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "id" }, message: "must have required property 'id'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.id !== void 0) {
+      let data0 = data.id;
+      if (typeof data0 === "string") {
+        if (!pattern10.test(data0)) {
+          const err1 = { instancePath: instancePath + "/id", schemaPath: "#/$defs/id/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]{1,64}$" }, message: 'must match pattern "^[A-Za-z0-9_-]{1,64}$"' };
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+      } else {
+        const err2 = { instancePath: instancePath + "/id", schemaPath: "#/$defs/id/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err2];
+        } else {
+          vErrors.push(err2);
+        }
+        errors++;
+      }
+    }
+    if (data.title !== void 0) {
+      if (typeof data.title !== "string") {
+        const err3 = { instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err3];
+        } else {
+          vErrors.push(err3);
+        }
+        errors++;
+      }
+    }
+    if (data.text !== void 0) {
+      if (typeof data.text !== "string") {
+        const err4 = { instancePath: instancePath + "/text", schemaPath: "#/properties/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err4];
+        } else {
+          vErrors.push(err4);
+        }
+        errors++;
+      }
+    }
+    if (data.date !== void 0) {
+      let data3 = data.date;
+      if (data3 && typeof data3 == "object" && !Array.isArray(data3)) {
+        if (data3.text === void 0) {
+          const err5 = { instancePath: instancePath + "/date", schemaPath: "#/$defs/storyDate/required", keyword: "required", params: { missingProperty: "text" }, message: "must have required property 'text'" };
+          if (vErrors === null) {
+            vErrors = [err5];
+          } else {
+            vErrors.push(err5);
+          }
+          errors++;
+        }
+        if (data3.text !== void 0) {
+          let data4 = data3.text;
+          if (typeof data4 === "string") {
+            if (!pattern5.test(data4)) {
+              const err6 = { instancePath: instancePath + "/date/text", schemaPath: "#/$defs/storyDate/properties/text/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+              if (vErrors === null) {
+                vErrors = [err6];
+              } else {
+                vErrors.push(err6);
+              }
+              errors++;
+            }
+          } else {
+            const err7 = { instancePath: instancePath + "/date/text", schemaPath: "#/$defs/storyDate/properties/text/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err7];
+            } else {
+              vErrors.push(err7);
+            }
+            errors++;
+          }
+        }
+        if (data3.edtf !== void 0) {
+          let data5 = data3.edtf;
+          if (typeof data5 === "string") {
+            if (!pattern5.test(data5)) {
+              const err8 = { instancePath: instancePath + "/date/edtf", schemaPath: "#/$defs/storyDate/properties/edtf/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+              if (vErrors === null) {
+                vErrors = [err8];
+              } else {
+                vErrors.push(err8);
+              }
+              errors++;
+            }
+          } else {
+            const err9 = { instancePath: instancePath + "/date/edtf", schemaPath: "#/$defs/storyDate/properties/edtf/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err9];
+            } else {
+              vErrors.push(err9);
+            }
+            errors++;
+          }
+        }
+        if (data3.sortYear !== void 0) {
+          let data6 = data3.sortYear;
+          if (!(typeof data6 == "number" && (!(data6 % 1) && !isNaN(data6)) && isFinite(data6))) {
+            const err10 = { instancePath: instancePath + "/date/sortYear", schemaPath: "#/$defs/storyDate/properties/sortYear/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+            if (vErrors === null) {
+              vErrors = [err10];
+            } else {
+              vErrors.push(err10);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err11 = { instancePath: instancePath + "/date", schemaPath: "#/$defs/storyDate/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err11];
+        } else {
+          vErrors.push(err11);
+        }
+        errors++;
+      }
+    }
+    if (data.place !== void 0) {
+      if (!validate22(data.place, { instancePath: instancePath + "/place", parentData: data, parentDataProperty: "place", rootData, dynamicAnchors })) {
+        vErrors = vErrors === null ? validate22.errors : vErrors.concat(validate22.errors);
+        errors = vErrors.length;
+      }
+    }
+    if (data.media !== void 0) {
+      let data8 = data.media;
+      if (Array.isArray(data8)) {
+        const len0 = data8.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          if (!validate26(data8[i0], { instancePath: instancePath + "/media/" + i0, parentData: data8, parentDataProperty: i0, rootData, dynamicAnchors })) {
+            vErrors = vErrors === null ? validate26.errors : vErrors.concat(validate26.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err12 = { instancePath: instancePath + "/media", schemaPath: "#/properties/media/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.people !== void 0) {
+      let data10 = data.people;
+      if (Array.isArray(data10)) {
+        const len1 = data10.length;
+        for (let i1 = 0; i1 < len1; i1++) {
+          let data11 = data10[i1];
+          if (data11 && typeof data11 == "object" && !Array.isArray(data11)) {
+            if (data11.name === void 0) {
+              const err13 = { instancePath: instancePath + "/people/" + i1, schemaPath: "#/properties/people/items/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
+              if (vErrors === null) {
+                vErrors = [err13];
+              } else {
+                vErrors.push(err13);
+              }
+              errors++;
+            }
+            if (data11.name !== void 0) {
+              let data12 = data11.name;
+              if (typeof data12 === "string") {
+                if (!pattern5.test(data12)) {
+                  const err14 = { instancePath: instancePath + "/people/" + i1 + "/name", schemaPath: "#/properties/people/items/properties/name/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+                  if (vErrors === null) {
+                    vErrors = [err14];
+                  } else {
+                    vErrors.push(err14);
+                  }
+                  errors++;
+                }
+              } else {
+                const err15 = { instancePath: instancePath + "/people/" + i1 + "/name", schemaPath: "#/properties/people/items/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err15];
+                } else {
+                  vErrors.push(err15);
+                }
+                errors++;
+              }
+            }
+            if (data11.role !== void 0) {
+              if (typeof data11.role !== "string") {
+                const err16 = { instancePath: instancePath + "/people/" + i1 + "/role", schemaPath: "#/properties/people/items/properties/role/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err16];
+                } else {
+                  vErrors.push(err16);
+                }
+                errors++;
+              }
+            }
+          } else {
+            const err17 = { instancePath: instancePath + "/people/" + i1, schemaPath: "#/properties/people/items/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+              vErrors = [err17];
+            } else {
+              vErrors.push(err17);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err18 = { instancePath: instancePath + "/people", schemaPath: "#/properties/people/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err18];
+        } else {
+          vErrors.push(err18);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err19 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err19];
+    } else {
+      vErrors.push(err19);
+    }
+    errors++;
+  }
+  validate21.errors = vErrors;
+  return errors === 0;
+}
+validate21.evaluated = { "props": { "id": true, "title": true, "text": true, "date": true, "place": true, "media": true, "people": true }, "dynamicProps": false, "dynamicItems": false };
+function validate20(data, { instancePath = "", parentData, parentDataProperty, rootData = data, dynamicAnchors = {} } = {}) {
+  ;
+  let vErrors = null;
+  let errors = 0;
+  const evaluated0 = validate20.evaluated;
+  if (evaluated0.dynamicProps) {
+    evaluated0.props = void 0;
+  }
+  if (evaluated0.dynamicItems) {
+    evaluated0.items = void 0;
+  }
+  if (data && typeof data == "object" && !Array.isArray(data)) {
+    if (data.format === void 0) {
+      const err0 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "format" }, message: "must have required property 'format'" };
+      if (vErrors === null) {
+        vErrors = [err0];
+      } else {
+        vErrors.push(err0);
+      }
+      errors++;
+    }
+    if (data.version === void 0) {
+      const err1 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "version" }, message: "must have required property 'version'" };
+      if (vErrors === null) {
+        vErrors = [err1];
+      } else {
+        vErrors.push(err1);
+      }
+      errors++;
+    }
+    if (data.title === void 0) {
+      const err2 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "title" }, message: "must have required property 'title'" };
+      if (vErrors === null) {
+        vErrors = [err2];
+      } else {
+        vErrors.push(err2);
+      }
+      errors++;
+    }
+    if (data.slides === void 0) {
+      const err3 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "slides" }, message: "must have required property 'slides'" };
+      if (vErrors === null) {
+        vErrors = [err3];
+      } else {
+        vErrors.push(err3);
+      }
+      errors++;
+    }
+    if (data.media === void 0) {
+      const err4 = { instancePath, schemaPath: "#/required", keyword: "required", params: { missingProperty: "media" }, message: "must have required property 'media'" };
+      if (vErrors === null) {
+        vErrors = [err4];
+      } else {
+        vErrors.push(err4);
+      }
+      errors++;
+    }
+    if (data.$schema !== void 0) {
+      if (typeof data.$schema !== "string") {
+        const err5 = { instancePath: instancePath + "/$schema", schemaPath: "#/properties/%24schema/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err5];
+        } else {
+          vErrors.push(err5);
+        }
+        errors++;
+      }
+    }
+    if (data.format !== void 0) {
+      if ("gramps-connect-story" !== data.format) {
+        const err6 = { instancePath: instancePath + "/format", schemaPath: "#/properties/format/const", keyword: "const", params: { allowedValue: "gramps-connect-story" }, message: "must be equal to constant" };
+        if (vErrors === null) {
+          vErrors = [err6];
+        } else {
+          vErrors.push(err6);
+        }
+        errors++;
+      }
+    }
+    if (data.version !== void 0) {
+      let data2 = data.version;
+      if (typeof data2 === "string") {
+        if (!pattern4.test(data2)) {
+          const err7 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/pattern", keyword: "pattern", params: { pattern: "^1\\.(0|[1-9][0-9]*)$" }, message: 'must match pattern "^1\\.(0|[1-9][0-9]*)$"' };
+          if (vErrors === null) {
+            vErrors = [err7];
+          } else {
+            vErrors.push(err7);
+          }
+          errors++;
+        }
+      } else {
+        const err8 = { instancePath: instancePath + "/version", schemaPath: "#/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+    if (data.title !== void 0) {
+      let data3 = data.title;
+      if (typeof data3 === "string") {
+        if (!pattern5.test(data3)) {
+          const err9 = { instancePath: instancePath + "/title", schemaPath: "#/properties/title/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+          if (vErrors === null) {
+            vErrors = [err9];
+          } else {
+            vErrors.push(err9);
+          }
+          errors++;
+        }
+      } else {
+        const err10 = { instancePath: instancePath + "/title", schemaPath: "#/properties/title/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err10];
+        } else {
+          vErrors.push(err10);
+        }
+        errors++;
+      }
+    }
+    if (data.language !== void 0) {
+      let data4 = data.language;
+      if (typeof data4 === "string") {
+        if (!pattern6.test(data4)) {
+          const err11 = { instancePath: instancePath + "/language", schemaPath: "#/properties/language/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$" }, message: 'must match pattern "^[A-Za-z]{2,8}(-[A-Za-z0-9]{1,8})*$"' };
+          if (vErrors === null) {
+            vErrors = [err11];
+          } else {
+            vErrors.push(err11);
+          }
+          errors++;
+        }
+      } else {
+        const err12 = { instancePath: instancePath + "/language", schemaPath: "#/properties/language/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err12];
+        } else {
+          vErrors.push(err12);
+        }
+        errors++;
+      }
+    }
+    if (data.created !== void 0) {
+      let data5 = data.created;
+      if (typeof data5 === "string") {
+        if (!pattern7.test(data5)) {
+          const err13 = { instancePath: instancePath + "/created", schemaPath: "#/properties/created/pattern", keyword: "pattern", params: { pattern: "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$" }, message: 'must match pattern "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})$"' };
+          if (vErrors === null) {
+            vErrors = [err13];
+          } else {
+            vErrors.push(err13);
+          }
+          errors++;
+        }
+      } else {
+        const err14 = { instancePath: instancePath + "/created", schemaPath: "#/properties/created/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err14];
+        } else {
+          vErrors.push(err14);
+        }
+        errors++;
+      }
+    }
+    if (data.generator !== void 0) {
+      let data6 = data.generator;
+      if (data6 && typeof data6 == "object" && !Array.isArray(data6)) {
+        if (data6.name === void 0) {
+          const err15 = { instancePath: instancePath + "/generator", schemaPath: "#/properties/generator/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
+          if (vErrors === null) {
+            vErrors = [err15];
+          } else {
+            vErrors.push(err15);
+          }
+          errors++;
+        }
+        if (data6.name !== void 0) {
+          let data7 = data6.name;
+          if (typeof data7 === "string") {
+            if (!pattern5.test(data7)) {
+              const err16 = { instancePath: instancePath + "/generator/name", schemaPath: "#/properties/generator/properties/name/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+              if (vErrors === null) {
+                vErrors = [err16];
+              } else {
+                vErrors.push(err16);
+              }
+              errors++;
+            }
+          } else {
+            const err17 = { instancePath: instancePath + "/generator/name", schemaPath: "#/properties/generator/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err17];
+            } else {
+              vErrors.push(err17);
+            }
+            errors++;
+          }
+        }
+        if (data6.version !== void 0) {
+          if (typeof data6.version !== "string") {
+            const err18 = { instancePath: instancePath + "/generator/version", schemaPath: "#/properties/generator/properties/version/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err18];
+            } else {
+              vErrors.push(err18);
+            }
+            errors++;
+          }
+        }
+        if (data6.url !== void 0) {
+          if (typeof data6.url !== "string") {
+            const err19 = { instancePath: instancePath + "/generator/url", schemaPath: "#/properties/generator/properties/url/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+            if (vErrors === null) {
+              vErrors = [err19];
+            } else {
+              vErrors.push(err19);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err20 = { instancePath: instancePath + "/generator", schemaPath: "#/properties/generator/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err20];
+        } else {
+          vErrors.push(err20);
+        }
+        errors++;
+      }
+    }
+    if (data.authors !== void 0) {
+      let data10 = data.authors;
+      if (Array.isArray(data10)) {
+        const len0 = data10.length;
+        for (let i0 = 0; i0 < len0; i0++) {
+          let data11 = data10[i0];
+          if (data11 && typeof data11 == "object" && !Array.isArray(data11)) {
+            if (data11.name === void 0) {
+              const err21 = { instancePath: instancePath + "/authors/" + i0, schemaPath: "#/properties/authors/items/required", keyword: "required", params: { missingProperty: "name" }, message: "must have required property 'name'" };
+              if (vErrors === null) {
+                vErrors = [err21];
+              } else {
+                vErrors.push(err21);
+              }
+              errors++;
+            }
+            if (data11.name !== void 0) {
+              let data12 = data11.name;
+              if (typeof data12 === "string") {
+                if (!pattern5.test(data12)) {
+                  const err22 = { instancePath: instancePath + "/authors/" + i0 + "/name", schemaPath: "#/properties/authors/items/properties/name/pattern", keyword: "pattern", params: { pattern: "\\S" }, message: 'must match pattern "\\S"' };
+                  if (vErrors === null) {
+                    vErrors = [err22];
+                  } else {
+                    vErrors.push(err22);
+                  }
+                  errors++;
+                }
+              } else {
+                const err23 = { instancePath: instancePath + "/authors/" + i0 + "/name", schemaPath: "#/properties/authors/items/properties/name/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err23];
+                } else {
+                  vErrors.push(err23);
+                }
+                errors++;
+              }
+            }
+            if (data11.url !== void 0) {
+              if (typeof data11.url !== "string") {
+                const err24 = { instancePath: instancePath + "/authors/" + i0 + "/url", schemaPath: "#/properties/authors/items/properties/url/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err24];
+                } else {
+                  vErrors.push(err24);
+                }
+                errors++;
+              }
+            }
+          } else {
+            const err25 = { instancePath: instancePath + "/authors/" + i0, schemaPath: "#/properties/authors/items/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+              vErrors = [err25];
+            } else {
+              vErrors.push(err25);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err26 = { instancePath: instancePath + "/authors", schemaPath: "#/properties/authors/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err26];
+        } else {
+          vErrors.push(err26);
+        }
+        errors++;
+      }
+    }
+    if (data.license !== void 0) {
+      if (typeof data.license !== "string") {
+        const err27 = { instancePath: instancePath + "/license", schemaPath: "#/properties/license/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+        if (vErrors === null) {
+          vErrors = [err27];
+        } else {
+          vErrors.push(err27);
+        }
+        errors++;
+      }
+    }
+    if (data.presentation !== void 0) {
+      let data15 = data.presentation;
+      if (data15 && typeof data15 == "object" && !Array.isArray(data15)) {
+        if (data15.basemap !== void 0) {
+          let data16 = data15.basemap;
+          if (!(data16 === "standard" || data16 === "historical" || data16 === "auto" || data16 === "none")) {
+            const err28 = { instancePath: instancePath + "/presentation/basemap", schemaPath: "#/properties/presentation/properties/basemap/enum", keyword: "enum", params: { allowedValues: schema31.properties.presentation.properties.basemap.enum }, message: "must be equal to one of the allowed values" };
+            if (vErrors === null) {
+              vErrors = [err28];
+            } else {
+              vErrors.push(err28);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err29 = { instancePath: instancePath + "/presentation", schemaPath: "#/properties/presentation/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err29];
+        } else {
+          vErrors.push(err29);
+        }
+        errors++;
+      }
+    }
+    if (data.slides !== void 0) {
+      let data17 = data.slides;
+      if (Array.isArray(data17)) {
+        if (data17.length < 1) {
+          const err30 = { instancePath: instancePath + "/slides", schemaPath: "#/properties/slides/minItems", keyword: "minItems", params: { limit: 1 }, message: "must NOT have fewer than 1 items" };
+          if (vErrors === null) {
+            vErrors = [err30];
+          } else {
+            vErrors.push(err30);
+          }
+          errors++;
+        }
+        const len1 = data17.length;
+        for (let i1 = 0; i1 < len1; i1++) {
+          if (!validate21(data17[i1], { instancePath: instancePath + "/slides/" + i1, parentData: data17, parentDataProperty: i1, rootData, dynamicAnchors })) {
+            vErrors = vErrors === null ? validate21.errors : vErrors.concat(validate21.errors);
+            errors = vErrors.length;
+          }
+        }
+      } else {
+        const err31 = { instancePath: instancePath + "/slides", schemaPath: "#/properties/slides/type", keyword: "type", params: { type: "array" }, message: "must be array" };
+        if (vErrors === null) {
+          vErrors = [err31];
+        } else {
+          vErrors.push(err31);
+        }
+        errors++;
+      }
+    }
+    if (data.media !== void 0) {
+      let data19 = data.media;
+      if (data19 && typeof data19 == "object" && !Array.isArray(data19)) {
+        for (const key0 in data19) {
+          const _errs38 = errors;
+          if (typeof key0 === "string") {
+            if (!pattern10.test(key0)) {
+              const err32 = { instancePath: instancePath + "/media", schemaPath: "#/$defs/id/pattern", keyword: "pattern", params: { pattern: "^[A-Za-z0-9_-]{1,64}$" }, message: 'must match pattern "^[A-Za-z0-9_-]{1,64}$"', propertyName: key0 };
+              if (vErrors === null) {
+                vErrors = [err32];
+              } else {
+                vErrors.push(err32);
+              }
+              errors++;
+            }
+          } else {
+            const err33 = { instancePath: instancePath + "/media", schemaPath: "#/$defs/id/type", keyword: "type", params: { type: "string" }, message: "must be string", propertyName: key0 };
+            if (vErrors === null) {
+              vErrors = [err33];
+            } else {
+              vErrors.push(err33);
+            }
+            errors++;
+          }
+          var valid8 = _errs38 === errors;
+          if (!valid8) {
+            const err34 = { instancePath: instancePath + "/media", schemaPath: "#/properties/media/propertyNames", keyword: "propertyNames", params: { propertyName: key0 }, message: "property name must be valid" };
+            if (vErrors === null) {
+              vErrors = [err34];
+            } else {
+              vErrors.push(err34);
+            }
+            errors++;
+          }
+        }
+        for (const key1 in data19) {
+          let data20 = data19[key1];
+          if (data20 && typeof data20 == "object" && !Array.isArray(data20)) {
+            if (data20.src === void 0) {
+              const err35 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/mediaItem/required", keyword: "required", params: { missingProperty: "src" }, message: "must have required property 'src'" };
+              if (vErrors === null) {
+                vErrors = [err35];
+              } else {
+                vErrors.push(err35);
+              }
+              errors++;
+            }
+            if (data20.mime === void 0) {
+              const err36 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/mediaItem/required", keyword: "required", params: { missingProperty: "mime" }, message: "must have required property 'mime'" };
+              if (vErrors === null) {
+                vErrors = [err36];
+              } else {
+                vErrors.push(err36);
+              }
+              errors++;
+            }
+            if (data20.src !== void 0) {
+              let data21 = data20.src;
+              if (typeof data21 === "string") {
+                if (!pattern19.test(data21)) {
+                  const err37 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/src", schemaPath: "#/$defs/mediaItem/properties/src/pattern", keyword: "pattern", params: { pattern: "^(?!/)(?!.*(^|/)\\.\\.?(/|$))[^\\\\]+$" }, message: 'must match pattern "^(?!/)(?!.*(^|/)\\.\\.?(/|$))[^\\\\]+$"' };
+                  if (vErrors === null) {
+                    vErrors = [err37];
+                  } else {
+                    vErrors.push(err37);
+                  }
+                  errors++;
+                }
+              } else {
+                const err38 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/src", schemaPath: "#/$defs/mediaItem/properties/src/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err38];
+                } else {
+                  vErrors.push(err38);
+                }
+                errors++;
+              }
+            }
+            if (data20.mime !== void 0) {
+              let data22 = data20.mime;
+              if (typeof data22 === "string") {
+                if (!pattern20.test(data22)) {
+                  const err39 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/mime", schemaPath: "#/$defs/mediaItem/properties/mime/pattern", keyword: "pattern", params: { pattern: "^[a-z]+/[A-Za-z0-9.+-]+$" }, message: 'must match pattern "^[a-z]+/[A-Za-z0-9.+-]+$"' };
+                  if (vErrors === null) {
+                    vErrors = [err39];
+                  } else {
+                    vErrors.push(err39);
+                  }
+                  errors++;
+                }
+              } else {
+                const err40 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/mime", schemaPath: "#/$defs/mediaItem/properties/mime/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err40];
+                } else {
+                  vErrors.push(err40);
+                }
+                errors++;
+              }
+            }
+            if (data20.width !== void 0) {
+              let data23 = data20.width;
+              if (!(typeof data23 == "number" && (!(data23 % 1) && !isNaN(data23)) && isFinite(data23))) {
+                const err41 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/width", schemaPath: "#/$defs/mediaItem/properties/width/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                  vErrors = [err41];
+                } else {
+                  vErrors.push(err41);
+                }
+                errors++;
+              }
+              if (typeof data23 == "number" && isFinite(data23)) {
+                if (data23 < 1 || isNaN(data23)) {
+                  const err42 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/width", schemaPath: "#/$defs/mediaItem/properties/width/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                  if (vErrors === null) {
+                    vErrors = [err42];
+                  } else {
+                    vErrors.push(err42);
+                  }
+                  errors++;
+                }
+              }
+            }
+            if (data20.height !== void 0) {
+              let data24 = data20.height;
+              if (!(typeof data24 == "number" && (!(data24 % 1) && !isNaN(data24)) && isFinite(data24))) {
+                const err43 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/height", schemaPath: "#/$defs/mediaItem/properties/height/type", keyword: "type", params: { type: "integer" }, message: "must be integer" };
+                if (vErrors === null) {
+                  vErrors = [err43];
+                } else {
+                  vErrors.push(err43);
+                }
+                errors++;
+              }
+              if (typeof data24 == "number" && isFinite(data24)) {
+                if (data24 < 1 || isNaN(data24)) {
+                  const err44 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/height", schemaPath: "#/$defs/mediaItem/properties/height/minimum", keyword: "minimum", params: { comparison: ">=", limit: 1 }, message: "must be >= 1" };
+                  if (vErrors === null) {
+                    vErrors = [err44];
+                  } else {
+                    vErrors.push(err44);
+                  }
+                  errors++;
+                }
+              }
+            }
+            if (data20.alt !== void 0) {
+              if (typeof data20.alt !== "string") {
+                const err45 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1") + "/alt", schemaPath: "#/$defs/mediaItem/properties/alt/type", keyword: "type", params: { type: "string" }, message: "must be string" };
+                if (vErrors === null) {
+                  vErrors = [err45];
+                } else {
+                  vErrors.push(err45);
+                }
+                errors++;
+              }
+            }
+          } else {
+            const err46 = { instancePath: instancePath + "/media/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/$defs/mediaItem/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+              vErrors = [err46];
+            } else {
+              vErrors.push(err46);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err47 = { instancePath: instancePath + "/media", schemaPath: "#/properties/media/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err47];
+        } else {
+          vErrors.push(err47);
+        }
+        errors++;
+      }
+    }
+    if (data.extensions !== void 0) {
+      let data26 = data.extensions;
+      if (data26 && typeof data26 == "object" && !Array.isArray(data26)) {
+        for (const key2 in data26) {
+          let data27 = data26[key2];
+          if (!(data27 && typeof data27 == "object" && !Array.isArray(data27))) {
+            const err48 = { instancePath: instancePath + "/extensions/" + key2.replace(/~/g, "~0").replace(/\//g, "~1"), schemaPath: "#/properties/extensions/additionalProperties/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+            if (vErrors === null) {
+              vErrors = [err48];
+            } else {
+              vErrors.push(err48);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err49 = { instancePath: instancePath + "/extensions", schemaPath: "#/properties/extensions/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+        if (vErrors === null) {
+          vErrors = [err49];
+        } else {
+          vErrors.push(err49);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err50 = { instancePath, schemaPath: "#/type", keyword: "type", params: { type: "object" }, message: "must be object" };
+    if (vErrors === null) {
+      vErrors = [err50];
+    } else {
+      vErrors.push(err50);
+    }
+    errors++;
+  }
+  validate20.errors = vErrors;
+  return errors === 0;
+}
+validate20.evaluated = { "props": { "$schema": true, "format": true, "version": true, "title": true, "language": true, "created": true, "generator": true, "authors": true, "license": true, "presentation": true, "slides": true, "media": true, "extensions": true }, "dynamicProps": false, "dynamicItems": false };
+
+// src/version.ts
+var FORMAT_ID = "gramps-connect-story";
+var FORMAT_VERSION = "1.0";
+var CURRENT_MAJOR = 1;
+var UPGRADERS = {};
+var SUPPORTED_FORMAT_MAJORS = Object.freeze(
+  Array.from({ length: CURRENT_MAJOR }, (_, i) => i + 1).filter(
+    (major) => major === CURRENT_MAJOR || UPGRADERS[major] !== void 0
+  )
+);
+function parseVersion(version) {
+  if (typeof version !== "string") return null;
+  const match = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/.exec(version);
+  if (!match) return null;
+  return { major: Number(match[1]), minor: Number(match[2]) };
+}
+
+// src/validate.ts
+var SCHEMA_MINOR = 0;
+function validate2(doc, files) {
+  const errors = [];
+  const warnings = [];
+  if (!validate(doc)) {
+    for (const err of validate.errors ?? []) {
+      errors.push({ path: err.instancePath, message: describeSchemaError(err) });
+    }
+    return { valid: false, errors, warnings };
+  }
+  const story = doc;
+  const slideIds = /* @__PURE__ */ new Set();
+  const usedMedia2 = /* @__PURE__ */ new Set();
+  const checkRef = (key, path) => {
+    usedMedia2.add(key);
+    if (!Object.prototype.hasOwnProperty.call(story.media, key)) {
+      errors.push({ path, message: `refers to media "${key}", which isn't in "media".` });
+    }
+  };
+  story.slides.forEach((slide, i) => {
+    if (slideIds.has(slide.id)) {
+      errors.push({ path: `/slides/${i}/id`, message: `duplicate slide id "${slide.id}".` });
+    }
+    slideIds.add(slide.id);
+    slide.media?.forEach((m, j) => checkRef(m.ref, `/slides/${i}/media/${j}/ref`));
+    slide.place?.overlays?.forEach((o, j) => checkRef(o.media, `/slides/${i}/place/overlays/${j}/media`));
+  });
+  for (const [key, item] of Object.entries(story.media)) {
+    const path = `/media/${escapePointer(key)}`;
+    if (files && !files.has(item.src)) {
+      errors.push({ path: `${path}/src`, message: `file "${item.src}" is not in the zip.` });
+    }
+    if (!usedMedia2.has(key)) {
+      warnings.push({ path, message: `media "${key}" isn't used by any slide or overlay.` });
+    }
+  }
+  const version = parseVersion(story.version);
+  if (version && version.major === CURRENT_MAJOR && version.minor <= SCHEMA_MINOR) {
+    findUnknownFields(story, story_schema_default, "", warnings);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function describeSchemaError(err) {
+  if (err.keyword === "pattern" && err.params.pattern === "\\S") return "must not be empty.";
+  if (err.keyword === "required") return `is missing required field "${String(err.params.missingProperty)}".`;
+  if (err.keyword === "const") return `must be ${JSON.stringify(err.params.allowedValue)}.`;
+  if (err.keyword === "enum") return `must be one of ${err.params.allowedValues.map((v) => JSON.stringify(v)).join(", ")}.`;
+  return `${err.message ?? "is invalid"}.`;
+}
+function escapePointer(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function resolveRef(node, root) {
+  if (!node.$ref) return node;
+  const name = node.$ref.replace(/^#\/\$defs\//, "");
+  return root.$defs[name];
+}
+function findUnknownFields(value, node, path, warnings, root = story_schema_default) {
+  node = resolveRef(node, root);
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => {
+      const itemNode = node.prefixItems?.[i] ?? node.items;
+      if (itemNode) findUnknownFields(item, itemNode, `${path}/${i}`, warnings, root);
+    });
+    return;
+  }
+  if (typeof value !== "object" || value === null) return;
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = `${path}/${escapePointer(key)}`;
+    const known = node.properties?.[key];
+    if (known) {
+      findUnknownFields(child, known, childPath, warnings, root);
+    } else if (typeof node.additionalProperties === "object") {
+      findUnknownFields(child, node.additionalProperties, childPath, warnings, root);
+    } else if (node.properties && node.additionalProperties !== true) {
+      warnings.push({ path: childPath, message: `unknown field "${key}" (ignored).` });
+    }
+  }
+}
+
+// src/player/StoryPlayer.tsx
+import { useEffect as useEffect3, useMemo, useRef as useRef3, useState as useState3 } from "react";
+
+// src/player/dates.ts
+var DATE = /^(-?\d{4})(?:-(\d{2}|XX))?(?:-(\d{2}|XX))?[~?%]?$/;
+function yearOf(part) {
+  const match = DATE.exec(part.trim());
+  return match ? Number(match[1]) : null;
+}
+function edtfYearRange(edtf) {
+  if (!edtf) return null;
+  const value = edtf.trim();
+  const set = /^\[(.+)\.\.(.+)\]$/.exec(value);
+  if (set) {
+    const min = yearOf(set[1]);
+    const max = yearOf(set[2]);
+    return min !== null && max !== null ? { min: Math.min(min, max), max: Math.max(min, max) } : null;
+  }
+  if (value.includes("/")) {
+    const [startText, endText] = value.split("/");
+    const openStart = startText === ".." || startText === "";
+    const openEnd = endText === ".." || endText === "";
+    const start = openStart ? void 0 : yearOf(startText);
+    const end = openEnd ? void 0 : yearOf(endText);
+    if (start === null || end === null) return null;
+    if (start === void 0 && end === void 0) return null;
+    if (start !== void 0 && end !== void 0) return { min: Math.min(start, end), max: Math.max(start, end) };
+    return { min: start, max: end };
+  }
+  const year = yearOf(value);
+  return year === null ? null : { min: year, max: year };
+}
+function dateCoversYear(date, year) {
+  if (!date || year === null) return true;
+  const range = edtfYearRange(date.edtf);
+  if (!range) return true;
+  if (range.min !== void 0 && year < range.min) return false;
+  if (range.max !== void 0 && year > range.max) return false;
+  return true;
+}
+function timelineYear(date) {
+  if (!date) return null;
+  const match = date.edtf ? DATE.exec(date.edtf.trim()) : null;
+  const sortYear = date.sortYear ?? (match ? Number(match[1]) : void 0);
+  if (sortYear === void 0) return null;
+  if (!match || Number(match[1]) !== sortYear) return sortYear;
+  const month = match[2] && match[2] !== "XX" ? Number(match[2]) : 0;
+  const day = match[3] && match[3] !== "XX" ? Number(match[3]) : 0;
+  if (!month) return sortYear;
+  return sortYear + (month - 1) / 12 + (day ? (day - 1) / 365 : 0);
+}
+
+// src/player/geo.ts
+function visit(coords, bounds) {
+  if (!Array.isArray(coords)) return;
+  if (coords.length >= 2 && typeof coords[0] === "number" && typeof coords[1] === "number") {
+    const [lon, lat] = coords;
+    bounds[0] = Math.min(bounds[0], lon);
+    bounds[1] = Math.min(bounds[1], lat);
+    bounds[2] = Math.max(bounds[2], lon);
+    bounds[3] = Math.max(bounds[3], lat);
+    return;
+  }
+  for (const child of coords) visit(child, bounds);
+}
+function visitGeoJson(node, bounds) {
+  if (!node || typeof node !== "object") return;
+  const obj = node;
+  if (obj.coordinates !== void 0) visit(obj.coordinates, bounds);
+  if (obj.geometry) visitGeoJson(obj.geometry, bounds);
+  for (const g of obj.geometries ?? []) visitGeoJson(g, bounds);
+  for (const f of obj.features ?? []) visitGeoJson(f, bounds);
+}
+function placeBounds(place) {
+  if (!place) return null;
+  const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  visitGeoJson(place.geometry, bounds);
+  for (const overlay of place.overlays ?? []) visit(overlay.corners, bounds);
+  return Number.isFinite(bounds[0]) ? bounds : null;
+}
+function placeCenter(place) {
+  if (place?.lat !== void 0 && place.lon !== void 0) return [place.lon, place.lat];
+  const bounds = placeBounds(place);
+  return bounds ? [(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2] : null;
+}
+function storyPlaces(places) {
+  const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  const points = /* @__PURE__ */ new Map();
+  for (const place of places) {
+    const center = placeCenter(place);
+    if (!center) continue;
+    points.set(`${center[0].toFixed(5)},${center[1].toFixed(5)}`, center);
+    visit(center, bounds);
+    const box = placeBounds(place);
+    if (box) visit([[box[0], box[1]], [box[2], box[3]]], bounds);
+  }
+  return points.size ? { points: [...points.values()], bounds } : null;
+}
+
+// src/player/MapBackground.tsx
+import { useEffect, useRef, useState } from "react";
+import * as maplibregl from "maplibre-gl";
+import "maplibre-gl/dist/maplibre-gl.css";
+
+// src/player/mapStyles.ts
+import { filterByDate } from "@openhistoricalmap/maplibre-gl-dates";
+var STYLE_LIGHT = "https://tiles.openfreemap.org/styles/liberty";
+var STYLE_DARK = "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json";
+var OHM_STYLE = "https://www.openhistoricalmap.org/map-styles/main/main.json";
+function mapStyleKey(dark, ohmYear) {
+  return ohmYear != null ? "ohm" : dark ? "dark" : "light";
+}
+function mapStyleUrl(dark, ohmYear) {
+  return ohmYear != null ? OHM_STYLE : dark ? STYLE_DARK : STYLE_LIGHT;
+}
+function crossfadeStyleSwap(map, styleUrl, beforeSwap, duration = 300) {
+  const container = map.getContainer();
+  if (!container.style.zIndex) container.style.zIndex = "0";
+  let snapshotUrl = null;
+  try {
+    snapshotUrl = map.getCanvas().toDataURL("image/png");
+  } catch {
+  }
+  beforeSwap();
+  map.setStyle(styleUrl);
+  if (!snapshotUrl) return;
+  const overlay = document.createElement("img");
+  overlay.src = snapshotUrl;
+  overlay.alt = "";
+  Object.assign(overlay.style, {
+    position: "absolute",
+    inset: "0",
+    width: "100%",
+    height: "100%",
+    zIndex: "5",
+    pointerEvents: "none",
+    transition: `opacity ${duration}ms ease`
+  });
+  container.appendChild(overlay);
+  map.once("idle", () => {
+    requestAnimationFrame(() => {
+      overlay.style.opacity = "0";
+    });
+    window.setTimeout(() => overlay.remove(), duration + 50);
+  });
+}
+function applyOhmYear(map, year) {
+  filterByDate(map, String(Math.round(year)));
+}
+
+// src/player/theme.ts
+function defaultColors(dark) {
+  return dark ? { surface: "#242424", text: "#c9c9c9", muted: "#828282", border: "#424242", mark: "#3987e5", panel: "rgb(20,20,20)" } : { surface: "#ffffff", text: "#000000", muted: "#868e96", border: "#dee2e6", mark: "#2a78d6", panel: "rgb(255,255,255)" };
+}
+var PIN_PATH_D = "M12 0C7.03 0 3 4.03 3 9c0 6.25 9 15 9 15s9-8.75 9-15c0-4.97-4.03-9-9-9z";
+
+// src/player/MapBackground.tsx
+import { jsx } from "react/jsx-runtime";
+var SHAPE_SOURCE = "story-shape";
+var FILL_LAYER = "story-shape-fill";
+var LINE_LAYER = "story-shape-line";
+var POINT_LAYER = "story-shape-points";
+var LABEL_LAYER = "story-shape-labels";
+var OVERLAY_PREFIX = "story-overlay-";
+var PLACES_SOURCE = "story-places";
+var PLACES_LAYER = "story-places-dots";
+var OVERVIEW_PADDING = 60;
+var EMPTY = { type: "FeatureCollection", features: [] };
+function moveCamera(map, slide, duration) {
+  if (slide.overview) {
+    const [west, south, east, north] = slide.overview.bounds;
+    map.fitBounds([[west, south], [east, north]], { maxZoom: 9, padding: OVERVIEW_PADDING, duration });
+    return;
+  }
+  const place = slide.place;
+  const bounds = placeBounds(place);
+  if (bounds) {
+    map.fitBounds([[bounds[0], bounds[1]], [bounds[2], bounds[3]]], { maxZoom: 17, duration });
+    return;
+  }
+  const center = placeCenter(place);
+  if (center) map.flyTo({ center, zoom: 9, essential: true, duration });
+}
+function placeMarker(marker, slide) {
+  if (!marker) return;
+  const center = placeCenter(slide.place);
+  if (center) marker.setLngLat(center);
+  marker.setOpacity(slide.overview ? 0 : center ? 1 : 0.4);
+}
+var placeDots = (overview) => ({
+  type: "FeatureCollection",
+  features: (overview?.points ?? []).map((coordinates) => ({
+    type: "Feature",
+    properties: {},
+    geometry: { type: "Point", coordinates }
+  }))
+});
+function MapBackground({ initialCenter, current, dark, colors, panelFraction, ohmYear, resolveMedia }) {
+  const [containerEl, setContainerEl] = useState(null);
+  const mapRef = useRef(null);
+  const markerRef = useRef(null);
+  const [ready, setReady] = useState(false);
+  const darkRef = useRef(dark);
+  darkRef.current = dark;
+  const ohmYearRef = useRef(ohmYear);
+  ohmYearRef.current = ohmYear;
+  const colorsRef = useRef(colors);
+  colorsRef.current = colors;
+  const overlayDatesRef = useRef(/* @__PURE__ */ new Map());
+  const appliedStyleKeyRef = useRef(mapStyleKey(dark, ohmYear));
+  const currentRef = useRef(current);
+  currentRef.current = current;
+  useEffect(() => {
+    if (!containerEl) return;
+    setReady(false);
+    appliedStyleKeyRef.current = mapStyleKey(darkRef.current, ohmYearRef.current);
+    const map = new maplibregl.Map({
+      container: containerEl,
+      style: mapStyleUrl(darkRef.current, ohmYearRef.current),
+      zoom: 5,
+      attributionControl: { compact: true },
+      // So crossfadeStyleSwap's snapshot has the last frame in it.
+      canvasContextAttributes: { preserveDrawingBuffer: true }
+    });
+    mapRef.current = map;
+    map.on("style.load", () => setReady(true));
+    map.setPadding({ top: 0, bottom: 0, left: 0, right: containerEl.clientWidth * panelFraction });
+    const start = currentRef.current;
+    map.jumpTo({ center: placeCenter(start.place) ?? initialCenter });
+    moveCamera(map, start, 0);
+    map.on("load", () => {
+      const c = colorsRef.current;
+      const el = document.createElement("div");
+      el.style.width = "26px";
+      el.style.height = "26px";
+      el.style.transition = "opacity 300ms";
+      el.innerHTML = `<svg viewBox="0 0 24 24" width="26" height="26"><path d="${PIN_PATH_D}" fill="${c.mark}" stroke="${c.surface}" stroke-width="1.5" /></svg>`;
+      markerRef.current = new maplibregl.Marker({ element: el, anchor: "bottom" }).setLngLat(initialCenter).addTo(map);
+      placeMarker(markerRef.current, currentRef.current);
+    });
+    return () => {
+      markerRef.current?.remove();
+      markerRef.current = null;
+      map.remove();
+      mapRef.current = null;
+    };
+  }, [containerEl]);
+  useEffect(() => {
+    const map = mapRef.current;
+    const key = mapStyleKey(dark, ohmYear);
+    if (!map || appliedStyleKeyRef.current === key) return;
+    appliedStyleKeyRef.current = key;
+    crossfadeStyleSwap(map, mapStyleUrl(dark, ohmYear), () => setReady(false));
+  }, [dark, ohmYear]);
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !ready || ohmYear == null) return;
+    applyOhmYear(map, ohmYear);
+  }, [ready, ohmYear]);
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !ready || map.getSource(SHAPE_SOURCE)) return;
+    const c = colorsRef.current;
+    map.addSource(SHAPE_SOURCE, { type: "geojson", data: EMPTY });
+    const color = ["coalesce", ["get", "color"], c.mark];
+    map.addLayer({
+      id: FILL_LAYER,
+      type: "fill",
+      source: SHAPE_SOURCE,
+      filter: ["==", ["geometry-type"], "Polygon"],
+      paint: { "fill-color": color, "fill-opacity": 0.25 }
+    });
+    map.addLayer({
+      id: LINE_LAYER,
+      type: "line",
+      source: SHAPE_SOURCE,
+      filter: ["any", ["==", ["geometry-type"], "Polygon"], ["==", ["geometry-type"], "LineString"]],
+      paint: { "line-color": color, "line-width": 2 }
+    });
+    map.addLayer({
+      id: POINT_LAYER,
+      type: "circle",
+      source: SHAPE_SOURCE,
+      // A named point is a label (next layer), drawn as text only.
+      filter: ["all", ["==", ["geometry-type"], "Point"], ["!", ["has", "name"]]],
+      paint: { "circle-radius": 5, "circle-color": color, "circle-stroke-width": 1, "circle-stroke-color": c.surface }
+    });
+    map.addLayer({
+      id: LABEL_LAYER,
+      type: "symbol",
+      source: SHAPE_SOURCE,
+      filter: ["all", ["==", ["geometry-type"], "Point"], ["has", "name"]],
+      layout: {
+        "text-field": ["get", "name"],
+        "text-size": 12,
+        "text-font": ["Noto Sans Regular"],
+        "text-anchor": "left",
+        "text-offset": [0.6, 0]
+      },
+      paint: {
+        "text-color": ["coalesce", ["get", "color"], c.text],
+        "text-halo-color": c.surface,
+        "text-halo-width": 1.5
+      }
+    });
+    map.addSource(PLACES_SOURCE, { type: "geojson", data: EMPTY });
+    map.addLayer({
+      id: PLACES_LAYER,
+      type: "circle",
+      source: PLACES_SOURCE,
+      paint: { "circle-radius": 6, "circle-color": c.mark, "circle-stroke-width": 2, "circle-stroke-color": c.surface }
+    });
+  }, [ready]);
+  const place = current.place;
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !ready) return;
+    const source = map.getSource(SHAPE_SOURCE);
+    source?.setData(place?.geometry ?? EMPTY);
+    const dots = map.getSource(PLACES_SOURCE);
+    dots?.setData(placeDots(current.overview));
+  }, [ready, current.key, place, current.overview]);
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map) return;
+    placeMarker(markerRef.current, current);
+    moveCamera(map, current, 900);
+  }, [current.key]);
+  const overlayKey = JSON.stringify(place?.overlays ?? []);
+  useEffect(() => {
+    const map = mapRef.current;
+    const overlays = place?.overlays ?? [];
+    if (!map || !ready || overlays.length === 0) return;
+    let cancelled = false;
+    const added = [];
+    (async () => {
+      const sorted = overlays.map((overlay, i) => ({ overlay, i })).sort((a, b) => (a.overlay.order ?? a.i) - (b.overlay.order ?? b.i));
+      for (const { overlay, i } of sorted) {
+        const url = await resolveMedia(overlay.media);
+        if (cancelled) return;
+        if (!url) continue;
+        const id = `${OVERLAY_PREFIX}${i}`;
+        if (map.getSource(id)) continue;
+        map.addSource(id, { type: "image", url, coordinates: overlay.corners });
+        map.addLayer({ id, type: "raster", source: id }, FILL_LAYER);
+        map.setPaintProperty(id, "raster-opacity", overlay.opacity ?? 1);
+        overlayDatesRef.current.set(id, overlay.date);
+        map.setLayoutProperty(id, "visibility", dateCoversYear(overlay.date, ohmYearRef.current) ? "visible" : "none");
+        added.push(id);
+      }
+    })();
+    return () => {
+      cancelled = true;
+      for (const id of added) {
+        overlayDatesRef.current.delete(id);
+        if (map.getLayer(id)) map.removeLayer(id);
+        if (map.getSource(id)) map.removeSource(id);
+      }
+    };
+  }, [overlayKey, ready]);
+  useEffect(() => {
+    const map = mapRef.current;
+    if (!map || !ready) return;
+    for (const [id, date] of overlayDatesRef.current) {
+      if (!map.getLayer(id)) continue;
+      map.setLayoutProperty(id, "visibility", dateCoversYear(date, ohmYear) ? "visible" : "none");
+    }
+  }, [ohmYear, ready]);
+  return /* @__PURE__ */ jsx("div", { ref: setContainerEl, style: { position: "absolute", inset: 0 } });
+}
+
+// src/player/MapModeControl.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function MapModeControl({ mode, onModeChange, autoYear, year, onYearChange, yearBounds, strings, colors }) {
+  const modes = [["auto", strings.auto], ["standard", strings.standard], ["historical", strings.historical]];
+  const font = { fontSize: 12, fontFamily: "inherit" };
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 10, whiteSpace: "nowrap" }, children: [
+    /* @__PURE__ */ jsx2("div", { role: "radiogroup", "aria-label": strings.mapMode, style: { display: "flex", border: `1px solid ${colors.border}`, borderRadius: 6, overflow: "hidden", background: colors.surface }, children: modes.map(([value, label]) => /* @__PURE__ */ jsx2(
+      "button",
+      {
+        type: "button",
+        role: "radio",
+        "aria-checked": mode === value,
+        onClick: () => onModeChange(value),
+        style: {
+          ...font,
+          padding: "4px 10px",
+          border: "none",
+          cursor: "pointer",
+          background: mode === value ? colors.mark : "transparent",
+          color: mode === value ? "#ffffff" : colors.text
+        },
+        children: label
+      },
+      value
+    )) }),
+    mode === "auto" && /* @__PURE__ */ jsx2("span", { style: { ...font, color: colors.muted }, children: autoYear != null ? strings.historicalMapYear(autoYear) : strings.noDateStandardMap }),
+    mode === "historical" && /* @__PURE__ */ jsxs("span", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+      /* @__PURE__ */ jsx2(
+        "input",
+        {
+          type: "range",
+          min: yearBounds[0],
+          max: yearBounds[1],
+          step: 1,
+          value: year,
+          onChange: (e) => onYearChange(Number(e.currentTarget.value)),
+          "aria-label": strings.historicalYear,
+          style: { width: 150, accentColor: colors.mark }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        "input",
+        {
+          type: "number",
+          min: yearBounds[0],
+          max: yearBounds[1],
+          step: 1,
+          value: year,
+          onChange: (e) => {
+            const value = Number(e.currentTarget.value);
+            if (Number.isFinite(value) && e.currentTarget.value !== "") onYearChange(Math.round(value));
+          },
+          "aria-label": strings.historicalYear,
+          style: { ...font, width: 70, padding: "3px 4px", border: `1px solid ${colors.border}`, borderRadius: 4, background: colors.surface, color: colors.text }
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/player/text.ts
+var MARKERS = /\*\*([^\n]+?)\*\*|\*([^\n]+?)\*/g;
+function parseLine(line) {
+  const spans = [];
+  let last = 0;
+  for (const match of line.matchAll(MARKERS)) {
+    const index = match.index ?? 0;
+    if (index > last) spans.push({ text: line.slice(last, index) });
+    if (match[1] !== void 0) spans.push({ text: match[1], bold: true });
+    else spans.push({ text: match[2], italic: true });
+    last = index + match[0].length;
+  }
+  if (last < line.length) spans.push({ text: line.slice(last) });
+  return spans;
+}
+function parseStoryText(text) {
+  return text.replace(/\r\n?/g, "\n").split(/\n[ \t]*\n+/).map((paragraph) => paragraph.replace(/^\n+|\n+$/g, "")).filter((paragraph) => paragraph.length > 0).map((paragraph) => paragraph.split("\n").map(parseLine));
+}
+
+// src/player/strings.ts
+var ENGLISH = {
+  previous: "Previous",
+  next: "Next",
+  close: "Close",
+  mapMode: "Map",
+  auto: "Auto",
+  standard: "Standard",
+  historical: "Historical",
+  historicalMapYear: (year) => `Historical map, ${year}`,
+  noDateStandardMap: "No date here \u2014 standard map",
+  historicalYear: "Historical map year",
+  photoOf: (n, total) => `Photo ${n} of ${total}`
+};
+var TABLE = {
+  en: ENGLISH,
+  de: {
+    previous: "Zur\xFCck",
+    next: "Weiter",
+    close: "Schlie\xDFen",
+    mapMode: "Karte",
+    auto: "Automatisch",
+    standard: "Standard",
+    historical: "Historisch",
+    historicalMapYear: (year) => `Historische Karte, ${year}`,
+    noDateStandardMap: "Kein Datum hier \u2014 Standardkarte",
+    historicalYear: "Jahr der historischen Karte",
+    photoOf: (n, total) => `Foto ${n} von ${total}`
+  },
+  es: {
+    previous: "Anterior",
+    next: "Siguiente",
+    close: "Cerrar",
+    mapMode: "Mapa",
+    auto: "Autom\xE1tico",
+    standard: "Est\xE1ndar",
+    historical: "Hist\xF3rico",
+    historicalMapYear: (year) => `Mapa hist\xF3rico, ${year}`,
+    noDateStandardMap: "Sin fecha aqu\xED \u2014 mapa est\xE1ndar",
+    historicalYear: "A\xF1o del mapa hist\xF3rico",
+    photoOf: (n, total) => `Foto ${n} de ${total}`
+  },
+  fr: {
+    previous: "Pr\xE9c\xE9dent",
+    next: "Suivant",
+    close: "Fermer",
+    mapMode: "Carte",
+    auto: "Auto",
+    standard: "Standard",
+    historical: "Historique",
+    historicalMapYear: (year) => `Carte historique, ${year}`,
+    noDateStandardMap: "Pas de date ici \u2014 carte standard",
+    historicalYear: "Ann\xE9e de la carte historique",
+    photoOf: (n, total) => `Photo ${n} sur ${total}`
+  },
+  nl: {
+    previous: "Vorige",
+    next: "Volgende",
+    close: "Sluiten",
+    mapMode: "Kaart",
+    auto: "Automatisch",
+    standard: "Standaard",
+    historical: "Historisch",
+    historicalMapYear: (year) => `Historische kaart, ${year}`,
+    noDateStandardMap: "Geen datum hier \u2014 standaardkaart",
+    historicalYear: "Jaar van de historische kaart",
+    photoOf: (n, total) => `Foto ${n} van ${total}`
+  }
+};
+function stringsFor(...languages) {
+  for (const tag of languages) {
+    const base = tag?.toLowerCase().split(/[-_]/)[0];
+    if (base && TABLE[base]) return TABLE[base];
+  }
+  return ENGLISH;
+}
+var PLAYER_LANGUAGES = Object.keys(TABLE);
+
+// src/player/TimelineStrip.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/player/timelineLayout.ts
+function storyDomain(years) {
+  const min = Math.min(...years);
+  const max = Math.max(...years);
+  if (max - min < 1) return [min - 5, min + 5];
+  const padding = (max - min) * 0.05;
+  return [min - padding, max + padding];
+}
+function xForYear(year, domain, width) {
+  const [start, end] = domain;
+  const span = end - start;
+  if (!(span > 0)) return width / 2;
+  return (year - start) / span * width;
+}
+var TICK_STEPS = [1e3, 500, 250, 100, 50, 25, 10, 5, 2, 1];
+var TARGET_TICKS = 8;
+function axisTicks(domain, width) {
+  const [start, end] = domain;
+  const span = end - start;
+  if (!(span > 0) || width <= 0) return [];
+  const step = TICK_STEPS.find((candidate) => span / candidate >= TARGET_TICKS) ?? 1;
+  const ticks = [];
+  for (let year = Math.ceil(start / step) * step; year < end; year += step) {
+    ticks.push({ x: (year - start) / span * width, label: tickLabel(year) });
+  }
+  return ticks;
+}
+function tickLabel(year) {
+  const whole = Math.floor(year);
+  return whole < 0 ? `${-whole} BC` : String(whole);
+}
+
+// src/player/TimelineStrip.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var TIMELINE_HEIGHT = 70;
+var MARGIN = 28;
+var AXIS_Y = 42;
+var LABEL_Y = 62;
+var CURRENT_SCALE = 0.95;
+function TimelineStrip({ points, currentIndex, onSelect, colors }) {
+  const containerRef = useRef2(null);
+  const [width, setWidth] = useState2(0);
+  useEffect2(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const observer = new ResizeObserver(([entry]) => setWidth(entry.contentRect.width));
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+  const plotWidth = Math.max(0, width - MARGIN * 2);
+  const domain = storyDomain(points.map((p) => p.year));
+  const ticks = plotWidth > 0 ? axisTicks(domain, plotWidth) : [];
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: containerRef,
+      style: {
+        position: "absolute",
+        left: 0,
+        right: 0,
+        bottom: 0,
+        height: TIMELINE_HEIGHT,
+        background: colors.surface,
+        // Above the slide panel, whose fading background would otherwise
+        // wash out any dot beneath it.
+        zIndex: 2
+      },
+      children: width > 0 && /* @__PURE__ */ jsxs2("svg", { width, height: TIMELINE_HEIGHT, style: { display: "block", overflow: "visible" }, children: [
+        /* @__PURE__ */ jsx3("line", { x1: MARGIN, y1: AXIS_Y, x2: width - MARGIN, y2: AXIS_Y, stroke: colors.border, strokeWidth: 1 }),
+        ticks.map((tick) => /* @__PURE__ */ jsx3("text", { x: MARGIN + tick.x, y: LABEL_Y, fontSize: 15, fill: colors.muted, textAnchor: "middle", children: tick.label }, tick.x)),
+        points.map((point) => {
+          const cx = MARGIN + xForYear(point.year, domain, plotWidth);
+          const current = point.index === currentIndex;
+          return current ? /* @__PURE__ */ jsx3(
+            "path",
+            {
+              d: PIN_PATH_D,
+              transform: `translate(${cx - 12 * CURRENT_SCALE} ${AXIS_Y - 24 * CURRENT_SCALE}) scale(${CURRENT_SCALE})`,
+              fill: colors.mark,
+              stroke: colors.text,
+              strokeWidth: 1.5,
+              style: { cursor: "pointer" },
+              onClick: () => onSelect(point.index),
+              children: /* @__PURE__ */ jsx3("title", { children: tickLabel(point.year) })
+            },
+            point.index
+          ) : /* @__PURE__ */ jsx3(
+            "circle",
+            {
+              cx,
+              cy: AXIS_Y,
+              r: 3.5,
+              fill: colors.mark,
+              stroke: colors.surface,
+              strokeWidth: 1.5,
+              style: { cursor: "pointer" },
+              onClick: () => onSelect(point.index),
+              children: /* @__PURE__ */ jsx3("title", { children: tickLabel(point.year) })
+            },
+            point.index
+          );
+        })
+      ] })
+    }
+  );
+}
+
+// src/player/StoryPlayer.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var PANEL_FRACTION = 0.62;
+var BAR_HEIGHT = 56;
+function initialMapMode(story) {
+  return story.presentation?.basemap === "historical" ? "auto" : "standard";
+}
+function SlideText({ text, colors }) {
+  return /* @__PURE__ */ jsx4(Fragment, { children: parseStoryText(text).map((lines, p) => /* @__PURE__ */ jsx4("p", { dir: "auto", style: { margin: "0 0 0.6em", color: colors.text, lineHeight: 1.55 }, children: lines.map((spans, l) => /* @__PURE__ */ jsxs3("span", { children: [
+    l > 0 && /* @__PURE__ */ jsx4("br", {}),
+    spans.map((span, s) => {
+      if (span.bold) return /* @__PURE__ */ jsx4("b", { children: span.text }, s);
+      if (span.italic) return /* @__PURE__ */ jsx4("i", { children: span.text }, s);
+      return /* @__PURE__ */ jsx4("span", { children: span.text }, s);
+    })
+  ] }, l)) }, p)) });
+}
+function SlidePhoto({ mediaKey, item, caption, credit, resolveMedia, colors }) {
+  const [src, setSrc] = useState3(null);
+  useEffect3(() => {
+    setSrc(null);
+    let cancelled = false;
+    resolveMedia(mediaKey, item).then((url) => {
+      if (!cancelled) setSrc(url);
+    }, () => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [mediaKey, item, resolveMedia]);
+  if (!src) return null;
+  return /* @__PURE__ */ jsxs3("figure", { style: { margin: 0, display: "flex", flexDirection: "column", alignItems: "center", gap: 4 }, children: [
+    /* @__PURE__ */ jsx4(
+      "img",
+      {
+        src,
+        alt: item.alt ?? "",
+        width: item.width,
+        height: item.height,
+        style: { maxHeight: "42vh", maxWidth: "100%", width: "auto", height: "auto", objectFit: "contain", borderRadius: 4 }
+      }
+    ),
+    (caption || credit) && /* @__PURE__ */ jsx4("figcaption", { style: { fontSize: 13, color: colors.muted }, children: [caption, credit && `\xA9 ${credit}`].filter(Boolean).join(" \xB7 ") })
+  ] });
+}
+function PhotoThumb({ mediaKey, item, label, selected, onSelect, resolveMedia, colors }) {
+  const [src, setSrc] = useState3(null);
+  useEffect3(() => {
+    let cancelled = false;
+    resolveMedia(mediaKey, item).then((url) => {
+      if (!cancelled) setSrc(url);
+    }, () => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [mediaKey, item, resolveMedia]);
+  return /* @__PURE__ */ jsx4(
+    "button",
+    {
+      type: "button",
+      "aria-label": label,
+      title: label,
+      "aria-pressed": selected,
+      onClick: onSelect,
+      style: {
+        width: 44,
+        height: 44,
+        padding: 0,
+        borderRadius: 4,
+        overflow: "hidden",
+        cursor: "pointer",
+        border: `2px solid ${selected ? colors.mark : "transparent"}`,
+        background: colors.border,
+        opacity: selected ? 1 : 0.7
+      },
+      children: src && /* @__PURE__ */ jsx4("img", { src, alt: "", style: { width: "100%", height: "100%", objectFit: "cover", display: "block" } })
+    }
+  );
+}
+function SlideContent({ slide, story, resolveMedia, colors, strings }) {
+  const photos = (slide?.media ?? []).filter((m) => Object.prototype.hasOwnProperty.call(story.media, m.ref));
+  const [shown, setShown] = useState3(0);
+  const photo = photos[Math.min(shown, photos.length - 1)];
+  const eyebrow = [slide?.date?.text, slide?.place?.name].filter(Boolean).join(" \xB7 ");
+  return /* @__PURE__ */ jsxs3(Fragment, { children: [
+    photo && /* @__PURE__ */ jsx4(
+      SlidePhoto,
+      {
+        mediaKey: photo.ref,
+        item: story.media[photo.ref],
+        caption: photo.caption,
+        credit: photo.credit,
+        resolveMedia,
+        colors
+      }
+    ),
+    photos.length > 1 && /* @__PURE__ */ jsx4("div", { style: { display: "flex", gap: 6, flexWrap: "wrap", justifyContent: "center" }, children: photos.map((m, i) => /* @__PURE__ */ jsx4(
+      PhotoThumb,
+      {
+        mediaKey: m.ref,
+        item: story.media[m.ref],
+        label: strings.photoOf(i + 1, photos.length),
+        selected: photo === m,
+        onSelect: () => setShown(i),
+        resolveMedia,
+        colors
+      },
+      `${i}:${m.ref}`
+    )) }),
+    /* @__PURE__ */ jsxs3("div", { style: { display: "flex", flexDirection: "column", gap: 4, alignItems: "center", maxWidth: 640, textAlign: "center" }, children: [
+      eyebrow && /* @__PURE__ */ jsx4("div", { dir: "auto", style: { fontSize: 14, color: colors.muted }, children: eyebrow }),
+      slide?.title && /* @__PURE__ */ jsx4("div", { dir: "auto", style: { fontSize: 20, fontWeight: 700, color: colors.text }, children: slide.title }),
+      slide?.text && /* @__PURE__ */ jsx4("div", { children: /* @__PURE__ */ jsx4(SlideText, { text: slide.text, colors }) })
+    ] })
+  ] });
+}
+function RoundButton({ label, onClick, disabled, size, children, style }) {
+  return /* @__PURE__ */ jsx4(
+    "button",
+    {
+      type: "button",
+      "aria-label": label,
+      title: label,
+      onClick,
+      disabled,
+      style: {
+        width: size,
+        height: size,
+        borderRadius: "50%",
+        border: "none",
+        background: "#25262b",
+        color: "#ffffff",
+        fontSize: size >= 48 ? 22 : 18,
+        cursor: disabled ? "default" : "pointer",
+        opacity: disabled ? 0.35 : 0.8,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: 0,
+        fontFamily: "inherit",
+        ...style
+      },
+      children
+    }
+  );
+}
+function NavArrows({ index, total, onPrev, onNext, variant, strings, colors }) {
+  if (variant === "edge") {
+    const edge = { position: "absolute", top: "50%", transform: "translateY(-50%)", zIndex: 2 };
+    return /* @__PURE__ */ jsxs3(Fragment, { children: [
+      /* @__PURE__ */ jsx4(RoundButton, { label: strings.previous, size: 56, disabled: index === 0, onClick: onPrev, style: { ...edge, left: 24 }, children: "\u2190" }),
+      /* @__PURE__ */ jsx4(RoundButton, { label: strings.next, size: 56, disabled: index === total - 1, onClick: onNext, style: { ...edge, right: 24 }, children: "\u2192" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3("div", { style: { display: "flex", alignItems: "center", justifyContent: "center", gap: 16, marginTop: 16 }, children: [
+    /* @__PURE__ */ jsx4(RoundButton, { label: strings.previous, size: 34, disabled: index === 0, onClick: onPrev, children: "\u2190" }),
+    /* @__PURE__ */ jsxs3("span", { style: { fontSize: 14, color: colors.muted }, children: [
+      index + 1,
+      " / ",
+      total
+    ] }),
+    /* @__PURE__ */ jsx4(RoundButton, { label: strings.next, size: 34, disabled: index === total - 1, onClick: onNext, children: "\u2192" })
+  ] });
+}
+function StoryPlayer({
+  story,
+  resolveMedia,
+  dark = false,
+  colors: colorOverrides,
+  strings: stringOverrides,
+  onClose,
+  keyboard = true,
+  onSlideChange,
+  renderMapModeControl,
+  brand,
+  actions,
+  initialSlide = 0
+}) {
+  const colors = useMemo(() => ({ ...defaultColors(dark), ...colorOverrides }), [dark, colorOverrides]);
+  const strings = useMemo(
+    () => ({
+      ...stringsFor(story.language, typeof navigator === "undefined" ? void 0 : navigator.language),
+      ...stringOverrides
+    }),
+    [story.language, stringOverrides]
+  );
+  const rootRef = useRef3(null);
+  const slides = story.slides;
+  const [index, setIndex] = useState3(initialSlide);
+  const slide = slides[index];
+  useEffect3(() => {
+    setIndex(Math.min(Math.max(initialSlide, 0), Math.max(slides.length - 1, 0)));
+  }, [story, initialSlide, slides.length]);
+  const datedSlides = useMemo(() => {
+    const points = [];
+    slides.forEach((s, i) => {
+      const year = timelineYear(s.date);
+      if (year !== null) points.push({ index: i, year });
+    });
+    return points;
+  }, [slides]);
+  const showTimeline = datedSlides.length >= 2;
+  const [mapMode, setMapMode] = useState3(() => initialMapMode(story));
+  const [historicalYear, setHistoricalYear] = useState3(() => (/* @__PURE__ */ new Date()).getFullYear());
+  const currentYear = timelineYear(slide?.date);
+  const autoYear = currentYear !== null ? Math.floor(currentYear) : null;
+  const yearBounds = useMemo(() => {
+    if (datedSlides.length === 0) {
+      const thisYear = (/* @__PURE__ */ new Date()).getFullYear();
+      return [thisYear - 200, thisYear];
+    }
+    const years = datedSlides.map((d) => d.year);
+    return [Math.floor(Math.min(...years)), Math.ceil(Math.max(...years))];
+  }, [datedSlides]);
+  const wasHistoricalRef = useRef3(false);
+  useEffect3(() => {
+    if (mapMode === "historical" && !wasHistoricalRef.current) setHistoricalYear(autoYear ?? yearBounds[1]);
+    wasHistoricalRef.current = mapMode === "historical";
+  }, [mapMode, autoYear, yearBounds]);
+  const ohmYear = mapMode === "standard" ? null : mapMode === "auto" ? autoYear : historicalYear;
+  const goPrev = () => setIndex((i) => Math.max(i - 1, 0));
+  const goNext = () => setIndex((i) => Math.min(i + 1, slides.length - 1));
+  const onSlideChangeRef = useRef3(onSlideChange);
+  onSlideChangeRef.current = onSlideChange;
+  useEffect3(() => {
+    onSlideChangeRef.current?.(index);
+  }, [index]);
+  useEffect3(() => {
+    if (!keyboard) return;
+    const target = keyboard === "focus" ? rootRef.current : window;
+    if (!target) return;
+    function onKey(e) {
+      const key = e.key;
+      const from = e.target;
+      if (from && (from.tagName === "INPUT" || from.tagName === "TEXTAREA" || from.isContentEditable)) return;
+      if (key === "ArrowRight") setIndex((i) => Math.min(i + 1, slides.length - 1));
+      if (key === "ArrowLeft") setIndex((i) => Math.max(i - 1, 0));
+    }
+    target.addEventListener("keydown", onKey);
+    return () => target.removeEventListener("keydown", onKey);
+  }, [keyboard, slides.length]);
+  const swipeStart = useRef3(null);
+  const swipeHandlers = {
+    onTouchStart: (e) => {
+      const t = e.touches[0];
+      swipeStart.current = e.touches.length === 1 ? { x: t.clientX, y: t.clientY } : null;
+    },
+    onTouchEnd: (e) => {
+      const start = swipeStart.current;
+      swipeStart.current = null;
+      const t = e.changedTouches[0];
+      if (!start || !t) return;
+      const dx = t.clientX - start.x;
+      const dy = t.clientY - start.y;
+      if (Math.abs(dx) < 50 || Math.abs(dx) < Math.abs(dy) * 1.5) return;
+      if (dx < 0) goNext();
+      else goPrev();
+    }
+  };
+  const places = useMemo(() => storyPlaces(slides.map((s) => s.place)), [slides]);
+  const mapSlide = useMemo(() => ({
+    key: slide?.id ?? String(index),
+    place: slide?.place,
+    // The opening card, with no place of its own, shows where the story goes.
+    overview: index === 0 && !placeCenter(slide?.place) ? places : null
+  }), [slide, index, places]);
+  const firstCenter = useMemo(() => {
+    if (story.presentation?.basemap === "none") return null;
+    for (const s of slides) {
+      const center = placeCenter(s.place);
+      if (center) return center;
+    }
+    return null;
+  }, [story, slides]);
+  const modeControlProps = {
+    mode: mapMode,
+    onModeChange: setMapMode,
+    autoYear,
+    year: historicalYear,
+    onYearChange: setHistoricalYear,
+    yearBounds
+  };
+  const mediaResolver = useMemo(() => (key) => {
+    const item = Object.prototype.hasOwnProperty.call(story.media, key) ? story.media[key] : void 0;
+    return item ? resolveMedia(key, item) : Promise.resolve(null);
+  }, [story, resolveMedia]);
+  const content = /* @__PURE__ */ jsx4(SlideContent, { slide, story, resolveMedia, colors, strings }, slide?.id ?? index);
+  const timeline = showTimeline && /* @__PURE__ */ jsx4(TimelineStrip, { points: datedSlides, currentIndex: index, onSelect: setIndex, colors });
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      ref: rootRef,
+      lang: story.language,
+      tabIndex: keyboard === "focus" ? 0 : void 0,
+      style: {
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        overflow: "hidden",
+        background: colors.surface,
+        color: colors.text
+      },
+      children: [
+        /* @__PURE__ */ jsx4(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              right: 0,
+              height: BAR_HEIGHT,
+              zIndex: 3,
+              background: dark ? "rgba(20,20,20,0.55)" : "rgba(255,255,255,0.55)"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsxs3(
+          "div",
+          {
+            dir: "auto",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 20,
+              height: BAR_HEIGHT,
+              maxWidth: "26%",
+              zIndex: 3,
+              display: "flex",
+              alignItems: "center",
+              gap: 10,
+              fontWeight: 600
+            },
+            children: [
+              brand && /* @__PURE__ */ jsx4("span", { style: { flex: "none", display: "flex" }, children: brand }),
+              /* @__PURE__ */ jsx4("span", { style: { whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" }, children: story.title })
+            ]
+          }
+        ),
+        firstCenter && /* @__PURE__ */ jsx4(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              right: 0,
+              height: BAR_HEIGHT,
+              zIndex: 3,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              pointerEvents: "none"
+            },
+            children: /* @__PURE__ */ jsx4("div", { style: { pointerEvents: "auto" }, children: renderMapModeControl ? renderMapModeControl(modeControlProps) : /* @__PURE__ */ jsx4(MapModeControl, { ...modeControlProps, strings, colors }) })
+          }
+        ),
+        actions && /* @__PURE__ */ jsx4(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 0,
+              right: onClose ? 60 : 12,
+              height: BAR_HEIGHT,
+              zIndex: 3,
+              display: "flex",
+              alignItems: "center",
+              gap: 8
+            },
+            children: actions
+          }
+        ),
+        onClose && /* @__PURE__ */ jsx4(
+          RoundButton,
+          {
+            label: strings.close,
+            size: 36,
+            onClick: onClose,
+            style: { position: "absolute", top: 10, right: 12, zIndex: 3 },
+            children: "\xD7"
+          }
+        ),
+        firstCenter ? /* @__PURE__ */ jsxs3("div", { style: { position: "absolute", inset: 0 }, children: [
+          /* @__PURE__ */ jsx4(
+            MapBackground,
+            {
+              initialCenter: firstCenter,
+              current: mapSlide,
+              dark,
+              colors,
+              panelFraction: PANEL_FRACTION,
+              ohmYear,
+              resolveMedia: mediaResolver
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            "div",
+            {
+              style: {
+                position: "absolute",
+                top: 0,
+                bottom: 0,
+                right: 0,
+                width: `${PANEL_FRACTION * 100}%`,
+                zIndex: 1,
+                padding: `${BAR_HEIGHT}px 32px ${showTimeline ? TIMELINE_HEIGHT : 32}px`,
+                boxSizing: "border-box",
+                display: "flex",
+                flexDirection: "column",
+                justifyContent: "center",
+                alignItems: "center",
+                gap: 16,
+                overflowY: "auto",
+                // Transparent where the panel starts, mid-screen, and solid
+                // well before the centered content, so text never sits on map.
+                background: `linear-gradient(to right, transparent 0%, ${colors.panel} 22%)`
+              },
+              ...swipeHandlers,
+              children: content
+            }
+          ),
+          /* @__PURE__ */ jsx4(NavArrows, { index, total: slides.length, onPrev: goPrev, onNext: goNext, variant: "edge", strings, colors }),
+          timeline
+        ] }) : /* @__PURE__ */ jsxs3(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              inset: 0,
+              overflowY: "auto",
+              boxSizing: "border-box",
+              padding: `${BAR_HEIGHT + 16}px 24px ${showTimeline ? TIMELINE_HEIGHT + 16 : 24}px`,
+              display: "flex",
+              flexDirection: "column",
+              alignItems: "center",
+              justifyContent: "center",
+              gap: 16
+            },
+            ...swipeHandlers,
+            children: [
+              content,
+              /* @__PURE__ */ jsx4(NavArrows, { index, total: slides.length, onPrev: goPrev, onNext: goNext, variant: "inline", strings, colors }),
+              timeline
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/editor/dates.ts
+import { loadLocale, parseDate, resolveLocaleCode, toEdtf } from "@gramps-connect/gramps-date";
+var suggestEdtf = async (text, language) => {
+  if (!text.trim()) return void 0;
+  const code = language && resolveLocaleCode(language.replace(/-/g, "_")) || "en";
+  if (code !== "en" && !await loadLocale(code)) return void 0;
+  try {
+    return toEdtf(parseDate(text, { locale: code }));
+  } catch {
+    return void 0;
+  }
+};
+
+// src/editor/DateField.tsx
+import { useEffect as useEffect4, useRef as useRef4, useState as useState4 } from "react";
+import { Anchor, Group, Stack, Text, TextInput } from "@mantine/core";
+
+// src/editor/model.ts
+function blankStory(title, language) {
+  return {
+    format: FORMAT_ID,
+    version: FORMAT_VERSION,
+    title,
+    ...language ? { language } : {},
+    slides: [{ id: "s0", title }],
+    media: {}
+  };
+}
+function nextSlideId(doc) {
+  let max = -1;
+  for (const slide of doc.slides) {
+    const match = /^s(\d+)$/.exec(slide.id);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  let n = max + 1;
+  const ids = new Set(doc.slides.map((s) => s.id));
+  while (ids.has(`s${n}`)) n += 1;
+  return `s${n}`;
+}
+function withSlides(doc, slides) {
+  return { ...doc, slides };
+}
+function addSlide(doc, index) {
+  const slides = [...doc.slides];
+  const at = Math.min(Math.max(index + 1, 0), slides.length);
+  slides.splice(at, 0, { id: nextSlideId(doc) });
+  return { doc: withSlides(doc, slides), index: at };
+}
+function duplicateSlide(doc, index) {
+  const slides = [...doc.slides];
+  const copy = structuredClone(slides[index]);
+  copy.id = nextSlideId(doc);
+  slides.splice(index + 1, 0, copy);
+  return { doc: withSlides(doc, slides), index: index + 1 };
+}
+function deleteSlide(doc, index) {
+  if (doc.slides.length <= 1) return { doc, index };
+  const slides = doc.slides.filter((_, i) => i !== index);
+  return { doc: withSlides(doc, slides), index: Math.min(index, slides.length - 1) };
+}
+function moveSlide(doc, from, to) {
+  if (from === to || to < 0 || to >= doc.slides.length) return doc;
+  const slides = [...doc.slides];
+  const [slide] = slides.splice(from, 1);
+  slides.splice(to, 0, slide);
+  return withSlides(doc, slides);
+}
+function patched(base, patch) {
+  const next = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === void 0) delete next[key];
+    else next[key] = value;
+  }
+  return next;
+}
+function updateSlide(doc, index, patch) {
+  const slides = [...doc.slides];
+  slides[index] = patched(slides[index], patch);
+  return withSlides(doc, slides);
+}
+function updateStory(doc, patch) {
+  return patched(doc, patch);
+}
+function slideDate(previous, text, edtf) {
+  if (!text.trim()) return void 0;
+  const next = patched(previous ?? { text }, { text, edtf: edtf || void 0 });
+  if (next.edtf !== previous?.edtf) delete next.sortYear;
+  return next;
+}
+function sameBytes(a, b) {
+  if (!a || a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function findMedia(doc, files, data) {
+  for (const [key, item] of Object.entries(doc.media)) {
+    if (sameBytes(files.get(item.src), data)) return key;
+  }
+  return void 0;
+}
+function addImage(doc, files, image, stem = "photo") {
+  const existing = findMedia(doc, files, image.data);
+  if (existing) return { doc, files, key: existing };
+  let n = 1;
+  const taken = (key2) => Object.prototype.hasOwnProperty.call(doc.media, key2) || files.has(`media/${key2}.${image.ext}`);
+  while (taken(`${stem}-${n}`)) n += 1;
+  const key = `${stem}-${n}`;
+  const src = `media/${key}.${image.ext}`;
+  const item = {
+    src,
+    mime: image.mime,
+    ...image.width ? { width: image.width } : {},
+    ...image.height ? { height: image.height } : {}
+  };
+  return {
+    doc: { ...doc, media: { ...doc.media, [key]: item } },
+    files: new Map(files).set(src, image.data),
+    key
+  };
+}
+function setSlidePhotos(doc, index, media) {
+  return updateSlide(doc, index, { media: media.length ? media : void 0 });
+}
+function updateMedia(doc, key, patch) {
+  if (!Object.prototype.hasOwnProperty.call(doc.media, key)) return doc;
+  return { ...doc, media: { ...doc.media, [key]: patched(doc.media[key], patch) } };
+}
+function usedMedia(doc) {
+  const used = /* @__PURE__ */ new Set();
+  for (const slide of doc.slides) {
+    for (const m of slide.media ?? []) used.add(m.ref);
+    for (const o of slide.place?.overlays ?? []) used.add(o.media);
+  }
+  return used;
+}
+function pruneMedia(doc, files) {
+  const used = usedMedia(doc);
+  const media = Object.fromEntries(Object.entries(doc.media).filter(([key]) => used.has(key)));
+  const srcs = new Set(Object.values(media).map((m) => m.src));
+  return {
+    doc: { ...doc, media },
+    files: new Map([...files].filter(([path]) => srcs.has(path)))
+  };
+}
+function storyFileName(title) {
+  const safe = title.replace(/[\\/:*?"<>|\u0000-\u001f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
+  return `${safe || "story"}.story.zip`;
+}
+var COALESCE_MS = 1500;
+var MAX_STEPS = 200;
+function startHistory(doc) {
+  return { past: [], present: doc, future: [] };
+}
+function record(history, next, key, now = Date.now()) {
+  if (next === history.present) return history;
+  const coalesce = key !== void 0 && key === history.lastKey && history.lastAt !== void 0 && now - history.lastAt < COALESCE_MS;
+  const past = coalesce ? history.past : [...history.past, history.present].slice(-MAX_STEPS);
+  return { past, present: next, future: [], lastKey: key, lastAt: now };
+}
+function undo(history) {
+  const previous = history.past[history.past.length - 1];
+  if (!previous) return history;
+  return { past: history.past.slice(0, -1), present: previous, future: [history.present, ...history.future] };
+}
+function redo(history) {
+  const [next, ...future] = history.future;
+  if (!next) return history;
+  return { past: [...history.past, history.present], present: next, future };
+}
+
+// src/editor/DateField.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function DateField({ value, language, parse, strings, onChange }) {
+  const [following, setFollowing] = useState4(value?.edtf ? null : true);
+  const latest = useRef4(value);
+  latest.current = value;
+  const request = useRef4(0);
+  useEffect4(() => {
+    if (following !== null) return;
+    let live = true;
+    void parse(value?.text ?? "", language).then((edtf2) => {
+      if (live) setFollowing(edtf2 === value?.edtf);
+    });
+    return () => {
+      live = false;
+    };
+  }, []);
+  const follow = (text) => {
+    const id = ++request.current;
+    void parse(text, language).then((edtf2) => {
+      if (id !== request.current || latest.current?.text !== text) return;
+      onChange(slideDate(latest.current, text, edtf2));
+    });
+  };
+  const onText = (text) => {
+    onChange(slideDate(latest.current, text, latest.current?.edtf));
+    if (following !== false) follow(text);
+  };
+  const edtf = value?.edtf ?? "";
+  const understood = !edtf || edtfYearRange(edtf) !== null;
+  let note;
+  if (edtf && !understood) note = strings.preciseDateNotUnderstood;
+  else if (!edtf) note = strings.noPreciseDate;
+  else if (following) note = strings.preciseDateFollows;
+  else note = strings.preciseDateHint;
+  return /* @__PURE__ */ jsxs4(Stack, { gap: 6, children: [
+    /* @__PURE__ */ jsx5(
+      TextInput,
+      {
+        label: strings.date,
+        description: strings.dateHint,
+        value: value?.text ?? "",
+        onChange: (e) => onText(e.currentTarget.value)
+      }
+    ),
+    value?.text && /* @__PURE__ */ jsxs4(Group, { gap: "sm", align: "flex-end", wrap: "nowrap", children: [
+      /* @__PURE__ */ jsx5(
+        TextInput,
+        {
+          label: strings.preciseDate,
+          size: "xs",
+          w: 200,
+          value: edtf,
+          error: !understood,
+          styles: { input: { fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace" } },
+          onChange: (e) => {
+            setFollowing(false);
+            onChange(slideDate(latest.current, latest.current?.text ?? "", e.currentTarget.value.trim() || void 0));
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxs4(Stack, { gap: 0, pb: 4, children: [
+        /* @__PURE__ */ jsx5(Text, { size: "xs", c: understood ? "dimmed" : "red", children: note }),
+        following === false && /* @__PURE__ */ jsx5(Anchor, { component: "button", type: "button", size: "xs", onClick: () => {
+          setFollowing(true);
+          follow(value.text);
+        }, children: strings.matchDateAsWritten })
+      ] })
+    ] })
+  ] });
+}
+
+// src/editor/PhotosField.tsx
+import { useEffect as useEffect5, useRef as useRef5, useState as useState5 } from "react";
+import { ActionIcon, Box, Button, Group as Group2, Loader, Stack as Stack2, Text as Text2, TextInput as TextInput2, Tooltip } from "@mantine/core";
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var imagesIn = (list) => [...list ?? []].filter((f) => f.type.startsWith("image/"));
+function Preview({ mediaKey, urlFor }) {
+  const [url, setUrl] = useState5(null);
+  useEffect5(() => {
+    let live = true;
+    void urlFor(mediaKey).then((u) => {
+      if (live) setUrl(u);
+    });
+    return () => {
+      live = false;
+    };
+  }, [mediaKey, urlFor]);
+  return /* @__PURE__ */ jsx6(Box, { w: 96, h: 96, style: { flex: "none", borderRadius: 6, overflow: "hidden", background: "var(--mantine-color-default-hover)" }, children: url && /* @__PURE__ */ jsx6("img", { src: url, alt: "", style: { width: "100%", height: "100%", objectFit: "cover", display: "block" } }) });
+}
+function PhotosField({ photos, media, urlFor, strings, busy, onChange, onFiles, onDescription }) {
+  const input = useRef5(null);
+  const replacing = useRef5(void 0);
+  const [dropping, setDropping] = useState5(false);
+  const pick = (replace) => {
+    replacing.current = replace;
+    input.current?.click();
+  };
+  const set = (i, patch, field) => {
+    const next = photos.map((p, j) => {
+      if (j !== i) return p;
+      const changed = { ...p, ...patch };
+      for (const [k, v] of Object.entries(patch)) if (!v) delete changed[k];
+      return changed;
+    });
+    onChange(next, `photo:${i}:${field}`);
+  };
+  const move = (from, to) => {
+    const next = [...photos];
+    const [p] = next.splice(from, 1);
+    next.splice(to, 0, p);
+    onChange(next, "photos");
+  };
+  const onDrop = (e) => {
+    e.preventDefault();
+    setDropping(false);
+    const files = imagesIn(e.dataTransfer.files);
+    if (files.length) onFiles(files);
+  };
+  return /* @__PURE__ */ jsxs5(
+    Stack2,
+    {
+      gap: "sm",
+      onDragOver: (e) => {
+        if ([...e.dataTransfer.types].includes("Files")) {
+          e.preventDefault();
+          setDropping(true);
+        }
+      },
+      onDragLeave: (e) => {
+        if (e.currentTarget === e.target) setDropping(false);
+      },
+      onDrop,
+      style: {
+        borderRadius: 8,
+        padding: dropping ? 8 : 0,
+        margin: dropping ? -8 : 0,
+        outline: dropping ? "2px dashed var(--mantine-primary-color-filled)" : void 0
+      },
+      children: [
+        /* @__PURE__ */ jsxs5(Group2, { justify: "space-between", children: [
+          /* @__PURE__ */ jsx6(Text2, { size: "sm", fw: 500, children: strings.photos }),
+          /* @__PURE__ */ jsxs5(Group2, { gap: "xs", children: [
+            busy && /* @__PURE__ */ jsx6(Loader, { size: "xs" }),
+            /* @__PURE__ */ jsxs5(Button, { variant: "default", size: "xs", onClick: () => pick(), disabled: busy, children: [
+              "+ ",
+              strings.addPhoto
+            ] })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx6(
+          "input",
+          {
+            ref: input,
+            type: "file",
+            accept: "image/*",
+            multiple: true,
+            hidden: true,
+            onChange: (e) => {
+              const files = imagesIn(e.currentTarget.files);
+              e.currentTarget.value = "";
+              if (files.length) onFiles(replacing.current === void 0 ? files : files.slice(0, 1), replacing.current);
+            }
+          }
+        ),
+        photos.length === 0 && /* @__PURE__ */ jsx6(Text2, { size: "xs", c: "dimmed", children: strings.photosHint }),
+        photos.map((photo, i) => {
+          const item = Object.prototype.hasOwnProperty.call(media, photo.ref) ? media[photo.ref] : void 0;
+          return /* @__PURE__ */ jsxs5(Group2, { gap: "sm", align: "flex-start", wrap: "nowrap", children: [
+            /* @__PURE__ */ jsxs5(Stack2, { gap: 4, align: "center", children: [
+              /* @__PURE__ */ jsx6(Preview, { mediaKey: photo.ref, urlFor }),
+              /* @__PURE__ */ jsxs5(Group2, { gap: 4, children: [
+                /* @__PURE__ */ jsx6(Tooltip, { label: strings.movePhotoUp, children: /* @__PURE__ */ jsx6(ActionIcon, { size: "sm", variant: "default", "aria-label": strings.movePhotoUp, disabled: i === 0, onClick: () => move(i, i - 1), children: "\u2191" }) }),
+                /* @__PURE__ */ jsx6(Tooltip, { label: strings.movePhotoDown, children: /* @__PURE__ */ jsx6(ActionIcon, { size: "sm", variant: "default", "aria-label": strings.movePhotoDown, disabled: i === photos.length - 1, onClick: () => move(i, i + 1), children: "\u2193" }) })
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs5(Stack2, { gap: 6, style: { flex: 1, minWidth: 0 }, children: [
+              /* @__PURE__ */ jsx6(TextInput2, { size: "xs", label: strings.caption, value: photo.caption ?? "", onChange: (e) => set(i, { caption: e.currentTarget.value }, "caption") }),
+              /* @__PURE__ */ jsx6(TextInput2, { size: "xs", label: strings.credit, placeholder: strings.creditHint, value: photo.credit ?? "", onChange: (e) => set(i, { credit: e.currentTarget.value }, "credit") }),
+              item && /* @__PURE__ */ jsx6(
+                TextInput2,
+                {
+                  size: "xs",
+                  label: strings.description,
+                  description: strings.descriptionHint,
+                  value: item.alt ?? "",
+                  onChange: (e) => onDescription(photo.ref, e.currentTarget.value)
+                }
+              ),
+              /* @__PURE__ */ jsxs5(Group2, { gap: "xs", children: [
+                /* @__PURE__ */ jsx6(Button, { variant: "subtle", size: "compact-xs", onClick: () => pick(i), disabled: busy, children: strings.replacePhoto }),
+                /* @__PURE__ */ jsx6(Button, { variant: "subtle", size: "compact-xs", color: "red", onClick: () => onChange(photos.filter((_, j) => j !== i), "photos"), children: strings.removePhoto })
+              ] })
+            ] })
+          ] }, i);
+        })
+      ]
+    }
+  );
+}
+
+// src/editor/SlideList.tsx
+import { useState as useState6 } from "react";
+import { Stack as Stack3, UnstyledButton } from "@mantine/core";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function SlideList({ items, selected, onSelect, onMove, getKey, renderItem, label }) {
+  const [dragging, setDragging] = useState6(null);
+  const [over, setOver] = useState6(null);
+  const end = () => {
+    setDragging(null);
+    setOver(null);
+  };
+  return /* @__PURE__ */ jsx7(Stack3, { gap: 4, role: "listbox", "aria-label": label, children: items.map((item, i) => {
+    const isSelected = i === selected;
+    const dropLine = over === i && dragging !== null && dragging !== i ? dragging < i ? { borderBottom: "2px solid var(--mantine-primary-color-filled)" } : { borderTop: "2px solid var(--mantine-primary-color-filled)" } : {};
+    return /* @__PURE__ */ jsx7(
+      UnstyledButton,
+      {
+        role: "option",
+        "aria-selected": isSelected,
+        draggable: true,
+        onClick: () => onSelect(i),
+        onDragStart: (e) => {
+          setDragging(i);
+          e.dataTransfer.effectAllowed = "move";
+          e.dataTransfer.setData("text/plain", String(i));
+        },
+        onDragOver: (e) => {
+          if (dragging === null) return;
+          e.preventDefault();
+          setOver(i);
+        },
+        onDrop: (e) => {
+          e.preventDefault();
+          if (dragging !== null && dragging !== i) onMove(dragging, i);
+          end();
+        },
+        onDragEnd: end,
+        style: {
+          display: "block",
+          width: "100%",
+          padding: "6px 8px",
+          borderRadius: 6,
+          background: isSelected ? "var(--mantine-primary-color-light)" : void 0,
+          opacity: dragging === i ? 0.5 : 1,
+          ...dropLine
+        },
+        children: renderItem(item, i)
+      },
+      getKey(item, i)
+    );
+  }) });
+}
+
+// src/editor/StoryTextField.tsx
+import { useRef as useRef6 } from "react";
+import { Button as Button2, Group as Group3, Stack as Stack4, Text as Text3, Textarea } from "@mantine/core";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function applyMarker(el, marker, value, onChange) {
+  const start = el.selectionStart ?? value.length;
+  const end = el.selectionEnd ?? value.length;
+  if (start === end) {
+    onChange(value.slice(0, start) + marker + marker + value.slice(end));
+    requestAnimationFrame(() => {
+      el.focus();
+      el.setSelectionRange(start + marker.length, start + marker.length);
+    });
+    return;
+  }
+  const selected = value.slice(start, end);
+  const alreadyWrapped = selected.length > marker.length * 2 && selected.startsWith(marker) && selected.endsWith(marker);
+  const replacement = alreadyWrapped ? selected.slice(marker.length, selected.length - marker.length) : `${marker}${selected}${marker}`;
+  onChange(value.slice(0, start) + replacement + value.slice(end));
+}
+function StoryTextField({ label, value, onChange, boldLabel = "Bold", italicLabel = "Italic", minRows = 3 }) {
+  const ref = useRef6(null);
+  return /* @__PURE__ */ jsxs6(Stack4, { gap: 4, children: [
+    /* @__PURE__ */ jsxs6(Group3, { gap: "xs", children: [
+      /* @__PURE__ */ jsx8(Text3, { size: "sm", fw: 500, children: label }),
+      /* @__PURE__ */ jsx8(
+        Button2,
+        {
+          variant: "default",
+          size: "compact-xs",
+          fw: 700,
+          "aria-label": boldLabel,
+          title: boldLabel,
+          onClick: () => ref.current && applyMarker(ref.current, "**", value, onChange),
+          children: "B"
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        Button2,
+        {
+          variant: "default",
+          size: "compact-xs",
+          fs: "italic",
+          "aria-label": italicLabel,
+          title: italicLabel,
+          onClick: () => ref.current && applyMarker(ref.current, "*", value, onChange),
+          children: "i"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx8(
+      Textarea,
+      {
+        ref,
+        "aria-label": label,
+        autosize: true,
+        minRows,
+        maxRows: 14,
+        value,
+        onChange: (e) => onChange(e.currentTarget.value)
+      }
+    )
+  ] });
+}
+
+// src/editor/strings.ts
+var EDITOR_ENGLISH = {
+  story: "Story",
+  storySettings: "Title, language and map",
+  title: "Title",
+  language: "Language",
+  languageHint: "The language the story is written in, e.g. en, de or fr-CA. Dates are read in it.",
+  map: "Map",
+  mapStandard: "Today's map",
+  mapHistorical: "Historical maps for each slide's year",
+  mapAuto: "Viewer's choice",
+  mapNone: "No map",
+  slides: "Slides",
+  untitledSlide: "Untitled slide",
+  addSlide: "Add slide",
+  duplicateSlide: "Duplicate",
+  deleteSlide: "Delete",
+  moveUp: "Move up",
+  moveDown: "Move down",
+  slideTitle: "Title",
+  text: "Text",
+  bold: "Bold",
+  italic: "Italic",
+  date: "Date",
+  dateHint: "As readers should see it, e.g. about 1850, 3 May 1850, between 1850 and 1860.",
+  preciseDate: "Precise date (EDTF)",
+  preciseDateHint: "Places the slide on the timeline and picks historical maps.",
+  preciseDateFollows: "Worked out from the date as written.",
+  preciseDateNotUnderstood: "Not a date the timeline can use.",
+  matchDateAsWritten: "Work it out from the date",
+  noPreciseDate: "None: this slide stays off the timeline.",
+  place: "Place",
+  photos: "Photos",
+  photosHint: "Add, drop or paste a photo. It's resized for the screen, and hidden details like camera and location are left out.",
+  addPhoto: "Add photo",
+  replacePhoto: "Replace",
+  movePhotoUp: "Move photo up",
+  movePhotoDown: "Move photo down",
+  removePhoto: "Remove",
+  caption: "Caption",
+  credit: "Credit",
+  creditHint: "Who took it, or where it's from",
+  description: "Description",
+  descriptionHint: "What the photo shows, for anyone who can't see it.",
+  photoFailed: (name) => `Couldn't use ${name}: this browser can't read it as an image.`,
+  undo: "Undo",
+  redo: "Redo",
+  present: "Present",
+  preview: "Preview",
+  problems: (count) => count === 1 ? "1 problem to fix before saving" : `${count} problems to fix before saving`,
+  openingSlide: "Opening slide"
+};
+
+// src/editor/StoryEditor.tsx
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var BAR_HEIGHT2 = 56;
+var STORY = -1;
+function issueSlide(issue) {
+  const match = /^\/slides\/(\d+)/.exec(issue.path);
+  return match ? Number(match[1]) : STORY;
+}
+async function prepareImage(file) {
+  const image = await optimizeImage(file);
+  return { data: new Uint8Array(await image.blob.arrayBuffer()), mime: image.mime, ext: image.ext, width: image.width, height: image.height };
+}
+function Thumb({ doc, slide, resolveMedia }) {
+  const ref = slide.media?.[0]?.ref;
+  const item = ref && Object.prototype.hasOwnProperty.call(doc.media, ref) ? doc.media[ref] : void 0;
+  const [url, setUrl] = useState7(null);
+  useEffect6(() => {
+    let live = true;
+    setUrl(null);
+    if (ref && item) void resolveMedia(ref, item).then((u) => {
+      if (live) setUrl(u);
+    });
+    return () => {
+      live = false;
+    };
+  }, [ref, item, resolveMedia]);
+  return /* @__PURE__ */ jsx9(
+    Box2,
+    {
+      w: 40,
+      h: 40,
+      style: { flex: "none", borderRadius: 4, background: "var(--mantine-color-default-hover)", overflow: "hidden" },
+      children: url && /* @__PURE__ */ jsx9("img", { src: url, alt: "", style: { width: "100%", height: "100%", objectFit: "cover", display: "block" } })
+    }
+  );
+}
+function StoryEditor({
+  initialStory,
+  initialFiles,
+  onChange,
+  prepareImage: prepare = prepareImage,
+  toolbar,
+  brand,
+  dark = false,
+  strings: stringOverrides,
+  playerStrings,
+  parseDateText = suggestEdtf
+}) {
+  const strings = useMemo2(() => ({ ...EDITOR_ENGLISH, ...stringOverrides }), [stringOverrides]);
+  const [history, setHistory] = useState7(() => startHistory(initialStory));
+  const [selected, setSelected] = useState7(0);
+  const [presenting, setPresenting] = useState7(false);
+  const [problemsOpen, setProblemsOpen] = useState7(false);
+  const wide = useMediaQuery("(min-width: 1000px)", true);
+  const doc = history.present;
+  const [files, setFiles] = useState7(() => new Map(initialFiles ?? []));
+  const [busy, setBusy] = useState7(false);
+  const [photoError, setPhotoError] = useState7(null);
+  const docRef = useRef7(doc);
+  docRef.current = doc;
+  const filesRef = useRef7(files);
+  filesRef.current = files;
+  const urls = useRef7(/* @__PURE__ */ new Map());
+  useEffect6(() => () => {
+    for (const url of urls.current.values()) URL.revokeObjectURL(url);
+  }, []);
+  const resolveMedia = useCallback(async (_key, item) => {
+    const cached = urls.current.get(item.src);
+    if (cached) return cached;
+    const data = filesRef.current.get(item.src);
+    if (!data) return null;
+    const url = URL.createObjectURL(new Blob([data], { type: item.mime }));
+    urls.current.set(item.src, url);
+    return url;
+  }, []);
+  const urlFor = useCallback((key) => {
+    const item = Object.prototype.hasOwnProperty.call(docRef.current.media, key) ? docRef.current.media[key] : void 0;
+    return item ? resolveMedia(key, item) : Promise.resolve(null);
+  }, [resolveMedia]);
+  const apply = useCallback((next, key) => {
+    setHistory((h) => record(h, next, key));
+  }, []);
+  useEffect6(() => {
+    onChange?.(doc, files);
+  }, [doc, files, onChange]);
+  const index = selected === STORY ? STORY : Math.min(selected, doc.slides.length - 1);
+  const slide = index === STORY ? void 0 : doc.slides[index];
+  const setSlide = (patch, key) => {
+    if (index !== STORY) apply(updateSlide(history.present, index, patch), `${slide.id}:${key}`);
+  };
+  const issues = useMemo2(() => validate2(doc, files).errors, [doc, files]);
+  const addPhotos = useCallback(async (chosen, slideId2, replace) => {
+    setBusy(true);
+    setPhotoError(null);
+    const chosenImages = [];
+    for (const file of chosen) {
+      try {
+        const known = findMedia(docRef.current, filesRef.current, new Uint8Array(await file.arrayBuffer()));
+        chosenImages.push(known ?? await prepare(file));
+      } catch {
+        setPhotoError(strings.photoFailed(file.name || "the image"));
+      }
+    }
+    setBusy(false);
+    if (!chosenImages.length) return;
+    let next = docRef.current;
+    let nextFiles = filesRef.current;
+    const keys = [];
+    for (const image of chosenImages) {
+      if (typeof image === "string") {
+        keys.push(image);
+        continue;
+      }
+      const added = addImage(next, nextFiles, image);
+      next = added.doc;
+      nextFiles = added.files;
+      keys.push(added.key);
+    }
+    const at = next.slides.findIndex((s) => s.id === slideId2);
+    if (at < 0) return;
+    const photos = [...next.slides[at].media ?? []];
+    if (replace !== void 0 && photos[replace]) photos[replace] = { ...photos[replace], ref: keys[0] };
+    else photos.push(...keys.map((ref) => ({ ref })));
+    setFiles(nextFiles);
+    apply(setSlidePhotos(next, at, photos));
+  }, [apply, prepare, strings]);
+  const slideId = slide?.id;
+  useEffect6(() => {
+    if (!slideId) return;
+    const onPaste = (e) => {
+      if (e.target?.closest("input, textarea, [contenteditable=true]")) return;
+      const images = [...e.clipboardData?.files ?? []].filter((f) => f.type.startsWith("image/"));
+      if (!images.length) return;
+      e.preventDefault();
+      void addPhotos(images, slideId);
+    };
+    window.addEventListener("paste", onPaste);
+    return () => window.removeEventListener("paste", onPaste);
+  }, [slideId, addPhotos]);
+  useEffect6(() => {
+    const onKey = (e) => {
+      if (!(e.ctrlKey || e.metaKey) || e.altKey) return;
+      const target = e.target;
+      if (target?.closest("input, textarea, [contenteditable=true]")) return;
+      const key = e.key.toLowerCase();
+      if (key === "z" && !e.shiftKey) {
+        e.preventDefault();
+        setHistory(undo);
+      } else if (key === "z" && e.shiftKey || key === "y") {
+        e.preventDefault();
+        setHistory(redo);
+      }
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, []);
+  const slideActions = slide && /* @__PURE__ */ jsxs7(Group4, { gap: 6, children: [
+    /* @__PURE__ */ jsx9(Tooltip2, { label: strings.moveUp, children: /* @__PURE__ */ jsx9(
+      ActionIcon2,
+      {
+        variant: "default",
+        "aria-label": strings.moveUp,
+        disabled: index === 0,
+        onClick: () => {
+          apply(moveSlide(doc, index, index - 1));
+          setSelected(index - 1);
+        },
+        children: "\u2191"
+      }
+    ) }),
+    /* @__PURE__ */ jsx9(Tooltip2, { label: strings.moveDown, children: /* @__PURE__ */ jsx9(
+      ActionIcon2,
+      {
+        variant: "default",
+        "aria-label": strings.moveDown,
+        disabled: index === doc.slides.length - 1,
+        onClick: () => {
+          apply(moveSlide(doc, index, index + 1));
+          setSelected(index + 1);
+        },
+        children: "\u2193"
+      }
+    ) }),
+    /* @__PURE__ */ jsx9(Button3, { variant: "default", size: "xs", onClick: () => {
+      const r = duplicateSlide(doc, index);
+      apply(r.doc);
+      setSelected(r.index);
+    }, children: strings.duplicateSlide }),
+    /* @__PURE__ */ jsx9(
+      Button3,
+      {
+        variant: "default",
+        size: "xs",
+        color: "red",
+        disabled: doc.slides.length <= 1,
+        onClick: () => {
+          const r = deleteSlide(doc, index);
+          apply(r.doc);
+          setSelected(r.index);
+        },
+        children: strings.deleteSlide
+      }
+    )
+  ] });
+  const storyForm = /* @__PURE__ */ jsxs7(Stack5, { gap: "md", children: [
+    /* @__PURE__ */ jsx9(Text4, { fw: 600, size: "lg", children: strings.story }),
+    /* @__PURE__ */ jsx9(
+      TextInput3,
+      {
+        label: strings.title,
+        required: true,
+        value: doc.title,
+        onChange: (e) => apply(updateStory(doc, { title: e.currentTarget.value }), "story:title")
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      TextInput3,
+      {
+        label: strings.language,
+        description: strings.languageHint,
+        w: 260,
+        value: doc.language ?? "",
+        onChange: (e) => apply(updateStory(doc, { language: e.currentTarget.value.trim() || void 0 }), "story:language")
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      Select,
+      {
+        label: strings.map,
+        w: 320,
+        allowDeselect: false,
+        data: [
+          { value: "auto", label: strings.mapAuto },
+          { value: "standard", label: strings.mapStandard },
+          { value: "historical", label: strings.mapHistorical },
+          { value: "none", label: strings.mapNone }
+        ],
+        value: doc.presentation?.basemap ?? "auto",
+        onChange: (value) => value && apply(updateStory(doc, {
+          presentation: { ...doc.presentation, basemap: value }
+        }))
+      }
+    )
+  ] });
+  const slideForm = slide && /* @__PURE__ */ jsxs7(Stack5, { gap: "md", children: [
+    /* @__PURE__ */ jsxs7(Group4, { justify: "space-between", wrap: "wrap", gap: "xs", children: [
+      /* @__PURE__ */ jsx9(Text4, { fw: 600, size: "lg", children: index === 0 ? strings.openingSlide : `${index + 1} / ${doc.slides.length}` }),
+      slideActions
+    ] }),
+    /* @__PURE__ */ jsx9(
+      TextInput3,
+      {
+        label: strings.slideTitle,
+        value: slide.title ?? "",
+        onChange: (e) => setSlide({ title: e.currentTarget.value || void 0 }, "title")
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      DateField,
+      {
+        value: slide.date,
+        language: doc.language,
+        parse: parseDateText,
+        strings,
+        onChange: (date) => setSlide({ date }, "date")
+      }
+    ),
+    /* @__PURE__ */ jsx9(
+      StoryTextField,
+      {
+        label: strings.text,
+        value: slide.text ?? "",
+        boldLabel: strings.bold,
+        italicLabel: strings.italic,
+        minRows: 5,
+        onChange: (text) => setSlide({ text: text || void 0 }, "text")
+      }
+    ),
+    slide.place && /* @__PURE__ */ jsxs7(Stack5, { gap: 2, children: [
+      /* @__PURE__ */ jsx9(Text4, { size: "sm", fw: 500, children: strings.place }),
+      /* @__PURE__ */ jsxs7(Text4, { size: "sm", children: [
+        slide.place.name ?? "",
+        slide.place.lat !== void 0 && slide.place.lon !== void 0 && /* @__PURE__ */ jsxs7(Text4, { span: true, c: "dimmed", size: "sm", children: [
+          " ",
+          slide.place.lat.toFixed(4),
+          ", ",
+          slide.place.lon.toFixed(4)
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx9(
+      PhotosField,
+      {
+        photos: slide.media ?? [],
+        media: doc.media,
+        urlFor,
+        strings,
+        busy,
+        onChange: (photos, key) => apply(setSlidePhotos(doc, index, photos), `${slide.id}:${key}`),
+        onFiles: (chosen, replace) => void addPhotos(chosen, slide.id, replace),
+        onDescription: (key, alt) => apply(updateMedia(doc, key, { alt: alt || void 0 }), `media:${key}:alt`)
+      }
+    ),
+    photoError && /* @__PURE__ */ jsx9(Text4, { size: "xs", c: "red", role: "alert", children: photoError })
+  ] }, slide.id);
+  const list = /* @__PURE__ */ jsxs7(Stack5, { gap: "xs", children: [
+    /* @__PURE__ */ jsxs7(
+      UnstyledButton2,
+      {
+        onClick: () => setSelected(STORY),
+        style: { padding: "8px", borderRadius: 6, background: index === STORY ? "var(--mantine-primary-color-light)" : void 0 },
+        children: [
+          /* @__PURE__ */ jsx9(Text4, { fw: 600, size: "sm", children: strings.story }),
+          /* @__PURE__ */ jsx9(Text4, { size: "xs", c: "dimmed", children: strings.storySettings })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx9(Divider, { label: strings.slides, labelPosition: "left" }),
+    /* @__PURE__ */ jsx9(
+      SlideList,
+      {
+        label: strings.slides,
+        items: doc.slides,
+        selected: index,
+        onSelect: setSelected,
+        onMove: (from, to) => {
+          apply(moveSlide(doc, from, to));
+          setSelected(to);
+        },
+        getKey: (s) => s.id,
+        renderItem: (s, i) => /* @__PURE__ */ jsxs7(Group4, { gap: "sm", wrap: "nowrap", children: [
+          /* @__PURE__ */ jsx9(Thumb, { doc, slide: s, resolveMedia }),
+          /* @__PURE__ */ jsxs7(Box2, { style: { minWidth: 0 }, children: [
+            /* @__PURE__ */ jsx9(Text4, { size: "sm", fw: 500, truncate: true, dir: "auto", c: s.title ? void 0 : "dimmed", children: s.title || strings.untitledSlide }),
+            /* @__PURE__ */ jsx9(Text4, { size: "xs", c: "dimmed", truncate: true, children: i === 0 ? strings.openingSlide : s.date?.text ?? "" })
+          ] })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsxs7(
+      Button3,
+      {
+        variant: "light",
+        size: "xs",
+        mt: 4,
+        onClick: () => {
+          const r = addSlide(doc, index === STORY ? doc.slides.length - 1 : index);
+          apply(r.doc);
+          setSelected(r.index);
+        },
+        children: [
+          "+ ",
+          strings.addSlide
+        ]
+      }
+    )
+  ] });
+  const preview = /* @__PURE__ */ jsx9(Box2, { style: { position: "relative", height: wide ? "100%" : 460, borderRadius: 8, overflow: "hidden", border: "1px solid var(--mantine-color-default-border)" }, children: /* @__PURE__ */ jsx9(
+    StoryPlayer,
+    {
+      story: doc,
+      resolveMedia,
+      dark,
+      strings: playerStrings,
+      keyboard: false,
+      initialSlide: index === STORY ? 0 : index,
+      onSlideChange: (i) => {
+        if (i !== index && index !== STORY) setSelected(i);
+      }
+    }
+  ) });
+  const column = (children, width) => /* @__PURE__ */ jsx9(
+    Box2,
+    {
+      style: {
+        width,
+        flex: width ? "none" : 1,
+        minWidth: 0,
+        padding: 16,
+        overflowY: wide ? "auto" : void 0,
+        height: wide ? "100%" : void 0
+      },
+      children
+    }
+  );
+  return /* @__PURE__ */ jsxs7(Box2, { style: { height: "100%", display: "flex", flexDirection: "column" }, children: [
+    /* @__PURE__ */ jsxs7(
+      Group4,
+      {
+        h: BAR_HEIGHT2,
+        px: "md",
+        gap: "sm",
+        wrap: "nowrap",
+        justify: "space-between",
+        style: { flex: "none", borderBottom: "1px solid var(--mantine-color-default-border)" },
+        children: [
+          /* @__PURE__ */ jsxs7(Group4, { gap: "sm", wrap: "nowrap", style: { minWidth: 0 }, children: [
+            brand,
+            /* @__PURE__ */ jsx9(Text4, { fw: 600, truncate: true, dir: "auto", children: doc.title })
+          ] }),
+          /* @__PURE__ */ jsxs7(Group4, { gap: "xs", wrap: "nowrap", children: [
+            issues.length > 0 && /* @__PURE__ */ jsxs7(Popover, { opened: problemsOpen, onChange: setProblemsOpen, width: 360, position: "bottom-end", withArrow: true, children: [
+              /* @__PURE__ */ jsx9(Popover.Target, { children: /* @__PURE__ */ jsx9(Badge, { color: "red", variant: "light", style: { cursor: "pointer" }, onClick: () => setProblemsOpen((o) => !o), children: strings.problems(issues.length) }) }),
+              /* @__PURE__ */ jsx9(Popover.Dropdown, { children: /* @__PURE__ */ jsx9(Stack5, { gap: 6, children: issues.map((issue, i) => {
+                const at = issueSlide(issue);
+                return /* @__PURE__ */ jsxs7(UnstyledButton2, { onClick: () => {
+                  setSelected(at);
+                  setProblemsOpen(false);
+                }, children: [
+                  /* @__PURE__ */ jsx9(Text4, { size: "sm", fw: 500, children: at === STORY ? strings.story : doc.slides[at]?.title || `${strings.untitledSlide} ${at + 1}` }),
+                  /* @__PURE__ */ jsxs7(Text4, { size: "xs", c: "dimmed", children: [
+                    issue.path,
+                    " ",
+                    issue.message
+                  ] })
+                ] }, i);
+              }) }) })
+            ] }),
+            /* @__PURE__ */ jsx9(Tooltip2, { label: strings.undo, children: /* @__PURE__ */ jsx9(ActionIcon2, { variant: "default", size: "lg", "aria-label": strings.undo, disabled: history.past.length === 0, onClick: () => setHistory(undo), children: "\u21B6" }) }),
+            /* @__PURE__ */ jsx9(Tooltip2, { label: strings.redo, children: /* @__PURE__ */ jsx9(ActionIcon2, { variant: "default", size: "lg", "aria-label": strings.redo, disabled: history.future.length === 0, onClick: () => setHistory(redo), children: "\u21B7" }) }),
+            /* @__PURE__ */ jsx9(Button3, { variant: "default", onClick: () => setPresenting(true), children: strings.present }),
+            toolbar
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs7(
+      Box2,
+      {
+        style: {
+          flex: 1,
+          minHeight: 0,
+          display: "flex",
+          flexDirection: wide ? "row" : "column",
+          overflowY: wide ? void 0 : "auto"
+        },
+        children: [
+          column(list, wide ? 280 : void 0),
+          column(index === STORY ? storyForm : slideForm, wide ? "min(520px, 36%)" : void 0),
+          column(preview)
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx9(Modal, { opened: presenting, onClose: () => setPresenting(false), fullScreen: true, withCloseButton: false, padding: 0, children: /* @__PURE__ */ jsx9(Box2, { style: { position: "fixed", inset: 0 }, children: /* @__PURE__ */ jsx9(
+      StoryPlayer,
+      {
+        story: doc,
+        resolveMedia,
+        dark,
+        strings: playerStrings,
+        initialSlide: index === STORY ? 0 : index,
+        onClose: () => setPresenting(false)
+      }
+    ) }) })
+  ] });
+}
+export {
+  COALESCE_MS,
+  DateField,
+  EDITOR_ENGLISH,
+  PhotosField,
+  SlideList,
+  StoryEditor,
+  StoryTextField,
+  addImage,
+  addSlide,
+  blankStory,
+  deleteSlide,
+  duplicateSlide,
+  findMedia,
+  moveSlide,
+  nextSlideId,
+  prepareImage,
+  pruneMedia,
+  record,
+  redo,
+  setSlidePhotos,
+  slideDate,
+  startHistory,
+  storyFileName,
+  suggestEdtf,
+  undo,
+  updateMedia,
+  updateSlide,
+  updateStory,
+  usedMedia
+};
+//# sourceMappingURL=editor.js.map