Compiled (unminified) | superstruct

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

schemas/libraries/superstruct/download_compiled/index/unminified.jscode_offView RawView Raw
Copy to clipboardCopy to clipboard

//#region ../node_modules/.pnpm/superstruct@2.0.2/node_modules/superstruct/dist/index.mjs
/**
 * A `StructFailure` represents a single specific failure in validation.
 */
/**
 * `StructError` objects are thrown (or returned) when validation fails.
 *
 * Validation logic is design to exit early for maximum performance. The error
 * represents the first error encountered during validation. For more detail,
 * the `error.failures` property is a generator function that can be run to
 * continue validation and receive all the failures in the data.
 */
var StructError = class extends TypeError {
  constructor(failure, failures) {
    let cached;
    const {
      message,
      explanation,
      ...rest
    } = failure;
    const { path } = failure;
    const msg =
      path.length === 0
        ? message
        : `At path: ${path.join(".")} -- ${message}`;
    super(explanation ?? msg);
    if (explanation != null)
      this.cause = msg;
    Object.assign(this, rest);
    this.name = this.constructor.name;
    this.failures = () => {
      return (
        cached ??
        (cached = [
          failure,
          ...failures(),
        ])
      );
    };
  }
};
/**
 * Check if a value is an iterator.
 */
function isIterable(x) {
  return (
    isObject(x) &&
    typeof x[Symbol.iterator] ===
      "function"
  );
}
/**
 * Check if a value is a plain object.
 */
function isObject(x) {
  return (
    typeof x === "object" && x != null
  );
}
/**
 * Check if a value is a non-array object.
 */
function isNonArrayObject(x) {
  return (
    isObject(x) && !Array.isArray(x)
  );
}
/**
 * Return a value as a printable string.
 */
function print(value) {
  if (typeof value === "symbol")
    return value.toString();
  return typeof value === "string"
    ? JSON.stringify(value)
    : `${value}`;
}
/**
 * Shifts (removes and returns) the first value from the `input` iterator.
 * Like `Array.prototype.shift()` but for an `Iterator`.
 */
function shiftIterator(input) {
  const { done, value } = input.next();
  return done ? void 0 : value;
}
/**
 * Convert a single validation result to a failure.
 */
function toFailure(
  result,
  context,
  struct,
  value,
) {
  if (result === true) return;
  else if (result === false)
    result = {};
  else if (typeof result === "string")
    result = { message: result };
  const { path, branch } = context;
  const { type } = struct;
  const {
    refinement,
    message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ""}, but received: \`${print(value)}\``,
  } = result;
  return {
    value,
    type,
    refinement,
    key: path[path.length - 1],
    path,
    branch,
    ...result,
    message,
  };
}
/**
 * Convert a validation result to an iterable of failures.
 */
function* toFailures(
  result,
  context,
  struct,
  value,
) {
  if (!isIterable(result))
    result = [result];
  for (const r of result) {
    const failure = toFailure(
      r,
      context,
      struct,
      value,
    );
    if (failure) yield failure;
  }
}
/**
 * Check a value against a struct, traversing deeply into nested values, and
 * returning an iterator of failures or success.
 */
function* run(
  value,
  struct,
  options = {},
) {
  const {
    path = [],
    branch = [value],
    coerce = false,
    mask = false,
  } = options;
  const ctx = {
    path,
    branch,
    mask,
  };
  if (coerce)
    value = struct.coercer(value, ctx);
  let status = "valid";
  for (const failure of struct.validator(
    value,
    ctx,
  )) {
    failure.explanation =
      options.message;
    status = "not_valid";
    yield [failure, void 0];
  }
  for (let [k, v, s] of struct.entries(
    value,
    ctx,
  )) {
    const ts = run(v, s, {
      path:
        k === void 0
          ? path
          : [...path, k],
      branch:
        k === void 0
          ? branch
          : [...branch, v],
      coerce,
      mask,
      message: options.message,
    });
    for (const t of ts)
      if (t[0]) {
        status =
          t[0].refinement != null
            ? "not_refined"
            : "not_valid";
        yield [t[0], void 0];
      } else if (coerce) {
        v = t[1];
        if (k === void 0) value = v;
        else if (value instanceof Map)
          value.set(k, v);
        else if (value instanceof Set)
          value.add(v);
        else if (isObject(value)) {
          if (
            v !== void 0 ||
            k in value
          )
            value[k] = v;
        }
      }
  }
  if (status !== "not_valid")
    for (const failure of struct.refiner(
      value,
      ctx,
    )) {
      failure.explanation =
        options.message;
      status = "not_refined";
      yield [failure, void 0];
    }
  if (status === "valid")
    yield [void 0, value];
}
/**
 * `Struct` objects encapsulate the validation logic for a specific type of
 * values. Once constructed, you use the `assert`, `is` or `validate` helpers to
 * validate unknown input data against the struct.
 */
var Struct = class {
  constructor(props) {
    const {
      type,
      schema,
      validator,
      refiner,
      coercer = (value) => value,
      entries = function* () {},
    } = props;
    this.type = type;
    this.schema = schema;
    this.entries = entries;
    this.coercer = coercer;
    if (validator)
      this.validator = (
        value,
        context,
      ) => {
        return toFailures(
          validator(value, context),
          context,
          this,
          value,
        );
      };
    else this.validator = () => [];
    if (refiner)
      this.refiner = (
        value,
        context,
      ) => {
        return toFailures(
          refiner(value, context),
          context,
          this,
          value,
        );
      };
    else this.refiner = () => [];
  }
  /**
   * Assert that a value passes the struct's validation, throwing if it doesn't.
   */
  assert(value, message) {
    return assert(value, this, message);
  }
  /**
   * Create a value with the struct's coercion logic, then validate it.
   */
  create(value, message) {
    return create(value, this, message);
  }
  /**
   * Check if a value passes the struct's validation.
   */
  is(value) {
    return is(value, this);
  }
  /**
   * Mask a value, coercing and validating it, but returning only the subset of
   * properties defined by the struct's schema. Masking applies recursively to
   * props of `object` structs only.
   */
  mask(value, message) {
    return mask(value, this, message);
  }
  /**
   * Validate a value with the struct's validation logic, returning a tuple
   * representing the result.
   *
   * You may optionally pass `true` for the `coerce` argument to coerce
   * the value before attempting to validate it. If you do, the result will
   * contain the coerced result when successful. Also, `mask` will turn on
   * masking of the unknown `object` props recursively if passed.
   */
  validate(value, options = {}) {
    return validate(
      value,
      this,
      options,
    );
  }
};
/**
 * Assert that a value passes a struct, throwing if it doesn't.
 */
