@meteora-ag/cp-amm-sdk 1.0.1 → 1.0.2

package/node_modules/superstruct/umd/superstruct.min.d.ts

@@ -1,579 +0,0 @@
-/**
- * A `StructFailure` represents a single specific failure in validation.
- */
-type Failure = {
-    value: any;
-    key: any;
-    type: string;
-    refinement: string | undefined;
-    message: string;
-    branch: Array<any>;
-    path: Array<any>;
-};
-/**
- * `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.
- */
-declare class StructError extends TypeError {
-    value: any;
-    key: any;
-    type: string;
-    refinement: string | undefined;
-    path: Array<any>;
-    branch: Array<any>;
-    failures: () => Array<Failure>;
-    [x: string]: any;
-    constructor(failure: Failure, failures: () => Generator<Failure>);
-}
-/**
- * Convert a union of type to an intersection.
- */
-type UnionToIntersection<U> = (U extends any ? (arg: U) => any : never) extends (arg: infer I) => void ? I : never;
-/**
- * Assign properties from one type to another, overwriting existing.
- */
-type Assign<T, U> = Simplify<U & Omit<T, keyof U>>;
-/**
- * A schema for enum structs.
- */
-type EnumSchema<T extends string | number | undefined> = {
-    [K in NonNullable<T>]: K;
-};
-/**
- * Check if a type is a match for another whilst treating overlapping
- * unions as a match.
- */
-type IsMatch<T, G> = T extends G ? (G extends T ? T : never) : never;
-/**
- * Check if a type is an exact match.
- */
-type IsExactMatch<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? T : never;
-/**
- * Check if a type is a record type.
- */
-type IsRecord<T> = T extends object ? string extends keyof T ? T : never : never;
-/**
- * Check if a type is a tuple.
- */
-type IsTuple<T> = T extends [
-    any
-] ? T : T extends [
-    any,
-    any
-] ? T : T extends [
-    any,
-    any,
-    any
-] ? T : T extends [
-    any,
-    any,
-    any,
-    any
-] ? T : T extends [
-    any,
-    any,
-    any,
-    any,
-    any
-] ? T : never;
-/**
- * Check if a type is a union.
- */
-type IsUnion<T, U extends T = T> = (T extends any ? (U extends T ? false : true) : false) extends false ? never : T;
-/**
- * A schema for object structs.
- */
-type ObjectSchema = Record<string, Struct<any, any>>;
-/**
- * Infer a type from an object struct schema.
- */
-type ObjectType<S extends ObjectSchema> = Simplify<Optionalize<{
-    [K in keyof S]: Infer<S[K]>;
-}>>;
-/**
- * Omit properties from a type that extend from a specific type.
- */
-type OmitBy<T, V> = Omit<T, {
-    [K in keyof T]: V extends Extract<T[K], V> ? K : never;
-}[keyof T]>;
-/**
- * Normalize properties of a type that allow `undefined` to make them optional.
- */
-type Optionalize<S extends object> = OmitBy<S, undefined> & Partial<PickBy<S, undefined>>;
-/**
- * Transform an object schema type to represent a partial.
- */
-type PartialObjectSchema<S extends ObjectSchema> = {
-    [K in keyof S]: Struct<Infer<S[K]> | undefined>;
-};
-/**
- * Pick properties from a type that extend from a specific type.
- */
-type PickBy<T, V> = Pick<T, {
-    [K in keyof T]: V extends Extract<T[K], V> ? K : never;
-}[keyof T]>;
-/**
- * Simplifies a type definition to its most basic representation.
- */
-type Simplify<T> = T extends any[] | Date ? T : {
-    [K in keyof T]: T[K];
-} & {};
-/**
- * A schema for any type of struct.
- */
-type StructSchema<T> = [
-    T
-] extends [
-    string | undefined
-] ? [
-    T
-] extends [
-    IsMatch<T, string | undefined>
-] ? null : [
-    T
-] extends [
-    IsUnion<T>
-] ? EnumSchema<T> : T : [
-    T
-] extends [
-    number | undefined
-] ? [
-    T
-] extends [
-    IsMatch<T, number | undefined>
-] ? null : [
-    T
-] extends [
-    IsUnion<T>
-] ? EnumSchema<T> : T : [
-    T
-] extends [
-    boolean
-] ? [
-    T
-] extends [
-    IsExactMatch<T, boolean>
-] ? null : T : T extends bigint | symbol | undefined | null | Function | Date | Error | RegExp | Map<any, any> | WeakMap<any, any> | Set<any> | WeakSet<any> | Promise<any> ? null : T extends Array<infer E> ? T extends IsTuple<T> ? null : Struct<E> : T extends object ? T extends IsRecord<T> ? null : {
-    [K in keyof T]: Describe<T[K]>;
-} : null;
-/**
- * Shorthand type for matching any `Struct`.
- */
-type AnyStruct = Struct<any, any>;
-/**
- * Infer a tuple of types from a tuple of `Struct`s.
- *
- * This is used to recursively retrieve the type from `union` `intersection` and
- * `tuple` structs.
- */
-type InferStructTuple<Tuple extends AnyStruct[], Length extends number = Tuple["length"]> = Length extends Length ? number extends Length ? Tuple : _InferTuple<Tuple, Length, [
-]> : never;
-type _InferTuple<Tuple extends AnyStruct[], Length extends number, Accumulated extends unknown[], Index extends number = Accumulated["length"]> = Index extends Length ? Accumulated : _InferTuple<Tuple, Length, [
-    ...Accumulated,
-    Infer<Tuple[Index]>
-]>;
-/**
- * `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.
- */
-declare class Struct<T = unknown, S = unknown> {
-    readonly TYPE: T;
-    type: string;
-    schema: S;
-    coercer: (value: unknown, context: Context) => unknown;
-    validator: (value: unknown, context: Context) => Iterable<Failure>;
-    refiner: (value: T, context: Context) => Iterable<Failure>;
-    entries: (value: unknown, context: Context) => Iterable<[
-        string | number,
-        unknown,
-        Struct<any> | Struct<never>
-    ]>;
-    constructor(props: {
-        type: string;
-        schema: S;
-        coercer?: Coercer;
-        validator?: Validator;
-        refiner?: Refiner<T>;
-        entries?: Struct<T, S>["entries"];
-    });
-    /**
-     * Assert that a value passes the struct's validation, throwing if it doesn't.
-     */
-    assert(value: unknown): asserts value is T;
-    /**
-     * Create a value with the struct's coercion logic, then validate it.
-     */
-    create(value: unknown): T;
-    /**
-     * Check if a value passes the struct's validation.
-     */
-    is(value: unknown): value is T;
-    /**
-     * Mask a value, coercing and validating it, but returning only the subset of
-     * properties defined by the struct's schema.
-     */
-    mask(value: unknown): T;
-    /**
-     * Validate a value with the struct's validation logic, returning a tuple
-     * representing the result.
-     *
-     * You may optionally pass `true` for the `withCoercion` argument to coerce
-     * the value before attempting to validate it. If you do, the result will
-     * contain the coerced result when successful.
-     */
-    validate(value: unknown, options?: {
-        coerce?: boolean;
-    }): [
-        StructError,
-        undefined
-    ] | [
-        undefined,
-        T
-    ];
-}
-/**
- * Assert that a value passes a struct, throwing if it doesn't.
- */
-declare function assert<T, S>(value: unknown, struct: Struct<T, S>): asserts value is T;
-/**
- * Create a value with the coercion logic of struct and validate it.
- */
-declare function create<T, S>(value: unknown, struct: Struct<T, S>): T;
-/**
- * Mask a value, returning only the subset of properties defined by a struct.
- */
-declare function mask<T, S>(value: unknown, struct: Struct<T, S>): T;
-/**
- * Check if a value passes a struct.
- */
-declare function is<T, S>(value: unknown, struct: Struct<T, S>): value is T;
-/**
- * Validate a value against a struct, returning an error if invalid, or the
- * value (with potential coercion) if valid.
- */
-declare function validate<T, S>(value: unknown, struct: Struct<T, S>, options?: {
-    coerce?: boolean;
-    mask?: boolean;
-}): [
-    StructError,
-    undefined
-] | [
-    undefined,
-    T
-];
-/**
- * A `Context` contains information about the current location of the
- * validation inside the initial input value.
- */
-type Context = {
-    branch: Array<any>;
-    path: Array<any>;
-};
-/**
- * A type utility to extract the type from a `Struct` class.
- */
-type Infer<T extends Struct<any, any>> = T["TYPE"];
-/**
- * A type utility to describe that a struct represents a TypeScript type.
- */
-type Describe<T> = Struct<T, StructSchema<T>>;
-/**
- * A `Result` is returned from validation functions.
- */
-type Result = boolean | string | Partial<Failure> | Iterable<boolean | string | Partial<Failure>>;
-/**
- * A `Coercer` takes an unknown value and optionally coerces it.
- */
-type Coercer<T = unknown> = (value: T, context: Context) => unknown;
-/**
- * A `Validator` takes an unknown value and validates it.
- */
-type Validator = (value: unknown, context: Context) => Result;
-/**
- * A `Refiner` takes a value of a known type and validates it against a further
- * constraint.
- */
-type Refiner<T> = (value: T, context: Context) => Result;
-/**
- * Augment a `Struct` to add an additional coercion step to its input.
- *
- * This allows you to transform input data before validating it, to increase the
- * likelihood that it passes validation—for example for default values, parsing
- * different formats, etc.
- *
- * Note: You must use `create(value, Struct)` on the value to have the coercion
- * take effect! Using simply `assert()` or `is()` will not use coercion.
- */
-declare function coerce<T, S, C>(struct: Struct<T, S>, condition: Struct<C, any>, coercer: Coercer<C>): Struct<T, S>;
-/**
- * Augment a struct to replace `undefined` values with a default.
- *
- * Note: You must use `create(value, Struct)` on the value to have the coercion
- * take effect! Using simply `assert()` or `is()` will not use coercion.
- */
-declare function defaulted<T, S>(struct: Struct<T, S>, fallback: any, options?: {
-    strict?: boolean;
-}): Struct<T, S>;
-/**
- * Augment a struct to trim string inputs.
- *
- * Note: You must use `create(value, Struct)` on the value to have the coercion
- * take effect! Using simply `assert()` or `is()` will not use coercion.
- */
-declare function trimmed<T, S>(struct: Struct<T, S>): Struct<T, S>;
-/**
- * Ensure that a string, array, map, or set is empty.
- */
-declare function empty<T extends string | any[] | Map<any, any> | Set<any>, S extends any>(struct: Struct<T, S>): Struct<T, S>;
-/**
- * Ensure that a number or date is below a threshold.
- */
-declare function max<T extends number | Date, S extends any>(struct: Struct<T, S>, threshold: T, options?: {
-    exclusive?: boolean;
-}): Struct<T, S>;
-/**
- * Ensure that a number or date is above a threshold.
- */
-declare function min<T extends number | Date, S extends any>(struct: Struct<T, S>, threshold: T, options?: {
-    exclusive?: boolean;
-}): Struct<T, S>;
-/**
- * Ensure that a string, array, map or set is not empty.
- */
-declare function nonempty<T extends string | any[] | Map<any, any> | Set<any>, S extends any>(struct: Struct<T, S>): Struct<T, S>;
-/**
- * Ensure that a string matches a regular expression.
- */
-declare function pattern<T extends string, S extends any>(struct: Struct<T, S>, regexp: RegExp): Struct<T, S>;
-/**
- * Ensure that a string, array, number, date, map, or set has a size (or length, or time) between `min` and `max`.
- */
-declare function size<T extends string | number | Date | any[] | Map<any, any> | Set<any>, S extends any>(struct: Struct<T, S>, min: number, max?: number): Struct<T, S>;
-/**
- * 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.
- */
-declare function refine<T, S>(struct: Struct<T, S>, name: string, refiner: Refiner<T>): Struct<T, S>;
-/**
- * Ensure that any value passes validation.
- */
-declare function any(): Struct<any, null>;
-/**
- * Ensure that a value is an array and that its elements are of a specific type.
- *
- * Note: If you omit the element struct, the arrays elements will not be
- * iterated at all. This can be helpful for cases where performance is critical,
- * and it is preferred to using `array(any())`.
- */
-declare function array<T extends Struct<any>>(Element: T): Struct<Infer<T>[], T>;
-declare function array(): Struct<unknown[], undefined>;
-/**
- * Ensure that a value is a bigint.
- */
-declare function bigint(): Struct<bigint, null>;
-/**
- * Ensure that a value is a boolean.
- */
-declare function boolean(): Struct<boolean, null>;
-/**
- * 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`.
- */
-declare function date(): Struct<Date, null>;
-/**
- * Ensure that a value is one of a set of potential values.
- *
- * Note: after creating the struct, you can access the definition of the
- * potential values as `struct.schema`.
- */
-declare function enums<T extends number>(values: readonly T[]): Struct<T, {
-    [K in T[][number]]: K;
-}>;
-declare function enums<T extends string>(values: readonly T[]): Struct<T, {
-    [K in T[][number]]: K;
-}>;
-/**
- * Ensure that a value is a function.
- */
-declare function func(): Struct<Function, null>;
-/**
- * Ensure that a value is an instance of a specific class.
- */
-declare function instance<T extends {
-    new (...args: any): any;
-}>(Class: T): Struct<InstanceType<T>, null>;
-/**
- * Ensure that a value is an integer.
- */
-declare function integer(): Struct<number, null>;
-/**
- * Ensure that a value matches all of a set of types.
- */
-declare function intersection<A extends AnyStruct, B extends AnyStruct[]>(Structs: [
-    A,
-    ...B
-]): Struct<Infer<A> & UnionToIntersection<InferStructTuple<B>[number]>, null>;
-/**
- * Ensure that a value is an exact value, using `===` for comparison.
- */
-declare function literal<T extends boolean>(constant: T): Struct<T, T>;
-declare function literal<T extends number>(constant: T): Struct<T, T>;
-declare function literal<T extends string>(constant: T): Struct<T, T>;
-declare function literal<T>(constant: T): Struct<T, null>;
-/**
- * Ensure that a value is a `Map` object, and that its keys and values are of
- * specific types.
- */
-declare function map(): Struct<Map<unknown, unknown>, null>;
-declare function map<K, V>(Key: Struct<K>, Value: Struct<V>): Struct<Map<K, V>, null>;
-/**
- * Ensure that no value ever passes validation.
- */
-declare function never(): Struct<never, null>;
-/**
- * Augment an existing struct to allow `null` values.
- */
-declare function nullable<T, S>(struct: Struct<T, S>): Struct<T | null, S>;
-/**
- * Ensure that a value is a number.
- */
-declare function number(): Struct<number, null>;
-/**
- * Ensure that a value is an object, that is has a known set of properties,
- * and that its properties are of specific types.
- *
- * Note: Unrecognized properties will fail validation.
- */
-declare function object(): Struct<Record<string, unknown>, null>;
-declare function object<S extends ObjectSchema>(schema: S): Struct<ObjectType<S>, S>;
-/**
- * Augment a struct to allow `undefined` values.
- */
-declare function optional<T, S>(struct: Struct<T, S>): Struct<T | undefined, S>;
-/**
- * Ensure that a value is an object with keys and values of specific types, but
- * without ensuring any specific shape of properties.
- *
- * Like TypeScript's `Record` utility.
- */
-declare function record<K extends string, V>(Key: Struct<K>, Value: Struct<V>): Struct<Record<K, V>, null>;
-/**
- * Ensure that a value is a `RegExp`.
- *
- * Note: this does not test the value against the regular expression! For that
- * you need to use the `pattern()` refinement.
- */
-declare function regexp(): Struct<RegExp, null>;
-/**
- * Ensure that a value is a `Set` object, and that its elements are of a
- * specific type.
- */
-declare function set(): Struct<Set<unknown>, null>;
-declare function set<T>(Element: Struct<T>): Struct<Set<T>, null>;
-/**
- * Ensure that a value is a string.
- */
-declare function string(): Struct<string, null>;
-/**
- * Ensure that a value is a tuple of a specific length, and that each of its
- * elements is of a specific type.
- */
-declare function tuple<A extends AnyStruct, B extends AnyStruct[]>(Structs: [
-    A,
-    ...B
-]): Struct<[
-    Infer<A>,
-    ...InferStructTuple<B>
-], null>;
-/**
- * Ensure that a value has a set of known properties of specific types.
- *
- * Note: Unrecognized properties are allowed and untouched. This is similar to
- * how TypeScript's structural typing works.
- */
-declare function type<S extends ObjectSchema>(schema: S): Struct<ObjectType<S>, S>;
-/**
- * Ensure that a value matches one of a set of types.
- */
-declare function union<A extends AnyStruct, B extends AnyStruct[]>(Structs: [
-    A,
-    ...B
-]): Struct<Infer<A> | InferStructTuple<B>[number], null>;
-/**
- * Ensure that any value passes validation, without widening its type to `any`.
- */
-declare function unknown(): Struct<unknown, null>;
-/**
- * Create a new struct that combines the properties properties from multiple
- * object or type structs. Its return type will match the first parameter's type.
- *
- * Like JavaScript's `Object.assign` utility.
- */
-declare function assign<A extends ObjectSchema, B extends ObjectSchema>(A: Struct<ObjectType<A>, A>, B: Struct<ObjectType<B>, B>): Struct<ObjectType<Assign<A, B>>, Assign<A, B>>;
-declare function assign<A extends ObjectSchema, B extends ObjectSchema, C extends ObjectSchema>(A: Struct<ObjectType<A>, A>, B: Struct<ObjectType<B>, B>, C: Struct<ObjectType<C>, C>): Struct<ObjectType<Assign<Assign<A, B>, C>>, Assign<Assign<A, B>, C>>;
-declare function assign<A extends ObjectSchema, B extends ObjectSchema, C extends ObjectSchema, D extends ObjectSchema>(A: Struct<ObjectType<A>, A>, B: Struct<ObjectType<B>, B>, C: Struct<ObjectType<C>, C>, D: Struct<ObjectType<D>, D>): Struct<ObjectType<Assign<Assign<Assign<A, B>, C>, D>>, Assign<Assign<Assign<A, B>, C>, D>>;
-declare function assign<A extends ObjectSchema, B extends ObjectSchema, C extends ObjectSchema, D extends ObjectSchema, E extends ObjectSchema>(A: Struct<ObjectType<A>, A>, B: Struct<ObjectType<B>, B>, C: Struct<ObjectType<C>, C>, D: Struct<ObjectType<D>, D>, E: Struct<ObjectType<E>, E>): Struct<ObjectType<Assign<Assign<Assign<Assign<A, B>, C>, D>, E>>, Assign<Assign<Assign<Assign<A, B>, C>, D>, E>>;
-/**
- * Define a new struct type with a custom validation function.
- */
-declare function define<T>(name: string, validator: Validator): Struct<T, null>;
-/**
- * Create a new struct based on an existing struct, but the value is allowed to
- * be `undefined`. `log` will be called if the value is not `undefined`.
- */
-declare function deprecated<T>(struct: Struct<T>, log: (value: unknown, ctx: Context) => void): Struct<T>;
-/**
- * Create a struct with dynamic validation logic.
- *
- * The callback will receive the value currently being validated, and must
- * return a struct object to validate it with. This can be useful to model
- * validation logic that changes based on its input.
- */
-declare function dynamic<T>(fn: (value: unknown, ctx: Context) => Struct<T, any>): Struct<T, null>;
-/**
- * Create a struct with lazily evaluated validation logic.
- *
- * The first time validation is run with the struct, the callback will be called
- * and must return a struct object to use. This is useful for cases where you
- * want to have self-referential structs for nested data structures to avoid a
- * circular definition problem.
- */
-declare function lazy<T>(fn: () => Struct<T, any>): Struct<T, null>;
-/**
- * Create a new struct based on an existing object struct, but excluding
- * specific properties.
- *
- * Like TypeScript's `Omit` utility.
- */
-declare function omit<S extends ObjectSchema, K extends keyof S>(struct: Struct<ObjectType<S>, S>, keys: K[]): Struct<ObjectType<Omit<S, K>>, Omit<S, K>>;
-/**
- * Create a new struct based on an existing object struct, but with all of its
- * properties allowed to be `undefined`.
- *
- * Like TypeScript's `Partial` utility.
- */
-declare function partial<S extends ObjectSchema>(struct: Struct<ObjectType<S>, S> | S): Struct<ObjectType<PartialObjectSchema<S>>, PartialObjectSchema<S>>;
-/**
- * Create a new struct based on an existing object struct, but only including
- * specific properties.
- *
- * Like TypeScript's `Pick` utility.
- */
-declare function pick<S extends ObjectSchema, K extends keyof S>(struct: Struct<ObjectType<S>, S>, keys: K[]): Struct<ObjectType<Pick<S, K>>, Pick<S, K>>;
-/**
- * Define a new struct type with a custom validation function.
- *
- * @deprecated This function has been renamed to `define`.
- */
-declare function struct<T>(name: string, validator: Validator): Struct<T, null>;
-export { Failure, StructError, Struct, assert, create, mask, is, validate, Context, Infer, Describe, Result, Coercer, Validator, Refiner, coerce, defaulted, trimmed, empty, max, min, nonempty, pattern, size, refine, any, array, bigint, boolean, date, enums, func, instance, integer, intersection, literal, map, never, nullable, number, object, optional, record, regexp, set, string, tuple, type, union, unknown, assign, define, deprecated, dynamic, lazy, omit, partial, pick, struct };

