@pnpm/exe 12.8.2 → 12.9.0

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,205 @@
+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

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,40 @@
+{
+  "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"
+}