@mtillmann/chapters 0.0.1

package/dist/index.js

@@ -0,0 +1,1339 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Formats/AppleChapters.ts
+import { JSDOM as JSDOM2 } from "jsdom";
+
+// src/util.ts
+var util_exports = {};
+__export(util_exports, {
+  Float: () => Float,
+  Floats: () => Floats,
+  Int: () => Int,
+  Ints: () => Ints,
+  NPTToSeconds: () => NPTToSeconds,
+  enforceMilliseconds: () => enforceMilliseconds,
+  escapeRegExpCharacters: () => escapeRegExpCharacters,
+  formatBytes: () => formatBytes,
+  hash: () => hash,
+  indenter: () => indenter,
+  secondsToNPT: () => secondsToNPT,
+  secondsToTimestamp: () => secondsToTimestamp,
+  stringToLines: () => stringToLines,
+  timestampToSeconds: () => timestampToSeconds,
+  toSeconds: () => toSeconds,
+  zeroPad: () => zeroPad
+});
+function zeroPad(num, len = 3) {
+  return String(num).padStart(len, "0");
+}
+function secondsToTimestamp(seconds, options = {}) {
+  options = {
+    hours: true,
+    milliseconds: false,
+    ...options
+  };
+  const date = new Date(Int(seconds) * 1e3).toISOString();
+  if (date.slice(11, 13) !== "00") {
+    options.hours = true;
+  }
+  const hms = date.slice(options.hours ? 11 : 14, 19);
+  if (options.milliseconds) {
+    let fraction = "000";
+    if (seconds.toString().includes(".")) {
+      fraction = (String(seconds).split(".").pop() + "000").slice(0, 3);
+    }
+    return hms + "." + fraction;
+  }
+  return hms;
+}
+function NPTToSeconds(npt) {
+  const parts = npt.split(".");
+  const hms = parts[0].split(":");
+  const ms = parts.length > 1 ? Int(parts[1]) : 0;
+  while (hms.length < 3) {
+    hms.unshift("0");
+  }
+  const [hours, minutes, seconds] = Ints(hms);
+  return timestampToSeconds(`${zeroPad(hours.toString(), 2)}:${zeroPad(minutes.toString(), 2)}:${zeroPad(seconds.toString(), 2)}.${zeroPad(ms.toString(), 3)}`);
+}
+function secondsToNPT(seconds) {
+  if (seconds === 0) {
+    return "0";
+  }
+  const regularTimestamp = secondsToTimestamp(seconds, { milliseconds: true });
+  let [hoursAndMinutesAndSeconds, milliseconds] = regularTimestamp.split(".");
+  const [hours, minutes, secondsOnly] = Ints(hoursAndMinutesAndSeconds.split(":"));
+  if (milliseconds === "000") {
+    milliseconds = "";
+  } else {
+    milliseconds = "." + milliseconds;
+  }
+  if (hours === 0 && minutes === 0) {
+    return `${secondsOnly}${milliseconds}`;
+  }
+  const secondsString = zeroPad(secondsOnly, 2);
+  if (hours === 0) {
+    return `${minutes}:${secondsString}${milliseconds}`;
+  }
+  const minutesString = zeroPad(minutes, 2);
+  return `${hours}:${minutesString}:${secondsString}${milliseconds}`;
+}
+function timestampToSeconds(timestamp, fixedString = false) {
+  let [seconds, minutes, hours] = Ints(timestamp.split(":")).reverse();
+  let milliseconds = timestamp.split(".").length > 1 ? Int(timestamp.split(".").pop()) : 0;
+  if (!hours) {
+    hours = 0;
+  }
+  if (!minutes) {
+    minutes = 0;
+  }
+  if (!seconds) {
+    seconds = 0;
+  }
+  if (milliseconds > 0) {
+    milliseconds = milliseconds / 1e3;
+  }
+  if (seconds > 59) {
+    const extraMinutes = Math.floor(seconds / 60);
+    minutes += extraMinutes;
+    seconds -= extraMinutes * 60;
+  }
+  if (minutes > 59) {
+    const extraHours = Math.floor(minutes / 60);
+    hours += extraHours;
+    minutes -= extraHours * 60;
+  }
+  if (fixedString) {
+    return Float((hours * 3600 + minutes * 60 + seconds + milliseconds).toFixed(3));
+  }
+  return hours * 3600 + minutes * 60 + seconds + milliseconds;
+}
+function hash() {
+  return (Math.random() + 1).toString(16).substring(7);
+}
+function escapeRegExpCharacters(text) {
+  return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+function enforceMilliseconds(seconds) {
+  return Float(seconds.toFixed(3));
+}
+function formatBytes(bytes, decimals = 2, format = "kB") {
+  if (bytes < 1) {
+    return "0 B";
+  }
+  const k = format === "kB" ? 1e3 : 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const sizes = ["", "K", "M", "G", "T", "P", "E", "Z", "Y"];
+  const suffix = [format === "kB" ? sizes[i].toLowerCase() : sizes[i], "B"];
+  if (format === "KiB") {
+    suffix.splice(1, 0, "i");
+  }
+  return Float(bytes / Math.pow(k, i)).toFixed(decimals) + " " + suffix.join("");
+}
+function Int(value, defaultValue = 0) {
+  const i = parseInt(String(value || defaultValue));
+  return Number.isNaN(i) ? defaultValue : i;
+}
+function Float(value, defaultValue = 0) {
+  const f = parseFloat(String(value || defaultValue));
+  return Number.isNaN(f) ? defaultValue : f;
+}
+function Ints(value, defaultValue = 0) {
+  return value.map((i) => Int(i, defaultValue));
+}
+function Floats(value, defaultValue = 0) {
+  return value.map((i) => Float(i, defaultValue));
+}
+function indenter(spacesPerDepth = 2) {
+  const character = spacesPerDepth === 0 ? "" : " ";
+  return function(depth, string) {
+    return character.repeat(depth * spacesPerDepth) + string;
+  };
+}
+function stringToLines(string) {
+  return string.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => line.trim());
+}
+function toSeconds(input) {
+  if (typeof input === "number") {
+    return input;
+  }
+  if (input.includes(":")) {
+    return timestampToSeconds(input);
+  }
+  return Float(input);
+}
+
+// src/Formats/Base.ts
+import filenamify from "filenamify";
+var Base = class {
+  supportsPrettyPrint = false;
+  chapterTitleTemplate = "Chapter $chapter of $total";
+  chapters = [];
+  defaultMeta = {
+    author: "",
+    title: "",
+    podcastName: "",
+    description: "",
+    fileName: "",
+    waypoints: false,
+    version: "1.2.0"
+  };
+  // why?!
+  meta = { ...this.defaultMeta };
+  // meta:MediaItemMeta = {...this.defaultMeta};
+  filename = "chapters.json";
+  mimeType = "application/json";
+  duration = 0;
+  isChapterFormat = true;
+  static create(input) {
+    return new this().from(input);
+  }
+  from(input) {
+    if (!input) {
+      throw new Error("No input provided");
+    } else if (typeof input === "string") {
+      this.parse(input);
+    } else if ("isChapterFormat" in input) {
+      this.chapters = JSON.parse(JSON.stringify(input.chapters));
+      this.meta = { ...this.meta, ...JSON.parse(JSON.stringify(input.meta)) };
+    }
+    if (this.chapters.length > 0) {
+      const chapter = this.chapters.at(-1);
+      if (chapter.endTime) {
+        this.duration = chapter.endTime;
+      } else if (chapter.startTime) {
+        this.duration = chapter.startTime;
+      }
+    }
+    if (this.duration === 0) {
+      this.duration = 3600;
+    }
+    this.bump();
+    return this;
+  }
+  detect(inputString) {
+    try {
+      const data = JSON.parse(inputString);
+      const { errors } = this.test(data);
+      if (errors.length > 0) {
+        throw new Error("data test failed");
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
+  test(data) {
+    if (!("chapters" in data)) {
+      return { errors: ['JSON Structure: missing "chapters"'] };
+    }
+    if (!("version" in data)) {
+      return { errors: ['JSON Structure: missing "version"'] };
+    }
+    return { errors: [] };
+  }
+  bump(keepDuration = false) {
+    this.chapters.sort((a, b) => a.startTime - b.startTime);
+    const lastChapter = this.chapters.at(-1);
+    if (lastChapter && !keepDuration) {
+      this.duration = Math.max(parseFloat(String(this.duration || 0)), parseFloat(String(lastChapter.endTime ?? 0)), parseFloat(String(lastChapter.startTime ?? 0)));
+    }
+    this.chapters = this.chapters.map((chapter, index) => {
+      const endTime = this.endTime(index);
+      const duration = endTime - this.chapters[index].startTime;
+      const timestampOptions = { hours: false };
+      return {
+        ...{
+          id: hash(),
+          startTime: 0
+        },
+        ...chapter,
+        ...{
+          endTime,
+          duration,
+          startTime_hr: secondsToTimestamp(chapter.startTime, timestampOptions),
+          endTime_hr: secondsToTimestamp(endTime, timestampOptions),
+          duration_hr: secondsToTimestamp(duration, timestampOptions)
+        },
+        ..."toc" in chapter ? {} : { toc: true }
+      };
+    });
+  }
+  endTime(index) {
+    return this.chapters[index + 1] ? this.chapters[index + 1].startTime - 1e-3 : this.duration;
+  }
+  expandFirstToStart() {
+    this.chapters[0].startTime = 0;
+    this.bump();
+  }
+  add(chapter) {
+    this.chapters.push(chapter);
+    this.bump();
+  }
+  remove(index) {
+    if (this.chapters[index]?.img?.slice(0, 5) === "blob:") {
+      URL.revokeObjectURL(String(this.chapters[index].img));
+    }
+    this.chapters.splice(index, 1);
+    this.bump();
+  }
+  to(className) {
+    return className.create(this);
+  }
+  parse(string) {
+    const data = JSON.parse(string);
+    const { errors } = this.test(data);
+    if (errors.length > 0) {
+      throw new Error(errors.join(""));
+    }
+    this.chapters = data.chapters;
+    this.chapters = this.chapters.map((chapter) => {
+      if ("img" in chapter) {
+        if (chapter.img?.slice(0, 4) === "http") {
+          chapter.img_type = "absolute";
+        } else {
+          chapter.img_type = "relative";
+          chapter.img_filename = chapter.img;
+        }
+      }
+      return chapter;
+    });
+    this.meta = Object.fromEntries(Object.entries(this.meta).map(([key, value]) => [key, data[key] || value]));
+  }
+  toString(pretty = false, exportOptions = {}) {
+    const options = {
+      ...{
+        imagePrefix: "",
+        writeRedundantToc: false,
+        writeEndTimes: false
+      },
+      ...exportOptions
+    };
+    const defaultMetaProperties = Object.keys(this.defaultMeta);
+    return JSON.stringify(
+      {
+        ...Object.fromEntries(
+          Object.entries(this.meta).filter(([key, value]) => {
+            return defaultMetaProperties.includes(key) && value !== "" && value !== false;
+          })
+        ),
+        ...{
+          chapters: this.chapters.map((chapter) => {
+            const filtered = {
+              startTime: enforceMilliseconds(chapter.startTime)
+            };
+            if (options.writeEndTimes) {
+              filtered.endTime = enforceMilliseconds(chapter.endTime);
+            }
+            if ("toc" in chapter && chapter.toc === false) {
+              filtered.toc = false;
+            }
+            if (!("toc" in filtered) && options.writeRedundantToc) {
+              filtered.toc = true;
+            }
+            ["location", "img", "url", "title"].forEach((property) => {
+              const key = property;
+              if (key in chapter && String(chapter[key]).trim().length > 0) {
+                filtered[key] = chapter[key];
+              }
+            });
+            if ("img_filename" in chapter && "img" in filtered && chapter.img_type === "relative") {
+              filtered.img = filenamify(chapter.img_filename);
+            }
+            if (options.imagePrefix.trim().length > 0 && "img" in filtered && ["relative", "blob"].includes(chapter.img_type)) {
+              filtered.img = options.imagePrefix + String(filtered.img);
+            }
+            return filtered;
+          })
+        }
+      },
+      null,
+      pretty ? 2 : 0
+    );
+  }
+  applyChapterMinLength(seconds) {
+    const originalIdMap = this.chapters.map((chapter) => String(chapter.id));
+    const newChapters = [];
+    let elapsed = 0;
+    let currentChapter;
+    this.chapters.forEach((chapter) => {
+      elapsed += chapter.duration;
+      if (!currentChapter) {
+        currentChapter = chapter;
+      }
+      if (elapsed >= seconds) {
+        delete currentChapter.endTime;
+        delete currentChapter.duration;
+        newChapters.push(currentChapter);
+        currentChapter = null;
+        elapsed = 0;
+      }
+    });
+    this.chapters = newChapters;
+    this.bump();
+    const newIdMap = Object.fromEntries(this.chapters.map((c, i) => [c.id, i]));
+    return Object.fromEntries(originalIdMap.map((id, index) => {
+      return [index, id in newIdMap ? newIdMap[id] : "deleted"];
+    }));
+  }
+  addChapterAt(index, chapter = {}) {
+    let startTime = 0;
+    if (index > this.chapters.length) {
+      const start = this.chapters.at(-1) ? this.chapters.at(-1).startTime : 0;
+      startTime = start + (this.duration - start) * 0.5;
+    } else if (index === 0) {
+      startTime = 0;
+    } else {
+      const start = this.chapters.at(index - 1).startTime;
+      const end = this.chapters.at(index) ? this.chapters.at(index).startTime : this.duration;
+      startTime = start + (end - start) * 0.5;
+    }
+    if (chapter && "startTime" in chapter) {
+      delete chapter.startTime;
+    }
+    this.chapters.push({
+      ...chapter,
+      id: hash(),
+      startTime
+    });
+    this.bump();
+    return startTime;
+  }
+  addChapterAtTime(time, chapter = {}) {
+    const startTime = toSeconds(time);
+    if (this.chapterExistsAtStartTime(startTime)) {
+      return false;
+    }
+    this.chapters.push({
+      ...chapter,
+      id: hash(),
+      startTime
+    });
+    this.bump();
+    return true;
+  }
+  rebuildChapterTitles(template) {
+    this.chapters.forEach((chapter, index) => {
+      this.chapters[index].title = this.getChapterTitle(index, template);
+    });
+  }
+  ensureTitle(index) {
+    return this.chapters[index].title ?? this.getChapterTitle(index);
+  }
+  getChapterTitle(index, template) {
+    template = template ?? this.chapterTitleTemplate;
+    return template.replace("$chapter", String(index + 1)).replace("$total", String(this.chapters.length));
+  }
+  chapterExistsAtStartTime(time) {
+    time = toSeconds(time);
+    return this.chapters.filter((c) => c.startTime === time).length > 0;
+  }
+  updateChapterStartTime(index, startTime) {
+    const newStartTime = toSeconds(startTime);
+    if (this.chapterExistsAtStartTime(newStartTime)) {
+      return "timeInUse";
+    }
+    if (newStartTime > this.duration) {
+      this.duration = newStartTime;
+    }
+    this.chapters[index].startTime = newStartTime;
+    this.bump();
+    return newStartTime;
+  }
+  chapterIndexFromStartTime(startTime) {
+    startTime = toSeconds(startTime);
+    return this.chapters.reduce((newIndex, chapter, index) => {
+      if (chapter.startTime === startTime) {
+        newIndex = index;
+      }
+      return newIndex;
+    }, 0);
+  }
+  chapterIndexFromTime(time) {
+    const timeStamp = toSeconds(time);
+    return this.chapters.reduce((newIndex, chapter, index) => {
+      if (timeStamp > chapter.startTime) {
+        newIndex = index;
+      }
+      return newIndex;
+    }, null);
+  }
+  ensureUniqueFilenames() {
+    const usedFilenames = [];
+    this.chapters = this.chapters.map((chapter) => {
+      if (chapter.img_type !== "blob") {
+        return chapter;
+      }
+      chapter.img_filename = filenamify(chapter.img_filename);
+      let filename = chapter.img_filename;
+      if (usedFilenames.includes(filename)) {
+        filename = filename.replace(/(\.\w+)$/, `_${hash()}$1`);
+        chapter.img_filename = filename;
+      }
+      usedFilenames.push(filename);
+      return chapter;
+    });
+  }
+  applyImgUri(imgUri) {
+    this.chapters.forEach((chapter, i) => {
+      if ("img" in chapter) {
+        this.chapters[i].img = imgUri.replace(/\/*$/, "") + "/" + chapter.img.replace(/^\/*/, "");
+      }
+    });
+  }
+};
+
+// src/Formats/MatroskaXML.ts
+import { JSDOM } from "jsdom";
+var MatroskaXML = class extends Base {
+  supportsPrettyPrint = true;
+  filename = "matroska-chapters.xml";
+  mimeType = "text/xml";
+  chapterStringNodeName = "ChapString";
+  inputTimeToSeconds(string) {
+    return Float(string) / 1e9;
+  }
+  secondsToOutputTime(seconds) {
+    return String(Int(String(seconds * 1e9)));
+  }
+  detect(inputString) {
+    return /^<\?xml/.test(inputString.trim()) && inputString.includes("<Chapters>") && inputString.includes(`<${this.chapterStringNodeName}>`);
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error("Input needs xml declaration and a <Chapters> node");
+    }
+    let dom;
+    if (typeof DOMParser !== "undefined") {
+      dom = new DOMParser().parseFromString(string, "application/xml");
+    } else {
+      dom = new JSDOM(string, { contentType: "application/xml" });
+      dom = dom.window.document;
+    }
+    this.chapters = [...dom.querySelectorAll("ChapterAtom")].map((chapter) => {
+      return {
+        title: String(chapter.querySelector(this.chapterStringNodeName)?.textContent),
+        startTime: this.inputTimeToSeconds(String(chapter.querySelector("ChapterTimeStart")?.textContent)),
+        endTime: this.inputTimeToSeconds(String(chapter.querySelector("ChapterTimeEnd")?.textContent))
+      };
+    });
+  }
+  toString(pretty = false) {
+    const indent = indenter(pretty ? 2 : 0);
+    const output = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<!DOCTYPE Chapters SYSTEM "matroskachapters.dtd">',
+      "<Chapters>",
+      indent(1, "<EditionEntry>"),
+      indent(2, `<EditionUID>${Date.now()}${Int(Math.random() * 1e6)}</EditionUID>`)
+    ];
+    this.chapters.forEach((chapter, index) => {
+      output.push(indent(2, "<ChapterAtom>"));
+      output.push(indent(3, `<ChapterTimeStart>${this.secondsToOutputTime(chapter.startTime)}</ChapterTimeStart>`));
+      output.push(indent(3, `<ChapterTimeEnd>${this.secondsToOutputTime(chapter.endTime)}</ChapterTimeEnd>`));
+      output.push(indent(3, `<ChapterUID>${Int(1 + chapter.startTime)}${Int(Math.random() * 1e6)}</ChapterUID>`));
+      output.push(indent(3, "<ChapterDisplay>"));
+      output.push(indent(4, `<${this.chapterStringNodeName}>${this.ensureTitle(index)}</${this.chapterStringNodeName}>`));
+      output.push(indent(3, "</ChapterDisplay>"));
+      output.push(indent(2, "</ChapterAtom>"));
+    });
+    output.push(
+      indent(1, "</EditionEntry>"),
+      "</Chapters>"
+    );
+    return output.join(pretty ? "\n" : "");
+  }
+};
+
+// src/Formats/AppleChapters.ts
+var AppleChapters = class extends MatroskaXML {
+  supportsPrettyPrint = true;
+  filename = "apple-chapters.xml";
+  mimeType = "text/xml";
+  detect(inputString) {
+    return /^<\?xml/.test(inputString.trim()) && inputString.includes("<TextStream");
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error("Input needs xml declaration and a <TextStream...> node");
+    }
+    let dom;
+    if (typeof DOMParser !== "undefined") {
+      dom = new DOMParser().parseFromString(string, "application/xml");
+    } else {
+      dom = new JSDOM2(string, { contentType: "application/xml" });
+      dom = dom.window.document;
+    }
+    this.chapters = [...dom.querySelectorAll("TextSample")].map((chapter) => {
+      const title = String(chapter.getAttribute("text") ?? chapter.textContent);
+      return {
+        title,
+        startTime: timestampToSeconds(String(chapter.getAttribute("sampleTime")))
+      };
+    });
+  }
+  toString(pretty = false, exportOptions = {}) {
+    const indent = indenter(pretty ? 2 : 0);
+    const output = [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<TextStream version="1.1">',
+      indent(1, "<TextStreamHeader>"),
+      indent(2, "<TextSampleDescription>"),
+      indent(2, "</TextSampleDescription>"),
+      indent(1, "</TextStreamHeader>")
+    ];
+    this.chapters.forEach((chapter) => {
+      const attrContent = exportOptions.acUseTextAttr && chapter.title ? ` text="${chapter.title}"` : "";
+      const content = !exportOptions.acUseTextAttr && chapter.title ? chapter.title : "";
+      output.push(indent(3, `<TextSample sampleTime="${secondsToTimestamp(chapter.startTime, { milliseconds: true })}"${attrContent}>${content}</TextSample>`));
+    });
+    output.push(
+      "</TextStream>"
+    );
+    return output.join(pretty ? "\n" : "");
+  }
+};
+
+// src/Formats/ChaptersJson.ts
+var ChaptersJson = class extends Base {
+  supportsPrettyPrint = true;
+};
+
+// src/Formats/FFMetadata.ts
+var FFMetadata = class extends Base {
+  filename = "FFMpegdata.txt";
+  mimeType = "text/plain";
+  characters = ["=", ";", "#", "\\", "\n"];
+  safeCharacters = this.characters.map((char) => escapeRegExpCharacters(char)).join("|");
+  unescapeRegexp = new RegExp("\\\\(" + this.safeCharacters + ")", "g");
+  escapeRegexp = new RegExp("(" + this.safeCharacters + ")", "g");
+  detect(inputString) {
+    return inputString.trim().slice(0, 12) === ";FFMETADATA1";
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error(";FFMETADATA1 header missing :(");
+    }
+    const lines = stringToLines(string);
+    const chapters = [];
+    let ignoreAllUntilNextChapter = false;
+    let isMultilineTitle = false;
+    lines.forEach((line) => {
+      const [key, value] = line.split("=");
+      if (chapters.length === 0 && key === "title") {
+        this.meta.title = this.unescape(value);
+        return;
+      }
+      if (line === "[CHAPTER]") {
+        const c = { startTime: 0 };
+        chapters.push(c);
+        ignoreAllUntilNextChapter = false;
+        return;
+      }
+      if (line.slice(0, 1) === "[") {
+        ignoreAllUntilNextChapter = true;
+      }
+      if (chapters.length === 0 || ignoreAllUntilNextChapter) {
+        return;
+      }
+      if (!/[^\\]=/.test(line) && isMultilineTitle) {
+        chapters[chapters.length - 1].title += " " + line;
+        return;
+      }
+      isMultilineTitle = false;
+      if (key === "title") {
+        chapters[chapters.length - 1].title = this.unescape(value);
+        if (/\\$/.test(value)) {
+          isMultilineTitle = true;
+        }
+      } else if (key === "START") {
+        chapters[chapters.length - 1].startTime = enforceMilliseconds(parseFloat(value) * 1e-3);
+      } else if (key === "END") {
+        chapters[chapters.length - 1].endTime = enforceMilliseconds(parseFloat(value) * 1e-3);
+      }
+    });
+    this.chapters = chapters;
+  }
+  unescape(string) {
+    return string.replace(this.unescapeRegexp, "$1").replace(/\\$/g, "");
+  }
+  escape(string) {
+    return string.replace(this.escapeRegexp, "\\$1");
+  }
+  toString() {
+    const output = [";FFMETADATA1"];
+    if (this.meta.title.trim().length > 0) {
+      output.push(`title=${this.escape(this.meta.title)}`);
+    }
+    output.push("");
+    this.chapters.forEach((chapter) => {
+      output.push("[CHAPTER]", "TIMEBASE=1/1000");
+      output.push("START=" + enforceMilliseconds(chapter.startTime) * 1e3);
+      output.push("END=" + enforceMilliseconds(chapter.endTime) * 1e3);
+      if (chapter.title && chapter.title.trim().length > 0) {
+        output.push(`title=${this.escape(chapter.title)}`);
+      }
+      output.push("");
+    });
+    return output.join("\n");
+  }
+};
+
+// src/Formats/FFMpegInfo.ts
+var FFMpegInfo = class extends Base {
+  detect(inputString) {
+    return /^frame:\d/.test(inputString.trim());
+  }
+  parse(input) {
+    if (!this.detect(input)) {
+      throw new Error("input must start with frame:");
+    }
+    const matches = Array.from(input.matchAll(/frame:(\d+).*pts_time:([\d.]+)\r?\n/g));
+    this.chapters = matches.map((match) => {
+      const startTime = enforceMilliseconds(parseFloat(match[2]));
+      return {
+        startTime
+      };
+    });
+    this.rebuildChapterTitles();
+  }
+  toString() {
+    throw new Error("this class won't generate actual output");
+  }
+};
+
+// src/Formats/MKVMergeSimple.ts
+var MKVMergeSimple = class extends Base {
+  filename = "mkvmerge-chapters.txt";
+  mimeType = "text/plain";
+  zeroPad = 2;
+  detect(inputString) {
+    const re = new RegExp(`^CHAPTER${zeroPad(1, this.zeroPad)}`);
+    return re.test(inputString.trim());
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error(`File must start with CHAPTER${zeroPad(1, this.zeroPad)}`);
+    }
+    const lines = string.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => line.trim());
+    const chapters = [];
+    lines.forEach((line) => {
+      const match = /^CHAPTER(?<index>\d+)(?<key>NAME)?=(?<value>.*)/.exec(line);
+      if (!match?.groups) {
+        return true;
+      }
+      const index = Int(match.groups.index) - 1;
+      const key = match.groups.key === "NAME" ? "title" : "startTime";
+      const value = key === "startTime" ? timestampToSeconds(match.groups.value) : match.groups.value;
+      if (chapters[index]) {
+        chapters[index][key] = value;
+      } else {
+        chapters[index] = { [key]: value };
+      }
+    });
+    this.chapters = chapters;
+  }
+  toString() {
+    return this.chapters.map((chapter, index) => {
+      const i = zeroPad(index + 1, this.zeroPad);
+      const options = {
+        hours: true,
+        milliseconds: true
+      };
+      const output = [
+        `CHAPTER${i}=${secondsToTimestamp(chapter.startTime, options)}`
+      ];
+      if (chapter.title && chapter.title.trim().length > 0) {
+        output.push(`CHAPTER${i}NAME=${chapter.title}`);
+      }
+      return output.join("\n");
+    }).join("\n");
+  }
+};
+
+// src/Formats/MKVMergeXML.ts
+var MKVMergeXML = class extends MatroskaXML {
+  supportsPrettyPrint = true;
+  filename = "mkvmerge-chapters.xml";
+  mimeType = "text/xml";
+  chapterStringNodeName = "ChapterString";
+  inputTimeToSeconds(string) {
+    return timestampToSeconds(string);
+  }
+  secondsToOutputTime(seconds) {
+    return secondsToTimestamp(seconds, { hours: true, milliseconds: true });
+  }
+};
+
+// src/Formats/PySceneDetect.ts
+var PySceneDetect = class extends Base {
+  filename = "psd-scenes.csv";
+  mimeType = "text/csv";
+  detect(inputString) {
+    return ["Scene Number", "Timecode Lis"].includes(inputString.trim().slice(0, 12));
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error('File must start with "Scene Number" or "Timecode List"');
+    }
+    const lines = string.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => line.trim());
+    if (/^Timecode/.test(lines[0])) {
+      lines.shift();
+    }
+    lines.shift();
+    this.chapters = lines.map((line) => {
+      const cols = line.split(",");
+      return {
+        startTime: timestampToSeconds(cols[2]),
+        endTime: timestampToSeconds(cols[5])
+      };
+    });
+  }
+  toString(pretty = false, exportOptions = {}) {
+    const framerate = exportOptions.psdFramerate || 23.976;
+    const omitTimecodes = !!exportOptions.psdOmitTimecodes;
+    const lines = this.chapters.map((chapter, index) => {
+      const next = this.chapters[index + 1];
+      const endTime = next?.startTime || this.duration;
+      const l = endTime - chapter.startTime;
+      return [
+        index + 1,
+        // Scene Number
+        Math.round(chapter.startTime * framerate) + 1,
+        // Start Frame
+        secondsToTimestamp(chapter.startTime, { hours: true, milliseconds: true }),
+        // Start Timecode
+        Int(chapter.startTime * 1e3),
+        // Start Time (seconds)
+        Math.round(endTime * framerate),
+        // End Frame
+        secondsToTimestamp(endTime, { hours: true, milliseconds: true }),
+        // End Timecode
+        Int(endTime * 1e3),
+        // End Time (seconds)
+        Math.round((endTime - chapter.startTime) * framerate),
+        // Length (frames)
+        secondsToTimestamp(l, { hours: true, milliseconds: true }),
+        // Length (timecode)
+        Int(Math.ceil(l * 1e3))
+        // Length (seconds)
+      ];
+    });
+    const tl = "Timecode List:" + lines.slice(1).map((l) => l[2]).join(",");
+    const outputLines = lines.map((l) => l.join(","));
+    outputLines.unshift("Scene Number,Start Frame,Start Timecode,Start Time (seconds),End Frame,End Timecode,End Time (seconds),Length (frames),Length (timecode),Length (seconds)");
+    if (!omitTimecodes) {
+      outputLines.unshift(tl);
+    }
+    return outputLines.join("\n");
+  }
+};
+
+// src/Formats/VorbisComment.ts
+var VorbisComment = class extends MKVMergeSimple {
+  filename = "vorbis-comment.txt";
+  mimeType = "text/plain";
+  zeroPad = 3;
+};
+
+// src/Formats/WebVTT.ts
+var WebVTT = class extends Base {
+  filename = "webvtt-chapters.vtt";
+  mimeType = "text/vtt";
+  detect(inputString) {
+    return inputString.trim().slice(0, 6) === "WEBVTT";
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error("WEBVTT header missing :(");
+    }
+    const lines = string.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => line.trim());
+    const header = lines.shift().split(/\s*-\s*/);
+    if (header[1]) {
+      this.meta.title = header[1];
+    }
+    const chapters = [];
+    lines.forEach((line) => {
+      if (/^\d+$/.test(line)) {
+        chapters.push({});
+        return;
+      }
+      const index = chapters.length - 1;
+      const timestamps = /(.*)\s+-->\s+(.*)/.exec(line);
+      if (timestamps && timestamps.length === 3) {
+        chapters[index].startTime = timestampToSeconds(timestamps[1]);
+        chapters[index].endTime = timestampToSeconds(timestamps[2]);
+        return;
+      }
+      chapters[index].title = line;
+    });
+    this.chapters = chapters;
+  }
+  toString() {
+    const output = ["WEBVTT"];
+    if (this.meta.title.trim().length > 0) {
+      output[0] += " - " + this.meta.title.trim();
+    }
+    const options = { hours: true, milliseconds: true };
+    this.chapters.forEach((chapter, index) => {
+      output.push("");
+      output.push(
+        ...[
+          String(index + 1),
+          secondsToTimestamp(chapter.startTime, options) + " --> " + secondsToTimestamp(chapter.endTime, options),
+          this.ensureTitle(index)
+        ].filter((line) => String(line).trim().length > 0)
+      );
+    });
+    return output.join("\n");
+  }
+};
+
+// src/Formats/Youtube.ts
+var Youtube = class extends Base {
+  filename = "youtube-chapters.txt";
+  mimeType = "text/plain";
+  detect(inputString) {
+    return /^0?0:00(:00)?\s/.test(inputString.trim());
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error("Youtube Chapters *MUST* begin with (0)0:00(:00), received: " + string.substr(0, 10) + "...");
+    }
+    this.chapters = stringToLines(string).map((line) => {
+      const l = line.split(" ");
+      const timestamp = String(l.shift());
+      return {
+        startTime: timestampToSeconds(timestamp),
+        title: l.join(" ")
+      };
+    });
+  }
+  toString() {
+    const options = {
+      milliseconds: false,
+      hours: this.chapters.at(-1).startTime > 3600
+    };
+    return this.chapters.map((chapter, index) => {
+      const startTime = index === 0 && chapter.startTime !== 0 ? 0 : chapter.startTime;
+      return `${secondsToTimestamp(startTime, options)} ${this.ensureTitle(index)}`;
+    }).join("\n");
+  }
+};
+
+// src/Formats/ShutterEDL.ts
+var ShutterEDL = class extends Base {
+  // this format is based on the shutter encoder edl format
+  // https://github.com/paulpacifico/shutter-encoder/blob/f3d6bb6dfcd629861a0b0a50113bf4b062e1ba17/src/application/SceneDetection.java
+  detect(inputString) {
+    return /^TITLE:\s.*\r?\n/.test(inputString.trim());
+  }
+  decodeTime(timeString) {
+    return timeString.replace(/:(\d+)$/, ".$10");
+  }
+  encodeTime(time) {
+    const string = secondsToTimestamp(time, { milliseconds: true });
+    const ms = String(Math.ceil(Int(string.split(".").pop()) * 0.1));
+    return string.replace(/\.(\d+)$/, `:${ms.padStart(2, "0")}`);
+  }
+  parse(input) {
+    if (!this.detect(input)) {
+      throw new Error("input must start with TITLE:");
+    }
+    const titleMatch = input.match(/^TITLE:\s(.*)\r?\n/);
+    this.meta.title = titleMatch?.[1] ?? "Chapters";
+    this.chapters = Array.from(input.matchAll(/(?<index>\d{6})\s+(?<title>[^\s]+)\s+\w+\s+\w+\s+(?<startTime>\d\d:\d\d:\d\d:\d\d)\s+(?<endTime>\d\d:\d\d:\d\d:\d\d)/g)).reduce((acc, match) => {
+      if (!match?.groups) {
+        return acc;
+      }
+      const startTime = timestampToSeconds(this.decodeTime(match.groups.startTime));
+      const endTime = timestampToSeconds(this.decodeTime(match.groups.endTime));
+      const title = match.groups.title;
+      const last = acc.at(-1);
+      if (last?.startTime === startTime) {
+        return acc;
+      }
+      acc.push({
+        startTime,
+        endTime,
+        title
+      });
+      return acc;
+    }, []);
+  }
+  toString() {
+    const tracks = ["V", "A", "A2"];
+    const output = this.chapters.reduce((acc, chapter, i) => {
+      const index = i * 3 + 1;
+      const startTime = this.encodeTime(chapter.startTime);
+      const endTime = this.encodeTime(chapter.endTime);
+      for (let j = 0; j < 3; j++) {
+        acc.push(`${(j + index).toString().padStart(6, "0")} ${chapter.title} ${tracks[j]}${" ".repeat(6 - tracks[j].length)}C        ${startTime} ${endTime} ${startTime} ${endTime}`);
+      }
+      return acc;
+    }, []);
+    output.unshift("TITLE: " + (this.meta.title ?? "Chapters"));
+    return output.join("\n");
+  }
+};
+
+// src/Formats/PodloveSimpleChapters.ts
+import { JSDOM as JSDOM3 } from "jsdom";
+var PodloveSimpleChapters = class extends Base {
+  supportsPrettyPrint = true;
+  filename = "podlove-simple-chapters-fragment.xml";
+  mimeType = "text/xml";
+  detect(inputString) {
+    return inputString.includes("<psc:chapters");
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error("Input must contain <psc:chapters ...> node");
+    }
+    let dom;
+    if (typeof DOMParser !== "undefined") {
+      dom = new DOMParser().parseFromString(string, "application/xml");
+    } else {
+      dom = new JSDOM3(string, { contentType: "application/xml" });
+      dom = dom.window.document;
+    }
+    this.chapters = [...dom.querySelectorAll("[start]")].reduce((acc, node) => {
+      if (node.tagName === "psc:chapter") {
+        const start = node.getAttribute("start");
+        const title = node.getAttribute("title");
+        const image = node.getAttribute("image");
+        const href = node.getAttribute("href");
+        const chapter = {
+          startTime: NPTToSeconds(start)
+        };
+        if (title) {
+          chapter.title = title;
+        }
+        if (image) {
+          chapter.img = image;
+        }
+        if (href) {
+          chapter.url = href;
+        }
+        acc.push(chapter);
+      }
+      return acc;
+    }, []);
+  }
+  toString(pretty = false) {
+    const indent = indenter(pretty ? 2 : 0);
+    const output = [
+      '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">',
+      indent(1, "<channel>"),
+      indent(2, "<!-- this is only a fragment of an rss feed, see -->"),
+      indent(2, "<!-- https://podlove.org/simple-chapters/#:~:text=37%20seconds-,Embedding%20Example,-This%20is%20an -->"),
+      indent(2, "<!-- for more information -->"),
+      indent(2, '<psc:chapters version="1.2" xmlns:psc="http://podlove.org/simple-chapters">')
+    ];
+    this.chapters.forEach((chapter) => {
+      const node = [
+        `<psc:chapter start="${secondsToNPT(chapter.startTime)}"`
+      ];
+      if (chapter.title) {
+        node.push(` title="${chapter.title}"`);
+      }
+      if (chapter.img) {
+        node.push(` image="${chapter.img}"`);
+      }
+      if (chapter.url) {
+        node.push(` href="${chapter.url}"`);
+      }
+      node.push("/>");
+      output.push(indent(3, node.join("")));
+    });
+    output.push(
+      indent(2, "</psc:chapters>"),
+      indent(1, "</channel>"),
+      indent(0, "</rss>")
+    );
+    return output.join(pretty ? "\n" : "");
+  }
+};
+
+// src/Formats/MP4Chaps.ts
+var MP4Chaps = class extends Base {
+  filename = "mp4chaps.txt";
+  mimeType = "text/plain";
+  detect(inputString) {
+    return /^\d\d:\d\d:\d\d.\d\d?\d?\s/.test(inputString.trim());
+  }
+  parse(string) {
+    if (!this.detect(string)) {
+      throw new Error("MP4Chaps *MUST* begin with 00:00:00, received: " + string.substr(0, 10) + "...");
+    }
+    this.chapters = stringToLines(string).map((line) => {
+      const l = line.split(" ");
+      const startTime = timestampToSeconds(l.shift());
+      const [title, href] = l.join(" ").split("<");
+      const chapter = {
+        startTime,
+        title: title.trim()
+      };
+      if (href) {
+        chapter.url = href.replace(">", "");
+      }
+      return chapter;
+    });
+  }
+  toString() {
+    return this.chapters.map((chapter) => {
+      const line = [];
+      line.push(secondsToTimestamp(chapter.startTime, { milliseconds: true }));
+      line.push(chapter.title);
+      if (chapter.url) {
+        line.push(`<${chapter.url}>`);
+      }
+      return line.join(" ");
+    }).join("\n");
+  }
+};
+
+// src/Formats/PodloveJson.ts
+var PodloveJson = class extends Base {
+  filename = "podlove-chapters.json";
+  mimeType = "application/json";
+  test(data) {
+    if (!Array.isArray(data)) {
+      return { errors: ["JSON Structure: must be an array"] };
+    }
+    if (data.length === 0) {
+      return { errors: ["JSON Structure: must not be empty"] };
+    }
+    if (!data.every((chapter) => "start" in chapter)) {
+      return { errors: ["JSON Structure: every chapter must have a start property"] };
+    }
+    return { errors: [] };
+  }
+  parse(string) {
+    const data = JSON.parse(string);
+    const { errors } = this.test(data);
+    if (errors.length > 0) {
+      throw new Error(errors.join(""));
+    }
+    this.chapters = data.map((raw) => {
+      const { start, title, image, href } = raw;
+      const chapter = {
+        startTime: timestampToSeconds(start)
+      };
+      if (title) {
+        chapter.title = title;
+      }
+      if (image) {
+        chapter.img = image;
+      }
+      if (href) {
+        chapter.url = href;
+      }
+      return chapter;
+    });
+  }
+  toString(pretty = false) {
+    return JSON.stringify(this.chapters.map((chapter, i) => ({
+      start: secondsToTimestamp(chapter.startTime, { milliseconds: true }),
+      title: this.ensureTitle(i),
+      image: chapter.img ?? "",
+      href: chapter.url ?? ""
+    })), null, pretty ? 2 : 0);
+  }
+};
+
+// src/Formats/AppleHLS.ts
+var AppleHLS = class extends Base {
+  filename = "apple-hls.json";
+  mimeType = "application/json";
+  supportsPrettyPrint = true;
+  titleLanguage = "en";
+  imageDims = [1280, 720];
+  test(data) {
+    if (!Array.isArray(data)) {
+      return { errors: ["JSON Structure: must be an array"] };
+    }
+    if (data.length === 0) {
+      return { errors: ["JSON Structure: must not be empty"] };
+    }
+    if (!data.every((chapter) => "chapter" in chapter && "start-time" in chapter)) {
+      return { errors: ["JSON Structure: every chapter must have a chapter and a start-time property"] };
+    }
+    return { errors: [] };
+  }
+  parse(string) {
+    const data = JSON.parse(string);
+    const { errors } = this.test(data);
+    if (errors.length > 0) {
+      throw new Error(errors.join(""));
+    }
+    this.chapters = data.map((raw) => {
+      const chapter = {
+        startTime: parseFloat(raw["start-time"])
+      };
+      if ("titles" in raw && raw.titles.length > 0) {
+        chapter.title = raw.titles[0].title;
+      }
+      if ("images" in raw && raw.images.length > 0) {
+        chapter.img = raw.images[0].url;
+      }
+      return chapter;
+    });
+  }
+  toString(pretty = false) {
+    return JSON.stringify(this.chapters.map((c, i) => {
+      const chapter = {
+        "start-time": c.startTime,
+        chapter: i + 1,
+        titles: [
+          {
+            title: this.ensureTitle(i),
+            language: this.titleLanguage
+          }
+        ]
+      };
+      if (c.img) {
+        chapter.images = [
+          {
+            "image-category": "chapter",
+            url: c.img,
+            "pixel-width": this.imageDims[0],
+            "pixel-height": this.imageDims[1]
+          }
+        ];
+      }
+      return chapter;
+    }), null, pretty ? 2 : 0);
+  }
+};
+
+// src/Formats/Scenecut.ts
+var Scenecut = class extends Base {
+  filename = "scene-cuts.json";
+  mimeType = "application/json";
+  frameRate = 30;
+  /**
+     * The number "1001" in the context of video processing and multimedia, especially in relation to frame rates and timecodes, is often associated with the NTSC color system used in North America and Japan.
+     * In this system, the frame rate is often described as "29.97 frames per second", but it's technically 30000/1001 frames per second, which is approximately 29.97 but not exactly. This is known as a "drop frame" rate, and the "1001" comes from this fractional frame rate.
+    */
+  ptsScale = 1;
+  score = 0.5;
+  test(data) {
+    if (!Array.isArray(data)) {
+      return { errors: ["JSON Structure: must be an array"] };
+    }
+    if (data.length === 0) {
+      return { errors: ["JSON Structure: must not be empty"] };
+    }
+    if (!data.every((chapter) => "pts_time" in chapter)) {
+      return { errors: ["JSON Structure: every chapter must have a start property"] };
+    }
+    return { errors: [] };
+  }
+  parse(string) {
+    const data = JSON.parse(string);
+    const { errors } = this.test(data);
+    if (errors.length > 0) {
+      throw new Error(errors.join(""));
+    }
+    this.chapters = data.map((raw) => {
+      const chapter = {
+        startTime: Float(raw.pts_time)
+      };
+      this.frameRate = raw.pts / raw.pts_time;
+      return chapter;
+    });
+  }
+  toString(pretty = false, exportOptions = {}) {
+    const frameRate = Float("frameRate" in exportOptions ? exportOptions.frameRate : this.frameRate);
+    const ptsScale = Float("ptsScale" in exportOptions ? exportOptions.ptsScale : this.ptsScale);
+    const score = Float("score" in exportOptions ? exportOptions.score : this.score);
+    return JSON.stringify(this.chapters.map((chapter) => ({
+      frame: Math.round(chapter.startTime * frameRate),
+      pts: Math.round(chapter.startTime * frameRate * ptsScale).toFixed(3),
+      pts_time: chapter.startTime,
+      score
+    })), null, pretty ? 2 : 0);
+  }
+};
+
+// src/Formats/AutoFormat.ts
+var classMap = {
+  chaptersjson: ChaptersJson,
+  ffmetadata: FFMetadata,
+  matroskaxml: MatroskaXML,
+  mkvmergexml: MKVMergeXML,
+  mkvmergesimple: MKVMergeSimple,
+  webvtt: WebVTT,
+  youtube: Youtube,
+  ffmpeginfo: FFMpegInfo,
+  pyscenedetect: PySceneDetect,
+  vorbiscomment: VorbisComment,
+  applechapters: AppleChapters,
+  shutteredl: ShutterEDL,
+  psc: PodloveSimpleChapters,
+  mp4chaps: MP4Chaps,
+  podlovejson: PodloveJson,
+  applehls: AppleHLS,
+  scenecut: Scenecut
+};
+var AutoFormat = {
+  classMap,
+  detect(inputString, returnWhat = "instance") {
+    let detected;
+    for (const [key, className] of Object.entries(this.classMap)) {
+      try {
+        detected = className.create(inputString);
+        if (detected) {
+          if (returnWhat === "class") {
+            return className;
+          } else if (returnWhat === "key") {
+            return key;
+          }
+          return detected;
+        }
+      } catch (e) {
+      }
+    }
+    if (!detected) {
+      throw new Error("failed to detect type of given input :(");
+    }
+  },
+  from(inputString) {
+    return this.detect(inputString);
+  },
+  as(classKeyOrClass, input) {
+    if (typeof classKeyOrClass === "string") {
+      if (!(classKeyOrClass in this.classMap)) {
+        throw new Error(`invalid class key "${classKeyOrClass}"`);
+      }
+      return this.classMap[classKeyOrClass].create(input);
+    }
+    return classKeyOrClass.create(input);
+  }
+};
+export {
+  AppleChapters,
+  AppleHLS,
+  AutoFormat,
+  ChaptersJson,
+  FFMetadata,
+  FFMpegInfo,
+  MKVMergeSimple,
+  MKVMergeXML,
+  MP4Chaps,
+  MatroskaXML,
+  PodloveJson,
+  PodloveSimpleChapters,
+  PySceneDetect,
+  Scenecut,
+  ShutterEDL,
+  util_exports as Util,
+  VorbisComment,
+  WebVTT,
+  Youtube
+};