@amazon/vinyl 1.1.0 → 1.2.0

package/dist/test/benchmark.js

@@ -1,26 +1,24 @@
 "use strict";
 (() => {
   var __defProp = Object.defineProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-  // ../vinyl-util/dist/browserTestUtil/index.js
-  var __defProp2 = Object.defineProperty;
+  var __defProps = Object.defineProperties;
+  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
   var __getOwnPropSymbols = Object.getOwnPropertySymbols;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __propIsEnum = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  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))
-        __defNormalProp2(a, prop, b[prop]);
+        __defNormalProp(a, prop, b[prop]);
     if (__getOwnPropSymbols)
       for (var prop of __getOwnPropSymbols(b)) {
         if (__propIsEnum.call(b, prop))
-          __defNormalProp2(a, prop, b[prop]);
+          __defNormalProp(a, prop, b[prop]);
       }
     return a;
   };
+  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
   var __objRest = (source, exclude) => {
     var target = {};
     for (var prop in source)
@@ -33,7 +31,9 @@
       }
     return target;
   };
-  var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // ../vinyl-util/test/browserTestUtil/mock/createSpyFactory.ts
   var createSpy = jasmine.createSpy;
   function createSpyFactory(createFake) {
     return (key) => {
@@ -45,58 +45,66 @@
   function createSpy2(key) {
     return createSpy(String(key));
   }
+
+  // ../vinyl-util/test/browserTestUtil/mock/dom/lib.dom.ts
   var MockAbortSignal = class {
     constructor() {
-      __publicField2(this, "aborted", false);
-      __publicField2(this, "onabort", null);
-      __publicField2(this, "reason");
-      __publicField2(this, "throwIfAborted", createSpy2("throwIfAborted"));
-      __publicField2(this, "addEventListener", createSpy2("addEventListener"));
-      __publicField2(this, "removeEventListener", createSpy2(
+      __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"
       ));
-      __publicField2(this, "dispatchEvent", createSpy2("dispatchEvent"));
+      __publicField(this, "dispatchEvent", createSpy2("dispatchEvent"));
     }
   };
   var MockMediaSource = class {
     constructor() {
-      __publicField2(this, "activeSourceBuffers");
-      __publicField2(this, "duration", 0);
-      __publicField2(this, "onsourceclose", null);
-      __publicField2(this, "onsourceended", null);
-      __publicField2(this, "onsourceopen", null);
-      __publicField2(this, "readyState", "closed");
-      __publicField2(this, "sourceBuffers");
-      __publicField2(this, "addSourceBuffer", createSpy2("addSourceBuffer"));
-      __publicField2(this, "clearLiveSeekableRange", createSpy2(
+      __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"
       ));
-      __publicField2(this, "endOfStream", createSpy2("endOfStream"));
-      __publicField2(this, "removeSourceBuffer", createSpy2("removeSourceBuffer"));
-      __publicField2(this, "setLiveSeekableRange", createSpy2(
+      __publicField(this, "endOfStream", createSpy2("endOfStream"));
+      __publicField(this, "removeSourceBuffer", createSpy2("removeSourceBuffer"));
+      __publicField(this, "setLiveSeekableRange", createSpy2(
         "setLiveSeekableRange"
       ));
-      __publicField2(this, "addEventListener", createSpy2("addEventListener"));
-      __publicField2(this, "removeEventListener", createSpy2(
+      __publicField(this, "addEventListener", createSpy2("addEventListener"));
+      __publicField(this, "removeEventListener", createSpy2(
         "removeEventListener"
       ));
-      __publicField2(this, "dispatchEvent", createSpy2("dispatchEvent"));
+      __publicField(this, "dispatchEvent", createSpy2("dispatchEvent"));
     }
   };
+
+  // ../vinyl-util/test/browserTestUtil/mock/dom/globals.ts
   var MockMediaSourceGlobal = class extends MockMediaSource {
   };
-  __publicField2(MockMediaSourceGlobal, "canConstructInDedicatedWorker", false);
-  __publicField2(MockMediaSourceGlobal, "isTypeSupported", createSpy2(
+  __publicField(MockMediaSourceGlobal, "canConstructInDedicatedWorker", false);
+  __publicField(MockMediaSourceGlobal, "isTypeSupported", createSpy2(
     "isTypeSupported"
   ));
   var MockAbortSignalGlobal = class extends MockAbortSignal {
   };
-  __publicField2(MockAbortSignalGlobal, "abort", createSpy2("abort"));
-  __publicField2(MockAbortSignalGlobal, "any", createSpy2("any"));
-  __publicField2(MockAbortSignalGlobal, "timeout", createSpy2("timeout"));
+  __publicField(MockAbortSignalGlobal, "abort", createSpy2("abort"));
+  __publicField(MockAbortSignalGlobal, "any", createSpy2("any"));
+  __publicField(MockAbortSignalGlobal, "timeout", createSpy2("timeout"));
+
+  // ../vinyl-util/test/browserTestUtil/expect/expectNothing.ts
   function expectNothing() {
     expect(true).toBeTruthy();
   }
+
+  // ../vinyl-util/test/browserTestUtil/env/jasmineEnv.ts
   var nextTestTimeoutOverridden = false;
   function setTestTimeout(timeout) {
     let originalTimeout = null;
@@ -110,6 +118,8 @@
       if (nextTestTimeoutOverridden) nextTestTimeoutOverridden = false;
     });
   }
+
+  // ../vinyl-util/test/browserTestUtil/benchmark/Benchmark.ts
   var now;
   if (typeof window !== "undefined" && typeof window.performance !== "undefined" && typeof window.performance.now !== "undefined") {
     now = () => window.performance.now();
@@ -120,9 +130,9 @@
   }
   var BenchmarkRunResults = class {
     constructor(name) {
-      this.name = name;
-      __publicField2(this, "cycleResults", []);
-      __publicField2(this, "_totalSamples", 0);
+      __publicField(this, "name", name);
+      __publicField(this, "cycleResults", []);
+      __publicField(this, "_totalSamples", 0);
     }
     get totalSamples() {
       return this._totalSamples;
@@ -173,8 +183,11 @@
   };
   var RunResultsComparison = class {
     constructor(name, results) {
-      this.name = name;
-      __publicField2(this, "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;
       });
@@ -219,7 +232,7 @@
     maxCycleDuration: 0.5,
     cycles: 9
   };
-  var _Benchmark = class _Benchmark2 {
+  var _Benchmark = class _Benchmark {
     /**
      * Constructs a new Benchmark.
      *
@@ -229,14 +242,14 @@
      * @param options Optional configuration for the benchmark.
      */
     constructor(name, executor, options) {
-      this.name = name;
-      this.executor = executor;
-      __publicField2(this, "options");
+      __publicField(this, "name", name);
+      __publicField(this, "executor", executor);
+      __publicField(this, "options");
       this.options = __spreadValues(__spreadValues({}, defaultBenchmarkOptions), options);
     }
     async run() {
       const opts = this.options;
-      await _Benchmark2.semaphore;
+      await _Benchmark.semaphore;
       const warmupTimeMs = opts.warmupTime * 1e3;
       const cycleStart = now();
       let isAsync = false;
@@ -254,7 +267,7 @@
         }
         return results;
       })();
-      _Benchmark2.semaphore = resultsPromise;
+      _Benchmark.semaphore = resultsPromise;
       return await resultsPromise;
     }
     /**
@@ -280,7 +293,7 @@
       };
     }
   };
-  __publicField2(_Benchmark, "semaphore", nextFrame());
+  __publicField(_Benchmark, "semaphore", nextFrame());
   var Benchmark = _Benchmark;
   function benchmark(name, executor, options) {
     const benchmark2 = new Benchmark(name, executor, options);
@@ -307,7 +320,6 @@
     const sum = values.reduce((acc, value) => acc + value, 0);
     return sum / values.length;
   }
-  var createSpy3 = jasmine.createSpy;
 
   // test/benchmark/setup.ts
   function setupBenchmark() {
@@ -375,33 +387,15 @@
     return element2;
   }
 
-  // ../vinyl-util/dist/index.js
-  var __defProp3 = Object.defineProperty;
-  var __defProps = Object.defineProperties;
-  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
-  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-  var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues2 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp2.call(b, prop))
-        __defNormalProp3(a, prop, b[prop]);
-    if (__getOwnPropSymbols2)
-      for (var prop of __getOwnPropSymbols2(b)) {
-        if (__propIsEnum2.call(b, prop))
-          __defNormalProp3(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-  var __publicField3 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  // ../vinyl-util/src/util/type.ts
   function invariant() {
     return void 0;
   }
   function covariant() {
     return void 0;
   }
+
+  // ../vinyl-util/src/error/ErrorOrigin.ts
   var ErrorOrigin = {
     /**
      * The error originated from Vinyl and was reported from the uncaught exception or promise
@@ -446,11 +440,13 @@
      */
     DRM: "drm"
   };
+
+  // ../vinyl-util/src/error/ReportableError.ts
   var ReportableError = class _ReportableError extends Error {
-    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal") {
+    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal" /* FATAL */) {
       super(message);
-      this.origin = origin;
-      this.level = level;
+      __publicField(this, "origin", origin);
+      __publicField(this, "level", level);
       Object.setPrototypeOf(this, _ReportableError.prototype);
     }
     get [Symbol.toStringTag]() {
@@ -472,25 +468,38 @@
       };
     }
   };
+
+  // ../vinyl-util/src/error/IllegalArgumentError.ts
   var IllegalArgumentError = class _IllegalArgumentError extends ReportableError {
     constructor(message, isInternal = true) {
       super(message, isInternal ? ErrorOrigin.INTERNAL : ErrorOrigin.API);
-      this.isInternal = isInternal;
+      __publicField(this, "isInternal", isInternal);
       Object.setPrototypeOf(this, _IllegalArgumentError.prototype);
     }
     get [Symbol.toStringTag]() {
       return "IllegalArgumentError";
     }
   };
-  function getOrSet(map2, key, defaultValue) {
-    if (map2.has(key)) {
-      return map2.get(key);
+
+  // ../vinyl-util/src/util/map/map.ts
+  function getOrSet(map, key, defaultValue) {
+    if (map.has(key)) {
+      return map.get(key);
     } else {
       const value = defaultValue(key);
-      map2.set(key, value);
+      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;
+  }
+
+  // ../vinyl-util/src/util/string/string.ts
   var locale = {
     variableNotDefined: "Variable '{name}' is not defined"
   };
@@ -535,6 +544,7 @@
       return str;
     }
   }
+  var standardEntityValueToNames = flipMap(predefinedDecodeEntities);
   function eqStr(a, b, ignoreCase = false) {
     if (a == null && b == null) return true;
     if (a == null || b == null) return false;
@@ -552,12 +562,16 @@
       return str.substring(0, maxLength - indicator.length) + indicator;
     return str;
   }
-  function clamp(value, min2, max2) {
-    return Math.min(Math.max(value, min2), max2);
+
+  // ../vinyl-util/src/util/math/math.ts
+  function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
   }
   function roundToNearest(value, snap, offset = 0) {
     return Math.round((value - offset) / snap) * snap + offset;
   }
+
+  // ../vinyl-util/src/util/serialization/ParseError.ts
   function printStringPosition(str, index, options) {
     var _a3;
     const caret = (options == null ? void 0 : options.caret) || "^";
@@ -584,13 +598,19 @@
     out += " ".repeat(leadingChars) + caret;
     return out;
   }
+
+  // ../vinyl-util/src/util/string/StringReader.ts
   var StringReader = class {
     /**
      * @param data The string to read.
      */
     constructor(data) {
-      this.data = data;
-      __publicField3(this, "position", 0);
+      __publicField(this, "data", data);
+      /**
+       * The current cursor.
+       * This should always be between the range 0 and `data.length`
+       */
+      __publicField(this, "position", 0);
     }
     /**
      * Returns true if the current {@link position} is less than the source data's length.
@@ -793,9 +813,9 @@
         `${reason}${locale2.messageSeparator}${location2}`,
         ErrorOrigin.PARSING
       );
-      this.position = position;
-      this.reason = reason;
-      __publicField3(this, "location");
+      __publicField(this, "position", position);
+      __publicField(this, "reason", reason);
+      __publicField(this, "location");
       this.location = location2;
       Object.setPrototypeOf(this, _StringParseError.prototype);
     }
@@ -803,16 +823,20 @@
       return "StringParseError";
     }
     toJSON() {
-      return __spreadProps(__spreadValues2({}, super.toJSON()), {
+      return __spreadProps(__spreadValues({}, super.toJSON()), {
         position: this.position,
         location: this.location,
         reason: this.reason
       });
     }
   };
+
+  // ../vinyl-util/src/util/set/set.ts
   function union(a, b) {
     return /* @__PURE__ */ new Set([...a, ...b]);
   }
+
+  // ../vinyl-util/src/util/object/object.ts
   function ownKeys(obj) {
     if (!obj) return /* @__PURE__ */ new Set();
     if (typeof Reflect !== "undefined")
@@ -828,6 +852,8 @@
     const proto = Object.getPrototypeOf(value);
     return !proto || !Object.getPrototypeOf(proto);
   }
+
+  // ../vinyl-util/src/util/serialization/json.ts
   function toJson(value) {
     return toJsonInternal(value, /* @__PURE__ */ new Set());
   }
@@ -876,6 +902,8 @@
       }
     }
   }
+
+  // ../vinyl-util/src/util/serialization/stringifyForPrint.ts
   function stringifyForPrint(value, maxLength, indicator = "\u2026") {
     let str = JSON.stringify(
       toJson(value),
@@ -898,6 +926,8 @@
     if (maxLength) str = truncate(str, maxLength, indicator);
     return str;
   }
+
+  // ../vinyl-util/src/util/serialization/primitives.ts
   function parseBoolean(str) {
     return str === "true" || str === "1";
   }
@@ -912,10 +942,12 @@
     if (!Number.isFinite(value)) return null;
     return value;
   }
+
+  // ../vinyl-util/src/util/collection/LinkedList.ts
   var LinkedList = class {
     constructor() {
-      __publicField3(this, "_head", null);
-      __publicField3(this, "_tail", null);
+      __publicField(this, "_head", null);
+      __publicField(this, "_tail", null);
     }
     /**
      * Returns the current head.
@@ -1218,9 +1250,11 @@
       };
     }
   };
+
+  // ../vinyl-util/src/event/Signal.ts
   var SignalImpl = class {
     constructor() {
-      __publicField3(this, "handlers", /* @__PURE__ */ new LinkedList());
+      __publicField(this, "handlers", new LinkedList());
     }
     get empty() {
       return this.handlers.empty;
@@ -1269,16 +1303,20 @@
   function signal() {
     return new SignalImpl();
   }
+
+  // ../vinyl-util/src/logging/LogTarget.ts
   var counter = 0;
   function createLogPrefix(target) {
     const name = typeof target === "string" ? target : target[Symbol.toStringTag];
     return `${name}/${++counter}`;
   }
+
+  // ../vinyl-util/src/event/EventHost.ts
   var EventHostImpl = class {
     constructor() {
-      __publicField3(this, "logPrefix", /* @__PURE__ */ createLogPrefix(this));
-      __publicField3(this, "signals", /* @__PURE__ */ new Map());
-      __publicField3(this, "__eventMapType", /* @__PURE__ */ covariant());
+      __publicField(this, "logPrefix", createLogPrefix(this));
+      __publicField(this, "signals", /* @__PURE__ */ new Map());
+      __publicField(this, "__eventMapType", covariant());
     }
     get [Symbol.toStringTag]() {
       return "EventHostImpl";
@@ -1306,6 +1344,8 @@
       this.signals.clear();
     }
   };
+
+  // ../vinyl-util/src/util/collection/array.ts
   function last(arrayLike) {
     if (!arrayLike) return void 0;
     return arrayLike[arrayLike.length - 1];
@@ -1316,6 +1356,8 @@
     array.splice(index, 1);
     return true;
   }
+
+  // ../vinyl-util/src/util/collection/typedArray.ts
   function cloneTypedArray(array) {
     return new array.constructor(array);
   }
@@ -1333,16 +1375,20 @@
   function isTypedArray(value) {
     return typedArrayTypes.some((type) => value instanceof type);
   }
+
+  // ../vinyl-util/src/core/cloneable.ts
   function isCloneable(value) {
     return value != null && typeof value === "object" && "clone" in value && typeof value.clone === "function" && value.clone.length === 0;
   }
+
+  // ../vinyl-util/src/util/object/mergeDeep.ts
   var locale3 = {
     cyclicRefError: "Cyclic reference found at: {path}",
     mergeReferenceError: `No merge rule found at {path} for "{source}" and reference copy not allowed`
   };
   function mergeDeep(sources, options) {
     if (!sources.length) return void 0;
-    const finalOpts = __spreadValues2(__spreadValues2({}, defaultMergeOptions), options);
+    const finalOpts = __spreadValues(__spreadValues({}, defaultMergeOptions), options);
     const stack = new PropStack();
     const n = sources.length;
     if (n === 1)
@@ -1355,9 +1401,15 @@
   }
   var PropStack = class {
     constructor() {
-      __publicField3(this, "refsA", /* @__PURE__ */ new Set());
-      __publicField3(this, "refsB", /* @__PURE__ */ new Set());
-      __publicField3(this, "propStack", []);
+      /**
+       * 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 .
@@ -1387,7 +1439,7 @@
   };
   function _mergeDeep(sourceA, sourceB, propStack, prop, options) {
     if (typeof sourceB !== "object" || sourceB === null) return sourceB;
-    const merge2 = (sourceA2, sourceB2, prop2) => {
+    const merge = (sourceA2, sourceB2, prop2) => {
       return _mergeDeep(sourceA2, sourceB2, propStack, prop2, options);
     };
     for (const rule of options.rules) {
@@ -1396,7 +1448,7 @@
         const result = rule.merge(
           rule.matches(sourceA) ? sourceA : void 0,
           sourceB,
-          merge2
+          merge
         );
         propStack.pop();
         return result;
@@ -1431,15 +1483,15 @@
     matches(object) {
       return Array.isArray(object);
     },
-    merge(sourceA, sourceB, merge2) {
+    merge(sourceA, sourceB, merge) {
       const out = [];
       if (sourceA) {
         for (const element2 of sourceA) {
-          out.push(merge2(void 0, element2, out.length));
+          out.push(merge(void 0, element2, out.length));
         }
       }
       for (const element2 of sourceB) {
-        out.push(merge2(void 0, element2, out.length));
+        out.push(merge(void 0, element2, out.length));
       }
       return out;
     }
@@ -1448,15 +1500,15 @@
     matches(object) {
       return isPlainObject(object);
     },
-    merge(sourceA, sourceB, merge2) {
+    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] = merge2(sourceA[key], sourceB[key], key);
+          out[key] = merge(sourceA[key], sourceB[key], key);
         } else if (sourceA && key in sourceA) {
-          out[key] = merge2(void 0, sourceA[key], key);
+          out[key] = merge(void 0, sourceA[key], key);
         } else {
-          out[key] = merge2(void 0, sourceB[key], key);
+          out[key] = merge(void 0, sourceB[key], key);
         }
       }
       return out;
@@ -1482,7 +1534,7 @@
     matches(object) {
       return object instanceof Map;
     },
-    merge(sourceA, sourceB, merge2) {
+    merge(sourceA, sourceB, merge) {
       var _a3;
       const out = /* @__PURE__ */ new Map();
       for (const key of /* @__PURE__ */ new Set([
@@ -1490,11 +1542,11 @@
         ...sourceB.keys()
       ])) {
         if (sourceB.has(key) && (sourceA == null ? void 0 : sourceA.has(key))) {
-          out.set(key, merge2(sourceA.get(key), sourceB.get(key), key));
+          out.set(key, merge(sourceA.get(key), sourceB.get(key), key));
         } else if (sourceA == null ? void 0 : sourceA.has(key)) {
-          out.set(key, merge2(void 0, sourceA.get(key), key));
+          out.set(key, merge(void 0, sourceA.get(key), key));
         } else {
-          out.set(key, merge2(void 0, sourceB.get(key), key));
+          out.set(key, merge(void 0, sourceB.get(key), key));
         }
       }
       return out;
@@ -1504,12 +1556,12 @@
     matches(object) {
       return object instanceof Set;
     },
-    merge(sourceA, sourceB, merge2) {
+    merge(sourceA, sourceB, merge) {
       var _a3;
       return new Set(
         [...(_a3 = sourceA == null ? void 0 : sourceA.values()) != null ? _a3 : [], ...sourceB.values()].map(
           (element2, index) => {
-            return merge2(void 0, element2, index);
+            return merge(void 0, element2, index);
           }
         )
       );
@@ -1545,11 +1597,8 @@
       urlMergeRule
     ]
   };
-  function merge(...sources) {
-    if (!sources.length) return void 0;
-    if (Array.isArray(sources[0])) return Array.prototype.concat(...sources);
-    return Object.assign({}, ...sources);
-  }
+
+  // ../vinyl-util/src/error/IllegalStateError.ts
   var IllegalStateError = class _IllegalStateError extends ReportableError {
     get [Symbol.toStringTag]() {
       return "IllegalStateError";
@@ -1559,6 +1608,8 @@
       Object.setPrototypeOf(this, _IllegalStateError.prototype);
     }
   };
+
+  // ../vinyl-util/src/core/disposable.ts
   function isDisposable(value) {
     return value != null && typeof value.dispose === "function" && value.dispose.length === 0;
   }
@@ -1571,16 +1622,18 @@
       Object.setPrototypeOf(this, _DisposedError.prototype);
     }
   };
+
+  // ../vinyl-util/src/util/object/lazy.ts
   var LazyImpl = class {
     /**
      * @param factory A factory function that will be invoked at most once.
      */
     constructor(factory) {
-      this.factory = factory;
-      __publicField3(this, "_constructing", false);
-      __publicField3(this, "_constructed", false);
-      __publicField3(this, "disposed", false);
-      __publicField3(this, "_value");
+      __publicField(this, "factory", factory);
+      __publicField(this, "_constructing", false);
+      __publicField(this, "_constructed", false);
+      __publicField(this, "disposed", false);
+      __publicField(this, "_value");
     }
     get constructed() {
       return this._constructed;
@@ -1621,6 +1674,8 @@
   function lazy(factory) {
     return new LazyImpl(factory);
   }
+
+  // ../vinyl-util/src/util/object/clone.ts
   function clone(target, options) {
     var _a3, _b, _c;
     return mergeDeep([target], {
@@ -1631,16 +1686,18 @@
   function toMergeRule(cloneRule) {
     return {
       matches: cloneRule.matches,
-      merge(_sourceA, sourceB, merge2) {
+      merge(_sourceA, sourceB, merge) {
         return cloneRule.clone(
           sourceB,
           (source, prop) => {
-            return merge2(void 0, source, prop);
+            return merge(void 0, source, prop);
           }
         );
       }
     };
   }
+
+  // ../vinyl-util/src/error/ValidationError.ts
   var ValidationError = class _ValidationError extends ReportableError {
     /**
      * @param message The validation error message.
@@ -1649,19 +1706,21 @@
      */
     constructor(message, origin = ErrorOrigin.API, path = []) {
       super(message, origin);
-      this.path = path;
+      __publicField(this, "path", path);
       Object.setPrototypeOf(this, _ValidationError.prototype);
     }
     get [Symbol.toStringTag]() {
       return "ValidationError";
     }
     toJSON() {
-      return __spreadProps(__spreadValues2({}, super.toJSON()), {
+      return __spreadProps(__spreadValues({}, super.toJSON()), {
         origin: this.origin,
         path: this.path
       });
     }
   };
+
+  // ../vinyl-util/src/util/iteration/iterable.ts
   function mapIter(iterable, transform) {
     const it2 = iterable[Symbol.iterator]();
     return {
@@ -1678,13 +1737,34 @@
       }
     };
   }
+
+  // ../vinyl-util/src/util/collection/LruCache.ts
   var LruCache = class {
     constructor(initialCapacity) {
-      __publicField3(this, "cache", /* @__PURE__ */ new Map());
-      __publicField3(this, "list", /* @__PURE__ */ new LinkedList());
-      __publicField3(this, "onEvicting", null);
-      __publicField3(this, "onEvict", null);
-      __publicField3(this, "_capacity", 0);
+      /**
+       * 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() {
@@ -1813,6 +1893,8 @@
       return "LruCache";
     }
   };
+
+  // ../vinyl-util/src/util/fun/memoize.ts
   function memoize(inner, keyProvider, capacity = 500) {
     if (!keyProvider) {
       let cached = false;
@@ -1879,6 +1961,8 @@
       );
     }
   }
+
+  // ../vinyl-util/src/util/date/date.ts
   var locale4 = {
     invalidDateError: `"{value}" is an invalid date`
   };
@@ -1897,6 +1981,8 @@
   function stringifyDate(value) {
     return value.toISOString();
   }
+
+  // ../vinyl-util/src/global/environment.ts
   function getLocation() {
     return typeof location === "object" ? location : defaultLocation;
   }
@@ -1905,7 +1991,9 @@
     search: "",
     href: ""
   };
-  var getSearchParams = /* @__PURE__ */ memoize(
+
+  // ../vinyl-util/src/util/browser/searchParams.ts
+  var getSearchParams = memoize(
     (search = getLocationSearch()) => {
       const url = new URL("about:blank");
       url.search = search;
@@ -1917,9 +2005,11 @@
   function getLocationSearch() {
     return getLocation().search;
   }
+
+  // ../vinyl-util/src/global/globalRegistry.ts
   var GlobalRegistry = class {
     constructor() {
-      __publicField3(this, "registry", []);
+      __publicField(this, "registry", []);
     }
     /**
      * Returns the number of references currently in the registry.
@@ -1963,12 +2053,12 @@
   var globalRefDebug = false;
   var GlobalRefImpl = class {
     constructor(defaultInitializer) {
-      this.defaultInitializer = defaultInitializer;
-      __publicField3(this, "_value");
-      __publicField3(this, "_initialized", false);
-      __publicField3(this, "constructing", false);
-      __publicField3(this, "initializer");
-      __publicField3(this, "lastInitStack", null);
+      __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() {
@@ -2034,10 +2124,10 @@ ${this.lastInitStack}` : "";
   };
   var GlobalRefOverride = class _GlobalRefOverride {
     constructor(original, defaultInitializer, setInitializer) {
-      this.original = original;
-      this.defaultInitializer = defaultInitializer;
-      this.setInitializer = setInitializer;
-      __publicField3(this, "initializer");
+      __publicField(this, "original", original);
+      __publicField(this, "defaultInitializer", defaultInitializer);
+      __publicField(this, "setInitializer", setInitializer);
+      __publicField(this, "initializer");
       this.initializer = defaultInitializer;
     }
     get initialized() {
@@ -2071,22 +2161,26 @@ ${this.lastInitStack}` : "";
   function globalRef(init) {
     return getGlobalRegistry().register(new GlobalRefImpl(init));
   }
-  function getLogLevelFromSearch(search = getLocationSearch(), defaultLevel = 3) {
+
+  // ../vinyl-util/src/logging/getLogLevelFromSearch.ts
+  function getLogLevelFromSearch(search = getLocationSearch(), defaultLevel = 3 /* WARN */) {
     var _a3;
     const str = getSearchParams(search).get("vinylLogLevel");
     if (!str) return defaultLevel;
     return (_a3 = parseLogLevel(str)) != null ? _a3 : defaultLevel;
   }
+
+  // ../vinyl-util/src/logging/Logger.ts
   var LoggerImpl = class extends EventHostImpl {
-    constructor(logLevel = 1) {
+    constructor(logLevel = 1 /* DEBUG */) {
       super();
-      this.logLevel = logLevel;
+      __publicField(this, "logLevel", logLevel);
     }
     get [Symbol.toStringTag]() {
       return "Logger";
     }
     log(target, level, ...messages) {
-      if (level === 5 || level < this.logLevel) return;
+      if (level === 5 /* NONE */ || level < this.logLevel) return;
       this.dispatch("log", {
         level,
         messages: toJson(messages),
@@ -2094,25 +2188,23 @@ ${this.lastInitStack}` : "";
       });
     }
   };
-  var loggerRef = /* @__PURE__ */ globalRef(
+  var loggerRef = globalRef(
     () => new LoggerImpl(
       // The logger is initialized to VERBOSE if vinylLogLevel=verbose is in the query string
       // Otherwise use DEBUG.
-      getLogLevelFromSearch() === 0 ? 0 : 1
-      /* DEBUG */
+      getLogLevelFromSearch() === 0 /* VERBOSE */ ? 0 /* VERBOSE */ : 1 /* DEBUG */
     )
   );
   function logDebug(target, ...messages) {
-    loggerRef.value.log(target, 1, ...messages);
+    loggerRef.value.log(target, 1 /* DEBUG */, ...messages);
   }
   var strToLogLevel = {
-    verbose: 0,
-    debug: 1,
-    info: 2,
-    warn: 3,
-    error: 4,
-    none: 5
-    /* NONE */
+    verbose: 0 /* VERBOSE */,
+    debug: 1 /* DEBUG */,
+    info: 2 /* INFO */,
+    warn: 3 /* WARN */,
+    error: 4 /* ERROR */,
+    none: 5 /* NONE */
   };
   function parseLogLevel(str) {
     var _a3;
@@ -2288,1870 +2380,1233 @@ ${this.lastInitStack}` : "";
     });
   });
 
-  // ../vinyl-validation/dist/index.js
-  var __defProp4 = Object.defineProperty;
-  var __defProps2 = Object.defineProperties;
-  var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols3 = Object.getOwnPropertySymbols;
-  var __hasOwnProp3 = Object.prototype.hasOwnProperty;
-  var __propIsEnum3 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp4 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues3 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp3.call(b, prop))
-        __defNormalProp4(a, prop, b[prop]);
-    if (__getOwnPropSymbols3)
-      for (var prop of __getOwnPropSymbols3(b)) {
-        if (__propIsEnum3.call(b, prop))
-          __defNormalProp4(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
-  var __publicField4 = (obj, key, value) => __defNormalProp4(obj, typeof key !== "symbol" ? key + "" : key, value);
-  var validatorLocale = {
-    /**
-     * The expectation template string with the following replacement tokens:
-     *
-     * `{expected}` - The expected description.
-     * `{actual}` - The actual value.
-     * `{path}` - The path, dot separated.
-     */
-    template: "Expected: {expected}, but was: {actual}. At: {path}"
-  };
-  function createValidationExpectationMessage(expectationMessage, input, path, inputStringify = (input2) => stringifyForPrint(input2, 500)) {
-    return substitute(validatorLocale.template, {
-      expected: expectationMessage,
-      actual: inputStringify(input),
-      path: path.join(".")
-    });
+  // ../vinyl-mpd-parser/src/xmlns/mpeg/cenc/2013.ts
+  var CENC_NAMESPACE_URI = "urn:mpeg:cenc:2013";
+
+  // ../vinyl-mpd-parser/src/xmlns/microsoft/playready.ts
+  var PLAY_READY_NAMESPACE_URI = "urn:microsoft:playready";
+
+  // ../vinyl-mpd-parser/src/error/parsingError.ts
+  function throwParsingError(message) {
+    throw new ValidationError(message, ErrorOrigin.PARSING);
   }
-  function createValidator(expectationMessage, isValid, inputStringify = (input) => stringifyForPrint(input, 500)) {
-    return {
-      description: expectationMessage,
-      isValid(input) {
-        return isValid(input);
-      },
-      validate(input, _, path = []) {
-        if (!isValid(input)) {
-          return [
-            {
-              message: createValidationExpectationMessage(
-                expectationMessage,
-                input,
-                path,
-                inputStringify
-              ),
-              path
-            }
-          ];
-        }
-        return [];
-      },
-      assert: (input, origin, path = []) => {
-        if (!isValid(input)) {
-          throw new ValidationError(
-            createValidationExpectationMessage(
-              expectationMessage,
-              input,
-              path,
-              inputStringify
-            ),
-            origin,
-            path
-          );
-        }
-      }
-    };
+
+  // ../vinyl-mpd-parser/src/media/ratio.ts
+  var ratioRegExp = /^([0-9]*):([0-9]*)$/;
+  function parseRatio(str) {
+    const match = str ? ratioRegExp.exec(str) : null;
+    if (!match) throwParsingError(`invalid ratio format: ${str}`);
+    return [parseInt(match[1] || "1"), parseInt(match[2] || "1")];
   }
-  function createDeepValidator(description, validate) {
-    return {
-      description,
-      isValid(input) {
-        return validate(input, { all: false }, []).length === 0;
-      },
-      validate(input, options, path = []) {
-        return validate(input, options != null ? options : { all: false }, path);
-      },
-      assert: (input, origin, path = []) => {
-        const errors = validate(input, { all: false }, path);
-        if (errors.length) {
-          const error = errors[0];
-          throw new ValidationError(error.message, origin, error.path);
-        }
-      }
-    };
+  function stringifyRatio(value) {
+    return `${value[0]}:${value[1]}`;
   }
-  var locale5 = {
-    /**
-     * {value} The child validators' descriptions, joined with `separator`.
-     *
-     * groupings of and validators is unimportant,
-     * and(and(a, b), c) is the same as and(a, and(b, c)), so `a & b & c` is an accurate
-     * representation for either.
-     */
-    template: "{value}",
-    /**
-     * The separator with which to join child validator descriptions.
-     */
-    separator: " & "
-  };
-  function andValidators(...validators) {
-    return createDeepValidator(
-      substitute(locale5.template, {
-        value: validators.map((v) => v.description).join(locale5.separator)
-      }),
-      (input, options, path) => {
-        for (const validator of validators) {
-          const errors = validator.validate(input, options, path);
-          if (errors.length) return errors;
-        }
-        return [];
-      }
-    );
+
+  // ../vinyl-mpd-parser/src/media/frameRate.ts
+  var framerateRegexp = /^(\d+)(?:\/(\d+))?$/;
+  function parseFrameRate(str) {
+    const match = str ? framerateRegexp.exec(str) : null;
+    if (!match) throwParsingError(`invalid frame rate: '${str}'`);
+    return [parseInt(match[1]), parseInt(match[2] || "1")];
   }
-  var locale22 = {
-    /**
-     * {value} - The child validators' descriptions, joined with `separator`.
-     */
-    template: "({value})",
-    /**
-     * The separator with which to join child validator descriptions.
-     */
-    separator: " | "
-  };
-  function orValidators(...validators) {
-    const description = substitute(locale22.template, {
-      value: validators.map((v) => v.description).join(locale22.separator)
+  function stringifyFrameRate(value) {
+    return value[1] === 1 ? value[0].toString() : `${value[0]}/${value[1]}`;
+  }
+
+  // ../vinyl-mpd-parser/src/media/byteRange.ts
+  var byteRangeExp = /^(-?[0-9]+)-(-?[0-9]*)$/;
+  function parseByteRange(str) {
+    const match = str ? byteRangeExp.exec(str) : null;
+    if (!match) throwParsingError(`invalid byte range: '${str}'`);
+    let start = parseInt(match[1]);
+    if (start < 0) start >>>= 0;
+    let end = parseIntSafe(match[2]);
+    if (end != null && end < 0) end = end >>> 0;
+    return [start, end];
+  }
+  function stringifyByteRange(value) {
+    const end = value[1];
+    return `${value[0]}-${end == null ? "" : end}`;
+  }
+
+  // ../vinyl-xml/src/xml/xmlRules.ts
+  function element(rules, options) {
+    return __spreadProps(__spreadValues({
+      type: "element" /* ELEMENT */,
+      localPart: void 0,
+      namespaceUri: void 0,
+      required: false
+    }, options), {
+      rules
     });
-    return createDeepValidator(description, (input, options, path) => {
-      let longestErrors = [];
-      let longestPath = 0;
-      for (const validator of validators) {
-        const errors = validator.validate(input, options, path);
-        if (!errors.length) return errors;
-        const pathLength = errors.reduce(
-          (max, m) => Math.max(m.path.length, max),
-          0
-        );
-        if (pathLength >= longestPath) {
-          longestErrors = errors;
-          longestPath = pathLength;
-        }
-      }
-      return longestPath > path.length ? longestErrors : [
-        {
-          message: createValidationExpectationMessage(
-            description,
-            input,
-            path
-          ),
-          path
-        }
-      ];
+  }
+  function elements(rules, options) {
+    return __spreadProps(__spreadValues({
+      type: "elements" /* ELEMENTS */,
+      localPart: void 0,
+      namespaceUri: void 0,
+      minOccurs: 0,
+      maxOccurs: null,
+      useEmptyArrays: false
+    }, options), {
+      rules
     });
   }
-  var requiredValidationOptions = {
-    optional: false
-  };
-  var SchemaBase = class {
-    constructor(currentValidator, previousSchema, operation) {
-      this.currentValidator = currentValidator;
-      this.previousSchema = previousSchema;
-      this.operation = operation;
-      __publicField4(this, "__type", /* @__PURE__ */ invariant());
-      __publicField4(this, "validator");
-      __publicField4(this, "_options", requiredValidationOptions);
-      __publicField4(this, "assert", (input, origin, path) => {
-        this.validator.assert(input, origin, path);
-      });
-      __publicField4(this, "isValid", (input) => this.validator.isValid(input));
-      __publicField4(this, "validate", (input, options, path) => this.validator.validate(input, options, path));
-      this.validator = operation == null ? currentValidator : operation(previousSchema, currentValidator);
-    }
-    get options() {
-      return this._options;
+  function characters(parse, stringify2) {
+    return { type: "characters" /* CHARACTERS */, parse, stringify: stringify2 };
+  }
+  var charactersString = characters((i) => i, stringify);
+  function attr(parse, stringify2, options) {
+    return __spreadProps(__spreadValues({
+      type: "attribute" /* ATTRIBUTE */,
+      localPart: void 0,
+      namespaceUri: null,
+      required: false,
+      default: void 0
+    }, options), {
+      parse,
+      stringify: stringify2
+    });
+  }
+  function attrString(options) {
+    return attr((i) => i, stringify, options);
+  }
+  function attrInt(options) {
+    return attr(parseInt, stringify, options);
+  }
+  function attrFloat(options) {
+    return attr(parseFloat, stringify, options);
+  }
+  function attrBoolean(options) {
+    return attr(parseBoolean, stringify, options);
+  }
+  function attrDateTime(options) {
+    return attr(parseDate, stringifyDate, options);
+  }
+
+  // ../vinyl-xml/src/xml/XmlSchemaError.ts
+  var xmlSchemaErrorLocale = {
+    atLeastElements: "Expected at least {expected} occurrences of {property} but was {actual}",
+    atMostElements: "Expected at most {expected} occurrences of {property} but was {actual}",
+    cyclicReferences: "Cyclic reference detected",
+    requiredAttribute: `Attribute '{property}' is required`
+  };
+  var XmlSchemaError = class _XmlSchemaError extends ReportableError {
+    get [Symbol.toStringTag]() {
+      return "XmlSchemaError";
     }
-    get description() {
-      return this.validator.description;
+    constructor(message) {
+      super(message, ErrorOrigin.PARSING);
+      Object.setPrototypeOf(this, _XmlSchemaError.prototype);
     }
-    /**
-     * Clones this schema, transforming all validators with the given mutator.
-     *
-     * @param transform A transformer which takes an existing validator in the chain and returns
-     * a new one. Validators should be considered to be immutable; transform should not change the
-     * input but instead return a new validator.
-     */
-    clone(transform = (v) => v) {
-      const cloned = this.operation ? this.self(
-        transform(this.currentValidator),
-        this.previousSchema.clone(transform),
-        this.operation
-      ) : this.self(transform(this.currentValidator));
-      cloned._options = this._options;
-      return cloned;
+  };
+
+  // ../vinyl-xml/src/xml/parseXml.ts
+  var XMLNS = "http://www.w3.org/2000/xmlns/";
+  var LT = char("<");
+  var GT = char(">");
+  var EQ = char("=");
+  var SLASH = char("/");
+  var COLON = char(":");
+  var QMARK = char("?");
+  var EXCL = char("!");
+  var APOS = char("'");
+  var QUOT = char('"');
+  var QUOTES = /* @__PURE__ */ new Set([APOS, QUOT]);
+  function parseXml(str, handler) {
+    const c = new StringReader(str);
+    let current = {
+      qName: "#document",
+      namespaceMap: /* @__PURE__ */ new Map(),
+      defaultNamespaceUri: null
+    };
+    const stack = [current];
+    const namespaceLookup = (prefix) => {
+      if (!prefix) return current.defaultNamespaceUri;
+      for (let i = stack.length - 1; i >= 0; i--) {
+        const map = stack[i].namespaceMap;
+        if (map.has(prefix)) return stack[i].namespaceMap.get(prefix);
+      }
+      return null;
+    };
+    try {
+      handler.startDocument();
+    } catch (e) {
+      c.err(e.message);
     }
-    self(current, previous, operation) {
-      if (this.constructor.length > 3) {
-        throw new IllegalArgumentError(
-          "constructor should have at most three required arguments"
-        );
+    while (c.hasNext()) {
+      const charsStart = c.untilChar(LT);
+      if (charsStart < c.position) {
+        const chars = str.substring(charsStart, c.position);
+        try {
+          handler.textNode(chars);
+        } catch (e) {
+          c.err(e.message);
+        }
+      }
+      if (!c.hasNext()) break;
+      c.next();
+      if (c.charIf(SLASH)) {
+        c.white();
+        const name = readQName(c);
+        if (name.qName !== current.qName)
+          c.err(`Expected </${current.qName}> but was </${name.qName}>`);
+        stack.pop();
+        current = last(stack);
+        c.white();
+        c.readChar(GT);
+        try {
+          handler.endElement();
+        } catch (e) {
+          c.err(e.message);
+        }
+      } else if (c.charIf(QMARK)) {
+        untilTagClose(c);
+      } else if (c.charIf(EXCL)) {
+        if (c.charIf(
+          45
+          /* - */
+        )) {
+          c.readChar(45);
+          c.untilString("-->");
+          c.read("-->");
+        } else if (c.stringIf("[CDATA[")) {
+          const charsStart2 = c.untilString("]]>");
+          try {
+            handler.cDataNode(str.substring(charsStart2, c.position));
+          } catch (e) {
+            c.err(e.message);
+          }
+          c.read("]]>");
+        } else {
+          untilTagClose(c);
+        }
+      } else {
+        const name = readQName(c);
+        current = {
+          qName: name.qName,
+          namespaceMap: /* @__PURE__ */ new Map(),
+          defaultNamespaceUri: current.defaultNamespaceUri
+        };
+        stack.push(current);
+        const attributes = xmlAttributes(c, current);
+        name.namespaceUri = namespaceLookup(name.prefix);
+        for (const attributesKey in attributes) {
+          const value = attributes[attributesKey];
+          const name2 = value.name;
+          if (name2.prefix && !name2.namespaceUri) {
+            name2.namespaceUri = namespaceLookup(name2.prefix);
+          }
+        }
+        try {
+          handler.startElement(name, attributes);
+        } catch (e) {
+          c.err(e.message);
+        }
+        if (c.charIf(SLASH)) {
+          c.readChar(GT);
+          stack.pop();
+          current = last(stack);
+          try {
+            handler.endElement();
+          } catch (e) {
+            c.err(e.message);
+          }
+        } else {
+          c.readChar(GT);
+        }
       }
-      return new this.constructor(current, previous, operation);
     }
-    /**
-     * Constructs a new schema with a validator chaining the current validator with the
-     * provided next in an AND operation.
-     *
-     * @param nextValidator The validator to run after the current.
-     * @return Returns a new Schema instance the same class with a new validator chaining the
-     * current validator with the given next in an AND operation.
-     */
-    chain(nextValidator) {
-      return this.self(nextValidator, this, andValidators);
+    try {
+      return handler.endDocument();
+    } catch (e) {
+      return c.err(e.message);
     }
-    optional() {
-      const cloned = this.clone();
-      cloned._options = __spreadProps2(__spreadValues3({}, cloned.options), {
-        optional: true
-      });
-      return cloned;
+  }
+  function readAttributeValue(c) {
+    const quote = c.next();
+    if (!QUOTES.has(quote)) c.err(`Expected ' or "`);
+    const value = c.substringUntil((charCode) => charCode === quote);
+    c.readChar(quote);
+    return decodeEntities(value);
+  }
+  function untilTagClose(c) {
+    while (true) {
+      c.until((c2) => c2 === APOS || c2 === QUOT || c2 === GT);
+      const char2 = c.next();
+      if (QUOTES.has(char2)) {
+        c.untilChar(char2);
+        c.next();
+      } else {
+        break;
+      }
     }
-    required() {
-      const cloned = this.clone();
-      cloned._options = __spreadProps2(__spreadValues3({}, cloned.options), {
-        optional: false
-      });
-      return cloned;
+  }
+  function isNameChar(charCode) {
+    if (charCode >= 97) {
+      if (charCode >= 183) {
+        if (charCode >= 768) {
+          if (charCode >= 8255) {
+            return charCode <= 8256;
+          } else {
+            return charCode <= 879;
+          }
+        } else {
+          return charCode === 183;
+        }
+      } else {
+        return charCode <= 122;
+      }
+    } else {
+      if (charCode >= 95) {
+        return charCode === 95;
+      } else {
+        if (charCode >= 65) {
+          return charCode <= 90;
+        } else {
+          if (charCode >= 45) {
+            if (charCode >= 48) {
+              return charCode <= 57;
+            } else {
+              return charCode <= 46;
+            }
+          } else {
+            return false;
+          }
+        }
+      }
     }
-  };
-  var locale32 = {
-    null: "null",
-    nullish: "nullish",
-    undefined: "undefined"
-  };
-  var valueValidators = {
-    any() {
-      return createValidator("", () => true);
-    },
-    /**
-     * Creates a validator that asserts that the input is nullish.
-     */
-    nullish() {
-      return createValidator(locale32.nullish, (input) => input == null);
-    },
-    /**
-     * Creates a validator that asserts that the input is strictly null.
-     */
-    null() {
-      return createValidator(locale32.null, (input) => input === null);
-    },
-    /**
-     * Creates a validator that asserts that the input is strictly undefined.
-     */
-    undefined() {
-      return createValidator(locale32.undefined, (input) => input === void 0);
+  }
+  function readQName(reader) {
+    const prefixOrLocalName = reader.substringWhile(isNameChar);
+    let prefix, localPart, name;
+    if (reader.charIf(COLON)) {
+      prefix = prefixOrLocalName;
+      localPart = reader.substringWhile(isNameChar);
+      name = `${prefix}:${localPart}`;
+    } else {
+      prefix = null;
+      localPart = prefixOrLocalName;
+      name = localPart;
+    }
+    return { prefix, localPart, qName: name, namespaceUri: null };
+  }
+  function xmlAttributes(reader, stackElement) {
+    const attributes = {};
+    while (true) {
+      reader.white();
+      if (!isNameChar(reader.peek)) break;
+      const name = readQName(reader);
+      reader.white();
+      let value = "";
+      if (reader.charIf(EQ)) {
+        reader.white();
+        value = readAttributeValue(reader);
+      } else {
+      }
+      if (name.prefix === "xmlns") {
+        name.namespaceUri = XMLNS;
+        stackElement.namespaceMap.set(
+          name.localPart,
+          value === "" ? null : value
+        );
+      } else if (!name.prefix && name.localPart === "xmlns") {
+        name.namespaceUri = XMLNS;
+        stackElement.defaultNamespaceUri = !value ? null : value;
+      }
+      if (attributes[name.qName] != null)
+        reader.err(`Attribute '${name.qName}' is already specified.`);
+      attributes[name.qName] = { name, value };
     }
+    return attributes;
+  }
+
+  // ../vinyl-xml/src/xml/mergeXmlRules.ts
+  var locale5 = {
+    illegalRuleOverrideTypeError: "Cannot override the rule {property} of type {sourceType} with a rule of type {overrideType}",
+    illegalQNameOverrideError: "Cannot override the rule {property} with a different localPart or namespace"
   };
-  var ValueSchema = class _ValueSchema extends SchemaBase {
-    /**
-     * Prepends this validator allowing for null or undefined.
-     */
-    maybe() {
-      return this.or(valueValidators.nullish());
+  function mergeXmlRules(...rules) {
+    let finalRule = rules[0];
+    for (let i = 1; i < rules.length; i++) {
+      finalRule = plainObjectMergeRule.merge(
+        finalRule,
+        rules[i],
+        mergeXmlRule
+      );
     }
-    /**
-     * Prepends this validator allowing for null.
-     */
-    orNull() {
-      return this.or(valueValidators.null());
+    return finalRule;
+  }
+  function mergeXmlRule(sourceA, sourceB, prop) {
+    var _a3, _b, _c, _d;
+    if (sourceA == null) return sourceB;
+    const sourceAIsLazy = typeof sourceA === "function";
+    const sourceBIsLazy = typeof sourceB === "function";
+    if (sourceAIsLazy || sourceBIsLazy) {
+      return () => {
+        const a = sourceAIsLazy ? sourceA() : sourceA;
+        const b = sourceBIsLazy ? sourceB() : sourceB;
+        return mergeXmlRule(a, b, prop);
+      };
     }
-    /**
-     * Prepends this validator allowing for undefined.
-     */
-    orUndefined() {
-      return this.or(valueValidators.undefined());
+    if (sourceA.type !== sourceB.type) {
+      throw new ValidationError(
+        substitute(locale5.illegalRuleOverrideTypeError, {
+          property: prop,
+          sourceType: sourceA.type,
+          overrideType: sourceB.type
+        })
+      );
     }
-    /**
-     * Returns a validator that asserts if this validator and the next passes.
-     *
-     * @see andValidators
-     *
-     * @param nextValidator The validator to run after the current.
-     * @return Returns a new ValueSchema intersecting this validator and the next.
-     */
-    and(nextValidator) {
-      return new _ValueSchema(nextValidator, this, andValidators);
+    switch (sourceA.type) {
+      case "attribute" /* ATTRIBUTE */:
+      case "element" /* ELEMENT */:
+      case "elements" /* ELEMENTS */: {
+        const b = sourceB;
+        if (sourceA.namespaceUri !== b.namespaceUri || ((_a3 = sourceA.localPart) != null ? _a3 : prop) !== ((_b = b.localPart) != null ? _b : prop)) {
+          throw new ValidationError(
+            substitute(locale5.illegalQNameOverrideError, {
+              property: prop
+            })
+          );
+        }
+        break;
+      }
     }
-    /**
-     * Returns a validator that asserts if this validator or the next passes.
-     *
-     * Implementation note:
-     * subclasses should not change the schema instance returned unless all chainable validators
-     * accept input type 'unknown'.
-     *
-     * @param nextValidator The validator to run after the current.
-     * @return Returns a new ValueSchema providing the union of this validator and the next.
-     */
-    or(nextValidator) {
-      return new _ValueSchema(nextValidator, this, orValidators);
+    switch (sourceA.type) {
+      case "attribute" /* ATTRIBUTE */: {
+        const b = sourceB;
+        return __spreadProps(__spreadValues({}, b), {
+          default: (_c = b.default) != null ? _c : sourceA.default
+        });
+      }
+      case "characters" /* CHARACTERS */:
+        return sourceB;
+      case "element" /* ELEMENT */: {
+        const b = sourceB;
+        return __spreadProps(__spreadValues({}, b), {
+          required: sourceA.required || b.required,
+          rules: mergeXmlRules(sourceA.rules, b.rules)
+        });
+      }
+      case "elements" /* ELEMENTS */: {
+        const b = sourceB;
+        const maxOccurs = sourceA.maxOccurs != null && b.maxOccurs != null ? Math.min(sourceA.maxOccurs, b.maxOccurs) : (_d = sourceA.maxOccurs) != null ? _d : b.maxOccurs;
+        return __spreadProps(__spreadValues({}, b), {
+          minOccurs: Math.max(sourceA.minOccurs, b.minOccurs),
+          maxOccurs,
+          useEmptyArrays: sourceA.useEmptyArrays || b.useEmptyArrays,
+          rules: mergeXmlRules(sourceA.rules, b.rules)
+        });
+      }
     }
+  }
+
+  // ../vinyl-xml/src/xml/mappedXmlRules.ts
+  var EmptyRules = {
+    __type: invariant(),
+    attributes: /* @__PURE__ */ new Map(),
+    elements: /* @__PURE__ */ new Map(),
+    characters: void 0
   };
-  var locale42 = {
-    array: "array",
-    minLength: "at least {value} elements",
-    maxLength: "at most {value} elements",
-    exactlyLength: "exactly {value} elements",
-    actualLength: "length {value}",
-    withElements: "({value})[]",
-    tuple: "[{value}]"
-  };
-  var arrayValidators = {
-    /**
-     * Creates a validator that asserts that the input is an array.
-     *
-     * Note: arrays can only be readonly by type system, there is no native readonly
-     * js array. This validator assumes mutability, use the ArraySchema readonly() method
-     * to cast to a readonly array.
-     */
-    isArray() {
-      return createValidator(
-        locale42.array,
-        (input) => Array.isArray(input)
-      );
-    },
-    /**
-     * Creates a validator that asserts that every element passes the given validator.
-     *
-     * @param elementValidator
-     */
-    withElements(elementValidator) {
-      return createDeepValidator(
-        substitute(locale42.withElements, {
-          value: elementValidator.description
-        }),
-        (input, options, path) => {
-          const errors = [];
-          for (let i = 0; i < input.length; i++) {
-            const element2 = input[i];
-            errors.push(
-              ...elementValidator.validate(
-                element2,
-                options,
-                path.concat(i.toString())
-              )
+  function mapXmlRules(rules, parentNamespaceUri = null) {
+    var _a3, _b, _c;
+    const attributeRules = /* @__PURE__ */ new Map();
+    const elementRules = /* @__PURE__ */ new Map();
+    let charactersRule = void 0;
+    for (const property in rules) {
+      const handlerOrFunction = rules[property];
+      let handler;
+      if (typeof handlerOrFunction === "function") {
+        handler = handlerOrFunction();
+      } else {
+        handler = handlerOrFunction;
+      }
+      let key;
+      switch (handler.type) {
+        case "characters" /* CHARACTERS */:
+          if (charactersRule !== void 0)
+            throw new IllegalArgumentError(
+              "characters handler already defined"
+            );
+          charactersRule = {
+            property,
+            parse: handler.parse,
+            stringify: handler.stringify
+          };
+          break;
+        case "element" /* ELEMENT */:
+        case "elements" /* ELEMENTS */: {
+          const localPart = (_a3 = handler.localPart) != null ? _a3 : property;
+          const namespaceUri = handler.namespaceUri === void 0 ? parentNamespaceUri : handler.namespaceUri;
+          key = xmlRuleKey(localPart, namespaceUri);
+          if (elementRules.has(key)) {
+            throw new IllegalArgumentError(
+              `Multiple element rules for ${key}`
             );
-            if (!options.all && errors.length) return errors;
           }
-          return errors;
+          if (handler.type === "element" /* ELEMENT */) {
+            const rules2 = handler.rules;
+            elementRules.set(key, {
+              array: false,
+              property,
+              minOccurs: handler.required ? 1 : 0,
+              maxOccurs: 1,
+              rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
+              useEmptyArrays: false,
+              localPart,
+              namespaceUri
+            });
+          } else {
+            const rules2 = handler.rules;
+            elementRules.set(key, {
+              array: true,
+              property,
+              maxOccurs: handler.maxOccurs,
+              minOccurs: handler.minOccurs,
+              rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
+              useEmptyArrays: handler.useEmptyArrays,
+              localPart,
+              namespaceUri
+            });
+          }
+          break;
         }
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input array is a tuple whose elements match
-     * the given validators.
-     *
-     * @param validators
-     */
-    tuple(...validators) {
-      const lengthValidator = createValidator(
-        substitute(locale42.exactlyLength, {
-          value: validators.length
-        }),
-        (length) => length === validators.length
-      );
-      return createDeepValidator(
-        substitute(locale42.tuple, { value: validators.join(", ") }),
-        (input, options, path) => {
-          const errors = [];
-          errors.push(
-            ...lengthValidator.validate(input.length, options, path)
-          );
-          if (!options.all && errors.length) return errors;
-          const n = Math.min(validators.length, input.length);
-          for (let i = 0; i < n; i++) {
-            const element2 = input[i];
-            const validator = validators[i];
-            errors.push(
-              ...validator.validate(
-                element2,
-                options,
-                path.concat(i.toString())
-              )
+        case "attribute" /* ATTRIBUTE */: {
+          const namespaceUri = handler.namespaceUri;
+          const localPart = (_b = handler.localPart) != null ? _b : property;
+          key = xmlRuleKey(localPart, namespaceUri);
+          if (attributeRules.has(key)) {
+            throw new IllegalArgumentError(
+              `Multiple attribute rules for ${key}`
             );
-            if (!options.all && errors.length) return errors;
           }
-          return errors;
+          attributeRules.set(key, {
+            property,
+            default: handler.default,
+            parse: handler.parse,
+            stringify: handler.stringify,
+            required: handler.required,
+            localPart,
+            namespaceUri: (_c = handler.namespaceUri) != null ? _c : null
+          });
+          break;
         }
-      );
-    },
-    /**
-     * Creates a validator that validates the input array has the given minimum length.
-     * @param min The minimum number of elements (inclusive)
-     */
-    minLength(min) {
-      return createValidator(
-        substitute(locale42.minLength, { value: min }),
-        (input) => input.length >= min,
-        (input) => substitute(locale42.actualLength, { value: input.length })
-      );
-    },
-    /**
-     *
-     * Creates a validator that validates the input array has the given maximum length.
-     * @param max The maximum number of elements (inclusive)
-     */
-    maxLength(max) {
-      return createValidator(
-        substitute(locale42.maxLength, { value: max }),
-        (input) => input.length <= max,
-        (input) => substitute(locale42.actualLength, { value: input.length })
-      );
-    }
-  };
-  var _ArraySchema = class _ArraySchema2 extends ValueSchema {
-    /**
-     * The base ArraySchema instance validating that the input is an Array.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _ArraySchema2(arrayValidators.isArray());
-      return this._base;
-    }
-    /**
-     * Creates a validator that asserts that every element passes the given validator.
-     *
-     * @param elementValidator
-     */
-    withElements(elementValidator) {
-      return this.chain(arrayValidators.withElements(elementValidator));
+      }
     }
-    /**
-     * Creates a validator that asserts that the input array is a tuple whose elements match
-     * the given validators.
-     *
-     * @param validators
-     */
-    tuple(...validators) {
-      return this.chain(arrayValidators.tuple(...validators));
+    return {
+      __type: invariant(),
+      attributes: attributeRules,
+      elements: elementRules,
+      characters: charactersRule
+    };
+  }
+  function xmlRuleKey(localPart, namespaceUri = null) {
+    return `${namespaceUri != null ? namespaceUri : ""}:${localPart}`;
+  }
+
+  // ../vinyl-xml/src/xml/ParseXmlHandlerImpl.ts
+  function getRule(name, rules) {
+    return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
+  }
+  var ParseXmlHandlerImpl = class {
+    constructor(rules, options) {
+      __publicField(this, "rules", rules);
+      __publicField(this, "stack", []);
+      __publicField(this, "options");
+      __publicField(this, "busy", false);
+      this.options = __spreadValues({ validateRules: true }, options);
     }
-    /**
-     * Creates a validator that validates the input array has the given minimum length.
-     * @param min The minimum number of elements (inclusive)
-     */
-    minLength(min) {
-      return this.chain(arrayValidators.minLength(min));
+    startDocument() {
+      if (this.busy)
+        throw new IllegalStateError("XML content handler is busy");
+      this.busy = true;
+      const rules = this.rules;
+      this.stack.push({
+        element: new XmlElementImpl(),
+        rules,
+        characters: ""
+      });
     }
-    /**
-     *
-     * Creates a validator that validates the input array has the given maximum length.
-     * @param max The maximum number of elements (inclusive)
-     */
-    maxLength(max) {
-      return this.chain(arrayValidators.maxLength(max));
+    startElement(name, attributes) {
+      var _a3;
+      const parent = last(this.stack);
+      let element2 = null;
+      const elementRule = getRule(name, parent.rules.elements);
+      const rules = (_a3 = elementRule == null ? void 0 : elementRule.rules()) != null ? _a3 : EmptyRules;
+      if (elementRule) {
+        const prop = elementRule.property;
+        element2 = new XmlElementImpl(parent.element);
+        if (elementRule.array) {
+          const arr = parent.element[prop];
+          if (Array.isArray(arr)) {
+            arr.push(element2);
+          } else {
+            parent.element[prop] = [element2];
+          }
+        } else {
+          if (parent.element[prop]) {
+            throw new XmlSchemaError(
+              `Expected single element with name ${name.qName}`
+            );
+          } else {
+            parent.element[prop] = element2;
+          }
+        }
+        const attributeRules = rules.attributes;
+        for (const k in attributes) {
+          const attribute = attributes[k];
+          const name2 = attribute.name;
+          const attributeRule = getRule(name2, attributeRules);
+          if (attributeRule) {
+            element2[attributeRule.property] = attributeRule.parse(
+              attribute.value
+            );
+          }
+        }
+        attributeRules.forEach((_value, key) => {
+          const rule = attributeRules.get(key);
+          if (!(rule.property in element2)) {
+            if (rule.default != null) {
+              element2[rule.property] = rule.default;
+            } else if (this.options.validateRules && rule.required) {
+              throw new XmlSchemaError(
+                substitute(xmlSchemaErrorLocale.requiredAttribute, {
+                  property: rule.property
+                })
+              );
+            }
+          }
+        });
+      }
+      this.stack.push({
+        element: element2,
+        rules,
+        characters: ""
+      });
     }
-    /**
-     * Casts to a readonly array.
-     * This is a shallow cast, elements of the array will not be changed.
-     */
-    readonly() {
-      return this;
+    textNode(str) {
+      const current = last(this.stack);
+      if (!current.rules.characters) return;
+      current.characters += decodeEntities(str.trim());
     }
-    /**
-     * Casts the type parameter.
-     */
-    cast() {
-      return this;
+    cDataNode(str) {
+      const current = last(this.stack);
+      if (!current.rules.characters) return;
+      current.characters += str;
     }
-  };
-  __publicField4(_ArraySchema, "_base", null);
-  var locale52 = {
-    template: "type {value}"
-  };
-  function typeOfValidator(expected) {
-    return createValidator(
-      substitute(locale52.template, { value: expected }),
-      (input) => {
-        return input != null && typeof input === expected;
-      }
-    );
-  }
-  var typeOfValidatorCache = {};
-  function cachedTypeOfValidator(type) {
-    if (!(type in typeOfValidatorCache)) {
-      typeOfValidatorCache[type] = typeOfValidator(type);
+    endElement() {
+      const lastEl = this.stack.pop();
+      const charactersRule = lastEl.rules.characters;
+      if (charactersRule)
+        lastEl.element[charactersRule.property] = charactersRule.parse(
+          lastEl.characters
+        );
+      lastEl.rules.elements.forEach((rule) => {
+        if (rule.array && !(rule.property in lastEl.element)) {
+          if (rule.useEmptyArrays) {
+            lastEl.element[rule.property] = [];
+          }
+        }
+      });
+      this.validate(lastEl);
     }
-    return typeOfValidatorCache[type];
-  }
-  var typeOfValidators = {
-    get boolean() {
-      return cachedTypeOfValidator("boolean");
-    },
-    get func() {
-      return cachedTypeOfValidator("function");
-    },
-    get number() {
-      return cachedTypeOfValidator("number");
-    },
-    get object() {
-      return cachedTypeOfValidator("object");
-    },
-    get string() {
-      return cachedTypeOfValidator("string");
-    },
-    get symbol() {
-      return cachedTypeOfValidator("symbol");
+    endDocument() {
+      this.busy = false;
+      const last2 = this.stack.pop();
+      this.validate(last2);
+      return last2.element;
     }
-  };
-  var locale6 = {
-    length: "at most {value} arguments",
-    actualLength: "{value} arguments"
-  };
-  var functionValidators = {
-    length(max) {
-      return createValidator(
-        substitute(locale6.length, { value: max }),
-        (input) => input.length <= max,
-        (input) => substitute(locale6.actualLength, { value: input.length })
-      );
+    validate(current) {
+      if (!this.options.validateRules) return;
+      current.rules.elements.forEach((rule) => {
+        var _a3, _b;
+        const length = rule.array ? (_b = (_a3 = current.element[rule.property]) == null ? void 0 : _a3.length) != null ? _b : 0 : current.element[rule.property] ? 1 : 0;
+        if (length < rule.minOccurs) {
+          throw new XmlSchemaError(
+            substitute(xmlSchemaErrorLocale.atLeastElements, {
+              property: rule.property,
+              expected: rule.minOccurs,
+              actual: length
+            })
+          );
+        }
+        if (rule.maxOccurs != null && length > rule.maxOccurs) {
+          throw new XmlSchemaError(
+            substitute(xmlSchemaErrorLocale.atMostElements, {
+              property: rule.property,
+              expected: rule.maxOccurs,
+              actual: length
+            })
+          );
+        }
+      });
     }
   };
-  var _FunctionSchema = class _FunctionSchema2 extends ValueSchema {
-    /**
-     * The base Function validator validating that the input is a function.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _FunctionSchema2(typeOfValidators.func);
-      return this._base;
+  var parentSymbol = /* @__PURE__ */ Symbol("parent");
+  var _a;
+  _a = parentSymbol;
+  var _XmlElementImpl = class _XmlElementImpl {
+    constructor(parent = null) {
+      __publicField(this, _a);
+      this[parentSymbol] = parent;
     }
-    length(max) {
-      return this.chain(functionValidators.length(max));
+    get parent() {
+      return this[parentSymbol];
     }
-    /**
-     * Casts the function signature.
-     * Function signatures, except for their required number of parameters, cannot be
-     * meaningfully validated.
-     */
-    cast() {
-      return this;
+    set parent(value) {
+      this[parentSymbol] = value;
     }
-  };
-  __publicField4(_FunctionSchema, "_base", null);
-  var locale7 = {
-    set: "Set",
-    withElements: "Set<{value}>"
-  };
-  var setValidators = {
-    /**
-     * Creates a validator that asserts that the input is a set.
-     */
-    isSet() {
-      return createValidator(
-        locale7.set,
-        (input) => input instanceof Set
-      );
-    },
-    /**
-     * Creates a validator that asserts that every element passes the given validator.
-     *
-     * @param elementValidator
-     */
-    withElements(elementValidator) {
-      return createDeepValidator(
-        substitute(locale7.withElements, {
-          value: elementValidator.description
-        }),
-        (input, options, path) => {
-          const errors = [];
-          let i = 0;
-          for (const element2 of input) {
-            errors.push(
-              ...elementValidator.validate(
-                element2,
-                options,
-                path.concat(i.toString())
-              )
-            );
-            if (!options.all && errors.length) return errors;
-            i++;
+    clone() {
+      const out = new _XmlElementImpl(this.parent);
+      for (const key in this) {
+        const child = clone(this[key]);
+        if (Array.isArray(child)) {
+          for (const e of child) {
+            if (typeof e === "object" && "parent" in e) e.parent = out;
           }
-          return errors;
+        } else if (typeof child === "object" && "parent" in child) {
+          child.parent = out;
         }
-      );
+        out[key] = child;
+      }
+      return out;
+    }
+    toJSON() {
+      const out = {};
+      for (const key in this) {
+        out[key] = toJson(this[key]);
+      }
+      return out;
     }
   };
-  var _SetSchema = class _SetSchema2 extends ValueSchema {
+  var XmlElementImpl = _XmlElementImpl;
+
+  // ../vinyl-validation/src/validation/Validator.ts
+  var validatorLocale = {
     /**
-     * The base SetSchema instance validating that the input is a Set.
+     * The expectation template string with the following replacement tokens:
+     *
+     * `{expected}` - The expected description.
+     * `{actual}` - The actual value.
+     * `{path}` - The path, dot separated.
      */
-    static get base() {
-      if (this._base == null)
-        this._base = new _SetSchema2(setValidators.isSet());
-      return this._base;
-    }
+    template: "Expected: {expected}, but was: {actual}. At: {path}"
+  };
+  function createValidationExpectationMessage(expectationMessage, input, path, inputStringify = (input2) => stringifyForPrint(input2, 500)) {
+    return substitute(validatorLocale.template, {
+      expected: expectationMessage,
+      actual: inputStringify(input),
+      path: path.join(".")
+    });
+  }
+  function createValidator(expectationMessage, isValid, inputStringify = (input) => stringifyForPrint(input, 500)) {
+    return {
+      description: expectationMessage,
+      isValid(input) {
+        return isValid(input);
+      },
+      validate(input, _, path = []) {
+        if (!isValid(input)) {
+          return [
+            {
+              message: createValidationExpectationMessage(
+                expectationMessage,
+                input,
+                path,
+                inputStringify
+              ),
+              path
+            }
+          ];
+        }
+        return [];
+      },
+      assert: (input, origin, path = []) => {
+        if (!isValid(input)) {
+          throw new ValidationError(
+            createValidationExpectationMessage(
+              expectationMessage,
+              input,
+              path,
+              inputStringify
+            ),
+            origin,
+            path
+          );
+        }
+      }
+    };
+  }
+  function createDeepValidator(description, validate) {
+    return {
+      description,
+      isValid(input) {
+        return validate(input, { all: false }, []).length === 0;
+      },
+      validate(input, options, path = []) {
+        return validate(input, options != null ? options : { all: false }, path);
+      },
+      assert: (input, origin, path = []) => {
+        const errors = validate(input, { all: false }, path);
+        if (errors.length) {
+          const error = errors[0];
+          throw new ValidationError(error.message, origin, error.path);
+        }
+      }
+    };
+  }
+
+  // ../vinyl-validation/src/validation/andValidators.ts
+  var locale6 = {
     /**
-     * Creates a validator that asserts that every element passes the given validator.
+     * {value} The child validators' descriptions, joined with `separator`.
      *
-     * @param elementValidator
+     * groupings of and validators is unimportant,
+     * and(and(a, b), c) is the same as and(a, and(b, c)), so `a & b & c` is an accurate
+     * representation for either.
      */
-    withElements(elementValidator) {
-      return this.chain(setValidators.withElements(elementValidator));
-    }
+    template: "{value}",
     /**
-     * Casts to a readonly set.
-     * This is a shallow cast, elements of the array will not be changed.
+     * The separator with which to join child validator descriptions.
      */
-    readonly() {
-      return this;
-    }
+    separator: " & "
+  };
+  function andValidators(...validators) {
+    return createDeepValidator(
+      substitute(locale6.template, {
+        value: validators.map((v) => v.description).join(locale6.separator)
+      }),
+      (input, options, path) => {
+        for (const validator of validators) {
+          const errors = validator.validate(input, options, path);
+          if (errors.length) return errors;
+        }
+        return [];
+      }
+    );
+  }
+
+  // ../vinyl-validation/src/validation/orValidators.ts
+  var locale7 = {
     /**
-     * Casts the parameter type.
+     * {value} - The child validators' descriptions, joined with `separator`.
      */
-    cast() {
-      return this;
-    }
+    template: "({value})",
+    /**
+     * The separator with which to join child validator descriptions.
+     */
+    separator: " | "
   };
-  __publicField4(_SetSchema, "_base", null);
-  var locale8 = {
-    gte: "at least {value}",
-    gt: "greater than {value}",
-    lte: "at most {value}",
-    lt: "less than {value}",
-    within: "within {min} and {max}",
-    safeInteger: "safe integer",
-    finite: "finite"
+  function orValidators(...validators) {
+    const description = substitute(locale7.template, {
+      value: validators.map((v) => v.description).join(locale7.separator)
+    });
+    return createDeepValidator(description, (input, options, path) => {
+      let longestErrors = [];
+      let longestPath = 0;
+      for (const validator of validators) {
+        const errors = validator.validate(input, options, path);
+        if (!errors.length) return errors;
+        const pathLength = errors.reduce(
+          (max, m) => Math.max(m.path.length, max),
+          0
+        );
+        if (pathLength >= longestPath) {
+          longestErrors = errors;
+          longestPath = pathLength;
+        }
+      }
+      return longestPath > path.length ? longestErrors : [
+        {
+          message: createValidationExpectationMessage(
+            description,
+            input,
+            path
+          ),
+          path
+        }
+      ];
+    });
+  }
+
+  // ../vinyl-validation/src/validation/SchemaBase.ts
+  var requiredValidationOptions = {
+    optional: false
   };
-  var numberValidators = {
+  var SchemaBase = class {
+    constructor(currentValidator, previousSchema, operation) {
+      __publicField(this, "currentValidator", currentValidator);
+      __publicField(this, "previousSchema", previousSchema);
+      __publicField(this, "operation", operation);
+      __publicField(this, "__type", invariant());
+      __publicField(this, "validator");
+      __publicField(this, "_options", requiredValidationOptions);
+      __publicField(this, "assert", (input, origin, path) => {
+        this.validator.assert(input, origin, path);
+      });
+      __publicField(this, "isValid", (input) => this.validator.isValid(input));
+      __publicField(this, "validate", (input, options, path) => this.validator.validate(input, options, path));
+      this.validator = operation == null ? currentValidator : operation(previousSchema, currentValidator);
+    }
+    get options() {
+      return this._options;
+    }
+    get description() {
+      return this.validator.description;
+    }
     /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * value.
+     * Clones this schema, transforming all validators with the given mutator.
      *
-     * @param min The minimum (inclusive) the value may be.
+     * @param transform A transformer which takes an existing validator in the chain and returns
+     * a new one. Validators should be considered to be immutable; transform should not change the
+     * input but instead return a new validator.
      */
-    gte(min) {
-      return createValidator(
-        substitute(locale8.gte, { value: min }),
-        (input) => input >= min
-      );
-    },
+    clone(transform = (v) => v) {
+      const cloned = this.operation ? this.self(
+        transform(this.currentValidator),
+        this.previousSchema.clone(transform),
+        this.operation
+      ) : this.self(transform(this.currentValidator));
+      cloned._options = this._options;
+      return cloned;
+    }
+    self(current, previous, operation) {
+      if (this.constructor.length > 3) {
+        throw new IllegalArgumentError(
+          "constructor should have at most three required arguments"
+        );
+      }
+      return new this.constructor(current, previous, operation);
+    }
     /**
-     * Creates a validator that asserts that the input number is greater than the provided minimum
-     * value.
+     * Constructs a new schema with a validator chaining the current validator with the
+     * provided next in an AND operation.
      *
-     * @param min The minimum (exclusive) the value may be.
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new Schema instance the same class with a new validator chaining the
+     * current validator with the given next in an AND operation.
      */
-    gt(min) {
-      return createValidator(
-        substitute(locale8.gt, { value: min }),
-        (input) => input > min
-      );
+    chain(nextValidator) {
+      return this.self(nextValidator, this, andValidators);
+    }
+    optional() {
+      const cloned = this.clone();
+      cloned._options = __spreadProps(__spreadValues({}, cloned.options), {
+        optional: true
+      });
+      return cloned;
+    }
+    required() {
+      const cloned = this.clone();
+      cloned._options = __spreadProps(__spreadValues({}, cloned.options), {
+        optional: false
+      });
+      return cloned;
+    }
+  };
+
+  // ../vinyl-validation/src/validation/ValueSchema.ts
+  var locale8 = {
+    null: "null",
+    nullish: "nullish",
+    undefined: "undefined"
+  };
+  var valueValidators = {
+    any() {
+      return createValidator("", () => true);
     },
     /**
-     * Creates a validator that asserts that the input number is at most the provided maximum
-     * value.
-     *
-     * @param max The maximum (inclusive) the value may be.
+     * Creates a validator that asserts that the input is nullish.
      */
-    lte(max) {
-      return createValidator(
-        substitute(locale8.lte, { value: max }),
-        (input) => input <= max
-      );
+    nullish() {
+      return createValidator(locale8.nullish, (input) => input == null);
     },
     /**
-     * Creates a validator that asserts that the input number is less than the provided maximum
-     * value.
-     *
-     * @param max The maximum (exclusive) the value may be.
+     * Creates a validator that asserts that the input is strictly null.
      */
-    lt(max) {
-      return createValidator(
-        substitute(locale8.lt, { value: max }),
-        (input) => input < max
-      );
+    null() {
+      return createValidator(locale8.null, (input) => input === null);
     },
     /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * and at most the provided maximum values.
-     *
-     * @param min The minimum (inclusive) value the input may be.
-     * @param max The maximum (inclusive) value the input may be.
+     * Creates a validator that asserts that the input is strictly undefined.
      */
-    within(min, max) {
-      return createValidator(
-        substitute(locale8.within, { min, max }),
-        (input) => input >= min && input <= max
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input number is finite.
-     */
-    finite() {
-      return createValidator(locale8.finite, (input) => Number.isFinite(input));
-    },
-    /**
-     * Creates a validator that asserts that the input number is a safe integer.
-     */
-    safeInteger() {
-      return createValidator(
-        locale8.safeInteger,
-        (input) => Number.isSafeInteger(input)
-      );
+    undefined() {
+      return createValidator(locale8.undefined, (input) => input === void 0);
     }
   };
-  var _NumberSchema = class _NumberSchema2 extends ValueSchema {
+  var ValueSchema = class _ValueSchema extends SchemaBase {
     /**
-     * The base Object validator validating that the input is an object.
+     * Prepends this validator allowing for null or undefined.
      */
-    static get base() {
-      if (this._base == null)
-        this._base = new _NumberSchema2(typeOfValidators.number);
-      return this._base;
+    maybe() {
+      return this.or(valueValidators.nullish());
     }
     /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * value.
-     *
-     * @param min The minimum (inclusive) the value may be.
+     * Prepends this validator allowing for null.
      */
-    gte(min) {
-      return this.chain(numberValidators.gte(min));
+    orNull() {
+      return this.or(valueValidators.null());
     }
     /**
-     * Creates a validator that asserts that the input number is greater than the provided minimum
-     * value.
-     *
-     * @param min The minimum (exclusive) the value may be.
+     * Prepends this validator allowing for undefined.
      */
-    gt(min) {
-      return this.chain(numberValidators.gt(min));
+    orUndefined() {
+      return this.or(valueValidators.undefined());
     }
     /**
-     * Creates a validator that asserts that the input number is at most the provided maximum
-     * value.
+     * Returns a validator that asserts if this validator and the next passes.
      *
-     * @param max The maximum (inclusive) the value may be.
-     */
-    lte(max) {
-      return this.chain(numberValidators.lte(max));
-    }
-    /**
-     * Creates a validator that asserts that the input number is less than the provided maximum
-     * value.
+     * @see andValidators
      *
-     * @param max The maximum (exclusive) the value may be.
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema intersecting this validator and the next.
      */
-    lt(max) {
-      return this.chain(numberValidators.lt(max));
+    and(nextValidator) {
+      return new _ValueSchema(nextValidator, this, andValidators);
     }
     /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * and at most the provided maximum values.
+     * Returns a validator that asserts if this validator or the next passes.
      *
-     * @param min The minimum (inclusive) value the input may be.
-     * @param max The maximum (inclusive) value the input may be.
-     */
-    within(min, max) {
-      return this.chain(numberValidators.within(min, max));
-    }
-    /**
-     * Creates a validator that asserts that the input number is finite.
-     */
-    finite() {
-      return this.chain(numberValidators.finite());
-    }
-    /**
-     * Creates a validator that asserts that the input number is a safe integer.
+     * Implementation note:
+     * subclasses should not change the schema instance returned unless all chainable validators
+     * accept input type 'unknown'.
+     *
+     * @param nextValidator The validator to run after the current.
+     * @return Returns a new ValueSchema providing the union of this validator and the next.
      */
-    safeInteger() {
-      return this.chain(numberValidators.safeInteger());
+    or(nextValidator) {
+      return new _ValueSchema(nextValidator, this, orValidators);
     }
   };
-  __publicField4(_NumberSchema, "_base", null);
-  var NumberSchema = _NumberSchema;
-  function isValidatorWithPartial(validator) {
-    return "partial" in validator && "partialDeep" in validator;
-  }
-  function maybeToDeepPartial(validator) {
-    return isValidatorWithPartial(validator) ? validator.partialDeep() : validator;
-  }
-  function maybeToPartial(validator) {
-    return isValidatorWithPartial(validator) ? validator.partial() : validator;
-  }
+
+  // ../vinyl-validation/src/validation/typeOfValidators.ts
   var locale9 = {
-    extend: "{\n{body}\n}",
-    prop: "{key}: {value}",
-    propSeparator: ",\n",
-    indent: "  ",
-    required: `property '{key}' is required`
+    template: "type {value}"
   };
-  var objectValidators = {
-    /**
-     * Creates a validator that validates the input has properties that pass their respective
-     * validators.
-     *
-     * @param propertyValidators
-     */
-    properties(propertyValidators) {
-      const propertiesDescriptions = [];
-      const keys = ownKeys(propertyValidators);
-      for (const key of keys) {
-        const validator2 = propertyValidators[key];
-        propertiesDescriptions.push(
-          substitute(locale9.prop, {
-            key: String(key) + (validator2.options.optional ? "?" : ""),
-            value: validator2.description
-          })
-        );
+  function typeOfValidator(expected) {
+    return createValidator(
+      substitute(locale9.template, { value: expected }),
+      (input) => {
+        return input != null && typeof input === expected;
       }
-      const description = substitute(locale9.extend, {
-        body: propertiesDescriptions.join(locale9.propSeparator).split("\n").map((line) => locale9.indent + line).join("\n")
-      });
-      const validator = createDeepValidator(
-        description,
-        (input, options, path) => {
-          const errors = [];
-          for (const key of keys) {
-            const validator2 = propertyValidators[key];
-            if (key in input) {
-              const value = input[key];
-              errors.push(
-                ...validator2.validate(
-                  value,
-                  options,
-                  path.concat(String(key))
-                )
-              );
-            } else {
-              if (!validator2.options.optional) {
-                errors.push({
-                  message: substitute(locale9.required, { key }),
-                  path: path.concat(String(key))
-                });
-              }
-            }
-            if (!options.all && errors.length) return errors;
-          }
-          return errors;
-        }
-      );
-      return merge(validator, {
-        partial() {
-          const optionalPropertyValidators = {};
-          for (const key of keys) {
-            optionalPropertyValidators[key] = propertyValidators[key].optional();
-          }
-          return objectValidators.properties(
-            optionalPropertyValidators
-          );
-        },
-        partialDeep() {
-          const optionalPropertyValidators = {};
-          for (const key of keys) {
-            optionalPropertyValidators[key] = maybeToDeepPartial(
-              propertyValidators[key].optional()
-            );
-          }
-          return objectValidators.properties(
-            optionalPropertyValidators
-          );
-        }
-      });
-    }
-  };
-  var _ObjectSchema = class _ObjectSchema2 extends ValueSchema {
-    /**
-     * The base Object validator validating that the input is an object.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _ObjectSchema2(typeOfValidators.object);
-      return this._base;
-    }
-    /**
-     * Creates a validator that validates the input has properties that pass their respective
-     * validators.
-     *
-     * @param propertyValidators
-     */
-    extend(propertyValidators) {
-      return this.chain(objectValidators.properties(propertyValidators));
-    }
-    /**
-     * Allows all properties to be undefined.
-     */
-    partial() {
-      return this.clone(maybeToPartial);
-    }
-    /**
-     * Allows all recursive properties to be undefined.
-     */
-    partialDeep() {
-      return this.clone(maybeToDeepPartial);
+    );
+  }
+  var typeOfValidatorCache = {};
+  function cachedTypeOfValidator(type) {
+    if (!(type in typeOfValidatorCache)) {
+      typeOfValidatorCache[type] = typeOfValidator(type);
     }
-    /**
-     * Casts the type parameter.
-     */
-    cast() {
-      return this;
+    return typeOfValidatorCache[type];
+  }
+  var typeOfValidators = {
+    get boolean() {
+      return cachedTypeOfValidator("boolean");
+    },
+    get func() {
+      return cachedTypeOfValidator("function");
+    },
+    get number() {
+      return cachedTypeOfValidator("number");
+    },
+    get object() {
+      return cachedTypeOfValidator("object");
+    },
+    get string() {
+      return cachedTypeOfValidator("string");
+    },
+    get symbol() {
+      return cachedTypeOfValidator("symbol");
     }
   };
-  __publicField4(_ObjectSchema, "_base", null);
+
+  // ../vinyl-validation/src/validation/NumberSchema.ts
   var locale10 = {
-    notEmpty: "not empty",
-    minLength: "at least {value} characters",
-    maxLength: "at most {value} characters",
-    noWhitespace: "no whitespace characters",
-    matches: "matches {value}"
+    gte: "at least {value}",
+    gt: "greater than {value}",
+    lte: "at most {value}",
+    lt: "less than {value}",
+    within: "within {min} and {max}",
+    safeInteger: "safe integer",
+    finite: "finite"
   };
-  var stringValidators = {
-    /**
-     * Creates a validator that asserts that the input is not empty.
-     */
-    notEmpty() {
-      return createValidator(locale10.notEmpty, (input) => input !== "");
-    },
+  var numberValidators = {
     /**
-     * Creates a validator that asserts that the input string has at least the given minimum
-     * length.
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
      *
-     * @param min The string must be at least this length.
+     * @param min The minimum (inclusive) the value may be.
      */
-    minLength(min) {
+    gte(min) {
       return createValidator(
-        substitute(locale10.minLength, { value: min }),
-        (input) => input.length >= min
+        substitute(locale10.gte, { value: min }),
+        (input) => input >= min
       );
     },
     /**
-     * Creates a validator that asserts that the input string has at most the given maximum
-     * length.
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
      *
-     * @param max The string must be at most this length.
+     * @param min The minimum (exclusive) the value may be.
      */
-    maxLength(max) {
+    gt(min) {
       return createValidator(
-        substitute(locale10.maxLength, { value: max }),
-        (input) => input.length <= max
+        substitute(locale10.gt, { value: min }),
+        (input) => input > min
       );
     },
     /**
-     * Creates a validator that asserts that the input string has no whitespace characters.
-     * Whitespace characters include space, new line, carriage return, and tab.
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
      */
-    noWhitespace() {
+    lte(max) {
       return createValidator(
-        locale10.noWhitespace,
-        (input) => input.search(/\s/g) === -1
+        substitute(locale10.lte, { value: max }),
+        (input) => input <= max
       );
     },
     /**
-     * Creates a validator that asserts that the input string matches the given regex.
-     * @param regex
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
      */
-    matches(regex) {
+    lt(max) {
       return createValidator(
-        substitute(locale10.matches, { value: regex.toString() }),
-        (input) => {
-          return regex.test(input);
-        }
+        substitute(locale10.lt, { value: max }),
+        (input) => input < max
       );
-    }
-  };
-  var _StringSchema = class _StringSchema2 extends ValueSchema {
-    /**
-     * The base SetSchema instance validating that the input is a Set.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _StringSchema2(typeOfValidators.string);
-      return this._base;
-    }
-    /**
-     * Creates a validator that asserts that the input is not empty.
-     */
-    notEmpty() {
-      return this.chain(stringValidators.notEmpty());
-    }
-    /**
-     * Creates a validator that asserts that the input string has at least the given minimum
-     * length.
-     *
-     * @param min The string must be at least this length.
-     */
-    minLength(min) {
-      return this.chain(stringValidators.minLength(min));
-    }
-    /**
-     * Creates a validator that asserts that the input string has at most the given maximum
-     * length.
-     *
-     * @param max The string must be at most this length.
-     */
-    maxLength(max) {
-      return this.chain(stringValidators.maxLength(max));
-    }
-    /**
-     * Creates a validator that asserts that the input string has no whitespace characters.
-     * Whitespace characters include space, new line, carriage return, and tab.
-     */
-    noWhitespace() {
-      return this.chain(stringValidators.noWhitespace());
-    }
-    /**
-     * Creates a validator that asserts that the input string matches the given regex.
-     * @param regex
-     */
-    matches(regex) {
-      return this.chain(stringValidators.matches(regex));
-    }
-  };
-  __publicField4(_StringSchema, "_base", null);
-  var StringSchema = _StringSchema;
-  var locale11 = {
-    record: "{ [key: {key}]: {value} }"
-  };
-  var recordValidators = {
+    },
     /**
-     * Returns a validator that asserts that the object's own enumerable properties has keys and
-     * values that match their respective validators.
-     *
-     * Prototype members are not included.
-     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
-     * to the key validator as '0'.
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
      *
-     * @param keyValidator Validates each key.
-     * @param valueValidator Validates each value.
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
      */
-    record(keyValidator, valueValidator) {
-      return createDeepValidator(
-        substitute(locale11.record, {
-          key: keyValidator.description,
-          value: valueValidator.description
-        }),
-        (input, options, path) => {
-          const errors = [];
-          for (const key of ownKeys(input)) {
-            const keyStr = String(key);
-            errors.push(
-              ...keyValidator.validate(
-                key,
-                options,
-                path.concat(`[${keyStr}]`)
-              )
-            );
-            if (!options.all && errors.length) return errors;
-            const value = input[key];
-            errors.push(
-              ...valueValidator.validate(
-                value,
-                options,
-                path.concat(keyStr)
-              )
-            );
-            if (!options.all && errors.length) return errors;
-          }
-          return errors;
-        }
+    within(min, max) {
+      return createValidator(
+        substitute(locale10.within, { min, max }),
+        (input) => input >= min && input <= max
       );
-    }
-  };
-  var _RecordSchema = class _RecordSchema2 extends ValueSchema {
-    /**
-     * The base Object validator validating that the input is an object.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _RecordSchema2(typeOfValidators.object);
-      return this._base;
-    }
-    static get defaultKeyValidator() {
-      return StringSchema.base;
-    }
-    /**
-     * Returns a validator that asserts that the object's own enumerable properties has keys and
-     * values that match their respective validators.
-     *
-     * Prototype members are not included.
-     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
-     * to the key validator as '0'.
-     *
-     * @param keyValidator Validates each key.
-     * @param valueValidator Validates each value.
-     */
-    record(keyValidator, valueValidator) {
-      return this.chain(recordValidators.record(keyValidator, valueValidator));
-    }
+    },
     /**
-     * Returns a validator that asserts that the object's own enumerable properties has
-     * string keys and values that match the given validator.
-     *
-     * Prototype members are not included.
-     *
-     * @param valueValidator Validates each value.
-     */
-    recordValues(valueValidator) {
-      return this.record(_RecordSchema2.defaultKeyValidator, valueValidator);
-    }
-    /**
-     * Casts to a ReadonlyRecord
-     */
-    readonly() {
-      return this;
-    }
-    /**
-     * Casts the type parameter.
-     */
-    cast() {
-      return this;
-    }
-  };
-  __publicField4(_RecordSchema, "_base", null);
-  var locale12 = {
-    isOneOf: "one of: {value}",
-    instanceOf: "instance of {value}",
-    oneOfSeparator: " | "
-  };
-  function isOneOf(...possibleValues) {
-    return new ValueSchema(
-      createValidator(
-        substitute(locale12.isOneOf, {
-          value: possibleValues.join(locale12.oneOfSeparator)
-        }),
-        (input) => possibleValues.includes(input)
-      )
-    );
-  }
-  function number() {
-    return NumberSchema.base;
-  }
-
-  // ../vinyl-xml/dist/index.js
-  var __defProp5 = Object.defineProperty;
-  var __defProps3 = Object.defineProperties;
-  var __getOwnPropDescs3 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols4 = Object.getOwnPropertySymbols;
-  var __hasOwnProp4 = Object.prototype.hasOwnProperty;
-  var __propIsEnum4 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp5 = (obj, key, value) => key in obj ? __defProp5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues4 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp4.call(b, prop))
-        __defNormalProp5(a, prop, b[prop]);
-    if (__getOwnPropSymbols4)
-      for (var prop of __getOwnPropSymbols4(b)) {
-        if (__propIsEnum4.call(b, prop))
-          __defNormalProp5(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps3 = (a, b) => __defProps3(a, __getOwnPropDescs3(b));
-  var __publicField5 = (obj, key, value) => __defNormalProp5(obj, typeof key !== "symbol" ? key + "" : key, value);
-  function element(rules, options) {
-    return __spreadProps3(__spreadValues4({
-      type: "element",
-      localPart: void 0,
-      namespaceUri: void 0,
-      required: false
-    }, options), {
-      rules
-    });
-  }
-  function elements(rules, options) {
-    return __spreadProps3(__spreadValues4({
-      type: "elements",
-      localPart: void 0,
-      namespaceUri: void 0,
-      minOccurs: 0,
-      maxOccurs: null,
-      useEmptyArrays: false
-    }, options), {
-      rules
-    });
-  }
-  function characters(parse, stringify2) {
-    return { type: "characters", parse, stringify: stringify2 };
-  }
-  var charactersString = /* @__PURE__ */ characters((i) => i, stringify);
-  function attr(parse, stringify2, options) {
-    return __spreadProps3(__spreadValues4({
-      type: "attribute",
-      localPart: void 0,
-      namespaceUri: null,
-      required: false,
-      default: void 0
-    }, options), {
-      parse,
-      stringify: stringify2
-    });
-  }
-  function attrString(options) {
-    return attr((i) => i, stringify, options);
-  }
-  function attrInt(options) {
-    return attr(parseInt, stringify, options);
-  }
-  function attrFloat(options) {
-    return attr(parseFloat, stringify, options);
-  }
-  function attrBoolean(options) {
-    return attr(parseBoolean, stringify, options);
-  }
-  function attrDateTime(options) {
-    return attr(parseDate, stringifyDate, options);
-  }
-  var xmlSchemaErrorLocale = {
-    atLeastElements: "Expected at least {expected} occurrences of {property} but was {actual}",
-    atMostElements: "Expected at most {expected} occurrences of {property} but was {actual}",
-    cyclicReferences: "Cyclic reference detected",
-    requiredAttribute: `Attribute '{property}' is required`
-  };
-  var XmlSchemaError = class _XmlSchemaError extends ReportableError {
-    get [Symbol.toStringTag]() {
-      return "XmlSchemaError";
-    }
-    constructor(message) {
-      super(message, ErrorOrigin.PARSING);
-      Object.setPrototypeOf(this, _XmlSchemaError.prototype);
-    }
-  };
-  var XMLNS = "http://www.w3.org/2000/xmlns/";
-  var LT = /* @__PURE__ */ char("<");
-  var GT = /* @__PURE__ */ char(">");
-  var EQ = /* @__PURE__ */ char("=");
-  var SLASH = /* @__PURE__ */ char("/");
-  var COLON = /* @__PURE__ */ char(":");
-  var QMARK = /* @__PURE__ */ char("?");
-  var EXCL = /* @__PURE__ */ char("!");
-  var APOS = /* @__PURE__ */ char("'");
-  var QUOT = /* @__PURE__ */ char('"');
-  var QUOTES = /* @__PURE__ */ new Set([APOS, QUOT]);
-  function parseXml(str, handler) {
-    const c = new StringReader(str);
-    let current = {
-      qName: "#document",
-      namespaceMap: /* @__PURE__ */ new Map(),
-      defaultNamespaceUri: null
-    };
-    const stack = [current];
-    const namespaceLookup = (prefix) => {
-      if (!prefix) return current.defaultNamespaceUri;
-      for (let i = stack.length - 1; i >= 0; i--) {
-        const map = stack[i].namespaceMap;
-        if (map.has(prefix)) return stack[i].namespaceMap.get(prefix);
-      }
-      return null;
-    };
-    try {
-      handler.startDocument();
-    } catch (e) {
-      c.err(e.message);
-    }
-    while (c.hasNext()) {
-      const charsStart = c.untilChar(LT);
-      if (charsStart < c.position) {
-        const chars = str.substring(charsStart, c.position);
-        try {
-          handler.textNode(chars);
-        } catch (e) {
-          c.err(e.message);
-        }
-      }
-      if (!c.hasNext()) break;
-      c.next();
-      if (c.charIf(SLASH)) {
-        c.white();
-        const name = readQName(c);
-        if (name.qName !== current.qName)
-          c.err(`Expected </${current.qName}> but was </${name.qName}>`);
-        stack.pop();
-        current = last(stack);
-        c.white();
-        c.readChar(GT);
-        try {
-          handler.endElement();
-        } catch (e) {
-          c.err(e.message);
-        }
-      } else if (c.charIf(QMARK)) {
-        untilTagClose(c);
-      } else if (c.charIf(EXCL)) {
-        if (c.charIf(
-          45
-          /* - */
-        )) {
-          c.readChar(45);
-          c.untilString("-->");
-          c.read("-->");
-        } else if (c.stringIf("[CDATA[")) {
-          const charsStart2 = c.untilString("]]>");
-          try {
-            handler.cDataNode(str.substring(charsStart2, c.position));
-          } catch (e) {
-            c.err(e.message);
-          }
-          c.read("]]>");
-        } else {
-          untilTagClose(c);
-        }
-      } else {
-        const name = readQName(c);
-        current = {
-          qName: name.qName,
-          namespaceMap: /* @__PURE__ */ new Map(),
-          defaultNamespaceUri: current.defaultNamespaceUri
-        };
-        stack.push(current);
-        const attributes = xmlAttributes(c, current);
-        name.namespaceUri = namespaceLookup(name.prefix);
-        for (const attributesKey in attributes) {
-          const value = attributes[attributesKey];
-          const name2 = value.name;
-          if (name2.prefix && !name2.namespaceUri) {
-            name2.namespaceUri = namespaceLookup(name2.prefix);
-          }
-        }
-        try {
-          handler.startElement(name, attributes);
-        } catch (e) {
-          c.err(e.message);
-        }
-        if (c.charIf(SLASH)) {
-          c.readChar(GT);
-          stack.pop();
-          current = last(stack);
-          try {
-            handler.endElement();
-          } catch (e) {
-            c.err(e.message);
-          }
-        } else {
-          c.readChar(GT);
-        }
-      }
-    }
-    try {
-      return handler.endDocument();
-    } catch (e) {
-      return c.err(e.message);
-    }
-  }
-  function readAttributeValue(c) {
-    const quote = c.next();
-    if (!QUOTES.has(quote)) c.err(`Expected ' or "`);
-    const value = c.substringUntil((charCode) => charCode === quote);
-    c.readChar(quote);
-    return decodeEntities(value);
-  }
-  function untilTagClose(c) {
-    while (true) {
-      c.until((c2) => c2 === APOS || c2 === QUOT || c2 === GT);
-      const char2 = c.next();
-      if (QUOTES.has(char2)) {
-        c.untilChar(char2);
-        c.next();
-      } else {
-        break;
-      }
-    }
-  }
-  function isNameChar(charCode) {
-    if (charCode >= 97) {
-      if (charCode >= 183) {
-        if (charCode >= 768) {
-          if (charCode >= 8255) {
-            return charCode <= 8256;
-          } else {
-            return charCode <= 879;
-          }
-        } else {
-          return charCode === 183;
-        }
-      } else {
-        return charCode <= 122;
-      }
-    } else {
-      if (charCode >= 95) {
-        return charCode === 95;
-      } else {
-        if (charCode >= 65) {
-          return charCode <= 90;
-        } else {
-          if (charCode >= 45) {
-            if (charCode >= 48) {
-              return charCode <= 57;
-            } else {
-              return charCode <= 46;
-            }
-          } else {
-            return false;
-          }
-        }
-      }
-    }
-  }
-  function readQName(reader) {
-    const prefixOrLocalName = reader.substringWhile(isNameChar);
-    let prefix, localPart, name;
-    if (reader.charIf(COLON)) {
-      prefix = prefixOrLocalName;
-      localPart = reader.substringWhile(isNameChar);
-      name = `${prefix}:${localPart}`;
-    } else {
-      prefix = null;
-      localPart = prefixOrLocalName;
-      name = localPart;
-    }
-    return { prefix, localPart, qName: name, namespaceUri: null };
-  }
-  function xmlAttributes(reader, stackElement) {
-    const attributes = {};
-    while (true) {
-      reader.white();
-      if (!isNameChar(reader.peek)) break;
-      const name = readQName(reader);
-      reader.white();
-      let value = "";
-      if (reader.charIf(EQ)) {
-        reader.white();
-        value = readAttributeValue(reader);
-      } else {
-      }
-      if (name.prefix === "xmlns") {
-        name.namespaceUri = XMLNS;
-        stackElement.namespaceMap.set(
-          name.localPart,
-          value === "" ? null : value
-        );
-      } else if (!name.prefix && name.localPart === "xmlns") {
-        name.namespaceUri = XMLNS;
-        stackElement.defaultNamespaceUri = !value ? null : value;
-      }
-      if (attributes[name.qName] != null)
-        reader.err(`Attribute '${name.qName}' is already specified.`);
-      attributes[name.qName] = { name, value };
-    }
-    return attributes;
-  }
-  var locale23 = {
-    illegalRuleOverrideTypeError: "Cannot override the rule {property} of type {sourceType} with a rule of type {overrideType}",
-    illegalQNameOverrideError: "Cannot override the rule {property} with a different localPart or namespace"
-  };
-  function mergeXmlRules(...rules) {
-    let finalRule = rules[0];
-    for (let i = 1; i < rules.length; i++) {
-      finalRule = plainObjectMergeRule.merge(
-        finalRule,
-        rules[i],
-        mergeXmlRule
-      );
-    }
-    return finalRule;
-  }
-  function mergeXmlRule(sourceA, sourceB, prop) {
-    var _a22, _b, _c, _d;
-    if (sourceA == null) return sourceB;
-    const sourceAIsLazy = typeof sourceA === "function";
-    const sourceBIsLazy = typeof sourceB === "function";
-    if (sourceAIsLazy || sourceBIsLazy) {
-      return () => {
-        const a = sourceAIsLazy ? sourceA() : sourceA;
-        const b = sourceBIsLazy ? sourceB() : sourceB;
-        return mergeXmlRule(a, b, prop);
-      };
-    }
-    if (sourceA.type !== sourceB.type) {
-      throw new ValidationError(
-        substitute(locale23.illegalRuleOverrideTypeError, {
-          property: prop,
-          sourceType: sourceA.type,
-          overrideType: sourceB.type
-        })
-      );
-    }
-    switch (sourceA.type) {
-      case "attribute":
-      case "element":
-      case "elements": {
-        const b = sourceB;
-        if (sourceA.namespaceUri !== b.namespaceUri || ((_a22 = sourceA.localPart) != null ? _a22 : prop) !== ((_b = b.localPart) != null ? _b : prop)) {
-          throw new ValidationError(
-            substitute(locale23.illegalQNameOverrideError, {
-              property: prop
-            })
-          );
-        }
-        break;
-      }
-    }
-    switch (sourceA.type) {
-      case "attribute": {
-        const b = sourceB;
-        return __spreadProps3(__spreadValues4({}, b), {
-          default: (_c = b.default) != null ? _c : sourceA.default
-        });
-      }
-      case "characters":
-        return sourceB;
-      case "element": {
-        const b = sourceB;
-        return __spreadProps3(__spreadValues4({}, b), {
-          required: sourceA.required || b.required,
-          rules: mergeXmlRules(sourceA.rules, b.rules)
-        });
-      }
-      case "elements": {
-        const b = sourceB;
-        const maxOccurs = sourceA.maxOccurs != null && b.maxOccurs != null ? Math.min(sourceA.maxOccurs, b.maxOccurs) : (_d = sourceA.maxOccurs) != null ? _d : b.maxOccurs;
-        return __spreadProps3(__spreadValues4({}, b), {
-          minOccurs: Math.max(sourceA.minOccurs, b.minOccurs),
-          maxOccurs,
-          useEmptyArrays: sourceA.useEmptyArrays || b.useEmptyArrays,
-          rules: mergeXmlRules(sourceA.rules, b.rules)
-        });
-      }
-    }
-  }
-  var EmptyRules = {
-    __type: /* @__PURE__ */ invariant(),
-    attributes: /* @__PURE__ */ new Map(),
-    elements: /* @__PURE__ */ new Map(),
-    characters: void 0
-  };
-  function mapXmlRules(rules, parentNamespaceUri = null) {
-    var _a22, _b, _c;
-    const attributeRules = /* @__PURE__ */ new Map();
-    const elementRules = /* @__PURE__ */ new Map();
-    let charactersRule = void 0;
-    for (const property in rules) {
-      const handlerOrFunction = rules[property];
-      let handler;
-      if (typeof handlerOrFunction === "function") {
-        handler = handlerOrFunction();
-      } else {
-        handler = handlerOrFunction;
-      }
-      let key;
-      switch (handler.type) {
-        case "characters":
-          if (charactersRule !== void 0)
-            throw new IllegalArgumentError(
-              "characters handler already defined"
-            );
-          charactersRule = {
-            property,
-            parse: handler.parse,
-            stringify: handler.stringify
-          };
-          break;
-        case "element":
-        case "elements": {
-          const localPart = (_a22 = handler.localPart) != null ? _a22 : property;
-          const namespaceUri = handler.namespaceUri === void 0 ? parentNamespaceUri : handler.namespaceUri;
-          key = xmlRuleKey(localPart, namespaceUri);
-          if (elementRules.has(key)) {
-            throw new IllegalArgumentError(
-              `Multiple element rules for ${key}`
-            );
-          }
-          if (handler.type === "element") {
-            const rules2 = handler.rules;
-            elementRules.set(key, {
-              array: false,
-              property,
-              minOccurs: handler.required ? 1 : 0,
-              maxOccurs: 1,
-              rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
-              useEmptyArrays: false,
-              localPart,
-              namespaceUri
-            });
-          } else {
-            const rules2 = handler.rules;
-            elementRules.set(key, {
-              array: true,
-              property,
-              maxOccurs: handler.maxOccurs,
-              minOccurs: handler.minOccurs,
-              rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
-              useEmptyArrays: handler.useEmptyArrays,
-              localPart,
-              namespaceUri
-            });
-          }
-          break;
-        }
-        case "attribute": {
-          const namespaceUri = handler.namespaceUri;
-          const localPart = (_b = handler.localPart) != null ? _b : property;
-          key = xmlRuleKey(localPart, namespaceUri);
-          if (attributeRules.has(key)) {
-            throw new IllegalArgumentError(
-              `Multiple attribute rules for ${key}`
-            );
-          }
-          attributeRules.set(key, {
-            property,
-            default: handler.default,
-            parse: handler.parse,
-            stringify: handler.stringify,
-            required: handler.required,
-            localPart,
-            namespaceUri: (_c = handler.namespaceUri) != null ? _c : null
-          });
-          break;
-        }
-      }
-    }
-    return {
-      __type: invariant(),
-      attributes: attributeRules,
-      elements: elementRules,
-      characters: charactersRule
-    };
-  }
-  function xmlRuleKey(localPart, namespaceUri = null) {
-    return `${namespaceUri != null ? namespaceUri : ""}:${localPart}`;
-  }
-  function getRule(name, rules) {
-    return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
-  }
-  var ParseXmlHandlerImpl = class {
-    constructor(rules, options) {
-      this.rules = rules;
-      __publicField5(this, "stack", []);
-      __publicField5(this, "options");
-      __publicField5(this, "busy", false);
-      this.options = __spreadValues4({ validateRules: true }, options);
-    }
-    startDocument() {
-      if (this.busy)
-        throw new IllegalStateError("XML content handler is busy");
-      this.busy = true;
-      const rules = this.rules;
-      this.stack.push({
-        element: new XmlElementImpl(),
-        rules,
-        characters: ""
-      });
-    }
-    startElement(name, attributes) {
-      var _a22;
-      const parent = last(this.stack);
-      let element2 = null;
-      const elementRule = getRule(name, parent.rules.elements);
-      const rules = (_a22 = elementRule == null ? void 0 : elementRule.rules()) != null ? _a22 : EmptyRules;
-      if (elementRule) {
-        const prop = elementRule.property;
-        element2 = new XmlElementImpl(parent.element);
-        if (elementRule.array) {
-          const arr = parent.element[prop];
-          if (Array.isArray(arr)) {
-            arr.push(element2);
-          } else {
-            parent.element[prop] = [element2];
-          }
-        } else {
-          if (parent.element[prop]) {
-            throw new XmlSchemaError(
-              `Expected single element with name ${name.qName}`
-            );
-          } else {
-            parent.element[prop] = element2;
-          }
-        }
-        const attributeRules = rules.attributes;
-        for (const k in attributes) {
-          const attribute = attributes[k];
-          const name2 = attribute.name;
-          const attributeRule = getRule(name2, attributeRules);
-          if (attributeRule) {
-            element2[attributeRule.property] = attributeRule.parse(
-              attribute.value
-            );
-          }
-        }
-        attributeRules.forEach((_value, key) => {
-          const rule = attributeRules.get(key);
-          if (!(rule.property in element2)) {
-            if (rule.default != null) {
-              element2[rule.property] = rule.default;
-            } else if (this.options.validateRules && rule.required) {
-              throw new XmlSchemaError(
-                substitute(xmlSchemaErrorLocale.requiredAttribute, {
-                  property: rule.property
-                })
-              );
-            }
-          }
-        });
-      }
-      this.stack.push({
-        element: element2,
-        rules,
-        characters: ""
-      });
-    }
-    textNode(str) {
-      const current = last(this.stack);
-      if (!current.rules.characters) return;
-      current.characters += decodeEntities(str.trim());
-    }
-    cDataNode(str) {
-      const current = last(this.stack);
-      if (!current.rules.characters) return;
-      current.characters += str;
-    }
-    endElement() {
-      const lastEl = this.stack.pop();
-      const charactersRule = lastEl.rules.characters;
-      if (charactersRule)
-        lastEl.element[charactersRule.property] = charactersRule.parse(
-          lastEl.characters
-        );
-      lastEl.rules.elements.forEach((rule) => {
-        if (rule.array && !(rule.property in lastEl.element)) {
-          if (rule.useEmptyArrays) {
-            lastEl.element[rule.property] = [];
-          }
-        }
-      });
-      this.validate(lastEl);
+     * Creates a validator that asserts that the input number is finite.
+     */
+    finite() {
+      return createValidator(locale10.finite, (input) => Number.isFinite(input));
+    },
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    safeInteger() {
+      return createValidator(
+        locale10.safeInteger,
+        (input) => Number.isSafeInteger(input)
+      );
     }
-    endDocument() {
-      this.busy = false;
-      const last3 = this.stack.pop();
-      this.validate(last3);
-      return last3.element;
+  };
+  var _NumberSchema = class _NumberSchema extends ValueSchema {
+    /**
+     * The base Object validator validating that the input is an object.
+     */
+    static get base() {
+      if (this._base == null)
+        this._base = new _NumberSchema(typeOfValidators.number);
+      return this._base;
     }
-    validate(current) {
-      if (!this.options.validateRules) return;
-      current.rules.elements.forEach((rule) => {
-        var _a22, _b;
-        const length = rule.array ? (_b = (_a22 = current.element[rule.property]) == null ? void 0 : _a22.length) != null ? _b : 0 : current.element[rule.property] ? 1 : 0;
-        if (length < rule.minOccurs) {
-          throw new XmlSchemaError(
-            substitute(xmlSchemaErrorLocale.atLeastElements, {
-              property: rule.property,
-              expected: rule.minOccurs,
-              actual: length
-            })
-          );
-        }
-        if (rule.maxOccurs != null && length > rule.maxOccurs) {
-          throw new XmlSchemaError(
-            substitute(xmlSchemaErrorLocale.atMostElements, {
-              property: rule.property,
-              expected: rule.maxOccurs,
-              actual: length
-            })
-          );
-        }
-      });
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * value.
+     *
+     * @param min The minimum (inclusive) the value may be.
+     */
+    gte(min) {
+      return this.chain(numberValidators.gte(min));
     }
-  };
-  var parentSymbol = /* @__PURE__ */ Symbol("parent");
-  var _a;
-  _a = parentSymbol;
-  var _XmlElementImpl = class _XmlElementImpl2 {
-    constructor(parent = null) {
-      __publicField5(this, _a);
-      this[parentSymbol] = parent;
+    /**
+     * Creates a validator that asserts that the input number is greater than the provided minimum
+     * value.
+     *
+     * @param min The minimum (exclusive) the value may be.
+     */
+    gt(min) {
+      return this.chain(numberValidators.gt(min));
     }
-    get parent() {
-      return this[parentSymbol];
+    /**
+     * Creates a validator that asserts that the input number is at most the provided maximum
+     * value.
+     *
+     * @param max The maximum (inclusive) the value may be.
+     */
+    lte(max) {
+      return this.chain(numberValidators.lte(max));
     }
-    set parent(value) {
-      this[parentSymbol] = value;
+    /**
+     * Creates a validator that asserts that the input number is less than the provided maximum
+     * value.
+     *
+     * @param max The maximum (exclusive) the value may be.
+     */
+    lt(max) {
+      return this.chain(numberValidators.lt(max));
     }
-    clone() {
-      const out = new _XmlElementImpl2(this.parent);
-      for (const key in this) {
-        const child = clone(this[key]);
-        if (Array.isArray(child)) {
-          for (const e of child) {
-            if (typeof e === "object" && "parent" in e) e.parent = out;
-          }
-        } else if (typeof child === "object" && "parent" in child) {
-          child.parent = out;
-        }
-        out[key] = child;
-      }
-      return out;
+    /**
+     * Creates a validator that asserts that the input number is at least the provided minimum
+     * and at most the provided maximum values.
+     *
+     * @param min The minimum (inclusive) value the input may be.
+     * @param max The maximum (inclusive) value the input may be.
+     */
+    within(min, max) {
+      return this.chain(numberValidators.within(min, max));
     }
-    toJSON() {
-      const out = {};
-      for (const key in this) {
-        out[key] = toJson(this[key]);
-      }
-      return out;
+    /**
+     * Creates a validator that asserts that the input number is finite.
+     */
+    finite() {
+      return this.chain(numberValidators.finite());
+    }
+    /**
+     * Creates a validator that asserts that the input number is a safe integer.
+     */
+    safeInteger() {
+      return this.chain(numberValidators.safeInteger());
     }
   };
-  var XmlElementImpl = _XmlElementImpl;
-  var actuateValidator = /* @__PURE__ */ isOneOf("onLoad", "onRequest");
-  function assertActuateEnum(str) {
-    actuateValidator.assert(str, ErrorOrigin.PARSING);
-    return str;
-  }
+  __publicField(_NumberSchema, "_base", null);
+  var NumberSchema = _NumberSchema;
 
-  // ../vinyl-mpd-parser/dist/index.js
-  var __defProp6 = Object.defineProperty;
-  var __defProps4 = Object.defineProperties;
-  var __getOwnPropDescs4 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols5 = Object.getOwnPropertySymbols;
-  var __hasOwnProp5 = Object.prototype.hasOwnProperty;
-  var __propIsEnum5 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp6 = (obj, key, value) => key in obj ? __defProp6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues5 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp5.call(b, prop))
-        __defNormalProp6(a, prop, b[prop]);
-    if (__getOwnPropSymbols5)
-      for (var prop of __getOwnPropSymbols5(b)) {
-        if (__propIsEnum5.call(b, prop))
-          __defNormalProp6(a, prop, b[prop]);
-      }
-    return a;
+  // ../vinyl-validation/src/validation/validators.ts
+  var locale11 = {
+    isOneOf: "one of: {value}",
+    instanceOf: "instance of {value}",
+    oneOfSeparator: " | "
   };
-  var __spreadProps4 = (a, b) => __defProps4(a, __getOwnPropDescs4(b));
-  var CENC_NAMESPACE_URI = "urn:mpeg:cenc:2013";
-  var PLAY_READY_NAMESPACE_URI = "urn:microsoft:playready";
-  function throwParsingError(message) {
-    throw new ValidationError(message, ErrorOrigin.PARSING);
-  }
-  var ratioRegExp = /^([0-9]*):([0-9]*)$/;
-  function parseRatio(str) {
-    const match = str ? ratioRegExp.exec(str) : null;
-    if (!match) throwParsingError(`invalid ratio format: ${str}`);
-    return [parseInt(match[1] || "1"), parseInt(match[2] || "1")];
-  }
-  function stringifyRatio(value) {
-    return `${value[0]}:${value[1]}`;
-  }
-  var framerateRegexp = /^(\d+)(?:\/(\d+))?$/;
-  function parseFrameRate(str) {
-    const match = str ? framerateRegexp.exec(str) : null;
-    if (!match) throwParsingError(`invalid frame rate: '${str}'`);
-    return [parseInt(match[1]), parseInt(match[2] || "1")];
-  }
-  function stringifyFrameRate(value) {
-    return value[1] === 1 ? value[0].toString() : `${value[0]}/${value[1]}`;
+  function isOneOf(...possibleValues) {
+    return new ValueSchema(
+      createValidator(
+        substitute(locale11.isOneOf, {
+          value: possibleValues.join(locale11.oneOfSeparator)
+        }),
+        (input) => possibleValues.includes(input)
+      )
+    );
   }
-  var byteRangeExp = /^(-?[0-9]+)-(-?[0-9]*)$/;
-  function parseByteRange(str) {
-    const match = str ? byteRangeExp.exec(str) : null;
-    if (!match) throwParsingError(`invalid byte range: '${str}'`);
-    let start = parseInt(match[1]);
-    if (start < 0) start >>>= 0;
-    let end = parseIntSafe(match[2]);
-    if (end != null && end < 0) end = end >>> 0;
-    return [start, end];
+  function number() {
+    return NumberSchema.base;
   }
-  function stringifyByteRange(value) {
-    const end = value[1];
-    return `${value[0]}-${end == null ? "" : end}`;
+
+  // ../vinyl-xml/src/xlink/actuateValidator.ts
+  var actuateValidator = isOneOf("onLoad", "onRequest");
+  function assertActuateEnum(str) {
+    actuateValidator.assert(str, ErrorOrigin.PARSING);
+    return str;
   }
+
+  // ../vinyl-mpd-parser/src/duration/duration.ts
   var I = 60;
   var H = 3600;
   var D = 86400;
@@ -4188,6 +3643,8 @@ ${this.lastInitStack}` : "";
     if (seconds > 0 || !value) isoString += `${roundToNearest(seconds, 1e-3)}S`;
     return isoString;
   }
+
+  // ../vinyl-mpd-parser/src/manifest/dashManifestXmlRules.ts
   var dashNamespaceUri = "urn:mpeg:dash:schema:mpd:2011";
   function dashManifestXmlRules() {
     const attrActuateType = attr(assertActuateEnum, stringify, {
@@ -4239,7 +3696,7 @@ ${this.lastInitStack}` : "";
     const segmentTimelineType = {
       S: elements(segmentTimelineTypeSType)
     };
-    const multipleSegmentBaseType = __spreadProps4(__spreadValues5({}, segmentBaseType), {
+    const multipleSegmentBaseType = __spreadProps(__spreadValues({}, segmentBaseType), {
       SegmentTimeline: element(segmentTimelineType),
       BitstreamSwitching: element(urlType),
       duration: attrInt,
@@ -4251,12 +3708,12 @@ ${this.lastInitStack}` : "";
       media: attrString,
       mediaRange: attr(parseByteRange, stringifyByteRange)
     };
-    const segmentListType = __spreadProps4(__spreadValues5({}, multipleSegmentBaseType), {
+    const segmentListType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
       actuate: attrActuateType,
       href: attrString,
       SegmentURL: elements(segmentURLType)
     });
-    const segmentTemplateType = __spreadProps4(__spreadValues5({}, multipleSegmentBaseType), {
+    const segmentTemplateType = __spreadProps(__spreadValues({}, multipleSegmentBaseType), {
       bitstreamSwitching: attrString,
       index: attrString,
       initialization: attrString,
@@ -4308,13 +3765,13 @@ ${this.lastInitStack}` : "";
       startWithSAP: attr(parseSap, stringify),
       width: attrInt
     };
-    const subRepresentationType = __spreadProps4(__spreadValues5({}, representationBaseType), {
+    const subRepresentationType = __spreadProps(__spreadValues({}, representationBaseType), {
       bandwidth: attrInt,
       contentComponent: attr(parseStringVector, stringifyStringVector),
       dependencyLevel: attr(parseIntVector, stringifyIntVector),
       level: attrInt
     });
-    const representationType = __spreadProps4(__spreadValues5({}, representationBaseType), {
+    const representationType = __spreadProps(__spreadValues({}, representationBaseType), {
       bandwidth: attrInt({ required: true }),
       bitrate: attrInt,
       dependencyId: attr(parseStringVector, stringifyStringVector),
@@ -4327,7 +3784,7 @@ ${this.lastInitStack}` : "";
       SegmentTemplate: element(segmentTemplateType),
       SubRepresentation: elements(subRepresentationType)
     });
-    const adaptationSetType = __spreadProps4(__spreadValues5({}, representationBaseType), {
+    const adaptationSetType = __spreadProps(__spreadValues({}, representationBaseType), {
       Accessibility: elements(descriptorType),
       Role: elements(descriptorType),
       Rating: elements(descriptorType),
@@ -4438,7 +3895,7 @@ ${this.lastInitStack}` : "";
   function stringifyProfiles(value) {
     return value.join(",");
   }
-  var videoScanTypeValidator = /* @__PURE__ */ isOneOf(
+  var videoScanTypeValidator = isOneOf(
     "progressive",
     "interlaced",
     "unknown"
@@ -4447,7 +3904,7 @@ ${this.lastInitStack}` : "";
     videoScanTypeValidator.assert(str, ErrorOrigin.PARSING);
     return str;
   }
-  var switchingTypeTypeValidator = /* @__PURE__ */ isOneOf(
+  var switchingTypeTypeValidator = isOneOf(
     "media",
     "bitstream"
   );
@@ -4455,7 +3912,7 @@ ${this.lastInitStack}` : "";
     switchingTypeTypeValidator.assert(str, ErrorOrigin.PARSING);
     return str;
   }
-  var validateSap = /* @__PURE__ */ number().within(0, 6);
+  var validateSap = number().within(0, 6);
   function parseSap(str) {
     const number2 = parseInt(str);
     validateSap.assert(number2, ErrorOrigin.PARSING);
@@ -4473,7 +3930,7 @@ ${this.lastInitStack}` : "";
   function stringifyIntVector(value) {
     return value.join(" ");
   }
-  var presentationTypeValidator = /* @__PURE__ */ isOneOf(
+  var presentationTypeValidator = isOneOf(
     "static",
     "dynamic"
   );
@@ -4492,11 +3949,13 @@ ${this.lastInitStack}` : "";
         return parseInt(str);
     }
   }
+
+  // ../vinyl-mpd-parser/src/manifest/ext/drm/cencXmlRules.ts
   var cencXmlRules = {
-    default_KID: /* @__PURE__ */ attr(parseStringVector, stringifyStringVector, {
+    default_KID: attr(parseStringVector, stringifyStringVector, {
       namespaceUri: CENC_NAMESPACE_URI
     }),
-    pssh: /* @__PURE__ */ element(
+    pssh: element(
       {
         _content: charactersString
       },
@@ -4505,6 +3964,8 @@ ${this.lastInitStack}` : "";
       }
     )
   };
+
+  // ../vinyl-mpd-parser/src/manifest/ext/drm/contentProtection.ts
   function createDashProtectionXmlRules(contentProtectionRules) {
     const withProtections = {
       ContentProtection: elements(contentProtectionRules)
@@ -4514,8 +3975,8 @@ ${this.lastInitStack}` : "";
         {
           Period: elements(
             {
-              AdaptationSet: elements(__spreadProps4(__spreadValues5({}, withProtections), {
-                Representation: elements(__spreadProps4(__spreadValues5({}, withProtections), {
+              AdaptationSet: elements(__spreadProps(__spreadValues({}, withProtections), {
+                Representation: elements(__spreadProps(__spreadValues({}, withProtections), {
                   SubRepresentation: elements(
                     withProtections
                   )
@@ -4531,8 +3992,10 @@ ${this.lastInitStack}` : "";
       )
     };
   }
+
+  // ../vinyl-mpd-parser/src/manifest/ext/drm/playreadyXmlRules.ts
   var playreadyXmlRules = {
-    pro: /* @__PURE__ */ element(
+    pro: element(
       {
         _content: charactersString
       },
@@ -4541,12 +4004,14 @@ ${this.lastInitStack}` : "";
       }
     )
   };
-  var dashDrmRules = /* @__PURE__ */ mergeXmlRules(
-    /* @__PURE__ */ dashManifestXmlRules(),
-    /* @__PURE__ */ createDashProtectionXmlRules(cencXmlRules),
-    /* @__PURE__ */ createDashProtectionXmlRules(playreadyXmlRules)
+
+  // ../vinyl-mpd-parser/src/manifest/dashParser.ts
+  var dashDrmRules = mergeXmlRules(
+    dashManifestXmlRules(),
+    createDashProtectionXmlRules(cencXmlRules),
+    createDashProtectionXmlRules(playreadyXmlRules)
   );
-  var dashDrmRulesMapped = /* @__PURE__ */ mapXmlRules(dashDrmRules);
+  var dashDrmRulesMapped = mapXmlRules(dashDrmRules);
   function dashManifestHandler() {
     return new ParseXmlHandlerImpl(dashDrmRulesMapped);
   }
@@ -4628,36 +4093,113 @@ ${this.lastInitStack}` : "";
     ((_a2 = getSearchParams().get("checkAudio")) != null ? _a2 : "0").toLowerCase()
   );
 
-  // test/vinylTestUtil/mock/track/MockTrackController.ts
+  // ../vinyl-util/test/testUtil/reporters/LogReporter.ts
+  var consoleMethodLevels = {
+    debug: 1 /* DEBUG */,
+    log: 1 /* DEBUG */,
+    warn: 3 /* WARN */,
+    info: 2 /* INFO */,
+    error: 4 /* ERROR */
+  };
+
+  // ../vinyl-util/test/testUtil/mock/network/emptyRequestInfo.ts
+  var emptyRequestInfo = {
+    requestId: "",
+    requestOptions: { readErrorBody: 0 /* DISABLED */, serviceId: null },
+    init: {},
+    input: "",
+    maxRetries: 0,
+    timestamp: 0
+  };
+  var emptyRequestAttemptInfo = {
+    currentTry: 0,
+    timestamp: 0
+  };
+  var emptyResponseInfo = {
+    ok: false,
+    redirected: false,
+    status: 0,
+    statusText: "",
+    type: "default",
+    url: "",
+    contentLength: 0
+  };
+  var emptyInternalError = {
+    ok: false,
+    reason: null,
+    requestInfo: emptyRequestInfo,
+    retryAfter: null,
+    timestamp: 0,
+    type: "internal" /* INTERNAL */,
+    willRetry: false
+  };
+  var emptyNetworkError = {
+    ok: false,
+    reason: null,
+    requestInfo: emptyRequestInfo,
+    retryAfter: null,
+    timestamp: 0,
+    type: "network" /* NETWORK */,
+    willRetry: false,
+    attemptInfo: emptyRequestAttemptInfo
+  };
+  var emptyResponseError = {
+    ok: false,
+    reason: null,
+    requestInfo: emptyRequestInfo,
+    retryAfter: null,
+    timestamp: 0,
+    type: "response" /* RESPONSE */,
+    willRetry: false,
+    attemptInfo: emptyRequestAttemptInfo,
+    responseInfo: emptyResponseInfo
+  };
+  var emptyAbortError = __spreadProps(__spreadValues({}, emptyInternalError), {
+    type: "abort" /* ABORT */
+  });
+
+  // ../vinyl-util/test/testUtil/mock/network/MockRequester.ts
   var spyFactory = createSpyFactory();
 
-  // test/vinylTestUtil/mock/track/MockTrack.ts
+  // ../vinyl-util/test/testUtil/mock/network/MockNetworkState.ts
   var spyFactory2 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/track/MockAutoResetController.ts
+  // ../vinyl-util/test/testUtil/mock/network/MockNetworkMetricsController.ts
   var spyFactory3 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/hls/MockHlsManifestController.ts
+  // ../vinyl-util/test/testUtil/mock/logging/MockLogger.ts
   var spyFactory4 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/streaming/buffering/MockMediaSourceController.ts
+  // test/vinylTestUtil/mock/track/MockTrackController.ts
   var spyFactory5 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/playback/MockPlaybackSource.ts
+  // test/vinylTestUtil/mock/track/MockTrack.ts
   var spyFactory6 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/streaming/MockContentStream.ts
+  // test/vinylTestUtil/mock/track/MockAutoResetController.ts
   var spyFactory7 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/playback/MockPlaybackController.ts
+  // test/vinylTestUtil/mock/hls/MockHlsManifestController.ts
   var spyFactory8 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/drm/MockDrmController.ts
+  // test/vinylTestUtil/mock/streaming/buffering/MockMediaSourceController.ts
   var spyFactory9 = createSpyFactory();
 
-  // test/vinylTestUtil/mock/track/hls/createMockHlsDependencies.ts
+  // test/vinylTestUtil/mock/playback/MockPlaybackSource.ts
   var spyFactory10 = createSpyFactory();
 
+  // test/vinylTestUtil/mock/streaming/MockContentStream.ts
+  var spyFactory11 = createSpyFactory();
+
+  // test/vinylTestUtil/mock/playback/MockPlaybackController.ts
+  var spyFactory12 = createSpyFactory();
+
+  // test/vinylTestUtil/mock/drm/MockDrmController.ts
+  var spyFactory13 = createSpyFactory();
+
+  // test/vinylTestUtil/mock/track/hls/createMockHlsDependencies.ts
+  var spyFactory14 = createSpyFactory();
+
   // test/vinylTestUtil/mock/dash/mockDashManifest.ts
   var mockDashManifest = parseDashManifest(
     // language=XML
@@ -4672,69 +4214,69 @@ ${this.lastInitStack}` : "";
   );
 
   // test/vinylTestUtil/mock/dash/MockDashManifestController.ts
-  var spyFactory11 = createSpyFactory();
+  var spyFactory15 = createSpyFactory();
 
   // test/vinylTestUtil/mock/track/dash/createMockDashDependencies.ts
-  var spyFactory12 = createSpyFactory();
+  var spyFactory16 = createSpyFactory();
 
   // test/vinylTestUtil/mock/streaming/MockSegmentController.ts
-  var spyFactory13 = createSpyFactory();
+  var spyFactory17 = createSpyFactory();
 
   // test/vinylTestUtil/mock/streaming/buffering/MockSourceBufferController.ts
-  var spyFactory14 = createSpyFactory();
+  var spyFactory18 = createSpyFactory();
 
   // test/vinylTestUtil/mock/streaming/buffering/MockBufferingController.ts
-  var spyFactory15 = createSpyFactory();
+  var spyFactory19 = createSpyFactory();
 
   // test/vinylTestUtil/mock/streaming/abr/MockQualitySelector.ts
-  var spyFactory16 = createSpyFactory();
+  var spyFactory20 = createSpyFactory();
 
   // test/vinylTestUtil/mock/client/MockCapabilities.ts
-  var spyFactory17 = createSpyFactory();
+  var spyFactory21 = createSpyFactory();
 
   // test/vinylTestUtil/mock/playback/MockLoudnessNormalizationController.ts
-  var spyFactory18 = createSpyFactory();
+  var spyFactory22 = createSpyFactory();
 
   // test/vinylTestUtil/mock/logging/MockHistoryLogHandler.ts
-  var spyFactory19 = createSpyFactory();
+  var spyFactory23 = createSpyFactory();
 
   // test/vinylTestUtil/mock/drm/MockCommonMediaKeys.ts
-  var spyFactory20 = createSpyFactory();
+  var spyFactory24 = createSpyFactory();
 
   // test/vinylTestUtil/mock/drm/MockCommonMediaKeySystemAccess.ts
-  var spyFactory21 = createSpyFactory();
+  var spyFactory25 = createSpyFactory();
 
   // test/vinylTestUtil/mock/drm/MockCommonMediaKeySession.ts
-  var spyFactory22 = createSpyFactory();
+  var spyFactory26 = createSpyFactory();
 
   // test/vinylTestUtil/mock/drm/MockCommonEme.ts
-  var spyFactory23 = createSpyFactory();
+  var spyFactory27 = createSpyFactory();
 
   // test/vinylTestUtil/mock/dom/webkit/MockWebKitMediaKeys.ts
-  var spyFactory24 = createSpyFactory();
+  var spyFactory28 = createSpyFactory();
   var MockWebKitMediaKeys = class {
     constructor(keySystem) {
-      this.keySystem = keySystem;
-      __publicField(this, "createSession", spyFactory24("createSession"));
+      __publicField(this, "keySystem", keySystem);
+      __publicField(this, "createSession", spyFactory28("createSession"));
     }
   };
-  __publicField(MockWebKitMediaKeys, "isTypeSupported", spyFactory24("isTypeSupported"));
+  __publicField(MockWebKitMediaKeys, "isTypeSupported", spyFactory28("isTypeSupported"));
 
   // test/vinylTestUtil/mock/dom/webkit/MockWebKitMediaKeySession.ts
-  var spyFactory25 = createSpyFactory();
+  var spyFactory29 = createSpyFactory();
 
   // test/vinylTestUtil/mock/dom/ms/MockMSMediaKeys.ts
-  var spyFactory26 = createSpyFactory();
+  var spyFactory30 = createSpyFactory();
   var MockMSMediaKeys = class {
     constructor(keySystem) {
-      this.keySystem = keySystem;
-      __publicField(this, "createSession", spyFactory26("createSession"));
+      __publicField(this, "keySystem", keySystem);
+      __publicField(this, "createSession", spyFactory30("createSession"));
     }
   };
-  __publicField(MockMSMediaKeys, "isTypeSupported", spyFactory26("isTypeSupported"));
+  __publicField(MockMSMediaKeys, "isTypeSupported", spyFactory30("isTypeSupported"));
 
   // test/vinylTestUtil/mock/dom/ms/MockMSMediaKeySession.ts
-  var spyFactory27 = createSpyFactory();
+  var spyFactory31 = createSpyFactory();
 
   // test/vinylTestUtil/assets/dash_segmentListMediaRange.ts
   var dash_segmentListMediaRange = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>