@nice2dev/ui-graphics 1.3.15 → 1.3.16

package/dist/esm/node_modules/lib0/schema.js

@@ -1,165 +1,92 @@
-import { isObject, every as every$1, hasProperty } from './object.js';
-import { isArray, every, some } from './array.js';
-import { methodUnimplemented, create, unexpectedCase } from './error.js';
-import { production } from './environment.js';
-import { EqualityTraitSymbol, equals } from './trait/equality.js';
-import { equalityDeep } from './function.js';
-import { repeat } from './string.js';
-import { int53, word, bool, oneOf, int32 } from './prng.js';
-import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from './number.js';
-
-/**
- * @experimental WIP
- *
- * Simple & efficient schemas for your data.
- */
-
-
-/**
- * @typedef {string|number|bigint|boolean|null|undefined|symbol} Primitive
- */
-
-/**
- * @typedef {{ [k:string|number|symbol]: any }} AnyObject
- */
-
-/**
- * @template T
- * @typedef {T extends Schema<infer X> ? X : T} Unwrap
- */
-
-/**
- * @template T
- * @typedef {T extends Schema<infer X> ? X : T} TypeOf
- */
-
-/**
- * @template {readonly unknown[]} T
- * @typedef {T extends readonly [Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [] } UnwrapArray
- */
-
-/**
- * @template T
- * @typedef {T extends Schema<infer S> ? Schema<S> : never} CastToSchema
- */
-
-/**
- * @template {unknown[]} Arr
- * @typedef {Arr extends [...unknown[], infer L] ? L : never} TupleLast
- */
-
-/**
- * @template {unknown[]} Arr
- * @typedef {Arr extends [...infer Fs, unknown] ? Fs : never} TuplePop
- */
-
-/**
- * @template {readonly unknown[]} T
- * @typedef {T extends []
- *   ? {}
- *   : T extends [infer First]
- *   ? First
- *   : T extends [infer First, ...infer Rest]
- *   ? First & Intersect<Rest>
- *   : never
- * } Intersect
- */
-
-const schemaSymbol = Symbol('0schema');
-
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isObject, every as every$1, hasProperty } from "./object.js";
+import { isArray, every, some } from "./array.js";
+import { methodUnimplemented, create, unexpectedCase } from "./error.js";
+import { production } from "./environment.js";
+import { EqualityTraitSymbol, equals } from "./trait/equality.js";
+import { equalityDeep } from "./function.js";
+import { repeat } from "./string.js";
+import { int53, word, bool, oneOf, int32 } from "./prng.js";
+import { MAX_SAFE_INTEGER, MIN_SAFE_INTEGER } from "./number.js";
+const schemaSymbol = Symbol("0schema");
 class ValidationError {
-  constructor () {
-    /**
-     * Reverse errors
-     * @type {Array<{ path: string?, expected: string, has: string, message: string? }>}
-     */
+  constructor() {
     this._rerrs = [];
   }
-
   /**
    * @param {string?} path
    * @param {string} expected
    * @param {string} has
    * @param {string?} message
    */
-  extend (path, expected, has, message = null) {
+  extend(path, expected, has, message = null) {
     this._rerrs.push({ path, expected, has, message });
   }
-
-  toString () {
+  toString() {
     const s = [];
     for (let i = this._rerrs.length - 1; i > 0; i--) {
       const r = this._rerrs[i];
-      /* c8 ignore next */
-      s.push(repeat(' ', (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ''}${r.has} doesn't match ${r.expected}. ${r.message}`);
+      s.push(repeat(" ", (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ""}${r.has} doesn't match ${r.expected}. ${r.message}`);
     }
-    return s.join('\n')
+    return s.join("\n");
   }
 }
-
-/**
- * @param {any} a
- * @param {any} b
- * @return {boolean}
- */
 const shapeExtends = (a, b) => {
-  if (a === b) return true
-  if (a == null || b == null || a.constructor !== b.constructor) return false
-  if (a[EqualityTraitSymbol]) return equals(a, b) // last resort: check equality (do this before array and obj check which don't implement the equality trait)
+  if (a === b) return true;
+  if (a == null || b == null || a.constructor !== b.constructor) return false;
+  if (a[EqualityTraitSymbol]) return equals(a, b);
   if (isArray(a)) {
-    return every(a, aitem =>
-      some(b, bitem => shapeExtends(aitem, bitem))
-    )
+    return every(
+      a,
+      (aitem) => some(b, (bitem) => shapeExtends(aitem, bitem))
+    );
   } else if (isObject(a)) {
-    return every$1(a, (aitem, akey) =>
-      shapeExtends(aitem, b[akey])
-    )
+    return every$1(
+      a,
+      (aitem, akey) => shapeExtends(aitem, b[akey])
+    );
   }
-  /* c8 ignore next */
-  return false
+  return false;
 };
-
-/**
- * @template T
- * @implements {equalityTraits.EqualityTrait}
- */
 class Schema {
-  // this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
-  /**
-   * If true, the more things are added to the shape the more objects this schema will accept (e.g.
-   * union). By default, the more objects are added, the the fewer objects this schema will accept.
-   * @protected
-   */
-  static _dilutes = false
-
   /**
    * @param {Schema<any>} other
    */
-  extends (other) {
-    let [a, b] = [/** @type {any} */(this).shape, /** @type {any} */ (other).shape];
-    if (/** @type {typeof Schema<any>} */ (this.constructor)._dilutes) [b, a] = [a, b];
-    return shapeExtends(a, b)
+  extends(other) {
+    let [a, b] = [
+      /** @type {any} */
+      this.shape,
+      /** @type {any} */
+      other.shape
+    ];
+    if (
+      /** @type {typeof Schema<any>} */
+      this.constructor._dilutes
+    ) [b, a] = [a, b];
+    return shapeExtends(a, b);
   }
-
   /**
    * Overwrite this when necessary. By default, we only check the `shape` property which every shape
    * should have.
    * @param {Schema<any>} other
    */
-  equals (other) {
-    // @ts-ignore
-    return this.constructor === other.constructor && equalityDeep(this.shape, other.shape)
+  equals(other) {
+    return this.constructor === other.constructor && equalityDeep(this.shape, other.shape);
+  }
+  [schemaSymbol]() {
+    return true;
   }
-
-  [schemaSymbol] () { return true }
-
   /**
    * @param {object} other
    */
-  [EqualityTraitSymbol] (other) {
-    return this.equals(/** @type {any} */ (other))
+  [EqualityTraitSymbol](other) {
+    return this.equals(
+      /** @type {any} */
+      other
+    );
   }
-
   /**
    * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
    * Schema. Validate will check the structure of the parameter and return true iff the instance
@@ -168,10 +95,9 @@ class Schema {
    * @param {T} o
    * @return {boolean}
    */
-  validate (o) {
-    return this.check(o)
+  validate(o) {
+    return this.check(o);
   }
-
   /* c8 ignore start */
   /**
    * Similar to validate, but this method accepts untyped parameters.
@@ -180,26 +106,25 @@ class Schema {
    * @param {ValidationError} [_err]
    * @return {_o is T}
    */
-  check (_o, _err) {
+  check(_o, _err) {
     methodUnimplemented();
   }
   /* c8 ignore stop */
-
   /**
    * @type {Schema<T?>}
    */
-  get nullable () {
-    // @ts-ignore
-    return $union(this, $null)
+  get nullable() {
+    return $union(this, $null);
   }
-
   /**
    * @type {$Optional<Schema<T>>}
    */
-  get optional () {
-    return new $Optional(/** @type {Schema<T>} */ (this))
+  get optional() {
+    return new $Optional(
+      /** @type {Schema<T>} */
+      this
+    );
   }
-
   /**
    * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
    * Use this if you know that the type is of a specific type and you just want to convince the type
@@ -212,11 +137,13 @@ class Schema {
    * @param {OO} o
    * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
    */
-  cast (o) {
+  cast(o) {
     assert(o, this);
-    return /** @type {any} */ (o)
+    return (
+      /** @type {any} */
+      o
+    );
   }
-
   /**
    * EXPECTO PATRONUM!! 🪄
    * This function protects against type errors. Though it may not work in the real world.
@@ -236,758 +163,480 @@ class Schema {
    * @param {T} o
    * @return {o extends T ? T : never}
    */
-  expect (o) {
+  expect(o) {
     assert(o, this);
-    return o
+    return o;
   }
 }
-
+// this.shape must not be defined on Schema. Otherwise typecheck on metatypes (e.g. $$object) won't work as expected anymore
 /**
- * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} Constr
- * @typedef {Constr extends ((...args:any[]) => infer T) ? T : (Constr extends (new (...args:any[]) => any) ? InstanceType<Constr> : never)} Instance
- */
-
-/**
- * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
- * @extends {Schema<Instance<C>>}
+ * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+ * union). By default, the more objects are added, the the fewer objects this schema will accept.
+ * @protected
  */
+__publicField(Schema, "_dilutes", false);
 class $ConstructedBy extends Schema {
   /**
    * @param {C} c
    * @param {((o:Instance<C>)=>boolean)|null} check
    */
-  constructor (c, check) {
+  constructor(c, check) {
     super();
     this.shape = c;
     this._c = check;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
    */
-  check (o, err = undefined) {
+  check(o, err = void 0) {
     const c = o?.constructor === this.shape && (this._c == null || this._c(o));
-    /* c8 ignore next */
-    !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? 'Constructor match failed' : 'Check failed');
-    return c
+    !c && err?.extend(null, this.shape.name, o?.constructor.name, o?.constructor !== this.shape ? "Constructor match failed" : "Check failed");
+    return c;
   }
 }
-
-/**
- * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
- * @param {C} c
- * @param {((o:Instance<C>) => boolean)|null} check
- * @return {CastToSchema<$ConstructedBy<C>>}
- */
 const $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
 $constructedBy($ConstructedBy);
-
-/**
- * Check custom properties on any object. You may want to overwrite the generated Schema<any>.
- *
- * @extends {Schema<any>}
- */
 class $Custom extends Schema {
   /**
    * @param {(o:any) => boolean} check
    */
-  constructor (check) {
+  constructor(check) {
     super();
-    /**
-     * @type {(o:any) => boolean}
-     */
     this.shape = check;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} err
    * @return {o is any}
    */
-  check (o, err) {
+  check(o, err) {
     const c = this.shape(o);
-    /* c8 ignore next */
-    !c && err?.extend(null, 'custom prop', o?.constructor.name, 'failed to check custom prop');
-    return c
+    !c && err?.extend(null, "custom prop", o?.constructor.name, "failed to check custom prop");
+    return c;
   }
 }
-
-/**
- * @param {(o:any) => boolean} check
- * @return {Schema<any>}
- */
 const $custom = (check) => new $Custom(check);
 $constructedBy($Custom);
-
-/**
- * @template {Primitive} T
- * @extends {Schema<T>}
- */
 class $Literal extends Schema {
   /**
    * @param {Array<T>} literals
    */
-  constructor (literals) {
+  constructor(literals) {
     super();
     this.shape = literals;
   }
-
   /**
    *
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is T}
    */
-  check (o, err) {
-    const c = this.shape.some(a => a === o);
-    /* c8 ignore next */
-    !c && err?.extend(null, this.shape.join(' | '), o.toString());
-    return c
+  check(o, err) {
+    const c = this.shape.some((a) => a === o);
+    !c && err?.extend(null, this.shape.join(" | "), o.toString());
+    return c;
   }
 }
-
-/**
- * @template {Primitive[]} T
- * @param {T} literals
- * @return {CastToSchema<$Literal<T[number]>>}
- */
 const $literal = (...literals) => new $Literal(literals);
 const $$literal = $constructedBy($Literal);
-
-/**
- * @template {Array<string|Schema<string|number>>} Ts
- * @typedef {Ts extends [] ? `` : (Ts extends [infer T] ? (Unwrap<T> extends (string|number) ? Unwrap<T> : never) : (Ts extends [infer T1, ...infer Rest] ? `${Unwrap<T1> extends (string|number) ? Unwrap<T1> : never}${Rest extends Array<string|Schema<string|number>> ? CastStringTemplateArgsToTemplate<Rest> : never}` : never))} CastStringTemplateArgsToTemplate
- */
-
-/**
- * @param {string} str
- * @return {string}
- */
-const _regexEscape = /** @type {any} */ (RegExp).escape || /** @type {(str:string) => string} */ (str =>
-  str.replace(/[().|&,$^[\]]/g, s => '\\' + s)
+const _regexEscape = (
+  /** @type {any} */
+  RegExp.escape || /** @type {(str:string) => string} */
+  ((str) => str.replace(/[().|&,$^[\]]/g, (s) => "\\" + s))
 );
-
-/**
- * @param {string|Schema<any>} s
- * @return {string[]}
- */
-const _schemaStringTemplateToRegex = s => {
+const _schemaStringTemplateToRegex = (s) => {
   if ($string.check(s)) {
-    return [_regexEscape(s)]
+    return [_regexEscape(s)];
   }
   if ($$literal.check(s)) {
-    return /** @type {Array<string|number>} */ (s.shape).map(v => v + '')
+    return (
+      /** @type {Array<string|number>} */
+      s.shape.map((v) => v + "")
+    );
   }
   if ($$number.check(s)) {
-    return ['[+-]?\\d+.?\\d*']
+    return ["[+-]?\\d+.?\\d*"];
   }
   if ($$string.check(s)) {
-    return ['.*']
+    return [".*"];
   }
   if ($$union.check(s)) {
-    return s.shape.map(_schemaStringTemplateToRegex).flat(1)
+    return s.shape.map(_schemaStringTemplateToRegex).flat(1);
   }
-  /* c8 ignore next 2 */
-  // unexpected schema structure (only supports unions and string in literal types)
   unexpectedCase();
 };
-
-/**
- * @template {Array<string|Schema<string|number>>} T
- * @extends {Schema<CastStringTemplateArgsToTemplate<T>>}
- */
 class $StringTemplate extends Schema {
   /**
    * @param {T} shape
    */
-  constructor (shape) {
+  constructor(shape) {
     super();
     this.shape = shape;
-    this._r = new RegExp('^' + shape.map(_schemaStringTemplateToRegex).map(opts => `(${opts.join('|')})`).join('') + '$');
+    this._r = new RegExp("^" + shape.map(_schemaStringTemplateToRegex).map((opts) => `(${opts.join("|")})`).join("") + "$");
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is CastStringTemplateArgsToTemplate<T>}
    */
-  check (o, err) {
+  check(o, err) {
     const c = this._r.exec(o) != null;
-    /* c8 ignore next */
-    !c && err?.extend(null, this._r.toString(), o.toString(), 'String doesn\'t match string template.');
-    return c
+    !c && err?.extend(null, this._r.toString(), o.toString(), "String doesn't match string template.");
+    return c;
   }
 }
 $constructedBy($StringTemplate);
-
-const isOptionalSymbol = Symbol('optional');
-/**
- * @template {Schema<any>} S
- * @extends Schema<Unwrap<S>|undefined>
- */
+const isOptionalSymbol = Symbol("optional");
 class $Optional extends Schema {
   /**
    * @param {S} shape
    */
-  constructor (shape) {
+  constructor(shape) {
     super();
     this.shape = shape;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is (Unwrap<S>|undefined)}
    */
-  check (o, err) {
-    const c = o === undefined || this.shape.check(o);
-    /* c8 ignore next */
-    !c && err?.extend(null, 'undefined (optional)', '()');
-    return c
+  check(o, err) {
+    const c = o === void 0 || this.shape.check(o);
+    !c && err?.extend(null, "undefined (optional)", "()");
+    return c;
+  }
+  get [isOptionalSymbol]() {
+    return true;
   }
-
-  get [isOptionalSymbol] () { return true }
 }
 const $$optional = $constructedBy($Optional);
-
-/**
- * @extends Schema<never>
- */
 class $Never extends Schema {
   /**
    * @param {any} _o
    * @param {ValidationError} [err]
    * @return {_o is never}
    */
-  check (_o, err) {
-    /* c8 ignore next */
-    err?.extend(null, 'never', typeof _o);
-    return false
+  check(_o, err) {
+    err?.extend(null, "never", typeof _o);
+    return false;
   }
 }
 $constructedBy($Never);
-
-/**
- * @template {{ [key: string|symbol|number]: Schema<any> }} S
- * @typedef {{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }} $ObjectToType
- */
-
-/**
- * @template {{[key:string|symbol|number]: Schema<any>}} S
- * @extends {Schema<$ObjectToType<S>>}
- */
-class $Object extends Schema {
+const _$Object = class _$Object extends Schema {
   /**
    * @param {S} shape
    * @param {boolean} partial
    */
-  constructor (shape, partial = false) {
+  constructor(shape, partial = false) {
     super();
-    /**
-     * @type {S}
-     */
     this.shape = shape;
     this._isPartial = partial;
   }
-
-  static _dilutes = true
-
   /**
    * @type {Schema<Partial<$ObjectToType<S>>>}
    */
-  get partial () {
-    return new $Object(this.shape, true)
+  get partial() {
+    return new _$Object(this.shape, true);
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} err
    * @return {o is $ObjectToType<S>}
    */
-  check (o, err) {
+  check(o, err) {
     if (o == null) {
-      /* c8 ignore next */
-      err?.extend(null, 'object', 'null');
-      return false
+      err?.extend(null, "object", "null");
+      return false;
     }
     return every$1(this.shape, (vv, vk) => {
-      const c = (this._isPartial && !hasProperty(o, vk)) || vv.check(o[vk], err);
-      !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], 'Object property does not match');
-      return c
-    })
+      const c = this._isPartial && !hasProperty(o, vk) || vv.check(o[vk], err);
+      !c && err?.extend(vk.toString(), vv.toString(), typeof o[vk], "Object property does not match");
+      return c;
+    });
   }
-}
-
-/**
- * @template S
- * @typedef {Schema<{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }>} _ObjectDefToSchema
- */
-
-// I used an explicit type annotation instead of $ObjectToType, so that the user doesn't see the
-// weird type definitions when inspecting type definions.
-/**
- * @template {{ [key:string|symbol|number]: Schema<any> }} S
- * @param {S} def
- * @return {_ObjectDefToSchema<S> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never}
- */
-const $object = def => /** @type {any} */ (new $Object(def));
+};
+__publicField(_$Object, "_dilutes", true);
+let $Object = _$Object;
+const $object = (def) => (
+  /** @type {any} */
+  new $Object(def)
+);
 const $$object = $constructedBy($Object);
-/**
- * @type {Schema<{[key:string]: any}>}
- */
-const $objectAny = $custom(o => o != null && (o.constructor === Object || o.constructor == null));
-
-/**
- * @template {Schema<string|number|symbol>} Keys
- * @template {Schema<any>} Values
- * @extends {Schema<{ [key in Unwrap<Keys>]: Unwrap<Values> }>}
- */
+const $objectAny = $custom((o) => o != null && (o.constructor === Object || o.constructor == null));
 class $Record extends Schema {
   /**
    * @param {Keys} keys
    * @param {Values} values
    */
-  constructor (keys, values) {
+  constructor(keys, values) {
     super();
     this.shape = {
-      keys, values
+      keys,
+      values
     };
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} err
    * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
    */
-  check (o, err) {
+  check(o, err) {
     return o != null && every$1(o, (vv, vk) => {
       const ck = this.shape.keys.check(vk, err);
-      /* c8 ignore next */
-      !ck && err?.extend(vk + '', 'Record', typeof o, ck ? 'Key doesn\'t match schema' : 'Value doesn\'t match value');
-      return ck && this.shape.values.check(vv, err)
-    })
+      !ck && err?.extend(vk + "", "Record", typeof o, ck ? "Key doesn't match schema" : "Value doesn't match value");
+      return ck && this.shape.values.check(vv, err);
+    });
   }
 }
-
-/**
- * @template {Schema<string|number|symbol>} Keys
- * @template {Schema<any>} Values
- * @param {Keys} keys
- * @param {Values} values
- * @return {CastToSchema<$Record<Keys,Values>>}
- */
 const $record = (keys, values) => new $Record(keys, values);
 const $$record = $constructedBy($Record);
-
-/**
- * @template {Schema<any>[]} S
- * @extends {Schema<{ [Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never }>}
- */
 class $Tuple extends Schema {
   /**
    * @param {S} shape
    */
-  constructor (shape) {
+  constructor(shape) {
     super();
     this.shape = shape;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} err
    * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
    */
-  check (o, err) {
+  check(o, err) {
     return o != null && every$1(this.shape, (vv, vk) => {
-      const c = /** @type {Schema<any>} */ (vv).check(o[vk], err);
-      /* c8 ignore next */
-      !c && err?.extend(vk.toString(), 'Tuple', typeof vv);
-      return c
-    })
+      const c = (
+        /** @type {Schema<any>} */
+        vv.check(o[vk], err)
+      );
+      !c && err?.extend(vk.toString(), "Tuple", typeof vv);
+      return c;
+    });
   }
 }
-
-/**
- * @template {Array<Schema<any>>} T
- * @param {T} def
- * @return {CastToSchema<$Tuple<T>>}
- */
 const $tuple = (...def) => new $Tuple(def);
 $constructedBy($Tuple);
-
-/**
- * @template {Schema<any>} S
- * @extends {Schema<Array<S extends Schema<infer T> ? T : never>>}
- */
 class $Array extends Schema {
   /**
    * @param {Array<S>} v
    */
-  constructor (v) {
+  constructor(v) {
     super();
-    /**
-     * @type {Schema<S extends Schema<infer T> ? T : never>}
-     */
     this.shape = v.length === 1 ? v[0] : new $Union(v);
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is Array<S extends Schema<infer T> ? T : never>} o
    */
-  check (o, err) {
-    const c = isArray(o) && every(o, oi => this.shape.check(oi));
-    /* c8 ignore next */
-    !c && err?.extend(null, 'Array', '');
-    return c
+  check(o, err) {
+    const c = isArray(o) && every(o, (oi) => this.shape.check(oi));
+    !c && err?.extend(null, "Array", "");
+    return c;
   }
 }
-
-/**
- * @template {Array<Schema<any>>} T
- * @param {T} def
- * @return {Schema<Array<T extends Array<Schema<infer S>> ? S : never>>}
- */
 const $array = (...def) => new $Array(def);
 const $$array = $constructedBy($Array);
-/**
- * @type {Schema<Array<any>>}
- */
-const $arrayAny = $custom(o => isArray(o));
-
-/**
- * @template T
- * @extends {Schema<T>}
- */
+const $arrayAny = $custom((o) => isArray(o));
 class $InstanceOf extends Schema {
   /**
    * @param {new (...args:any) => T} constructor
    * @param {((o:T) => boolean)|null} check
    */
-  constructor (constructor, check) {
+  constructor(constructor, check) {
     super();
     this.shape = constructor;
     this._c = check;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} err
    * @return {o is T}
    */
-  check (o, err) {
+  check(o, err) {
     const c = o instanceof this.shape && (this._c == null || this._c(o));
-    /* c8 ignore next */
     !c && err?.extend(null, this.shape.name, o?.constructor.name);
-    return c
+    return c;
   }
 }
-
-/**
- * @template T
- * @param {new (...args:any) => T} c
- * @param {((o:T) => boolean)|null} check
- * @return {Schema<T>}
- */
 const $instanceOf = (c, check = null) => new $InstanceOf(c, check);
 $constructedBy($InstanceOf);
-
 const $$schema = $instanceOf(Schema);
-
-/**
- * @template {Schema<any>[]} Args
- * @typedef {(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>} _LArgsToLambdaDef
- */
-
-/**
- * @template {Array<Schema<any>>} Args
- * @extends {Schema<_LArgsToLambdaDef<Args>>}
- */
 class $Lambda extends Schema {
   /**
    * @param {Args} args
    */
-  constructor (args) {
+  constructor(args) {
     super();
     this.len = args.length - 1;
     this.args = $tuple(...args.slice(-1));
     this.res = args[this.len];
   }
-
   /**
    * @param {any} f
    * @param {ValidationError} err
    * @return {f is _LArgsToLambdaDef<Args>}
    */
-  check (f, err) {
+  check(f, err) {
     const c = f.constructor === Function && f.length <= this.len;
-    /* c8 ignore next */
-    !c && err?.extend(null, 'function', typeof f);
-    return c
+    !c && err?.extend(null, "function", typeof f);
+    return c;
   }
 }
 const $$lambda = $constructedBy($Lambda);
-
-/**
- * @type {Schema<Function>}
- */
-const $function = $custom(o => typeof o === 'function');
-
-/**
- * @template {Array<Schema<any>>} T
- * @extends {Schema<Intersect<UnwrapArray<T>>>}
- */
+const $function = $custom((o) => typeof o === "function");
 class $Intersection extends Schema {
   /**
    * @param {T} v
    */
-  constructor (v) {
+  constructor(v) {
     super();
-    /**
-     * @type {T}
-     */
     this.shape = v;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is Intersect<UnwrapArray<T>>}
    */
-  check (o, err) {
-    // @ts-ignore
-    const c = every(this.shape, check => check.check(o, err));
-    /* c8 ignore next */
-    !c && err?.extend(null, 'Intersectinon', typeof o);
-    return c
+  check(o, err) {
+    const c = every(this.shape, (check) => check.check(o, err));
+    !c && err?.extend(null, "Intersectinon", typeof o);
+    return c;
   }
 }
-$constructedBy($Intersection, o => o.shape.length > 0); // Intersection with length=0 is considered "any"
-
-/**
- * @template S
- * @extends {Schema<S>}
- */
+$constructedBy($Intersection, (o) => o.shape.length > 0);
 class $Union extends Schema {
-  static _dilutes = true
-
   /**
    * @param {Array<Schema<S>>} v
    */
-  constructor (v) {
+  constructor(v) {
     super();
     this.shape = v;
   }
-
   /**
    * @param {any} o
    * @param {ValidationError} [err]
    * @return {o is S}
    */
-  check (o, err) {
+  check(o, err) {
     const c = some(this.shape, (vv) => vv.check(o, err));
-    err?.extend(null, 'Union', typeof o);
-    return c
+    err?.extend(null, "Union", typeof o);
+    return c;
   }
 }
-
-/**
- * @template {Array<any>} T
- * @param {T} schemas
- * @return {CastToSchema<$Union<Unwrap<ReadSchema<T>>>>}
- */
-const $union = (...schemas) => schemas.findIndex($s => $$union.check($s)) >= 0
-  ? $union(...schemas.map($s => $($s)).map($s => $$union.check($s) ? $s.shape : [$s]).flat(1))
-  : (schemas.length === 1
-      ? schemas[0]
-      : new $Union(schemas));
-const $$union = /** @type {Schema<$Union<any>>} */ ($constructedBy($Union));
-
+__publicField($Union, "_dilutes", true);
+const $union = (...schemas) => schemas.findIndex(($s) => $$union.check($s)) >= 0 ? $union(...schemas.map(($s) => $($s)).map(($s) => $$union.check($s) ? $s.shape : [$s]).flat(1)) : schemas.length === 1 ? schemas[0] : new $Union(schemas);
+const $$union = (
+  /** @type {Schema<$Union<any>>} */
+  $constructedBy($Union)
+);
 const _t = () => true;
-/**
- * @type {Schema<any>}
- */
 const $any = $custom(_t);
-const $$any = /** @type {Schema<Schema<any>>} */ ($constructedBy($Custom, o => o.shape === _t));
-
-/**
- * @type {Schema<bigint>}
- */
-const $bigint = $custom(o => typeof o === 'bigint');
-const $$bigint = /** @type {Schema<Schema<BigInt>>} */ ($custom(o => o === $bigint));
-
-/**
- * @type {Schema<symbol>}
- */
-const $symbol = $custom(o => typeof o === 'symbol');
-/** @type {Schema<Schema<Symbol>>} */ ($custom(o => o === $symbol));
-
-/**
- * @type {Schema<number>}
- */
-const $number = $custom(o => typeof o === 'number');
-const $$number = /** @type {Schema<Schema<number>>} */ ($custom(o => o === $number));
-
-/**
- * @type {Schema<string>}
- */
-const $string = $custom(o => typeof o === 'string');
-const $$string = /** @type {Schema<Schema<string>>} */ ($custom(o => o === $string));
-
-/**
- * @type {Schema<boolean>}
- */
-const $boolean = $custom(o => typeof o === 'boolean');
-const $$boolean = /** @type {Schema<Schema<Boolean>>} */ ($custom(o => o === $boolean));
-
-/**
- * @type {Schema<undefined>}
- */
-const $undefined = $literal(undefined);
-/** @type {Schema<Schema<undefined>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined));
-
-/**
- * @type {Schema<void>}
- */
-$literal(undefined);
-
+const $$any = (
+  /** @type {Schema<Schema<any>>} */
+  $constructedBy($Custom, (o) => o.shape === _t)
+);
+const $bigint = $custom((o) => typeof o === "bigint");
+const $$bigint = (
+  /** @type {Schema<Schema<BigInt>>} */
+  $custom((o) => o === $bigint)
+);
+const $symbol = $custom((o) => typeof o === "symbol");
+$custom((o) => o === $symbol);
+const $number = $custom((o) => typeof o === "number");
+const $$number = (
+  /** @type {Schema<Schema<number>>} */
+  $custom((o) => o === $number)
+);
+const $string = $custom((o) => typeof o === "string");
+const $$string = (
+  /** @type {Schema<Schema<string>>} */
+  $custom((o) => o === $string)
+);
+const $boolean = $custom((o) => typeof o === "boolean");
+const $$boolean = (
+  /** @type {Schema<Schema<Boolean>>} */
+  $custom((o) => o === $boolean)
+);
+const $undefined = $literal(void 0);
+$constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === void 0);
+$literal(void 0);
 const $null = $literal(null);
-const $$null = /** @type {Schema<Schema<null>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === null));
-
+const $$null = (
+  /** @type {Schema<Schema<null>>} */
+  $constructedBy($Literal, (o) => o.shape.length === 1 && o.shape[0] === null)
+);
 $constructedBy(Uint8Array);
-/** @type {Schema<Schema<Uint8Array>>} */ ($constructedBy($ConstructedBy, o => o.shape === Uint8Array));
-
-/**
- * @type {Schema<Primitive>}
- */
+$constructedBy($ConstructedBy, (o) => o.shape === Uint8Array);
 const $primitive = $union($number, $string, $null, $undefined, $bigint, $boolean, $symbol);
-
-/**
- * @typedef {JSON[]} JSONArray
- */
-/**
- * @typedef {Primitive|JSONArray|{ [key:string]:JSON }} JSON
- */
-/**
- * @type {Schema<null|number|string|boolean|JSON[]|{[key:string]:JSON}>}
- */
 (() => {
-  const $jsonArr = /** @type {$Array<$any>} */ ($array($any));
-  const $jsonRecord = /** @type {$Record<$string,$any>} */ ($record($string, $any));
+  const $jsonArr = (
+    /** @type {$Array<$any>} */
+    $array($any)
+  );
+  const $jsonRecord = (
+    /** @type {$Record<$string,$any>} */
+    $record($string, $any)
+  );
   const $json = $union($number, $string, $null, $boolean, $jsonArr, $jsonRecord);
   $jsonArr.shape = $json;
   $jsonRecord.shape.values = $json;
-  return $json
+  return $json;
 })();
-
-/**
- * @template {any} IN
- * @typedef {IN extends Schema<any> ? IN
- *   : (IN extends string|number|boolean|null ? Schema<IN>
- *     : (IN extends new (...args:any[])=>any ? Schema<InstanceType<IN>>
- *       : (IN extends any[] ? Schema<{ [K in keyof IN]: Unwrap<ReadSchema<IN[K]>> }[number]>
-   *       : (IN extends object ? (_ObjectDefToSchema<{[K in keyof IN]:ReadSchema<IN[K]>}> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never)
-   *         : never)
- *         )
- *       )
- *     )
- * } ReadSchemaOld
- */
-
-/**
- * @template {any} IN
- * @typedef {[Extract<IN,Schema<any>>,Extract<IN,string|number|boolean|null>,Extract<IN,new (...args:any[])=>any>,Extract<IN,any[]>,Extract<Exclude<IN,Schema<any>|string|number|boolean|null|(new (...args:any[])=>any)|any[]>,object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj]
- *   ? Schema<
- *       (Schemas extends Schema<infer S> ? S : never)
- *     | Primitives
- *     | (Constructors extends new (...args:any[])=>any ? InstanceType<Constructors> : never)
- *     | (Arrs extends any[] ? { [K in keyof Arrs]: Unwrap<ReadSchema<Arrs[K]>> }[number] : never)
- *     | (Obj extends object ? Unwrap<(_ObjectDefToSchema<{[K in keyof Obj]:ReadSchema<Obj[K]>}> extends Schema<infer S> ? Schema<{ [K in keyof S]: S[K] }> : never)> : never)>
- *   : never
- * } ReadSchema
- */
-
-/**
- * @typedef {ReadSchema<{x:42}|{y:99}|Schema<string>|[1,2,{}]>} Q
- */
-
-/**
- * @template IN
- * @param {IN} o
- * @return {ReadSchema<IN>}
- */
-const $ = o => {
+const $ = (o) => {
   if ($$schema.check(o)) {
-    return /** @type {any} */ (o)
+    return (
+      /** @type {any} */
+      o
+    );
   } else if ($objectAny.check(o)) {
-    /**
-     * @type {any}
-     */
     const o2 = {};
     for (const k in o) {
       o2[k] = $(o[k]);
     }
-    return /** @type {any} */ ($object(o2))
+    return (
+      /** @type {any} */
+      $object(o2)
+    );
   } else if ($arrayAny.check(o)) {
-    return /** @type {any} */ ($union(...o.map($)))
+    return (
+      /** @type {any} */
+      $union(...o.map($))
+    );
   } else if ($primitive.check(o)) {
-    return /** @type {any} */ ($literal(o))
+    return (
+      /** @type {any} */
+      $literal(o)
+    );
   } else if ($function.check(o)) {
-    return /** @type {any} */ ($constructedBy(/** @type {any} */ (o)))
+    return (
+      /** @type {any} */
+      $constructedBy(
+        /** @type {any} */
+        o
+      )
+    );
   }
-  /* c8 ignore next */
   unexpectedCase();
 };
-
-/* c8 ignore start */
-/**
- * Assert that a variable is of this specific type.
- * The assertion check is only performed in non-production environments.
- *
- * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
- */
-const assert = production
-  ? () => {}
-  : (o, schema) => {
-      const err = new ValidationError();
-      if (!schema.check(o, err)) {
-        throw create(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
-      }
-    };
-/* c8 ignore end */
-
-/**
- * @template In
- * @template Out
- * @typedef {{ if: Schema<In>, h: (o:In,state?:any)=>Out }} Pattern
- */
-
-/**
- * @template {Pattern<any,any>} P
- * @template In
- * @typedef {ReturnType<Extract<P,Pattern<In extends number ? number : (In extends string ? string : In),any>>['h']>} PatternMatchResult
- */
-
-/**
- * @todo move this to separate library
- * @template {any} [State=undefined]
- * @template {Pattern<any,any>} [Patterns=never]
- */
+const assert = production ? () => {
+} : (o, schema) => {
+  const err = new ValidationError();
+  if (!schema.check(o, err)) {
+    throw create(`Expected value to be of type ${schema.constructor.name}.
+${err.toString()}`);
+  }
+};
 class PatternMatcher {
   /**
    * @param {Schema<State>} [$state]
    */
-  constructor ($state) {
-    /**
-     * @type {Array<Patterns>}
-     */
+  constructor($state) {
     this.patterns = [];
     this.$state = $state;
   }
-
   /**
    * @template P
    * @template R
@@ -995,101 +644,83 @@ class PatternMatcher {
    * @param {(o:NoInfer<Unwrap<ReadSchema<P>>>,s:State)=>R} handler
    * @return {PatternMatcher<State,Patterns|Pattern<Unwrap<ReadSchema<P>>,R>>}
    */
-  if (pattern, handler) {
-    // @ts-ignore
+  if(pattern, handler) {
     this.patterns.push({ if: $(pattern), h: handler });
-    // @ts-ignore
-    return this
+    return this;
   }
-
   /**
    * @template R
    * @param {(o:any,s:State)=>R} h
    */
-  else (h) {
-    return this.if($any, h)
+  else(h) {
+    return this.if($any, h);
   }
-
   /**
    * @return {State extends undefined
    *   ? <In extends Unwrap<Patterns['if']>>(o:In,state?:undefined)=>PatternMatchResult<Patterns,In>
    *   : <In extends Unwrap<Patterns['if']>>(o:In,state:State)=>PatternMatchResult<Patterns,In>}
    */
-  done () {
-    // @ts-ignore
-    return /** @type {any} */ (o, s) => {
-      for (let i = 0; i < this.patterns.length; i++) {
-        const p = this.patterns[i];
-        if (p.if.check(o)) {
-          // @ts-ignore
-          return p.h(o, s)
+  done() {
+    return (
+      /** @type {any} */
+      (o, s) => {
+        for (let i = 0; i < this.patterns.length; i++) {
+          const p = this.patterns[i];
+          if (p.if.check(o)) {
+            return p.h(o, s);
+          }
         }
+        throw create("Unhandled pattern");
       }
-      throw create('Unhandled pattern')
-    }
+    );
   }
 }
-
-/**
- * @template [State=undefined]
- * @param {State} [state]
- * @return {PatternMatcher<State extends undefined ? undefined : Unwrap<ReadSchema<State>>>}
- */
-const match = state => new PatternMatcher(/** @type {any} */ (state));
-
-/**
- * Helper function to generate a (non-exhaustive) sample set from a gives schema.
- *
- * @type {<T>(o:T,gen:prng.PRNG)=>T}
- */
-const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any))
-  .if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))
-  .if($$string, (_o, gen) => word(gen))
-  .if($$boolean, (_o, gen) => bool(gen))
-  .if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)))
-  .if($$union, (o, gen) => random(gen, oneOf(gen, o.shape)))
-  .if($$object, (o, gen) => {
-    /**
-     * @type {any}
-     */
+const match = (state) => new PatternMatcher(
+  /** @type {any} */
+  state
+);
+const _random = (
+  /** @type {any} */
+  match(
+    /** @type {Schema<prng.PRNG>} */
+    $any
+  ).if($$number, (_o, gen) => int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER)).if($$string, (_o, gen) => word(gen)).if($$boolean, (_o, gen) => bool(gen)).if($$bigint, (_o, gen) => BigInt(int53(gen, MIN_SAFE_INTEGER, MAX_SAFE_INTEGER))).if($$union, (o, gen) => random(gen, oneOf(gen, o.shape))).if($$object, (o, gen) => {
     const res = {};
     for (const k in o.shape) {
       let prop = o.shape[k];
       if ($$optional.check(prop)) {
-        if (bool(gen)) { continue }
+        if (bool(gen)) {
+          continue;
+        }
         prop = prop.shape;
       }
       res[k] = _random(prop, gen);
     }
-    return res
-  })
-  .if($$array, (o, gen) => {
+    return res;
+  }).if($$array, (o, gen) => {
     const arr = [];
     const n = int32(gen, 0, 42);
     for (let i = 0; i < n; i++) {
       arr.push(random(gen, o.shape));
     }
-    return arr
-  })
-  .if($$literal, (o, gen) => {
-    return oneOf(gen, o.shape)
-  })
-  .if($$null, (o, gen) => {
-    return null
-  })
-  .if($$lambda, (o, gen) => {
+    return arr;
+  }).if($$literal, (o, gen) => {
+    return oneOf(gen, o.shape);
+  }).if($$null, (o, gen) => {
+    return null;
+  }).if($$lambda, (o, gen) => {
     const res = random(gen, o.res);
-    return () => res
-  })
-  .if($$any, (o, gen) => random(gen, oneOf(gen, [
-    $number, $string, $null, $undefined, $bigint, $boolean,
+    return () => res;
+  }).if($$any, (o, gen) => random(gen, oneOf(gen, [
+    $number,
+    $string,
+    $null,
+    $undefined,
+    $bigint,
+    $boolean,
     $array($number),
-    $record($union('a', 'b', 'c'), $number)
-  ])))
-  .if($$record, (o, gen) => {
-    /**
-     * @type {any}
-     */
+    $record($union("a", "b", "c"), $number)
+  ]))).if($$record, (o, gen) => {
     const res = {};
     const keysN = int53(gen, 0, 3);
     for (let i = 0; i < keysN; i++) {
@@ -1097,16 +728,66 @@ const _random = /** @type {any} */ (match(/** @type {Schema<prng.PRNG>} */ ($any
       const val = random(gen, o.shape.values);
       res[key] = val;
     }
-    return res
-  })
-  .done());
-
-/**
- * @template S
- * @param {prng.PRNG} gen
- * @param {S} schema
- * @return {Unwrap<ReadSchema<S>>}
- */
-const random = (gen, schema) => /** @type {any} */ (_random($(schema), gen));
-
-export { $, $$any, $$array, $$bigint, $$boolean, $$lambda, $$literal, $$null, $$number, $$object, $$optional, $$record, $$schema, $$string, $$union, $Array, $ConstructedBy, $Custom, $InstanceOf, $Intersection, $Lambda, $Literal, $Object, $Record, $StringTemplate, $Tuple, $Union, $any, $array, $arrayAny, $bigint, $boolean, $constructedBy, $custom, $function, $instanceOf, $literal, $null, $number, $object, $objectAny, $primitive, $record, $string, $symbol, $tuple, $undefined, $union, PatternMatcher, Schema, ValidationError, assert, match, random };
+    return res;
+  }).done()
+);
+const random = (gen, schema) => (
+  /** @type {any} */
+  _random($(schema), gen)
+);
+export {
+  $,
+  $$any,
+  $$array,
+  $$bigint,
+  $$boolean,
+  $$lambda,
+  $$literal,
+  $$null,
+  $$number,
+  $$object,
+  $$optional,
+  $$record,
+  $$schema,
+  $$string,
+  $$union,
+  $Array,
+  $ConstructedBy,
+  $Custom,
+  $InstanceOf,
+  $Intersection,
+  $Lambda,
+  $Literal,
+  $Object,
+  $Record,
+  $StringTemplate,
+  $Tuple,
+  $Union,
+  $any,
+  $array,
+  $arrayAny,
+  $bigint,
+  $boolean,
+  $constructedBy,
+  $custom,
+  $function,
+  $instanceOf,
+  $literal,
+  $null,
+  $number,
+  $object,
+  $objectAny,
+  $primitive,
+  $record,
+  $string,
+  $symbol,
+  $tuple,
+  $undefined,
+  $union,
+  PatternMatcher,
+  Schema,
+  ValidationError,
+  assert,
+  match,
+  random
+};