pnpm 12.9.0 → 12.10.0

package/dist/wasm/node_modules/typanion/lib/internal/format.d.ts

@@ -1,5 +0,0 @@
-import { ValidationState } from '../types';
-export declare function getPrintable(value: unknown): string;
-export declare function getPrintableArray(value: unknown[], conjunction: string): string;
-export declare function computeKey(state: ValidationState | undefined, key: string | number): string;
-export declare function plural(n: number, singular: string, plural: string): string;

package/dist/wasm/node_modules/typanion/lib/internal/regexps.d.ts

@@ -1,5 +0,0 @@
-export declare const colorStringRegExp: RegExp;
-export declare const colorStringAlphaRegExp: RegExp;
-export declare const base64RegExp: RegExp;
-export declare const uuid4RegExp: RegExp;
-export declare const iso8601RegExp: RegExp;

package/dist/wasm/node_modules/typanion/lib/internal/tools.d.ts

@@ -1,5 +0,0 @@
-import { BoundCoercionFn, CoercionFn, ValidationState } from '../types';
-export declare function pushError({ errors, p }: ValidationState | undefined, message: string): boolean;
-export declare function makeSetter(target: any, key: any): (v: any) => void;
-export declare function makeCoercionFn(target: any, key: any): CoercionFn;
-export declare function makeLazyCoercionFn(fn: CoercionFn, orig: any, generator: () => any): BoundCoercionFn;

package/dist/wasm/node_modules/typanion/lib/predicates/cascadingPredicates.d.ts

@@ -1,114 +0,0 @@
-import { AnyStrictValidator } from '../types';
-/**
- * Create a validator that checks that the tested array or string has at least
- * the specified length.
- */
-export declare function hasMinLength<T extends {
-    length: number;
-}>(length: number): import("../types").LooseValidator<T, T>;
-/**
- * Create a validator that checks that the tested array or string has at most
- * the specified length.
- */
-export declare function hasMaxLength<T extends {
-    length: number;
-}>(length: number): import("../types").LooseValidator<T, T>;
-/**
- * Create a validator that checks that the tested array or string has exactly
- * the specified length.
- */
-export declare function hasExactLength<T extends {
-    length: number;
-}>(length: number): import("../types").LooseValidator<T, T>;
-/**
- * Create a validator that checks that the tested array only contains unique
- * elements. The optional `map` parameter lets you define a transform to
- * apply before making the check (the result of this transform will be
- * discarded afterwards).
- */
-export declare function hasUniqueItems<T>({ map, }?: {
-    map?: (value: T) => unknown;
-}): import("../types").LooseValidator<T[], T[]>;
-/**
- * Create a validator that checks that the tested number is strictly less than 0.
- */
-export declare function isNegative(): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested number is equal or greater
- * than 0.
- */
-export declare function isPositive(): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested number is equal or greater
- * than the specified reference.
- */
-export declare function isAtLeast(n: number): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested number is equal or smaller
- * than the specified reference.
- */
-export declare function isAtMost(n: number): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested number is between the
- * specified references (including the upper boundary).
- */
-export declare function isInInclusiveRange(a: number, b: number): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested number is between the
- * specified references (excluding the upper boundary).
- */
-export declare function isInExclusiveRange(a: number, b: number): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested number is an integer.
- *
- * By default Typanion will also check that it's a *safe* integer. For example,
- * 2^53 wouldn't be a safe integer because 2^53+1 would be rounded to 2^53,
- * which could put your applications at risk when used in loops.
- */
-export declare function isInteger({ unsafe, }?: {
-    unsafe?: boolean;
-}): import("../types").LooseValidator<number, number>;
-/**
- * Create a validator that checks that the tested string matches the given
- * regular expression.
- */
-export declare function matchesRegExp(regExp: RegExp): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string only contain lowercase
- * characters.
- */
-export declare function isLowerCase(): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string only contain uppercase
- * characters.
- */
-export declare function isUpperCase(): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string is a valid UUID v4.
- */
-export declare function isUUID4(): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string is a valid ISO8601
- * date.
- */
-export declare function isISO8601(): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string is a valid hexadecimal
- * color. Setting the optional `alpha` parameter to `true` allows an additional
- * transparency channel to be included.
- */
-export declare function isHexColor({ alpha, }: {
-    alpha?: boolean;
-}): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string is valid base64.
- */
-export declare function isBase64(): import("../types").LooseValidator<string, string>;
-/**
- * Create a validator that checks that the tested string is valid JSON. A
- * optional spec can be passed as parameter, in which case the data will be
- * deserialized and validated against the spec (coercion will be disabled
- * for this check, and even if successful the returned value will still be
- * the original string).
- */
-export declare function isJSON(spec?: AnyStrictValidator): import("../types").LooseValidator<string, string>;

