@amazon/vinyl-util 1.2.0 → 2.0.4

package/dist/test/benchmark.js

@@ -30,475 +30,452 @@
   };
   var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-  // test/browserTestUtil/mock/createSpyFactory.ts
-  var createSpy = jasmine.createSpy;
-  function createSpy2(key) {
-    return createSpy(String(key));
-  }
+  // src/error/ErrorOrigin.ts
+  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"
+  };
 
-  // test/browserTestUtil/mock/dom/lib.dom.ts
-  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"));
+  // src/error/ReportableError.ts
+  var ReportableError = class _ReportableError extends Error {
+    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal" /* FATAL */) {
+      super(message);
+      __publicField(this, "origin", origin);
+      __publicField(this, "level", level);
+      Object.setPrototypeOf(this, _ReportableError.prototype);
     }
-  };
-  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"));
+    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
+      };
     }
   };
 
-  // test/browserTestUtil/mock/dom/globals.ts
-  var MockMediaSourceGlobal = class extends MockMediaSource {
-  };
-  __publicField(MockMediaSourceGlobal, "canConstructInDedicatedWorker", false);
-  __publicField(MockMediaSourceGlobal, "isTypeSupported", createSpy2(
-    "isTypeSupported"
-  ));
-  var MockAbortSignalGlobal = class extends MockAbortSignal {
+  // src/error/IllegalArgumentError.ts
+  var IllegalArgumentError = class _IllegalArgumentError extends ReportableError {
+    constructor(message, isInternal = true) {
+      super(message, isInternal ? ErrorOrigin.INTERNAL : ErrorOrigin.API);
+      __publicField(this, "isInternal", isInternal);
+      Object.setPrototypeOf(this, _IllegalArgumentError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "IllegalArgumentError";
+    }
   };
-  __publicField(MockAbortSignalGlobal, "abort", createSpy2("abort"));
-  __publicField(MockAbortSignalGlobal, "any", createSpy2("any"));
-  __publicField(MockAbortSignalGlobal, "timeout", createSpy2("timeout"));
-
-  // test/browserTestUtil/expect/expectNothing.ts
-  function expectNothing() {
-    expect(true).toBeTruthy();
-  }
-
-  // test/browserTestUtil/env/jasmineEnv.ts
-  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;
-    });
-  }
 
-  // test/browserTestUtil/benchmark/Benchmark.ts
-  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) {
-      __publicField(this, "name", name);
-      __publicField(this, "cycleResults", []);
-      __publicField(this, "_totalSamples", 0);
-    }
-    get totalSamples() {
-      return this._totalSamples;
+  // src/util/collection/LinkedList.ts
+  var LinkedList = class {
+    constructor() {
+      __publicField(this, "_head", null);
+      __publicField(this, "_tail", null);
     }
-    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 current head.
+     */
+    get head() {
+      return this._head;
     }
     /**
-     * Returns the mean ops per second minus outliers of greater than 3 standard deviations.
+     * Returns the current tail.
      */
-    get meanOpsPerSec() {
-      return average(this.cycleResultsNoOutliers);
+    get tail() {
+      return this._tail;
     }
-    get standardDeviation() {
-      return standardDeviation(this.cycleResults);
+    /**
+     * Returns true if the list is empty.
+     */
+    get empty() {
+      return this._head === null;
     }
-    get variance() {
-      return this.standardDeviation / this.meanOpsPerSec;
+    /**
+     * 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;
     }
     /**
-     * Returns the mean ops / s ± variance % as a string.
+     * Appends all given values to the end of this list.
+     *
+     * @param values
      */
-    get meanOpsStr() {
-      const mean = this.meanOpsPerSec.toLocaleString(void 0, {
-        maximumSignificantDigits: 4
-      });
-      const variance = this.variance.toLocaleString(void 0, {
-        style: "percent"
-      });
-      return `${mean} \xB1${variance}`;
+    pushAll(...values) {
+      for (const value of values) {
+        this.push(value);
+      }
     }
-    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;
+    /**
+     * 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;
     }
-    toString() {
-      if (!this.cycleResults.length) return "No results";
-      return `${this.name}: ${this.meanOpsStr} ops/sec`;
-    }
-  };
-  var RunResultsComparison = class {
-    constructor(name, results) {
-      __publicField(this, "name", name);
-      /**
-       * Sorted by median ops/s from slowest to fastest.
-       */
-      __publicField(this, "results");
-      this.results = results.sort((a, b) => {
-        return a.meanOpsPerSec - b.meanOpsPerSec;
-      });
+    /**
+     * 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;
     }
-    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, _a) => {
-        var _b = _a, { Name } = _b, x = __objRest(_b, ["Name"]);
-        acc[Name] = x;
-        return acc;
-      }, {});
-      console.log("\n" + this.name);
-      console.table(table);
+    /**
+     * 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;
     }
-    runComparisonToString(run) {
-      var _a, _b;
-      const baseline = (_b = (_a = this.results[0]) == null ? void 0 : _a.meanOpsPerSec) != null ? _b : 0;
-      const fasterPercent = run.meanOpsPerSec / baseline - 1;
-      return fasterPercent < 0.01 ? "-" : fasterPercent.toLocaleString(void 0, {
-        style: "percent"
-      }) + " faster";
+    /**
+     * 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]);
+      }
     }
-  };
-  function compareResults(name, ...results) {
-    return new RunResultsComparison(name, results);
-  }
-  var defaultBenchmarkOptions = {
-    warmupTime: 0.5,
-    maxCycleDuration: 0.5,
-    cycles: 9
-  };
-  var _Benchmark = class _Benchmark {
     /**
-     * Constructs a new Benchmark.
+     * 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 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.
+     * @param node The node to add or move to the head of this list.
      */
-    constructor(name, executor, options) {
-      __publicField(this, "name", name);
-      __publicField(this, "executor", executor);
-      __publicField(this, "options");
-      this.options = __spreadValues(__spreadValues({}, defaultBenchmarkOptions), options);
+    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;
     }
-    async run() {
-      const opts = this.options;
-      await _Benchmark.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;
-      })();
-      _Benchmark.semaphore = resultsPromise;
-      return await resultsPromise;
+    /**
+     * 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;
     }
     /**
-     * Runs one cycle. A cycle will repeat the executor approximately `options.maxCycleDuration`
-     * seconds.
+     * Removes the given linked node.
      *
-     * @param isAsync
-     * @return Returns the duration (in seconds) and number of operations the cycle repeated.
+     * @param node
      */
-    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;
-  }
-
-  // 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 _a;
-        console.log("Tests complete");
-        const jasmineContainer = document.getElementsByClassName(
-          "jasmine_html-reporter"
-        )[0];
-        (_a = jasmineContainer.parentElement) == null ? void 0 : _a.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 element = document.createElement(tagName, options);
-    if (parent) parent.appendChild(element);
-    return element;
-  }
-
-  // src/util/type.ts
-  function covariant() {
-    return void 0;
-  }
-
-  // src/util/url/resolveUrl.ts
-  function resolveUrl(relative, base) {
-    if (relative.indexOf("://") > 0) return relative;
-    if (relative.startsWith("//")) {
-      const schemeEnd2 = base.indexOf("://");
-      return base.substring(0, schemeEnd2 + 1) + relative;
+    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;
     }
-    const schemeEnd = base.indexOf("://") + 3;
-    const pathStart = base.indexOf("/", schemeEnd);
-    const origin = pathStart === -1 ? base : base.substring(0, pathStart);
-    if (relative.startsWith("/")) return origin + relative;
-    if (relative === "") return base;
-    const basePath = pathStart === -1 ? "/" : base.substring(pathStart);
-    const lastSlash = basePath.lastIndexOf("/");
-    const dir = basePath.substring(0, lastSlash + 1);
-    return origin + resolveDots(dir + relative);
-  }
-  function resolveDots(path) {
-    if (path.indexOf(".") === -1) return path;
-    const parts = path.split("/");
-    const out = [];
-    for (let i = 0; i < parts.length; i++) {
-      const p = parts[i];
-      if (p === "..") {
-        if (out.length > 1) out.pop();
-      } else if (p !== ".") {
-        out.push(p);
+    /**
+     * 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;
     }
-    return out.join("/");
-  }
-
-  // src/error/ErrorOrigin.ts
-  var ErrorOrigin = {
     /**
-     * The error originated from Vinyl and was reported from the uncaught exception or promise
-     * rejection handlers.
+     * 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.
      */
-    UNCAUGHT: "uncaught",
+    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;
+    }
     /**
-     * The error originated from Vinyl and was caught.
+     * Iterates over every element, invoking the given callback.
+     *
+     * @param callback
      */
-    INTERNAL: "internal",
+    forEach(callback) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed) callback(current.value);
+        current = current.next;
+      }
+    }
     /**
-     * A Vinyl interface was used incorrectly by a consumer.
+     * Similar to `Array.prototype.some`, returns true if at least one element passes the given
+     * predicate.
+     *
+     * @param predicate
      */
-    API: "api",
+    some(predicate) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return true;
+        current = current.next;
+      }
+      return false;
+    }
     /**
-     * The error originated from a failed service call (500 errors).
+     * Returns the first node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
      */
