@mango-iiif/av 0.0.1

package/dist/chunk-R4OUWZ3R.js

@@ -0,0 +1,1038 @@
+// src/types.ts
+var defaultStrings = {
+  chapters: "Chapters",
+  transcript: "Transcript",
+  annotations: "Annotations",
+  metadata: "Metadata",
+  files: "Files",
+  rights: "Rights",
+  previous: "Previous",
+  next: "Next",
+  previousSection: "Previous section",
+  nextSection: "Next section",
+  autoAdvance: "Auto-advance",
+  mediaPlayer: "Media player",
+  mediaSource: "Media source",
+  mediaInformation: "Media information",
+  download: "Download",
+  downloadMediaFile: "Download media file",
+  searchTranscript: "Search transcript",
+  transcriptSearchMatches: "Transcript search matches",
+  searchMatchAt: "Search match at {time}",
+  resumePrompt: "Resume from {time}?",
+  resume: "Resume",
+  startOver: "Start over",
+  loadingManifest: "Loading IIIF manifest\u2026",
+  loadingTranscript: "Loading transcript\u2026",
+  unableToLoadPlayer: "Unable to load the player.",
+  unableToLoadMedia: "Unable to load media.",
+  noMediaLoaded: "No media loaded",
+  noPlayableMedia: "No playable audio or video source",
+  noManifest: "No manifest is loaded.",
+  noTranscript: "No transcript is available.",
+  noAnnotations: "No annotations are available.",
+  noMetadata: "No metadata is available.",
+  noChapters: "No structured navigation is available.",
+  noSupplementalFiles: "No supplemental files are available.",
+  autoSource: "Auto",
+  sourceNumber: "Source {number}",
+  transcriptNumber: "Transcript {number}",
+  sectionNumber: "Section {number}",
+  chapterNumber: "Chapter {number}",
+  untitledManifest: "Untitled manifest",
+  unableToLoadManifest: "Unable to load IIIF manifest ({status} {statusText}).",
+  expectedManifest: "Expected a IIIF Manifest, received {type}.",
+  manifestWithoutCanvases: "The IIIF Manifest does not contain any Canvases."
+};
+var defaultConfig = {
+  controls: {
+    seek: true,
+    volume: true,
+    captions: true,
+    playbackRate: true,
+    pictureInPicture: true,
+    fullscreen: true,
+    sourceSelector: true,
+    download: false,
+    skipSeconds: 10
+  },
+  panels: {
+    chapters: true,
+    transcript: true,
+    annotations: true,
+    metadata: true,
+    supplementalFiles: true
+  },
+  transcript: {
+    autoScroll: true,
+    search: true,
+    download: true,
+    showNotes: false,
+    showMetadata: false,
+    showSearchMarkers: true
+  },
+  resume: {
+    enabled: false,
+    maxItems: 200,
+    ttlDays: 30,
+    prompt: true
+  },
+  strings: defaultStrings,
+  preferredLanguages: ["en", "none"],
+  autoAdvance: false,
+  repeat: false,
+  activePanel: "chapters",
+  crossorigin: "anonymous",
+  preload: "metadata",
+  playbackRates: [0.5, 0.75, 1, 1.25, 1.5, 2]
+};
+
+// src/utils.ts
+var asObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var asArray = (value) => {
+  if (value === null || value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+};
+var readId = (value) => {
+  if (typeof value === "string") return value;
+  const object = asObject(value);
+  const id = object?.id ?? object?.["@id"];
+  return typeof id === "string" ? id : void 0;
+};
+var readType = (value) => {
+  const object = asObject(value);
+  const type = object?.type ?? object?.["@type"];
+  return typeof type === "string" ? type : void 0;
+};
+var languageValues = (value) => {
+  if (typeof value === "string") return [{ value }];
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => languageValues(item));
+  }
+  const object = asObject(value);
+  if (!object) return [];
+  if (typeof object["@value"] === "string") {
+    const result = { value: object["@value"] };
+    if (typeof object["@language"] === "string") result.language = object["@language"];
+    return [result];
+  }
+  return Object.entries(object).flatMap(
+    ([language, values]) => asArray(values).flatMap(
+      (item) => typeof item === "string" ? [{ language, value: item }] : languageValues(item).map((entry) => ({ ...entry, language: entry.language ?? language }))
+    )
+  );
+};
+var label = (value, preferredLanguages = ["en", "none"], fallback = "") => {
+  const values = languageValues(value);
+  for (const language of preferredLanguages) {
+    const match = values.find((item) => item.language === language);
+    if (match) return match.value;
+  }
+  return values[0]?.value ?? fallback;
+};
+var parseTime = (value) => {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (!value) return void 0;
+  if (/^\d+(?:\.\d+)?$/.test(value)) return Number(value);
+  const parts = value.replace(",", ".").split(":").map(Number);
+  if (parts.some((part) => !Number.isFinite(part))) return void 0;
+  if (parts.length === 3) return (parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0);
+  if (parts.length === 2) return (parts[0] ?? 0) * 60 + (parts[1] ?? 0);
+  return void 0;
+};
+var parseTemporalFragment = (target) => {
+  let fragment;
+  if (typeof target === "string") fragment = target.split("#")[1];
+  const object = asObject(target);
+  if (!fragment && object) {
+    const selector = asObject(object.selector);
+    const value = selector?.value;
+    if (typeof value === "string") fragment = value.replace(/^#/, "");
+    if (selector?.type === "PointSelector" && typeof selector.t === "number") {
+      return { start: selector.t };
+    }
+  }
+  const time = fragment?.match(/(?:^|&)t=([^&]+)/)?.[1];
+  if (!time) return void 0;
+  const [startValue, endValue] = time.split(",");
+  const start = parseTime(startValue);
+  const end = parseTime(endValue);
+  if (start === void 0) return void 0;
+  return end === void 0 ? { start } : { start, end };
+};
+var withoutFragment = (value) => value.split("#")[0] ?? value;
+var isHls = (src, format) => /(?:\.m3u8)(?:$|[?#])/i.test(src) || format === "application/vnd.apple.mpegurl" || format === "application/x-mpegURL";
+var mediaKind = (type, format, src = "") => {
+  const haystack = `${type ?? ""} ${format ?? ""} ${src}`.toLowerCase();
+  if (/\baudio\b|\.mp3(?:$|[?#])|\.m4a(?:$|[?#])|\.wav(?:$|[?#])|\.aac(?:$|[?#])/.test(haystack)) return "audio";
+  if (/\bvideo\b|\.mp4(?:$|[?#])|\.webm(?:$|[?#])|\.m3u8(?:$|[?#])|mpegurl/.test(haystack)) return "video";
+  return void 0;
+};
+var formatTime = (seconds) => {
+  if (!Number.isFinite(seconds)) return "0:00";
+  const value = Math.max(0, Math.floor(seconds));
+  const hours = Math.floor(value / 3600);
+  const minutes = Math.floor(value % 3600 / 60);
+  const remaining = value % 60;
+  return hours > 0 ? `${hours}:${String(minutes).padStart(2, "0")}:${String(remaining).padStart(2, "0")}` : `${minutes}:${String(remaining).padStart(2, "0")}`;
+};
+var resolveStrings = (strings2 = {}) => ({
+  ...defaultStrings,
+  ...strings2
+});
+var formatString = (template, values = {}) => template.replace(
+  /\{(\w+)\}/g,
+  (placeholder, name) => Object.prototype.hasOwnProperty.call(values, name) ? String(values[name]) : placeholder
+);
+var mergeConfig = (base, update) => {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(update)) {
+    if (value !== void 0 && asObject(value) && asObject(result[key])) {
+      result[key] = mergeConfig(
+        asObject(result[key]),
+        asObject(value)
+      );
+    } else if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+};
+var escapeHtml = (value) => value.replace(/[&<>'"]/g, (character) => ({
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  "'": "&#039;",
+  '"': "&quot;"
+})[character] ?? character);
+
+// src/iiif/normalize.ts
+var strings = (value) => asArray(value).flatMap((item) => typeof item === "string" ? [item] : []);
+var number = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var readFormat = (object) => typeof object.format === "string" ? object.format : void 0;
+var metadata = (value, languages, ui) => asArray(value).flatMap((item) => {
+  const object = asObject(item);
+  if (!object) return [];
+  const values = languageValues(object.value);
+  if (values.length === 0) return [];
+  return [{ label: label(object.label, languages, ui.metadata), values }];
+});
+var downloads = (value, languages, ui) => asArray(value).flatMap((item) => {
+  const object = asObject(item);
+  const id = readId(item);
+  if (!object || !id) return [];
+  const result = {
+    id,
+    label: label(object.label, languages, id.split("/").pop() ?? ui.download)
+  };
+  const format = readFormat(object);
+  if (format) result.format = format;
+  const filename = typeof object.filename === "string" ? object.filename : void 0;
+  if (filename) result.filename = filename;
+  return [result];
+});
+var services = (value, languages) => asArray(value).flatMap((item) => {
+  const object = asObject(item);
+  const id = readId(item);
+  if (!object || !id) return [];
+  const profile = typeof object.profile === "string" ? object.profile : void 0;
+  const type = `${readType(object) ?? ""} ${profile ?? ""}`.toLowerCase();
+  let serviceType = "unknown";
+  if (type.includes("probe")) serviceType = "probe";
+  else if (type.includes("token")) serviceType = "token";
+  else if (type.includes("logout")) serviceType = "logout";
+  else if (type.includes("access") || type.includes("login") || type.includes("clickthrough") || type.includes("kiosk")) serviceType = "access";
+  const result = {
+    id,
+    serviceType,
+    services: services(object.service, languages)
+  };
+  if (profile) result.profile = profile;
+  const serviceLabel = label(object.label, languages);
+  if (serviceLabel) result.label = serviceLabel;
+  return [result];
+});
+var firstContentId = (canvasValue) => {
+  const canvas = asObject(canvasValue);
+  if (!canvas) return void 0;
+  const v3Page = asObject(asArray(canvas.items)[0]);
+  const v3Annotation = asObject(asArray(v3Page?.items)[0]);
+  const v3Body = asObject(asArray(v3Annotation?.body)[0]);
+  const v2Annotation = asObject(asArray(canvas.images)[0]);
+  const v2Body = asObject(v2Annotation?.resource);
+  return readId(v3Body) ?? readId(v2Body);
+};
+var bodyItems = (body) => {
+  const values = asArray(body).flatMap((item) => {
+    const object = asObject(item);
+    if (!object) return [];
+    const type = readType(object)?.toLowerCase();
+    if (type?.includes("choice") || Array.isArray(object.items) || Array.isArray(object.item)) {
+      return asArray(object.items ?? object.item ?? object.default).flatMap((choice) => {
+        const choiceObject = asObject(choice);
+        return choiceObject ? [choiceObject] : [];
+      });
+    }
+    return [object];
+  });
+  return values;
+};
+var sourceFromBody = (body, canvas, target, languages, index, ui, annotationTimeMode) => {
+  const originalId = readId(body);
+  if (!originalId) return void 0;
+  const format = readFormat(body);
+  const kind = mediaKind(readType(body), format, originalId);
+  if (!kind) return void 0;
+  const result = {
+    id: originalId,
+    src: withoutFragment(originalId),
+    kind,
+    isHls: isHls(originalId, format)
+  };
+  if (format) result.format = format;
+  const bodyLabel = label(body.label, languages, index === 0 ? ui.autoSource : formatString(ui.sourceNumber, { number: index + 1 }));
+  if (bodyLabel) result.label = bodyLabel;
+  const width = number(body.width) ?? number(canvas.width);
+  const height = number(body.height) ?? number(canvas.height);
+  const duration = number(body.duration) ?? number(canvas.duration);
+  if (width !== void 0) result.width = width;
+  if (height !== void 0) result.height = height;
+  if (duration !== void 0) result.duration = duration;
+  const quality = typeof body.quality === "string" ? body.quality : void 0;
+  if (quality) result.quality = quality;
+  const segment = parseTemporalFragment(originalId);
+  if (segment) result.segment = segment;
+  const canvasTarget = parseTemporalFragment(target);
+  if (canvasTarget) result.canvasTarget = canvasTarget;
+  const timeMode = body.timeMode ?? annotationTimeMode;
+  if (timeMode === "trim" || timeMode === "scale" || timeMode === "loop") result.timeMode = timeMode;
+  return result;
+};
+var textualBodies = (body) => bodyItems(body).filter((item) => {
+  const type = readType(item)?.toLowerCase();
+  return type?.includes("textualbody") || typeof item.value === "string";
+});
+var annotationMotivations = (annotation) => strings(annotation.motivation);
+var annotationFrom = (value, canvasId, pageId, languages, index) => {
+  const annotation = asObject(value);
+  if (!annotation) return void 0;
+  const bodies = textualBodies(annotation.body ?? annotation.resource);
+  const text = bodies.flatMap((body) => typeof body.value === "string" ? [body.value] : languageValues(body.chars).map((entry) => entry.value)).join("\n");
+  if (!text) return void 0;
+  const motivation = annotationMotivations(annotation);
+  const purpose = bodies.flatMap((body) => strings(body.purpose));
+  const tags = bodies.filter((body) => strings(body.purpose).includes("tagging")).flatMap((body) => typeof body.value === "string" ? [body.value] : []);
+  const id = readId(annotation) ?? `${canvasId}/annotation/${index}`;
+  const result = {
+    id,
+    canvasId,
+    motivation,
+    purpose,
+    text,
+    tags
+  };
+  const annotationLabel = label(annotation.label, languages);
+  if (annotationLabel) result.label = annotationLabel;
+  const time = parseTemporalFragment(annotation.target ?? annotation.on);
+  if (time) result.time = time;
+  if (pageId) result.sourcePageId = pageId;
+  return result;
+};
+var classifySupplement = (body, annotation, canvasId, languages, index, ui) => {
+  const id = readId(body);
+  if (!id) return {};
+  const format = readFormat(body);
+  const bodyLabel = label(body.label, languages, formatString(ui.transcriptNumber, { number: index + 1 }));
+  const language = typeof body.language === "string" ? body.language : void 0;
+  const purpose = strings(body.purpose);
+  const lower = `${bodyLabel} ${id} ${purpose.join(" ")}`.toLowerCase();
+  const isTimedTrack = format === "text/vtt" || /\.vtt(?:$|[?#])/.test(id);
+  let kind = "subtitles";
+  if (lower.includes("caption")) kind = "captions";
+  if (lower.includes("description")) kind = "descriptions";
+  const result = {};
+  if (isTimedTrack) {
+    const track = { id, src: id, kind, label: bodyLabel };
+    if (language) track.language = language;
+    if (format) track.format = format;
+    if (lower.includes("forced")) track.forced = true;
+    result.track = track;
+  }
+  const transcript = {
+    id: `${canvasId}/transcript/${index}`,
+    src: id,
+    label: bodyLabel,
+    machineGenerated: /\(machine[ -]generated\)/i.test(bodyLabel)
+  };
+  if (format) transcript.format = format;
+  if (language) transcript.language = language;
+  result.transcript = transcript;
+  return result;
+};
+var annotationPageItems = (page) => asArray(page.items ?? page.resources);
+var collectSupplementing = (pages, canvasId, languages, ui) => {
+  const tracks = [];
+  const transcripts = [];
+  const annotations = [];
+  let index = 0;
+  for (const page of pages) {
+    const pageId = readId(page);
+    for (const item of annotationPageItems(page)) {
+      const annotation = asObject(item);
+      if (!annotation) continue;
+      const motivations = annotationMotivations(annotation);
+      const normalizedAnnotation = annotationFrom(annotation, canvasId, pageId, languages, index);
+      if (normalizedAnnotation) annotations.push(normalizedAnnotation);
+      for (const body of bodyItems(annotation.body ?? annotation.resource)) {
+        const bodyId = readId(body);
+        if (bodyId && (motivations.includes("supplementing") || motivations.includes("transcribing") || motivations.length === 0)) {
+          const supplement = classifySupplement(body, annotation, canvasId, languages, index, ui);
+          if (supplement.track) tracks.push(supplement.track);
+          if (supplement.transcript) transcripts.push(supplement.transcript);
+        }
+      }
+      const inline = textualBodies(annotation.body ?? annotation.resource);
+      if (inline.length > 0 && (motivations.includes("supplementing") || motivations.includes("transcribing"))) {
+        const cues = inline.flatMap((body, bodyIndex) => {
+          const text = typeof body.value === "string" ? body.value : label(body.chars, languages);
+          if (!text) return [];
+          const cue = {
+            id: `${readId(annotation) ?? `${canvasId}/annotation/${index}`}/cue/${bodyIndex}`,
+            text,
+            type: "cue"
+          };
+          const time = parseTemporalFragment(annotation.target ?? annotation.on);
+          if (time) {
+            cue.start = time.start;
+            if (time.end !== void 0) cue.end = time.end;
+          }
+          return [cue];
+        });
+        if (cues.length > 0) {
+          transcripts.push({
+            id: `${pageId ?? canvasId}/inline-transcript`,
+            label: label(page.label, languages, ui.transcript),
+            machineGenerated: false,
+            cues
+          });
+        }
+      }
+      index += 1;
+    }
+  }
+  return { tracks, transcripts, annotations };
+};
+var paintingAnnotations = (canvas, version) => {
+  if (version === 2) {
+    return asArray(canvas.images).flatMap((item) => {
+      const object = asObject(item);
+      return object ? [object] : [];
+    });
+  }
+  return asArray(canvas.items).flatMap((page) => {
+    const object = asObject(page);
+    return object ? annotationPageItems(object).flatMap((item) => asObject(item) ? [asObject(item)] : []) : [];
+  });
+};
+var inlineSupplementPages = (canvas, version) => {
+  const raw = version === 2 ? canvas.otherContent : canvas.annotations;
+  return asArray(raw).flatMap((item) => {
+    const object = asObject(item);
+    return object && (Array.isArray(object.items) || Array.isArray(object.resources)) ? [object] : [];
+  });
+};
+var externalSupplementReferences = (canvas, version) => {
+  const raw = version === 2 ? canvas.otherContent : canvas.annotations;
+  return asArray(raw).flatMap((item) => {
+    const object = asObject(item);
+    if (object && (Array.isArray(object.items) || Array.isArray(object.resources))) return [];
+    const id = readId(item);
+    return id ? [id] : [];
+  });
+};
+var posterFrom = (canvas) => {
+  const placeholder = asObject(canvas.placeholderCanvas);
+  return firstContentId(placeholder);
+};
+var canvasFrom = (canvas, index, version, languages, ui) => {
+  const id = readId(canvas) ?? `urn:mango:canvas:${index}`;
+  const sources = paintingAnnotations(canvas, version).flatMap(
+    (annotation, annotationIndex) => bodyItems(annotation.body ?? annotation.resource).flatMap((body, bodyIndex) => {
+      const source = sourceFromBody(body, canvas, annotation.target ?? annotation.on, languages, annotationIndex + bodyIndex, ui, annotation.timeMode);
+      return source ? [source] : [];
+    })
+  );
+  const supplementing = collectSupplementing(inlineSupplementPages(canvas, version), id, languages, ui);
+  const result = {
+    id,
+    index,
+    label: label(canvas.label, languages, formatString(ui.sectionNumber, { number: index + 1 })),
+    behavior: strings(canvas.behavior ?? canvas.viewingHint),
+    sources,
+    tracks: supplementing.tracks,
+    transcripts: supplementing.transcripts,
+    annotations: supplementing.annotations,
+    rendering: downloads(canvas.rendering, languages, ui),
+    metadata: metadata(canvas.metadata, languages, ui),
+    authServices: services(canvas.service, languages)
+  };
+  const summary = label(canvas.summary ?? canvas.description, languages);
+  if (summary) result.summary = summary;
+  const duration = number(canvas.duration);
+  const width = number(canvas.width);
+  const height = number(canvas.height);
+  if (duration !== void 0) result.duration = duration;
+  if (width !== void 0) result.width = width;
+  if (height !== void 0) result.height = height;
+  const poster = posterFrom(canvas);
+  if (poster) result.poster = poster;
+  const accompanying = readId(canvas.accompanyingCanvas);
+  if (accompanying) result.accompanyingCanvas = accompanying;
+  const homepage = readId(asArray(canvas.homepage ?? canvas.related)[0]);
+  if (homepage) result.homepage = homepage;
+  return result;
+};
+var resolveRangeTarget = (value) => {
+  const id = readId(value) ?? readId(asObject(value)?.source);
+  if (!id) return {};
+  const result = { canvasId: withoutFragment(id) };
+  const time = parseTemporalFragment(id);
+  if (time) result.time = time;
+  return result;
+};
+var chaptersFrom = (manifest, version, languages, ui) => {
+  const rawStructures = asArray(manifest.structures).flatMap((item) => asObject(item) ? [asObject(item)] : []);
+  const byId = new Map(rawStructures.map((range) => [readId(range), range]));
+  const seen = /* @__PURE__ */ new Set();
+  const parseRange = (range, depth = 0) => {
+    if (depth > 50 || seen.has(range)) return void 0;
+    seen.add(range);
+    const rangeBehavior = strings(range.behavior ?? range.viewingHint);
+    if (rangeBehavior.includes("no-nav") || rangeBehavior.includes("thumbnail-nav")) return void 0;
+    const id = readId(range) ?? `urn:mango:range:${seen.size}`;
+    const members = version === 3 ? asArray(range.items) : asArray(range.members ?? range.ranges ?? range.canvases);
+    const children = [];
+    let target = {};
+    for (const member of members) {
+      const object = asObject(member);
+      const memberId = readId(member);
+      const memberType = readType(object)?.toLowerCase();
+      const referencedRange = memberId ? byId.get(memberId) : void 0;
+      if (referencedRange || memberType?.includes("range") || object && (object.items || object.ranges || object.members)) {
+        const child = parseRange(referencedRange ?? object, depth + 1);
+        if (child) children.push(child);
+      } else if (!target.canvasId && memberId) {
+        target = resolveRangeTarget(member);
+      }
+    }
+    const result = {
+      id,
+      label: label(range.label, languages, formatString(ui.chapterNumber, { number: seen.size })),
+      behavior: rangeBehavior,
+      children
+    };
+    if (target.canvasId) result.canvasId = target.canvasId;
+    if (target.time) result.time = target.time;
+    const summary = label(range.summary ?? range.description, languages);
+    if (summary) result.summary = summary;
+    const homepage = readId(asArray(range.homepage ?? range.related)[0]);
+    if (homepage) result.homepage = homepage;
+    return result;
+  };
+  return rawStructures.flatMap((range) => {
+    const chapter = parseRange(range);
+    return chapter ? [chapter] : [];
+  });
+};
+var startFrom = (manifest, version) => {
+  const value = version === 2 ? asObject(asArray(manifest.sequences)[0])?.startCanvas ?? manifest.startCanvas : manifest.start;
+  const id = readId(value) ?? readId(asObject(value)?.source);
+  if (!id) return void 0;
+  const result = { canvasId: withoutFragment(id) };
+  const time = parseTemporalFragment(value) ?? parseTemporalFragment(id);
+  if (time) result.time = time.start;
+  return result;
+};
+var manifestCanvases = (manifest, version) => {
+  const raw = version === 3 ? manifest.items : asObject(asArray(manifest.sequences)[0])?.canvases;
+  return asArray(raw).flatMap((item) => asObject(item) ? [asObject(item)] : []);
+};
+var detectVersion = (manifest) => {
+  const context = JSON.stringify(manifest["@context"] ?? "");
+  if (context.includes("/presentation/2/")) return 2;
+  if (Array.isArray(manifest.sequences) || readType(manifest)?.startsWith("sc:")) return 2;
+  return 3;
+};
+var normalizeManifest = async (input, options = {}) => {
+  const ui = resolveStrings(options.strings);
+  const fetcher = options.fetch ?? globalThis.fetch;
+  let source;
+  if (typeof input === "string") {
+    if (input.trim().startsWith("{")) {
+      source = JSON.parse(input);
+    } else {
+      if (!fetcher) throw new Error("No fetch implementation is available to load the IIIF manifest.");
+      const response = await fetcher(input, options.requestInit);
+      if (!response.ok) throw new Error(formatString(ui.unableToLoadManifest, {
+        status: response.status,
+        statusText: response.statusText
+      }));
+      source = await response.json();
+    }
+  } else {
+    source = input;
+  }
+  const type = readType(source)?.toLowerCase();
+  if (type && !type.includes("manifest")) throw new Error(formatString(ui.expectedManifest, {
+    type: readType(source) ?? ""
+  }));
+  const version = detectVersion(source);
+  const languages = options.preferredLanguages ?? ["en", "none"];
+  const canvases = manifestCanvases(source, version).map((canvas, index) => canvasFrom(canvas, index, version, languages, ui));
+  if (canvases.length === 0) throw new Error(ui.manifestWithoutCanvases);
+  if (options.loadExternalAnnotations !== false && fetcher) {
+    const rawCanvases = manifestCanvases(source, version);
+    await Promise.all(rawCanvases.map(async (canvas, index) => {
+      const target = canvases[index];
+      if (!target) return;
+      const references = externalSupplementReferences(canvas, version);
+      const loaded = await Promise.all(references.map(async (url) => {
+        try {
+          const response = await fetcher(url, options.requestInit);
+          if (!response.ok) return void 0;
+          return asObject(await response.json());
+        } catch {
+          return void 0;
+        }
+      }));
+      const parsed = collectSupplementing(loaded.filter((page) => Boolean(page)), target.id, languages, ui);
+      target.tracks.push(...parsed.tracks);
+      target.transcripts.push(...parsed.transcripts);
+      target.annotations.push(...parsed.annotations);
+    }));
+  }
+  const id = readId(source) ?? "urn:mango:manifest";
+  const result = {
+    id,
+    type: "Manifest",
+    version,
+    label: label(source.label, languages, ui.untitledManifest),
+    behavior: strings(source.behavior ?? source.viewingHint),
+    canvases,
+    chapters: chaptersFrom(source, version, languages, ui),
+    metadata: metadata(source.metadata, languages, ui),
+    rendering: downloads(source.rendering, languages, ui)
+  };
+  const summary = label(source.summary ?? source.description, languages);
+  if (summary) result.summary = summary;
+  const start = startFrom(source, version);
+  if (start) result.start = start;
+  if (typeof source.rights === "string") result.rights = source.rights;
+  const requiredStatement = metadata([source.requiredStatement ?? source.attribution], languages, ui)[0];
+  if (requiredStatement) result.requiredStatement = requiredStatement;
+  const homepage = readId(asArray(source.homepage ?? source.related)[0]);
+  if (homepage) result.homepage = homepage;
+  const logo = readId(asArray(source.logo ?? source.provider)[0]);
+  if (logo) result.logo = logo;
+  return result;
+};
+
+// src/controller.ts
+var positionPrefix = "@mango-iiif/av:position:";
+var AVPlayerController = class extends EventTarget {
+  #config;
+  #state = {
+    status: "idle",
+    canvasIndex: 0,
+    sourceIndex: 0,
+    currentTime: 0,
+    duration: 0,
+    volume: 1,
+    muted: false,
+    playbackRate: 1,
+    autoAdvance: false,
+    repeat: false
+  };
+  #media;
+  #lastTime = 0;
+  #timelineScale = 1;
+  #pendingTime;
+  #boundListeners = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this.#config = mergeConfig(defaultConfig, config);
+    this.#state.autoAdvance = this.#config.autoAdvance;
+    this.#state.repeat = this.#config.repeat;
+  }
+  get config() {
+    return this.#config;
+  }
+  get state() {
+    return this.#state;
+  }
+  get manifest() {
+    return this.#state.manifest;
+  }
+  get canvas() {
+    return this.#state.manifest?.canvases[this.#state.canvasIndex];
+  }
+  get source() {
+    return this.canvas?.sources[this.#state.sourceIndex];
+  }
+  get media() {
+    return this.#media;
+  }
+  on(type, listener) {
+    const eventListener = listener;
+    this.addEventListener(type, eventListener);
+    return () => this.removeEventListener(type, eventListener);
+  }
+  configure(config) {
+    this.#config = mergeConfig(
+      this.#config,
+      config
+    );
+    if (config.autoAdvance !== void 0) this.#state.autoAdvance = config.autoAdvance;
+    if (config.repeat !== void 0) this.#state.repeat = config.repeat;
+    this.#emit("av-configchange", { config: this.#config });
+    this.#emitState();
+  }
+  async load(input) {
+    this.#state.status = "loading";
+    delete this.#state.error;
+    this.#emit("av-loadstart", { source: input });
+    this.#emitState();
+    try {
+      const normalizeOptions = {
+        preferredLanguages: this.#config.preferredLanguages,
+        strings: this.#config.strings
+      };
+      if (this.#config.fetch) normalizeOptions.fetch = this.#config.fetch;
+      if (this.#config.requestInit) normalizeOptions.requestInit = this.#config.requestInit;
+      const manifest = await normalizeManifest(input, normalizeOptions);
+      this.#state.manifest = manifest;
+      const requestedCanvas = this.#config.startCanvasId ?? manifest.start?.canvasId;
+      const canvasIndex = requestedCanvas ? Math.max(0, manifest.canvases.findIndex((canvas2) => canvas2.id === withoutFragment(requestedCanvas))) : 0;
+      this.#state.canvasIndex = canvasIndex;
+      this.#state.sourceIndex = 0;
+      this.#timelineScale = 1;
+      this.#state.currentTime = 0;
+      this.#state.duration = this.canvas?.duration ?? 0;
+      this.#state.autoAdvance = this.#config.autoAdvance || manifest.behavior.includes("auto-advance");
+      this.#state.repeat = this.#config.repeat || manifest.behavior.includes("repeat");
+      this.#state.status = "ready";
+      const initialTime = this.#config.startTime ?? manifest.start?.time ?? this.source?.canvasTarget?.start;
+      if (initialTime !== void 0) this.#pendingTime = initialTime;
+      this.#emit("av-ready", { manifest });
+      const canvas = this.canvas;
+      if (canvas) this.#emit("av-canvaschange", { canvas, canvasIndex });
+      this.#emitState();
+      return manifest;
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      this.#state.status = "error";
+      this.#state.error = error;
+      this.#emit("av-error", { error });
+      this.#emitState();
+      throw error;
+    }
+  }
+  attachMedia(media) {
+    if (this.#media === media) return;
+    this.detachMedia();
+    this.#media = media;
+    const listeners = {
+      loadedmetadata: () => {
+        const segment = this.source?.segment;
+        const target = this.source?.canvasTarget;
+        if (this.source?.timeMode === "scale" && target?.end !== void 0 && Number.isFinite(media.duration)) {
+          const sourceDuration = segment?.end !== void 0 ? segment.end - segment.start : media.duration;
+          const targetDuration = target.end - target.start;
+          if (sourceDuration > 0 && targetDuration > 0) {
+            this.#timelineScale = sourceDuration / targetDuration;
+            media.playbackRate = this.#timelineScale;
+          }
+        }
+        const pending = this.#pendingTime ?? target?.start;
+        if (pending !== void 0) {
+          media.currentTime = this.#toMediaTime(pending);
+          this.#pendingTime = void 0;
+        }
+        this.#state.duration = this.canvas?.duration ?? target?.end ?? (Number.isFinite(media.duration) ? this.#toCanvasTime(media.duration) : 0);
+        this.#emitState();
+      },
+      play: () => {
+        this.#state.status = "playing";
+        this.#emit("av-play", { canvasId: this.canvas?.id ?? "", time: this.#toCanvasTime(media.currentTime) });
+        this.#emitState();
+      },
+      pause: () => {
+        if (!media.ended) this.#state.status = "paused";
+        this.#savePosition();
+        this.#emit("av-pause", { canvasId: this.canvas?.id ?? "", time: this.#toCanvasTime(media.currentTime) });
+        this.#emitState();
+      },
+      timeupdate: () => {
+        const time = this.#toCanvasTime(media.currentTime);
+        const duration = this.canvas?.duration ?? this.source?.canvasTarget?.end ?? (Number.isFinite(media.duration) ? this.#toCanvasTime(media.duration) : 0);
+        this.#state.currentTime = time;
+        this.#state.duration = duration;
+        this.#emit("av-timeupdate", { canvasId: this.canvas?.id ?? "", time, duration });
+        const end = this.source?.canvasTarget?.end ?? (this.source?.segment?.end !== void 0 ? this.#toCanvasTime(this.source.segment.end) : void 0);
+        if (end !== void 0 && time >= end) {
+          if (this.source?.timeMode === "loop") {
+            media.currentTime = this.source.segment?.start ?? 0;
+          } else {
+            media.pause();
+            void this.#advanceAfterEnd();
+          }
+        }
+        this.#lastTime = time;
+        this.#emitState();
+      },
+      seeking: () => {
+        this.#emit("av-seek", { canvasId: this.canvas?.id ?? "", from: this.#lastTime, to: this.#toCanvasTime(media.currentTime) });
+      },
+      volumechange: () => {
+        this.#state.volume = media.volume;
+        this.#state.muted = media.muted;
+        this.#emitState();
+      },
+      ratechange: () => {
+        this.#state.playbackRate = media.playbackRate;
+        this.#emitState();
+      },
+      ended: () => {
+        this.#state.status = "ended";
+        this.#emit("av-ended", { canvasId: this.canvas?.id ?? "" });
+        this.#clearPosition();
+        this.#emitState();
+        void this.#advanceAfterEnd();
+      },
+      error: () => {
+        const error = new Error(media.error?.message ?? "The media resource could not be played.");
+        this.#state.status = "error";
+        this.#state.error = error;
+        this.#emit("av-error", { error });
+        this.#emitState();
+      }
+    };
+    for (const [type, listener] of Object.entries(listeners)) {
+      media.addEventListener(type, listener);
+      this.#boundListeners.set(type, listener);
+    }
+  }
+  detachMedia() {
+    if (!this.#media) return;
+    for (const [type, listener] of this.#boundListeners) this.#media.removeEventListener(type, listener);
+    this.#boundListeners.clear();
+    this.#media = void 0;
+  }
+  async play() {
+    await this.#media?.play();
+  }
+  pause() {
+    this.#media?.pause();
+  }
+  stop() {
+    this.pause();
+    this.seekTo(this.source?.canvasTarget?.start ?? 0);
+  }
+  seekTo(time) {
+    const source = this.source;
+    const minimum = source?.canvasTarget?.start ?? 0;
+    const maximum = source?.canvasTarget?.end ?? this.#state.duration;
+    const target = maximum > 0 ? Math.min(Math.max(time, minimum), maximum) : Math.max(time, minimum);
+    if (this.#media && this.#media.readyState > 0) this.#media.currentTime = this.#toMediaTime(target);
+    else this.#pendingTime = target;
+    this.#state.currentTime = target;
+    this.#emitState();
+  }
+  seekBy(delta) {
+    this.seekTo(this.#state.currentTime + delta);
+  }
+  selectCanvas(indexOrId, options = {}) {
+    const canvases = this.#state.manifest?.canvases ?? [];
+    const index = typeof indexOrId === "number" ? indexOrId : canvases.findIndex((canvas2) => canvas2.id === withoutFragment(indexOrId));
+    if (index < 0 || index >= canvases.length) return void 0;
+    const wasPlaying = options.autoplay ?? this.#state.status === "playing";
+    this.#state.canvasIndex = index;
+    this.#state.sourceIndex = 0;
+    this.#timelineScale = 1;
+    this.#state.currentTime = options.time ?? canvases[index]?.sources[0]?.canvasTarget?.start ?? 0;
+    this.#state.duration = canvases[index]?.duration ?? 0;
+    this.#pendingTime = this.#state.currentTime;
+    const canvas = canvases[index];
+    if (canvas) this.#emit("av-canvaschange", { canvas, canvasIndex: index });
+    this.#emitState();
+    if (wasPlaying) queueMicrotask(() => void this.play());
+    return canvas;
+  }
+  next(options = {}) {
+    const count = this.#state.manifest?.canvases.length ?? 0;
+    if (this.#state.canvasIndex + 1 < count) return this.selectCanvas(this.#state.canvasIndex + 1, options);
+    if (this.#state.repeat && count > 0) return this.selectCanvas(0, options);
+    return void 0;
+  }
+  previous(options = {}) {
+    if (this.#state.canvasIndex > 0) return this.selectCanvas(this.#state.canvasIndex - 1, options);
+    return void 0;
+  }
+  selectSource(index) {
+    const sources = this.canvas?.sources ?? [];
+    const source = sources[index];
+    if (!source) return void 0;
+    const wasPlaying = this.#state.status === "playing";
+    const currentTime = this.#state.currentTime;
+    this.#state.sourceIndex = index;
+    this.#timelineScale = 1;
+    this.#pendingTime = currentTime;
+    this.#emit("av-sourcechange", { source, sourceIndex: index });
+    this.#emitState();
+    if (wasPlaying) queueMicrotask(() => void this.play());
+    return source;
+  }
+  async createAnnotation(draft) {
+    const canvas = this.canvas;
+    if (!canvas) throw new Error("A Canvas must be active before creating an annotation.");
+    const created = this.#config.annotationAdapter?.create ? await this.#config.annotationAdapter.create(canvas, draft) : this.#annotationFromDraft(canvas, draft);
+    canvas.annotations.push(created);
+    this.#emit("av-annotationschange", { canvasId: canvas.id, annotations: [...canvas.annotations] });
+    this.#emitState();
+    return created;
+  }
+  async updateAnnotation(id, update) {
+    const canvas = this.canvas;
+    if (!canvas) throw new Error("A Canvas must be active before updating an annotation.");
+    const index = canvas.annotations.findIndex((annotation) => annotation.id === id);
+    const current = canvas.annotations[index];
+    if (!current) throw new Error(`Annotation ${id} was not found on the active Canvas.`);
+    const candidate = {
+      ...current,
+      ...update,
+      motivation: update.motivation ?? current.motivation,
+      purpose: update.purpose ?? current.purpose,
+      tags: update.tags ?? current.tags
+    };
+    const saved = this.#config.annotationAdapter?.update ? await this.#config.annotationAdapter.update(canvas, candidate) : candidate;
+    canvas.annotations[index] = saved;
+    this.#emit("av-annotationschange", { canvasId: canvas.id, annotations: [...canvas.annotations] });
+    this.#emitState();
+    return saved;
+  }
+  async removeAnnotation(id) {
+    const canvas = this.canvas;
+    if (!canvas) throw new Error("A Canvas must be active before removing an annotation.");
+    const index = canvas.annotations.findIndex((annotation) => annotation.id === id);
+    const current = canvas.annotations[index];
+    if (!current) throw new Error(`Annotation ${id} was not found on the active Canvas.`);
+    if (this.#config.annotationAdapter?.remove) await this.#config.annotationAdapter.remove(canvas, current);
+    canvas.annotations.splice(index, 1);
+    this.#emit("av-annotationschange", { canvasId: canvas.id, annotations: [...canvas.annotations] });
+    this.#emitState();
+  }
+  setAutoAdvance(enabled) {
+    this.#state.autoAdvance = enabled;
+    this.#emitState();
+  }
+  setRepeat(enabled) {
+    this.#state.repeat = enabled;
+    this.#emitState();
+  }
+  getSavedPosition() {
+    if (!this.#config.resume.enabled || !this.canvas || typeof localStorage === "undefined") return void 0;
+    const raw = localStorage.getItem(`${positionPrefix}${this.#state.manifest?.id}:${this.canvas.id}`);
+    if (!raw) return void 0;
+    try {
+      const saved = JSON.parse(raw);
+      const ttl = (this.#config.resume.ttlDays ?? 30) * 864e5;
+      if (Date.now() - saved.savedAt > ttl) {
+        this.#clearPosition();
+        return void 0;
+      }
+      return saved.time;
+    } catch {
+      return void 0;
+    }
+  }
+  destroy() {
+    this.#savePosition();
+    this.detachMedia();
+  }
+  async resolvedSourceUrl() {
+    const source = this.source;
+    if (!source) return void 0;
+    if (!this.#config.resolveRequest) return source.src;
+    const context = {};
+    if (this.manifest) context.manifest = this.manifest;
+    if (this.canvas) context.canvas = this.canvas;
+    return await this.#config.resolveRequest(source.src, context);
+  }
+  async #advanceAfterEnd() {
+    if (!this.#state.autoAdvance) return;
+    const next = this.next({ autoplay: true });
+    if (!next) this.#state.status = "ended";
+  }
+  #savePosition() {
+    if (!this.#config.resume.enabled || !this.canvas || typeof localStorage === "undefined") return;
+    const time = this.#state.currentTime;
+    if (time <= 0 || this.#state.duration > 0 && time >= this.#state.duration - 2) return;
+    const key = `${positionPrefix}${this.#state.manifest?.id}:${this.canvas.id}`;
+    localStorage.setItem(key, JSON.stringify({ time, savedAt: Date.now() }));
+    const keys = Object.keys(localStorage).filter((item) => item.startsWith(positionPrefix));
+    const maxItems = this.#config.resume.maxItems ?? 200;
+    if (keys.length > maxItems) {
+      const oldest = keys.map((item) => ({ item, value: JSON.parse(localStorage.getItem(item) ?? "{}") })).sort((a, b) => (a.value.savedAt ?? 0) - (b.value.savedAt ?? 0))[0];
+      if (oldest) localStorage.removeItem(oldest.item);
+    }
+  }
+  #clearPosition() {
+    if (!this.canvas || typeof localStorage === "undefined") return;
+    localStorage.removeItem(`${positionPrefix}${this.#state.manifest?.id}:${this.canvas.id}`);
+  }
+  #emit(type, detail) {
+    this.dispatchEvent(new CustomEvent(type, { detail, bubbles: false, composed: false }));
+  }
+  #emitState() {
+    this.#emit("av-statechange", { ...this.#state });
+  }
+  #annotationFromDraft(canvas, draft) {
+    const annotation = {
+      id: `${canvas.id}/annotation/${crypto.randomUUID?.() ?? Date.now()}`,
+      canvasId: canvas.id,
+      motivation: draft.motivation ?? ["commenting"],
+      purpose: draft.purpose ?? ["commenting"],
+      text: draft.text,
+      tags: draft.tags ?? []
+    };
+    if (draft.label) annotation.label = draft.label;
+    if (draft.time) annotation.time = draft.time;
+    return annotation;
+  }
+  #toCanvasTime(mediaTime) {
+    const sourceStart = this.source?.segment?.start ?? 0;
+    const targetStart = this.source?.canvasTarget?.start ?? 0;
+    const scale = this.source?.timeMode === "scale" ? this.#timelineScale : 1;
+    return targetStart + (mediaTime - sourceStart) / scale;
+  }
+  #toMediaTime(canvasTime) {
+    const sourceStart = this.source?.segment?.start ?? 0;
+    const targetStart = this.source?.canvasTarget?.start ?? 0;
+    const scale = this.source?.timeMode === "scale" ? this.#timelineScale : 1;
+    return sourceStart + (canvasTime - targetStart) * scale;
+  }
+};
+
+export {
+  defaultStrings,
+  defaultConfig,
+  parseTime,
+  parseTemporalFragment,
+  formatTime,
+  resolveStrings,
+  formatString,
+  escapeHtml,
+  normalizeManifest,
+  AVPlayerController
+};
+//# sourceMappingURL=chunk-R4OUWZ3R.js.map