package/dist/wasm/node_modules/typanion/lib/predicates/helperPredicates.d.ts

@@ -1,80 +0,0 @@
-import { AnyStrictValidator, InferType, LooseTest, StrictTest, StrictValidator } from '../types';
-/**
- * Create a validator that runs the provided spec before applying a series of
- * followup validation on the refined type. This is useful when you not only
- * wish to validate the data type itself, but also its format.
- *
- * For example, the following would validate that a value is a valid port:
- *   t.cascade(t.isNumber(), t.isInteger(), t.isInInclusiveRange(1, 655356))
- *
- * And the following would validate that a value is base64:
- *   t.cascade(t.isString(), t.isBase64())
- */
-export declare function cascade<T extends AnyStrictValidator>(spec: T, followups: Array<StrictTest<InferType<T>, InferType<T>> | LooseTest<InferType<T>>>): StrictValidator<unknown, InferType<T>>;
-export declare function cascade<T extends AnyStrictValidator>(spec: T, ...followups: Array<StrictTest<InferType<T>, InferType<T>> | LooseTest<InferType<T>>>): StrictValidator<unknown, InferType<T>>;
-/**
- * @deprecated Replace `applyCascade` by `cascade`
- */
-export declare function applyCascade<T extends AnyStrictValidator>(spec: T, followups: Array<StrictTest<InferType<T>, InferType<T>> | LooseTest<InferType<T>>>): StrictValidator<unknown, InferType<T>>;
-export declare function applyCascade<T extends AnyStrictValidator>(spec: T, ...followups: Array<StrictTest<InferType<T>, InferType<T>> | LooseTest<InferType<T>>>): StrictValidator<unknown, InferType<T>>;
-/**
- * Wraps the given spec to also allow `undefined`.
- */
-export declare function isOptional<T extends AnyStrictValidator>(spec: T): StrictValidator<unknown, InferType<T> | undefined>;
-/**
- * Wraps the given spec to also allow `null`.
- */
-export declare function isNullable<T extends AnyStrictValidator>(spec: T): StrictValidator<unknown, InferType<T> | null>;
-export declare type MissingType = 'missing' | 'undefined' | 'nil' | 'falsy';
-/**
- * Create a validator that checks that the tested object contains the specified
- * keys.
-*/
-export declare function hasRequiredKeys(requiredKeys: string[], options?: {
-    missingIf?: MissingType;
-}): import("../types").LooseValidator<Record<string, unknown>, Record<string, unknown>>;
-/**
-* Create a validator that checks that the tested object contains at least one
-* of the specified keys.
-*/
-export declare function hasAtLeastOneKey(requiredKeys: string[], options?: {
-    missingIf?: MissingType;
-}): import("../types").LooseValidator<Record<string, unknown>, Record<string, unknown>>;
-/**
- * Create a validator that checks that the tested object contains none of the
- * specified keys.
-*/
-export declare function hasForbiddenKeys(forbiddenKeys: string[], options?: {
-    missingIf?: MissingType;
-}): import("../types").LooseValidator<{
-    [key: string]: unknown;
-}, {
-    [key: string]: unknown;
-}>;
-/**
- * Create a validator that checks that the tested object contains at most one
- * of the specified keys.
- */
-export declare function hasMutuallyExclusiveKeys(exclusiveKeys: string[], options?: {
-    missingIf?: MissingType;
-}): import("../types").LooseValidator<{
-    [key: string]: unknown;
-}, {
-    [key: string]: unknown;
-}>;
-export declare enum KeyRelationship {
-    Forbids = "Forbids",
-    Requires = "Requires"
-}
-/**
- * Create a validator that checks that, when the specified subject property is
- * set, the relationship is satisfied.
- */
-export declare function hasKeyRelationship(subject: string, relationship: KeyRelationship, others: string[], options?: {
-    ignore?: any[];
-    missingIf?: MissingType;
-}): import("../types").LooseValidator<{
-    [key: string]: unknown;
-}, {
-    [key: string]: unknown;
-}>;

