@amazon/vinyl-mpd-parser 1.0.0

package/dist/test/benchmark.js

@@ -0,0 +1,4497 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+  // ../vinyl-util/dist/browserTestUtil/index.js
+  var __defProp2 = Object.defineProperty;
+  var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+  var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues2 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    if (__getOwnPropSymbols2)
+      for (var prop of __getOwnPropSymbols2(b)) {
+        if (__propIsEnum2.call(b, prop))
+          __defNormalProp2(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __objRest = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp2.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols2)
+      for (var prop of __getOwnPropSymbols2(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum2.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
+  var __publicField = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var createSpy = jasmine.createSpy;
+  function createSpy2(key) {
+    return createSpy(String(key));
+  }
+  var MockAbortSignal = class {
+    constructor() {
+      __publicField(this, "aborted", false);
+      __publicField(this, "onabort", null);
+      __publicField(this, "reason");
+      __publicField(this, "throwIfAborted", createSpy2("throwIfAborted"));
+      __publicField(this, "addEventListener", createSpy2("addEventListener"));
+      __publicField(this, "removeEventListener", createSpy2(
+        "removeEventListener"
+      ));
+      __publicField(this, "dispatchEvent", createSpy2("dispatchEvent"));
+    }
+  };
+  var MockMediaSource = class {
+    constructor() {
+      __publicField(this, "activeSourceBuffers");
+      __publicField(this, "duration", 0);
+      __publicField(this, "onsourceclose", null);
+      __publicField(this, "onsourceended", null);
+      __publicField(this, "onsourceopen", null);
+      __publicField(this, "readyState", "closed");
+      __publicField(this, "sourceBuffers");
+      __publicField(this, "addSourceBuffer", createSpy2("addSourceBuffer"));
+      __publicField(this, "clearLiveSeekableRange", createSpy2(
+        "clearLiveSeekableRange"
+      ));
+      __publicField(this, "endOfStream", createSpy2("endOfStream"));
+      __publicField(this, "removeSourceBuffer", createSpy2("removeSourceBuffer"));
+      __publicField(this, "setLiveSeekableRange", createSpy2(
+        "setLiveSeekableRange"
+      ));
+      __publicField(this, "addEventListener", createSpy2("addEventListener"));
+      __publicField(this, "removeEventListener", createSpy2(
+        "removeEventListener"
+      ));
+      __publicField(this, "dispatchEvent", createSpy2("dispatchEvent"));
+    }
+  };
+  var MockMediaSourceGlobal = class extends MockMediaSource {
+  };
+  __publicField(MockMediaSourceGlobal, "canConstructInDedicatedWorker", false);
+  __publicField(MockMediaSourceGlobal, "isTypeSupported", createSpy2(
+    "isTypeSupported"
+  ));
+  var MockAbortSignalGlobal = class extends MockAbortSignal {
+  };
+  __publicField(MockAbortSignalGlobal, "abort", createSpy2("abort"));
+  __publicField(MockAbortSignalGlobal, "any", createSpy2("any"));
+  __publicField(MockAbortSignalGlobal, "timeout", createSpy2("timeout"));
+  function expectNothing() {
+    expect(true).toBeTruthy();
+  }
+  var nextTestTimeoutOverridden = false;
+  function setTestTimeout(timeout) {
+    let originalTimeout = null;
+    beforeEach(() => {
+      originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+      if (!nextTestTimeoutOverridden)
+        jasmine.DEFAULT_TIMEOUT_INTERVAL = timeout * 1e3;
+    });
+    afterEach(() => {
+      if (originalTimeout) jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+      if (nextTestTimeoutOverridden) nextTestTimeoutOverridden = false;
+    });
+  }
+  var now;
+  if (typeof window !== "undefined" && typeof window.performance !== "undefined" && typeof window.performance.now !== "undefined") {
+    now = () => window.performance.now();
+  } else if (typeof self !== "undefined" && typeof self.performance !== "undefined" && typeof self.performance.now !== "undefined") {
+    now = () => self.performance.now();
+  } else {
+    now = () => Date.now();
+  }
+  var BenchmarkRunResults = class {
+    constructor(name) {
+      this.name = name;
+      __publicField(this, "cycleResults", []);
+      __publicField(this, "_totalSamples", 0);
+    }
+    get totalSamples() {
+      return this._totalSamples;
+    }
+    get cycleResultsNoOutliers() {
+      const sD = this.standardDeviation;
+      const avg = average(this.cycleResults);
+      return this.cycleResults.filter((e) => {
+        const zScore = (avg - e) / sD;
+        return Math.abs(zScore) < 3;
+      });
+    }
+    /**
+     * Returns the mean ops per second minus outliers of greater than 3 standard deviations.
+     */
+    get meanOpsPerSec() {
+      return average(this.cycleResultsNoOutliers);
+    }
+    get standardDeviation() {
+      return standardDeviation(this.cycleResults);
+    }
+    get variance() {
+      return this.standardDeviation / this.meanOpsPerSec;
+    }
+    /**
+     * Returns the mean ops / s ± variance % as a string.
+     */
+    get meanOpsStr() {
+      const mean = this.meanOpsPerSec.toLocaleString(void 0, {
+        maximumSignificantDigits: 4
+      });
+      const variance = this.variance.toLocaleString(void 0, {
+        style: "percent"
+      });
+      return `${mean} \xB1${variance}`;
+    }
+    add(cycle) {
+      const opsPerSecond = cycle.ops / cycle.duration;
+      let index = this.cycleResults.findIndex((value) => opsPerSecond < value);
+      if (index < 0) index = this.cycleResults.length;
+      this.cycleResults.splice(index, 0, opsPerSecond);
+      this._totalSamples += cycle.ops;
+    }
+    toString() {
+      if (!this.cycleResults.length) return "No results";
+      return `${this.name}: ${this.meanOpsStr} ops/sec`;
+    }
+  };
+  var RunResultsComparison = class {
+    constructor(name, results) {
+      this.name = name;
+      __publicField(this, "results");
+      this.results = results.sort((a, b) => {
+        return a.meanOpsPerSec - b.meanOpsPerSec;
+      });
+    }
+    logToTable() {
+      const r = this.results.map((run) => {
+        const variance = run.variance.toLocaleString(void 0, {
+          style: "percent"
+        });
+        const mean = run.meanOpsPerSec.toLocaleString(void 0, {
+          maximumSignificantDigits: 4
+        });
+        return {
+          Name: run.name,
+          Mean: `${mean} \xB1${variance}`,
+          Samples: run.totalSamples,
+          Compare: this.runComparisonToString(run)
+        };
+      });
+      const table = r.reduce((acc, _a2) => {
+        var _b = _a2, { Name } = _b, x = __objRest(_b, ["Name"]);
+        acc[Name] = x;
+        return acc;
+      }, {});
+      console.log("\n" + this.name);
+      console.table(table);
+    }
+    runComparisonToString(run) {
+      var _a2, _b;
+      const baseline = (_b = (_a2 = this.results[0]) == null ? void 0 : _a2.meanOpsPerSec) != null ? _b : 0;
+      const fasterPercent = run.meanOpsPerSec / baseline - 1;
+      return fasterPercent < 0.01 ? "-" : fasterPercent.toLocaleString(void 0, {
+        style: "percent"
+      }) + " faster";
+    }
+  };
+  function compareResults(name, ...results) {
+    return new RunResultsComparison(name, results);
+  }
+  var defaultBenchmarkOptions = {
+    warmupTime: 0.5,
+    maxCycleDuration: 0.5,
+    cycles: 9
+  };
+  var _Benchmark = class _Benchmark2 {
+    /**
+     * Constructs a new Benchmark.
+     *
+     * @param name The name of the benchmark, to be used when logging.
+     * @param executor The method to execute and measure. If this method returns a promise, the
+     * promise will be awaited. The executor should either always return a promise, or never.
+     * @param options Optional configuration for the benchmark.
+     */
+    constructor(name, executor, options) {
+      this.name = name;
+      this.executor = executor;
+      __publicField(this, "options");
+      this.options = __spreadValues2(__spreadValues2({}, defaultBenchmarkOptions), options);
+    }
+    async run() {
+      const opts = this.options;
+      await _Benchmark2.semaphore;
+      const warmupTimeMs = opts.warmupTime * 1e3;
+      const cycleStart = now();
+      let isAsync = false;
+      do {
+        const result = this.executor();
+        isAsync = isAsync || result && typeof result.then === "function";
+        if (isAsync) await result;
+      } while (now() - cycleStart < warmupTimeMs);
+      const resultsPromise = (async () => {
+        const results = new BenchmarkRunResults(this.name);
+        for (let i = 0; i < opts.cycles; i++) {
+          const cycleResults = await this.runCycle(isAsync);
+          results.add(cycleResults);
+          await nextFrame();
+        }
+        return results;
+      })();
+      _Benchmark2.semaphore = resultsPromise;
+      return await resultsPromise;
+    }
+    /**
+     * Runs one cycle. A cycle will repeat the executor approximately `options.maxCycleDuration`
+     * seconds.
+     *
+     * @param isAsync
+     * @return Returns the duration (in seconds) and number of operations the cycle repeated.
+     */
+    async runCycle(isAsync) {
+      const cycleMs = this.options.maxCycleDuration * 1e3;
+      let ops = 0;
+      const cycleStart = now();
+      do {
+        const result = this.executor();
+        if (isAsync) await result;
+        ops++;
+      } while (now() - cycleStart < cycleMs);
+      const duration = (now() - cycleStart) / 1e3;
+      return {
+        duration,
+        ops
+      };
+    }
+  };
+  __publicField(_Benchmark, "semaphore", nextFrame());
+  var Benchmark = _Benchmark;
+  function benchmark(name, executor, options) {
+    const benchmark2 = new Benchmark(name, executor, options);
+    return benchmark2.run().then((results) => {
+      console.log(results.toString());
+      return results;
+    });
+  }
+  function nextFrame() {
+    return new Promise((resolve) => {
+      setTimeout(resolve);
+    });
+  }
+  function standardDeviation(values) {
+    const avg = average(values);
+    const squareDiffs = values.map((value) => {
+      const diff = value - avg;
+      return diff * diff;
+    });
+    const avgSquareDiff = average(squareDiffs);
+    return Math.sqrt(avgSquareDiff);
+  }
+  function average(values) {
+    const sum = values.reduce((acc, value) => acc + value, 0);
+    return sum / values.length;
+  }
+  var createSpy3 = jasmine.createSpy;
+
+  // test/benchmark/setup.ts
+  function setupBenchmark() {
+    setTestTimeout(180);
+    afterEach(expectNothing);
+  }
+  var comparisons = [];
+  function addComparison(comparison) {
+    comparisons.push(comparison);
+  }
+  function addBenchmarks(name, ...results) {
+    const comparison = compareResults(name, ...results);
+    comparison.logToTable();
+    comparisons.push(comparison);
+  }
+  if (typeof document !== "undefined") {
+    jasmine.getEnv().addReporter({
+      jasmineDone: () => {
+        var _a2;
+        console.log("Tests complete");
+        const jasmineContainer = document.getElementsByClassName(
+          "jasmine_html-reporter"
+        )[0];
+        (_a2 = jasmineContainer.parentElement) == null ? void 0 : _a2.removeChild(jasmineContainer);
+        const container = createEl("div", document.body);
+        container.id = "benchmarkResults";
+        const sortedComparisons = [...comparisons].sort(
+          (a, b) => a.name > b.name ? 1 : -1
+        );
+        for (const comparison of sortedComparisons) {
+          toTableHtml(comparison, container);
+        }
+      }
+    });
+  }
+  function toTableHtml(comparison, parent) {
+    const container = createEl("div", parent);
+    container.className = "benchmarkComparison";
+    const title = createEl("h2", container);
+    title.innerText = comparison.name;
+    const table = createEl("table", container);
+    const head = createEl("thead", table);
+    const headRow = createEl("tr", head);
+    const name = createEl("th", headRow);
+    name.innerText = "Name";
+    const median = createEl("th", headRow);
+    median.innerText = "Mean ops/s";
+    const samples = createEl("th", headRow);
+    samples.innerText = "Samples";
+    const compare = createEl("th", headRow);
+    compare.innerText = "% Comparison";
+    const body = createEl("tbody", table);
+    comparison.results.forEach((result) => {
+      const row = createEl("tr", body);
+      createEl("th", row).innerText = result.name;
+      createEl("td", row).innerText = result.meanOpsStr;
+      createEl("td", row).innerText = result.totalSamples.toLocaleString();
+      createEl("td", row).innerText = comparison.runComparisonToString(result);
+    });
+    return container;
+  }
+  function createEl(tagName, parent, options) {
+    const element2 = document.createElement(tagName, options);
+    if (parent) parent.appendChild(element2);
+    return element2;
+  }
+
+  // src/xmlns/mpeg/cenc/2013.ts
+  var CENC_NAMESPACE_URI = "urn:mpeg:cenc:2013";
+
+  // src/xmlns/microsoft/playready.ts
+  var PLAY_READY_NAMESPACE_URI = "urn:microsoft:playready";
+
+  // ../vinyl-util/dist/index.js
+  var __defProp3 = Object.defineProperty;
+  var __defProps2 = Object.defineProperties;
+  var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols3 = Object.getOwnPropertySymbols;
+  var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+  var __propIsEnum3 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues3 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp3.call(b, prop))
+        __defNormalProp3(a, prop, b[prop]);
+    if (__getOwnPropSymbols3)
+      for (var prop of __getOwnPropSymbols3(b)) {
+        if (__propIsEnum3.call(b, prop))
+          __defNormalProp3(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+  var __publicField2 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  function invariant() {
+    return void 0;
+  }
+  var ErrorOrigin = {
+    /**
+     * The error originated from Vinyl and was reported from the uncaught exception or promise
+     * rejection handlers.
+     */
+    UNCAUGHT: "uncaught",
+    /**
+     * The error originated from Vinyl and was caught.
+     */
+    INTERNAL: "internal",
+    /**
+     * A Vinyl interface was used incorrectly by a consumer.
+     */
+    API: "api",
+    /**
+     * The error originated from a failed service call (500 errors).
+     */
+    SERVICE_EXTERNAL: "serviceExternal",
+    /**
+     * The error originated from a failed service call (400 errors).
+     */
+    SERVICE_INTERNAL: "serviceInternal",
+    /**
+     * The error originated from a problem playing provided media.
+     * The reporter is from a component such as the element, source buffer, media source, etc.
+     */
+    MEDIA: "media",
+    /**
+     * The error originated from a problem parsing input data.
+     * Such as a malformed Dash or HLS manifest.
+     */
+    PARSING: "parsing",
+    /**
+     * The error originated from an incompatibility with browser APIs,
+     * such as EME.
+     */
+    COMPATIBILITY: "compatibility",
+    /**
+     * The error originated from DRM.
+     * This does not include internal or service errors, only errors from the creation of media keys or media key
+     * sessions.
+     */
+    DRM: "drm"
+  };
+  var ReportableError = class _ReportableError extends Error {
+    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal") {
+      super(message);
+      this.origin = origin;
+      this.level = level;
+      Object.setPrototypeOf(this, _ReportableError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "ReportableError";
+    }
+    get name() {
+      return this[Symbol.toStringTag];
+    }
+    /**
+     * All ReportableError instances must be serializable.
+     */
+    toJSON() {
+      return {
+        level: this.level,
+        message: this.message,
+        name: this.name,
+        origin: this.origin,
+        stack: this.stack
+      };
+    }
+  };
+  var IllegalArgumentError = class _IllegalArgumentError extends ReportableError {
+    constructor(message, isInternal = true) {
+      super(message, isInternal ? ErrorOrigin.INTERNAL : ErrorOrigin.API);
+      this.isInternal = isInternal;
+      Object.setPrototypeOf(this, _IllegalArgumentError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "IllegalArgumentError";
+    }
+  };
+  function getOrSet(map2, key, defaultValue) {
+    if (map2.has(key)) {
+      return map2.get(key);
+    } else {
+      const value = defaultValue(key);
+      map2.set(key, value);
+      return value;
+    }
+  }
+  var locale = {
+    variableNotDefined: "Variable '{name}' is not defined"
+  };
+  var DEFAULT_SUBSTITUTE_PATTERN = /\{(\w+)}/g;
+  function substitute(str, variables, pattern = DEFAULT_SUBSTITUTE_PATTERN) {
+    return str.replace(pattern, (_, name) => {
+      if (!(name in variables)) {
+        throw new IllegalArgumentError(
+          locale.variableNotDefined.replace("{name}", String(name))
+        );
+      }
+      return String(variables[name]);
+    });
+  }
+  function isWhitespaceChar(charCode) {
+    return charCode === 32 || // ' ' (space)
+    charCode === 9 || // '\t' (tab)
+    charCode === 13 || // '\r' (carriage return)
+    charCode === 10;
+  }
+  var encodedEntitiesRegex = /&(#(\d+)|\w+);/gi;
+  var predefinedDecodeEntities = /* @__PURE__ */ new Map([
+    ["apos", "'"],
+    ["amp", "&"],
+    ["lt", "<"],
+    ["gt", ">"],
+    ["quot", '"']
+  ]);
+  function decodeEntities(str, namedEntities = predefinedDecodeEntities) {
+    if (encodedEntitiesRegex.test(str)) {
+      return str.replace(
+        encodedEntitiesRegex,
+        (substring, entityName, codePoint) => {
+          if (codePoint !== void 0)
+            return String.fromCharCode(parseInt(codePoint));
+          const entityValue = namedEntities.get(entityName.toLowerCase());
+          if (!entityValue) return substring;
+          return entityValue;
+        }
+      );
+    } else {
+      return str;
+    }
+  }
+  function eqStr(a, b, ignoreCase = false) {
+    if (a == null && b == null) return true;
+    if (a == null || b == null) return false;
+    if (a === b) return true;
+    if (ignoreCase)
+      return a.length === b.length && a.toLowerCase() === b.toLowerCase();
+    return false;
+  }
+  function char(str) {
+    return str.charCodeAt(0);
+  }
+  function truncate(str, maxLength, indicator = "\u2026") {
+    if (str == null) return str;
+    if (str.length > maxLength)
+      return str.substring(0, maxLength - indicator.length) + indicator;
+    return str;
+  }
+  function clamp(value, min2, max2) {
+    return Math.min(Math.max(value, min2), max2);
+  }
+  function roundToNearest(value, snap, offset = 0) {
+    return Math.round((value - offset) / snap) * snap + offset;
+  }
+  function printStringPosition(str, index, options) {
+    var _a2;
+    const caret = (options == null ? void 0 : options.caret) || "^";
+    index = clamp(index, 0, str.length);
+    const minIndex = str.lastIndexOf("\n", index - 1) + 1;
+    let maxIndex = str.indexOf("\n", index);
+    if (maxIndex === -1) maxIndex = str.length;
+    const split = (options == null ? void 0 : options.split) === void 0 ? 0.6 : options.split;
+    const cols = ((_a2 = options == null ? void 0 : options.maxColumns) != null ? _a2 : 60) - caret.length;
+    let leadingChars = cols * split;
+    let trailingChars = cols * (1 - split);
+    const maxLeadingChars = index - minIndex;
+    const maxTrailingChars = maxIndex - index;
+    if (leadingChars > maxLeadingChars) {
+      trailingChars += leadingChars - maxLeadingChars;
+      leadingChars = maxLeadingChars;
+      if (trailingChars > maxTrailingChars) trailingChars = maxTrailingChars;
+    } else if (trailingChars > maxTrailingChars) {
+      leadingChars += trailingChars - maxTrailingChars;
+      trailingChars = maxTrailingChars;
+      if (leadingChars > maxLeadingChars) leadingChars = maxLeadingChars;
+    }
+    let out = str.substring(index - leadingChars, index + trailingChars) + "\n";
+    out += " ".repeat(leadingChars) + caret;
+    return out;
+  }
+  var StringReader = class {
+    /**
+     * @param data The string to read.
+     */
+    constructor(data) {
+      this.data = data;
+      __publicField2(this, "position", 0);
+    }
+    /**
+     * Returns true if the current {@link position} is less than the source data's length.
+     */
+    hasNext() {
+      return this.position < this.data.length;
+    }
+    /**
+     * Returns the number of characters remaining to be read.
+     */
+    get remaining() {
+      return this.data.length - this.position;
+    }
+    /**
+     * Returns the length of {@link data}.
+     */
+    get length() {
+      return this.data.length;
+    }
+    /**
+     * Throws a {@link StringParseError} where the location uses {@link printStringPosition} to
+     * show a friendly message indicating the current position.
+     *
+     * @param message
+     * @param offset The offset to add to the current position.
+     */
+    err(message, offset = 0) {
+      throw new StringParseError(this.data, this.position + offset, message);
+    }
+    /**
+     * Reads and returns the character code at the current position.
+     * To read the next character without advancing the cursor, use {@link peek}
+     *
+     * Note:
+     * This method has no bounds checking; if {@link position} is greater than or equal to
+     * `str.length` then NaN will be returned and {@link position} will still be incremented.
+     *
+     * @see String.charCodeAt
+     */
+    next() {
+      return this.data.charCodeAt(this.position++);
+    }
+    /**
+     * Reads characters until the predicate returns false or the data length has been reached.
+     *
+     * @param predicate Given the char code at the cursor index, returns true if the character
+     * should be included in the substring result.
+     * @returns number The start position.
+     */
+    while(predicate) {
+      const start = this.position;
+      let i = start;
+      const n = this.data.length;
+      while (i < n && predicate(this.data.charCodeAt(i))) i++;
+      this.position = i;
+      return start;
+    }
+    /**
+     * Reads characters until the predicate returns true or the string length has been reached.
+     *
+     * @param predicate
+     * @returns number Returns the start index.
+     */
+    until(predicate) {
+      return this.while((charCode) => !predicate(charCode));
+    }
+    /**
+     * Reads characters until the given character has been found or the string length has been
+     * reached.
+     *
+     * @param charCode
+     * @return number Returns the start index.
+     */
+    untilChar(charCode) {
+      return this.until((cc) => cc === charCode);
+    }
+    /**
+     * Reads characters until the given string has been found or the string length has been
+     * reached.
+     *
+     * @param string The string to match
+     * @return number Returns the start index.
+     */
+    untilString(string) {
+      const start = this.position;
+      const index = this.data.indexOf(string, this.position);
+      this.position = index === -1 ? this.data.length : index;
+      return start;
+    }
+    /**
+     * The same as {@link while} except returns the read substring as a result.
+     */
+    substringWhile(predicate) {
+      return this.data.substring(this.while(predicate), this.position);
+    }
+    /**
+     * The same as {@link until} except returns the read substring as a result.
+     */
+    substringUntil(predicate) {
+      return this.substringWhile((charCode) => !predicate(charCode));
+    }
+    /**
+     * The same as {@link untilChar} except returns the read substring as a result.
+     */
+    substringUntilChar(charCode) {
+      return this.substringWhile((iCharCode) => charCode !== iCharCode);
+    }
+    /**
+     * Reads the substring from the current index with the given length.
+     *
+     * @param length
+     */
+    substr(length) {
+      const sub = this.data.substring(this.position, this.position + length);
+      this.position += sub.length;
+      return sub;
+    }
+    /**
+     * Reads the expected string from the current position.
+     * If the read string doesn't match the given string, a {@link StringParseError} is thrown.
+     *
+     * @param str The string required to match at the current position.
+     * @param ignoreCase If true, the comparison will be case-insensitive.
+     */
+    read(str, ignoreCase = false) {
+      const actual = this.substr(str.length);
+      if (!eqStr(actual, str, ignoreCase))
+        this.err(`Expected '${str}', actual: '${actual}'`);
+      return actual;
+    }
+    /**
+     * Reads the expected char code from the current position.
+     * If the read character doesn't match the given character, a {@link StringParseError} is
+     * thrown.
+     *
+     * @param charCode The character code required to match at the current position.
+     */
+    readChar(charCode) {
+      const actual = this.next();
+      if (actual !== charCode)
+        this.err(
+          `Expected '${String.fromCharCode(charCode)}', actual: '${String.fromCharCode(actual)}'`
+        );
+      return actual;
+    }
+    /**
+     * Returns the character at the current position without advancing the cursor.
+     *
+     * Note:
+     * This method has no bounds checking; if {@link position} is greater than or equal to
+     * `str.length` then `NaN` will be returned.
+     *
+     * @see String.charCodeAt
+     */
+    get peek() {
+      return this.data.charCodeAt(this.position);
+    }
+    /**
+     * Reads through all whitespace characters, returning the starting index.
+     */
+    white() {
+      return this.while(isWhitespaceChar);
+    }
+    /**
+     * If {@link peek} equals the given character code, returns true and advances the index by
+     * one.
+     *
+     * @param charCode
+     */
+    charIf(charCode) {
+      if (this.peek === charCode) {
+        this.next();
+        return true;
+      } else {
+        return false;
+      }
+    }
+    /**
+     * If the given string matches the substring at the current position, returns true and advances
+     * the index by the string's length.
+     */
+    stringIf(string, ignoreCase = false) {
+      if (this.remaining < string.length) return false;
+      const substr = this.data.substring(
+        this.position,
+        this.position + string.length
+      );
+      const match = eqStr(substr, string, ignoreCase);
+      if (match) this.position += string.length;
+      return match;
+    }
+  };
+  var locale2 = {
+    messageSeparator: ", at: \n"
+  };
+  var StringParseError = class _StringParseError extends ReportableError {
+    constructor(str, position, reason) {
+      const location2 = printStringPosition(str, position);
+      super(
+        `${reason}${locale2.messageSeparator}${location2}`,
+        ErrorOrigin.PARSING
+      );
+      this.position = position;
+      this.reason = reason;
+      __publicField2(this, "location");
+      this.location = location2;
+      Object.setPrototypeOf(this, _StringParseError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "StringParseError";
+    }
+    toJSON() {
+      return __spreadProps2(__spreadValues3({}, super.toJSON()), {
+        position: this.position,
+        location: this.location,
+        reason: this.reason
+      });
+    }
+  };
+  function union(a, b) {
+    return /* @__PURE__ */ new Set([...a, ...b]);
+  }
+  function ownKeys(obj) {
+    if (!obj) return /* @__PURE__ */ new Set();
+    if (typeof Reflect !== "undefined")
+      return new Set(Reflect.ownKeys(obj));
+    const properties = /* @__PURE__ */ new Set();
+    Object.getOwnPropertyNames(obj).forEach((item) => properties.add(item));
+    Object.getOwnPropertySymbols(obj).forEach((item) => properties.add(item));
+    return properties;
+  }
+  function isPlainObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      return false;
+    const proto = Object.getPrototypeOf(value);
+    return !proto || !Object.getPrototypeOf(proto);
+  }
+  function toJson(value) {
+    return toJsonInternal(value, /* @__PURE__ */ new Set());
+  }
+  function toJsonInternal(value, visited) {
+    switch (typeof value) {
+      case "object":
+        return objectToJsonInternal(value, visited);
+      case "undefined":
+      case "boolean":
+      case "number":
+      case "string":
+        return value;
+      case "function":
+        return `[function ${value.name}]`;
+      case "symbol":
+        return `[symbol ${value.toString().slice(7, -1)}]`;
+      case "bigint":
+        return value.toString();
+    }
+  }
+  function objectToJsonInternal(value, visited) {
+    if (value == null) return value;
+    if (visited.has(value)) return `<circular reference: ${String(value)}>`;
+    visited.add(value);
+    if ("toJSON" in value && typeof value.toJSON === "function")
+      return value.toJSON();
+    if (value instanceof Set) {
+      return Array.from(value).map((e) => toJsonInternal(e, visited));
+    } else if (Array.isArray(value)) {
+      return value.map((e) => toJsonInternal(e, visited));
+    } else {
+      if (isPlainObject(value)) {
+        const o = {};
+        for (const key in value) {
+          o[key] = toJsonInternal(value[key], visited);
+        }
+        return o;
+      } else if (value instanceof Error) {
+        return {
+          name: value.name,
+          message: value.message,
+          stack: value.stack
+        };
+      } else {
+        return value.toString();
+      }
+    }
+  }
+  function stringifyForPrint(value, maxLength, indicator = "\u2026") {
+    let str = JSON.stringify(
+      toJson(value),
+      (_, value2) => {
+        const type = typeof value2;
+        if (["undefined"].includes(type)) {
+          return `{{${String(value2)}}}`;
+        }
+        if (type === "number") {
+          if (Number.isNaN(value2) || !Number.isFinite(value2))
+            return `{{${value2.toString()}}}`;
+        }
+        return value2;
+      },
+      "  "
+    );
+    str = str.replace(/("\{\{.*}}")/g, (_, s) => {
+      return s.substring(3, s.length - 3);
+    });
+    if (maxLength) str = truncate(str, maxLength, indicator);
+    return str;
+  }
+  function parseBoolean(str) {
+    return str === "true" || str === "1";
+  }
+  function stringify(value) {
+    if (value === null) return "null";
+    if (value === void 0) return "undefined";
+    return value.toString();
+  }
+  function parseIntSafe(str, radix) {
+    if (!str) return null;
+    const value = parseInt(str, radix);
+    if (!Number.isFinite(value)) return null;
+    return value;
+  }
+  var LinkedList = class {
+    constructor() {
+      __publicField2(this, "_head", null);
+      __publicField2(this, "_tail", null);
+    }
+    /**
+     * Returns the current head.
+     */
+    get head() {
+      return this._head;
+    }
+    /**
+     * Returns the current tail.
+     */
+    get tail() {
+      return this._tail;
+    }
+    /**
+     * Returns true if the list is empty.
+     */
+    get empty() {
+      return this._head === null;
+    }
+    /**
+     * Creates a new node for the given value, adding it to the end of the list.
+     *
+     * @param value
+     * @return Returns the newly created node.
+     */
+    push(value) {
+      const node = {
+        previous: this._tail,
+        value,
+        removed: false,
+        next: null
+      };
+      this.pushNode(node);
+      return node;
+    }
+    /**
+     * Appends all given values to the end of this list.
+     *
+     * @param values
+     */
+    pushAll(...values) {
+      for (const value of values) {
+        this.push(value);
+      }
+    }
+    /**
+     * Appends the given node to the tail of this list.
+     * If the node is already at the tail, it will no-op.
+     * If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the tail of this list.
+     */
+    pushNode(node) {
+      if (this._tail === node) return;
+      this.remove(node);
+      node.removed = false;
+      node.next = null;
+      node.previous = this._tail;
+      if (this._tail) this._tail.next = node;
+      this._tail = node;
+      if (!this._head) this._head = node;
+    }
+    /**
+     * Removes the last node (the tail), returning it.
+     * If this list is empty, null is returned.
+     */
+    pop() {
+      const node = this._tail;
+      if (!node) return null;
+      this.remove(node);
+      return node;
+    }
+    /**
+     * Creates a new node, adding it to the front of the list.
+     *
+     * @param value The value to box in a linked node.
+     * @return Returns the new node.
+     */
+    unshift(value) {
+      const node = {
+        previous: null,
+        value,
+        removed: true,
+        next: this._head
+      };
+      this.unshiftNode(node);
+      return node;
+    }
+    /**
+     * Prepends all the given values to the head of this list.
+     * The values will maintain their order.
+     *
+     * E.g.
+     * ```
+     * list.unshiftAll(8, 9, 10)   // 8, 9, 10
+     * list.unshiftAll(4, 5, 6, 7) // 4, 5, 6, 7, 8, 9, 10
+     * list.unshiftAll(1, 2, 3)    // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     * ```
+     *
+     * @param values The values to box in linked nodes.
+     */
+    unshiftAll(...values) {
+      for (let i = values.length - 1; i >= 0; i--) {
+        this.unshift(values[i]);
+      }
+    }
+    /**
+     * Prepends the given node to the head of this list.
+     * - If the node is already at the head, it will no-op.
+     * - If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the head of this list.
+     */
+    unshiftNode(node) {
+      if (this._head === node) return;
+      this.remove(node);
+      node.removed = false;
+      node.previous = null;
+      node.next = this._head;
+      if (this._head) this._head.previous = node;
+      this._head = node;
+      if (!this._tail) this._tail = node;
+    }
+    /**
+     * Removes the first node (the head), returning it.
+     * - If this list is empty, null is returned.
+     */
+    shift() {
+      const node = this._head;
+      if (!node) return null;
+      this.remove(node);
+      return node;
+    }
+    /**
+     * Removes the given linked node.
+     *
+     * @param node
+     */
+    remove(node) {
+      if (node.removed) return;
+      node.removed = true;
+      if (node.previous) node.previous.next = node.next;
+      if (node.next) node.next.previous = node.previous;
+      if (this._head === node) this._head = node.next;
+      if (this._tail === node) this._tail = node.previous;
+    }
+    /**
+     * Inserts the given node before pointer node.
+     *
+     * @param node The node to insert before pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeBefore(node, pointer) {
+      if (!node.removed && node.next === pointer) return;
+      this.remove(node);
+      node.removed = false;
+      if (pointer.previous) {
+        pointer.previous.next = node;
+        node.previous = pointer.previous;
+      } else {
+        this._head = node;
+        node.previous = null;
+      }
+      node.next = pointer;
+      pointer.previous = node;
+    }
+    /**
+     * Inserts the given node after pointer node.
+     *
+     * @param node The node to insert after pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeAfter(node, pointer) {
+      if (!node.removed && node.previous === pointer) return;
+      this.remove(node);
+      node.removed = false;
+      if (pointer.next) {
+        pointer.next.previous = node;
+        node.next = pointer.next;
+      } else {
+        this._tail = node;
+        node.next = null;
+      }
+      node.previous = pointer;
+      pointer.next = node;
+    }
+    /**
+     * Iterates over every element, invoking the given callback.
+     *
+     * @param callback
+     */
+    forEach(callback) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed) callback(current.value);
+        current = current.next;
+      }
+    }
+    /**
+     * Similar to `Array.prototype.some`, returns true if at least one element passes the given
+     * predicate.
+     *
+     * @param predicate
+     */
+    some(predicate) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return true;
+        current = current.next;
+      }
+      return false;
+    }
+    /**
+     * Returns the first node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    find(predicate) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return current;
+        current = current.next;
+      }
+      return null;
+    }
+    /**
+     * Returns the last node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    findLast(predicate) {
+      let current = this._tail;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return current;
+        current = current.previous;
+      }
+      return null;
+    }
+    /**
+     * Clears this list.
+     */
+    clear() {
+      let current = this._head;
+      while (current != null) {
+        const next = current.next;
+        current.removed = true;
+        current = next;
+      }
+      this._head = null;
+      this._tail = null;
+    }
+    /**
+     * Returns a new iterator, starting at the head.
+     */
+    [Symbol.iterator]() {
+      return this.createIterator(this._head, null, (node) => node.next);
+    }
+    /**
+     * Returns a new reversed iterable where the iterator starts at the tail, moving backwards
+     * to the head.
+     */
+    reversed() {
+      return this.createIterator(this._tail, null, (node) => node.previous);
+    }
+    /**
+     * Creates an iterable iterator, starting at the specified node, getting the next node from
+     * the next() function.
+     *
+     * Note that using iterators is not as performant as {@link some} or {@link forEach}
+     *
+     * @param start The starting node. (inclusive)
+     * @param end The ending node (exclusive).
+     * @param next A method that is given the current node, and returns the next node.
+     */
+    createIterator(start, end, next) {
+      let current = start;
+      return {
+        [Symbol.iterator]() {
+          return this;
+        },
+        next: () => {
+          if (current === end || !current) {
+            return {
+              value: void 0,
+              done: true
+            };
+          }
+          const result = {
+            value: current.value,
+            done: false
+          };
+          current = next(current);
+          while (current == null ? void 0 : current.removed) {
+            current = next(current);
+          }
+          return result;
+        }
+      };
+    }
+  };
+  function last(arrayLike) {
+    if (!arrayLike) return void 0;
+    return arrayLike[arrayLike.length - 1];
+  }
+  function cloneTypedArray(array) {
+    return new array.constructor(array);
+  }
+  var typedArrayTypes = [
+    Float32Array,
+    Float64Array,
+    Int16Array,
+    Int32Array,
+    Int8Array,
+    Uint16Array,
+    Uint32Array,
+    Uint8Array,
+    Uint8ClampedArray
+  ];
+  function isTypedArray(value) {
+    return typedArrayTypes.some((type) => value instanceof type);
+  }
+  function isCloneable(value) {
+    return value != null && typeof value === "object" && "clone" in value && typeof value.clone === "function" && value.clone.length === 0;
+  }
+  var locale3 = {
+    cyclicRefError: "Cyclic reference found at: {path}",
+    mergeReferenceError: `No merge rule found at {path} for "{source}" and reference copy not allowed`
+  };
+  function mergeDeep(sources, options) {
+    if (!sources.length) return void 0;
+    const finalOpts = __spreadValues3(__spreadValues3({}, defaultMergeOptions), options);
+    const stack = new PropStack();
+    const n = sources.length;
+    if (n === 1)
+      return _mergeDeep(void 0, sources[0], stack, 0, finalOpts);
+    let out = _mergeDeep(sources[0], sources[1], stack, 1, finalOpts);
+    for (let i = 2; i < n; i++) {
+      out = _mergeDeep(out, sources[i], stack, i, finalOpts);
+    }
+    return out;
+  }
+  var PropStack = class {
+    constructor() {
+      __publicField2(this, "refsA", /* @__PURE__ */ new Set());
+      __publicField2(this, "refsB", /* @__PURE__ */ new Set());
+      __publicField2(this, "propStack", []);
+    }
+    /**
+     * The property stack, joined by .
+     */
+    get currentPath() {
+      return this.propStack.map((e) => e[2]).filter((e) => e != null).join(".");
+    }
+    push(sourceA, sourceB, prop) {
+      this.propStack.push([sourceA, sourceB, prop]);
+      this.addRef(this.refsA, sourceA);
+      this.addRef(this.refsB, sourceB);
+    }
+    pop() {
+      const last2 = this.propStack.pop();
+      this.refsA.delete(last2[0]);
+      this.refsB.delete(last2[1]);
+    }
+    addRef(refSet, source) {
+      if (typeof source !== "object") return;
+      if (refSet.has(source)) {
+        throw new IllegalArgumentError(
+          substitute(locale3.cyclicRefError, { path: this.currentPath })
+        );
+      }
+      refSet.add(source);
+    }
+  };
+  function _mergeDeep(sourceA, sourceB, propStack, prop, options) {
+    if (typeof sourceB !== "object" || sourceB === null) return sourceB;
+    const merge2 = (sourceA2, sourceB2, prop2) => {
+      return _mergeDeep(sourceA2, sourceB2, propStack, prop2, options);
+    };
+    for (const rule of options.rules) {
+      if (rule.matches(sourceB)) {
+        propStack.push(sourceA, sourceB, prop);
+        const result = rule.merge(
+          rule.matches(sourceA) ? sourceA : void 0,
+          sourceB,
+          merge2
+        );
+        propStack.pop();
+        return result;
+      }
+    }
+    if (!options.allowReferenceCopy) {
+      propStack.push(sourceA, sourceB, prop);
+      throw new MergeReferenceError(propStack.currentPath, sourceB);
+    }
+    return sourceB;
+  }
+  var MergeReferenceError = class _MergeReferenceError extends ReportableError {
+    constructor(propPath, source) {
+      super(
+        substitute(locale3.mergeReferenceError, {
+          path: propPath,
+          source
+        })
+      );
+      Object.setPrototypeOf(this, _MergeReferenceError.prototype);
+    }
+  };
+  var cloneableMergeRule = {
+    matches(object) {
+      return isCloneable(object);
+    },
+    merge(_1, sourceB, _2) {
+      return sourceB.clone();
+    }
+  };
+  var arrayMergeRule = {
+    matches(object) {
+      return Array.isArray(object);
+    },
+    merge(sourceA, sourceB, merge2) {
+      const out = [];
+      if (sourceA) {
+        for (const element2 of sourceA) {
+          out.push(merge2(void 0, element2, out.length));
+        }
+      }
+      for (const element2 of sourceB) {
+        out.push(merge2(void 0, element2, out.length));
+      }
+      return out;
+    }
+  };
+  var plainObjectMergeRule = {
+    matches(object) {
+      return isPlainObject(object);
+    },
+    merge(sourceA, sourceB, merge2) {
+      const out = {};
+      for (const key of union(ownKeys(sourceA), ownKeys(sourceB))) {
+        if (sourceA && key in sourceB && key in sourceA) {
+          out[key] = merge2(sourceA[key], sourceB[key], key);
+        } else if (sourceA && key in sourceA) {
+          out[key] = merge2(void 0, sourceA[key], key);
+        } else {
+          out[key] = merge2(void 0, sourceB[key], key);
+        }
+      }
+      return out;
+    }
+  };
+  var regexpMergeRule = {
+    matches(object) {
+      return object instanceof RegExp;
+    },
+    merge(_1, sourceB, _2) {
+      return new RegExp(sourceB.source, sourceB.flags);
+    }
+  };
+  var dateMergeRule = {
+    matches(object) {
+      return object instanceof Date;
+    },
+    merge(_1, sourceB, _2) {
+      return new Date(sourceB.getTime());
+    }
+  };
+  var mapMergeRule = {
+    matches(object) {
+      return object instanceof Map;
+    },
+    merge(sourceA, sourceB, merge2) {
+      var _a2;
+      const out = /* @__PURE__ */ new Map();
+      for (const key of /* @__PURE__ */ new Set([
+        ...(_a2 = sourceA == null ? void 0 : sourceA.keys()) != null ? _a2 : [],
+        ...sourceB.keys()
+      ])) {
+        if (sourceB.has(key) && (sourceA == null ? void 0 : sourceA.has(key))) {
+          out.set(key, merge2(sourceA.get(key), sourceB.get(key), key));
+        } else if (sourceA == null ? void 0 : sourceA.has(key)) {
+          out.set(key, merge2(void 0, sourceA.get(key), key));
+        } else {
+          out.set(key, merge2(void 0, sourceB.get(key), key));
+        }
+      }
+      return out;
+    }
+  };
+  var setMergeRule = {
+    matches(object) {
+      return object instanceof Set;
+    },
+    merge(sourceA, sourceB, merge2) {
+      var _a2;
+      return new Set(
+        [...(_a2 = sourceA == null ? void 0 : sourceA.values()) != null ? _a2 : [], ...sourceB.values()].map(
+          (element2, index) => {
+            return merge2(void 0, element2, index);
+          }
+        )
+      );
+    }
+  };
+  var typedArrayMergeRule = {
+    matches(object) {
+      return isTypedArray(object);
+    },
+    merge(_1, sourceB, _2) {
+      return cloneTypedArray(sourceB);
+    }
+  };
+  var urlMergeRule = {
+    matches(object) {
+      return object instanceof URL;
+    },
+    merge(_1, sourceB, _2) {
+      return new URL(sourceB.toString());
+    }
+  };
+  var defaultMergeOptions = {
+    allowReferenceCopy: true,
+    rules: [
+      cloneableMergeRule,
+      arrayMergeRule,
+      plainObjectMergeRule,
+      regexpMergeRule,
+      dateMergeRule,
+      mapMergeRule,
+      setMergeRule,
+      typedArrayMergeRule,
+      urlMergeRule
+    ]
+  };
+  function merge(...sources) {
+    if (!sources.length) return void 0;
+    if (Array.isArray(sources[0])) return Array.prototype.concat(...sources);
+    return Object.assign({}, ...sources);
+  }
+  var IllegalStateError = class _IllegalStateError extends ReportableError {
+    get [Symbol.toStringTag]() {
+      return "IllegalStateError";
+    }
+    constructor(message) {
+      super(message);
+      Object.setPrototypeOf(this, _IllegalStateError.prototype);
+    }
+  };
+  function clone(target, options) {
+    var _a2, _b, _c;
+    return mergeDeep([target], {
+      allowReferenceCopy: (_a2 = options == null ? void 0 : options.allowReferenceCopy) != null ? _a2 : false,
+      rules: (_c = (_b = options == null ? void 0 : options.rules) == null ? void 0 : _b.map(toMergeRule)) != null ? _c : defaultMergeOptions.rules
+    });
+  }
+  function toMergeRule(cloneRule) {
+    return {
+      matches: cloneRule.matches,
+      merge(_sourceA, sourceB, merge2) {
+        return cloneRule.clone(
+          sourceB,
+          (source, prop) => {
+            return merge2(void 0, source, prop);
+          }
+        );
+      }
+    };
+  }
+  var ValidationError = class _ValidationError extends ReportableError {
+    /**
+     * @param message The validation error message.
+     * @param origin The error origin, typically API (default) or SERVICE_EXTERNAL
+     * @param path The property path to the invalid field.
+     */
+    constructor(message, origin = ErrorOrigin.API, path = []) {
+      super(message, origin);
+      this.path = path;
+      Object.setPrototypeOf(this, _ValidationError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "ValidationError";
+    }
+    toJSON() {
+      return __spreadProps2(__spreadValues3({}, super.toJSON()), {
+        origin: this.origin,
+        path: this.path
+      });
+    }
+  };
+  function mapIter(iterable, transform) {
+    const it2 = iterable[Symbol.iterator]();
+    return {
+      [Symbol.iterator]() {
+        return mapIter(iterable, transform);
+      },
+      next: () => {
+        const result = it2.next();
+        if (result.done) return result;
+        return {
+          value: transform(result.value),
+          done: false
+        };
+      }
+    };
+  }
+  var LruCache = class {
+    constructor(initialCapacity) {
+      __publicField2(this, "cache", /* @__PURE__ */ new Map());
+      __publicField2(this, "list", /* @__PURE__ */ new LinkedList());
+      __publicField2(this, "onEvicting", null);
+      __publicField2(this, "onEvict", null);
+      __publicField2(this, "_capacity", 0);
+      this._capacity = initialCapacity;
+    }
+    get capacity() {
+      return this._capacity;
+    }
+    set capacity(value) {
+      this._capacity = value;
+      while (this.cache.size > this.capacity) {
+        this.evictLeastRecentlyUsed();
+      }
+    }
+    /**
+     * @returns the number of elements in the Map.
+     */
+    get size() {
+      return this.cache.size;
+    }
+    /**
+     * @returns boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key) {
+      return this.cache.has(key);
+    }
+    /**
+     * Returns the mapped value for the given key, and moves the element to the most recently
+     * used position.
+     *
+     * @returns Returns the element associated with the given key, or undefined if no such
+     * element exists.
+     */
+    get(key) {
+      const node = this.cache.get(key);
+      if (!node) return void 0;
+      this.list.pushNode(node);
+      return node.value[1];
+    }
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the
+     * same key already exists, the element will be updated and position moved to most recently
+     * used.
+     */
+    set(key, value) {
+      if (this.has(key)) {
+        const node = this.cache.get(key);
+        node.value[1] = value;
+        this.list.pushNode(node);
+      } else {
+        const node = this.list.push([key, value]);
+        this.cache.set(key, node);
+        if (this.cache.size > this.capacity) {
+          this.evictLeastRecentlyUsed();
+        }
+      }
+      return this;
+    }
+    evictLeastRecentlyUsed() {
+      var _a2, _b, _c;
+      let node = this.list.head;
+      while (node) {
+        const [key2, value2] = node.value;
+        const allowed = (_b = (_a2 = this.onEvicting) == null ? void 0 : _a2.call(null, value2, key2, this)) != null ? _b : true;
+        if (allowed) break;
+        node = node.next;
+      }
+      if (!node)
+        throw new IllegalStateError(
+          "onEvicting returned false for all elements"
+        );
+      const [key, value] = node.value;
+      this.list.remove(node);
+      this.cache.delete(node.value[0]);
+      (_c = this.onEvict) == null ? void 0 : _c.call(null, value, key, this);
+    }
+    /**
+     * Clears all elements from the cache.
+     */
+    clear() {
+      this.list.clear();
+      this.cache.clear();
+    }
+    /**
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
+    delete(key) {
+      if (!this.has(key)) return false;
+      const node = this.cache.get(key);
+      this.cache.delete(key);
+      this.list.remove(node);
+      return true;
+    }
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     *
+     * @param callback A callback to invoke for every element in the cache.
+     * @param thisArg Value to use as this when executing callback
+     */
+    forEach(callback, thisArg) {
+      return this.list.forEach((entry) => {
+        callback.call(thisArg, entry[1], entry[0], this);
+      });
+    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries() {
+      return this[Symbol.iterator]();
+    }
+    /**
+     * Returns an iterable of keys in the map. This will be ordered from least recently used to
+     * most.
+     */
+    keys() {
+      return mapIter(this.list, ([key]) => key);
+    }
+    /**
+     * Returns an iterable of values in the map. This will be ordered from least recently used to
+     * most.
+     */
+    values() {
+      return mapIter(this.list, ([, value]) => value);
+    }
+    [Symbol.iterator]() {
+      return this.list[Symbol.iterator]();
+    }
+    get [Symbol.toStringTag]() {
+      return "LruCache";
+    }
+  };
+  function memoize(inner, keyProvider, capacity = 500) {
+    if (!keyProvider) {
+      let cached = false;
+      let value = void 0;
+      const memoized = () => {
+        if (!cached) {
+          cached = true;
+          value = inner();
+        }
+        return value;
+      };
+      return Object.assign(
+        memoized,
+        {
+          clear: () => {
+            cached = false;
+            value = void 0;
+          }
+        }
+      );
+    } else if (capacity === 0) {
+      const memoized = (...args) => inner(...args);
+      return Object.assign(
+        memoized,
+        {
+          clear: () => {
+          }
+        }
+      );
+    } else if (capacity === 1) {
+      let hasValue = false;
+      let cachedKey;
+      let cachedValue;
+      const memoized = (...args) => {
+        const key = keyProvider(...args);
+        if (!hasValue || cachedKey !== key) {
+          hasValue = true;
+          cachedKey = key;
+          cachedValue = inner(...args);
+        }
+        return cachedValue;
+      };
+      return Object.assign(
+        memoized,
+        {
+          clear: () => {
+            hasValue = false;
+          }
+        }
+      );
+    } else {
+      const cache = new LruCache(capacity);
+      const memoized = (...args) => {
+        const key = keyProvider(...args);
+        return getOrSet(cache, key, () => inner(...args));
+      };
+      return Object.assign(
+        memoized,
+        {
+          clear: () => {
+            cache.clear();
+          }
+        }
+      );
+    }
+  }
+  var locale4 = {
+    invalidDateError: `"{value}" is an invalid date`
+  };
+  function parseTimestamp(str) {
+    const timestamp = Date.parse(str);
+    if (Number.isNaN(timestamp))
+      throw new ValidationError(
+        substitute(locale4.invalidDateError, { value: str }),
+        ErrorOrigin.PARSING
+      );
+    return timestamp;
+  }
+  function parseDate(str) {
+    return new Date(parseTimestamp(str));
+  }
+  function stringifyDate(value) {
+    return value.toISOString();
+  }
+
+  // src/error/parsingError.ts
+  function throwParsingError(message) {
+    throw new ValidationError(message, ErrorOrigin.PARSING);
+  }
+
+  // src/media/ratio.ts
+  var ratioRegExp = /^([0-9]*):([0-9]*)$/;
+  function parseRatio(str) {
+    const match = str ? ratioRegExp.exec(str) : null;
+    if (!match) throwParsingError(`invalid ratio format: ${str}`);
+    return [parseInt(match[1] || "1"), parseInt(match[2] || "1")];
+  }
+  function stringifyRatio(value) {
+    return `${value[0]}:${value[1]}`;
+  }
+
+  // src/media/frameRate.ts
+  var framerateRegexp = /^(\d+)(?:\/(\d+))?$/;
+  function parseFrameRate(str) {
+    const match = str ? framerateRegexp.exec(str) : null;
+    if (!match) throwParsingError(`invalid frame rate: '${str}'`);
+    return [parseInt(match[1]), parseInt(match[2] || "1")];
+  }
+  function stringifyFrameRate(value) {
+    return value[1] === 1 ? value[0].toString() : `${value[0]}/${value[1]}`;
+  }
+
+  // src/media/byteRange.ts
+  var byteRangeExp = /^(-?[0-9]+)-(-?[0-9]*)$/;
+  function parseByteRange(str) {
+    const match = str ? byteRangeExp.exec(str) : null;
+    if (!match) throwParsingError(`invalid byte range: '${str}'`);
+    let start = parseInt(match[1]);
+    if (start < 0) start >>>= 0;
+    let end = parseIntSafe(match[2]);
+    if (end != null && end < 0) end = end >>> 0;
+    return [start, end];
+  }
+  function stringifyByteRange(value) {
+    const end = value[1];
+    return `${value[0]}-${end == null ? "" : end}`;
+  }
+
+  // ../vinyl-validation/dist/index.js
+  var __defProp4 = Object.defineProperty;
+  var __defProps3 = Object.defineProperties;
+  var __getOwnPropDescs3 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols4 = Object.getOwnPropertySymbols;
+  var __hasOwnProp4 = Object.prototype.hasOwnProperty;
+  var __propIsEnum4 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp4 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues4 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp4.call(b, prop))
+        __defNormalProp4(a, prop, b[prop]);
+    if (__getOwnPropSymbols4)
+      for (var prop of __getOwnPropSymbols4(b)) {
+        if (__propIsEnum4.call(b, prop))
+          __defNormalProp4(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps3 = (a, b) => __defProps3(a, __getOwnPropDescs3(b));
+  var __publicField3 = (obj, key, value) => __defNormalProp4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var validatorLocale = {
+    /**
+     * The expectation template string with the following replacement tokens:
+     *
+     * `{expected}` - The expected description.
+     * `{actual}` - The actual value.
+     * `{path}` - The path, dot separated.
+     */
+    template: "Expected: {expected}, but was: {actual}. At: {path}"
+  };
+  function createValidationExpectationMessage(expectationMessage, input, path, inputStringify = (input2) => stringifyForPrint(input2, 500)) {
+    return substitute(validatorLocale.template, {
+      expected: expectationMessage,
+      actual: inputStringify(input),
+      path: path.join(".")
+    });
+  }
+  function createValidator(expectationMessage, isValid, inputStringify = (input) => stringifyForPrint(input, 500)) {
+    return {
+      description: expectationMessage,
+      isValid(input) {
+        return isValid(input);
+      },
+      validate(input, _, path = []) {
+        if (!isValid(input)) {
+          return [
+            {
+              message: createValidationExpectationMessage(
+                expectationMessage,
+                input,
+                path,
+                inputStringify
+              ),
+              path
+            }
+          ];
+        }
+        return [];
+      },
+      assert: (input, origin, path = []) => {
+        if (!isValid(input)) {
+          throw new ValidationError(
+            createValidationExpectationMessage(
+              expectationMessage,
+              input,
+              path,
+              inputStringify
+            ),
+            origin,
+            path
+          );
+        }
+      }
+    };
+  }
+  function createDeepValidator(description, validate) {
+    return {
+      description,
+      isValid(input) {
+        return validate(input, { all: false }, []).length === 0;
+      },
+      validate(input, options, path = []) {
+        return validate(input, options != null ? options : { all: false }, path);
+      },
+      assert: (input, origin, path = []) => {
+        const errors = validate(input, { all: false }, path);
+        if (errors.length) {
+          const error = errors[0];
+          throw new ValidationError(error.message, origin, error.path);
+        }
+      }
+    };
+  }
+  var locale5 = {
+    /**
+     * {value} The child validators' descriptions, joined with `separator`.
+     *
+     * groupings of and validators is unimportant,
+     * and(and(a, b), c) is the same as and(a, and(b, c)), so `a & b & c` is an accurate
+     * representation for either.
+     */
+    template: "{value}",
+    /**
+     * The separator with which to join child validator descriptions.
+     */
+    separator: " & "
+  };
+  function andValidators(...validators) {
+    return createDeepValidator(
+      substitute(locale5.template, {
+        value: validators.map((v) => v.description).join(locale5.separator)
+      }),
+      (input, options, path) => {
+        for (const validator of validators) {
+          const errors = validator.validate(input, options, path);
+          if (errors.length) return errors;
+        }
+        return [];
+      }
+    );
+  }
+  var locale22 = {
+    /**
+     * {value} - The child validators' descriptions, joined with `separator`.
+     */
+    template: "({value})",
+    /**
+     * The separator with which to join child validator descriptions.
+     */
+    separator: " | "
+  };
+  function orValidators(...validators) {
+    const description = substitute(locale22.template, {
+      value: validators.map((v) => v.description).join(locale22.separator)
+    });
+    return createDeepValidator(description, (input, options, path) => {
+      let longestErrors = [];
+      let longestPath = 0;
+      for (const validator of validators) {
+        const errors = validator.validate(input, options, path);
+        if (!errors.length) return errors;
+        const pathLength = errors.reduce(
+          (max, m) => Math.max(m.path.length, max),
+          0
+        );
+        if (pathLength >= longestPath) {
+          longestErrors = errors;
+          longestPath = pathLength;
+        }
+      }
+      return longestPath > path.length ? longestErrors : [
+        {
+          message: createValidationExpectationMessage(
+            description,
+            input,
+            path
+          ),
+          path
+        }
+      ];
+    });
+  }
+  var requiredValidationOptions = {
+    optional: false
+  };
+  var SchemaBase = class {
+    constructor(currentValidator, previousSchema, operation) {
+      this.currentValidator = currentValidator;
+      this.previousSchema = previousSchema;
+      this.operation = operation;
+      __publicField3(this, "__type", /* @__PURE__ */ invariant());
+      __publicField3(this, "validator");
+      __publicField3(this, "_options", requiredValidationOptions);
+      __publicField3(this, "assert", (input, origin, path) => {
+        this.validator.assert(input, origin, path);
+      });
+      __publicField3(this, "isValid", (input) => this.validator.isValid(input));
+      __publicField3(this, "validate", (input, options, path) => this.validator.validate(input, options, path));
+      this.validator = operation == null ? currentValidator : operation(previousSchema, currentValidator);
+    }
+    get options() {
+      return this._options;
+    }
+    get description() {
+      return this.validator.description;
+    }
+    /**
+     * Clones this schema, transforming all validators with the given mutator.
+     *
+     * @param transform A transformer which takes an existing validator in the chain and returns
+     * a new one. Validators should be considered to be immutable; transform should not change the
+     * input but instead return a new validator.
+     */
+    clone(transform = (v) => v) {
+      const cloned = this.operation ? this.self(
+        transform(this.currentValidator),
+        this.previousSchema.clone(transform),
+        this.operation
+      ) : this.self(transform(this.currentValidator));
+      cloned._options = this._options;
+      return cloned;
+    }
+    self(current, previous, operation) {
+      if (this.constructor.length > 3) {
+        throw new IllegalArgumentError(
+          "constructor should have at most three required arguments"
+        );
+      }
+      return new this.constructor(current, previous, operation);
+    }
+    /**
+     * Constructs a new schema with a validator chaining the current validator with the
+     * provided next in an AND operation.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new Schema instance the same class with a new validator chaining the
+     * current validator with the given next in an AND operation.
+     */
+    chain(nextValidator) {
+      return this.self(nextValidator, this, andValidators);
+    }
+    optional() {
+      const cloned = this.clone();
+      cloned._options = __spreadProps3(__spreadValues4({}, cloned.options), {
+        optional: true
+      });
+      return cloned;
+    }
+    required() {
+      const cloned = this.clone();
+      cloned._options = __spreadProps3(__spreadValues4({}, cloned.options), {
+        optional: false
+      });
+      return cloned;
+    }
+  };
+  var locale32 = {
+    null: "null",
+    nullish: "nullish",
+    undefined: "undefined"
+  };
+  var valueValidators = {
+    any() {
+      return createValidator("", () => true);
+    },
+    /**
+     * Creates a validator that asserts that the input is nullish.
+     */
+    nullish() {
+      return createValidator(locale32.nullish, (input) => input == null);
+    },
+    /**
+     * Creates a validator that asserts that the input is strictly null.
+     */
+    null() {
+      return createValidator(locale32.null, (input) => input === null);
+    },
+    /**
+     * Creates a validator that asserts that the input is strictly undefined.
+     */
+    undefined() {
+      return createValidator(locale32.undefined, (input) => input === void 0);
+    }
+  };
+  var ValueSchema = class _ValueSchema extends SchemaBase {
+    /**
+     * Prepends this validator allowing for null or undefined.
+     */
+    maybe() {
+      return this.or(valueValidators.nullish());
+    }
+    /**
+     * Prepends this validator allowing for null.
+     */
+    orNull() {
+      return this.or(valueValidators.null());
+    }
+    /**
+     * Prepends this validator allowing for undefined.
+     */
+    orUndefined() {
+      return this.or(valueValidators.undefined());
+    }
+    /**
+     * Returns a validator that asserts if this validator and the next passes.
+     *
+     * @see andValidators
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema intersecting this validator and the next.
+     */
+    and(nextValidator) {
+      return new _ValueSchema(nextValidator, this, andValidators);
+    }
+    /**
+     * Returns a validator that asserts if this validator or the next passes.
+     *
+     * Implementation note:
+     * subclasses should not change the schema instance returned unless all chainable validators
+     * accept input type 'unknown'.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema providing the union of this validator and the next.
+     */
+    or(nextValidator) {
+      return new _ValueSchema(nextValidator, this, orValidators);
+    }
+  };
+  var locale42 = {
+    array: "array",
+    minLength: "at least {value} elements",
+    maxLength: "at most {value} elements",
+    exactlyLength: "exactly {value} elements",
+    actualLength: "length {value}",
+    withElements: "({value})[]",
+    tuple: "[{value}]"
+  };
+  var arrayValidators = {
+    /**
+     * Creates a validator that asserts that the input is an array.
+     *
+     * Note: arrays can only be readonly by type system, there is no native readonly
+     * js array. This validator assumes mutability, use the ArraySchema readonly() method
+     * to cast to a readonly array.
+     */
+    isArray() {
+      return createValidator(
+        locale42.array,
+        (input) => Array.isArray(input)
+      );
+    },
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements(elementValidator) {
+      return createDeepValidator(
+        substitute(locale42.withElements, {
+          value: elementValidator.description
+        }),
+        (input, options, path) => {
+          const errors = [];
+          for (let i = 0; i < input.length; i++) {
+            const element2 = input[i];
+            errors.push(
+              ...elementValidator.validate(
+                element2,
+                options,
+                path.concat(i.toString())
+              )
+            );
+            if (!options.all && errors.length) return errors;
+          }
+          return errors;
+        }
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input array is a tuple whose elements match
+     * the given validators.
+     *
+     * @param validators
+     */
+    tuple(...validators) {
+      const lengthValidator = createValidator(
+        substitute(locale42.exactlyLength, {
+          value: validators.length
+        }),
+        (length) => length === validators.length
+      );
+      return createDeepValidator(
+        substitute(locale42.tuple, { value: validators.join(", ") }),
+        (input, options, path) => {
+          const errors = [];
+          errors.push(
+            ...lengthValidator.validate(input.length, options, path)
+          );
+          if (!options.all && errors.length) return errors;
+          const n = Math.min(validators.length, input.length);
+          for (let i = 0; i < n; i++) {
+            const element2 = input[i];
+            const validator = validators[i];
+            errors.push(
+              ...validator.validate(
+                element2,
+                options,
+                path.concat(i.toString())
+              )
+            );
+            if (!options.all && errors.length) return errors;
+          }
+          return errors;
+        }
+      );
+    },
+    /**
+     * Creates a validator that validates the input array has the given minimum length.
+     * @param min The minimum number of elements (inclusive)
+     */
+    minLength(min) {
+      return createValidator(
+        substitute(locale42.minLength, { value: min }),
+        (input) => input.length >= min,
+        (input) => substitute(locale42.actualLength, { value: input.length })
+      );
+    },
+    /**
+     *
+     * Creates a validator that validates the input array has the given maximum length.
+     * @param max The maximum number of elements (inclusive)
+     */
+    maxLength(max) {
+      return createValidator(
+        substitute(locale42.maxLength, { value: max }),
+        (input) => input.length <= max,
+        (input) => substitute(locale42.actualLength, { value: input.length })
+      );
+    }
+  };
+  var _ArraySchema = class _ArraySchema2 extends ValueSchema {
+    /**
+     * The base ArraySchema instance validating that the input is an Array.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _ArraySchema2(arrayValidators.isArray());
+      return this._base;
+    }
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements(elementValidator) {
+      return this.chain(arrayValidators.withElements(elementValidator));
+    }
+    /**
+     * Creates a validator that asserts that the input array is a tuple whose elements match
+     * the given validators.
+     *
+     * @param validators
+     */
+    tuple(...validators) {
+      return this.chain(arrayValidators.tuple(...validators));
+    }
+    /**
+     * Creates a validator that validates the input array has the given minimum length.
+     * @param min The minimum number of elements (inclusive)
+     */
+    minLength(min) {
+      return this.chain(arrayValidators.minLength(min));
+    }
+    /**
+     *
+     * Creates a validator that validates the input array has the given maximum length.
+     * @param max The maximum number of elements (inclusive)
+     */
+    maxLength(max) {
+      return this.chain(arrayValidators.maxLength(max));
+    }
+    /**
+     * Casts to a readonly array.
+     * This is a shallow cast, elements of the array will not be changed.
+     */
+    readonly() {
+      return this;
+    }
+    /**
+     * Casts the type parameter.
+     */
+    cast() {
+      return this;
+    }
+  };
+  __publicField3(_ArraySchema, "_base", null);
+  var locale52 = {
+    template: "type {value}"
+  };
+  function typeOfValidator(expected) {
+    return createValidator(
+      substitute(locale52.template, { value: expected }),
+      (input) => {
+        return input != null && typeof input === expected;
+      }
+    );
+  }
+  var typeOfValidatorCache = {};
+  function cachedTypeOfValidator(type) {
+    if (!(type in typeOfValidatorCache)) {
+      typeOfValidatorCache[type] = typeOfValidator(type);
+    }
+    return typeOfValidatorCache[type];
+  }
+  var typeOfValidators = {
+    get boolean() {
+      return cachedTypeOfValidator("boolean");
+    },
+    get func() {
+      return cachedTypeOfValidator("function");
+    },
+    get number() {
+      return cachedTypeOfValidator("number");
+    },
+    get object() {
+      return cachedTypeOfValidator("object");
+    },
+    get string() {
+      return cachedTypeOfValidator("string");
+    },
+    get symbol() {
+      return cachedTypeOfValidator("symbol");
+    }
+  };
+  var locale6 = {
+    length: "at most {value} arguments",
+    actualLength: "{value} arguments"
+  };
+  var functionValidators = {
+    length(max) {
+      return createValidator(
+        substitute(locale6.length, { value: max }),
+        (input) => input.length <= max,
+        (input) => substitute(locale6.actualLength, { value: input.length })
+      );
+    }
+  };
+  var _FunctionSchema = class _FunctionSchema2 extends ValueSchema {
+    /**
+     * The base Function validator validating that the input is a function.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _FunctionSchema2(typeOfValidators.func);
+      return this._base;
+    }
+    length(max) {
+      return this.chain(functionValidators.length(max));
+    }
+    /**
+     * Casts the function signature.
+     * Function signatures, except for their required number of parameters, cannot be
+     * meaningfully validated.
+     */
+    cast() {
+      return this;
+    }
+  };
+  __publicField3(_FunctionSchema, "_base", null);
+  var locale7 = {
+    set: "Set",
+    withElements: "Set<{value}>"
+  };
+  var setValidators = {
+    /**
+     * Creates a validator that asserts that the input is a set.
+     */
+    isSet() {
+      return createValidator(
+        locale7.set,
+        (input) => input instanceof Set
+      );
+    },
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements(elementValidator) {
+      return createDeepValidator(
+        substitute(locale7.withElements, {
+          value: elementValidator.description
+        }),
+        (input, options, path) => {
+          const errors = [];
+          let i = 0;
+          for (const element2 of input) {
+            errors.push(
+              ...elementValidator.validate(
+                element2,
+                options,
+                path.concat(i.toString())
+              )
+            );
+            if (!options.all && errors.length) return errors;
+            i++;
+          }
+          return errors;
+        }
+      );
+    }
+  };
+  var _SetSchema = class _SetSchema2 extends ValueSchema {
+    /**
+     * The base SetSchema instance validating that the input is a Set.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _SetSchema2(setValidators.isSet());
+      return this._base;
+    }
+    /**
+     * Creates a validator that asserts that every element passes the given validator.
+     *
+     * @param elementValidator
+     */
+    withElements(elementValidator) {
+      return this.chain(setValidators.withElements(elementValidator));
+    }
+    /**
+     * Casts to a readonly set.
+     * This is a shallow cast, elements of the array will not be changed.
+     */
+    readonly() {
+      return this;
+    }
+    /**
+     * Casts the parameter type.
+     */
+    cast() {
+      return this;
+    }
+  };
+  __publicField3(_SetSchema, "_base", null);
+  var locale8 = {
+    gte: "at least {value}",
+    gt: "greater than {value}",
+    lte: "at most {value}",
+    lt: "less than {value}",
+    within: "within {min} and {max}",
+    safeInteger: "safe integer",
+    finite: "finite"
+  };
+  var numberValidators = {
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    gte(min) {
+      return createValidator(
+        substitute(locale8.gte, { value: min }),
+        (input) => input >= min
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    gt(min) {
+      return createValidator(
+        substitute(locale8.gt, { value: min }),
+        (input) => input > min
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    lte(max) {
+      return createValidator(
+        substitute(locale8.lte, { value: max }),
+        (input) => input <= max
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    lt(max) {
+      return createValidator(
+        substitute(locale8.lt, { value: max }),
+        (input) => input < max
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    within(min, max) {
+      return createValidator(
+        substitute(locale8.within, { min, max }),
+        (input) => input >= min && input <= max
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    finite() {
+      return createValidator(locale8.finite, (input) => Number.isFinite(input));
+    },
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    safeInteger() {
+      return createValidator(
+        locale8.safeInteger,
+        (input) => Number.isSafeInteger(input)
+      );
+    }
+  };
+  var _NumberSchema = class _NumberSchema2 extends ValueSchema {
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _NumberSchema2(typeOfValidators.number);
+      return this._base;
+    }
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    gte(min) {
+      return this.chain(numberValidators.gte(min));
+    }
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    gt(min) {
+      return this.chain(numberValidators.gt(min));
+    }
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    lte(max) {
+      return this.chain(numberValidators.lte(max));
+    }
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    lt(max) {
+      return this.chain(numberValidators.lt(max));
+    }
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    within(min, max) {
+      return this.chain(numberValidators.within(min, max));
+    }
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    finite() {
+      return this.chain(numberValidators.finite());
+    }
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    safeInteger() {
+      return this.chain(numberValidators.safeInteger());
+    }
+  };
+  __publicField3(_NumberSchema, "_base", null);
+  var NumberSchema = _NumberSchema;
+  function isValidatorWithPartial(validator) {
+    return "partial" in validator && "partialDeep" in validator;
+  }
+  function maybeToDeepPartial(validator) {
+    return isValidatorWithPartial(validator) ? validator.partialDeep() : validator;
+  }
+  function maybeToPartial(validator) {
+    return isValidatorWithPartial(validator) ? validator.partial() : validator;
+  }
+  var locale9 = {
+    extend: "{\n{body}\n}",
+    prop: "{key}: {value}",
+    propSeparator: ",\n",
+    indent: "  ",
+    required: `property '{key}' is required`
+  };
+  var objectValidators = {
+    /**
+     * Creates a validator that validates the input has properties that pass their respective
+     * validators.
+     *
+     * @param propertyValidators
+     */
+    properties(propertyValidators) {
+      const propertiesDescriptions = [];
+      const keys = ownKeys(propertyValidators);
+      for (const key of keys) {
+        const validator2 = propertyValidators[key];
+        propertiesDescriptions.push(
+          substitute(locale9.prop, {
+            key: String(key) + (validator2.options.optional ? "?" : ""),
+            value: validator2.description
+          })
+        );
+      }
+      const description = substitute(locale9.extend, {
+        body: propertiesDescriptions.join(locale9.propSeparator).split("\n").map((line) => locale9.indent + line).join("\n")
+      });
+      const validator = createDeepValidator(
+        description,
+        (input, options, path) => {
+          const errors = [];
+          for (const key of keys) {
+            const validator2 = propertyValidators[key];
+            if (key in input) {
+              const value = input[key];
+              errors.push(
+                ...validator2.validate(
+                  value,
+                  options,
+                  path.concat(String(key))
+                )
+              );
+            } else {
+              if (!validator2.options.optional) {
+                errors.push({
+                  message: substitute(locale9.required, { key }),
+                  path: path.concat(String(key))
+                });
+              }
+            }
+            if (!options.all && errors.length) return errors;
+          }
+          return errors;
+        }
+      );
+      return merge(validator, {
+        partial() {
+          const optionalPropertyValidators = {};
+          for (const key of keys) {
+            optionalPropertyValidators[key] = propertyValidators[key].optional();
+          }
+          return objectValidators.properties(
+            optionalPropertyValidators
+          );
+        },
+        partialDeep() {
+          const optionalPropertyValidators = {};
+          for (const key of keys) {
+            optionalPropertyValidators[key] = maybeToDeepPartial(
+              propertyValidators[key].optional()
+            );
+          }
+          return objectValidators.properties(
+            optionalPropertyValidators
+          );
+        }
+      });
+    }
+  };
+  var _ObjectSchema = class _ObjectSchema2 extends ValueSchema {
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _ObjectSchema2(typeOfValidators.object);
+      return this._base;
+    }
+    /**
+     * Creates a validator that validates the input has properties that pass their respective
+     * validators.
+     *
+     * @param propertyValidators
+     */
+    extend(propertyValidators) {
+      return this.chain(objectValidators.properties(propertyValidators));
+    }
+    /**
+     * Allows all properties to be undefined.
+     */
+    partial() {
+      return this.clone(maybeToPartial);
+    }
+    /**
+     * Allows all recursive properties to be undefined.
+     */
+    partialDeep() {
+      return this.clone(maybeToDeepPartial);
+    }
+    /**
+     * Casts the type parameter.
+     */
+    cast() {
+      return this;
+    }
+  };
+  __publicField3(_ObjectSchema, "_base", null);
+  var locale10 = {
+    notEmpty: "not empty",
+    minLength: "at least {value} characters",
+    maxLength: "at most {value} characters",
+    noWhitespace: "no whitespace characters",
+    matches: "matches {value}"
+  };
+  var stringValidators = {
+    /**
+     * Creates a validator that asserts that the input is not empty.
+     */
+    notEmpty() {
+      return createValidator(locale10.notEmpty, (input) => input !== "");
+    },
+    /**
+     * Creates a validator that asserts that the input string has at least the given minimum
+     * length.
+     *
+     * @param min The string must be at least this length.
+     */
+    minLength(min) {
+      return createValidator(
+        substitute(locale10.minLength, { value: min }),
+        (input) => input.length >= min
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input string has at most the given maximum
+     * length.
+     *
+     * @param max The string must be at most this length.
+     */
+    maxLength(max) {
+      return createValidator(
+        substitute(locale10.maxLength, { value: max }),
+        (input) => input.length <= max
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input string has no whitespace characters.
+     * Whitespace characters include space, new line, carriage return, and tab.
+     */
+    noWhitespace() {
+      return createValidator(
+        locale10.noWhitespace,
+        (input) => input.search(/\s/g) === -1
+      );
+    },
+    /**
+     * Creates a validator that asserts that the input string matches the given regex.
+     * @param regex
+     */
+    matches(regex) {
+      return createValidator(
+        substitute(locale10.matches, { value: regex.toString() }),
+        (input) => {
+          return regex.test(input);
+        }
+      );
+    }
+  };
+  var _StringSchema = class _StringSchema2 extends ValueSchema {
+    /**
+     * The base SetSchema instance validating that the input is a Set.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _StringSchema2(typeOfValidators.string);
+      return this._base;
+    }
+    /**
+     * Creates a validator that asserts that the input is not empty.
+     */
+    notEmpty() {
+      return this.chain(stringValidators.notEmpty());
+    }
+    /**
+     * Creates a validator that asserts that the input string has at least the given minimum
+     * length.
+     *
+     * @param min The string must be at least this length.
+     */
+    minLength(min) {
+      return this.chain(stringValidators.minLength(min));
+    }
+    /**
+     * Creates a validator that asserts that the input string has at most the given maximum
+     * length.
+     *
+     * @param max The string must be at most this length.
+     */
+    maxLength(max) {
+      return this.chain(stringValidators.maxLength(max));
+    }
+    /**
+     * Creates a validator that asserts that the input string has no whitespace characters.
+     * Whitespace characters include space, new line, carriage return, and tab.
+     */
+    noWhitespace() {
+      return this.chain(stringValidators.noWhitespace());
+    }
+    /**
+     * Creates a validator that asserts that the input string matches the given regex.
+     * @param regex
+     */
+    matches(regex) {
+      return this.chain(stringValidators.matches(regex));
+    }
+  };
+  __publicField3(_StringSchema, "_base", null);
+  var StringSchema = _StringSchema;
+  var locale11 = {
+    record: "{ [key: {key}]: {value} }"
+  };
+  var recordValidators = {
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has keys and
+     * values that match their respective validators.
+     *
+     * Prototype members are not included.
+     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+     * to the key validator as '0'.
+     *
+     * @param keyValidator Validates each key.
+     * @param valueValidator Validates each value.
+     */
+    record(keyValidator, valueValidator) {
+      return createDeepValidator(
+        substitute(locale11.record, {
+          key: keyValidator.description,
+          value: valueValidator.description
+        }),
+        (input, options, path) => {
+          const errors = [];
+          for (const key of ownKeys(input)) {
+            const keyStr = String(key);
+            errors.push(
+              ...keyValidator.validate(
+                key,
+                options,
+                path.concat(`[${keyStr}]`)
+              )
+            );
+            if (!options.all && errors.length) return errors;
+            const value = input[key];
+            errors.push(
+              ...valueValidator.validate(
+                value,
+                options,
+                path.concat(keyStr)
+              )
+            );
+            if (!options.all && errors.length) return errors;
+          }
+          return errors;
+        }
+      );
+    }
+  };
+  var _RecordSchema = class _RecordSchema2 extends ValueSchema {
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _RecordSchema2(typeOfValidators.object);
+      return this._base;
+    }
+    static get defaultKeyValidator() {
+      return StringSchema.base;
+    }
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has keys and
+     * values that match their respective validators.
+     *
+     * Prototype members are not included.
+     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
+     * to the key validator as '0'.
+     *
+     * @param keyValidator Validates each key.
+     * @param valueValidator Validates each value.
+     */
+    record(keyValidator, valueValidator) {
+      return this.chain(recordValidators.record(keyValidator, valueValidator));
+    }
+    /**
+     * Returns a validator that asserts that the object's own enumerable properties has
+     * string keys and values that match the given validator.
+     *
+     * Prototype members are not included.
+     *
+     * @param valueValidator Validates each value.
+     */
+    recordValues(valueValidator) {
+      return this.record(_RecordSchema2.defaultKeyValidator, valueValidator);
+    }
+    /**
+     * Casts to a ReadonlyRecord
+     */
+    readonly() {
+      return this;
+    }
+    /**
+     * Casts the type parameter.
+     */
+    cast() {
+      return this;
+    }
+  };
+  __publicField3(_RecordSchema, "_base", null);
+  var locale12 = {
+    isOneOf: "one of: {value}",
+    instanceOf: "instance of {value}",
+    oneOfSeparator: " | "
+  };
+  function isOneOf(...possibleValues) {
+    return new ValueSchema(
+      createValidator(
+        substitute(locale12.isOneOf, {
+          value: possibleValues.join(locale12.oneOfSeparator)
+        }),
+        (input) => possibleValues.includes(input)
+      )
+    );
+  }
+  function number() {
+    return NumberSchema.base;
+  }
+
+  // ../vinyl-xml/dist/index.js
+  var __defProp5 = Object.defineProperty;
+  var __defProps4 = Object.defineProperties;
+  var __getOwnPropDescs4 = Object.getOwnPropertyDescriptors;
+  var __getOwnPropSymbols5 = Object.getOwnPropertySymbols;
+  var __hasOwnProp5 = Object.prototype.hasOwnProperty;
+  var __propIsEnum5 = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp5 = (obj, key, value) => key in obj ? __defProp5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues5 = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp5.call(b, prop))
+        __defNormalProp5(a, prop, b[prop]);
+    if (__getOwnPropSymbols5)
+      for (var prop of __getOwnPropSymbols5(b)) {
+        if (__propIsEnum5.call(b, prop))
+          __defNormalProp5(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __spreadProps4 = (a, b) => __defProps4(a, __getOwnPropDescs4(b));
+  var __publicField4 = (obj, key, value) => __defNormalProp5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  function element(rules, options) {
+    return __spreadProps4(__spreadValues5({
+      type: "element",
+      localPart: void 0,
+      namespaceUri: void 0,
+      required: false
+    }, options), {
+      rules
+    });
+  }
+  function elements(rules, options) {
+    return __spreadProps4(__spreadValues5({
+      type: "elements",
+      localPart: void 0,
+      namespaceUri: void 0,
+      minOccurs: 0,
+      maxOccurs: null,
+      useEmptyArrays: false
+    }, options), {
+      rules
+    });
+  }
+  function characters(parse, stringify2) {
+    return { type: "characters", parse, stringify: stringify2 };
+  }
+  var charactersString = /* @__PURE__ */ characters((i) => i, stringify);
+  function attr(parse, stringify2, options) {
+    return __spreadProps4(__spreadValues5({
+      type: "attribute",
+      localPart: void 0,
+      namespaceUri: null,
+      required: false,
+      default: void 0
+    }, options), {
+      parse,
+      stringify: stringify2
+    });
+  }
+  function attrString(options) {
+    return attr((i) => i, stringify, options);
+  }
+  function attrInt(options) {
+    return attr(parseInt, stringify, options);
+  }
+  function attrFloat(options) {
+    return attr(parseFloat, stringify, options);
+  }
+  function attrBoolean(options) {
+    return attr(parseBoolean, stringify, options);
+  }
+  function attrDateTime(options) {
+    return attr(parseDate, stringifyDate, options);
+  }
+  var xmlSchemaErrorLocale = {
+    atLeastElements: "Expected at least {expected} occurrences of {property} but was {actual}",
+    atMostElements: "Expected at most {expected} occurrences of {property} but was {actual}",
+    cyclicReferences: "Cyclic reference detected",
+    requiredAttribute: `Attribute '{property}' is required`
+  };
+  var XmlSchemaError = class _XmlSchemaError extends ReportableError {
+    get [Symbol.toStringTag]() {
+      return "XmlSchemaError";
+    }
+    constructor(message) {
+      super(message, ErrorOrigin.PARSING);
+      Object.setPrototypeOf(this, _XmlSchemaError.prototype);
+    }
+  };
+  var XMLNS = "http://www.w3.org/2000/xmlns/";
+  var LT = /* @__PURE__ */ char("<");
+  var GT = /* @__PURE__ */ char(">");
+  var EQ = /* @__PURE__ */ char("=");
+  var SLASH = /* @__PURE__ */ char("/");
+  var COLON = /* @__PURE__ */ char(":");
+  var QMARK = /* @__PURE__ */ char("?");
+  var EXCL = /* @__PURE__ */ char("!");
+  var APOS = /* @__PURE__ */ char("'");
+  var QUOT = /* @__PURE__ */ char('"');
+  var QUOTES = /* @__PURE__ */ new Set([APOS, QUOT]);
+  function parseXml(str, handler) {
+    const c = new StringReader(str);
+    let current = {
+      qName: "#document",
+      namespaceMap: /* @__PURE__ */ new Map(),
+      defaultNamespaceUri: null
+    };
+    const stack = [current];
+    const namespaceLookup = (prefix) => {
+      if (!prefix) return current.defaultNamespaceUri;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const map = stack[i].namespaceMap;
+        if (map.has(prefix)) return stack[i].namespaceMap.get(prefix);
+      }
+      return null;
+    };
+    try {
+      handler.startDocument();
+    } catch (e) {
+      c.err(e.message);
+    }
+    while (c.hasNext()) {
+      const charsStart = c.untilChar(LT);
+      if (charsStart < c.position) {
+        const chars = str.substring(charsStart, c.position);
+        try {
+          handler.textNode(chars);
+        } catch (e) {
+          c.err(e.message);
+        }
+      }
+      if (!c.hasNext()) break;
+      c.next();
+      if (c.charIf(SLASH)) {
+        c.white();
+        const name = readQName(c);
+        if (name.qName !== current.qName)
+          c.err(`Expected </${current.qName}> but was </${name.qName}>`);
+        stack.pop();
+        current = last(stack);
+        c.white();
+        c.readChar(GT);
+        try {
+          handler.endElement();
+        } catch (e) {
+          c.err(e.message);
+        }
+      } else if (c.charIf(QMARK)) {
+        untilTagClose(c);
+      } else if (c.charIf(EXCL)) {
+        if (c.charIf(
+          45
+          /* - */
+        )) {
+          c.readChar(45);
+          c.untilString("-->");
+          c.read("-->");
+        } else if (c.stringIf("[CDATA[")) {
+          const charsStart2 = c.untilString("]]>");
+          try {
+            handler.cDataNode(str.substring(charsStart2, c.position));
+          } catch (e) {
+            c.err(e.message);
+          }
+          c.read("]]>");
+        } else {
+          untilTagClose(c);
+        }
+      } else {
+        const name = readQName(c);
+        current = {
+          qName: name.qName,
+          namespaceMap: /* @__PURE__ */ new Map(),
+          defaultNamespaceUri: current.defaultNamespaceUri
+        };
+        stack.push(current);
+        const attributes = xmlAttributes(c, current);
+        name.namespaceUri = namespaceLookup(name.prefix);
+        for (const attributesKey in attributes) {
+          const value = attributes[attributesKey];
+          const name2 = value.name;
+          if (name2.prefix && !name2.namespaceUri) {
+            name2.namespaceUri = namespaceLookup(name2.prefix);
+          }
+        }
+        try {
+          handler.startElement(name, attributes);
+        } catch (e) {
+          c.err(e.message);
+        }
+        if (c.charIf(SLASH)) {
+          c.readChar(GT);
+          stack.pop();
+          current = last(stack);
+          try {
+            handler.endElement();
+          } catch (e) {
+            c.err(e.message);
+          }
+        } else {
+          c.readChar(GT);
+        }
+      }
+    }
+    try {
+      return handler.endDocument();
+    } catch (e) {
+      return c.err(e.message);
+    }
+  }
+  function readAttributeValue(c) {
+    const quote = c.next();
+    if (!QUOTES.has(quote)) c.err(`Expected ' or "`);
+    const value = c.substringUntil((charCode) => charCode === quote);
+    c.readChar(quote);
+    return decodeEntities(value);
+  }
+  function untilTagClose(c) {
+    while (true) {
+      c.until((c2) => c2 === APOS || c2 === QUOT || c2 === GT);
+      const char2 = c.next();
+      if (QUOTES.has(char2)) {
+        c.untilChar(char2);
+        c.next();
+      } else {
+        break;
+      }
+    }
+  }
+  function isNameChar(charCode) {
+    if (charCode >= 97) {
+      if (charCode >= 183) {
+        if (charCode >= 768) {
+          if (charCode >= 8255) {
+            return charCode <= 8256;
+          } else {
+            return charCode <= 879;
+          }
+        } else {
+          return charCode === 183;
+        }
+      } else {
+        return charCode <= 122;
+      }
+    } else {
+      if (charCode >= 95) {
+        return charCode === 95;
+      } else {
+        if (charCode >= 65) {
+          return charCode <= 90;
+        } else {
+          if (charCode >= 45) {
+            if (charCode >= 48) {
+              return charCode <= 57;
+            } else {
+              return charCode <= 46;
+            }
+          } else {
+            return false;
+          }
+        }
+      }
+    }
+  }
+  function readQName(reader) {
+    const prefixOrLocalName = reader.substringWhile(isNameChar);
+    let prefix, localPart, name;
+    if (reader.charIf(COLON)) {
+      prefix = prefixOrLocalName;
+      localPart = reader.substringWhile(isNameChar);
+      name = `${prefix}:${localPart}`;
+    } else {
+      prefix = null;
+      localPart = prefixOrLocalName;
+      name = localPart;
+    }
+    return { prefix, localPart, qName: name, namespaceUri: null };
+  }
+  function xmlAttributes(reader, stackElement) {
+    const attributes = {};
+    while (true) {
+      reader.white();
+      if (!isNameChar(reader.peek)) break;
+      const name = readQName(reader);
+      reader.white();
+      let value = "";
+      if (reader.charIf(EQ)) {
+        reader.white();
+        value = readAttributeValue(reader);
+      } else {
+      }
+      if (name.prefix === "xmlns") {
+        name.namespaceUri = XMLNS;
+        stackElement.namespaceMap.set(
+          name.localPart,
+          value === "" ? null : value
+        );
+      } else if (!name.prefix && name.localPart === "xmlns") {
+        name.namespaceUri = XMLNS;
+        stackElement.defaultNamespaceUri = !value ? null : value;
+      }
+      if (attributes[name.qName] != null)
+        reader.err(`Attribute '${name.qName}' is already specified.`);
+      attributes[name.qName] = { name, value };
+    }
+    return attributes;
+  }
+  var locale23 = {
+    illegalRuleOverrideTypeError: "Cannot override the rule {property} of type {sourceType} with a rule of type {overrideType}",
+    illegalQNameOverrideError: "Cannot override the rule {property} with a different localPart or namespace"
+  };
+  function mergeXmlRules(...rules) {
+    let finalRule = rules[0];
+    for (let i = 1; i < rules.length; i++) {
+      finalRule = plainObjectMergeRule.merge(
+        finalRule,
+        rules[i],
+        mergeXmlRule
+      );
+    }
+    return finalRule;
+  }
+  function mergeXmlRule(sourceA, sourceB, prop) {
+    var _a2, _b, _c, _d;
+    if (sourceA == null) return sourceB;
+    const sourceAIsLazy = typeof sourceA === "function";
+    const sourceBIsLazy = typeof sourceB === "function";
+    if (sourceAIsLazy || sourceBIsLazy) {
+      return () => {
+        const a = sourceAIsLazy ? sourceA() : sourceA;
+        const b = sourceBIsLazy ? sourceB() : sourceB;
+        return mergeXmlRule(a, b, prop);
+      };
+    }
+    if (sourceA.type !== sourceB.type) {
+      throw new ValidationError(
+        substitute(locale23.illegalRuleOverrideTypeError, {
+          property: prop,
+          sourceType: sourceA.type,
+          overrideType: sourceB.type
+        })
+      );
+    }
+    switch (sourceA.type) {
+      case "attribute":
+      case "element":
+      case "elements": {
+        const b = sourceB;
+        if (sourceA.namespaceUri !== b.namespaceUri || ((_a2 = sourceA.localPart) != null ? _a2 : prop) !== ((_b = b.localPart) != null ? _b : prop)) {
+          throw new ValidationError(
+            substitute(locale23.illegalQNameOverrideError, {
+              property: prop
+            })
+          );
+        }
+        break;
+      }
+    }
+    switch (sourceA.type) {
+      case "attribute": {
+        const b = sourceB;
+        return __spreadProps4(__spreadValues5({}, b), {
+          default: (_c = b.default) != null ? _c : sourceA.default
+        });
+      }
+      case "characters":
+        return sourceB;
+      case "element": {
+        const b = sourceB;
+        return __spreadProps4(__spreadValues5({}, b), {
+          required: sourceA.required || b.required,
+          rules: mergeXmlRules(sourceA.rules, b.rules)
+        });
+      }
+      case "elements": {
+        const b = sourceB;
+        const maxOccurs = sourceA.maxOccurs != null && b.maxOccurs != null ? Math.min(sourceA.maxOccurs, b.maxOccurs) : (_d = sourceA.maxOccurs) != null ? _d : b.maxOccurs;
+        return __spreadProps4(__spreadValues5({}, b), {
+          minOccurs: Math.max(sourceA.minOccurs, b.minOccurs),
+          maxOccurs,
+          useEmptyArrays: sourceA.useEmptyArrays || b.useEmptyArrays,
+          rules: mergeXmlRules(sourceA.rules, b.rules)
+        });
+      }
+    }
+  }
+  var EmptyRules = {
+    __type: /* @__PURE__ */ invariant(),
+    attributes: /* @__PURE__ */ new Map(),
+    elements: /* @__PURE__ */ new Map(),
+    characters: void 0
+  };
+  function mapXmlRules(rules, parentNamespaceUri = null) {
+    var _a2, _b, _c;
+    const attributeRules = /* @__PURE__ */ new Map();
+    const elementRules = /* @__PURE__ */ new Map();
+    let charactersRule = void 0;
+    for (const property in rules) {
+      const handlerOrFunction = rules[property];
+      let handler;
+      if (typeof handlerOrFunction === "function") {
+        handler = handlerOrFunction();
+      } else {
+        handler = handlerOrFunction;
+      }
+      let key;
+      switch (handler.type) {
+        case "characters":
+          if (charactersRule !== void 0)
+            throw new IllegalArgumentError(
+              "characters handler already defined"
+            );
+          charactersRule = {
+            property,
+            parse: handler.parse,
+            stringify: handler.stringify
+          };
+          break;
+        case "element":
+        case "elements": {
+          const localPart = (_a2 = handler.localPart) != null ? _a2 : property;
+          const namespaceUri = handler.namespaceUri === void 0 ? parentNamespaceUri : handler.namespaceUri;
+          key = xmlRuleKey(localPart, namespaceUri);
+          if (elementRules.has(key)) {
+            throw new IllegalArgumentError(
+              `Multiple element rules for ${key}`
+            );
+          }
+          if (handler.type === "element") {
+            const rules2 = handler.rules;
+            elementRules.set(key, {
+              array: false,
+              property,
+              minOccurs: handler.required ? 1 : 0,
+              maxOccurs: 1,
+              rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
+              useEmptyArrays: false,
+              localPart,
+              namespaceUri
+            });
+          } else {
+            const rules2 = handler.rules;
+            elementRules.set(key, {
+              array: true,
+              property,
+              maxOccurs: handler.maxOccurs,
+              minOccurs: handler.minOccurs,
+              rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
+              useEmptyArrays: handler.useEmptyArrays,
+              localPart,
+              namespaceUri
+            });
+          }
+          break;
+        }
+        case "attribute": {
+          const namespaceUri = handler.namespaceUri;
+          const localPart = (_b = handler.localPart) != null ? _b : property;
+          key = xmlRuleKey(localPart, namespaceUri);
+          if (attributeRules.has(key)) {
+            throw new IllegalArgumentError(
+              `Multiple attribute rules for ${key}`
+            );
+          }
+          attributeRules.set(key, {
+            property,
+            default: handler.default,
+            parse: handler.parse,
+            stringify: handler.stringify,
+            required: handler.required,
+            localPart,
+            namespaceUri: (_c = handler.namespaceUri) != null ? _c : null
+          });
+          break;
+        }
+      }
+    }
+    return {
+      __type: invariant(),
+      attributes: attributeRules,
+      elements: elementRules,
+      characters: charactersRule
+    };
+  }
+  function xmlRuleKey(localPart, namespaceUri = null) {
+    return `${namespaceUri != null ? namespaceUri : ""}:${localPart}`;
+  }
+  function getRule(name, rules) {
+    return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
+  }
+  var ParseXmlHandlerImpl = class {
+    constructor(rules, options) {
+      this.rules = rules;
+      __publicField4(this, "stack", []);
+      __publicField4(this, "options");
+      __publicField4(this, "busy", false);
+      this.options = __spreadValues5({ validateRules: true }, options);
+    }
+    startDocument() {
+      if (this.busy)
+        throw new IllegalStateError("XML content handler is busy");
+      this.busy = true;
+      const rules = this.rules;
+      this.stack.push({
+        element: new XmlElementImpl(),
+        rules,
+        characters: ""
+      });
+    }
+    startElement(name, attributes) {
+      var _a2;
+      const parent = last(this.stack);
+      let element2 = null;
+      const elementRule = getRule(name, parent.rules.elements);
+      const rules = (_a2 = elementRule == null ? void 0 : elementRule.rules()) != null ? _a2 : EmptyRules;
+      if (elementRule) {
+        const prop = elementRule.property;
+        element2 = new XmlElementImpl(parent.element);
+        if (elementRule.array) {
+          const arr = parent.element[prop];
+          if (Array.isArray(arr)) {
+            arr.push(element2);
+          } else {
+            parent.element[prop] = [element2];
+          }
+        } else {
+          if (parent.element[prop]) {
+            throw new XmlSchemaError(
+              `Expected single element with name ${name.qName}`
+            );
+          } else {
+            parent.element[prop] = element2;
+          }
+        }
+        const attributeRules = rules.attributes;
+        for (const k in attributes) {
+          const attribute = attributes[k];
+          const name2 = attribute.name;
+          const attributeRule = getRule(name2, attributeRules);
+          if (attributeRule) {
+            element2[attributeRule.property] = attributeRule.parse(
+              attribute.value
+            );
+          }
+        }
+        attributeRules.forEach((_value, key) => {
+          const rule = attributeRules.get(key);
+          if (!(rule.property in element2)) {
+            if (rule.default != null) {
+              element2[rule.property] = rule.default;
+            } else if (this.options.validateRules && rule.required) {
+              throw new XmlSchemaError(
+                substitute(xmlSchemaErrorLocale.requiredAttribute, {
+                  property: rule.property
+                })
+              );
+            }
+          }
+        });
+      }
+      this.stack.push({
+        element: element2,
+        rules,
+        characters: ""
+      });
+    }
+    textNode(str) {
+      const current = last(this.stack);
+      if (!current.rules.characters) return;
+      current.characters += decodeEntities(str.trim());
+    }
+    cDataNode(str) {
+      const current = last(this.stack);
+      if (!current.rules.characters) return;
+      current.characters += str;
+    }
+    endElement() {
+      const lastEl = this.stack.pop();
+      const charactersRule = lastEl.rules.characters;
+      if (charactersRule)
+        lastEl.element[charactersRule.property] = charactersRule.parse(
+          lastEl.characters
+        );
+      lastEl.rules.elements.forEach((rule) => {
+        if (rule.array && !(rule.property in lastEl.element)) {
+          if (rule.useEmptyArrays) {
+            lastEl.element[rule.property] = [];
+          }
+        }
+      });
+      this.validate(lastEl);
+    }
+    endDocument() {
+      this.busy = false;
+      const last3 = this.stack.pop();
+      this.validate(last3);
+      return last3.element;
+    }
+    validate(current) {
+      if (!this.options.validateRules) return;
+      current.rules.elements.forEach((rule) => {
+        var _a2, _b;
+        const length = rule.array ? (_b = (_a2 = current.element[rule.property]) == null ? void 0 : _a2.length) != null ? _b : 0 : current.element[rule.property] ? 1 : 0;
+        if (length < rule.minOccurs) {
+          throw new XmlSchemaError(
+            substitute(xmlSchemaErrorLocale.atLeastElements, {
+              property: rule.property,
+              expected: rule.minOccurs,
+              actual: length
+            })
+          );
+        }
+        if (rule.maxOccurs != null && length > rule.maxOccurs) {
+          throw new XmlSchemaError(
+            substitute(xmlSchemaErrorLocale.atMostElements, {
+              property: rule.property,
+              expected: rule.maxOccurs,
+              actual: length
+            })
+          );
+        }
+      });
+    }
+  };
+  var parentSymbol = /* @__PURE__ */ Symbol("parent");
+  var _a;
+  _a = parentSymbol;
+  var _XmlElementImpl = class _XmlElementImpl2 {
+    constructor(parent = null) {
+      __publicField4(this, _a);
+      this[parentSymbol] = parent;
+    }
+    get parent() {
+      return this[parentSymbol];
+    }
+    set parent(value) {
+      this[parentSymbol] = value;
+    }
+    clone() {
+      const out = new _XmlElementImpl2(this.parent);
+      for (const key in this) {
+        const child = clone(this[key]);
+        if (Array.isArray(child)) {
+          for (const e of child) {
+            if (typeof e === "object" && "parent" in e) e.parent = out;
+          }
+        } else if (typeof child === "object" && "parent" in child) {
+          child.parent = out;
+        }
+        out[key] = child;
+      }
+      return out;
+    }
+    toJSON() {
+      const out = {};
+      for (const key in this) {
+        out[key] = toJson(this[key]);
+      }
+      return out;
+    }
+  };
+  var XmlElementImpl = _XmlElementImpl;
+  var actuateValidator = /* @__PURE__ */ isOneOf("onLoad", "onRequest");
+  function assertActuateEnum(str) {
+    actuateValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+  }
+
+  // src/duration/duration.ts
+  var I = 60;
+  var H = 3600;
+  var D = 86400;
+  var M = 2592e3;
+  var Y = 31536e3;
+  var iso8601Duration = /^(-?)P?(\d+(?:\.\d*)?Y)?(\d+(?:\.\d*)?M)?(\d+(?:\.\d*)?D)?T?(\d+(?:\.\d*)?H)?(\d+(?:\.\d*)?M)?(\d+(?:\.\d*)?S?)?$/i;
+  function parseDuration(value) {
+    const match = iso8601Duration.exec(value);
+    if (match == null)
+      throw new ValidationError(
+        `Unexpected duration: '${value}', should be in iso 8601 format`,
+        ErrorOrigin.PARSING
+      );
+    const sign = match[1] === "-" ? -1 : 1;
+    return sign * (parseFloat(match[2] || "0") * Y + parseFloat(match[3] || "0") * M + parseFloat(match[4] || "0") * D + parseFloat(match[5] || "0") * H + parseFloat(match[6] || "0") * I + parseFloat(match[7] || "0"));
+  }
+  function stringifyDuration(value) {
+    const sign = value < 0 ? "-" : "";
+    let abs = Math.abs(value);
+    const years = Math.floor(abs / Y);
+    abs -= years * Y;
+    const months = Math.floor(abs % Y / M);
+    const days = Math.floor(abs % M / D);
+    const hours = Math.floor(abs % D / H);
+    const minutes = Math.floor(abs % H / I);
+    const seconds = abs % I;
+    let isoString = `${sign}P`;
+    if (years > 0) isoString += `${years}Y`;
+    if (months > 0) isoString += `${months}M`;
+    if (days > 0) isoString += `${days}D`;
+    isoString += "T";
+    if (hours > 0) isoString += `${hours}H`;
+    if (minutes > 0) isoString += `${minutes}M`;
+    if (seconds > 0 || !value) isoString += `${roundToNearest(seconds, 1e-3)}S`;
+    return isoString;
+  }
+
+  // src/manifest/dashManifestXmlRules.ts
+  var dashNamespaceUri = "urn:mpeg:dash:schema:mpd:2011";
+  function dashManifestXmlRules() {
+    const attrActuateType = attr(assertActuateEnum, stringify, {
+      default: "onRequest"
+    });
+    const descriptorType = {
+      id: attrString,
+      schemeIdUri: attrString({ required: true }),
+      value: attrString
+    };
+    const baseURLType = {
+      availabilityTimeComplete: attrBoolean,
+      availabilityTimeOffset: attrFloat,
+      byteRange: attrString,
+      serviceLocation: attrString,
+      _content: charactersString
+    };
+    const contentComponentType = {
+      contentType: attrString,
+      id: attrInt,
+      lang: attrString,
+      par: attr(parseRatio, stringifyRatio),
+      Accessibility: elements(descriptorType),
+      Rating: elements(descriptorType),
+      Role: elements(descriptorType),
+      Viewpoint: elements(descriptorType)
+    };
+    const urlType = {
+      range: attr(parseByteRange, stringifyByteRange),
+      sourceURL: attrString
+    };
+    const uriType = { _content: charactersString };
+    const segmentBaseType = {
+      Initialization: element(urlType),
+      RepresentationIndex: element(urlType),
+      availabilityTimeComplete: attrBoolean,
+      availabilityTimeOffset: attrInt,
+      indexRange: attr(parseByteRange, stringifyByteRange),
+      indexRangeExact: attrBoolean({ default: false }),
+      presentationTimeOffset: attrFloat,
+      timescale: attrInt
+    };
+    const segmentTimelineTypeSType = {
+      d: attrInt({ required: true }),
+      n: attrInt,
+      r: attrInt({ default: 0 }),
+      t: attrInt
+    };
+    const segmentTimelineType = {
+      S: elements(segmentTimelineTypeSType)
+    };
+    const multipleSegmentBaseType = __spreadProps(__spreadValues({}, segmentBaseType), {
+      SegmentTimeline: element(segmentTimelineType),
+      BitstreamSwitching: element(urlType),
+      duration: attrInt,
+      startNumber: attrInt
+    });
+    const segmentURLType = {
+      index: attrString,
+      indexRange: attr(parseByteRange, stringifyByteRange),
+      media: attrString,
+      mediaRange: attr(parseByteRange, stringifyByteRange)
+    };
+    const segmentListType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
+      actuate: attrActuateType,
+      href: attrString,
+      SegmentURL: elements(segmentURLType)
+    });
+    const segmentTemplateType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
+      bitstreamSwitching: attrString,
+      index: attrString,
+      initialization: attrString,
+      media: attrString
+    });
+    const subsetType = {
+      contains: attr(parseIntVector, stringifyIntVector, { required: true }),
+      id: attrString
+    };
+    const eventType = {
+      duration: attrInt,
+      id: attrInt,
+      messageData: attrString,
+      presentationTime: attrInt({ default: 0 })
+    };
+    const eventStreamType = {
+      Event: elements(eventType),
+      actuate: attrActuateType,
+      href: attrString,
+      messageData: attrString,
+      schemeIdUri: attrString({ required: true }),
+      timescale: attrInt,
+      value: attrString
+    };
+    const switchingType = {
+      interval: attrInt({ required: true }),
+      type: attr(parseSwitchingTypeType, stringify)
+    };
+    const representationBaseType = {
+      FramePacking: elements(descriptorType),
+      AudioChannelConfiguration: elements(descriptorType),
+      ContentProtection: elements(descriptorType),
+      EssentialProperty: elements(descriptorType),
+      SupplementalProperty: elements(descriptorType),
+      InbandEventStream: elements(eventStreamType),
+      Switching: elements(switchingType),
+      audioSamplingRate: attr(parseIntVector, stringifyIntVector),
+      codecs: attrString,
+      codingDependency: attrBoolean,
+      frameRate: attr(parseFrameRate, stringifyFrameRate),
+      height: attrInt,
+      maximumSAPPeriod: attrInt,
+      maxPlayoutRate: attrInt,
+      mimeType: attrString,
+      profiles: attr(parseProfiles, stringifyProfiles),
+      sar: attr(parseRatio, stringifyRatio),
+      scanType: attr(parseVideoScan, stringify),
+      segmentProfiles: attrString,
+      startWithSAP: attr(parseSap, stringify),
+      width: attrInt
+    };
+    const subRepresentationType = __spreadProps(__spreadValues({}, representationBaseType), {
+      bandwidth: attrInt,
+      contentComponent: attr(parseStringVector, stringifyStringVector),
+      dependencyLevel: attr(parseIntVector, stringifyIntVector),
+      level: attrInt
+    });
+    const representationType = __spreadProps(__spreadValues({}, representationBaseType), {
+      bandwidth: attrInt({ required: true }),
+      bitrate: attrInt,
+      dependencyId: attr(parseStringVector, stringifyStringVector),
+      id: attrString({ required: true }),
+      mediaStreamStructureId: attr(parseStringVector, stringifyStringVector),
+      qualityRanking: attrInt,
+      BaseURL: elements(baseURLType),
+      SegmentBase: element(segmentBaseType),
+      SegmentList: element(segmentListType),
+      SegmentTemplate: element(segmentTemplateType),
+      SubRepresentation: elements(subRepresentationType)
+    });
+    const adaptationSetType = __spreadProps(__spreadValues({}, representationBaseType), {
+      Accessibility: elements(descriptorType),
+      Role: elements(descriptorType),
+      Rating: elements(descriptorType),
+      Viewpoint: elements(descriptorType),
+      ContentComponent: elements(contentComponentType),
+      BaseURL: elements(baseURLType),
+      SegmentBase: element(segmentBaseType),
+      SegmentList: element(segmentListType),
+      SegmentTemplate: element(segmentTemplateType),
+      Representation: elements(representationType),
+      actuate: attrActuateType,
+      bitstreamSwitching: attrBoolean,
+      contentType: attrString,
+      group: attrInt,
+      href: attrString,
+      id: attrInt,
+      lang: attrString,
+      maxBandwidth: attrInt,
+      maxFrameRate: attr(parseFrameRate, stringifyFrameRate),
+      maxHeight: attrInt,
+      maxWidth: attrInt,
+      minBandwidth: attrInt,
+      minFrameRate: attr(parseFrameRate, stringifyFrameRate),
+      minHeight: attrInt,
+      minWidth: attrInt,
+      par: attr(parseRatio, stringifyRatio),
+      segmentAlignment: attr(parseConditionalUint, stringify, {
+        default: false
+      }),
+      selectionPriority: attrInt({
+        default: 1
+      }),
+      subsegmentAlignment: attr(parseConditionalUint, stringify, {
+        default: false
+      }),
+      subsegmentStartsWithSAP: attr(parseSap, stringify, { default: 0 })
+    });
+    const rangeType = {
+      duration: attr(parseDuration, stringifyDuration),
+      starttime: attr(parseDuration, stringifyDuration)
+    };
+    const metricsType = {
+      metrics: attrString({ required: true }),
+      Range: elements(rangeType),
+      Reporting: elements(descriptorType, { minOccurs: 1 })
+    };
+    const periodType = {
+      BaseURL: elements(baseURLType),
+      SegmentBase: element(segmentBaseType),
+      SegmentList: element(segmentListType),
+      SegmentTemplate: element(segmentTemplateType),
+      AssetIdentifier: element(descriptorType),
+      EventStream: elements(eventStreamType),
+      AdaptationSet: elements(adaptationSetType),
+      Subset: elements(subsetType),
+      SupplementalProperty: elements(descriptorType),
+      actuate: attrActuateType,
+      bitstreamSwitching: attrBoolean({ default: false }),
+      duration: attr(parseDuration, stringifyDuration),
+      href: attrString,
+      id: attrString,
+      start: attr(parseDuration, stringifyDuration)
+    };
+    const programInformationType = {
+      lang: attrString,
+      moreInformationURL: attrString,
+      Copyright: attrString,
+      Source: attrString,
+      Title: attrString
+    };
+    const mpdType = {
+      ProgramInformation: elements(programInformationType),
+      BaseURL: elements(baseURLType),
+      Location: elements(uriType),
+      Period: elements(periodType, { minOccurs: 1 }),
+      Metrics: elements(metricsType),
+      EssentialProperty: elements(descriptorType),
+      SupplementalProperty: elements(descriptorType),
+      UTCTiming: elements(descriptorType),
+      availabilityEndTime: attrDateTime,
+      availabilityStartTime: attrDateTime,
+      id: attrString,
+      maxSegmentDuration: attr(parseDuration, stringifyDuration),
+      maxSubsegmentDuration: attr(parseDuration, stringifyDuration),
+      mediaPresentationDuration: attr(parseDuration, stringifyDuration),
+      minBufferTime: attr(parseDuration, stringifyDuration, {
+        required: true
+      }),
+      minimumUpdatePeriod: attr(parseDuration, stringifyDuration),
+      profiles: attr(parseProfiles, stringifyProfiles, { required: true }),
+      publishTime: attrDateTime,
+      suggestedPresentationDelay: attr(parseDuration, stringifyDuration),
+      timeShiftBufferDepth: attr(parseDuration, stringifyDuration),
+      type: attr(parsePresentationTypeType, stringify, {
+        default: "static"
+      })
+    };
+    return {
+      MPD: element(mpdType, {
+        required: true,
+        namespaceUri: dashNamespaceUri
+      })
+    };
+  }
+  function parseProfiles(str) {
+    return str.split(",");
+  }
+  function stringifyProfiles(value) {
+    return value.join(",");
+  }
+  var videoScanTypeValidator = isOneOf(
+    "progressive",
+    "interlaced",
+    "unknown"
+  );
+  function parseVideoScan(str) {
+    videoScanTypeValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+  }
+  var switchingTypeTypeValidator = isOneOf(
+    "media",
+    "bitstream"
+  );
+  function parseSwitchingTypeType(str) {
+    switchingTypeTypeValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+  }
+  var validateSap = number().within(0, 6);
+  function parseSap(str) {
+    const number2 = parseInt(str);
+    validateSap.assert(number2, ErrorOrigin.PARSING);
+    return number2;
+  }
+  function parseStringVector(str) {
+    return str.split(/\s+/);
+  }
+  function stringifyStringVector(value) {
+    return value.join(" ");
+  }
+  function parseIntVector(str) {
+    return str.split(/\s+/).map((subStr) => parseInt(subStr));
+  }
+  function stringifyIntVector(value) {
+    return value.join(" ");
+  }
+  var presentationTypeValidator = isOneOf(
+    "static",
+    "dynamic"
+  );
+  function parsePresentationTypeType(str) {
+    presentationTypeValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
+  }
+  function parseConditionalUint(str) {
+    const lower = str.toLowerCase();
+    switch (lower) {
+      case "true":
+        return true;
+      case "false":
+        return false;
+      default:
+        return parseInt(str);
+    }
+  }
+
+  // src/manifest/ext/drm/cencXmlRules.ts
+  var cencXmlRules = {
+    default_KID: attr(parseStringVector, stringifyStringVector, {
+      namespaceUri: CENC_NAMESPACE_URI
+    }),
+    pssh: element(
+      {
+        _content: charactersString
+      },
+      {
+        namespaceUri: CENC_NAMESPACE_URI
+      }
+    )
+  };
+
+  // src/manifest/ext/drm/contentProtection.ts
+  function createDashProtectionXmlRules(contentProtectionRules) {
+    const withProtections = {
+      ContentProtection: elements(contentProtectionRules)
+    };
+    return {
+      MPD: element(
+        {
+          Period: elements(
+            {
+              AdaptationSet: elements(__spreadProps(__spreadValues({}, withProtections), {
+                Representation: elements(__spreadProps(__spreadValues({}, withProtections), {
+                  SubRepresentation: elements(
+                    withProtections
+                  )
+                }))
+              }))
+            },
+            {
+              minOccurs: 1
+            }
+          )
+        },
+        { required: true, namespaceUri: dashNamespaceUri }
+      )
+    };
+  }
+
+  // src/manifest/ext/drm/playreadyXmlRules.ts
+  var playreadyXmlRules = {
+    pro: element(
+      {
+        _content: charactersString
+      },
+      {
+        namespaceUri: PLAY_READY_NAMESPACE_URI
+      }
+    )
+  };
+
+  // src/manifest/dashParser.ts
+  var dashDrmRules = mergeXmlRules(
+    dashManifestXmlRules(),
+    createDashProtectionXmlRules(cencXmlRules),
+    createDashProtectionXmlRules(playreadyXmlRules)
+  );
+  var dashDrmRulesMapped = mapXmlRules(dashDrmRules);
+  function dashManifestHandler() {
+    return new ParseXmlHandlerImpl(dashDrmRulesMapped);
+  }
+  function parseDashManifest(manifest) {
+    return parseXml(manifest, dashManifestHandler());
+  }
+
+  // test/dashTestAssets/dash_segmentListMediaRange.ts
+  var dash_segmentListMediaRange = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<MPD minBufferTime="PT2S" type="static" mediaPresentationDuration="PT400.0133056640625S" profiles="urn:mpeg:dash:profile:isoff-on-demand:2011" xmlns="urn:mpeg:dash:schema:mpd:2011" xmlns:amz-music="urn:amazon:music:drm:2019" xmlns:cenc="urn:mpeg:cenc:2013" xmlns:mspr="urn:microsoft:playready">
+    <Period id="0">
+        <AdaptationSet id="1" contentType="audio" selectionPriority="2000">
+            <ContentProtection schemeIdUri="urn:mpeg:dash:mp4protection:2011" cenc:default_KID="53443d2c-a548-037d-dfca-b6873a3b16a7" value="cenc"/>
+            <ContentProtection schemeIdUri="urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed">
+                <cenc:pssh>AAAAXXBzc2gAAAAA7e+LqXnWSs6jyCfc1R0h7QAAAD0SEFNEPSylSAN938q2hzo7FqcaC0FtYXpvbk11c2ljIhxjaWQ6VTBROUxLVklBMzNmeXJhSE9qc1dwdz09</cenc:pssh>
+            </ContentProtection>
+            <SupplementalProperty schemeIdUri="urn:mpeg:mpegB:cicp:ProgramLoudness" value="-13.5 LUFS"/>
+            <SupplementalProperty schemeIdUri="amz-music:trackType" value="HD"/>
+            <SupplementalProperty schemeIdUri="urn:mpeg:dash:adaptation-set-switching:2016" value="2"/>
+            <SupplementalProperty schemeIdUri="urn:mpeg:mpegB:cicp:AnchorLoudness" value="-11.7 LUFS"/>
+            <Representation id="1" qualityRanking="4" codecs="flac" audioSamplingRate="44100" bandwidth="1021104" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <SupplementalProperty schemeIdUri="amz-music:bitDepth" value="16"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/a3ce7553-e9a3-3ca6-8fda-8f354b8cee0f.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=HD_44&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="44100" duration="441000">
+                    <Initialization range="0-1067"/>
+                    <SegmentURL mediaRange="1580-1124387"/>
+                    <SegmentURL mediaRange="1124388-2301681"/>
+                    <SegmentURL mediaRange="2301682-3413884"/>
+                    <SegmentURL mediaRange="3413885-4563668"/>
+                    <SegmentURL mediaRange="4563669-5789595"/>
+                    <SegmentURL mediaRange="5789596-7027203"/>
+                    <SegmentURL mediaRange="7027204-8258589"/>
+                    <SegmentURL mediaRange="8258590-9476689"/>
+                    <SegmentURL mediaRange="9476690-10663879"/>
+                    <SegmentURL mediaRange="10663880-11801656"/>
+                    <SegmentURL mediaRange="11801657-13028295"/>
+                    <SegmentURL mediaRange="13028296-14259035"/>
+                    <SegmentURL mediaRange="14259036-15501034"/>
+                    <SegmentURL mediaRange="15501035-16715074"/>
+                    <SegmentURL mediaRange="16715075-17945696"/>
+                    <SegmentURL mediaRange="17945697-19181760"/>
+                    <SegmentURL mediaRange="19181761-20430664"/>
+                    <SegmentURL mediaRange="20430665-21668186"/>
+                    <SegmentURL mediaRange="21668187-22889588"/>
+                    <SegmentURL mediaRange="22889589-24105876"/>
+                    <SegmentURL mediaRange="24105877-25286931"/>
+                    <SegmentURL mediaRange="25286932-26474293"/>
+                    <SegmentURL mediaRange="26474294-27717336"/>
+                    <SegmentURL mediaRange="27717337-28944000"/>
+                    <SegmentURL mediaRange="28944001-30217943"/>
+                    <SegmentURL mediaRange="30217944-31494322"/>
+                    <SegmentURL mediaRange="31494323-32753722"/>
+                    <SegmentURL mediaRange="32753723-33819438"/>
+                    <SegmentURL mediaRange="33819439-34871800"/>
+                    <SegmentURL mediaRange="34871801-35987451"/>
+                    <SegmentURL mediaRange="35987452-37198633"/>
+                    <SegmentURL mediaRange="37198634-38400513"/>
+                    <SegmentURL mediaRange="38400514-39590378"/>
+                    <SegmentURL mediaRange="39590379-40775418"/>
+                    <SegmentURL mediaRange="40775419-42023162"/>
+                    <SegmentURL mediaRange="42023163-43262782"/>
+                    <SegmentURL mediaRange="43262783-44466388"/>
+                    <SegmentURL mediaRange="44466389-45664349"/>
+                    <SegmentURL mediaRange="45664350-46838625"/>
+                    <SegmentURL mediaRange="46838626-47421889"/>
+                </SegmentList>
+            </Representation>
+            <Representation id="2" qualityRanking="3" codecs="flac" audioSamplingRate="48000" bandwidth="1855801" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <SupplementalProperty schemeIdUri="amz-music:bitDepth" value="24"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/f5b706c9-5892-3a17-9d01-4da362cfad35.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=UHD_48&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="48000" duration="480000">
+                    <Initialization range="0-1067"/>
+                    <SegmentURL mediaRange="1580-2140301"/>
+                    <SegmentURL mediaRange="2140302-4352961"/>
+                    <SegmentURL mediaRange="4352962-6499834"/>
+                    <SegmentURL mediaRange="6499835-8687556"/>
+                    <SegmentURL mediaRange="8687557-10955471"/>
+                    <SegmentURL mediaRange="10955472-13235819"/>
+                    <SegmentURL mediaRange="13235820-15509496"/>
+                    <SegmentURL mediaRange="15509497-17768731"/>
+                    <SegmentURL mediaRange="17768732-19993372"/>
+                    <SegmentURL mediaRange="19993373-22167125"/>
+                    <SegmentURL mediaRange="22167126-24434254"/>
+                    <SegmentURL mediaRange="24434255-26706557"/>
+                    <SegmentURL mediaRange="26706558-28990196"/>
+                    <SegmentURL mediaRange="28990197-31245239"/>
+                    <SegmentURL mediaRange="31245240-33516976"/>
+                    <SegmentURL mediaRange="33516977-35793411"/>
+                    <SegmentURL mediaRange="35793412-38083225"/>
+                    <SegmentURL mediaRange="38083226-40361780"/>
+                    <SegmentURL mediaRange="40361781-42623154"/>
+                    <SegmentURL mediaRange="42623155-44879987"/>
+                    <SegmentURL mediaRange="44879988-47098315"/>
+                    <SegmentURL mediaRange="47098316-49322904"/>
+                    <SegmentURL mediaRange="49322905-51607367"/>
+                    <SegmentURL mediaRange="51607368-53874862"/>
+                    <SegmentURL mediaRange="53874863-56192866"/>
+                    <SegmentURL mediaRange="56192867-58512617"/>
+                    <SegmentURL mediaRange="58512618-60815181"/>
+                    <SegmentURL mediaRange="60815182-62914181"/>
+                    <SegmentURL mediaRange="62914182-65000611"/>
+                    <SegmentURL mediaRange="65000612-67150839"/>
+                    <SegmentURL mediaRange="67150840-69402495"/>
+                    <SegmentURL mediaRange="69402496-71643660"/>
+                    <SegmentURL mediaRange="71643661-73870974"/>
+                    <SegmentURL mediaRange="73870975-76093618"/>
+                    <SegmentURL mediaRange="76093619-78383457"/>
+                    <SegmentURL mediaRange="78383458-80665083"/>
+                    <SegmentURL mediaRange="80665084-82909593"/>
+                    <SegmentURL mediaRange="82909594-85145972"/>
+                    <SegmentURL mediaRange="85145973-87356513"/>
+                    <SegmentURL mediaRange="87356514-88804457"/>
+                </SegmentList>
+            </Representation>
+            <Representation id="3" qualityRanking="2" codecs="flac" audioSamplingRate="96000" bandwidth="3278164" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <SupplementalProperty schemeIdUri="amz-music:bitDepth" value="24"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/02b134c4-8144-3ab1-b125-5af2d0133d5b.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=UHD_96&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="96000" duration="960000">
+                    <Initialization range="0-1067"/>
+                    <SegmentURL mediaRange="1580-3813567"/>
+                    <SegmentURL mediaRange="3813568-7746339"/>
+                    <SegmentURL mediaRange="7746340-11599579"/>
+                    <SegmentURL mediaRange="11599580-15505023"/>
+                    <SegmentURL mediaRange="15505024-19519493"/>
+                    <SegmentURL mediaRange="19519494-23556777"/>
+                    <SegmentURL mediaRange="23556778-27581158"/>
+                    <SegmentURL mediaRange="27581159-31586807"/>
+                    <SegmentURL mediaRange="31586808-35549718"/>
+                    <SegmentURL mediaRange="35549719-39435585"/>
+                    <SegmentURL mediaRange="39435586-43443650"/>
+                    <SegmentURL mediaRange="43443651-47467685"/>
+                    <SegmentURL mediaRange="47467686-51498910"/>
+                    <SegmentURL mediaRange="51498911-55496614"/>
+                    <SegmentURL mediaRange="55496615-59513566"/>
+                    <SegmentURL mediaRange="59513567-63538385"/>
+                    <SegmentURL mediaRange="63538386-67582593"/>
+                    <SegmentURL mediaRange="67582594-71608871"/>
+                    <SegmentURL mediaRange="71608872-75612860"/>
+                    <SegmentURL mediaRange="75612861-79601033"/>
+                    <SegmentURL mediaRange="79601034-83549776"/>
+                    <SegmentURL mediaRange="83549777-87488907"/>
+                    <SegmentURL mediaRange="87488908-91534801"/>
+                    <SegmentURL mediaRange="91534802-95552040"/>
+                    <SegmentURL mediaRange="95552041-99649744"/>
+                    <SegmentURL mediaRange="99649745-103743373"/>
+                    <SegmentURL mediaRange="103743374-107815594"/>
+                    <SegmentURL mediaRange="107815595-111613915"/>
+                    <SegmentURL mediaRange="111613916-115390443"/>
+                    <SegmentURL mediaRange="115390444-119249732"/>
+                    <SegmentURL mediaRange="119249733-123233807"/>
+                    <SegmentURL mediaRange="123233808-127209398"/>
+                    <SegmentURL mediaRange="127209399-131167116"/>
+                    <SegmentURL mediaRange="131167117-135119879"/>
+                    <SegmentURL mediaRange="135119880-139163685"/>
+                    <SegmentURL mediaRange="139163686-143201079"/>
+                    <SegmentURL mediaRange="143201080-147195194"/>
+                    <SegmentURL mediaRange="147195195-151164220"/>
+                    <SegmentURL mediaRange="151164221-155096800"/>
+                    <SegmentURL mediaRange="155096801-157757393"/>
+                </SegmentList>
+            </Representation>
+            <Representation id="4" qualityRanking="1" codecs="flac" audioSamplingRate="192000" bandwidth="5666448" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <SupplementalProperty schemeIdUri="amz-music:bitDepth" value="24"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/edf9f9cb-46ce-33bd-96e1-8456547fbef4.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=UHD_192&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="192000" duration="1920000">
+                    <Initialization range="0-1067"/>
+                    <SegmentURL mediaRange="1580-6720450"/>
+                    <SegmentURL mediaRange="6720451-13610816"/>
+                    <SegmentURL mediaRange="13610817-20415282"/>
+                    <SegmentURL mediaRange="20415283-27272412"/>
+                    <SegmentURL mediaRange="27272413-34250251"/>
+                    <SegmentURL mediaRange="34250252-41260291"/>
+                    <SegmentURL mediaRange="41260292-48255248"/>
+                    <SegmentURL mediaRange="48255249-55224355"/>
+                    <SegmentURL mediaRange="55224356-62157463"/>
+                    <SegmentURL mediaRange="62157464-68996670"/>
+                    <SegmentURL mediaRange="68996671-75970335"/>
+                    <SegmentURL mediaRange="75970336-82964531"/>
+                    <SegmentURL mediaRange="82964532-89965755"/>
+                    <SegmentURL mediaRange="89965756-96928368"/>
+                    <SegmentURL mediaRange="96928369-103911265"/>
+                    <SegmentURL mediaRange="103911266-110903999"/>
+                    <SegmentURL mediaRange="110904000-117921608"/>
+                    <SegmentURL mediaRange="117921609-124920837"/>
+                    <SegmentURL mediaRange="124920838-131897214"/>
+                    <SegmentURL mediaRange="131897215-138848614"/>
+                    <SegmentURL mediaRange="138848615-145764349"/>
+                    <SegmentURL mediaRange="145764350-152655256"/>
+                    <SegmentURL mediaRange="152655257-159680382"/>
+                    <SegmentURL mediaRange="159680383-166667521"/>
+                    <SegmentURL mediaRange="166667522-173750581"/>
+                    <SegmentURL mediaRange="173750582-180827932"/>
+                    <SegmentURL mediaRange="180827933-187877145"/>
+                    <SegmentURL mediaRange="187877146-194626820"/>
+                    <SegmentURL mediaRange="194626821-201345524"/>
+                    <SegmentURL mediaRange="201345525-208145573"/>
+                    <SegmentURL mediaRange="208145574-215088653"/>
+                    <SegmentURL mediaRange="215088654-222022478"/>
+                    <SegmentURL mediaRange="222022479-228934595"/>
+                    <SegmentURL mediaRange="228934596-235844464"/>
+                    <SegmentURL mediaRange="235844465-242852767"/>
+                    <SegmentURL mediaRange="242852768-249863893"/>
+                    <SegmentURL mediaRange="249863894-256824103"/>
+                    <SegmentURL mediaRange="256824104-263749124"/>
+                    <SegmentURL mediaRange="263749125-270634182"/>
+                    <SegmentURL mediaRange="270634183-275673081"/>
+                </SegmentList>
+            </Representation>
+        </AdaptationSet>
+        <AdaptationSet id="2" contentType="audio" selectionPriority="1000">
+            <ContentProtection schemeIdUri="urn:mpeg:dash:mp4protection:2011" cenc:default_KID="f65d52c1-4de5-e5b6-7296-2f48eddf7378" value="cenc"/>
+            <ContentProtection schemeIdUri="urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed">
+                <cenc:pssh>AAAAXXBzc2gAAAAA7e+LqXnWSs6jyCfc1R0h7QAAAD0SEPZdUsFN5eW2cpYvSO3fc3gaC0FtYXpvbk11c2ljIhxjaWQ6OWwxU3dVM2w1Ylp5bGk5STdkOXplQT09</cenc:pssh>
+            </ContentProtection>
+            <SupplementalProperty schemeIdUri="urn:mpeg:mpegB:cicp:ProgramLoudness" value="-13.5 LUFS"/>
+            <SupplementalProperty schemeIdUri="amz-music:trackType" value="SD"/>
+            <SupplementalProperty schemeIdUri="urn:mpeg:dash:adaptation-set-switching:2016" value="1"/>
+            <SupplementalProperty schemeIdUri="urn:mpeg:mpegB:cicp:AnchorLoudness" value="-11.7 LUFS"/>
+            <Representation id="5" qualityRanking="3" codecs="opus" audioSamplingRate="48000" bandwidth="52950" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/7e2d628d-7666-3ad5-a9df-8ba4e1c6391c.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=SD_LOW&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="48000" duration="480000">
+                    <Initialization range="0-1031"/>
+                    <SegmentURL mediaRange="1544-61799"/>
+                    <SegmentURL mediaRange="61800-121935"/>
+                    <SegmentURL mediaRange="121936-182071"/>
+                    <SegmentURL mediaRange="182072-246260"/>
+                    <SegmentURL mediaRange="246261-310449"/>
+                    <SegmentURL mediaRange="310450-374638"/>
+                    <SegmentURL mediaRange="374639-438827"/>
+                    <SegmentURL mediaRange="438828-503016"/>
+                    <SegmentURL mediaRange="503017-567205"/>
+                    <SegmentURL mediaRange="567206-631394"/>
+                    <SegmentURL mediaRange="631395-695583"/>
+                    <SegmentURL mediaRange="695584-759772"/>
+                    <SegmentURL mediaRange="759773-823961"/>
+                    <SegmentURL mediaRange="823962-888150"/>
+                    <SegmentURL mediaRange="888151-952339"/>
+                    <SegmentURL mediaRange="952340-1016528"/>
+                    <SegmentURL mediaRange="1016529-1080717"/>
+                    <SegmentURL mediaRange="1080718-1144906"/>
+                    <SegmentURL mediaRange="1144907-1209095"/>
+                    <SegmentURL mediaRange="1209096-1273284"/>
+                    <SegmentURL mediaRange="1273285-1337473"/>
+                    <SegmentURL mediaRange="1337474-1401662"/>
+                    <SegmentURL mediaRange="1401663-1465851"/>
+                    <SegmentURL mediaRange="1465852-1530040"/>
+                    <SegmentURL mediaRange="1530041-1594229"/>
+                    <SegmentURL mediaRange="1594230-1658418"/>
+                    <SegmentURL mediaRange="1658419-1722607"/>
+                    <SegmentURL mediaRange="1722608-1786796"/>
+                    <SegmentURL mediaRange="1786797-1850985"/>
+                    <SegmentURL mediaRange="1850986-1915174"/>
+                    <SegmentURL mediaRange="1915175-1979363"/>
+                    <SegmentURL mediaRange="1979364-2043552"/>
+                    <SegmentURL mediaRange="2043553-2107741"/>
+                    <SegmentURL mediaRange="2107742-2171930"/>
+                    <SegmentURL mediaRange="2171931-2236119"/>
+                    <SegmentURL mediaRange="2236120-2300308"/>
+                    <SegmentURL mediaRange="2300309-2364497"/>
+                    <SegmentURL mediaRange="2364498-2428686"/>
+                    <SegmentURL mediaRange="2428687-2492875"/>
+                    <SegmentURL mediaRange="2492876-2559060"/>
+                </SegmentList>
+            </Representation>
+            <Representation id="6" qualityRanking="2" codecs="opus" audioSamplingRate="48000" bandwidth="196953" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/8e453bd1-9428-30fa-940f-fa85911368c2.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=SD_MEDIUM&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="48000" duration="480000">
+                    <Initialization range="0-1031"/>
+                    <SegmentURL mediaRange="1544-242159"/>
+                    <SegmentURL mediaRange="242160-482295"/>
+                    <SegmentURL mediaRange="482296-722431"/>
+                    <SegmentURL mediaRange="722432-966620"/>
+                    <SegmentURL mediaRange="966621-1210809"/>
+                    <SegmentURL mediaRange="1210810-1454998"/>
+                    <SegmentURL mediaRange="1454999-1699187"/>
+                    <SegmentURL mediaRange="1699188-1943376"/>
+                    <SegmentURL mediaRange="1943377-2187565"/>
+                    <SegmentURL mediaRange="2187566-2431754"/>
+                    <SegmentURL mediaRange="2431755-2675943"/>
+                    <SegmentURL mediaRange="2675944-2920132"/>
+                    <SegmentURL mediaRange="2920133-3164321"/>
+                    <SegmentURL mediaRange="3164322-3408510"/>
+                    <SegmentURL mediaRange="3408511-3652699"/>
+                    <SegmentURL mediaRange="3652700-3896888"/>
+                    <SegmentURL mediaRange="3896889-4141077"/>
+                    <SegmentURL mediaRange="4141078-4385266"/>
+                    <SegmentURL mediaRange="4385267-4629455"/>
+                    <SegmentURL mediaRange="4629456-4873644"/>
+                    <SegmentURL mediaRange="4873645-5117833"/>
+                    <SegmentURL mediaRange="5117834-5362022"/>
+                    <SegmentURL mediaRange="5362023-5606211"/>
+                    <SegmentURL mediaRange="5606212-5850400"/>
+                    <SegmentURL mediaRange="5850401-6094589"/>
+                    <SegmentURL mediaRange="6094590-6338778"/>
+                    <SegmentURL mediaRange="6338779-6582967"/>
+                    <SegmentURL mediaRange="6582968-6827156"/>
+                    <SegmentURL mediaRange="6827157-7071345"/>
+                    <SegmentURL mediaRange="7071346-7315534"/>
+                    <SegmentURL mediaRange="7315535-7559723"/>
+                    <SegmentURL mediaRange="7559724-7803912"/>
+                    <SegmentURL mediaRange="7803913-8048101"/>
+                    <SegmentURL mediaRange="8048102-8292290"/>
+                    <SegmentURL mediaRange="8292291-8536479"/>
+                    <SegmentURL mediaRange="8536480-8780668"/>
+                    <SegmentURL mediaRange="8780669-9024857"/>
+                    <SegmentURL mediaRange="9024858-9269046"/>
+                    <SegmentURL mediaRange="9269047-9513235"/>
+                    <SegmentURL mediaRange="9513236-9759420"/>
+                </SegmentList>
+            </Representation>
+            <Representation id="7" qualityRanking="1" codecs="opus" audioSamplingRate="48000" bandwidth="324955" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/40ba3a06-d285-3130-838f-0c1508c1d18b.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=SD_HIGH&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="48000" duration="480000">
+                    <Initialization range="0-1031"/>
+                    <SegmentURL mediaRange="1544-402479"/>
+                    <SegmentURL mediaRange="402480-802615"/>
+                    <SegmentURL mediaRange="802616-1202751"/>
+                    <SegmentURL mediaRange="1202752-1606940"/>
+                    <SegmentURL mediaRange="1606941-2011129"/>
+                    <SegmentURL mediaRange="2011130-2415318"/>
+                    <SegmentURL mediaRange="2415319-2819507"/>
+                    <SegmentURL mediaRange="2819508-3223696"/>
+                    <SegmentURL mediaRange="3223697-3627885"/>
+                    <SegmentURL mediaRange="3627886-4032074"/>
+                    <SegmentURL mediaRange="4032075-4436263"/>
+                    <SegmentURL mediaRange="4436264-4840452"/>
+                    <SegmentURL mediaRange="4840453-5244641"/>
+                    <SegmentURL mediaRange="5244642-5648830"/>
+                    <SegmentURL mediaRange="5648831-6053019"/>
+                    <SegmentURL mediaRange="6053020-6457208"/>
+                    <SegmentURL mediaRange="6457209-6861397"/>
+                    <SegmentURL mediaRange="6861398-7265586"/>
+                    <SegmentURL mediaRange="7265587-7669775"/>
+                    <SegmentURL mediaRange="7669776-8073964"/>
+                    <SegmentURL mediaRange="8073965-8478153"/>
+                    <SegmentURL mediaRange="8478154-8882342"/>
+                    <SegmentURL mediaRange="8882343-9286531"/>
+                    <SegmentURL mediaRange="9286532-9690720"/>
+                    <SegmentURL mediaRange="9690721-10094909"/>
+                    <SegmentURL mediaRange="10094910-10499098"/>
+                    <SegmentURL mediaRange="10499099-10903287"/>
+                    <SegmentURL mediaRange="10903288-11307476"/>
+                    <SegmentURL mediaRange="11307477-11711665"/>
+                    <SegmentURL mediaRange="11711666-12115854"/>
+                    <SegmentURL mediaRange="12115855-12520043"/>
+                    <SegmentURL mediaRange="12520044-12924232"/>
+                    <SegmentURL mediaRange="12924233-13328421"/>
+                    <SegmentURL mediaRange="13328422-13732610"/>
+                    <SegmentURL mediaRange="13732611-14136799"/>
+                    <SegmentURL mediaRange="14136800-14540988"/>
+                    <SegmentURL mediaRange="14540989-14945177"/>
+                    <SegmentURL mediaRange="14945178-15349366"/>
+                    <SegmentURL mediaRange="15349367-15753555"/>
+                    <SegmentURL mediaRange="15753556-16159740"/>
+                </SegmentList>
+            </Representation>
+        </AdaptationSet>
+        <AdaptationSet id="3" contentType="audio" selectionPriority="500">
+            <ContentProtection schemeIdUri="urn:mpeg:dash:mp4protection:2011" cenc:default_KID="4e4c6e3a-d760-ffd5-78b0-3824890da09d" value="cenc"/>
+            <ContentProtection schemeIdUri="urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed">
+                <cenc:pssh>AAAAXXBzc2gAAAAA7e+LqXnWSs6jyCfc1R0h7QAAAD0SEE5MbjrXYP/VeLA4JIkNoJ0aC0FtYXpvbk11c2ljIhxjaWQ6VGt4dU90ZGcvOVY0c0Rna2lRMmduUT09</cenc:pssh>
+            </ContentProtection>
+            <SupplementalProperty schemeIdUri="urn:mpeg:mpegB:cicp:ProgramLoudness" value="-13.5 LUFS"/>
+            <SupplementalProperty schemeIdUri="amz-music:trackType" value="LD"/>
+            <SupplementalProperty schemeIdUri="urn:mpeg:mpegB:cicp:AnchorLoudness" value="-11.7 LUFS"/>
+            <Representation id="8" qualityRanking="2000" codecs="opus" audioSamplingRate="48000" bandwidth="52950" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/748096ab-6991-368b-b9ca-5477bf90ba5a.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=LD_LOW&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="48000" duration="480000">
+                    <Initialization range="0-1031"/>
+                    <SegmentURL mediaRange="1544-61799"/>
+                    <SegmentURL mediaRange="61800-121935"/>
+                    <SegmentURL mediaRange="121936-182071"/>
+                    <SegmentURL mediaRange="182072-246260"/>
+                    <SegmentURL mediaRange="246261-310449"/>
+                    <SegmentURL mediaRange="310450-374638"/>
+                    <SegmentURL mediaRange="374639-438827"/>
+                    <SegmentURL mediaRange="438828-503016"/>
+                    <SegmentURL mediaRange="503017-567205"/>
+                    <SegmentURL mediaRange="567206-631394"/>
+                    <SegmentURL mediaRange="631395-695583"/>
+                    <SegmentURL mediaRange="695584-759772"/>
+                    <SegmentURL mediaRange="759773-823961"/>
+                    <SegmentURL mediaRange="823962-888150"/>
+                    <SegmentURL mediaRange="888151-952339"/>
+                    <SegmentURL mediaRange="952340-1016528"/>
+                    <SegmentURL mediaRange="1016529-1080717"/>
+                    <SegmentURL mediaRange="1080718-1144906"/>
+                    <SegmentURL mediaRange="1144907-1209095"/>
+                    <SegmentURL mediaRange="1209096-1273284"/>
+                    <SegmentURL mediaRange="1273285-1337473"/>
+                    <SegmentURL mediaRange="1337474-1401662"/>
+                    <SegmentURL mediaRange="1401663-1465851"/>
+                    <SegmentURL mediaRange="1465852-1530040"/>
+                    <SegmentURL mediaRange="1530041-1594229"/>
+                    <SegmentURL mediaRange="1594230-1658418"/>
+                    <SegmentURL mediaRange="1658419-1722607"/>
+                    <SegmentURL mediaRange="1722608-1786796"/>
+                    <SegmentURL mediaRange="1786797-1850985"/>
+                    <SegmentURL mediaRange="1850986-1915174"/>
+                    <SegmentURL mediaRange="1915175-1979363"/>
+                    <SegmentURL mediaRange="1979364-2043552"/>
+                    <SegmentURL mediaRange="2043553-2107741"/>
+                    <SegmentURL mediaRange="2107742-2171930"/>
+                    <SegmentURL mediaRange="2171931-2236119"/>
+                    <SegmentURL mediaRange="2236120-2300308"/>
+                    <SegmentURL mediaRange="2300309-2364497"/>
+                    <SegmentURL mediaRange="2364498-2428686"/>
+                    <SegmentURL mediaRange="2428687-2492875"/>
+                    <SegmentURL mediaRange="2492876-2559060"/>
+                </SegmentList>
+            </Representation>
+            <Representation id="9" qualityRanking="1000" codecs="opus" audioSamplingRate="48000" bandwidth="164952" mimeType="audio/mp4">
+                <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+                <BaseURL>https://d17vo8z6jop21h.cloudfront.net/94bd1ece-d200000391583662/8be307d6-71ea-3111-a869-40720e08a6f9.mp4?r=2e86bfd7-93aa-48a0-9d32-7bee6d2897a4&amp;rs=NA&amp;mt=US&amp;ql=LD_MEDIUM&amp;dtype=A16ZV8BU3SN1N3</BaseURL>
+                <SegmentList timescale="48000" duration="480000">
+                    <Initialization range="0-1031"/>
+                    <SegmentURL mediaRange="1544-202079"/>
+                    <SegmentURL mediaRange="202080-402215"/>
+                    <SegmentURL mediaRange="402216-602351"/>
+                    <SegmentURL mediaRange="602352-806540"/>
+                    <SegmentURL mediaRange="806541-1010729"/>
+                    <SegmentURL mediaRange="1010730-1214918"/>
+                    <SegmentURL mediaRange="1214919-1419107"/>
+                    <SegmentURL mediaRange="1419108-1623296"/>
+                    <SegmentURL mediaRange="1623297-1827485"/>
+                    <SegmentURL mediaRange="1827486-2031674"/>
+                    <SegmentURL mediaRange="2031675-2235863"/>
+                    <SegmentURL mediaRange="2235864-2440052"/>
+                    <SegmentURL mediaRange="2440053-2644241"/>
+                    <SegmentURL mediaRange="2644242-2848430"/>
+                    <SegmentURL mediaRange="2848431-3052619"/>
+                    <SegmentURL mediaRange="3052620-3256808"/>
+                    <SegmentURL mediaRange="3256809-3460997"/>
+                    <SegmentURL mediaRange="3460998-3665186"/>
+                    <SegmentURL mediaRange="3665187-3869375"/>
+                    <SegmentURL mediaRange="3869376-4073564"/>
+                    <SegmentURL mediaRange="4073565-4277753"/>
+                    <SegmentURL mediaRange="4277754-4481942"/>
+                    <SegmentURL mediaRange="4481943-4686131"/>
+                    <SegmentURL mediaRange="4686132-4890320"/>
+                    <SegmentURL mediaRange="4890321-5094509"/>
+                    <SegmentURL mediaRange="5094510-5298698"/>
+                    <SegmentURL mediaRange="5298699-5502887"/>
+                    <SegmentURL mediaRange="5502888-5707076"/>
+                    <SegmentURL mediaRange="5707077-5911265"/>
+                    <SegmentURL mediaRange="5911266-6115454"/>
+                    <SegmentURL mediaRange="6115455-6319643"/>
+                    <SegmentURL mediaRange="6319644-6523832"/>
+                    <SegmentURL mediaRange="6523833-6728021"/>
+                    <SegmentURL mediaRange="6728022-6932210"/>
+                    <SegmentURL mediaRange="6932211-7136399"/>
+                    <SegmentURL mediaRange="7136400-7340588"/>
+                    <SegmentURL mediaRange="7340589-7544777"/>
+                    <SegmentURL mediaRange="7544778-7748966"/>
+                    <SegmentURL mediaRange="7748967-7953155"/>
+                    <SegmentURL mediaRange="7953156-8159340"/>
+                </SegmentList>
+            </Representation>
+        </AdaptationSet>
+    </Period>
+</MPD>`;
+
+  // test/benchmark/manifest/dash/parseDashManifest.bench.ts
+  describe("parseDashManifest", () => {
+    setupBenchmark();
+    it("Parse Dash", async () => {
+      addBenchmarks(
+        "Parse Dash - isoff on demand",
+        await benchmark(
+          "SAX",
+          () => parseDashManifest(dash_segmentListMediaRange)
+        )
+      );
+    });
+  });
+})();
+//# sourceMappingURL=benchmark.js.map