@amazon/vinyl-util 1.0.0

package/dist/test/benchmark.js

@@ -0,0 +1,2026 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __propIsEnum = Object.prototype.propertyIsEnumerable;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __spreadValues = (a, b) => {
+    for (var prop in b || (b = {}))
+      if (__hasOwnProp.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    if (__getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(b)) {
+        if (__propIsEnum.call(b, prop))
+          __defNormalProp(a, prop, b[prop]);
+      }
+    return a;
+  };
+  var __objRest = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols)
+      for (var prop of __getOwnPropSymbols(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+          target[prop] = source[prop];
+      }
+    return target;
+  };
+  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));
+  }
+
+  // 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 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"));
+    }
+  };
+
+  // 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/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) {
+      this.name = name;
+      __publicField(this, "cycleResults", []);
+      __publicField(this, "_totalSamples", 0);
+    }
+    get totalSamples() {
+      return this._totalSamples;
+    }
+    get cycleResultsNoOutliers() {
+      const sD = this.standardDeviation;
+      const avg = average(this.cycleResults);
+      return this.cycleResults.filter((e) => {
+        const zScore = (avg - e) / sD;
+        return Math.abs(zScore) < 3;
+      });
+    }
+    /**
+     * Returns the mean ops per second minus outliers of greater than 3 standard deviations.
+     */
+    get meanOpsPerSec() {
+      return average(this.cycleResultsNoOutliers);
+    }
+    get standardDeviation() {
+      return standardDeviation(this.cycleResults);
+    }
+    get variance() {
+      return this.standardDeviation / this.meanOpsPerSec;
+    }
+    /**
+     * Returns the mean ops / s ± variance % as a string.
+     */
+    get meanOpsStr() {
+      const mean = this.meanOpsPerSec.toLocaleString(void 0, {
+        maximumSignificantDigits: 4
+      });
+      const variance = this.variance.toLocaleString(void 0, {
+        style: "percent"
+      });
+      return `${mean} \xB1${variance}`;
+    }
+    add(cycle) {
+      const opsPerSecond = cycle.ops / cycle.duration;
+      let index = this.cycleResults.findIndex((value) => opsPerSecond < value);
+      if (index < 0) index = this.cycleResults.length;
+      this.cycleResults.splice(index, 0, opsPerSecond);
+      this._totalSamples += cycle.ops;
+    }
+    toString() {
+      if (!this.cycleResults.length) return "No results";
+      return `${this.name}: ${this.meanOpsStr} ops/sec`;
+    }
+  };
+  var RunResultsComparison = class {
+    constructor(name, results) {
+      this.name = name;
+      /**
+       * Sorted by median ops/s from slowest to fastest.
+       */
+      __publicField(this, "results");
+      this.results = results.sort((a, b) => {
+        return a.meanOpsPerSec - b.meanOpsPerSec;
+      });
+    }
+    logToTable() {
+      const r = this.results.map((run) => {
+        const variance = run.variance.toLocaleString(void 0, {
+          style: "percent"
+        });
+        const mean = run.meanOpsPerSec.toLocaleString(void 0, {
+          maximumSignificantDigits: 4
+        });
+        return {
+          Name: run.name,
+          Mean: `${mean} \xB1${variance}`,
+          Samples: run.totalSamples,
+          Compare: this.runComparisonToString(run)
+        };
+      });
+      const table = r.reduce((acc, _a) => {
+        var _b = _a, { Name } = _b, x = __objRest(_b, ["Name"]);
+        acc[Name] = x;
+        return acc;
+      }, {});
+      console.log("\n" + this.name);
+      console.table(table);
+    }
+    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";
+    }
+  };
+  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) {
+      this.name = name;
+      this.executor = executor;
+      __publicField(this, "options");
+      this.options = __spreadValues(__spreadValues({}, defaultBenchmarkOptions), options);
+    }
+    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;
+    }
+    /**
+     * Runs one cycle. A cycle will repeat the executor approximately `options.maxCycleDuration`
+     * seconds.
+     *
+     * @param isAsync
+     * @return Returns the duration (in seconds) and number of operations the cycle repeated.
+     */
+    async runCycle(isAsync) {
+      const cycleMs = this.options.maxCycleDuration * 1e3;
+      let ops = 0;
+      const cycleStart = now();
+      do {
+        const result = this.executor();
+        if (isAsync) await result;
+        ops++;
+      } while (now() - cycleStart < cycleMs);
+      const duration = (now() - cycleStart) / 1e3;
+      return {
+        duration,
+        ops
+      };
+    }
+  };
+  __publicField(_Benchmark, "semaphore", nextFrame());
+  var Benchmark = _Benchmark;
+  function benchmark(name, executor, options) {
+    const benchmark2 = new Benchmark(name, executor, options);
+    return benchmark2.run().then((results) => {
+      console.log(results.toString());
+      return results;
+    });
+  }
+  function nextFrame() {
+    return new Promise((resolve) => {
+      setTimeout(resolve);
+    });
+  }
+  function standardDeviation(values) {
+    const avg = average(values);
+    const squareDiffs = values.map((value) => {
+      const diff = value - avg;
+      return diff * diff;
+    });
+    const avgSquareDiff = average(squareDiffs);
+    return Math.sqrt(avgSquareDiff);
+  }
+  function average(values) {
+    const sum = values.reduce((acc, value) => acc + value, 0);
+    return sum / values.length;
+  }
+
+  // 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;
+    }
+    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);
+      }
+    }
+    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.
+     */
+    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"
+  };
+
+  // src/error/ReportableError.ts
+  var ReportableError = class _ReportableError extends Error {
+    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal" /* FATAL */) {
+      super(message);
+      this.origin = origin;
+      this.level = level;
+      Object.setPrototypeOf(this, _ReportableError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "ReportableError";
+    }
+    get name() {
+      return this[Symbol.toStringTag];
+    }
+    /**
+     * All ReportableError instances must be serializable.
+     */
+    toJSON() {
+      return {
+        level: this.level,
+        message: this.message,
+        name: this.name,
+        origin: this.origin,
+        stack: this.stack
+      };
+    }
+  };
+
+  // src/error/IllegalArgumentError.ts
+  var IllegalArgumentError = class _IllegalArgumentError extends ReportableError {
+    constructor(message, isInternal = true) {
+      super(message, isInternal ? ErrorOrigin.INTERNAL : ErrorOrigin.API);
+      this.isInternal = isInternal;
+      Object.setPrototypeOf(this, _IllegalArgumentError.prototype);
+    }
+    get [Symbol.toStringTag]() {
+      return "IllegalArgumentError";
+    }
+  };
+
+  // src/util/map/map.ts
+  function getOrSet(map, key, defaultValue) {
+    if (map.has(key)) {
+      return map.get(key);
+    } else {
+      const value = defaultValue(key);
+      map.set(key, value);
+      return value;
+    }
+  }
+  function flipMap(map) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [key, value] of map) {
+      result.set(value, key);
+    }
+    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]);
+    });
+  }
+  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/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();
+    }
+  }
+  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();
+      }
+    }
+  }
+
+  // src/util/collection/LinkedList.ts
+  var LinkedList = class {
+    constructor() {
+      __publicField(this, "_head", null);
+      __publicField(this, "_tail", null);
+    }
+    /**
+     * Returns the current head.
+     */
+    get head() {
+      return this._head;
+    }
+    /**
+     * Returns the current tail.
+     */
+    get tail() {
+      return this._tail;
+    }
+    /**
+     * Returns true if the list is empty.
+     */
+    get empty() {
+      return this._head === null;
+    }
+    /**
+     * Creates a new node for the given value, adding it to the end of the list.
+     *
+     * @param value
+     * @return Returns the newly created node.
+     */
+    push(value) {
+      const node = {
+        previous: this._tail,
+        value,
+        removed: false,
+        next: null
+      };
+      this.pushNode(node);
+      return node;
+    }
+    /**
+     * Appends all given values to the end of this list.
+     *
+     * @param values
+     */
+    pushAll(...values) {
+      for (const value of values) {
+        this.push(value);
+      }
+    }
+    /**
+     * Appends the given node to the tail of this list.
+     * If the node is already at the tail, it will no-op.
+     * If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the tail of this list.
+     */
+    pushNode(node) {
+      if (this._tail === node) return;
+      this.remove(node);
+      node.removed = false;
+      node.next = null;
+      node.previous = this._tail;
+      if (this._tail) this._tail.next = node;
+      this._tail = node;
+      if (!this._head) this._head = node;
+    }
+    /**
+     * Removes the last node (the tail), returning it.
+     * If this list is empty, null is returned.
+     */
+    pop() {
+      const node = this._tail;
+      if (!node) return null;
+      this.remove(node);
+      return node;
+    }
+    /**
+     * Creates a new node, adding it to the front of the list.
+     *
+     * @param value The value to box in a linked node.
+     * @return Returns the new node.
+     */
+    unshift(value) {
+      const node = {
+        previous: null,
+        value,
+        removed: true,
+        next: this._head
+      };
+      this.unshiftNode(node);
+      return node;
+    }
+    /**
+     * Prepends all the given values to the head of this list.
+     * The values will maintain their order.
+     *
+     * E.g.
+     * ```
+     * list.unshiftAll(8, 9, 10)   // 8, 9, 10
+     * list.unshiftAll(4, 5, 6, 7) // 4, 5, 6, 7, 8, 9, 10
+     * list.unshiftAll(1, 2, 3)    // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     * ```
+     *
+     * @param values The values to box in linked nodes.
+     */
+    unshiftAll(...values) {
+      for (let i = values.length - 1; i >= 0; i--) {
+        this.unshift(values[i]);
+      }
+    }
+    /**
+     * Prepends the given node to the head of this list.
+     * - If the node is already at the head, it will no-op.
+     * - If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the head of this list.
+     */
+    unshiftNode(node) {
+      if (this._head === node) return;
+      this.remove(node);
+      node.removed = false;
+      node.previous = null;
+      node.next = this._head;
+      if (this._head) this._head.previous = node;
+      this._head = node;
+      if (!this._tail) this._tail = node;
+    }
+    /**
+     * Removes the first node (the head), returning it.
+     * - If this list is empty, null is returned.
+     */
+    shift() {
+      const node = this._head;
+      if (!node) return null;
+      this.remove(node);
+      return node;
+    }
+    /**
+     * Removes the given linked node.
+     *
+     * @param node
+     */
+    remove(node) {
+      if (node.removed) return;
+      node.removed = true;
+      if (node.previous) node.previous.next = node.next;
+      if (node.next) node.next.previous = node.previous;
+      if (this._head === node) this._head = node.next;
+      if (this._tail === node) this._tail = node.previous;
+    }
+    /**
+     * Inserts the given node before pointer node.
+     *
+     * @param node The node to insert before pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeBefore(node, pointer) {
+      if (!node.removed && node.next === pointer) return;
+      this.remove(node);
+      node.removed = false;
+      if (pointer.previous) {
+        pointer.previous.next = node;
+        node.previous = pointer.previous;
+      } else {
+        this._head = node;
+        node.previous = null;
+      }
+      node.next = pointer;
+      pointer.previous = node;
+    }
+    /**
+     * Inserts the given node after pointer node.
+     *
+     * @param node The node to insert after pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeAfter(node, pointer) {
+      if (!node.removed && node.previous === pointer) return;
+      this.remove(node);
+      node.removed = false;
+      if (pointer.next) {
+        pointer.next.previous = node;
+        node.next = pointer.next;
+      } else {
+        this._tail = node;
+        node.next = null;
+      }
+      node.previous = pointer;
+      pointer.next = node;
+    }
+    /**
+     * Iterates over every element, invoking the given callback.
+     *
+     * @param callback
+     */
+    forEach(callback) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed) callback(current.value);
+        current = current.next;
+      }
+    }
+    /**
+     * Similar to `Array.prototype.some`, returns true if at least one element passes the given
+     * predicate.
+     *
+     * @param predicate
+     */
+    some(predicate) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return true;
+        current = current.next;
+      }
+      return false;
+    }
+    /**
+     * Returns the first node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    find(predicate) {
+      let current = this._head;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return current;
+        current = current.next;
+      }
+      return null;
+    }
+    /**
+     * Returns the last node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    findLast(predicate) {
+      let current = this._tail;
+      while (current) {
+        if (!current.removed && predicate(current.value)) return current;
+        current = current.previous;
+      }
+      return null;
+    }
+    /**
+     * Clears this list.
+     */
+    clear() {
+      let current = this._head;
+      while (current != null) {
+        const next = current.next;
+        current.removed = true;
+        current = next;
+      }
+      this._head = null;
+      this._tail = null;
+    }
+    /**
+     * Returns a new iterator, starting at the head.
+     */
+    [Symbol.iterator]() {
+      return this.createIterator(this._head, null, (node) => node.next);
+    }
+    /**
+     * Returns a new reversed iterable where the iterator starts at the tail, moving backwards
+     * to the head.
+     */
+    reversed() {
+      return this.createIterator(this._tail, null, (node) => node.previous);
+    }
+    /**
+     * Creates an iterable iterator, starting at the specified node, getting the next node from
+     * the next() function.
+     *
+     * Note that using iterators is not as performant as {@link some} or {@link forEach}
+     *
+     * @param start The starting node. (inclusive)
+     * @param end The ending node (exclusive).
+     * @param next A method that is given the current node, and returns the next node.
+     */
+    createIterator(start, end, next) {
+      let current = start;
+      return {
+        [Symbol.iterator]() {
+          return this;
+        },
+        next: () => {
+          if (current === end || !current) {
+            return {
+              value: void 0,
+              done: true
+            };
+          }
+          const result = {
+            value: current.value,
+            done: false
+          };
+          current = next(current);
+          while (current == null ? void 0 : current.removed) {
+            current = next(current);
+          }
+          return result;
+        }
+      };
+    }
+  };
+
+  // src/event/Signal.ts
+  var SignalImpl = class {
+    constructor() {
+      __publicField(this, "handlers", new LinkedList());
+    }
+    get empty() {
+      return this.handlers.empty;
+    }
+    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;
+    }
+    /**
+     * 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;
+      });
+    }
+    /**
+     * Removes all handlers.
+     */
+    clear() {
+      this.handlers.clear();
+    }
+    /**
+     * Same as clear.
+     */
+    dispose() {
+      this.clear();
+    }
+  };
+  function signal() {
+    return new SignalImpl();
+  }
+
+  // src/logging/LogTarget.ts
+  var counter = 0;
+  function createLogPrefix(target) {
+    const name = typeof target === "string" ? target : target[Symbol.toStringTag];
+    return `${name}/${++counter}`;
+  }
+
+  // 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;
+    }
+    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;
+  }
+
+  // src/util/collection/typedArray.ts
+  function cloneTypedArray(array) {
+    return new array.constructor(array);
+  }
+  var typedArrayTypes = [
+    Float32Array,
+    Float64Array,
+    Int16Array,
+    Int32Array,
+    Int8Array,
+    Uint16Array,
+    Uint32Array,
+    Uint8Array,
+    Uint8ClampedArray
+  ];
+  function isTypedArray(value) {
+    return typedArrayTypes.some((type) => value instanceof type);
+  }
+
+  // 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/object/mergeDeep.ts
+  var locale2 = {
+    cyclicRefError: "Cyclic reference found at: {path}",
+    mergeReferenceError: `No merge rule found at {path} for "{source}" and reference copy not allowed`
+  };
+  function mergeDeep(sources, options) {
+    if (!sources.length) return void 0;
+    const finalOpts = __spreadValues(__spreadValues({}, defaultMergeOptions), options);
+    const stack = new PropStack();
+    const n = sources.length;
+    if (n === 1)
+      return _mergeDeep(void 0, sources[0], stack, 0, finalOpts);
+    let out = _mergeDeep(sources[0], sources[1], stack, 1, finalOpts);
+    for (let i = 2; i < n; i++) {
+      out = _mergeDeep(out, sources[i], stack, i, finalOpts);
+    }
+    return out;
+  }
+  var PropStack = class {
+    constructor() {
+      /**
+       * Object references for sourceA.
+       */
+      __publicField(this, "refsA", /* @__PURE__ */ new Set());
+      /**
+       * Object references for sourceB.
+       */
+      __publicField(this, "refsB", /* @__PURE__ */ new Set());
+      __publicField(this, "propStack", []);
+    }
+    /**
+     * The property stack, joined by .
+     */
+    get currentPath() {
+      return this.propStack.map((e) => e[2]).filter((e) => e != null).join(".");
+    }
+    push(sourceA, sourceB, prop) {
+      this.propStack.push([sourceA, sourceB, prop]);
+      this.addRef(this.refsA, sourceA);
+      this.addRef(this.refsB, sourceB);
+    }
+    pop() {
+      const last = this.propStack.pop();
+      this.refsA.delete(last[0]);
+      this.refsB.delete(last[1]);
+    }
+    addRef(refSet, source) {
+      if (typeof source !== "object") return;
+      if (refSet.has(source)) {
+        throw new IllegalArgumentError(
+          substitute(locale2.cyclicRefError, { path: this.currentPath })
+        );
+      }
+      refSet.add(source);
+    }
+  };
+  function _mergeDeep(sourceA, sourceB, propStack, prop, options) {
+    if (typeof sourceB !== "object" || sourceB === null) return sourceB;
+    const merge = (sourceA2, sourceB2, prop2) => {
+      return _mergeDeep(sourceA2, sourceB2, propStack, prop2, options);
+    };
+    for (const rule of options.rules) {
+      if (rule.matches(sourceB)) {
+        propStack.push(sourceA, sourceB, prop);
+        const result = rule.merge(
+          rule.matches(sourceA) ? sourceA : void 0,
+          sourceB,
+          merge
+        );
+        propStack.pop();
+        return result;
+      }
+    }
+    if (!options.allowReferenceCopy) {
+      propStack.push(sourceA, sourceB, prop);
+      throw new MergeReferenceError(propStack.currentPath, sourceB);
+    }
+    return sourceB;
+  }
+  var MergeReferenceError = class _MergeReferenceError extends ReportableError {
+    constructor(propPath, source) {
+      super(
+        substitute(locale2.mergeReferenceError, {
+          path: propPath,
+          source
+        })
+      );
+      Object.setPrototypeOf(this, _MergeReferenceError.prototype);
+    }
+  };
+  var cloneableMergeRule = {
+    matches(object) {
+      return isCloneable(object);
+    },
+    merge(_1, sourceB, _2) {
+      return sourceB.clone();
+    }
+  };
+  var arrayMergeRule = {
+    matches(object) {
+      return Array.isArray(object);
+    },
+    merge(sourceA, sourceB, 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 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);
+    }
+    /**
+     * Clears all elements from the cache.
+     */
+    clear() {
+      this.list.clear();
+      this.cache.clear();
+    }
+    /**
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
+    delete(key) {
+      if (!this.has(key)) return false;
+      const node = this.cache.get(key);
+      this.cache.delete(key);
+      this.list.remove(node);
+      return true;
+    }
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     *
+     * @param callback A callback to invoke for every element in the cache.
+     * @param thisArg Value to use as this when executing callback
+     */
+    forEach(callback, thisArg) {
+      return this.list.forEach((entry) => {
+        callback.call(thisArg, entry[1], entry[0], this);
+      });
+    }
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries() {
+      return this[Symbol.iterator]();
+    }
+    /**
+     * Returns an iterable of keys in the map. This will be ordered from least recently used to
+     * most.
+     */
+    keys() {
+      return mapIter(this.list, ([key]) => key);
+    }
+    /**
+     * Returns an iterable of values in the map. This will be ordered from least recently used to
+     * most.
+     */
+    values() {
+      return mapIter(this.list, ([, value]) => value);
+    }
+    [Symbol.iterator]() {
+      return this.list[Symbol.iterator]();
+    }
+    get [Symbol.toStringTag]() {
+      return "LruCache";
+    }
+  };
+
+  // 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/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/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;
+    }
+    /**
+     * Registers an initializer that will be invoked during global state initialization.
+     * @param initializer
+     */
+    register(initializer) {
+      this.registry.push(initializer);
+      return initializer;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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.
+     */
+    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) {
+      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;
+    }
+    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;
+    }
+    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;
+      }
+    }
+    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");
+    }
+  };
+  var GlobalRefOverride = class _GlobalRefOverride {
+    constructor(original, defaultInitializer, setInitializer) {
+      this.original = original;
+      this.defaultInitializer = defaultInitializer;
+      this.setInitializer = setInitializer;
+      __publicField(this, "initializer");
+      this.initializer = defaultInitializer;
+    }
+    get initialized() {
+      return this.original.initialized;
+    }
+    get value() {
+      return this.original.value;
+    }
+    initialize() {
+      this.setInitializer(this.initializer);
+      this.original.initialize();
+    }
+    reset() {
+      this.initializer = this.defaultInitializer;
+      this.original.reset();
+      this.setInitializer(this.initializer);
+    }
+    set(newInitializer) {
+      const overriddenInitializer = () => {
+        return newInitializer(this.defaultInitializer);
+      };
+      this.initializer = overriddenInitializer;
+      this.setInitializer(overriddenInitializer);
+      return new _GlobalRefOverride(
+        this,
+        overriddenInitializer,
+        this.setInitializer
+      );
+    }
+  };
+  function globalRef(init) {
+    return getGlobalRegistry().register(new GlobalRefImpl(init));
+  }
+
+  // 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();
+      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
+      });
+    }
+  };
+  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;
+  }
+
+  // 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);
+    });
+  });
+
+  // test/benchmark/util/serialization/toJson.bench.ts
+  describe("json", () => {
+    setupBenchmark();
+    it("toJson", async () => {
+      const results = await benchmark(`toJson`, () => {
+        toJson({
+          requestInfo: {
+            fetchId: "lgn9lrwaid8o3utd5r",
+            init: {
+              method: "POST",
+              headers: {
+                "Content-Encoding": "amz-1.0",
+                "Content-Type": "application/json",
+                "X-Amz-Target": "com.amazon.digitalmusiclocator.DigitalMusicLocatorServiceExternal.getStreamingURLs"
+              },
+              body: '{"contentIdList":[{"identifier":"d9e4e337-97ba-41a9-9f31-84a8bf99f1dc","identifierType":"COID"}],"bitRate":"HIGH","deviceToken":{"deviceId":"lg4msezd1e355heuc5b","deviceTypeId":"A16ZV8BU3SN1N3"},"appMetadata":{"appId":"WebCP","https":true,"appVersion":"1.0.0"},"clientMetadata":{"clientId":"WebCP","clientRequestId":"lgn9lrw623mgvi7k3et"}}',
+              signal: "[object AbortSignal]"
+            },
+            input: "https://example.com/bar/",
+            maxRetries: 1,
+            timestamp: /* @__PURE__ */ new Date("2023-04-19T05:40:17.914Z"),
+            requestOptions: {
+              serviceId: null,
+              readErrorBody: 1
+            }
+          },
+          attemptInfo: {
+            currentTry: 1,
+            timestamp: /* @__PURE__ */ new Date("2023-04-19T05:40:17.914Z")
+          },
+          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);
+    });
+  });
+
+  // test/benchmark/util/collection/LinkedList.bench.ts
+  describe("LinkedList", () => {
+    setupBenchmark();
+    function createList(n) {
+      const list = new LinkedList();
+      for (let i = 0; i < n; i++) {
+        list.push({ r: 0, a: Math.random(), b: Math.random() });
+      }
+      return list;
+    }
+    function createArray(n) {
+      const arr = [];
+      for (let i = 0; i < n; i++) {
+        arr.push({ r: 0, a: Math.random(), b: Math.random() });
+      }
+      return arr;
+    }
+    ;
+    [100, 1e3].forEach((size) => {
+      const list = createList(size);
+      const arr = createArray(size);
+      describe(`size: ${size}`, () => {
+        it("forEach", async () => {
+          const name = `forEach ${size}`;
+          const listResults = await benchmark(
+            `LinkedList ${name}`,
+            () => {
+              list.forEach((e) => e.r = e.a + e.b);
+            }
+          );
+          const arrayResults = await benchmark(`Array ${name}`, () => {
+            arr.forEach((e) => e.r = e.a + e.b);
+          });
+          addBenchmarks(name, listResults, arrayResults);
+        });
+        it("unshift", async () => {
+          const name = `unshift/shift ${size}`;
+          const e = { r: 0, a: 0, b: 0 };
+          const listResults = await benchmark(
+            `LinkedList ${name}`,
+            () => {
+              list.unshift(e);
+              list.shift();
+            }
+          );
+          const arrayResults = await benchmark(`Array ${name}`, () => {
+            arr.unshift(e);
+            arr.shift();
+          });
+          addBenchmarks(name, listResults, arrayResults);
+        });
+        it("push", async () => {
+          const name = `push/pop ${size}`;
+          const e = { r: 0, a: 0, b: 0 };
+          const listResults = await benchmark(
+            `LinkedList ${name}`,
+            () => {
+              list.push(e);
+              list.pop();
+            }
+          );
+          const arrayResults = await benchmark(`Array ${name}`, () => {
+            arr.push(e);
+            arr.pop();
+          });
+          addBenchmarks(name, listResults, arrayResults);
+        });
+        it("for of", async () => {
+          const name = `for of ${size}`;
+          const listResults = await benchmark(
+            `LinkedList ${name}`,
+            () => {
+              for (const e of list) {
+                e.r = e.a + e.b;
+              }
+            }
+          );
+          const arrayResults = await benchmark(`Array ${name}`, () => {
+            for (const e of arr) {
+              e.r = e.a + e.b;
+            }
+          });
+          addBenchmarks(name, listResults, arrayResults);
+        });
+      });
+    });
+  });
+
+  // test/benchmark/logging/Logging.bench.ts
+  describe("Logging", () => {
+    setupBenchmark();
+    it("logDebug", async () => {
+      const target = {
+        logPrefix: "path"
+      };
+      const results = await benchmark(`logDebug`, () => {
+        logDebug(target, {
+          requestInfo: {
+            fetchId: "lgn9lrwaid8o3utd5r",
+            init: {
+              method: "POST",
+              headers: {
+                "Content-Encoding": "amz-1.0",
+                "Content-Type": "application/json",
+                "X-Amz-Target": "com.amazon.digitalmusiclocator.DigitalMusicLocatorServiceExternal.getStreamingURLs"
+              },
+              body: '{"contentIdList":[{"identifier":"d9e4e337-97ba-41a9-9f31-84a8bf99f1dc","identifierType":"COID"}],"bitRate":"HIGH","deviceToken":{"deviceId":"lg4msezd1e355heuc5b","deviceTypeId":"A16ZV8BU3SN1N3"},"appMetadata":{"appId":"WebCP","https":true,"appVersion":"1.0.0"},"clientMetadata":{"clientId":"WebCP","clientRequestId":"lgn9lrw623mgvi7k3et"}}',
+              signal: "[object AbortSignal]"
+            },
+            input: "https://example.com/bar/",
+            maxRetries: 1,
+            timestamp: /* @__PURE__ */ new Date("2023-04-19T05:40:17.914Z"),
+            fetchOptions: {
+              serviceId: null,
+              readErrorBody: 1
+            }
+          },
+          attemptInfo: {
+            currentTry: 1,
+            timestamp: /* @__PURE__ */ new Date("2023-04-19T05:40:17.914Z")
+          },
+          target: "[object FetchProviderImpl]"
+        });
+      });
+      addBenchmarks("logDebug", results);
+    });
+  });
+})();
+//# sourceMappingURL=benchmark.js.map