package/dist/wasm/node_modules/typanion/lib/predicates/typePredicates.d.ts

@@ -1,205 +0,0 @@
-import { AnyStrictValidator, InferType, StrictValidator } from '../types';
-/**
- * Create a validator that always returns true and never refines the type.
- */
-export declare function isUnknown(): StrictValidator<unknown, unknown>;
-/**
- * Create a validator that only returns true when the tested value is exactly
- * the same as the expected one.
- *
- * Refines the type to the provided literal, as much as possible. For example,
- * if you provide a literal string as parameter, the resulting type will be
- * whatever this literal string is, not a generic `string` type. The same is
- * true for `null`, `true`, `false`, and literal numbers.
- */
-export declare function isLiteral(expected: null): StrictValidator<unknown, null>;
-export declare function isLiteral(expected: true): StrictValidator<unknown, true>;
-export declare function isLiteral(expected: false): StrictValidator<unknown, false>;
-export declare function isLiteral<T extends number>(expected: T): StrictValidator<unknown, T>;
-export declare function isLiteral<T extends string>(expected: T): StrictValidator<unknown, T>;
-export declare function isLiteral<T>(expected: T): StrictValidator<unknown, T>;
-/**
- * Create a validator that only returns true when the tested value is a string.
- * Refines the type to `string`.
- */
-export declare function isString(): StrictValidator<unknown, string>;
-/**
- * Create a validator that only returns true when the tested value is amongst
- * the expected set of values. Accepts both value arrays (['foo', 'bar']) and
- * dictionaries ({foo: 'foo', bar: 'bar'}), which makes them compatible with
- * regular TypeScript enumerations (as long as they're not declared as `const
- * enum`).
- *
- * Refines the type to the enumeration values as much as possible. For example,
- * if you pass a TypeScript enumeration as expected set of values, the
- * resulting type will be the union of all values in this enumeration.
- */
-export declare function isEnum<T extends boolean | string | number | null>(values: ReadonlyArray<T>): StrictValidator<unknown, T>;
-export declare function isEnum<T>(enumSpec: Record<string, T>): StrictValidator<unknown, T>;
-/**
- * Create a validator that only returns true when the tested value is a
- * boolean. Refines the type to `boolean`.
- *
- * Supports coercion:
- * - 'true' / 'True' / '1' / 1 will turn to `true`
- * - 'false' / 'False' / '0' / 0 will turn to `false`
- */
-export declare function isBoolean(): StrictValidator<unknown, boolean>;
-/**
- * Create a validator that only returns true when the tested value is a
- * number (including floating numbers; use `cascade` and `isInteger` to
- * restrict the range further). Refines the type to `number`.
- *
- * Supports coercion.
- */
-export declare function isNumber(): StrictValidator<unknown, number>;
-/**
- * Important: This validator only makes sense when used in conjunction with
- * coercion! It will always error when used without.
- *
- * Create a validator that only returns true when the tested value is a
- * JSON representation of the expected type. Refines the type to the
- * expected type, and casts the value into its inner value.
- */
-export declare function isPayload<T extends AnyStrictValidator>(spec: T): StrictValidator<unknown, InferType<T>>;
-/**
- * Create a validator that only returns true when the tested value is a
- * valid date. Refines the type to `Date`.
- *
- * Supports coercion via one of the following formats:
- * - ISO86001 strings
- * - Unix timestamps
- */
-export declare function isDate(): StrictValidator<unknown, Date>;
-/**
- * Create a validator that only returns true when the tested value is an
- * array whose all values match the provided subspec. Refines the type to
- * `Array<T>`, with `T` being the subspec inferred type.
- *
- * Supports coercion if the `delimiter` option is set, in which case strings
- * will be split accordingly.
- */
-export declare function isArray<T extends AnyStrictValidator>(spec: T, { delimiter }?: {
-    delimiter?: string | RegExp;
-}): StrictValidator<unknown, InferType<T>[]>;
-/**
- * Create a validator that only returns true when the tested value is an
- * set whose all values match the provided subspec. Refines the type to
- * `Set<T>`, with `T` being the subspec inferred type.
- *
- * Supports coercion from arrays (or anything that can be coerced into an
- * array).
- */
-export declare function isSet<T extends AnyStrictValidator>(spec: T, { delimiter }?: {
-    delimiter?: string | RegExp;
-}): StrictValidator<unknown, Set<InferType<T>>>;
-/**
- * Create a validator that only returns true when the tested value is an
- * map whose all values match the provided subspecs. Refines the type to
- * `Map<U, V>`, with `U` being the key subspec inferred type and `V` being
- * the value subspec inferred type.
- *
- * Supports coercion from array of tuples (or anything that can be coerced into
- * an array of tuples).
- */
-export declare function isMap<TKey extends AnyStrictValidator, TValue extends AnyStrictValidator>(keySpec: TKey, valueSpec: TValue): StrictValidator<unknown, Map<InferType<TKey>, InferType<TValue>>>;
-declare type AnyStrictValidatorTuple = AnyStrictValidator[] | [];
-declare type InferTypeFromTuple<T extends AnyStrictValidatorTuple> = {
-    [K in keyof T]: InferType<T[K]>;
-};
-/**
- * Create a validator that only returns true when the tested value is a
- * tuple whose each value matches the corresponding subspec. Refines the type
- * into a tuple whose each item has the type inferred by the corresponding
- * tuple.
- *
- * Supports coercion if the `delimiter` option is set, in which case strings
- * will be split accordingly.
- */
-export declare function isTuple<T extends AnyStrictValidatorTuple>(spec: T, { delimiter }?: {
-    delimiter?: string | RegExp;
-}): StrictValidator<unknown, InferTypeFromTuple<T>>;
-/**
- * Create a validator that only returns true when the tested value is an
- * object with any amount of properties that must all match the provided
- * subspec. Refines the type to `Record<string, T>`, with `T` being the
- * subspec inferred type.
- *
- * Keys can be optionally validated as well by using the `keys` optional
- * subspec parameter.
- */
-export declare function isRecord<T extends AnyStrictValidator>(spec: T, { keys: keySpec, }?: {
-    keys?: StrictValidator<unknown, string> | null;
-}): StrictValidator<unknown, Record<string, InferType<T>>>;
-/**
- * @deprecated Replace `isDict` by `isRecord`
- */
-export declare function isDict<T extends AnyStrictValidator>(spec: T, opts?: {
-    keys?: StrictValidator<unknown, string> | null;
-}): StrictValidator<unknown, Record<string, InferType<T>>>;
-declare type ExtractIndex<T> = {
-    [K in keyof T as {} extends Record<K, 1> ? K : never]: T[K];
-};
-declare type RemoveIndex<T> = {
-    [K in keyof T as {} extends Record<K, 1> ? never : K]: T[K];
-};
-declare type UndefinedProperties<T> = {
-    [P in keyof T]-?: undefined extends T[P] ? P : never;
-}[keyof T];
-declare type UndefinedToOptional<T> = Partial<Pick<T, UndefinedProperties<T>>> & Pick<T, Exclude<keyof T, UndefinedProperties<T>>>;
-declare type ObjectType<T> = UndefinedToOptional<RemoveIndex<T>> & ExtractIndex<T>;
-/**
- * Create a validator that only returns true when the tested value is an
- * object whose all properties match their corresponding subspec. Refines
- * the type into an object whose each property has the type inferred by the
- * corresponding subspec.
- *
- * Unlike `t.isPartial`, `t.isObject` doesn't allow extraneous properties by
- * default. This behaviour can be altered by using the `extra` optional
- * subspec parameter, which will be called to validate an object only
- * containing the extraneous properties.
- *
- * Calling `t.isObject(..., {extra: t.isRecord(t.isUnknown())})` is
- * essentially the same as calling `t.isPartial(...)`.
- */
-export declare function isObject<T extends {
-    [P in keyof T]: AnyStrictValidator;
-}, UnknownValidator extends AnyStrictValidator = StrictValidator<unknown, unknown>>(props: T, { extra: extraSpec, }?: {
-    extra?: UnknownValidator | null;
-}): import("../types").StrictTest<unknown, ObjectType<{ [P in keyof T]: InferType<T[P]>; } & InferType<UnknownValidator>>> & import("../types").Trait<ObjectType<{ [P in keyof T]: InferType<T[P]>; } & InferType<UnknownValidator>>> & {
-    properties: T;
-};
-/**
- * Create a validator that only returns true when the tested value is an
- * object whose all properties match their corresponding subspec. Refines
- * the type into an object whose each property has the type inferred by the
- * corresponding subspec.
- *
- * Unlike `t.isObject`, `t.isPartial` allows extraneous properties. The
- * resulting type will reflect this behaviour by including an index
- * signature (each extraneous property being typed `unknown`).
- *
- * Calling `t.isPartial(...)` is essentially the same as calling
- * `t.isObject(..., {extra: t.isRecord(t.isUnknown())})`.
- */
-export declare function isPartial<T extends {
-    [P in keyof T]: AnyStrictValidator;
-}>(props: T): import("../types").StrictTest<unknown, ObjectType<{ [P in keyof T]: InferType<T[P]>; } & Record<string, unknown>>> & import("../types").Trait<ObjectType<{ [P in keyof T]: InferType<T[P]>; } & Record<string, unknown>>> & {
-    properties: T;
-};
-/**
- * Create a validator that only returns true when the tested value is an
- * object whose prototype is derived from the given class. Refines the type
- * into a class instance.
- */
-export declare const isInstanceOf: <T extends new (...args: any) => InstanceType<T>>(constructor: T) => StrictValidator<unknown, InstanceType<T>>;
-/**
- * Create a validator that only returns true when the tested value is an
- * object matching any of the provided subspecs. If the optional `exclusive`
- * parameter is set to `true`, the behaviour changes so that the validator
- * only returns true when exactly one subspec matches.
- */
-export declare const isOneOf: <T extends AnyStrictValidator>(specs: readonly T[], { exclusive, }?: {
-    exclusive?: boolean | undefined;
-}) => StrictValidator<unknown, InferType<T>>;
-export {};

