@amazon/vinyl-hls-parser 1.1.1 → 1.2.1

package/dist/test/integ.js

@@ -1,2127 +0,0 @@
-"use strict";
-(() => {
-  var __defProp = Object.defineProperty;
-  var __defProps = Object.defineProperties;
-  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __propIsEnum = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    if (__getOwnPropSymbols)
-      for (var prop of __getOwnPropSymbols(b)) {
-        if (__propIsEnum.call(b, prop))
-          __defNormalProp(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-
-  // ../vinyl-util/dist/index.js
-  var __defProp2 = Object.defineProperty;
-  var __defProps2 = Object.defineProperties;
-  var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
-  var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-  var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues2 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp2.call(b, prop))
-        __defNormalProp2(a, prop, b[prop]);
-    if (__getOwnPropSymbols2)
-      for (var prop of __getOwnPropSymbols2(b)) {
-        if (__propIsEnum2.call(b, prop))
-          __defNormalProp2(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
-  var __publicField = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
-  function invariant() {
-    return void 0;
-  }
-  var ErrorOrigin = {
-    /**
-     * The error originated from Vinyl and was reported from the uncaught exception or promise
-     * rejection handlers.
-     */
-    UNCAUGHT: "uncaught",
-    /**
-     * The error originated from Vinyl and was caught.
-     */
-    INTERNAL: "internal",
-    /**
-     * A Vinyl interface was used incorrectly by a consumer.
-     */
-    API: "api",
-    /**
-     * The error originated from a failed service call (500 errors).
-     */
-    SERVICE_EXTERNAL: "serviceExternal",
-    /**
-     * The error originated from a failed service call (400 errors).
-     */
-    SERVICE_INTERNAL: "serviceInternal",
-    /**
-     * The error originated from a problem playing provided media.
-     * The reporter is from a component such as the element, source buffer, media source, etc.
-     */
-    MEDIA: "media",
-    /**
-     * The error originated from a problem parsing input data.
-     * Such as a malformed Dash or HLS manifest.
-     */
-    PARSING: "parsing",
-    /**
-     * The error originated from an incompatibility with browser APIs,
-     * such as EME.
-     */
-    COMPATIBILITY: "compatibility",
-    /**
-     * The error originated from DRM.
-     * This does not include internal or service errors, only errors from the creation of media keys or media key
-     * sessions.
-     */
-    DRM: "drm"
-  };
-  var ReportableError = class _ReportableError extends Error {
-    constructor(message, origin = ErrorOrigin.INTERNAL, level = "fatal") {
-      super(message);
-      this.origin = origin;
-      this.level = level;
-      Object.setPrototypeOf(this, _ReportableError.prototype);
-    }
-    get [Symbol.toStringTag]() {
-      return "ReportableError";
-    }
-    get name() {
-      return this[Symbol.toStringTag];
-    }
-    /**
-     * All ReportableError instances must be serializable.
-     */
-    toJSON() {
-      return {
-        level: this.level,
-        message: this.message,
-        name: this.name,
-        origin: this.origin,
-        stack: this.stack
-      };
-    }
-  };
-  var IllegalArgumentError = class _IllegalArgumentError extends ReportableError {
-    constructor(message, isInternal = true) {
-      super(message, isInternal ? ErrorOrigin.INTERNAL : ErrorOrigin.API);
-      this.isInternal = isInternal;
-      Object.setPrototypeOf(this, _IllegalArgumentError.prototype);
-    }
-    get [Symbol.toStringTag]() {
-      return "IllegalArgumentError";
-    }
-  };
-  var locale = {
-    variableNotDefined: "Variable '{name}' is not defined"
-  };
-  var DEFAULT_SUBSTITUTE_PATTERN = /\{(\w+)}/g;
-  function substitute(str, variables, pattern = DEFAULT_SUBSTITUTE_PATTERN) {
-    return str.replace(pattern, (_, name) => {
-      if (!(name in variables)) {
-        throw new IllegalArgumentError(
-          locale.variableNotDefined.replace("{name}", String(name))
-        );
-      }
-      return String(variables[name]);
-    });
-  }
-  function isWhitespaceChar(charCode) {
-    return charCode === 32 || // ' ' (space)
-    charCode === 9 || // '\t' (tab)
-    charCode === 13 || // '\r' (carriage return)
-    charCode === 10;
-  }
-  function eqStr(a, b, ignoreCase = false) {
-    if (a == null && b == null) return true;
-    if (a == null || b == null) return false;
-    if (a === b) return true;
-    if (ignoreCase)
-      return a.length === b.length && a.toLowerCase() === b.toLowerCase();
-    return false;
-  }
-  function char(str) {
-    return str.charCodeAt(0);
-  }
-  function truncate(str, maxLength, indicator = "\u2026") {
-    if (str == null) return str;
-    if (str.length > maxLength)
-      return str.substring(0, maxLength - indicator.length) + indicator;
-    return str;
-  }
-  function clamp(value, min2, max2) {
-    return Math.min(Math.max(value, min2), max2);
-  }
-  function printStringPosition(str, index, options) {
-    var _a;
-    const caret = (options == null ? void 0 : options.caret) || "^";
-    index = clamp(index, 0, str.length);
-    const minIndex = str.lastIndexOf("\n", index - 1) + 1;
-    let maxIndex = str.indexOf("\n", index);
-    if (maxIndex === -1) maxIndex = str.length;
-    const split = (options == null ? void 0 : options.split) === void 0 ? 0.6 : options.split;
-    const cols = ((_a = options == null ? void 0 : options.maxColumns) != null ? _a : 60) - caret.length;
-    let leadingChars = cols * split;
-    let trailingChars = cols * (1 - split);
-    const maxLeadingChars = index - minIndex;
-    const maxTrailingChars = maxIndex - index;
-    if (leadingChars > maxLeadingChars) {
-      trailingChars += leadingChars - maxLeadingChars;
-      leadingChars = maxLeadingChars;
-      if (trailingChars > maxTrailingChars) trailingChars = maxTrailingChars;
-    } else if (trailingChars > maxTrailingChars) {
-      leadingChars += trailingChars - maxTrailingChars;
-      trailingChars = maxTrailingChars;
-      if (leadingChars > maxLeadingChars) leadingChars = maxLeadingChars;
-    }
-    let out = str.substring(index - leadingChars, index + trailingChars) + "\n";
-    out += " ".repeat(leadingChars) + caret;
-    return out;
-  }
-  var StringReader = class {
-    /**
-     * @param data The string to read.
-     */
-    constructor(data) {
-      this.data = data;
-      __publicField(this, "position", 0);
-    }
-    /**
-     * Returns true if the current {@link position} is less than the source data's length.
-     */
-    hasNext() {
-      return this.position < this.data.length;
-    }
-    /**
-     * Returns the number of characters remaining to be read.
-     */
-    get remaining() {
-      return this.data.length - this.position;
-    }
-    /**
-     * Returns the length of {@link data}.
-     */
-    get length() {
-      return this.data.length;
-    }
-    /**
-     * Throws a {@link StringParseError} where the location uses {@link printStringPosition} to
-     * show a friendly message indicating the current position.
-     *
-     * @param message
-     * @param offset The offset to add to the current position.
-     */
-    err(message, offset = 0) {
-      throw new StringParseError(this.data, this.position + offset, message);
-    }
-    /**
-     * Reads and returns the character code at the current position.
-     * To read the next character without advancing the cursor, use {@link peek}
-     *
-     * Note:
-     * This method has no bounds checking; if {@link position} is greater than or equal to
-     * `str.length` then NaN will be returned and {@link position} will still be incremented.
-     *
-     * @see String.charCodeAt
-     */
-    next() {
-      return this.data.charCodeAt(this.position++);
-    }
-    /**
-     * Reads characters until the predicate returns false or the data length has been reached.
-     *
-     * @param predicate Given the char code at the cursor index, returns true if the character
-     * should be included in the substring result.
-     * @returns number The start position.
-     */
-    while(predicate) {
-      const start = this.position;
-      let i = start;
-      const n = this.data.length;
-      while (i < n && predicate(this.data.charCodeAt(i))) i++;
-      this.position = i;
-      return start;
-    }
-    /**
-     * Reads characters until the predicate returns true or the string length has been reached.
-     *
-     * @param predicate
-     * @returns number Returns the start index.
-     */
-    until(predicate) {
-      return this.while((charCode) => !predicate(charCode));
-    }
-    /**
-     * Reads characters until the given character has been found or the string length has been
-     * reached.
-     *
-     * @param charCode
-     * @return number Returns the start index.
-     */
-    untilChar(charCode) {
-      return this.until((cc) => cc === charCode);
-    }
-    /**
-     * Reads characters until the given string has been found or the string length has been
-     * reached.
-     *
-     * @param string The string to match
-     * @return number Returns the start index.
-     */
-    untilString(string) {
-      const start = this.position;
-      const index = this.data.indexOf(string, this.position);
-      this.position = index === -1 ? this.data.length : index;
-      return start;
-    }
-    /**
-     * The same as {@link while} except returns the read substring as a result.
-     */
-    substringWhile(predicate) {
-      return this.data.substring(this.while(predicate), this.position);
-    }
-    /**
-     * The same as {@link until} except returns the read substring as a result.
-     */
-    substringUntil(predicate) {
-      return this.substringWhile((charCode) => !predicate(charCode));
-    }
-    /**
-     * The same as {@link untilChar} except returns the read substring as a result.
-     */
-    substringUntilChar(charCode) {
-      return this.substringWhile((iCharCode) => charCode !== iCharCode);
-    }
-    /**
-     * Reads the substring from the current index with the given length.
-     *
-     * @param length
-     */
-    substr(length) {
-      const sub = this.data.substring(this.position, this.position + length);
-      this.position += sub.length;
-      return sub;
-    }
-    /**
-     * Reads the expected string from the current position.
-     * If the read string doesn't match the given string, a {@link StringParseError} is thrown.
-     *
-     * @param str The string required to match at the current position.
-     * @param ignoreCase If true, the comparison will be case-insensitive.
-     */
-    read(str, ignoreCase = false) {
-      const actual = this.substr(str.length);
-      if (!eqStr(actual, str, ignoreCase))
-        this.err(`Expected '${str}', actual: '${actual}'`);
-      return actual;
-    }
-    /**
-     * Reads the expected char code from the current position.
-     * If the read character doesn't match the given character, a {@link StringParseError} is
-     * thrown.
-     *
-     * @param charCode The character code required to match at the current position.
-     */
-    readChar(charCode) {
-      const actual = this.next();
-      if (actual !== charCode)
-        this.err(
-          `Expected '${String.fromCharCode(charCode)}', actual: '${String.fromCharCode(actual)}'`
-        );
-      return actual;
-    }
-    /**
-     * Returns the character at the current position without advancing the cursor.
-     *
-     * Note:
-     * This method has no bounds checking; if {@link position} is greater than or equal to
-     * `str.length` then `NaN` will be returned.
-     *
-     * @see String.charCodeAt
-     */
-    get peek() {
-      return this.data.charCodeAt(this.position);
-    }
-    /**
-     * Reads through all whitespace characters, returning the starting index.
-     */
-    white() {
-      return this.while(isWhitespaceChar);
-    }
-    /**
-     * If {@link peek} equals the given character code, returns true and advances the index by
-     * one.
-     *
-     * @param charCode
-     */
-    charIf(charCode) {
-      if (this.peek === charCode) {
-        this.next();
-        return true;
-      } else {
-        return false;
-      }
-    }
-    /**
-     * If the given string matches the substring at the current position, returns true and advances
-     * the index by the string's length.
-     */
-    stringIf(string, ignoreCase = false) {
-      if (this.remaining < string.length) return false;
-      const substr = this.data.substring(
-        this.position,
-        this.position + string.length
-      );
-      const match = eqStr(substr, string, ignoreCase);
-      if (match) this.position += string.length;
-      return match;
-    }
-  };
-  var locale2 = {
-    messageSeparator: ", at: \n"
-  };
-  var StringParseError = class _StringParseError extends ReportableError {
-    constructor(str, position, reason) {
-      const location2 = printStringPosition(str, position);
-      super(
-        `${reason}${locale2.messageSeparator}${location2}`,
-        ErrorOrigin.PARSING
-      );
-      this.position = position;
-      this.reason = reason;
-      __publicField(this, "location");
-      this.location = location2;
-      Object.setPrototypeOf(this, _StringParseError.prototype);
-    }
-    get [Symbol.toStringTag]() {
-      return "StringParseError";
-    }
-    toJSON() {
-      return __spreadProps2(__spreadValues2({}, super.toJSON()), {
-        position: this.position,
-        location: this.location,
-        reason: this.reason
-      });
-    }
-  };
-  function ownKeys(obj) {
-    if (!obj) return /* @__PURE__ */ new Set();
-    if (typeof Reflect !== "undefined")
-      return new Set(Reflect.ownKeys(obj));
-    const properties = /* @__PURE__ */ new Set();
-    Object.getOwnPropertyNames(obj).forEach((item) => properties.add(item));
-    Object.getOwnPropertySymbols(obj).forEach((item) => properties.add(item));
-    return properties;
-  }
-  function isPlainObject(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-      return false;
-    const proto = Object.getPrototypeOf(value);
-    return !proto || !Object.getPrototypeOf(proto);
-  }
-  function toJson(value) {
-    return toJsonInternal(value, /* @__PURE__ */ new Set());
-  }
-  function toJsonInternal(value, visited) {
-    switch (typeof value) {
-      case "object":
-        return objectToJsonInternal(value, visited);
-      case "undefined":
-      case "boolean":
-      case "number":
-      case "string":
-        return value;
-      case "function":
-        return `[function ${value.name}]`;
-      case "symbol":
-        return `[symbol ${value.toString().slice(7, -1)}]`;
-      case "bigint":
-        return value.toString();
-    }
-  }
-  function objectToJsonInternal(value, visited) {
-    if (value == null) return value;
-    if (visited.has(value)) return `<circular reference: ${String(value)}>`;
-    visited.add(value);
-    if ("toJSON" in value && typeof value.toJSON === "function")
-      return value.toJSON();
-    if (value instanceof Set) {
-      return Array.from(value).map((e) => toJsonInternal(e, visited));
-    } else if (Array.isArray(value)) {
-      return value.map((e) => toJsonInternal(e, visited));
-    } else {
-      if (isPlainObject(value)) {
-        const o = {};
-        for (const key in value) {
-          o[key] = toJsonInternal(value[key], visited);
-        }
-        return o;
-      } else if (value instanceof Error) {
-        return {
-          name: value.name,
-          message: value.message,
-          stack: value.stack
-        };
-      } else {
-        return value.toString();
-      }
-    }
-  }
-  function stringifyForPrint(value, maxLength, indicator = "\u2026") {
-    let str = JSON.stringify(
-      toJson(value),
-      (_, value2) => {
-        const type = typeof value2;
-        if (["undefined"].includes(type)) {
-          return `{{${String(value2)}}}`;
-        }
-        if (type === "number") {
-          if (Number.isNaN(value2) || !Number.isFinite(value2))
-            return `{{${value2.toString()}}}`;
-        }
-        return value2;
-      },
-      "  "
-    );
-    str = str.replace(/("\{\{.*}}")/g, (_, s) => {
-      return s.substring(3, s.length - 3);
-    });
-    if (maxLength) str = truncate(str, maxLength, indicator);
-    return str;
-  }
-  function merge(...sources) {
-    if (!sources.length) return void 0;
-    if (Array.isArray(sources[0])) return Array.prototype.concat(...sources);
-    return Object.assign({}, ...sources);
-  }
-  var ValidationError = class _ValidationError extends ReportableError {
-    /**
-     * @param message The validation error message.
-     * @param origin The error origin, typically API (default) or SERVICE_EXTERNAL
-     * @param path The property path to the invalid field.
-     */
-    constructor(message, origin = ErrorOrigin.API, path = []) {
-      super(message, origin);
-      this.path = path;
-      Object.setPrototypeOf(this, _ValidationError.prototype);
-    }
-    get [Symbol.toStringTag]() {
-      return "ValidationError";
-    }
-    toJSON() {
-      return __spreadProps2(__spreadValues2({}, super.toJSON()), {
-        origin: this.origin,
-        path: this.path
-      });
-    }
-  };
-
-  // ../vinyl-validation/dist/index.js
-  var __defProp3 = Object.defineProperty;
-  var __defProps3 = Object.defineProperties;
-  var __getOwnPropDescs3 = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols3 = Object.getOwnPropertySymbols;
-  var __hasOwnProp3 = Object.prototype.hasOwnProperty;
-  var __propIsEnum3 = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __spreadValues3 = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp3.call(b, prop))
-        __defNormalProp3(a, prop, b[prop]);
-    if (__getOwnPropSymbols3)
-      for (var prop of __getOwnPropSymbols3(b)) {
-        if (__propIsEnum3.call(b, prop))
-          __defNormalProp3(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps3 = (a, b) => __defProps3(a, __getOwnPropDescs3(b));
-  var __publicField2 = (obj, key, value) => __defNormalProp3(obj, typeof key !== "symbol" ? key + "" : key, value);
-  var validatorLocale = {
-    /**
-     * The expectation template string with the following replacement tokens:
-     *
-     * `{expected}` - The expected description.
-     * `{actual}` - The actual value.
-     * `{path}` - The path, dot separated.
-     */
-    template: "Expected: {expected}, but was: {actual}. At: {path}"
-  };
-  function createValidationExpectationMessage(expectationMessage, input, path, inputStringify = (input2) => stringifyForPrint(input2, 500)) {
-    return substitute(validatorLocale.template, {
-      expected: expectationMessage,
-      actual: inputStringify(input),
-      path: path.join(".")
-    });
-  }
-  function createValidator(expectationMessage, isValid, inputStringify = (input) => stringifyForPrint(input, 500)) {
-    return {
-      description: expectationMessage,
-      isValid(input) {
-        return isValid(input);
-      },
-      validate(input, _, path = []) {
-        if (!isValid(input)) {
-          return [
-            {
-              message: createValidationExpectationMessage(
-                expectationMessage,
-                input,
-                path,
-                inputStringify
-              ),
-              path
-            }
-          ];
-        }
-        return [];
-      },
-      assert: (input, origin, path = []) => {
-        if (!isValid(input)) {
-          throw new ValidationError(
-            createValidationExpectationMessage(
-              expectationMessage,
-              input,
-              path,
-              inputStringify
-            ),
-            origin,
-            path
-          );
-        }
-      }
-    };
-  }
-  function createDeepValidator(description, validate) {
-    return {
-      description,
-      isValid(input) {
-        return validate(input, { all: false }, []).length === 0;
-      },
-      validate(input, options, path = []) {
-        return validate(input, options != null ? options : { all: false }, path);
-      },
-      assert: (input, origin, path = []) => {
-        const errors = validate(input, { all: false }, path);
-        if (errors.length) {
-          const error = errors[0];
-          throw new ValidationError(error.message, origin, error.path);
-        }
-      }
-    };
-  }
-  var locale3 = {
-    /**
-     * {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(locale3.template, {
-        value: validators.map((v) => v.description).join(locale3.separator)
-      }),
-      (input, options, path) => {
-        for (const validator of validators) {
-          const errors = validator.validate(input, options, path);
-          if (errors.length) return errors;
-        }
-        return [];
-      }
-    );
-  }
-  var locale22 = {
-    /**
-     * {value} - The child validators' descriptions, joined with `separator`.
-     */
-    template: "({value})",
-    /**
-     * The separator with which to join child validator descriptions.
-     */
-    separator: " | "
-  };
-  function orValidators(...validators) {
-    const description = substitute(locale22.template, {
-      value: validators.map((v) => v.description).join(locale22.separator)
-    });
-    return createDeepValidator(description, (input, options, path) => {
-      let longestErrors = [];
-      let longestPath = 0;
-      for (const validator of validators) {
-        const errors = validator.validate(input, options, path);
-        if (!errors.length) return errors;
-        const pathLength = errors.reduce(
-          (max, m) => Math.max(m.path.length, max),
-          0
-        );
-        if (pathLength >= longestPath) {
-          longestErrors = errors;
-          longestPath = pathLength;
-        }
-      }
-      return longestPath > path.length ? longestErrors : [
-        {
-          message: createValidationExpectationMessage(
-            description,
-            input,
-            path
-          ),
-          path
-        }
-      ];
-    });
-  }
-  var requiredValidationOptions = {
-    optional: false
-  };
-  var SchemaBase = class {
-    constructor(currentValidator, previousSchema, operation) {
-      this.currentValidator = currentValidator;
-      this.previousSchema = previousSchema;
-      this.operation = operation;
-      __publicField2(this, "__type", /* @__PURE__ */ invariant());
-      __publicField2(this, "validator");
-      __publicField2(this, "_options", requiredValidationOptions);
-      __publicField2(this, "assert", (input, origin, path) => {
-        this.validator.assert(input, origin, path);
-      });
-      __publicField2(this, "isValid", (input) => this.validator.isValid(input));
-      __publicField2(this, "validate", (input, options, path) => this.validator.validate(input, options, path));
-      this.validator = operation == null ? currentValidator : operation(previousSchema, currentValidator);
-    }
-    get options() {
-      return this._options;
-    }
-    get description() {
-      return this.validator.description;
-    }
-    /**
-     * Clones this schema, transforming all validators with the given mutator.
-     *
-     * @param transform A transformer which takes an existing validator in the chain and returns
-     * a new one. Validators should be considered to be immutable; transform should not change the
-     * input but instead return a new validator.
-     */
-    clone(transform = (v) => v) {
-      const cloned = this.operation ? this.self(
-        transform(this.currentValidator),
-        this.previousSchema.clone(transform),
-        this.operation
-      ) : this.self(transform(this.currentValidator));
-      cloned._options = this._options;
-      return cloned;
-    }
-    self(current, previous, operation) {
-      if (this.constructor.length > 3) {
-        throw new IllegalArgumentError(
-          "constructor should have at most three required arguments"
-        );
-      }
-      return new this.constructor(current, previous, operation);
-    }
-    /**
-     * Constructs a new schema with a validator chaining the current validator with the
-     * provided next in an AND operation.
-     *
-     * @param nextValidator The validator to run after the current.
-     * @return Returns a new Schema instance the same class with a new validator chaining the
-     * current validator with the given next in an AND operation.
-     */
-    chain(nextValidator) {
-      return this.self(nextValidator, this, andValidators);
-    }
-    optional() {
-      const cloned = this.clone();
-      cloned._options = __spreadProps3(__spreadValues3({}, cloned.options), {
-        optional: true
-      });
-      return cloned;
-    }
-    required() {
-      const cloned = this.clone();
-      cloned._options = __spreadProps3(__spreadValues3({}, cloned.options), {
-        optional: false
-      });
-      return cloned;
-    }
-  };
-  var locale32 = {
-    null: "null",
-    nullish: "nullish",
-    undefined: "undefined"
-  };
-  var valueValidators = {
-    any() {
-      return createValidator("", () => true);
-    },
-    /**
-     * Creates a validator that asserts that the input is nullish.
-     */
-    nullish() {
-      return createValidator(locale32.nullish, (input) => input == null);
-    },
-    /**
-     * Creates a validator that asserts that the input is strictly null.
-     */
-    null() {
-      return createValidator(locale32.null, (input) => input === null);
-    },
-    /**
-     * Creates a validator that asserts that the input is strictly undefined.
-     */
-    undefined() {
-      return createValidator(locale32.undefined, (input) => input === void 0);
-    }
-  };
-  var ValueSchema = class _ValueSchema extends SchemaBase {
-    /**
-     * Prepends this validator allowing for null or undefined.
-     */
-    maybe() {
-      return this.or(valueValidators.nullish());
-    }
-    /**
-     * Prepends this validator allowing for null.
-     */
-    orNull() {
-      return this.or(valueValidators.null());
-    }
-    /**
-     * Prepends this validator allowing for undefined.
-     */
-    orUndefined() {
-      return this.or(valueValidators.undefined());
-    }
-    /**
-     * Returns a validator that asserts if this validator and the next passes.
-     *
-     * @see andValidators
-     *
-     * @param nextValidator The validator to run after the current.
-     * @return Returns a new ValueSchema intersecting this validator and the next.
-     */
-    and(nextValidator) {
-      return new _ValueSchema(nextValidator, this, andValidators);
-    }
-    /**
-     * Returns a validator that asserts if this validator or the next passes.
-     *
-     * Implementation note:
-     * subclasses should not change the schema instance returned unless all chainable validators
-     * accept input type 'unknown'.
-     *
-     * @param nextValidator The validator to run after the current.
-     * @return Returns a new ValueSchema providing the union of this validator and the next.
-     */
-    or(nextValidator) {
-      return new _ValueSchema(nextValidator, this, orValidators);
-    }
-  };
-  var locale4 = {
-    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(
-        locale4.array,
-        (input) => Array.isArray(input)
-      );
-    },
-    /**
-     * Creates a validator that asserts that every element passes the given validator.
-     *
-     * @param elementValidator
-     */
-    withElements(elementValidator) {
-      return createDeepValidator(
-        substitute(locale4.withElements, {
-          value: elementValidator.description
-        }),
-        (input, options, path) => {
-          const errors = [];
-          for (let i = 0; i < input.length; i++) {
-            const element = input[i];
-            errors.push(
-              ...elementValidator.validate(
-                element,
-                options,
-                path.concat(i.toString())
-              )
-            );
-            if (!options.all && errors.length) return errors;
-          }
-          return errors;
-        }
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input array is a tuple whose elements match
-     * the given validators.
-     *
-     * @param validators
-     */
-    tuple(...validators) {
-      const lengthValidator = createValidator(
-        substitute(locale4.exactlyLength, {
-          value: validators.length
-        }),
-        (length) => length === validators.length
-      );
-      return createDeepValidator(
-        substitute(locale4.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 element = input[i];
-            const validator = validators[i];
-            errors.push(
-              ...validator.validate(
-                element,
-                options,
-                path.concat(i.toString())
-              )
-            );
-            if (!options.all && errors.length) return errors;
-          }
-          return errors;
-        }
-      );
-    },
-    /**
-     * Creates a validator that validates the input array has the given minimum length.
-     * @param min The minimum number of elements (inclusive)
-     */
-    minLength(min) {
-      return createValidator(
-        substitute(locale4.minLength, { value: min }),
-        (input) => input.length >= min,
-        (input) => substitute(locale4.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(locale4.maxLength, { value: max }),
-        (input) => input.length <= max,
-        (input) => substitute(locale4.actualLength, { value: input.length })
-      );
-    }
-  };
-  var _ArraySchema = class _ArraySchema2 extends ValueSchema {
-    /**
-     * The base ArraySchema instance validating that the input is an Array.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _ArraySchema2(arrayValidators.isArray());
-      return this._base;
-    }
-    /**
-     * Creates a validator that asserts that every element passes the given validator.
-     *
-     * @param elementValidator
-     */
-    withElements(elementValidator) {
-      return this.chain(arrayValidators.withElements(elementValidator));
-    }
-    /**
-     * Creates a validator that asserts that the input array is a tuple whose elements match
-     * the given validators.
-     *
-     * @param validators
-     */
-    tuple(...validators) {
-      return this.chain(arrayValidators.tuple(...validators));
-    }
-    /**
-     * Creates a validator that validates the input array has the given minimum length.
-     * @param min The minimum number of elements (inclusive)
-     */
-    minLength(min) {
-      return this.chain(arrayValidators.minLength(min));
-    }
-    /**
-     *
-     * Creates a validator that validates the input array has the given maximum length.
-     * @param max The maximum number of elements (inclusive)
-     */
-    maxLength(max) {
-      return this.chain(arrayValidators.maxLength(max));
-    }
-    /**
-     * Casts to a readonly array.
-     * This is a shallow cast, elements of the array will not be changed.
-     */
-    readonly() {
-      return this;
-    }
-    /**
-     * Casts the type parameter.
-     */
-    cast() {
-      return this;
-    }
-  };
-  __publicField2(_ArraySchema, "_base", null);
-  var locale5 = {
-    template: "type {value}"
-  };
-  function typeOfValidator(expected) {
-    return createValidator(
-      substitute(locale5.template, { value: expected }),
-      (input) => {
-        return input != null && typeof input === expected;
-      }
-    );
-  }
-  var typeOfValidatorCache = {};
-  function cachedTypeOfValidator(type) {
-    if (!(type in typeOfValidatorCache)) {
-      typeOfValidatorCache[type] = typeOfValidator(type);
-    }
-    return typeOfValidatorCache[type];
-  }
-  var typeOfValidators = {
-    get boolean() {
-      return cachedTypeOfValidator("boolean");
-    },
-    get func() {
-      return cachedTypeOfValidator("function");
-    },
-    get number() {
-      return cachedTypeOfValidator("number");
-    },
-    get object() {
-      return cachedTypeOfValidator("object");
-    },
-    get string() {
-      return cachedTypeOfValidator("string");
-    },
-    get symbol() {
-      return cachedTypeOfValidator("symbol");
-    }
-  };
-  var locale6 = {
-    length: "at most {value} arguments",
-    actualLength: "{value} arguments"
-  };
-  var functionValidators = {
-    length(max) {
-      return createValidator(
-        substitute(locale6.length, { value: max }),
-        (input) => input.length <= max,
-        (input) => substitute(locale6.actualLength, { value: input.length })
-      );
-    }
-  };
-  var _FunctionSchema = class _FunctionSchema2 extends ValueSchema {
-    /**
-     * The base Function validator validating that the input is a function.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _FunctionSchema2(typeOfValidators.func);
-      return this._base;
-    }
-    length(max) {
-      return this.chain(functionValidators.length(max));
-    }
-    /**
-     * Casts the function signature.
-     * Function signatures, except for their required number of parameters, cannot be
-     * meaningfully validated.
-     */
-    cast() {
-      return this;
-    }
-  };
-  __publicField2(_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 element of input) {
-            errors.push(
-              ...elementValidator.validate(
-                element,
-                options,
-                path.concat(i.toString())
-              )
-            );
-            if (!options.all && errors.length) return errors;
-            i++;
-          }
-          return errors;
-        }
-      );
-    }
-  };
-  var _SetSchema = class _SetSchema2 extends ValueSchema {
-    /**
-     * The base SetSchema instance validating that the input is a Set.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _SetSchema2(setValidators.isSet());
-      return this._base;
-    }
-    /**
-     * Creates a validator that asserts that every element passes the given validator.
-     *
-     * @param elementValidator
-     */
-    withElements(elementValidator) {
-      return this.chain(setValidators.withElements(elementValidator));
-    }
-    /**
-     * Casts to a readonly set.
-     * This is a shallow cast, elements of the array will not be changed.
-     */
-    readonly() {
-      return this;
-    }
-    /**
-     * Casts the parameter type.
-     */
-    cast() {
-      return this;
-    }
-  };
-  __publicField2(_SetSchema, "_base", null);
-  var locale8 = {
-    gte: "at least {value}",
-    gt: "greater than {value}",
-    lte: "at most {value}",
-    lt: "less than {value}",
-    within: "within {min} and {max}",
-    safeInteger: "safe integer",
-    finite: "finite"
-  };
-  var numberValidators = {
-    /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * value.
-     *
-     * @param min The minimum (inclusive) the value may be.
-     */
-    gte(min) {
-      return createValidator(
-        substitute(locale8.gte, { value: min }),
-        (input) => input >= min
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input number is greater than the provided minimum
-     * value.
-     *
-     * @param min The minimum (exclusive) the value may be.
-     */
-    gt(min) {
-      return createValidator(
-        substitute(locale8.gt, { value: min }),
-        (input) => input > min
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input number is at most the provided maximum
-     * value.
-     *
-     * @param max The maximum (inclusive) the value may be.
-     */
-    lte(max) {
-      return createValidator(
-        substitute(locale8.lte, { value: max }),
-        (input) => input <= max
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input number is less than the provided maximum
-     * value.
-     *
-     * @param max The maximum (exclusive) the value may be.
-     */
-    lt(max) {
-      return createValidator(
-        substitute(locale8.lt, { value: max }),
-        (input) => input < max
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * and at most the provided maximum values.
-     *
-     * @param min The minimum (inclusive) value the input may be.
-     * @param max The maximum (inclusive) value the input may be.
-     */
-    within(min, max) {
-      return createValidator(
-        substitute(locale8.within, { min, max }),
-        (input) => input >= min && input <= max
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input number is finite.
-     */
-    finite() {
-      return createValidator(locale8.finite, (input) => Number.isFinite(input));
-    },
-    /**
-     * Creates a validator that asserts that the input number is a safe integer.
-     */
-    safeInteger() {
-      return createValidator(
-        locale8.safeInteger,
-        (input) => Number.isSafeInteger(input)
-      );
-    }
-  };
-  var _NumberSchema = class _NumberSchema2 extends ValueSchema {
-    /**
-     * The base Object validator validating that the input is an object.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _NumberSchema2(typeOfValidators.number);
-      return this._base;
-    }
-    /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * value.
-     *
-     * @param min The minimum (inclusive) the value may be.
-     */
-    gte(min) {
-      return this.chain(numberValidators.gte(min));
-    }
-    /**
-     * Creates a validator that asserts that the input number is greater than the provided minimum
-     * value.
-     *
-     * @param min The minimum (exclusive) the value may be.
-     */
-    gt(min) {
-      return this.chain(numberValidators.gt(min));
-    }
-    /**
-     * Creates a validator that asserts that the input number is at most the provided maximum
-     * value.
-     *
-     * @param max The maximum (inclusive) the value may be.
-     */
-    lte(max) {
-      return this.chain(numberValidators.lte(max));
-    }
-    /**
-     * Creates a validator that asserts that the input number is less than the provided maximum
-     * value.
-     *
-     * @param max The maximum (exclusive) the value may be.
-     */
-    lt(max) {
-      return this.chain(numberValidators.lt(max));
-    }
-    /**
-     * Creates a validator that asserts that the input number is at least the provided minimum
-     * and at most the provided maximum values.
-     *
-     * @param min The minimum (inclusive) value the input may be.
-     * @param max The maximum (inclusive) value the input may be.
-     */
-    within(min, max) {
-      return this.chain(numberValidators.within(min, max));
-    }
-    /**
-     * Creates a validator that asserts that the input number is finite.
-     */
-    finite() {
-      return this.chain(numberValidators.finite());
-    }
-    /**
-     * Creates a validator that asserts that the input number is a safe integer.
-     */
-    safeInteger() {
-      return this.chain(numberValidators.safeInteger());
-    }
-  };
-  __publicField2(_NumberSchema, "_base", null);
-  function isValidatorWithPartial(validator) {
-    return "partial" in validator && "partialDeep" in validator;
-  }
-  function maybeToDeepPartial(validator) {
-    return isValidatorWithPartial(validator) ? validator.partialDeep() : validator;
-  }
-  function maybeToPartial(validator) {
-    return isValidatorWithPartial(validator) ? validator.partial() : validator;
-  }
-  var locale9 = {
-    extend: "{\n{body}\n}",
-    prop: "{key}: {value}",
-    propSeparator: ",\n",
-    indent: "  ",
-    required: `property '{key}' is required`
-  };
-  var objectValidators = {
-    /**
-     * Creates a validator that validates the input has properties that pass their respective
-     * validators.
-     *
-     * @param propertyValidators
-     */
-    properties(propertyValidators) {
-      const propertiesDescriptions = [];
-      const keys = ownKeys(propertyValidators);
-      for (const key of keys) {
-        const validator2 = propertyValidators[key];
-        propertiesDescriptions.push(
-          substitute(locale9.prop, {
-            key: String(key) + (validator2.options.optional ? "?" : ""),
-            value: validator2.description
-          })
-        );
-      }
-      const description = substitute(locale9.extend, {
-        body: propertiesDescriptions.join(locale9.propSeparator).split("\n").map((line) => locale9.indent + line).join("\n")
-      });
-      const validator = createDeepValidator(
-        description,
-        (input, options, path) => {
-          const errors = [];
-          for (const key of keys) {
-            const validator2 = propertyValidators[key];
-            if (key in input) {
-              const value = input[key];
-              errors.push(
-                ...validator2.validate(
-                  value,
-                  options,
-                  path.concat(String(key))
-                )
-              );
-            } else {
-              if (!validator2.options.optional) {
-                errors.push({
-                  message: substitute(locale9.required, { key }),
-                  path: path.concat(String(key))
-                });
-              }
-            }
-            if (!options.all && errors.length) return errors;
-          }
-          return errors;
-        }
-      );
-      return merge(validator, {
-        partial() {
-          const optionalPropertyValidators = {};
-          for (const key of keys) {
-            optionalPropertyValidators[key] = propertyValidators[key].optional();
-          }
-          return objectValidators.properties(
-            optionalPropertyValidators
-          );
-        },
-        partialDeep() {
-          const optionalPropertyValidators = {};
-          for (const key of keys) {
-            optionalPropertyValidators[key] = maybeToDeepPartial(
-              propertyValidators[key].optional()
-            );
-          }
-          return objectValidators.properties(
-            optionalPropertyValidators
-          );
-        }
-      });
-    }
-  };
-  var _ObjectSchema = class _ObjectSchema2 extends ValueSchema {
-    /**
-     * The base Object validator validating that the input is an object.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _ObjectSchema2(typeOfValidators.object);
-      return this._base;
-    }
-    /**
-     * Creates a validator that validates the input has properties that pass their respective
-     * validators.
-     *
-     * @param propertyValidators
-     */
-    extend(propertyValidators) {
-      return this.chain(objectValidators.properties(propertyValidators));
-    }
-    /**
-     * Allows all properties to be undefined.
-     */
-    partial() {
-      return this.clone(maybeToPartial);
-    }
-    /**
-     * Allows all recursive properties to be undefined.
-     */
-    partialDeep() {
-      return this.clone(maybeToDeepPartial);
-    }
-    /**
-     * Casts the type parameter.
-     */
-    cast() {
-      return this;
-    }
-  };
-  __publicField2(_ObjectSchema, "_base", null);
-  var locale10 = {
-    notEmpty: "not empty",
-    minLength: "at least {value} characters",
-    maxLength: "at most {value} characters",
-    noWhitespace: "no whitespace characters",
-    matches: "matches {value}"
-  };
-  var stringValidators = {
-    /**
-     * Creates a validator that asserts that the input is not empty.
-     */
-    notEmpty() {
-      return createValidator(locale10.notEmpty, (input) => input !== "");
-    },
-    /**
-     * Creates a validator that asserts that the input string has at least the given minimum
-     * length.
-     *
-     * @param min The string must be at least this length.
-     */
-    minLength(min) {
-      return createValidator(
-        substitute(locale10.minLength, { value: min }),
-        (input) => input.length >= min
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input string has at most the given maximum
-     * length.
-     *
-     * @param max The string must be at most this length.
-     */
-    maxLength(max) {
-      return createValidator(
-        substitute(locale10.maxLength, { value: max }),
-        (input) => input.length <= max
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input string has no whitespace characters.
-     * Whitespace characters include space, new line, carriage return, and tab.
-     */
-    noWhitespace() {
-      return createValidator(
-        locale10.noWhitespace,
-        (input) => input.search(/\s/g) === -1
-      );
-    },
-    /**
-     * Creates a validator that asserts that the input string matches the given regex.
-     * @param regex
-     */
-    matches(regex) {
-      return createValidator(
-        substitute(locale10.matches, { value: regex.toString() }),
-        (input) => {
-          return regex.test(input);
-        }
-      );
-    }
-  };
-  var _StringSchema = class _StringSchema2 extends ValueSchema {
-    /**
-     * The base SetSchema instance validating that the input is a Set.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _StringSchema2(typeOfValidators.string);
-      return this._base;
-    }
-    /**
-     * Creates a validator that asserts that the input is not empty.
-     */
-    notEmpty() {
-      return this.chain(stringValidators.notEmpty());
-    }
-    /**
-     * Creates a validator that asserts that the input string has at least the given minimum
-     * length.
-     *
-     * @param min The string must be at least this length.
-     */
-    minLength(min) {
-      return this.chain(stringValidators.minLength(min));
-    }
-    /**
-     * Creates a validator that asserts that the input string has at most the given maximum
-     * length.
-     *
-     * @param max The string must be at most this length.
-     */
-    maxLength(max) {
-      return this.chain(stringValidators.maxLength(max));
-    }
-    /**
-     * Creates a validator that asserts that the input string has no whitespace characters.
-     * Whitespace characters include space, new line, carriage return, and tab.
-     */
-    noWhitespace() {
-      return this.chain(stringValidators.noWhitespace());
-    }
-    /**
-     * Creates a validator that asserts that the input string matches the given regex.
-     * @param regex
-     */
-    matches(regex) {
-      return this.chain(stringValidators.matches(regex));
-    }
-  };
-  __publicField2(_StringSchema, "_base", null);
-  var StringSchema = _StringSchema;
-  var locale11 = {
-    record: "{ [key: {key}]: {value} }"
-  };
-  var recordValidators = {
-    /**
-     * Returns a validator that asserts that the object's own enumerable properties has keys and
-     * values that match their respective validators.
-     *
-     * Prototype members are not included.
-     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
-     * to the key validator as '0'.
-     *
-     * @param keyValidator Validates each key.
-     * @param valueValidator Validates each value.
-     */
-    record(keyValidator, valueValidator) {
-      return createDeepValidator(
-        substitute(locale11.record, {
-          key: keyValidator.description,
-          value: valueValidator.description
-        }),
-        (input, options, path) => {
-          const errors = [];
-          for (const key of ownKeys(input)) {
-            const keyStr = String(key);
-            errors.push(
-              ...keyValidator.validate(
-                key,
-                options,
-                path.concat(`[${keyStr}]`)
-              )
-            );
-            if (!options.all && errors.length) return errors;
-            const value = input[key];
-            errors.push(
-              ...valueValidator.validate(
-                value,
-                options,
-                path.concat(keyStr)
-              )
-            );
-            if (!options.all && errors.length) return errors;
-          }
-          return errors;
-        }
-      );
-    }
-  };
-  var _RecordSchema = class _RecordSchema2 extends ValueSchema {
-    /**
-     * The base Object validator validating that the input is an object.
-     */
-    static get base() {
-      if (this._base == null)
-        this._base = new _RecordSchema2(typeOfValidators.object);
-      return this._base;
-    }
-    static get defaultKeyValidator() {
-      return StringSchema.base;
-    }
-    /**
-     * Returns a validator that asserts that the object's own enumerable properties has keys and
-     * values that match their respective validators.
-     *
-     * Prototype members are not included.
-     * Numeric keys are validated as strings. For example the object `{ [0]: 1 }` will be passed
-     * to the key validator as '0'.
-     *
-     * @param keyValidator Validates each key.
-     * @param valueValidator Validates each value.
-     */
-    record(keyValidator, valueValidator) {
-      return this.chain(recordValidators.record(keyValidator, valueValidator));
-    }
-    /**
-     * Returns a validator that asserts that the object's own enumerable properties has
-     * string keys and values that match the given validator.
-     *
-     * Prototype members are not included.
-     *
-     * @param valueValidator Validates each value.
-     */
-    recordValues(valueValidator) {
-      return this.record(_RecordSchema2.defaultKeyValidator, valueValidator);
-    }
-    /**
-     * Casts to a ReadonlyRecord
-     */
-    readonly() {
-      return this;
-    }
-    /**
-     * Casts the type parameter.
-     */
-    cast() {
-      return this;
-    }
-  };
-  __publicField2(_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)
-      )
-    );
-  }
-
-  // src/types/EncryptionKey.ts
-  var encryptionMethodValidator = isOneOf(
-    "NONE",
-    "AES-128",
-    "SAMPLE-AES",
-    "SAMPLE-AES-CTR"
-  );
-
-  // src/types/AlternativeRendition.ts
-  var renditionTypeValidator = isOneOf(
-    "AUDIO",
-    "VIDEO",
-    "SUBTITLES",
-    "CLOSED-CAPTIONS"
-  );
-
-  // src/parse/parseUtil.ts
-  var LF = char("\n");
-  var CR = char("\r");
-  function readLine(reader) {
-    const line = reader.substringUntil((cc) => cc === LF || cc === CR);
-    if (reader.hasNext() && reader.peek === CR) reader.next();
-    if (reader.hasNext() && reader.peek === LF) reader.next();
-    return line;
-  }
-  function skipWhitespaceLine(reader) {
-    const start = reader.position;
-    reader.while((cc) => isWhitespaceChar(cc) && cc !== LF && cc !== CR);
-    if (!reader.hasNext() || reader.peek === LF || reader.peek === CR) {
-      if (reader.hasNext()) {
-        if (reader.peek === CR) reader.next();
-        if (reader.hasNext() && reader.peek === LF) reader.next();
-      }
-      return true;
-    }
-    reader.position = start;
-    return false;
-  }
-  function addIfPresent(obj, attrs, mappings) {
-    for (const [attrKey, objKey] of Object.entries(mappings)) {
-      if (attrs[attrKey]) {
-        ;
-        obj[objKey] = attrs[attrKey];
-      }
-    }
-    return obj;
-  }
-
-  // src/parse/parseAttributes.ts
-  var EQUALS = char("=");
-  var COMMA = char(",");
-  var QUOTE = char('"');
-  function parseAttributes(reader) {
-    const attrs = {};
-    while (reader.hasNext() && reader.peek !== char("\n") && reader.peek !== char("\r")) {
-      const key = reader.substringUntilChar(EQUALS);
-      if (!key || !reader.hasNext()) break;
-      reader.next();
-      let value;
-      if (reader.peek === QUOTE) {
-        reader.next();
-        value = reader.substringUntilChar(QUOTE);
-        if (reader.hasNext()) reader.next();
-      } else {
-        value = reader.substringUntil(
-          (cc) => cc === COMMA || cc === char("\n") || cc === char("\r")
-        );
-      }
-      attrs[key] = value;
-      if (reader.hasNext() && reader.peek === COMMA) {
-        reader.next();
-      }
-    }
-    return attrs;
-  }
-
-  // src/parse/parseMediaPlaylist.ts
-  var HLS_VARIABLE_PATTERN = /\{\$([^}]+)}/g;
-  var EXTM3U = "#EXTM3U";
-  var EXTINF = "#EXTINF:";
-  var EXT_X_TARGETDURATION = "#EXT-X-TARGETDURATION:";
-  var EXT_X_MEDIA_SEQUENCE = "#EXT-X-MEDIA-SEQUENCE:";
-  var EXT_X_ENDLIST = "#EXT-X-ENDLIST";
-  var EXT_X_PLAYLIST_TYPE = "#EXT-X-PLAYLIST-TYPE:";
-  var EXT_X_VERSION = "#EXT-X-VERSION:";
-  var EXT_X_KEY = "#EXT-X-KEY:";
-  var EXT_X_BYTERANGE = "#EXT-X-BYTERANGE:";
-  var EXT_X_DISCONTINUITY = "#EXT-X-DISCONTINUITY";
-  var EXT_X_PROGRAM_DATE_TIME = "#EXT-X-PROGRAM-DATE-TIME:";
-  var EXT_X_MAP = "#EXT-X-MAP:";
-  function parseMediaPlaylist(text, variables) {
-    const reader = new StringReader(text);
-    reader.white();
-    if (!reader.stringIf(EXTM3U)) {
-      reader.err("Expected #EXTM3U");
-    }
-    readLine(reader);
-    let version = 1;
-    let targetDuration = 0;
-    let mediaSequence = 0;
-    let playlistType = "LIVE";
-    let ended = false;
-    let currentKey;
-    let currentMap;
-    let pendingByteRange;
-    let pendingDiscontinuity = false;
-    let pendingDateTime;
-    const segments = [];
-    let sequenceCounter = 0;
-    while (reader.hasNext()) {
-      if (skipWhitespaceLine(reader)) continue;
-      const line = readLine(reader);
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      if (trimmed.startsWith(EXTINF)) {
-        const durationStr = trimmed.substring(EXTINF.length).split(",")[0];
-        const duration = Number(durationStr);
-        let uri = "";
-        while (reader.hasNext()) {
-          if (skipWhitespaceLine(reader)) continue;
-          const nextLine = readLine(reader).trim();
-          if (!nextLine.startsWith("#")) {
-            uri = variables ? substitute(nextLine, variables, HLS_VARIABLE_PATTERN) : nextLine;
-            break;
-          }
-          if (nextLine.startsWith(EXT_X_BYTERANGE)) {
-            const rangeStr = nextLine.substring(EXT_X_BYTERANGE.length);
-            pendingByteRange = parseByteRangeString(rangeStr);
-          } else if (nextLine === EXT_X_DISCONTINUITY) {
-            pendingDiscontinuity = true;
-          } else if (nextLine.startsWith(EXT_X_PROGRAM_DATE_TIME)) {
-            pendingDateTime = nextLine.substring(
-              EXT_X_PROGRAM_DATE_TIME.length
-            );
-          } else if (nextLine.startsWith(EXT_X_MAP)) {
-            const attrStr = nextLine.substring(EXT_X_MAP.length);
-            const attrReader = new StringReader(attrStr);
-            const attrs = parseAttributes(attrReader);
-            const mapUri = attrs["URI"];
-            if (mapUri) {
-              const byteRangeStr = attrs["BYTERANGE"];
-              currentMap = __spreadValues({
-                uri: mapUri
-              }, byteRangeStr && {
-                byteRange: parseByteRangeString(byteRangeStr)
-              });
-            }
-          }
-        }
-        segments.push(__spreadValues(__spreadProps(__spreadValues(__spreadValues(__spreadValues({
-          uri,
-          duration,
-          sequenceNumber: mediaSequence + sequenceCounter
-        }, currentKey && { key: currentKey }), currentMap && { map: currentMap }), pendingByteRange && { byteRange: pendingByteRange }), {
-          discontinuity: pendingDiscontinuity
-        }), pendingDateTime && { programDateTime: pendingDateTime }));
-        sequenceCounter++;
-        pendingByteRange = void 0;
-        pendingDiscontinuity = false;
-        pendingDateTime = void 0;
-      } else if (trimmed.startsWith(EXT_X_TARGETDURATION)) {
-        targetDuration = Number(
-          trimmed.substring(EXT_X_TARGETDURATION.length)
-        );
-      } else if (trimmed.startsWith(EXT_X_MEDIA_SEQUENCE)) {
-        mediaSequence = Number(
-          trimmed.substring(EXT_X_MEDIA_SEQUENCE.length)
-        );
-      } else if (trimmed === EXT_X_ENDLIST) {
-        ended = true;
-      } else if (trimmed.startsWith(EXT_X_PLAYLIST_TYPE)) {
-        const val = trimmed.substring(EXT_X_PLAYLIST_TYPE.length).trim();
-        if (val === "VOD" || val === "EVENT") {
-          playlistType = val;
-        }
-      } else if (trimmed.startsWith(EXT_X_VERSION)) {
-        version = Number(trimmed.substring(EXT_X_VERSION.length));
-      } else if (trimmed.startsWith(EXT_X_KEY)) {
-        const attrStr = trimmed.substring(EXT_X_KEY.length);
-        const attrReader = new StringReader(attrStr);
-        const attrs = parseAttributes(attrReader);
-        const method = attrs["METHOD"];
-        encryptionMethodValidator.assert(method);
-        currentKey = addIfPresent(
-          {
-            method
-          },
-          attrs,
-          {
-            URI: "uri",
-            IV: "iv",
-            KEYFORMAT: "keyFormat",
-            KEYFORMATVERSIONS: "keyFormatVersions"
-          }
-        );
-      } else if (trimmed.startsWith(EXT_X_MAP)) {
-        const attrStr = trimmed.substring(EXT_X_MAP.length);
-        const attrReader = new StringReader(attrStr);
-        const attrs = parseAttributes(attrReader);
-        const mapUri = attrs["URI"];
-        if (mapUri) {
-          const byteRangeStr = attrs["BYTERANGE"];
-          currentMap = __spreadValues({
-            uri: mapUri
-          }, byteRangeStr && {
-            byteRange: parseByteRangeString(byteRangeStr)
-          });
-        }
-      } else if (trimmed.startsWith(EXT_X_BYTERANGE)) {
-        const rangeStr = trimmed.substring(EXT_X_BYTERANGE.length);
-        pendingByteRange = parseByteRangeString(rangeStr);
-      } else if (trimmed === EXT_X_DISCONTINUITY) {
-        pendingDiscontinuity = true;
-      } else if (trimmed.startsWith(EXT_X_PROGRAM_DATE_TIME)) {
-        pendingDateTime = trimmed.substring(EXT_X_PROGRAM_DATE_TIME.length);
-      }
-    }
-    return {
-      version,
-      targetDuration,
-      mediaSequence,
-      playlistType,
-      ended,
-      segments
-    };
-  }
-  function parseByteRangeString(str) {
-    const parts = str.split("@");
-    return {
-      length: Number(parts[0]),
-      offset: parts.length > 1 ? Number(parts[1]) : 0
-    };
-  }
-
-  // src/parse/parseMainPlaylist.ts
-  var EXTM3U2 = "#EXTM3U";
-  var EXT_X_STREAM_INF = "#EXT-X-STREAM-INF:";
-  var EXT_X_MEDIA = "#EXT-X-MEDIA:";
-  var EXT_X_SESSION_DATA = "#EXT-X-SESSION-DATA:";
-  var EXT_X_DEFINE = "#EXT-X-DEFINE:";
-  function parseMainPlaylist(text) {
-    const reader = new StringReader(text);
-    reader.white();
-    if (!reader.stringIf(EXTM3U2)) {
-      reader.err("Expected #EXTM3U");
-    }
-    readLine(reader);
-    const variants = [];
-    const alternativeRenditions = [];
-    const sessionData = [];
-    const defines = {};
-    while (reader.hasNext()) {
-      if (skipWhitespaceLine(reader)) continue;
-      const line = readLine(reader);
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      if (trimmed.startsWith(EXT_X_STREAM_INF)) {
-        const attrStr = trimmed.substring(EXT_X_STREAM_INF.length);
-        const attrReader = new StringReader(attrStr);
-        const attrs = parseAttributes(attrReader);
-        let uri = "";
-        while (reader.hasNext()) {
-          if (skipWhitespaceLine(reader)) continue;
-          uri = readLine(reader).trim();
-          break;
-        }
-        variants.push(
-          addIfPresent(
-            __spreadValues(__spreadValues({
-              bandwidth: Number(attrs["BANDWIDTH"]),
-              uri
-            }, attrs["FRAME-RATE"] && {
-              frameRate: Number(attrs["FRAME-RATE"])
-            }), attrs.RESOLUTION && parseResolution(attrs.RESOLUTION)),
-            attrs,
-            {
-              CODECS: "codecs",
-              AUDIO: "audioGroup",
-              VIDEO: "videoGroup",
-              SUBTITLES: "subtitlesGroup",
-              "CLOSED-CAPTIONS": "closedCaptionsGroup"
-            }
-          )
-        );
-      } else if (trimmed.startsWith(EXT_X_MEDIA)) {
-        const attrStr = trimmed.substring(EXT_X_MEDIA.length);
-        const attrReader = new StringReader(attrStr);
-        const attrs = parseAttributes(attrReader);
-        const type = attrs["TYPE"];
-        renditionTypeValidator.assert(type);
-        alternativeRenditions.push(
-          addIfPresent(
-            __spreadValues(__spreadValues({
-              type,
-              groupId: attrs["GROUP-ID"],
-              name: attrs["NAME"]
-            }, attrs["DEFAULT"] && {
-              default: attrs["DEFAULT"] === "YES"
-            }), attrs["AUTOSELECT"] && {
-              autoSelect: attrs["AUTOSELECT"] === "YES"
-            }),
-            attrs,
-            {
-              URI: "uri",
-              LANGUAGE: "language"
-            }
-          )
-        );
-      } else if (trimmed.startsWith(EXT_X_SESSION_DATA)) {
-        const attrStr = trimmed.substring(EXT_X_SESSION_DATA.length);
-        const attrReader = new StringReader(attrStr);
-        const attrs = parseAttributes(attrReader);
-        sessionData.push(
-          addIfPresent(
-            {
-              dataId: attrs["DATA-ID"]
-            },
-            attrs,
-            {
-              VALUE: "value",
-              URI: "uri",
-              LANGUAGE: "language"
-            }
-          )
-        );
-      } else if (trimmed.startsWith(EXT_X_DEFINE)) {
-        const attrStr = trimmed.substring(EXT_X_DEFINE.length);
-        const attrReader = new StringReader(attrStr);
-        const attrs = parseAttributes(attrReader);
-        if (attrs["NAME"] && attrs["VALUE"]) {
-          defines[attrs["NAME"]] = attrs["VALUE"];
-        }
-      }
-    }
-    return { variants, alternativeRenditions, sessionData, defines };
-  }
-  function parseResolution(resolution) {
-    const parts = resolution.split("x");
-    if (parts.length !== 2) {
-      throw new ValidationError(
-        "Invalid resolution format, expected WIDTHxHEIGHT"
-      );
-    }
-    const width = Number(parts[0]);
-    const height = Number(parts[1]);
-    if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
-      throw new ValidationError(
-        "Invalid resolution values, width and height must be positive integers"
-      );
-    }
-    return { width, height };
-  }
-
-  // test/hlsTestAssets/hls_mainPlaylist.ts
-  var hls_mainPlaylist = `#EXTM3U
-#EXT-X-VERSION:6
-#EXT-X-INDEPENDENT-SEGMENTS
-
-#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,URI="audio/en.m3u8"
-#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="Spanish",LANGUAGE="es",DEFAULT=NO,AUTOSELECT=NO,URI="audio/es.m3u8"
-#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="subs",NAME="English",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,URI="subtitles/en.m3u8"
-
-#EXT-X-STREAM-INF:BANDWIDTH=1280000,CODECS="avc1.42e00a,mp4a.40.2",RESOLUTION=640x360,FRAME-RATE=29.97,AUDIO="audio",SUBTITLES="subs"
-low/index.m3u8
-#EXT-X-STREAM-INF:BANDWIDTH=2560000,CODECS="avc1.42e01e,mp4a.40.2",RESOLUTION=854x480,FRAME-RATE=29.97,AUDIO="audio",SUBTITLES="subs"
-mid/index.m3u8
-#EXT-X-STREAM-INF:BANDWIDTH=7680000,CODECS="avc1.42e01f,mp4a.40.2",RESOLUTION=1280x720,FRAME-RATE=29.97,AUDIO="audio",SUBTITLES="subs"
-high/index.m3u8`;
-
-  // test/hlsTestAssets/hls_mediaPlaylist.ts
-  var hls_mediaPlaylist = `#EXTM3U
-#EXT-X-VERSION:3
-#EXT-X-TARGETDURATION:10
-#EXT-X-MEDIA-SEQUENCE:0
-#EXT-X-PLAYLIST-TYPE:VOD
-
-#EXT-X-KEY:METHOD=AES-128,URI="https://example.com/key.bin",IV=0x99b74007b6254e4bd1c6e03631cad15b
-
-#EXTINF:9.009,
-segment00000.ts
-#EXTINF:9.009,
-segment00001.ts
-#EXTINF:9.009,
-segment00002.ts
-#EXTINF:9.009,
-segment00003.ts
-#EXTINF:9.009,
-segment00004.ts
-#EXTINF:5.005,
-segment00005.ts
-
-#EXT-X-ENDLIST`;
-
-  // test/hlsTestAssets/hls_mediaPlaylistWithByteRanges.ts
-  var hls_mediaPlaylistWithByteRanges = `#EXTM3U
-#EXT-X-VERSION:4
-#EXT-X-TARGETDURATION:10
-#EXT-X-MEDIA-SEQUENCE:0
-
-#EXTINF:10.0,
-#EXT-X-BYTERANGE:1000000@0
-segment.ts
-#EXTINF:10.0,
-#EXT-X-BYTERANGE:1000000@1000000
-segment.ts
-#EXT-X-DISCONTINUITY
-#EXTINF:10.0,
-#EXT-X-BYTERANGE:1000000@2000000
-segment.ts
-
-#EXT-X-ENDLIST`;
-
-  // test/integ/parseHlsManifest.integ.ts
-  describe("HLS Parser Integration Tests", () => {
-    it("parses HLS main playlist test asset", () => {
-      const result = parseMainPlaylist(hls_mainPlaylist);
-      expect(result.variants.length).toBe(3);
-      expect(result.alternativeRenditions.length).toBe(3);
-      expect(result.variants[0].bandwidth).toBe(128e4);
-      expect(result.variants[0].uri).toBe("low/index.m3u8");
-      expect(result.variants[0].codecs).toBe("avc1.42e00a,mp4a.40.2");
-      expect(result.variants[0].width).toBe(640);
-      expect(result.variants[0].height).toBe(360);
-      const audioRenditions = result.alternativeRenditions.filter(
-        (r) => r.type === "AUDIO"
-      );
-      expect(audioRenditions.length).toBe(2);
-      expect(audioRenditions[0].name).toBe("English");
-      expect(audioRenditions[0].language).toBe("en");
-      expect(audioRenditions[0].default).toBe(true);
-    });
-    it("parses HLS media playlist test asset", () => {
-      const result = parseMediaPlaylist(hls_mediaPlaylist);
-      expect(result.version).toBe(3);
-      expect(result.targetDuration).toBe(10);
-      expect(result.mediaSequence).toBe(0);
-      expect(result.playlistType).toBe("VOD");
-      expect(result.ended).toBe(true);
-      expect(result.segments.length).toBe(6);
-      expect(result.segments[0].uri).toBe("segment00000.ts");
-      expect(result.segments[0].duration).toBe(9.009);
-      expect(result.segments[0].sequenceNumber).toBe(0);
-      expect(result.segments[5].duration).toBe(5.005);
-    });
-    it("parses HLS media playlist with byte ranges", () => {
-      var _a, _b, _c;
-      const result = parseMediaPlaylist(hls_mediaPlaylistWithByteRanges);
-      expect(result.segments.length).toBe(3);
-      expect((_a = result.segments[0].byteRange) == null ? void 0 : _a.length).toBe(1e6);
-      expect((_b = result.segments[0].byteRange) == null ? void 0 : _b.offset).toBe(0);
-      expect((_c = result.segments[1].byteRange) == null ? void 0 : _c.offset).toBe(1e6);
-      expect(result.segments[2].discontinuity).toBe(true);
-    });
-    it("keeps URIs relative in parsed results", () => {
-      const result = parseMainPlaylist(hls_mainPlaylist);
-      expect(result.variants[0].uri).toBe("low/index.m3u8");
-      expect(result.variants[1].uri).toBe("mid/index.m3u8");
-      expect(result.variants[2].uri).toBe("high/index.m3u8");
-    });
-  });
-})();
-//# sourceMappingURL=integ.js.map