-    SERVICE_EXTERNAL: "serviceExternal",
+    find(predicate) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return current;
+        current = current.next;
+      }
+      return null;
+    }
     /**
-     * The error originated from a failed service call (400 errors).
+     * Returns the last node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
      */
-    SERVICE_INTERNAL: "serviceInternal",
+    findLast(predicate) {
+      let current = this._tail;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return current;
+        current = current.previous;
+      }
+      return null;
+    }
     /**
-     * The error originated from a problem playing provided media.
-     * The reporter is from a component such as the element, source buffer, media source, etc.
+     * Clears this list.
      */
-    MEDIA: "media",
+    clear() {
+      let current = this._head;
+      while (current != null) {
+        const next = current.next;
+        current.removed = true;
+        current = next;
+      }
+      this._head = null;
+      this._tail = null;
+    }
     /**
-     * The error originated from a problem parsing input data.
-     * Such as a malformed Dash or HLS manifest.
+     * Returns a new iterator, starting at the head.
      */
-    PARSING: "parsing",
+    [Symbol.iterator]() {
+      return this.createIterator(this._head, null, (node) => node.next);
+    }
     /**
-     * The error originated from an incompatibility with browser APIs,
-     * such as EME.
+     * Returns a new reversed iterable where the iterator starts at the tail, moving backwards
+     * to the head.
      */
-    COMPATIBILITY: "compatibility",
+    reversed() {
+      return this.createIterator(this._tail, null, (node) => node.previous);
+    }
     /**
-     * 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.
+     * 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.
      */
-    DRM: "drm"
+    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;
+        }
+      };
+    }
   };
 
-  // src/error/ReportableError.ts
-  var ReportableError = class _ReportableError extends Error {
-    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal" /* FATAL */) {
-      super(message);
-      __publicField(this, "origin", origin);
-      __publicField(this, "level", level);
-      Object.setPrototypeOf(this, _ReportableError.prototype);
+  // src/event/Signal.ts
+  var SignalImpl = class {
+    constructor() {
+      __publicField(this, "handlers", new LinkedList());
     }
-    get [Symbol.toStringTag]() {
-      return "ReportableError";
+    get empty() {
+      return this.handlers.empty;
     }
-    get name() {
-      return this[Symbol.toStringTag];
+    listen(handler, options) {
+      const remove2 = () => this.handlers.remove(node);
+      const node = this.handlers.push(
+        (options == null ? void 0 : options.once) ? (event) => {
+          remove2();
+          handler(event);
+        } : handler
+      );
+      return remove2;
     }
     /**
-     * All ReportableError instances must be serializable.
+     * Invokes all handlers, providing the given event.
+     *
+     * Handlers may add/remove callbacks or do a nested dispatch.
+     *
+     * If a handler is added within a handler, the new handler will not be invoked until the
+     * next dispatch.
+     *
+     * @param event
      */
-    toJSON() {
-      return {
-        level: this.level,
-        message: this.message,
-        name: this.name,
-        origin: this.origin,
-        stack: this.stack
-      };
+    dispatch(event) {
+      const handlers = this.handlers;
+      const tail = handlers.tail;
+      handlers.some((handler) => {
+        handler(event);
+        return handler === tail.value;
+      });
     }
-  };
-
-  // src/error/IllegalArgumentError.ts
-  var IllegalArgumentError = class _IllegalArgumentError extends ReportableError {
-    constructor(message, isInternal = true) {
-      super(message, isInternal ? ErrorOrigin.INTERNAL : ErrorOrigin.API);
-      __publicField(this, "isInternal", isInternal);
-      Object.setPrototypeOf(this, _IllegalArgumentError.prototype);
+    /**
+     * Removes all handlers.
+     */
+    clear() {
+      this.handlers.clear();
     }
-    get [Symbol.toStringTag]() {
-      return "IllegalArgumentError";
+    /**
+     * Same as clear.
+     */
+    dispose() {
+      this.clear();
     }
   };
+  function signal() {
+    return new SignalImpl();
+  }
 
   // src/util/map/map.ts
   function getOrSet(map, key, defaultValue) {
@@ -518,510 +495,641 @@
     return result;
   }
 
-  // src/util/string/string.ts
-  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]);
-    });
+  // src/util/type.ts
+  function covariant() {
+    return void 0;
   }
-  var predefinedDecodeEntities = /* @__PURE__ */ new Map([
-    ["apos", "'"],
-    ["amp", "&"],
-    ["lt", "<"],
-    ["gt", ">"],
-    ["quot", '"']
-  ]);
-  var standardEntityValueToNames = flipMap(predefinedDecodeEntities);
 
-  // src/util/set/set.ts
-  function union(a, b) {
-    return /* @__PURE__ */ new Set([...a, ...b]);
+  // src/logging/LogTarget.ts
+  var counter = 0;
+  function createLogPrefix(target) {
+    const name = typeof target === "string" ? target : target[Symbol.toStringTag];
+    return `${name}/${++counter}`;
   }
 
-  // src/util/object/object.ts
-  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))
+  // src/event/EventHost.ts
+  var EventHostImpl = class {
+    constructor() {
+      __publicField(this, "logPrefix", createLogPrefix(this));
+      __publicField(this, "signals", /* @__PURE__ */ new Map());
+      __publicField(this, "__eventMapType", covariant());
+    }
+    get [Symbol.toStringTag]() {
+      return "EventHostImpl";
+    }
+    hasAnyListeners() {
+      for (const value of this.signals.values()) {
+        if (!value.empty) return true;
+      }
       return false;
-    const proto = Object.getPrototypeOf(value);
-    return !proto || !Object.getPrototypeOf(proto);
-  }
-
-  // src/util/serialization/json.ts
-  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();
     }
+    hasListeners(type) {
+      var _a;
+      return ((_a = this.signals.get(type)) == null ? void 0 : _a.empty) === false;
+    }
+    on(type, handler, options) {
+      const sig = getOrSet(this.signals, type, () => signal());
+      return sig.listen(handler, options);
+    }
+    dispatch(type, event) {
+      var _a;
+      (_a = this.signals.get(type)) == null ? void 0 : _a.dispatch(event);
+    }
+    dispose() {
+      for (const signal2 of this.signals.values()) signal2.dispose();
+      this.signals.clear();
+    }
+  };
+
+  // src/util/collection/array.ts
+  function remove(array, element) {
+    const index = array.indexOf(element);
+    if (index === -1) return false;
+    array.splice(index, 1);
+    return true;
   }