package/dist/wasm/node_modules/typanion/lib/tools.d.ts

@@ -1,90 +0,0 @@
-import { AnyStrictValidator, InferType, LooseTest, LooseValidator, StrictTest, StrictValidator, Trait } from './types';
-export declare function makeTrait<U>(value: U): <V>() => U & Trait<V>;
-export declare function makeValidator<U, V extends U>({ test }: {
-    test: StrictTest<U, V>;
-}): StrictValidator<U, V>;
-export declare function makeValidator<U, V extends U = U>({ test }: {
-    test: LooseTest<U>;
-}): LooseValidator<U, V>;
-export declare class TypeAssertionError extends Error {
-    constructor({ errors }?: {
-        errors?: string[];
-    });
-}
-/**
- * Check that the specified value matches the given validator, and throws an
- * exception if it doesn't. Refine the type if it passes.
- */
-export declare function assert<T extends AnyStrictValidator>(val: unknown, validator: T): asserts val is InferType<T>;
-/**
- * Check that the specified value matches the given validator, and throws an
- * exception if it doesn't. Refine the type if it passes.
- *
- * Thrown exceptions include details about what exactly looks invalid in the
- * tested value.
- */
-export declare function assertWithErrors<T extends AnyStrictValidator>(val: unknown, validator: T): asserts val is InferType<T>;
-/**
- * Compile-time only. Refine the type as if the validator was matching the
- * tested value, but doesn't actually run it. Similar to the classic `as`
- * operator in TypeScript.
- */
-export declare function softAssert<T extends AnyStrictValidator>(val: unknown, validator: T): asserts val is InferType<T>;
-/**
- * Check that the value matches the given validator. Returns a tuple where the
- * first element is the validated value, and the second the reported errors.
- *
- * If the `errors` field is set to `false` (the default), the error reporting
- * will be a single boolean. If set to `true`, it'll be an array of strings.
- */
-export declare function as<T extends AnyStrictValidator>(value: unknown, validator: T, opts: {
-    coerce?: boolean;
-    errors?: boolean;
-    throw: true;
-}): InferType<T>;
-export declare function as<T extends AnyStrictValidator>(value: unknown, validator: T, opts: {
-    coerce?: boolean;
-    errors: false;
-    throw?: false;
-}): {
-    value: InferType<T>;
-    errors: undefined;
-} | {
-    value: unknown;
-    errors: true;
-};
-export declare function as<T extends AnyStrictValidator>(value: unknown, validator: T, opts: {
-    coerce?: boolean;
-    errors: true;
-    throw?: false;
-}): {
-    value: InferType<T>;
-    errors: undefined;
-} | {
-    value: unknown;
-    errors: Array<string>;
-};
-export declare function as<T extends AnyStrictValidator>(value: unknown, validator: T, opts?: {
-    coerce?: boolean;
-    errors?: boolean;
-    throw?: false;
-}): {
-    value: InferType<T>;
-    errors: undefined;
-} | {
-    value: unknown;
-    errors: Array<string> | true;
-};
-declare type FnValidatedArgument<T extends [] | [AnyStrictValidator, ...AnyStrictValidator[]]> = T extends [AnyStrictValidator, ...AnyStrictValidator[]] ? {
-    [K in keyof T]: InferType<T[K]>;
-} : [];
-interface FnValidatedFunction<T extends [] | [AnyStrictValidator, ...AnyStrictValidator[]], Ret> {
-    (...args: FnValidatedArgument<T>): Ret;
-}
-/**
- * Create and return a new function that apply the given validators to each
- * corresponding argument passed to the function and throws an exception in
- * case of a mismatch.
- */
-export declare function fn<T extends [] | [AnyStrictValidator, ...AnyStrictValidator[]], Ret>(validators: T, fn: (...args: FnValidatedArgument<T>) => Ret): FnValidatedFunction<T, Ret>;
-export {};