function assert(
  value,
  struct,
  message,
) {
  const result = validate(
    value,
    struct,
    { message },
  );
  if (result[0]) throw result[0];
}
/**
 * Create a value with the coercion logic of struct and validate it.
 */
function create(
  value,
  struct,
  message,
) {
  const result = validate(
    value,
    struct,
    {
      coerce: true,
      message,
    },
  );
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Mask a value, returning only the subset of properties defined by a struct.
 */
function mask(value, struct, message) {
  const result = validate(
    value,
    struct,
    {
      coerce: true,
      mask: true,
      message,
    },
  );
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Check if a value passes a struct.
 */
function is(value, struct) {
  return !validate(value, struct)[0];
}
/**
 * Validate a value against a struct, returning an error if invalid, or the
 * value (with potential coercion) if valid.
 */
function validate(
  value,
  struct,
  options = {},
) {
  const tuples = run(
    value,
    struct,
    options,
  );
  const tuple = shiftIterator(tuples);
  if (tuple[0])
    return [
      new StructError(
        tuple[0],
        function* () {
          for (const t of tuples)
            if (t[0]) yield t[0];
        },
      ),
      void 0,
    ];
  else return [void 0, tuple[1]];
}
/**
 * Define a new struct type with a custom validation function.
 */
function define(name, validator) {
  return new Struct({
    type: name,
    schema: null,
    validator,
  });
}
function array(Element) {
  return new Struct({
    type: "array",
    schema: Element,
    *entries(value) {
      if (
        Element &&
        Array.isArray(value)
      )
        for (const [
          i,
          v,
        ] of value.entries())
          yield [i, v, Element];
    },
    coercer(value) {
      return Array.isArray(value)
        ? value.slice()
        : value;
    },
    validator(value) {
      return (
        Array.isArray(value) ||
        `Expected an array value, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that a value is a valid `Date`.
 *
 * Note: this also ensures that the value is *not* an invalid `Date` object,
 * which can occur when parsing a date fails but still returns a `Date`.
 */
function date() {
  return define("date", (value) => {
    return (
      (value instanceof Date &&
        !isNaN(value.getTime())) ||
      `Expected a valid \`Date\` object, but received: ${print(value)}`
    );
  });
}
function enums(values) {
  const schema = {};
  const description = values
    .map((v) => print(v))
    .join();
  for (const key of values)
    schema[key] = key;
  return new Struct({
    type: "enums",
    schema,
    validator(value) {
      return (
        values.includes(value) ||
        `Expected one of \`${description}\`, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that no value ever passes validation.
 */
function never() {
  return define("never", () => false);
}
/**
 * Augment an existing struct to allow `null` values.
 */
function nullable(struct) {
  return new Struct({
    ...struct,
    validator: (value, ctx) =>
      value === null ||
      struct.validator(value, ctx),
    refiner: (value, ctx) =>
      value === null ||
      struct.refiner(value, ctx),
  });
}
/**
 * Ensure that a value is a number.
 */
function number() {
  return define("number", (value) => {
    return (
      (typeof value === "number" &&
        !isNaN(value)) ||
      `Expected a number, but received: ${print(value)}`
    );
  });
}
function object(schema) {
  const knowns = schema
    ? Object.keys(schema)
    : [];
  const Never = never();
  return new Struct({
    type: "object",
    schema: schema ? schema : null,
    *entries(value) {
      if (schema && isObject(value)) {
        const unknowns = new Set(
          Object.keys(value),
        );
        for (const key of knowns) {
          unknowns.delete(key);
          yield [
            key,
            value[key],
            schema[key],
          ];
        }
        for (const key of unknowns)
          yield [
            key,
            value[key],
            Never,
          ];
      }
    },
    validator(value) {
      return (
        isNonArrayObject(value) ||
        `Expected an object, but received: ${print(value)}`
      );
    },
    coercer(value, ctx) {
      if (!isNonArrayObject(value))
        return value;
      const coerced = { ...value };
      if (ctx.mask && schema) {
        for (const key in coerced)
          if (schema[key] === void 0)
            delete coerced[key];
      }
      return coerced;
    },
  });
}
/**
 * Ensure that a value is a string.
 */
function string() {
  return define("string", (value) => {
    return (
      typeof value === "string" ||
      `Expected a string, but received: ${print(value)}`
    );
  });
}
/**
 * Ensure that a number or date is below a threshold.
 */
function max(
  struct,
  threshold,
  options = {},
) {
  const { exclusive } = options;
  return refine(
    struct,
    "max",
    (value) => {
      return exclusive
        ? value < threshold
        : value <= threshold ||
            `Expected a ${struct.type} less than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
    },
  );
}
/**
 * Ensure that a number or date is above a threshold.
 */
function min(
  struct,
  threshold,
  options = {},
) {
  const { exclusive } = options;
  return refine(
    struct,
    "min",
    (value) => {
      return exclusive
        ? value > threshold
        : value >= threshold ||
            `Expected a ${struct.type} greater than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
    },
  );
}
/**
 * Augment a `Struct` to add an additional refinement to the validation.
 *
 * The refiner function is guaranteed to receive a value of the struct's type,
 * because the struct's existing validation will already have passed. This
 * allows you to layer additional validation on top of existing structs.
 */
function refine(struct, name, refiner) {
  return new Struct({
    ...struct,
    *refiner(value, ctx) {
      yield* struct.refiner(value, ctx);
      const failures = toFailures(
        refiner(value, ctx),
        ctx,
        struct,
        value,
      );
      for (const failure of failures)
        yield {
          ...failure,
          refinement: name,
        };
    },
  });
}
//#endregion
//#region ../schemas/libraries/superstruct/download/index.ts
function stringWithLength(min, max) {
  return refine(
    string(),
    `string with length between ${min} and ${max}`,
    (value) =>
      value.length >= min &&
      value.length <= max,
  );
}
const urlSchema = refine(
  string(),
  "url",
  (value) => URL.canParse(value),
);
const imageSchema = object({
  id: number(),
  created: date(),
  title: stringWithLength(1, 100),
  type: enums(["jpg", "png"]),
  size: number(),
  url: urlSchema,
});
const ratingSchema = object({
  id: number(),
  stars: max(min(number(), 1), 5),
  title: stringWithLength(1, 100),
  text: stringWithLength(1, 1e3),
  images: array(imageSchema),
});
create(
  {},
  object({
    id: number(),
    created: date(),
    title: stringWithLength(1, 100),
    brand: stringWithLength(1, 30),
    description: stringWithLength(
      1,
      500,
    ),
    price: max(min(number(), 1), 1e4),
    discount: nullable(
      max(min(number(), 1), 100),
    ),
    quantity: max(min(number(), 0), 10),
    tags: array(
      stringWithLength(1, 30),
    ),
    images: array(imageSchema),
    ratings: array(ratingSchema),
  }),
);
//#endregion

//#region ../node_modules/.pnpm/superstruct@2.0.2/node_modules/superstruct/dist/index.mjs
/**
 * A `StructFailure` represents a single specific failure in validation.
 */
/**
 * `StructError` objects are thrown (or returned) when validation fails.
 *
 * Validation logic is design to exit early for maximum performance. The error
 * represents the first error encountered during validation. For more detail,
 * the `error.failures` property is a generator function that can be run to
 * continue validation and receive all the failures in the data.
 */
var StructError = class extends TypeError {
  constructor(failure, failures) {
    let cached;
    const { message, explanation, ...rest } = failure;
    const { path } = failure;
    const msg =
      path.length === 0
        ? message
        : `At path: ${path.join(".")} -- ${message}`;
    super(explanation ?? msg);
    if (explanation != null) this.cause = msg;
    Object.assign(this, rest);
    this.name = this.constructor.name;
    this.failures = () => {
      return cached ?? (cached = [failure, ...failures()]);
    };
  }
};
/**
 * Check if a value is an iterator.
 */
function isIterable(x) {
  return (
    isObject(x) && typeof x[Symbol.iterator] === "function"
  );
}
/**
 * Check if a value is a plain object.
 */
function isObject(x) {
  return typeof x === "object" && x != null;
}
/**
 * Check if a value is a non-array object.
 */
function isNonArrayObject(x) {
  return isObject(x) && !Array.isArray(x);
}
/**
 * Return a value as a printable string.
 */
function print(value) {
  if (typeof value === "symbol") return value.toString();
  return typeof value === "string"
    ? JSON.stringify(value)
    : `${value}`;
}
/**
 * Shifts (removes and returns) the first value from the `input` iterator.
 * Like `Array.prototype.shift()` but for an `Iterator`.
 */
function shiftIterator(input) {
  const { done, value } = input.next();
  return done ? void 0 : value;
}
/**
 * Convert a single validation result to a failure.
 */
function toFailure(result, context, struct, value) {
  if (result === true) return;
  else if (result === false) result = {};
  else if (typeof result === "string")
    result = { message: result };
  const { path, branch } = context;
  const { type } = struct;
  const {
    refinement,
    message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ""}, but received: \`${print(value)}\``,
  } = result;
  return {
    value,
    type,
    refinement,
    key: path[path.length - 1],
    path,
    branch,
    ...result,
    message,
  };
}
/**
 * Convert a validation result to an iterable of failures.
 */
function* toFailures(result, context, struct, value) {
  if (!isIterable(result)) result = [result];
  for (const r of result) {
    const failure = toFailure(r, context, struct, value);
    if (failure) yield failure;
  }
}
/**
 * Check a value against a struct, traversing deeply into nested values, and
 * returning an iterator of failures or success.
 */
function* run(value, struct, options = {}) {
  const {
    path = [],
    branch = [value],
    coerce = false,
    mask = false,
  } = options;
  const ctx = {
    path,
    branch,
    mask,
  };
  if (coerce) value = struct.coercer(value, ctx);
  let status = "valid";
  for (const failure of struct.validator(value, ctx)) {
    failure.explanation = options.message;
    status = "not_valid";
    yield [failure, void 0];
  }
  for (let [k, v, s] of struct.entries(value, ctx)) {
    const ts = run(v, s, {
      path: k === void 0 ? path : [...path, k],
      branch: k === void 0 ? branch : [...branch, v],
      coerce,
      mask,
      message: options.message,
    });
    for (const t of ts)
      if (t[0]) {
        status =
          t[0].refinement != null
            ? "not_refined"
            : "not_valid";
        yield [t[0], void 0];
      } else if (coerce) {
        v = t[1];
        if (k === void 0) value = v;
        else if (value instanceof Map) value.set(k, v);
        else if (value instanceof Set) value.add(v);
        else if (isObject(value)) {
          if (v !== void 0 || k in value) value[k] = v;
        }
      }
  }
  if (status !== "not_valid")
    for (const failure of struct.refiner(value, ctx)) {
      failure.explanation = options.message;
      status = "not_refined";
      yield [failure, void 0];
    }
  if (status === "valid") yield [void 0, value];
}
/**
 * `Struct` objects encapsulate the validation logic for a specific type of
 * values. Once constructed, you use the `assert`, `is` or `validate` helpers to
 * validate unknown input data against the struct.
 */
var Struct = class {
  constructor(props) {
    const {
      type,
      schema,
      validator,
      refiner,
      coercer = (value) => value,
      entries = function* () {},
    } = props;
    this.type = type;
    this.schema = schema;
    this.entries = entries;
    this.coercer = coercer;
    if (validator)
      this.validator = (value, context) => {
        return toFailures(
          validator(value, context),
          context,
          this,
          value,
        );
      };
    else this.validator = () => [];
    if (refiner)
      this.refiner = (value, context) => {
        return toFailures(
          refiner(value, context),
          context,
          this,
          value,
        );
      };
    else this.refiner = () => [];
  }
  /**
   * Assert that a value passes the struct's validation, throwing if it doesn't.
   */
  assert(value, message) {
    return assert(value, this, message);
  }
  /**
   * Create a value with the struct's coercion logic, then validate it.
   */
  create(value, message) {
    return create(value, this, message);
  }
  /**
   * Check if a value passes the struct's validation.
   */
  is(value) {
    return is(value, this);
  }
  /**
   * Mask a value, coercing and validating it, but returning only the subset of
   * properties defined by the struct's schema. Masking applies recursively to
   * props of `object` structs only.
   */
  mask(value, message) {
    return mask(value, this, message);
  }
  /**
   * Validate a value with the struct's validation logic, returning a tuple
   * representing the result.
   *
   * You may optionally pass `true` for the `coerce` argument to coerce
   * the value before attempting to validate it. If you do, the result will
   * contain the coerced result when successful. Also, `mask` will turn on
   * masking of the unknown `object` props recursively if passed.
   */
  validate(value, options = {}) {
    return validate(value, this, options);
  }
};
/**
 * Assert that a value passes a struct, throwing if it doesn't.
 */
function assert(value, struct, message) {
  const result = validate(value, struct, { message });
  if (result[0]) throw result[0];
}
/**
 * Create a value with the coercion logic of struct and validate it.
 */
function create(value, struct, message) {
  const result = validate(value, struct, {
    coerce: true,
    message,
  });
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Mask a value, returning only the subset of properties defined by a struct.
 */
function mask(value, struct, message) {
  const result = validate(value, struct, {
    coerce: true,
    mask: true,
    message,
  });
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Check if a value passes a struct.
 */
function is(value, struct) {
  return !validate(value, struct)[0];
}
/**
 * Validate a value against a struct, returning an error if invalid, or the
 * value (with potential coercion) if valid.
 */
function validate(value, struct, options = {}) {
  const tuples = run(value, struct, options);
  const tuple = shiftIterator(tuples);
  if (tuple[0])
    return [
      new StructError(tuple[0], function* () {
        for (const t of tuples) if (t[0]) yield t[0];
      }),
      void 0,
    ];
  else return [void 0, tuple[1]];
}
/**
 * Define a new struct type with a custom validation function.
 */
function define(name, validator) {
  return new Struct({
    type: name,
    schema: null,
    validator,
  });
}
function array(Element) {
  return new Struct({
    type: "array",
    schema: Element,
    *entries(value) {
      if (Element && Array.isArray(value))
        for (const [i, v] of value.entries())
          yield [i, v, Element];
    },
    coercer(value) {
      return Array.isArray(value) ? value.slice() : value;
    },
    validator(value) {
      return (
        Array.isArray(value) ||
        `Expected an array value, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that a value is a valid `Date`.
 *
 * Note: this also ensures that the value is *not* an invalid `Date` object,
 * which can occur when parsing a date fails but still returns a `Date`.
 */
function date() {
  return define("date", (value) => {
    return (
      (value instanceof Date && !isNaN(value.getTime())) ||
      `Expected a valid \`Date\` object, but received: ${print(value)}`
    );
  });
}
function enums(values) {
  const schema = {};
  const description = values.map((v) => print(v)).join();
  for (const key of values) schema[key] = key;
  return new Struct({
    type: "enums",
    schema,
    validator(value) {
      return (
        values.includes(value) ||
        `Expected one of \`${description}\`, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that no value ever passes validation.
 */
function never() {
  return define("never", () => false);
}
/**
 * Augment an existing struct to allow `null` values.
 */
function nullable(struct) {
  return new Struct({
    ...struct,
    validator: (value, ctx) =>
      value === null || struct.validator(value, ctx),
    refiner: (value, ctx) =>
      value === null || struct.refiner(value, ctx),
  });
}
/**
 * Ensure that a value is a number.
 */
function number() {
  return define("number", (value) => {
    return (
      (typeof value === "number" && !isNaN(value)) ||
      `Expected a number, but received: ${print(value)}`
    );
  });
}
function object(schema) {
  const knowns = schema ? Object.keys(schema) : [];
  const Never = never();
  return new Struct({
    type: "object",
    schema: schema ? schema : null,
    *entries(value) {
      if (schema && isObject(value)) {
        const unknowns = new Set(Object.keys(value));
        for (const key of knowns) {
          unknowns.delete(key);
          yield [key, value[key], schema[key]];
        }
        for (const key of unknowns)
          yield [key, value[key], Never];
      }
    },
    validator(value) {
      return (
        isNonArrayObject(value) ||
        `Expected an object, but received: ${print(value)}`
      );
    },
    coercer(value, ctx) {
      if (!isNonArrayObject(value)) return value;
      const coerced = { ...value };
      if (ctx.mask && schema) {
        for (const key in coerced)
          if (schema[key] === void 0) delete coerced[key];
      }
      return coerced;
    },
  });
}
/**
 * Ensure that a value is a string.
 */
function string() {
  return define("string", (value) => {
    return (
      typeof value === "string" ||
      `Expected a string, but received: ${print(value)}`
    );
  });
}
/**
 * Ensure that a number or date is below a threshold.
 */
function max(struct, threshold, options = {}) {
  const { exclusive } = options;
  return refine(struct, "max", (value) => {
    return exclusive
      ? value < threshold
      : value <= threshold ||
          `Expected a ${struct.type} less than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
  });
}
/**
 * Ensure that a number or date is above a threshold.
 */
function min(struct, threshold, options = {}) {
  const { exclusive } = options;
  return refine(struct, "min", (value) => {
    return exclusive
      ? value > threshold
      : value >= threshold ||
          `Expected a ${struct.type} greater than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
  });
}
/**
 * Augment a `Struct` to add an additional refinement to the validation.
 *
 * The refiner function is guaranteed to receive a value of the struct's type,
 * because the struct's existing validation will already have passed. This
 * allows you to layer additional validation on top of existing structs.
 */
function refine(struct, name, refiner) {
  return new Struct({
    ...struct,
    *refiner(value, ctx) {
      yield* struct.refiner(value, ctx);
      const failures = toFailures(
        refiner(value, ctx),
        ctx,
        struct,
        value,
      );
      for (const failure of failures)
        yield {
          ...failure,
          refinement: name,
        };
    },
  });
}
//#endregion
//#region ../schemas/libraries/superstruct/download/index.ts
function stringWithLength(min, max) {
  return refine(
    string(),
    `string with length between ${min} and ${max}`,
    (value) => value.length >= min && value.length <= max,
  );
}
const urlSchema = refine(string(), "url", (value) =>
  URL.canParse(value),
);
const imageSchema = object({
  id: number(),
  created: date(),
  title: stringWithLength(1, 100),
  type: enums(["jpg", "png"]),
  size: number(),
  url: urlSchema,
});
const ratingSchema = object({
  id: number(),
  stars: max(min(number(), 1), 5),
  title: stringWithLength(1, 100),
  text: stringWithLength(1, 1e3),
  images: array(imageSchema),
});
create(
  {},
  object({
    id: number(),
    created: date(),
    title: stringWithLength(1, 100),
    brand: stringWithLength(1, 30),
    description: stringWithLength(1, 500),
    price: max(min(number(), 1), 1e4),
    discount: nullable(max(min(number(), 1), 100)),
    quantity: max(min(number(), 0), 10),
    tags: array(stringWithLength(1, 30)),
    images: array(imageSchema),
    ratings: array(ratingSchema),
  }),
);
//#endregion

//#region ../node_modules/.pnpm/superstruct@2.0.2/node_modules/superstruct/dist/index.mjs
/**
 * A `StructFailure` represents a single specific failure in validation.
 */
/**
 * `StructError` objects are thrown (or returned) when validation fails.
 *
 * Validation logic is design to exit early for maximum performance. The error
 * represents the first error encountered during validation. For more detail,
 * the `error.failures` property is a generator function that can be run to
 * continue validation and receive all the failures in the data.
 */
var StructError = class extends TypeError {
  constructor(failure, failures) {
    let cached;
    const { message, explanation, ...rest } = failure;
    const { path } = failure;
    const msg =
      path.length === 0 ? message : `At path: ${path.join(".")} -- ${message}`;
    super(explanation ?? msg);
    if (explanation != null) this.cause = msg;
    Object.assign(this, rest);
    this.name = this.constructor.name;
    this.failures = () => {
      return cached ?? (cached = [failure, ...failures()]);
    };
  }
};
/**
 * Check if a value is an iterator.
 */
function isIterable(x) {
  return isObject(x) && typeof x[Symbol.iterator] === "function";
}
/**
 * Check if a value is a plain object.
 */
function isObject(x) {
  return typeof x === "object" && x != null;
}
/**
 * Check if a value is a non-array object.
 */
function isNonArrayObject(x) {
  return isObject(x) && !Array.isArray(x);
}
/**
 * Return a value as a printable string.
 */
function print(value) {
  if (typeof value === "symbol") return value.toString();
  return typeof value === "string" ? JSON.stringify(value) : `${value}`;
}
/**
 * Shifts (removes and returns) the first value from the `input` iterator.
 * Like `Array.prototype.shift()` but for an `Iterator`.
 */
function shiftIterator(input) {
  const { done, value } = input.next();
  return done ? void 0 : value;
}
/**
 * Convert a single validation result to a failure.
 */
function toFailure(result, context, struct, value) {
  if (result === true) return;
  else if (result === false) result = {};
  else if (typeof result === "string") result = { message: result };
  const { path, branch } = context;
  const { type } = struct;
  const {
    refinement,
    message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ""}, but received: \`${print(value)}\``,
  } = result;
  return {
    value,
    type,
    refinement,
    key: path[path.length - 1],
    path,
    branch,
    ...result,
    message,
  };
}
/**
 * Convert a validation result to an iterable of failures.
 */
function* toFailures(result, context, struct, value) {
  if (!isIterable(result)) result = [result];
  for (const r of result) {
    const failure = toFailure(r, context, struct, value);
    if (failure) yield failure;
  }
}
/**
 * Check a value against a struct, traversing deeply into nested values, and
 * returning an iterator of failures or success.
 */
function* run(value, struct, options = {}) {
  const { path = [], branch = [value], coerce = false, mask = false } = options;
  const ctx = {
    path,
    branch,
    mask,
  };
  if (coerce) value = struct.coercer(value, ctx);
  let status = "valid";
  for (const failure of struct.validator(value, ctx)) {
    failure.explanation = options.message;
    status = "not_valid";
    yield [failure, void 0];
  }
  for (let [k, v, s] of struct.entries(value, ctx)) {
    const ts = run(v, s, {
      path: k === void 0 ? path : [...path, k],
      branch: k === void 0 ? branch : [...branch, v],
      coerce,
      mask,
      message: options.message,
    });
    for (const t of ts)
      if (t[0]) {
        status = t[0].refinement != null ? "not_refined" : "not_valid";
        yield [t[0], void 0];
      } else if (coerce) {
        v = t[1];
        if (k === void 0) value = v;
        else if (value instanceof Map) value.set(k, v);
        else if (value instanceof Set) value.add(v);
        else if (isObject(value)) {
          if (v !== void 0 || k in value) value[k] = v;
        }
      }
  }
  if (status !== "not_valid")
    for (const failure of struct.refiner(value, ctx)) {
      failure.explanation = options.message;
      status = "not_refined";
      yield [failure, void 0];
    }
  if (status === "valid") yield [void 0, value];
}
/**
 * `Struct` objects encapsulate the validation logic for a specific type of
 * values. Once constructed, you use the `assert`, `is` or `validate` helpers to
 * validate unknown input data against the struct.
 */
var Struct = class {
  constructor(props) {
    const {
      type,
      schema,
      validator,
      refiner,
      coercer = (value) => value,
      entries = function* () {},
    } = props;
    this.type = type;
    this.schema = schema;
    this.entries = entries;
    this.coercer = coercer;
    if (validator)
      this.validator = (value, context) => {
        return toFailures(validator(value, context), context, this, value);
      };
    else this.validator = () => [];
    if (refiner)
      this.refiner = (value, context) => {
        return toFailures(refiner(value, context), context, this, value);
      };
    else this.refiner = () => [];
  }
  /**
   * Assert that a value passes the struct's validation, throwing if it doesn't.
   */
  assert(value, message) {
    return assert(value, this, message);
  }
  /**
   * Create a value with the struct's coercion logic, then validate it.
   */
  create(value, message) {
    return create(value, this, message);
  }
  /**
   * Check if a value passes the struct's validation.
   */
  is(value) {
    return is(value, this);
  }
  /**
   * Mask a value, coercing and validating it, but returning only the subset of
   * properties defined by the struct's schema. Masking applies recursively to
   * props of `object` structs only.
   */
  mask(value, message) {
    return mask(value, this, message);
  }
  /**
   * Validate a value with the struct's validation logic, returning a tuple
   * representing the result.
   *
   * You may optionally pass `true` for the `coerce` argument to coerce
   * the value before attempting to validate it. If you do, the result will
   * contain the coerced result when successful. Also, `mask` will turn on
   * masking of the unknown `object` props recursively if passed.
   */
  validate(value, options = {}) {
    return validate(value, this, options);
  }
};
/**
 * Assert that a value passes a struct, throwing if it doesn't.
 */
function assert(value, struct, message) {
  const result = validate(value, struct, { message });
  if (result[0]) throw result[0];
}
/**
 * Create a value with the coercion logic of struct and validate it.
 */
function create(value, struct, message) {
  const result = validate(value, struct, {
    coerce: true,
    message,
  });
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Mask a value, returning only the subset of properties defined by a struct.
 */
function mask(value, struct, message) {
  const result = validate(value, struct, {
    coerce: true,
    mask: true,
    message,
  });
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Check if a value passes a struct.
 */
function is(value, struct) {
  return !validate(value, struct)[0];
}
/**
 * Validate a value against a struct, returning an error if invalid, or the
 * value (with potential coercion) if valid.
 */
function validate(value, struct, options = {}) {
  const tuples = run(value, struct, options);
  const tuple = shiftIterator(tuples);
  if (tuple[0])
    return [
      new StructError(tuple[0], function* () {
        for (const t of tuples) if (t[0]) yield t[0];
      }),
      void 0,
    ];
  else return [void 0, tuple[1]];
}
/**
 * Define a new struct type with a custom validation function.
 */
function define(name, validator) {
  return new Struct({
    type: name,
    schema: null,
    validator,
  });
}
function array(Element) {
  return new Struct({
    type: "array",
    schema: Element,
    *entries(value) {
      if (Element && Array.isArray(value))
        for (const [i, v] of value.entries()) yield [i, v, Element];
    },
    coercer(value) {
      return Array.isArray(value) ? value.slice() : value;
    },
    validator(value) {
      return (
        Array.isArray(value) ||
        `Expected an array value, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that a value is a valid `Date`.
 *
 * Note: this also ensures that the value is *not* an invalid `Date` object,
 * which can occur when parsing a date fails but still returns a `Date`.
 */
function date() {
  return define("date", (value) => {
    return (
      (value instanceof Date && !isNaN(value.getTime())) ||
      `Expected a valid \`Date\` object, but received: ${print(value)}`
    );
  });
}
function enums(values) {
  const schema = {};
  const description = values.map((v) => print(v)).join();
  for (const key of values) schema[key] = key;
  return new Struct({
    type: "enums",
    schema,
    validator(value) {
      return (
        values.includes(value) ||
        `Expected one of \`${description}\`, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that no value ever passes validation.
 */
function never() {
  return define("never", () => false);
}
/**
 * Augment an existing struct to allow `null` values.
 */
function nullable(struct) {
  return new Struct({
    ...struct,
    validator: (value, ctx) => value === null || struct.validator(value, ctx),
    refiner: (value, ctx) => value === null || struct.refiner(value, ctx),
  });
}
/**
 * Ensure that a value is a number.
 */
function number() {
  return define("number", (value) => {
    return (
      (typeof value === "number" && !isNaN(value)) ||
      `Expected a number, but received: ${print(value)}`
    );
  });
}
function object(schema) {
  const knowns = schema ? Object.keys(schema) : [];
  const Never = never();
  return new Struct({
    type: "object",
    schema: schema ? schema : null,
    *entries(value) {
      if (schema && isObject(value)) {
        const unknowns = new Set(Object.keys(value));
        for (const key of knowns) {
          unknowns.delete(key);
          yield [key, value[key], schema[key]];
        }
        for (const key of unknowns) yield [key, value[key], Never];
      }
    },
    validator(value) {
      return (
        isNonArrayObject(value) ||
        `Expected an object, but received: ${print(value)}`
      );
    },
    coercer(value, ctx) {
      if (!isNonArrayObject(value)) return value;
      const coerced = { ...value };
      if (ctx.mask && schema) {
        for (const key in coerced)
          if (schema[key] === void 0) delete coerced[key];
      }
      return coerced;
    },
  });
}
/**
 * Ensure that a value is a string.
 */
function string() {
  return define("string", (value) => {
    return (
      typeof value === "string" ||
      `Expected a string, but received: ${print(value)}`
    );
  });
}
/**
 * Ensure that a number or date is below a threshold.
 */
function max(struct, threshold, options = {}) {
  const { exclusive } = options;
  return refine(struct, "max", (value) => {
    return exclusive
      ? value < threshold
      : value <= threshold ||
          `Expected a ${struct.type} less than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
  });
}
/**
 * Ensure that a number or date is above a threshold.
 */
function min(struct, threshold, options = {}) {
  const { exclusive } = options;
  return refine(struct, "min", (value) => {
    return exclusive
      ? value > threshold
      : value >= threshold ||
          `Expected a ${struct.type} greater than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
  });
}
/**
 * Augment a `Struct` to add an additional refinement to the validation.
 *
 * The refiner function is guaranteed to receive a value of the struct's type,
 * because the struct's existing validation will already have passed. This
 * allows you to layer additional validation on top of existing structs.
 */
function refine(struct, name, refiner) {
  return new Struct({
    ...struct,
    *refiner(value, ctx) {
      yield* struct.refiner(value, ctx);
      const failures = toFailures(refiner(value, ctx), ctx, struct, value);
      for (const failure of failures)
        yield {
          ...failure,
          refinement: name,
        };
    },
  });
}
//#endregion
//#region ../schemas/libraries/superstruct/download/index.ts
function stringWithLength(min, max) {
  return refine(
    string(),
    `string with length between ${min} and ${max}`,
    (value) => value.length >= min && value.length <= max,
  );
}
const urlSchema = refine(string(), "url", (value) => URL.canParse(value));
const imageSchema = object({
  id: number(),
  created: date(),
  title: stringWithLength(1, 100),
  type: enums(["jpg", "png"]),
  size: number(),
  url: urlSchema,
});
const ratingSchema = object({
  id: number(),
  stars: max(min(number(), 1), 5),
  title: stringWithLength(1, 100),
  text: stringWithLength(1, 1e3),
  images: array(imageSchema),
});
create(
  {},
  object({
    id: number(),
    created: date(),
    title: stringWithLength(1, 100),
    brand: stringWithLength(1, 30),
    description: stringWithLength(1, 500),
    price: max(min(number(), 1), 1e4),
    discount: nullable(max(min(number(), 1), 100)),
    quantity: max(min(number(), 0), 10),
    tags: array(stringWithLength(1, 30)),
    images: array(imageSchema),
    ratings: array(ratingSchema),
  }),
);
//#endregion

//#region ../node_modules/.pnpm/superstruct@2.0.2/node_modules/superstruct/dist/index.mjs
/**
 * A `StructFailure` represents a single specific failure in validation.
 */
/**
 * `StructError` objects are thrown (or returned) when validation fails.
 *
 * Validation logic is design to exit early for maximum performance. The error
 * represents the first error encountered during validation. For more detail,
 * the `error.failures` property is a generator function that can be run to
 * continue validation and receive all the failures in the data.
 */
var StructError = class extends TypeError {
  constructor(failure, failures) {
    let cached;
    const { message, explanation, ...rest } = failure;
    const { path } = failure;
    const msg = path.length === 0 ? message : `At path: ${path.join(".")} -- ${message}`;
    super(explanation ?? msg);
    if (explanation != null) this.cause = msg;
    Object.assign(this, rest);
    this.name = this.constructor.name;
    this.failures = () => {
      return cached ?? (cached = [failure, ...failures()]);
    };
  }
};
/**
 * Check if a value is an iterator.
 */
function isIterable(x) {
  return isObject(x) && typeof x[Symbol.iterator] === "function";
}
/**
 * Check if a value is a plain object.
 */
function isObject(x) {
  return typeof x === "object" && x != null;
}
/**
 * Check if a value is a non-array object.
 */
function isNonArrayObject(x) {
  return isObject(x) && !Array.isArray(x);
}
/**
 * Return a value as a printable string.
 */
function print(value) {
  if (typeof value === "symbol") return value.toString();
  return typeof value === "string" ? JSON.stringify(value) : `${value}`;
}
/**
 * Shifts (removes and returns) the first value from the `input` iterator.
 * Like `Array.prototype.shift()` but for an `Iterator`.
 */
function shiftIterator(input) {
  const { done, value } = input.next();
  return done ? void 0 : value;
}
/**
 * Convert a single validation result to a failure.
 */
function toFailure(result, context, struct, value) {
  if (result === true) return;
  else if (result === false) result = {};
  else if (typeof result === "string") result = { message: result };
  const { path, branch } = context;
  const { type } = struct;
  const {
    refinement,
    message = `Expected a value of type \`${type}\`${refinement ? ` with refinement \`${refinement}\`` : ""}, but received: \`${print(value)}\``,
  } = result;
  return {
    value,
    type,
    refinement,
    key: path[path.length - 1],
    path,
    branch,
    ...result,
    message,
  };
}
/**
 * Convert a validation result to an iterable of failures.
 */
function* toFailures(result, context, struct, value) {
  if (!isIterable(result)) result = [result];
  for (const r of result) {
    const failure = toFailure(r, context, struct, value);
    if (failure) yield failure;
  }
}
/**
 * Check a value against a struct, traversing deeply into nested values, and
 * returning an iterator of failures or success.
 */
function* run(value, struct, options = {}) {
  const { path = [], branch = [value], coerce = false, mask = false } = options;
  const ctx = {
    path,
    branch,
    mask,
  };
  if (coerce) value = struct.coercer(value, ctx);
  let status = "valid";
  for (const failure of struct.validator(value, ctx)) {
    failure.explanation = options.message;
    status = "not_valid";
    yield [failure, void 0];
  }
  for (let [k, v, s] of struct.entries(value, ctx)) {
    const ts = run(v, s, {
      path: k === void 0 ? path : [...path, k],
      branch: k === void 0 ? branch : [...branch, v],
      coerce,
      mask,
      message: options.message,
    });
    for (const t of ts)
      if (t[0]) {
        status = t[0].refinement != null ? "not_refined" : "not_valid";
        yield [t[0], void 0];
      } else if (coerce) {
        v = t[1];
        if (k === void 0) value = v;
        else if (value instanceof Map) value.set(k, v);
        else if (value instanceof Set) value.add(v);
        else if (isObject(value)) {
          if (v !== void 0 || k in value) value[k] = v;
        }
      }
  }
  if (status !== "not_valid")
    for (const failure of struct.refiner(value, ctx)) {
      failure.explanation = options.message;
      status = "not_refined";
      yield [failure, void 0];
    }
  if (status === "valid") yield [void 0, value];
}
/**
 * `Struct` objects encapsulate the validation logic for a specific type of
 * values. Once constructed, you use the `assert`, `is` or `validate` helpers to
 * validate unknown input data against the struct.
 */
var Struct = class {
  constructor(props) {
    const {
      type,
      schema,
      validator,
      refiner,
      coercer = (value) => value,
      entries = function* () {},
    } = props;
    this.type = type;
    this.schema = schema;
    this.entries = entries;
    this.coercer = coercer;
    if (validator)
      this.validator = (value, context) => {
        return toFailures(validator(value, context), context, this, value);
      };
    else this.validator = () => [];
    if (refiner)
      this.refiner = (value, context) => {
        return toFailures(refiner(value, context), context, this, value);
      };
    else this.refiner = () => [];
  }
  /**
   * Assert that a value passes the struct's validation, throwing if it doesn't.
   */
  assert(value, message) {
    return assert(value, this, message);
  }
  /**
   * Create a value with the struct's coercion logic, then validate it.
   */
  create(value, message) {
    return create(value, this, message);
  }
  /**
   * Check if a value passes the struct's validation.
   */
  is(value) {
    return is(value, this);
  }
  /**
   * Mask a value, coercing and validating it, but returning only the subset of
   * properties defined by the struct's schema. Masking applies recursively to
   * props of `object` structs only.
   */
  mask(value, message) {
    return mask(value, this, message);
  }
  /**
   * Validate a value with the struct's validation logic, returning a tuple
   * representing the result.
   *
   * You may optionally pass `true` for the `coerce` argument to coerce
   * the value before attempting to validate it. If you do, the result will
   * contain the coerced result when successful. Also, `mask` will turn on
   * masking of the unknown `object` props recursively if passed.
   */
  validate(value, options = {}) {
    return validate(value, this, options);
  }
};
/**
 * Assert that a value passes a struct, throwing if it doesn't.
 */
function assert(value, struct, message) {
  const result = validate(value, struct, { message });
  if (result[0]) throw result[0];
}
/**
 * Create a value with the coercion logic of struct and validate it.
 */
function create(value, struct, message) {
  const result = validate(value, struct, {
    coerce: true,
    message,
  });
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Mask a value, returning only the subset of properties defined by a struct.
 */
function mask(value, struct, message) {
  const result = validate(value, struct, {
    coerce: true,
    mask: true,
    message,
  });
  if (result[0]) throw result[0];
  else return result[1];
}
/**
 * Check if a value passes a struct.
 */
function is(value, struct) {
  return !validate(value, struct)[0];
}
/**
 * Validate a value against a struct, returning an error if invalid, or the
 * value (with potential coercion) if valid.
 */
function validate(value, struct, options = {}) {
  const tuples = run(value, struct, options);
  const tuple = shiftIterator(tuples);
  if (tuple[0])
    return [
      new StructError(tuple[0], function* () {
        for (const t of tuples) if (t[0]) yield t[0];
      }),
      void 0,
    ];
  else return [void 0, tuple[1]];
}
/**
 * Define a new struct type with a custom validation function.
 */
function define(name, validator) {
  return new Struct({
    type: name,
    schema: null,
    validator,
  });
}
function array(Element) {
  return new Struct({
    type: "array",
    schema: Element,
    *entries(value) {
      if (Element && Array.isArray(value))
        for (const [i, v] of value.entries()) yield [i, v, Element];
    },
    coercer(value) {
      return Array.isArray(value) ? value.slice() : value;
    },
    validator(value) {
      return Array.isArray(value) || `Expected an array value, but received: ${print(value)}`;
    },
  });
}
/**
 * Ensure that a value is a valid `Date`.
 *
 * Note: this also ensures that the value is *not* an invalid `Date` object,
 * which can occur when parsing a date fails but still returns a `Date`.
 */
function date() {
  return define("date", (value) => {
    return (
      (value instanceof Date && !isNaN(value.getTime())) ||
      `Expected a valid \`Date\` object, but received: ${print(value)}`
    );
  });
}
function enums(values) {
  const schema = {};
  const description = values.map((v) => print(v)).join();
  for (const key of values) schema[key] = key;
  return new Struct({
    type: "enums",
    schema,
    validator(value) {
      return (
        values.includes(value) ||
        `Expected one of \`${description}\`, but received: ${print(value)}`
      );
    },
  });
}
/**
 * Ensure that no value ever passes validation.
 */
function never() {
  return define("never", () => false);
}
/**
 * Augment an existing struct to allow `null` values.
 */
function nullable(struct) {
  return new Struct({
    ...struct,
    validator: (value, ctx) => value === null || struct.validator(value, ctx),
    refiner: (value, ctx) => value === null || struct.refiner(value, ctx),
  });
}
/**
 * Ensure that a value is a number.
 */
function number() {
  return define("number", (value) => {
    return (
      (typeof value === "number" && !isNaN(value)) ||
      `Expected a number, but received: ${print(value)}`
    );
  });
}
function object(schema) {
  const knowns = schema ? Object.keys(schema) : [];
  const Never = never();
  return new Struct({
    type: "object",
    schema: schema ? schema : null,
    *entries(value) {
      if (schema && isObject(value)) {
        const unknowns = new Set(Object.keys(value));
        for (const key of knowns) {
          unknowns.delete(key);
          yield [key, value[key], schema[key]];
        }
        for (const key of unknowns) yield [key, value[key], Never];
      }
    },
    validator(value) {
      return isNonArrayObject(value) || `Expected an object, but received: ${print(value)}`;
    },
    coercer(value, ctx) {
      if (!isNonArrayObject(value)) return value;
      const coerced = { ...value };
      if (ctx.mask && schema) {
        for (const key in coerced) if (schema[key] === void 0) delete coerced[key];
      }
      return coerced;
    },
  });
}
/**
 * Ensure that a value is a string.
 */
function string() {
  return define("string", (value) => {
    return typeof value === "string" || `Expected a string, but received: ${print(value)}`;
  });
}
/**
 * Ensure that a number or date is below a threshold.
 */
function max(struct, threshold, options = {}) {
  const { exclusive } = options;
  return refine(struct, "max", (value) => {
    return exclusive
      ? value < threshold
      : value <= threshold ||
          `Expected a ${struct.type} less than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
  });
}
/**
 * Ensure that a number or date is above a threshold.
 */
function min(struct, threshold, options = {}) {
  const { exclusive } = options;
  return refine(struct, "min", (value) => {
    return exclusive
      ? value > threshold
      : value >= threshold ||
          `Expected a ${struct.type} greater than ${exclusive ? "" : "or equal to "}${threshold} but received \`${value}\``;
  });
}
/**
 * Augment a `Struct` to add an additional refinement to the validation.
 *
 * The refiner function is guaranteed to receive a value of the struct's type,
 * because the struct's existing validation will already have passed. This
 * allows you to layer additional validation on top of existing structs.
 */
function refine(struct, name, refiner) {
  return new Struct({
    ...struct,
    *refiner(value, ctx) {
      yield* struct.refiner(value, ctx);
      const failures = toFailures(refiner(value, ctx), ctx, struct, value);
      for (const failure of failures)
        yield {
          ...failure,
          refinement: name,
        };
    },
  });
}
//#endregion
//#region ../schemas/libraries/superstruct/download/index.ts
function stringWithLength(min, max) {
  return refine(
    string(),
    `string with length between ${min} and ${max}`,
    (value) => value.length >= min && value.length <= max,
  );
}
const urlSchema = refine(string(), "url", (value) => URL.canParse(value));
const imageSchema = object({
  id: number(),
  created: date(),
  title: stringWithLength(1, 100),
  type: enums(["jpg", "png"]),
  size: number(),
  url: urlSchema,
});
const ratingSchema = object({
  id: number(),
  stars: max(min(number(), 1), 5),
  title: stringWithLength(1, 100),
  text: stringWithLength(1, 1e3),
  images: array(imageSchema),
});
create(
  {},
  object({
    id: number(),
    created: date(),
    title: stringWithLength(1, 100),
    brand: stringWithLength(1, 30),
    description: stringWithLength(1, 500),
    price: max(min(number(), 1), 1e4),
    discount: nullable(max(min(number(), 1), 100)),
    quantity: max(min(number(), 0), 10),
    tags: array(stringWithLength(1, 30)),
    images: array(imageSchema),
    ratings: array(ratingSchema),
  }),
);
//#endregion

Preferences

Style

Theme

NPM browser

Code ligatures