-  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) {
+
+  // src/util/iteration/iterable.ts
+  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 {
-          name: value.name,
-          message: value.message,
-          stack: value.stack
+          value: transform(result.value),
+          done: false
         };
-      } else {
-        return value.toString();
+      }
+    };
+  }
+
+  // src/error/IllegalStateError.ts
+  var IllegalStateError = class _IllegalStateError extends ReportableError {
+    get [Symbol.toStringTag]() {
+      return "IllegalStateError";
+    }
+    constructor(message) {
+      super(message);
+      Object.setPrototypeOf(this, _IllegalStateError.prototype);
+    }
+  };
+
+  // src/util/collection/LruCache.ts
+  var LruCache = class {
+    constructor(initialCapacity) {
+      /**
+       * A map of the list nodes.
+       *
+       * @private
+       */
+      __publicField(this, "cache", /* @__PURE__ */ new Map());
+      /**
+       * Most recently used elements are at the tail, least recently used are at the head.
+       * @private
+       */
+      __publicField(this, "list", new LinkedList());
+      /**
+       * An element is about to be removed. Should return true if the element may be evicted,
+       * otherwise false.
+       * If false is returned for all elements, an IllegalStateError is thrown.
+       */
+      __publicField(this, "onEvicting", null);
+      /**
+       * When an element is added when at capacity, the least recently used element will be removed.
+       * This callback can be set to be notified with the element being evicted, which may be used
+       * for disposal.
+       */
+      __publicField(this, "onEvict", null);
+      __publicField(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();
       }
     }
-  }
-
-  // src/util/collection/LinkedList.ts
-  var LinkedList = class {
-    constructor() {
-      __publicField(this, "_head", null);
-      __publicField(this, "_tail", null);
+    /**
+     * @returns the number of elements in the Map.
+     */
+    get size() {
+      return this.cache.size;
     }
     /**
-     * Returns the current head.
+     * @returns boolean indicating whether an element with the specified key exists or not.
      */
-    get head() {
-      return this._head;
+    has(key) {
+      return this.cache.has(key);
     }
     /**
-     * Returns the current tail.
+     * 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 tail() {
-      return this._tail;
+    get(key) {
+      const node = this.cache.get(key);
+      if (!node) return void 0;
+      this.list.pushNode(node);
+      return node.value[1];
     }
     /**
-     * Returns true if the list is empty.
+     * 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.
      */
-    get empty() {
-      return this._head === null;
+    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 _a, _b, _c;
+      let node = this.list.head;
+      while (node) {
+        const [key2, value2] = node.value;
+        const allowed = (_b = (_a = this.onEvicting) == null ? void 0 : _a.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);
     }
     /**
-     * Creates a new node for the given value, adding it to the end of the list.
-     *
-     * @param value
-     * @return Returns the newly created node.
+     * Clears all elements from the cache.
      */
-    push(value) {
-      const node = {
-        previous: this._tail,
-        value,
-        removed: false,
-        next: null
-      };
-      this.pushNode(node);
-      return node;
+    clear() {
+      this.list.clear();
+      this.cache.clear();
     }
     /**
-     * Appends all given values to the end of this list.
-     *
-     * @param values
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
      */
-    pushAll(...values) {
-      for (const value of values) {
-        this.push(value);
-      }
+    delete(key) {
+      if (!this.has(key)) return false;
+      const node = this.cache.get(key);
+      this.cache.delete(key);
+      this.list.remove(node);
+      return true;
     }
     /**
-     * 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.
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
      *
-     * @param node The node to add or move to the tail of this list.
+     * @param callback A callback to invoke for every element in the cache.
+     * @param thisArg Value to use as this when executing callback
      */
-    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;
+    forEach(callback, thisArg) {
+      return this.list.forEach((entry) => {
+        callback.call(thisArg, entry[1], entry[0], this);
+      });
     }
     /**
-     * Removes the last node (the tail), returning it.
-     * If this list is empty, null is returned.
+     * Returns an iterable of key, value pairs for every entry in the map.
      */
-    pop() {
-      const node = this._tail;
-      if (!node) return null;
-      this.remove(node);
-      return node;
+    entries() {
+      return this[Symbol.iterator]();
     }
     /**
-     * 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.
+     * Returns an iterable of keys in the map. This will be ordered from least recently used to
+     * most.
      */
-    unshift(value) {
-      const node = {
-        previous: null,
-        value,
-        removed: true,
-        next: this._head
-      };
-      this.unshiftNode(node);
-      return node;
+    keys() {
+      return mapIter(this.list, ([key]) => key);
     }
     /**
-     * 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.
+     * Returns an iterable of values in the map. This will be ordered from least recently used to
+     * most.
      */
-    unshiftAll(...values) {
-      for (let i = values.length - 1; i >= 0; i--) {
-        this.unshift(values[i]);
+    values() {
+      return mapIter(this.list, ([, value]) => value);
+    }
+    [Symbol.iterator]() {
+      return this.list[Symbol.iterator]();
+    }
+    get [Symbol.toStringTag]() {
+      return "LruCache";
+    }
+  };
+
+  // src/util/fun/memoize.ts
+  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();
+          }
+        }
+      );
+    }
+  }
+
+  // src/util/string/string.ts
+  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]);
+    });
+  }
+  var predefinedDecodeEntities = /* @__PURE__ */ new Map([
+    ["apos", "'"],
+    ["amp", "&"],
+    ["lt", "<"],
+    ["gt", ">"],
+    ["quot", '"']
+  ]);
+  var standardEntityValueToNames = flipMap(predefinedDecodeEntities);
+
+  // src/core/disposable.ts
+  function isDisposable(value) {
+    return value != null && typeof value.dispose === "function" && value.dispose.length === 0;
+  }
+
+  // src/global/globalRegistry.ts
+  var GlobalRegistry = class {
+    constructor() {
+      __publicField(this, "registry", []);
     }
     /**
-     * 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.
+     * Returns the number of references currently in the registry.
      */
-    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;
+    get size() {
+      return this.registry.length;
     }
     /**
-     * Removes the first node (the head), returning it.
-     * - If this list is empty, null is returned.
+     * Registers an initializer that will be invoked during global state initialization.
+     * @param initializer
      */
-    shift() {
-      const node = this._head;
-      if (!node) return null;
-      this.remove(node);
-      return node;
+    register(initializer) {
+      this.registry.push(initializer);
+      return initializer;
     }
     /**
-     * Removes the given linked node.
-     *
-     * @param node
+     * Removes a global ref from the registry.
+     * May be called at any time.
+     * @param ref
+     * @return Returns true if the global ref was removed.
      */
-    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;
+    unregister(ref) {
+      return remove(this.registry, ref);
     }
     /**
-     * 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.
+     * Resets all registered initializers and sets this registry back to its pre-initialized state.
+     * This is typically only done within unit tests, but may be called if all players are
+     * disposed and the consumer intends to teardown global state.
      */
-    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;
+    reset() {
+      for (const registryElement of this.registry) {
+        registryElement.reset();
       }
-      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;
+  };
+  var _registry = null;
+  function getGlobalRegistry() {
+    if (!_registry) _registry = new GlobalRegistry();
+    return _registry;
+  }
+  var globalRefDebug = false;
+  var GlobalRefImpl = class {
+    constructor(defaultInitializer) {
+      __publicField(this, "defaultInitializer", defaultInitializer);
+      __publicField(this, "_value");
+      __publicField(this, "_initialized", false);
+      __publicField(this, "constructing", false);
+      __publicField(this, "initializer");
+      __publicField(this, "lastInitStack", null);
+      this.initializer = defaultInitializer;
     }
-    /**
-     * 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;
-      }
+    get initialized() {
+      return this._initialized;
     }
-    /**
-     * 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;
+    get value() {
+      this.initialize();
+      return this._value;
     }
-    /**
-     * 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;
+    reset() {
+      this.initializer = this.defaultInitializer;
+      if (!this._initialized) return;
+      this.assertNotConstructing();
+      this._initialized = false;
+      this.lastInitStack = null;
+      if (isDisposable(this._value)) {
+        this._value.dispose();
       }
-      return null;
+      this._value = void 0;
     }
-    /**
-     * 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;
+    initialize() {
+      if (this._initialized) return;
+      this.assertNotConstructing();
+      this.constructing = true;
+      try {
+        this._value = this.initializer();
+      } catch (error) {
+        this.constructing = false;
+        throw error;
       }
-      return null;
-    }
-    /**
-     * Clears this list.
-     */
-    clear() {
-      let current = this._head;
-      while (current != null) {
-        const next = current.next;
-        current.removed = true;
-        current = next;
+      this.constructing = false;
+      this._initialized = true;
+      if (globalRefDebug) {
+        this.lastInitStack = new Error("globalRef initialized").stack;
       }
-      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;
-        }
+    set(newInitializer) {
+      this.assertNotInitialized();
+      const overriddenInitializer = () => {
+        return newInitializer(this.defaultInitializer);
       };
+      this.initializer = overriddenInitializer;
+      return new GlobalRefOverride(
+        this,
+        overriddenInitializer,
+        (newInitializer2) => {
+          this.initializer = newInitializer2;
+        }
+      );
+    }
+    assertNotInitialized() {
+      if (this._initialized) {
+        const detail = this.lastInitStack ? `
+Last initialized at:
+${this.lastInitStack}` : "";
+        throw new IllegalStateError(`Cannot call when initialized${detail}`);
+      }
+    }
+    assertNotConstructing() {
+      if (this.constructing)
+        throw new IllegalStateError("Cannot call during construction");
     }
   };
-
-  // src/event/Signal.ts
-  var SignalImpl = class {
-    constructor() {
-      __publicField(this, "handlers", new LinkedList());
+  var GlobalRefOverride = class _GlobalRefOverride {
+    constructor(original, defaultInitializer, setInitializer) {
+      __publicField(this, "original", original);
+      __publicField(this, "defaultInitializer", defaultInitializer);
+      __publicField(this, "setInitializer", setInitializer);
+      __publicField(this, "initializer");
+      this.initializer = defaultInitializer;
     }
-    get empty() {
-      return this.handlers.empty;
+    get initialized() {
+      return this.original.initialized;
     }
-    listen(handler, options) {
-      const remove2 = () => this.handlers.remove(node);
-      const node = this.handlers.push(
-        (options == null ? void 0 : options.once) ? (event) => {
-          remove2();
-          handler(event);
-        } : handler
-      );
-      return remove2;
+    get value() {
+      return this.original.value;
     }
-    /**
-     * Invokes all handlers, providing the given event.
-     *
-     * Handlers may add/remove callbacks or do a nested dispatch.
-     *
-     * If a handler is added within a handler, the new handler will not be invoked until the
-     * next dispatch.
-     *
-     * @param event
-     */
-    dispatch(event) {
-      const handlers = this.handlers;
-      const tail = handlers.tail;
-      handlers.some((handler) => {
-        handler(event);
-        return handler === tail.value;
-      });
+    initialize() {
+      this.setInitializer(this.initializer);
+      this.original.initialize();
     }
-    /**
-     * Removes all handlers.
-     */
-    clear() {
-      this.handlers.clear();
+    reset() {
+      this.initializer = this.defaultInitializer;
+      this.original.reset();
+      this.setInitializer(this.initializer);
     }
-    /**
-     * Same as clear.
-     */
-    dispose() {
-      this.clear();
+    set(newInitializer) {
+      const overriddenInitializer = () => {
+        return newInitializer(this.defaultInitializer);
+      };
+      this.initializer = overriddenInitializer;
+      this.setInitializer(overriddenInitializer);
+      return new _GlobalRefOverride(
+        this,
+        overriddenInitializer,
+        this.setInitializer
+      );
     }
   };
-  function signal() {
-    return new SignalImpl();
+  function globalRef(init) {
+    return getGlobalRegistry().register(new GlobalRefImpl(init));
   }
 
-  // src/logging/LogTarget.ts
-  var counter = 0;
-  function createLogPrefix(target) {
-    const name = typeof target === "string" ? target : target[Symbol.toStringTag];
-    return `${name}/${++counter}`;
+  // src/core/cloneable.ts
+  function isCloneable(value) {
+    return value != null && typeof value === "object" && "clone" in value && typeof value.clone === "function" && value.clone.length === 0;
   }
 
-  // src/event/EventHost.ts
-  var EventHostImpl = class {
-    constructor() {
-      __publicField(this, "logPrefix", createLogPrefix(this));
-      __publicField(this, "signals", /* @__PURE__ */ new Map());
-      __publicField(this, "__eventMapType", covariant());
-    }
-    get [Symbol.toStringTag]() {
-      return "EventHostImpl";
-    }
-    hasAnyListeners() {
-      for (const value of this.signals.values()) {
-        if (!value.empty) return true;
-      }
+  // src/util/object/object.ts
+  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);
+  }
+
+  // src/util/serialization/json.ts
+  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();
     }
-    hasListeners(type) {
-      var _a;
-      return ((_a = this.signals.get(type)) == null ? void 0 : _a.empty) === false;
+  }
+  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();
+      }
     }
-    on(type, handler, options) {
-      const sig = getOrSet(this.signals, type, () => signal());
-      return sig.listen(handler, options);
+  }
+
+  // src/global/environment.ts
+  function getLocation() {
+    return typeof location === "object" ? location : defaultLocation;
+  }
+  var defaultLocation = {
+    origin: "",
+    search: "",
+    href: ""
+  };
+
+  // src/util/browser/searchParams.ts
+  var getSearchParams = memoize(
+    (search = getLocationSearch()) => {
+      const url = new URL("about:blank");
+      url.search = search;
+      return url.searchParams;
+    },
+    (search = getLocationSearch()) => search,
+    1
+  );
+  function getLocationSearch() {
+    return getLocation().search;
+  }
+
+  // src/logging/getLogLevelFromSearch.ts
+  function getLogLevelFromSearch(search = getLocationSearch(), defaultLevel = 3 /* WARN */) {
+    var _a;
+    const str = getSearchParams(search).get("vinylLogLevel");
+    if (!str) return defaultLevel;
+    return (_a = parseLogLevel(str)) != null ? _a : defaultLevel;
+  }
+
+  // src/logging/Logger.ts
+  var LoggerImpl = class extends EventHostImpl {
+    constructor(logLevel = 1 /* DEBUG */) {
+      super();
+      __publicField(this, "logLevel", logLevel);
     }
-    dispatch(type, event) {
-      var _a;
-      (_a = this.signals.get(type)) == null ? void 0 : _a.dispatch(event);
+    get [Symbol.toStringTag]() {
+      return "Logger";
     }
-    dispose() {
-      for (const signal2 of this.signals.values()) signal2.dispose();
-      this.signals.clear();
+    log(target, level, ...messages) {
+      if (level === 5 /* NONE */ || level < this.logLevel) return;
+      this.dispatch("log", {
+        level,
+        messages: toJson(messages),
+        target
+      });
     }
   };
-
-  // src/util/collection/array.ts
-  function remove(array, element) {
-    const index = array.indexOf(element);
-    if (index === -1) return false;
-    array.splice(index, 1);
-    return true;
+  var loggerRef = globalRef(
+    () => new LoggerImpl(
+      // The logger is initialized to VERBOSE if vinylLogLevel=verbose is in the query string
+      // Otherwise use DEBUG.
+      getLogLevelFromSearch() === 0 /* VERBOSE */ ? 0 /* VERBOSE */ : 1 /* DEBUG */
+    )
+  );
+  function logDebug(target, ...messages) {
+    loggerRef.value.log(target, 1 /* DEBUG */, ...messages);
+  }
+  var strToLogLevel = {
+    verbose: 0 /* VERBOSE */,
+    debug: 1 /* DEBUG */,
+    info: 2 /* INFO */,
+    warn: 3 /* WARN */,
+    error: 4 /* ERROR */,
+    none: 5 /* NONE */
+  };
+  function parseLogLevel(str) {
+    var _a;
+    return (_a = strToLogLevel[str.toLowerCase()]) != null ? _a : null;
   }
 
   // src/util/collection/typedArray.ts
@@ -1043,9 +1151,9 @@
     return typedArrayTypes.some((type) => value instanceof type);
   }
 
-  // src/core/cloneable.ts
-  function isCloneable(value) {
-    return value != null && typeof value === "object" && "clone" in value && typeof value.clone === "function" && value.clone.length === 0;
+  // src/util/set/set.ts
+  function union(a, b) {
+    return /* @__PURE__ */ new Set([...a, ...b]);
   }
 
   // src/util/object/mergeDeep.ts
@@ -1140,686 +1248,520 @@
   };
   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, merge) {
-      const out = [];
-      if (sourceA) {
-        for (const element of sourceA) {
-          out.push(merge(void 0, element, out.length));
-        }
-      }
-      for (const element of sourceB) {
-        out.push(merge(void 0, element, out.length));
-      }
-      return out;
-    }
-  };
-  var plainObjectMergeRule = {
-    matches(object) {
-      return isPlainObject(object);
-    },
-    merge(sourceA, sourceB, merge) {
-      const out = {};
-      for (const key of union(ownKeys(sourceA), ownKeys(sourceB))) {
-        if (sourceA && key in sourceB && key in sourceA) {
-          out[key] = merge(sourceA[key], sourceB[key], key);
-        } else if (sourceA && key in sourceA) {
-          out[key] = merge(void 0, sourceA[key], key);
-        } else {
-          out[key] = merge(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, merge) {
-      var _a;
-      const out = /* @__PURE__ */ new Map();
-      for (const key of /* @__PURE__ */ new Set([
-        ...(_a = sourceA == null ? void 0 : sourceA.keys()) != null ? _a : [],
-        ...sourceB.keys()
-      ])) {
-        if (sourceB.has(key) && (sourceA == null ? void 0 : sourceA.has(key))) {
-          out.set(key, merge(sourceA.get(key), sourceB.get(key), key));
-        } else if (sourceA == null ? void 0 : sourceA.has(key)) {
-          out.set(key, merge(void 0, sourceA.get(key), key));
-        } else {
-          out.set(key, merge(void 0, sourceB.get(key), key));
-        }
-      }
-      return out;
-    }
-  };
-  var setMergeRule = {
-    matches(object) {
-      return object instanceof Set;
-    },
-    merge(sourceA, sourceB, merge) {
-      var _a;
-      return new Set(
-        [...(_a = sourceA == null ? void 0 : sourceA.values()) != null ? _a : [], ...sourceB.values()].map(
-          (element, index) => {
-            return merge(void 0, element, 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
-    ]
-  };
-
-  // src/error/IllegalStateError.ts
-  var IllegalStateError = class _IllegalStateError extends ReportableError {
-    get [Symbol.toStringTag]() {
-      return "IllegalStateError";
-    }
-    constructor(message) {
-      super(message);
-      Object.setPrototypeOf(this, _IllegalStateError.prototype);
-    }
-  };
-
-  // src/core/disposable.ts
-  function isDisposable(value) {
-    return value != null && typeof value.dispose === "function" && value.dispose.length === 0;
-  }
-
-  // src/util/iteration/iterable.ts
-  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
-        };
-      }
-    };
-  }
-
-  // src/util/collection/LruCache.ts
-  var LruCache = class {
-    constructor(initialCapacity) {
-      /**
-       * A map of the list nodes.
-       *
-       * @private
-       */
-      __publicField(this, "cache", /* @__PURE__ */ new Map());
-      /**
-       * Most recently used elements are at the tail, least recently used are at the head.
-       * @private
-       */
-      __publicField(this, "list", new LinkedList());
-      /**
-       * An element is about to be removed. Should return true if the element may be evicted,
-       * otherwise false.
-       * If false is returned for all elements, an IllegalStateError is thrown.
-       */
-      __publicField(this, "onEvicting", null);
-      /**
-       * When an element is added when at capacity, the least recently used element will be removed.
-       * This callback can be set to be notified with the element being evicted, which may be used
-       * for disposal.
-       */
-      __publicField(this, "onEvict", null);
-      __publicField(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 isCloneable(object);
+    },
+    merge(_1, sourceB, _2) {
+      return sourceB.clone();
+    }
+  };
+  var arrayMergeRule = {
+    matches(object) {
+      return Array.isArray(object);
+    },
+    merge(sourceA, sourceB, merge) {
+      const out = [];
+      if (sourceA) {
+        for (const element of sourceA) {
+          out.push(merge(void 0, element, out.length));
         }
       }
-      return this;
-    }
-    evictLeastRecentlyUsed() {
-      var _a, _b, _c;
-      let node = this.list.head;
-      while (node) {
-        const [key2, value2] = node.value;
-        const allowed = (_b = (_a = this.onEvicting) == null ? void 0 : _a.call(null, value2, key2, this)) != null ? _b : true;
-        if (allowed) break;
-        node = node.next;
+      for (const element of sourceB) {
+        out.push(merge(void 0, element, out.length));
       }
-      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();
+      return out;
     }
-    /**
-     * @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;
+  };
+  var plainObjectMergeRule = {
+    matches(object) {
+      return isPlainObject(object);
+    },
+    merge(sourceA, sourceB, merge) {
+      const out = {};
+      for (const key of union(ownKeys(sourceA), ownKeys(sourceB))) {
+        if (sourceA && key in sourceB && key in sourceA) {
+          out[key] = merge(sourceA[key], sourceB[key], key);
+        } else if (sourceA && key in sourceA) {
+          out[key] = merge(void 0, sourceA[key], key);
+        } else {
+          out[key] = merge(void 0, sourceB[key], key);
+        }
+      }
+      return out;
     }
-    /**
-     * 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);
-      });
+  };
+  var regexpMergeRule = {
+    matches(object) {
+      return object instanceof RegExp;
+    },
+    merge(_1, sourceB, _2) {
+      return new RegExp(sourceB.source, sourceB.flags);
     }
-    /**
-     * Returns an iterable of key, value pairs for every entry in the map.
-     */
-    entries() {
-      return this[Symbol.iterator]();
+  };
+  var dateMergeRule = {
+    matches(object) {
+      return object instanceof Date;
+    },
+    merge(_1, sourceB, _2) {
+      return new Date(sourceB.getTime());
     }
-    /**
-     * 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);
+  };
+  var mapMergeRule = {
+    matches(object) {
+      return object instanceof Map;
+    },
+    merge(sourceA, sourceB, merge) {
+      var _a;
+      const out = /* @__PURE__ */ new Map();
+      for (const key of /* @__PURE__ */ new Set([
+        ...(_a = sourceA == null ? void 0 : sourceA.keys()) != null ? _a : [],
+        ...sourceB.keys()
+      ])) {
+        if (sourceB.has(key) && (sourceA == null ? void 0 : sourceA.has(key))) {
+          out.set(key, merge(sourceA.get(key), sourceB.get(key), key));
+        } else if (sourceA == null ? void 0 : sourceA.has(key)) {
+          out.set(key, merge(void 0, sourceA.get(key), key));
+        } else {
+          out.set(key, merge(void 0, sourceB.get(key), key));
+        }
+      }
+      return out;
     }
-    /**
-     * 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);
+  };
+  var setMergeRule = {
+    matches(object) {
+      return object instanceof Set;
+    },
+    merge(sourceA, sourceB, merge) {
+      var _a;
+      return new Set(
+        [...(_a = sourceA == null ? void 0 : sourceA.values()) != null ? _a : [], ...sourceB.values()].map(
+          (element, index) => {
+            return merge(void 0, element, index);
+          }
+        )
+      );
     }
-    [Symbol.iterator]() {
-      return this.list[Symbol.iterator]();
+  };
+  var typedArrayMergeRule = {
+    matches(object) {
+      return isTypedArray(object);
+    },
+    merge(_1, sourceB, _2) {
+      return cloneTypedArray(sourceB);
     }
-    get [Symbol.toStringTag]() {
-      return "LruCache";
+  };
+  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
+    ]
+  };
 
-  // src/util/fun/memoize.ts
-  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();
-          }
-        }
-      );
+  // src/util/url/resolveUrl.ts
+  var SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+  function resolveUrl(relative, base) {
+    if (SCHEME_RE.test(relative)) return relative;
+    if (relative.startsWith("//")) {
+      const schemeEnd2 = base.indexOf("://");
+      return base.substring(0, schemeEnd2 + 1) + relative;
     }
+    const schemeEnd = base.indexOf("://") + 3;
+    const pathStart = base.indexOf("/", schemeEnd);
+    const origin = pathStart === -1 ? base : base.substring(0, pathStart);
+    if (relative.startsWith("/")) return origin + relative;
+    if (relative === "") return base;
+    const basePath = pathStart === -1 ? "/" : base.substring(pathStart);
+    const lastSlash = basePath.lastIndexOf("/");
+    const dir = basePath.substring(0, lastSlash + 1);
+    return origin + resolveDots(dir + relative);
   }
-
-  // src/global/environment.ts
-  function getLocation() {
-    return typeof location === "object" ? location : defaultLocation;
+  function resolveDots(path) {
+    if (path.indexOf(".") === -1) return path;
+    const parts = path.split("/");
+    const out = [];
+    for (let i = 0; i < parts.length; i++) {
+      const p = parts[i];
+      if (p === "..") {
+        if (out.length > 1) out.pop();
+      } else if (p !== ".") {
+        out.push(p);
+      }
+    }
+    return out.join("/");
   }
-  var defaultLocation = {
-    origin: "",
-    search: "",
-    href: ""
-  };
 
-  // src/util/browser/searchParams.ts
-  var getSearchParams = memoize(
-    (search = getLocationSearch()) => {
-      const url = new URL("about:blank");
-      url.search = search;
-      return url.searchParams;
-    },
-    (search = getLocationSearch()) => search,
-    1
-  );
-  function getLocationSearch() {
-    return getLocation().search;
+  // test/browserTestUtil/benchmark/Benchmark.ts
+  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();
   }
-
-  // src/global/globalRegistry.ts
-  var GlobalRegistry = class {
-    constructor() {
-      __publicField(this, "registry", []);
-    }
-    /**
-     * Returns the number of references currently in the registry.
-     */
-    get size() {
-      return this.registry.length;
+  var BenchmarkRunResults = class {
+    constructor(name) {
+      __publicField(this, "name", name);
+      __publicField(this, "cycleResults", []);
+      __publicField(this, "_totalSamples", 0);
     }
-    /**
-     * Registers an initializer that will be invoked during global state initialization.
-     * @param initializer
-     */
-    register(initializer) {
-      this.registry.push(initializer);
-      return initializer;
+    get totalSamples() {
+      return this._totalSamples;
     }
-    /**
-     * Removes a global ref from the registry.
-     * May be called at any time.
-     * @param ref
-     * @return Returns true if the global ref was removed.
-     */
-    unregister(ref) {
-      return remove(this.registry, ref);
+    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;
+      });
     }
     /**
-     * Resets all registered initializers and sets this registry back to its pre-initialized state.
-     * This is typically only done within unit tests, but may be called if all players are
-     * disposed and the consumer intends to teardown global state.
+     * Returns the mean ops per second minus outliers of greater than 3 standard deviations.
      */
-    reset() {
-      for (const registryElement of this.registry) {
-        registryElement.reset();
-      }
-    }
-  };
-  var _registry = null;
-  function getGlobalRegistry() {
-    if (!_registry) _registry = new GlobalRegistry();
-    return _registry;
-  }
-  var globalRefDebug = false;
-  var GlobalRefImpl = class {
-    constructor(defaultInitializer) {
-      __publicField(this, "defaultInitializer", defaultInitializer);
-      __publicField(this, "_value");
-      __publicField(this, "_initialized", false);
-      __publicField(this, "constructing", false);
-      __publicField(this, "initializer");
-      __publicField(this, "lastInitStack", null);
-      this.initializer = defaultInitializer;
-    }
-    get initialized() {
-      return this._initialized;
-    }
-    get value() {
-      this.initialize();
-      return this._value;
+    get meanOpsPerSec() {
+      return average(this.cycleResultsNoOutliers);
     }
-    reset() {
-      this.initializer = this.defaultInitializer;
-      if (!this._initialized) return;
-      this.assertNotConstructing();
-      this._initialized = false;
-      this.lastInitStack = null;
-      if (isDisposable(this._value)) {
-        this._value.dispose();
-      }
-      this._value = void 0;
+    get standardDeviation() {
+      return standardDeviation(this.cycleResults);
     }
-    initialize() {
-      if (this._initialized) return;
-      this.assertNotConstructing();
-      this.constructing = true;
-      try {
-        this._value = this.initializer();
-      } catch (error) {
-        this.constructing = false;
-        throw error;
-      }
-      this.constructing = false;
-      this._initialized = true;
-      if (globalRefDebug) {
-        this.lastInitStack = new Error("globalRef initialized").stack;
-      }
+    get variance() {
+      return this.standardDeviation / this.meanOpsPerSec;
     }
-    set(newInitializer) {
-      this.assertNotInitialized();
-      const overriddenInitializer = () => {
-        return newInitializer(this.defaultInitializer);
-      };
-      this.initializer = overriddenInitializer;
-      return new GlobalRefOverride(
-        this,
-        overriddenInitializer,
-        (newInitializer2) => {
-          this.initializer = newInitializer2;
-        }
-      );
+    /**
+     * 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}`;
     }
-    assertNotInitialized() {
-      if (this._initialized) {
-        const detail = this.lastInitStack ? `
-Last initialized at:
-${this.lastInitStack}` : "";
-        throw new IllegalStateError(`Cannot call when initialized${detail}`);
-      }
+    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;
     }
-    assertNotConstructing() {
-      if (this.constructing)
-        throw new IllegalStateError("Cannot call during construction");
+    toString() {
+      if (!this.cycleResults.length) return "No results";
+      return `${this.name}: ${this.meanOpsStr} ops/sec`;
     }
   };
-  var GlobalRefOverride = class _GlobalRefOverride {
-    constructor(original, defaultInitializer, setInitializer) {
-      __publicField(this, "original", original);
-      __publicField(this, "defaultInitializer", defaultInitializer);
-      __publicField(this, "setInitializer", setInitializer);
-      __publicField(this, "initializer");
-      this.initializer = defaultInitializer;
+  var RunResultsComparison = class {
+    constructor(name, results) {
+      __publicField(this, "name", name);
+      /**
+       * Sorted by median ops/s from slowest to fastest.
+       */
+      __publicField(this, "results");
+      this.results = results.sort((a, b) => {
+        return a.meanOpsPerSec - b.meanOpsPerSec;
+      });
     }
-    get initialized() {
-      return this.original.initialized;
+    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, _a) => {
+        var _b = _a, { Name } = _b, x = __objRest(_b, ["Name"]);
+        acc[Name] = x;
+        return acc;
+      }, {});
+      console.log("\n" + this.name);
+      console.table(table);
     }
-    get value() {
-      return this.original.value;
+    runComparisonToString(run) {
+      var _a, _b;
+      const baseline = (_b = (_a = this.results[0]) == null ? void 0 : _a.meanOpsPerSec) != null ? _b : 0;
+      const fasterPercent = run.meanOpsPerSec / baseline - 1;
+      return fasterPercent < 0.01 ? "-" : fasterPercent.toLocaleString(void 0, {
+        style: "percent"
+      }) + " faster";
     }
-    initialize() {
-      this.setInitializer(this.initializer);
-      this.original.initialize();
+  };
+  function compareResults(name, ...results) {
+    return new RunResultsComparison(name, results);
+  }
+  var defaultBenchmarkOptions = {
+    warmupTime: 0.5,
+    maxCycleDuration: 0.5,
+    cycles: 9
+  };
+  var _Benchmark = class _Benchmark {
+    /**
+     * 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) {
+      __publicField(this, "name", name);
+      __publicField(this, "executor", executor);
+      __publicField(this, "options");
+      this.options = __spreadValues(__spreadValues({}, defaultBenchmarkOptions), options);
     }
-    reset() {
-      this.initializer = this.defaultInitializer;
-      this.original.reset();
-      this.setInitializer(this.initializer);
+    async run() {
+      const opts = this.options;
+      await _Benchmark.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;
+      })();
+      _Benchmark.semaphore = resultsPromise;
+      return await resultsPromise;
     }
-    set(newInitializer) {
-      const overriddenInitializer = () => {
-        return newInitializer(this.defaultInitializer);
+    /**
+     * 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
       };
-      this.initializer = overriddenInitializer;
-      this.setInitializer(overriddenInitializer);
-      return new _GlobalRefOverride(
-        this,
-        overriddenInitializer,
-        this.setInitializer
-      );
     }
   };
-  function globalRef(init) {
-    return getGlobalRegistry().register(new GlobalRefImpl(init));
+  __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;
   }
 
-  // src/logging/getLogLevelFromSearch.ts
-  function getLogLevelFromSearch(search = getLocationSearch(), defaultLevel = 3 /* WARN */) {
-    var _a;
-    const str = getSearchParams(search).get("vinylLogLevel");
-    if (!str) return defaultLevel;
-    return (_a = parseLogLevel(str)) != null ? _a : defaultLevel;
+  // test/browserTestUtil/env/jasmineEnv.ts
+  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;
+    });
   }
 
-  // src/logging/Logger.ts
-  var LoggerImpl = class extends EventHostImpl {
-    constructor(logLevel = 1 /* DEBUG */) {
-      super();
-      __publicField(this, "logLevel", logLevel);
-    }
-    get [Symbol.toStringTag]() {
-      return "Logger";
-    }
-    log(target, level, ...messages) {
-      if (level === 5 /* NONE */ || level < this.logLevel) return;
-      this.dispatch("log", {
-        level,
-        messages: toJson(messages),
-        target
-      });
+  // test/browserTestUtil/expect/expectNothing.ts
+  function expectNothing() {
+    expect(true).toBeTruthy();
+  }
+
+  // test/browserTestUtil/mock/createSpyFactory.ts
+  var createSpy = jasmine.createSpy;
+  function createSpy2(key) {
+    return createSpy(String(key));
+  }
+
+  // test/browserTestUtil/mock/dom/lib.dom.ts
+  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 loggerRef = globalRef(
-    () => new LoggerImpl(
-      // The logger is initialized to VERBOSE if vinylLogLevel=verbose is in the query string
-      // Otherwise use DEBUG.
-      getLogLevelFromSearch() === 0 /* VERBOSE */ ? 0 /* VERBOSE */ : 1 /* DEBUG */
-    )
-  );
-  function logDebug(target, ...messages) {
-    loggerRef.value.log(target, 1 /* DEBUG */, ...messages);
-  }
-  var strToLogLevel = {
-    verbose: 0 /* VERBOSE */,
-    debug: 1 /* DEBUG */,
-    info: 2 /* INFO */,
-    warn: 3 /* WARN */,
-    error: 4 /* ERROR */,
-    none: 5 /* NONE */
+  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"));
+    }
   };
-  function parseLogLevel(str) {
-    var _a;
-    return (_a = strToLogLevel[str.toLowerCase()]) != null ? _a : null;
-  }
 
-  // test/benchmark/util/url/resolveUrl.bench.ts
-  describe("resolveUrl", () => {
-    setupBenchmark();
-    it("relative path", async () => {
-      const name = "relative path";
-      const base = "https://cdn.example.com/content/audio/";
-      const relative = "segment_001.mp4";
-      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
-        const _o = resolveUrl(relative, base);
-      });
-      const newUrlResults = await benchmark(`new URL ${name}`, () => {
-        const _o = new URL(relative, base).href;
-      });
-      addBenchmarks(name, resolveUrlResults, newUrlResults);
-    });
-    it("absolute URI", async () => {
-      const name = "absolute URI";
-      const base = "https://cdn.example.com/content/audio/";
-      const absolute = "https://other.example.com/segment.mp4";
-      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
-        const _o = resolveUrl(absolute, base);
-      });
-      const newUrlResults = await benchmark(`new URL ${name}`, () => {
-        const _o = new URL(absolute, base).href;
-      });
-      addBenchmarks(name, resolveUrlResults, newUrlResults);
-    });
-    it("dot segments", async () => {
-      const name = "dot segments";
-      const base = "https://cdn.example.com/a/b/c/manifest.mpd";
-      const relative = "../../media/segment.mp4";
-      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
-        const _o = resolveUrl(relative, base);
-      });
-      const newUrlResults = await benchmark(`new URL ${name}`, () => {
-        const _o = new URL(relative, base).href;
-      });
-      addBenchmarks(name, resolveUrlResults, newUrlResults);
-    });
-    it("chained resolution (DASH BaseURL walk)", async () => {
-      const name = "chained resolution";
-      const manifest = "https://cdn.example.com/manifest.mpd";
-      const scopes = ["content/", "audio/", "128k/"];
-      const segment = "seg_001.m4s";
-      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
-        let resolved = manifest;
-        for (const scope of scopes) {
-          resolved = resolveUrl(scope, resolved);
-        }
-        resolveUrl(segment, resolved);
-      });
-      const newUrlResults = await benchmark(`new URL ${name}`, () => {
-        let resolved = new URL(manifest);
-        for (const scope of scopes) {
-          resolved = new URL(scope, resolved);
+  // test/browserTestUtil/mock/dom/globals.ts
+  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"));
+
+  // 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 _a;
+        console.log("Tests complete");
+        const jasmineContainer = document.getElementsByClassName(
+          "jasmine_html-reporter"
+        )[0];
+        (_a = jasmineContainer.parentElement) == null ? void 0 : _a.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);
         }
-        const _o = new URL(segment, resolved).href;
-      });
-      addBenchmarks(name, resolveUrlResults, newUrlResults);
+      }
     });
-  });
+  }
+  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 element = document.createElement(tagName, options);
+    if (parent) parent.appendChild(element);
+    return element;
+  }
 
-  // test/benchmark/util/serialization/toJson.bench.ts
-  describe("json", () => {
+  // test/benchmark/logging/Logging.bench.ts
+  describe("Logging", () => {
     setupBenchmark();
-    it("toJson", async () => {
-      const results = await benchmark(`toJson`, () => {
-        toJson({
+    it("logDebug", async () => {
+      const target = {
+        logPrefix: "path"
+      };
+      const results = await benchmark(`logDebug`, () => {
+        logDebug(target, {
           requestInfo: {
             fetchId: "lgn9lrwaid8o3utd5r",
             init: {
@@ -1835,7 +1777,7 @@ ${this.lastInitStack}` : "";
             input: "https://example.com/bar/",
             maxRetries: 1,
             timestamp: /* @__PURE__ */ new Date("2023-04-19T05:40:17.914Z"),
-            requestOptions: {
+            fetchOptions: {
               serviceId: null,
               readErrorBody: 1
             }
@@ -1847,51 +1789,7 @@ ${this.lastInitStack}` : "";
           target: "[object FetchProviderImpl]"
         });
       });
-      addBenchmarks("toJson", results);
-    });
-  });
-
-  // test/benchmark/util/object/mergeDeep.bench.ts
-  describe("mergeDeep", () => {
-    setupBenchmark();
-    it("object merge", async () => {
-      const a = {
-        b: {
-          c: 3,
-          d: 4,
-          e: "test"
-        },
-        f: {
-          g: 5,
-          h: true,
-          i: false
-        },
-        j: {
-          k: {
-            m: 5
-          }
-        }
-      };
-      const b = {
-        b: {
-          d: 4,
-          f2: "test2"
-        },
-        f: {
-          g: 5,
-          h: true,
-          i: false
-        },
-        j: {
-          k: {
-            m: 5
-          }
-        }
-      };
-      const mergeResultsDeep = await benchmark(`mergeDeep`, () => {
-        mergeDeep([a, b]);
-      });
-      addBenchmarks("merge deep", mergeResultsDeep);
+      addBenchmarks("logDebug", results);
     });
   });
 
@@ -1983,15 +1881,56 @@ ${this.lastInitStack}` : "";
     });
   });
 
-  // test/benchmark/logging/Logging.bench.ts
-  describe("Logging", () => {
+  // test/benchmark/util/object/mergeDeep.bench.ts
+  describe("mergeDeep", () => {
     setupBenchmark();
-    it("logDebug", async () => {
-      const target = {
-        logPrefix: "path"
+    it("object merge", async () => {
+      const a = {
+        b: {
+          c: 3,
+          d: 4,
+          e: "test"
+        },
+        f: {
+          g: 5,
+          h: true,
+          i: false
+        },
+        j: {
+          k: {
+            m: 5
+          }
+        }
       };
-      const results = await benchmark(`logDebug`, () => {
-        logDebug(target, {
+      const b = {
+        b: {
+          d: 4,
+          f2: "test2"
+        },
+        f: {
+          g: 5,
+          h: true,
+          i: false
+        },
+        j: {
+          k: {
+            m: 5
+          }
+        }
+      };
+      const mergeResultsDeep = await benchmark(`mergeDeep`, () => {
+        mergeDeep([a, b]);
+      });
+      addBenchmarks("merge deep", mergeResultsDeep);
+    });
+  });
+
+  // test/benchmark/util/serialization/toJson.bench.ts
+  describe("json", () => {
+    setupBenchmark();
+    it("toJson", async () => {
+      const results = await benchmark(`toJson`, () => {
+        toJson({
           requestInfo: {
             fetchId: "lgn9lrwaid8o3utd5r",
             init: {
@@ -2007,7 +1946,7 @@ ${this.lastInitStack}` : "";
             input: "https://example.com/bar/",
             maxRetries: 1,
             timestamp: /* @__PURE__ */ new Date("2023-04-19T05:40:17.914Z"),
-            fetchOptions: {
+            requestOptions: {
               serviceId: null,
               readErrorBody: 1
             }
@@ -2019,7 +1958,69 @@ ${this.lastInitStack}` : "";
           target: "[object FetchProviderImpl]"
         });
       });
-      addBenchmarks("logDebug", results);
+      addBenchmarks("toJson", results);
+    });
+  });
+
+  // test/benchmark/util/url/resolveUrl.bench.ts
+  describe("resolveUrl", () => {
+    setupBenchmark();
+    it("relative path", async () => {
+      const name = "relative path";
+      const base = "https://cdn.example.com/content/audio/";
+      const relative = "segment_001.mp4";
+      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
+        const _o = resolveUrl(relative, base);
+      });
+      const newUrlResults = await benchmark(`new URL ${name}`, () => {
+        const _o = new URL(relative, base).href;
+      });
+      addBenchmarks(name, resolveUrlResults, newUrlResults);
+    });
+    it("absolute URI", async () => {
+      const name = "absolute URI";
+      const base = "https://cdn.example.com/content/audio/";
+      const absolute = "https://other.example.com/segment.mp4";
+      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
+        const _o = resolveUrl(absolute, base);
+      });
+      const newUrlResults = await benchmark(`new URL ${name}`, () => {
+        const _o = new URL(absolute, base).href;
+      });
+      addBenchmarks(name, resolveUrlResults, newUrlResults);
+    });
+    it("dot segments", async () => {
+      const name = "dot segments";
+      const base = "https://cdn.example.com/a/b/c/manifest.mpd";
+      const relative = "../../media/segment.mp4";
+      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
+        const _o = resolveUrl(relative, base);
+      });
+      const newUrlResults = await benchmark(`new URL ${name}`, () => {
+        const _o = new URL(relative, base).href;
+      });
+      addBenchmarks(name, resolveUrlResults, newUrlResults);
+    });
+    it("chained resolution (DASH BaseURL walk)", async () => {
+      const name = "chained resolution";
+      const manifest = "https://cdn.example.com/manifest.mpd";
+      const scopes = ["content/", "audio/", "128k/"];
+      const segment = "seg_001.m4s";
+      const resolveUrlResults = await benchmark(`resolveUrl ${name}`, () => {
+        let resolved = manifest;
+        for (const scope of scopes) {
+          resolved = resolveUrl(scope, resolved);
+        }
+        resolveUrl(segment, resolved);
+      });
+      const newUrlResults = await benchmark(`new URL ${name}`, () => {
+        let resolved = new URL(manifest);
+        for (const scope of scopes) {
+          resolved = new URL(scope, resolved);
+        }
+        const _o = new URL(segment, resolved).href;
+      });
+      addBenchmarks(name, resolveUrlResults, newUrlResults);
     });
   });
 })();