package/node_modules/superstruct/umd/superstruct.min.js

@@ -1 +0,0 @@
-!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).Superstruct={})}(this,(function(e){"use strict";class t extends TypeError{constructor(e,t){let n;const{message:r,...i}=e,{path:o}=e;super(0===o.length?r:"At path: "+o.join(".")+" -- "+r),this.value=void 0,this.key=void 0,this.type=void 0,this.refinement=void 0,this.path=void 0,this.branch=void 0,this.failures=void 0,Object.assign(this,i),this.name=this.constructor.name,this.failures=()=>{var r;return null!=(r=n)?r:n=[e,...t()]}}}function n(e){return"object"==typeof e&&null!=e}function r(e){if("[object Object]"!==Object.prototype.toString.call(e))return!1;const t=Object.getPrototypeOf(e);return null===t||t===Object.prototype}function i(e){return"string"==typeof e?JSON.stringify(e):""+e}function o(e,t,n,r){if(!0===e)return;!1===e?e={}:"string"==typeof e&&(e={message:e});const{path:o,branch:c}=t,{type:a}=n,{refinement:s,message:u="Expected a value of type `"+a+"`"+(s?" with refinement `"+s+"`":"")+", but received: `"+i(r)+"`"}=e;return{value:r,type:a,refinement:s,key:o[o.length-1],path:o,branch:c,...e,message:u}}function*c(e,t,r,i){var c;n(c=e)&&"function"==typeof c[Symbol.iterator]||(e=[e]);for(const n of e){const e=o(n,t,r,i);e&&(yield e)}}function*a(e,t,r){void 0===r&&(r={});const{path:i=[],branch:o=[e],coerce:c=!1,mask:s=!1}=r,u={path:i,branch:o};if(c&&(e=t.coercer(e,u),s&&"type"!==t.type&&n(t.schema)&&n(e)&&!Array.isArray(e)))for(const n in e)void 0===t.schema[n]&&delete e[n];let f=!0;for(const n of t.validator(e,u))f=!1,yield[n,void 0];for(let[r,d,l]of t.entries(e,u)){const t=a(d,l,{path:void 0===r?i:[...i,r],branch:void 0===r?o:[...o,d],coerce:c,mask:s});for(const i of t)i[0]?(f=!1,yield[i[0],void 0]):c&&(d=i[1],void 0===r?e=d:e instanceof Map?e.set(r,d):e instanceof Set?e.add(d):n(e)&&(e[r]=d))}if(f)for(const n of t.refiner(e,u))f=!1,yield[n,void 0];f&&(yield[void 0,e])}class s{constructor(e){this.TYPE=void 0,this.type=void 0,this.schema=void 0,this.coercer=void 0,this.validator=void 0,this.refiner=void 0,this.entries=void 0;const{type:t,schema:n,validator:r,refiner:i,coercer:o=(e=>e),entries:a=function*(){}}=e;this.type=t,this.schema=n,this.entries=a,this.coercer=o,this.validator=r?(e,t)=>c(r(e,t),t,this,e):()=>[],this.refiner=i?(e,t)=>c(i(e,t),t,this,e):()=>[]}assert(e){return u(e,this)}create(e){return f(e,this)}is(e){return l(e,this)}mask(e){return d(e,this)}validate(e,t){return void 0===t&&(t={}),p(e,this,t)}}function u(e,t){const n=p(e,t);if(n[0])throw n[0]}function f(e,t){const n=p(e,t,{coerce:!0});if(n[0])throw n[0];return n[1]}function d(e,t){const n=p(e,t,{coerce:!0,mask:!0});if(n[0])throw n[0];return n[1]}function l(e,t){return!p(e,t)[0]}function p(e,n,r){void 0===r&&(r={});const i=a(e,n,r),o=function(e){const{done:t,value:n}=e.next();return t?void 0:n}(i);if(o[0]){return[new t(o[0],(function*(){for(const e of i)e[0]&&(yield e[0])})),void 0]}return[void 0,o[1]]}function y(e,t){return new s({type:e,schema:null,validator:t})}function v(){return y("never",(()=>!1))}function h(e){const t=e?Object.keys(e):[],r=v();return new s({type:"object",schema:e||null,*entries(i){if(e&&n(i)){const n=new Set(Object.keys(i));for(const r of t)n.delete(r),yield[r,i[r],e[r]];for(const e of n)yield[e,i[e],r]}},validator:e=>n(e)||"Expected an object, but received: "+i(e),coercer:e=>n(e)?{...e}:e})}function m(e){return new s({...e,validator:(t,n)=>void 0===t||e.validator(t,n),refiner:(t,n)=>void 0===t||e.refiner(t,n)})}function b(){return y("string",(e=>"string"==typeof e||"Expected a string, but received: "+i(e)))}function g(e){const t=Object.keys(e);return new s({type:"type",schema:e,*entries(r){if(n(r))for(const n of t)yield[n,r[n],e[n]]},validator:e=>n(e)||"Expected an object, but received: "+i(e)})}function w(){return y("unknown",(()=>!0))}function x(e,t,n){return new s({...e,coercer:(r,i)=>l(r,t)?e.coercer(n(r,i),i):e.coercer(r,i)})}function E(e){return e instanceof Map||e instanceof Set?e.size:e.length}function j(e,t,n){return new s({...e,*refiner(r,i){yield*e.refiner(r,i);const o=c(n(r,i),i,e,r);for(const e of o)yield{...e,refinement:t}}})}e.Struct=s,e.StructError=t,e.any=function(){return y("any",(()=>!0))},e.array=function(e){return new s({type:"array",schema:e,*entries(t){if(e&&Array.isArray(t))for(const[n,r]of t.entries())yield[n,r,e]},coercer:e=>Array.isArray(e)?e.slice():e,validator:e=>Array.isArray(e)||"Expected an array value, but received: "+i(e)})},e.assert=u,e.assign=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];const r="type"===t[0].type,i=t.map((e=>e.schema)),o=Object.assign({},...i);return r?g(o):h(o)},e.bigint=function(){return y("bigint",(e=>"bigint"==typeof e))},e.boolean=function(){return y("boolean",(e=>"boolean"==typeof e))},e.coerce=x,e.create=f,e.date=function(){return y("date",(e=>e instanceof Date&&!isNaN(e.getTime())||"Expected a valid `Date` object, but received: "+i(e)))},e.defaulted=function(e,t,n){return void 0===n&&(n={}),x(e,w(),(e=>{const i="function"==typeof t?t():t;if(void 0===e)return i;if(!n.strict&&r(e)&&r(i)){const t={...e};let n=!1;for(const e in i)void 0===t[e]&&(t[e]=i[e],n=!0);if(n)return t}return e}))},e.define=y,e.deprecated=function(e,t){return new s({...e,refiner:(t,n)=>void 0===t||e.refiner(t,n),validator:(n,r)=>void 0===n||(t(n,r),e.validator(n,r))})},e.dynamic=function(e){return new s({type:"dynamic",schema:null,*entries(t,n){const r=e(t,n);yield*r.entries(t,n)},validator:(t,n)=>e(t,n).validator(t,n),coercer:(t,n)=>e(t,n).coercer(t,n),refiner:(t,n)=>e(t,n).refiner(t,n)})},e.empty=function(e){return j(e,"empty",(t=>{const n=E(t);return 0===n||"Expected an empty "+e.type+" but received one with a size of `"+n+"`"}))},e.enums=function(e){const t={},n=e.map((e=>i(e))).join();for(const n of e)t[n]=n;return new s({type:"enums",schema:t,validator:t=>e.includes(t)||"Expected one of `"+n+"`, but received: "+i(t)})},e.func=function(){return y("func",(e=>"function"==typeof e||"Expected a function, but received: "+i(e)))},e.instance=function(e){return y("instance",(t=>t instanceof e||"Expected a `"+e.name+"` instance, but received: "+i(t)))},e.integer=function(){return y("integer",(e=>"number"==typeof e&&!isNaN(e)&&Number.isInteger(e)||"Expected an integer, but received: "+i(e)))},e.intersection=function(e){return new s({type:"intersection",schema:null,*entries(t,n){for(const r of e)yield*r.entries(t,n)},*validator(t,n){for(const r of e)yield*r.validator(t,n)},*refiner(t,n){for(const r of e)yield*r.refiner(t,n)}})},e.is=l,e.lazy=function(e){let t;return new s({type:"lazy",schema:null,*entries(n,r){null!=t||(t=e()),yield*t.entries(n,r)},validator:(n,r)=>(null!=t||(t=e()),t.validator(n,r)),coercer:(n,r)=>(null!=t||(t=e()),t.coercer(n,r)),refiner:(n,r)=>(null!=t||(t=e()),t.refiner(n,r))})},e.literal=function(e){const t=i(e),n=typeof e;return new s({type:"literal",schema:"string"===n||"number"===n||"boolean"===n?e:null,validator:n=>n===e||"Expected the literal `"+t+"`, but received: "+i(n)})},e.map=function(e,t){return new s({type:"map",schema:null,*entries(n){if(e&&t&&n instanceof Map)for(const[r,i]of n.entries())yield[r,r,e],yield[r,i,t]},coercer:e=>e instanceof Map?new Map(e):e,validator:e=>e instanceof Map||"Expected a `Map` object, but received: "+i(e)})},e.mask=d,e.max=function(e,t,n){void 0===n&&(n={});const{exclusive:r}=n;return j(e,"max",(n=>r?n<t:n<=t||"Expected a "+e.type+" less than "+(r?"":"or equal to ")+t+" but received `"+n+"`"))},e.min=function(e,t,n){void 0===n&&(n={});const{exclusive:r}=n;return j(e,"min",(n=>r?n>t:n>=t||"Expected a "+e.type+" greater than "+(r?"":"or equal to ")+t+" but received `"+n+"`"))},e.never=v,e.nonempty=function(e){return j(e,"nonempty",(t=>E(t)>0||"Expected a nonempty "+e.type+" but received an empty one"))},e.nullable=function(e){return new s({...e,validator:(t,n)=>null===t||e.validator(t,n),refiner:(t,n)=>null===t||e.refiner(t,n)})},e.number=function(){return y("number",(e=>"number"==typeof e&&!isNaN(e)||"Expected a number, but received: "+i(e)))},e.object=h,e.omit=function(e,t){const{schema:n}=e,r={...n};for(const e of t)delete r[e];switch(e.type){case"type":return g(r);default:return h(r)}},e.optional=m,e.partial=function(e){const t=e instanceof s?{...e.schema}:{...e};for(const e in t)t[e]=m(t[e]);return h(t)},e.pattern=function(e,t){return j(e,"pattern",(n=>t.test(n)||"Expected a "+e.type+" matching `/"+t.source+'/` but received "'+n+'"'))},e.pick=function(e,t){const{schema:n}=e,r={};for(const e of t)r[e]=n[e];return h(r)},e.record=function(e,t){return new s({type:"record",schema:null,*entries(r){if(n(r))for(const n in r){const i=r[n];yield[n,n,e],yield[n,i,t]}},validator:e=>n(e)||"Expected an object, but received: "+i(e)})},e.refine=j,e.regexp=function(){return y("regexp",(e=>e instanceof RegExp))},e.set=function(e){return new s({type:"set",schema:null,*entries(t){if(e&&t instanceof Set)for(const n of t)yield[n,n,e]},coercer:e=>e instanceof Set?new Set(e):e,validator:e=>e instanceof Set||"Expected a `Set` object, but received: "+i(e)})},e.size=function(e,t,n){void 0===n&&(n=t);const r="Expected a "+e.type,i=t===n?"of `"+t+"`":"between `"+t+"` and `"+n+"`";return j(e,"size",(e=>{if("number"==typeof e||e instanceof Date)return t<=e&&e<=n||r+" "+i+" but received `"+e+"`";if(e instanceof Map||e instanceof Set){const{size:o}=e;return t<=o&&o<=n||r+" with a size "+i+" but received one with a size of `"+o+"`"}{const{length:o}=e;return t<=o&&o<=n||r+" with a length "+i+" but received one with a length of `"+o+"`"}}))},e.string=b,e.struct=function(e,t){return console.warn("superstruct@0.11 - The `struct` helper has been renamed to `define`."),y(e,t)},e.trimmed=function(e){return x(e,b(),(e=>e.trim()))},e.tuple=function(e){const t=v();return new s({type:"tuple",schema:null,*entries(n){if(Array.isArray(n)){const r=Math.max(e.length,n.length);for(let i=0;i<r;i++)yield[i,n[i],e[i]||t]}},validator:e=>Array.isArray(e)||"Expected an array, but received: "+i(e)})},e.type=g,e.union=function(e){const t=e.map((e=>e.type)).join(" | ");return new s({type:"union",schema:null,coercer:(t,n)=>(e.find((e=>{const[n]=e.validate(t,{coerce:!0});return!n}))||w()).coercer(t,n),validator(n,r){const o=[];for(const t of e){const[...e]=a(n,t,r),[i]=e;if(!i[0])return[];for(const[t]of e)t&&o.push(t)}return["Expected the value to satisfy a union of `"+t+"`, but received: "+i(n),...o]}})},e.unknown=w,e.validate=p,Object.defineProperty(e,"__esModule",{value:!0})}));