package/dist/wasm/node_modules/typanion/lib/types.d.ts

@@ -1,22 +0,0 @@
-export declare type BoundCoercionFn = () => BoundCoercionFn;
-export declare type CoercionFn = (v: any) => BoundCoercionFn;
-export declare type Coercion = [string, BoundCoercionFn];
-/**
- * Given a Typanion validator, return the type the validator guarantees if it
- * matches.
- */
-export declare type InferType<U> = U extends Trait<infer V> ? V : never;
-export declare type Trait<Type> = {
-    __trait: Type;
-};
-export declare type LooseTest<U> = (value: U, test?: ValidationState) => boolean;
-export declare type StrictTest<U, V extends U> = (value: U, test?: ValidationState) => value is V;
-export declare type LooseValidator<U, V> = LooseTest<U> & Trait<V>;
-export declare type StrictValidator<U, V extends U> = StrictTest<U, V> & Trait<V>;
-export declare type AnyStrictValidator = StrictValidator<any, any>;
-export declare type ValidationState = {
-    p?: string;
-    errors?: string[];
-    coercions?: Coercion[];
-    coercion?: CoercionFn;
-};

package/dist/wasm/node_modules/typanion/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "typanion",
-  "description": "Simple runtime TypeScript validator library",
-  "homepage": "https://mael.dev/typanion/",
-  "version": "3.14.0",
-  "main": "lib/index",
-  "license": "MIT",
-  "sideEffects": false,
-  "repository": {
-    "url": "https://github.com/arcanis/typanion",
-    "type": "git"
-  },
-  "workspaces": [
-    "website"
-  ],
-  "devDependencies": {
-    "@rollup/plugin-typescript": "^8.2.1",
-    "@types/chai": "^4.2.11",
-    "@types/mocha": "^7.0.2",
-    "@types/node": "^17.0.21",
-    "chai": "^4.3.4",
-    "mocha": "^8.0.1",
-    "rollup": "^2.17.0",
-    "ts-node": "^8.10.2",
-    "tslib": "^2.0.0",
-    "typescript": "^4.6.3"
-  },
-  "scripts": {
-    "prepack": "rm -rf lib && rollup -c",
-    "postpack": "rm -rf lib",
-    "test": "yarn tsc && TS_NODE_TRANSPILE_ONLY=true mocha --require ts-node/register --extension ts tests/**/*.test.ts"
-  },
-  "publishConfig": {
-    "main": "lib/index"
-  },
-  "files": [
-    "lib"
-  ],
-  "packageManager": "yarn@4.0.0-rc.2"
-}