lib0 0.2.112 → 0.2.115-0

package/dist/schema.cjs

@@ -2,17 +2,17 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var object$1 = require('./object-491858d1.cjs');
-var array$1 = require('./array-78849c95.cjs');
-var error = require('./error-8582d695.cjs');
-var environment = require('./environment-2de08e0e.cjs');
+var object = require('./object-18980796.cjs');
+var array = require('./array-78849c95.cjs');
+var error = require('./error-0c1f634f.cjs');
+var environment = require('./environment-90227ead.cjs');
+var traits = require('./traits.cjs');
+var _function = require('./function-e7d18feb.cjs');
+var string = require('./string-fddc5f8b.cjs');
 require('./set-5b47859e.cjs');
-require('./map-0dabcc55.cjs');
-require('./string-b2827a90.cjs');
+require('./map-24d263c0.cjs');
 require('./conditions-f5c0c102.cjs');
 require('./storage.cjs');
-require('./function-09b8292c.cjs');
-require('./traits.cjs');
 
 /**
  * @experimental WIP
@@ -30,17 +30,22 @@ require('./traits.cjs');
 
 /**
  * @template T
- * @typedef {T extends $Schema<infer X> ? X : T} Unwrap
+ * @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
+ * @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
+ * @typedef {T extends Schema<infer S> ? Schema<S> : never} CastToSchema
  */
 
 /**
@@ -67,11 +72,98 @@ require('./traits.cjs');
 
 const schemaSymbol = Symbol('0schema');
 
+class ValidationError {
+  constructor () {
+    /**
+     * Reverse errors
+     * @type {Array<{ path: string?, expected: string, has: string, message: string? }>}
+     */
+    this._rerrs = [];
+  }
+
+  /**
+   * @param {string?} path
+   * @param {string} expected
+   * @param {string} has
+   * @param {string?} message
+   */
+  extend (path, expected, has, message = null) {
+    this._rerrs.push({ path, expected, has, message });
+  }
+
+  toString () {
+    const s = [];
+    for (let i = this._rerrs.length - 1; i > 0; i--) {
+      const r = this._rerrs[i];
+      s.push(string.repeat(' ', (this._rerrs.length - i) * 2) + `${r.path != null ? `[${r.path}] ` : ''}${r.has} doesn't match ${r.expected}. ${r.message}`);
+    }
+    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[traits.EqualityTraitSymbol]) return traits.equals(a, b) // last resort: check equality (do this before array and obj check which don't implement the equality trait)
+  if (array.isArray(a)) {
+    return array.every(a, aitem =>
+      array.some(b, bitem => shapeExtends(aitem, bitem))
+    )
+  } else if (object.isObject(a)) {
+    return object.every(a, (aitem, akey) =>
+      shapeExtends(aitem, b[akey])
+    )
+  }
+  /* c8 ignore next */
+  return false
+};
+
 /**
  * @template T
+ * @implements {traits.EqualityTrait}
  */
-class $Schema {
-  get [schemaSymbol] () { return true }
+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)
+  }
+
+  /**
+   * 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 && _function.equalityDeep(this.shape, other.shape)
+  }
+
+  [schemaSymbol] () { return true }
+
+  /**
+   * @param {object} other
+   */
+  [traits.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
@@ -89,25 +181,26 @@ class $Schema {
    * Similar to validate, but this method accepts untyped parameters.
    *
    * @param {any} _o
+   * @param {ValidationError} [_err]
    * @return {_o is T}
    */
-  check (_o) {
+  check (_o, _err) {
     error.methodUnimplemented();
   }
   /* c8 ignore stop */
 
   /**
-   * @type {$Schema<T?>}
+   * @type {Schema<T?>}
    */
   get nullable () {
-    return union(this, null_)
+    return $union(this, $null)
   }
 
   /**
-   * @type {$Optional<$Schema<T>>}
+   * @type {$Optional<Schema<T>>}
    */
   get optional () {
-    return new $Optional(/** @type {$Schema<T>} */ (this))
+    return new $Optional(/** @type {Schema<T>} */ (this))
   }
 
   /**
@@ -118,20 +211,27 @@ class $Schema {
    * **Do not rely on these error messages!**
    * Performs an assertion check only if not in a production environment.
    *
-   * @param {any} o
-   * @return {o extends T ? T : never}
+   * @template OO
+   * @param {OO} o
+   * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
    */
   cast (o) {
     assert(o, this);
-    return o
+    return /** @type {any} */ (o)
   }
 
   /**
+   * EXPECTO PATRONUM!! 🪄
+   * This function protects against type errors. Though it may not work in the real world.
+   *
+   * "After all this time?"
+   * "Always." - Snape, talking about type safety
+   *
    * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
    * Use this if you know that the type is of a specific type and you just want to convince the type
    * system.
    *
-   * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).ensure((n) => n + 1)`
+   * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
    *
    * **Do not rely on these error messages!**
    * Performs an assertion check if not in a production environment.
@@ -139,60 +239,115 @@ class $Schema {
    * @param {T} o
    * @return {o extends T ? T : never}
    */
-  ensure (o) {
+  expect (o) {
     assert(o, this);
     return o
   }
 }
 
+/**
+ * @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<C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)>}
+ * @extends {Schema<Instance<C>>}
  */
-class $ConstructedBy extends $Schema {
+class $ConstructedBy extends Schema {
   /**
    * @param {C} c
+   * @param {((o:Instance<C>)=>boolean)|null} check
    */
-  constructor (c) {
+  constructor (c, check) {
     super();
-    this.v = c;
+    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) {
-    return o?.constructor === this.v
+  check (o, err = undefined) {
+    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
   }
 }
 
 /**
  * @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 => new $ConstructedBy(c);
+const $constructedBy = (c, check = null) => new $ConstructedBy(c, check);
+const $$constructedBy = $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) {
+    super();
+    /**
+     * @type {(o:any) => boolean}
+     */
+    this.shape = check;
+  }
+
+  /**
+   * @param {any} o
+   * @param {ValidationError} err
+   * @return {o is any}
+   */
+  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
+  }
+}
+
+/**
+ * @param {(o:any) => boolean} check
+ * @return {Schema<any>}
+ */
+const $custom = check => new $Custom(check);
+const $$custom = $constructedBy($Custom);
 
 /**
  * @template {LiteralType} T
- * @extends {$Schema<T>}
+ * @extends {Schema<T>}
  */
-class $Literal extends $Schema {
+class $Literal extends Schema {
   /**
    * @param {Array<T>} literals
    */
   constructor (literals) {
     super();
-    this.v = literals;
+    this.shape = literals;
   }
 
   /**
+   *
    * @param {any} o
+   * @param {ValidationError} [err]
    * @return {o is T}
    */
-  check (o) {
-    return this.v.some(a => a === o)
+  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
   }
 }
 
@@ -201,234 +356,405 @@ class $Literal extends $Schema {
  * @param {T} literals
  * @return {CastToSchema<$Literal<T[number]>>}
  */
-const literal = (...literals) => new $Literal(literals);
+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)
+);
+
+/**
+ * @param {string|Schema<any>} s
+ * @return {string[]}
+ */
+const _schemaStringTemplateToRegex = s => {
+  if ($string.check(s)) {
+    return [_regexEscape(s)]
+  }
+  if ($$literal.check(s)) {
+    return s.shape.map(v => v + '')
+  }
+  if ($$number.check(s)) {
+    return ['[+-]?\\d+.?\\d*']
+  }
+  if ($$string.check(s)) {
+    return ['.*']
+  }
+  if ($$union.check(s)) {
+    return s.shape.map(_schemaStringTemplateToRegex).flat(1)
+  }
+  /* c8 ignore next 2 */
+  // unexpected schema structure (only supports unions and string in literal types)
+  error.unexpectedCase();
+};
+
+/**
+ * @template {Array<string|Schema<string|number>>} T
+ * @extends {Schema<CastStringTemplateArgsToTemplate<T>>}
+ */
+class $StringTemplate extends Schema {
+  /**
+   * @param {T} shape
+   */
+  constructor (shape) {
+    super();
+    this.shape = shape;
+    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) {
+    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
+  }
+}
+
+/**
+ * @template {Array<string|Schema<string|number>>} T
+ * @param {T} literals
+ * @return {CastToSchema<$StringTemplate<T>>}
+ */
+const $stringTemplate = (...literals) => new $StringTemplate(literals);
+const $$stringTemplate = $constructedBy($StringTemplate);
 
 const isOptionalSymbol = Symbol('optional');
 /**
- * @template {$Schema<any>} S
- * @extends $Schema<Unwrap<S>|undefined>
+ * @template {Schema<any>} S
+ * @extends Schema<Unwrap<S>|undefined>
  */
-class $Optional extends $Schema {
+class $Optional extends Schema {
   /**
-   * @param {S} s
+   * @param {S} shape
    */
-  constructor (s) {
+  constructor (shape) {
     super();
-    this.s = s;
+    this.shape = shape;
   }
 
   /**
    * @param {any} o
+   * @param {ValidationError} [err]
    * @return {o is (Unwrap<S>|undefined)}
    */
-  check (o) {
-    return o === undefined || this.s.check(o)
+  check (o, err) {
+    const c = o === undefined || this.shape.check(o);
+    /* c8 ignore next */
+    !c && err?.extend(null, 'undefined (optional)', '()');
+    return c
   }
 
   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) {
+    err?.extend(null, 'never', typeof _o);
+    return false
+  }
+}
 
 /**
- * @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
+ * @type {Schema<never>}
  */
+const $never = new $Never();
+const $$never = $constructedBy($Never);
 
 /**
- * @template {{[key:string|symbol|number]: $Schema<any>}} S
- * @extends {$Schema<$ObjectToType<S>>}
+ * @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
  */
-class $Object extends $Schema {
+
+/**
+ * @template {{[key:string|symbol|number]: Schema<any>}} S
+ * @extends {Schema<$ObjectToType<S>>}
+ */
+class $Object extends Schema {
   /**
-   * @param {S} v
+   * @param {S} shape
+   * @param {boolean} partial
    */
-  constructor (v) {
+  constructor (shape, partial = false) {
     super();
-    this.v = v;
+    /**
+     * @type {S}
+     */
+    this.shape = shape;
+    this._isPartial = partial;
+  }
+
+  /**
+   * @type {Schema<Partial<$ObjectToType<S>>>}
+   */
+  get partial () {
+    return new $Object(this.shape, true)
   }
 
   /**
    * @param {any} o
+   * @param {ValidationError} err
    * @return {o is $ObjectToType<S>}
    */
-  check (o) {
-    return o != null && object$1.every(this.v, (vv, vk) => vv.check(o[vk]))
+  check (o, err) {
+    if (o == null) {
+      /* c8 ignore next */
+      err?.extend(null, 'object', 'null');
+      return false
+    }
+    return object.every(this.shape, (vv, vk) => {
+      const c = (this._isPartial && !object.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 {{ [key:string|symbol|number]: Schema<any> }} 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
+ * @template {{ [key:string|symbol|number]: Schema<any> }} S
  * @param {S} def
- * @return {$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 }>}
+ * @return {_ObjectDefToSchema<S> extends Schema<infer S> ? Schema<S> : never}
  */
-const object = def => /** @type {any} */ (new $Object(def));
+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 == null || o.constructor === Object));
 
 /**
- * @template {$Schema<string|number|symbol>} Keys
- * @template {$Schema<any>} Values
- * @extends {$Schema<Record<Keys extends $Schema<infer K> ? K : never,Values extends $Schema<infer T> ? T : never>>}
+ * @template {Schema<string|number|symbol>} Keys
+ * @template {Schema<any>} Values
+ * @extends {Schema<{ [key in Unwrap<Keys>]: Unwrap<Values> }>}
  */
-class $Record extends $Schema {
+class $Record extends Schema {
   /**
    * @param {Keys} keys
    * @param {Values} values
    */
   constructor (keys, values) {
     super();
-    this.keys = keys;
-    this.values = values;
+    this.shape = {
+      keys, values
+    };
   }
 
   /**
    * @param {any} o
-   * @return {o is Record<Keys extends $Schema<infer K> ? K : never,Values extends $Schema<infer T> ? T : never>}
+   * @param {ValidationError} err
+   * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
    */
-  check (o) {
-    return o != null && object$1.every(o, (vv, vk) => this.keys.check(vk) && this.values.check(vv))
+  check (o, err) {
+    return o != null && object.every(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)
+    })
   }
 }
 
 /**
- * @template {$Schema<string|number|symbol>} Keys
- * @template {$Schema<any>} Values
+ * @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 = (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 }>}
+ * @template {Schema<any>[]} S
+ * @extends {Schema<{ [Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never }>}
  */
-class $Tuple extends $Schema {
+class $Tuple extends Schema {
   /**
-   * @param {S} v
+   * @param {S} shape
    */
-  constructor (v) {
+  constructor (shape) {
     super();
-    this.v = v;
+    this.shape = shape;
   }
 
   /**
    * @param {any} o
-   * @return {o is { [K in keyof S]: S[K] extends $Schema<infer Type> ? Type : never }}
+   * @param {ValidationError} err
+   * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
    */
-  check (o) {
-    return o != null && object$1.every(this.v, (vv, vk) => /** @type {$Schema<any>} */ (vv).check(o[vk]))
+  check (o, err) {
+    return o != null && object.every(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
+    })
   }
 }
 
 /**
- * @template {Array<$Schema<any>>} T
+ * @template {Array<Schema<any>>} T
  * @param {T} def
  * @return {CastToSchema<$Tuple<T>>}
  */
-const tuple = (...def) => new $Tuple(def);
+const $tuple = (...def) => new $Tuple(def);
+const $$tuple = $constructedBy($Tuple);
 
 /**
- * @template {$Schema<any>} S
- * @extends {$Schema<Array<S extends $Schema<infer T> ? T : never>>}
+ * @template {Schema<any>} S
+ * @extends {Schema<Array<S extends Schema<infer T> ? T : never>>}
  */
-class $Array extends $Schema {
+class $Array extends Schema {
   /**
    * @param {Array<S>} v
    */
   constructor (v) {
     super();
     /**
-     * @type {$Schema<S extends $Schema<infer T> ? T : never>}
+     * @type {Schema<S extends Schema<infer T> ? T : never>}
      */
-    this.v = v.length === 1 ? v[0] : new $Union(v);
+    this.shape = v.length === 1 ? v[0] : new $Union(v);
   }
 
   /**
    * @param {any} o
-   * @return {o is Array<S extends $Schema<infer T> ? T : never>} o
+   * @param {ValidationError} [err]
+   * @return {o is Array<S extends Schema<infer T> ? T : never>} o
    */
-  check (o) {
-    return array$1.isArray(o) && array$1.every(o, oi => this.v.check(oi))
+  check (o, err) {
+    const c = array.isArray(o) && array.every(o, oi => this.shape.check(oi));
+    /* c8 ignore next */
+    !c && err?.extend(null, 'Array', '');
+    return c
   }
 }
 
 /**
- * @template {Array<$Schema<any>>} T
+ * @template {Array<Schema<any>>} T
  * @param {T} def
- * @return {$Schema<Array<T extends Array<$Schema<infer S>> ? S : never>>}
+ * @return {Schema<Array<T extends Array<Schema<infer S>> ? S : never>>}
  */
-const array = (...def) => new $Array(def);
+const $array = (...def) => new $Array(def);
+const $$array = $constructedBy($Array);
+/**
+ * @type {Schema<Array<any>>}
+ */
+const $arrayAny = $custom(o => array.isArray(o));
 
 /**
  * @template T
- * @extends {$Schema<T>}
+ * @extends {Schema<T>}
  */
-class $InstanceOf extends $Schema {
+class $InstanceOf extends Schema {
   /**
    * @param {new (...args:any) => T} constructor
+   * @param {((o:T) => boolean)|null} check
    */
-  constructor (constructor) {
+  constructor (constructor, check) {
     super();
-    this.v = constructor;
+    this.shape = constructor;
+    this._c = check;
   }
 
   /**
    * @param {any} o
+   * @param {ValidationError} err
    * @return {o is T}
    */
-  check (o) {
-    return o instanceof this.v
+  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
   }
 }
 
 /**
  * @template T
  * @param {new (...args:any) => T} c
- * @return {$Schema<T>}
+ * @param {((o:T) => boolean)|null} check
+ * @return {Schema<T>}
  */
-const instance = c => new $InstanceOf(c);
+const $instanceOf = (c, check = null) => new $InstanceOf(c, check);
+const $$instanceOf = $constructedBy($InstanceOf);
+
+const $$schema = $instanceOf(Schema);
 
 /**
- * @template {$Schema<any>[]} Args
+ * @template {Schema<any>[]} Args
  * @typedef {(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>} _LArgsToLambdaDef
  */
 
 /**
- * @template {Array<$Schema<any>>} Args
- * @extends {$Schema<_LArgsToLambdaDef<Args>>}
+ * @template {Array<Schema<any>>} Args
+ * @extends {Schema<_LArgsToLambdaDef<Args>>}
  */
-class $Lambda extends $Schema {
+class $Lambda extends Schema {
   /**
    * @param {Args} args
    */
   constructor (args) {
     super();
     this.len = args.length - 1;
-    this.args = tuple(...args.slice(-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) {
-    return f.constructor === Function && f.length <= this.len
+  check (f, err) {
+    const c = f.constructor === Function && f.length <= this.len;
+    /* c8 ignore next */
+    !c && err?.extend(null, 'function', typeof f);
+    return c
   }
 }
 
 /**
- * @template {$Schema<any>[]} Args
+ * @template {Schema<any>[]} Args
  * @param {Args} args
- * @return {$Schema<(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>>}
+ * @return {Schema<(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>>}
  */
-const lambda = (...args) => new $Lambda(args.length > 0 ? args : [void_]);
+const $lambda = (...args) => new $Lambda(args.length > 0 ? args : [$void]);
+const $$lambda = $constructedBy($Lambda);
 
 /**
- * @template {Array<$Schema<any>>} T
- * @extends {$Schema<Intersect<UnwrapArray<T>>>}
+ * @template {Array<Schema<any>>} T
+ * @extends {Schema<Intersect<UnwrapArray<T>>>}
  */
-class $Intersection extends $Schema {
+class $Intersection extends Schema {
   /**
    * @param {T} v
    */
@@ -437,141 +763,220 @@ class $Intersection extends $Schema {
     /**
      * @type {T}
      */
-    this.v = v;
+    this.shape = v;
   }
 
   /**
    * @param {any} o
+   * @param {ValidationError} [err]
    * @return {o is Intersect<UnwrapArray<T>>}
    */
-  check (o) {
+  check (o, err) {
     // @ts-ignore
-    return array$1.every(this.v, check => check.check(o))
+    const c = array.every(this.shape, check => check.check(o, err));
+    /* c8 ignore next */
+    !c && err?.extend(null, 'Intersectinon', typeof o);
+    return c
   }
 }
 
 /**
- * @template {$Schema<any>[]} T
+ * @template {Schema<any>[]} T
  * @param {T} def
  * @return {CastToSchema<$Intersection<T>>}
  */
-const intersect = (...def) => new $Intersection(def);
+const $intersect = (...def) => new $Intersection(def);
+const $$intersect = $constructedBy($Intersection, o => o.shape.length > 0); // Intersection with length=0 is considered "any"
 
 /**
  * @template S
- * @extends {$Schema<S>}
+ * @extends {Schema<S>}
  */
-class $Union extends $Schema {
+class $Union extends Schema {
+  static _dilutes = true
+
   /**
-   * @param {Array<$Schema<S>>} v
+   * @param {Array<Schema<S>>} v
    */
   constructor (v) {
     super();
-    this.v = v;
+    this.shape = v;
   }
 
   /**
    * @param {any} o
+   * @param {ValidationError} [err]
    * @return {o is S}
    */
-  check (o) {
-    return array$1.some(this.v, (vv) => vv.check(o))
+  check (o, err) {
+    const c = array.some(this.shape, (vv) => vv.check(o, err));
+    err?.extend(null, 'Union', typeof o);
+    return c
   }
-
-  static schema = constructedBy($Union)
 }
 
 /**
- * @template {Array<$Schema<any>>} T
- * @param {T} def
- * @return {CastToSchema<$Union<T extends [] ? never : (T extends Array<$Schema<infer S>> ? S : never)>>}
+ * @template {Array<Schema<any>>} T
+ * @param {T} schemas
+ * @return {CastToSchema<$Union<T extends [] ? never : (T extends Array<Schema<infer S>> ? S : never)>>}
+ */
+const $union = (...schemas) => $$union.check(schemas[0]) ? new $Union([...schemas[0].shape, ...schemas.slice(1)]) : (schemas.length === 1 ? schemas[0] : new $Union(schemas));
+const $$union = /** @type {Schema<$Union<any>>} */ ($constructedBy($Union));
+
+const _t = () => true;
+/**
+ * @type {Schema<any>}
  */
-const union = (...def) => $Union.schema.check(def[0]) ? new $Union([...def[0].v, ...def.slice(1)]) : new $Union(def);
+const $any = $custom(_t);
+const $$any = /** @type {Schema<Schema<any>>} */ ($constructedBy($Custom, o => o.shape === _t));
 
 /**
- * @type {$Schema<any>}
+ * @type {Schema<bigint>}
  */
-const any = intersect();
+const $bigint = $constructedBy(BigInt);
+const $$bigint = /** @type {Schema<Schema<BigInt>>} */ ($constructedBy($ConstructedBy, o => o.shape === BigInt));
 
 /**
- * @type {$Schema<bigint>}
+ * @type {Schema<Symbol>}
  */
-const bigint = constructedBy(BigInt);
+const $symbol = $constructedBy(Symbol);
+const $$symbol = /** @type {Schema<Schema<Symbol>>} */ ($constructedBy($ConstructedBy, o => o.shape === Symbol));
 
 /**
- * @type {$Schema<Symbol>}
+ * @type {Schema<number>}
  */
-const symbol = constructedBy(Symbol);
+const $number = $constructedBy(Number);
+const $$number = /** @type {Schema<Schema<number>>} */ ($constructedBy($ConstructedBy, o => o.shape === Number));
 
 /**
- * @type {$Schema<number>}
+ * @type {Schema<string>}
  */
-const number = constructedBy(Number);
+const $string = $constructedBy(String);
+const $$string = /** @type {Schema<Schema<string>>} */ ($constructedBy($ConstructedBy, o => o.shape === String));
 
 /**
- * @type {$Schema<string>}
+ * @type {Schema<boolean>}
  */
-const string = constructedBy(String);
+const $boolean = $constructedBy(Boolean);
+const $$boolean = /** @type {Schema<Schema<Boolean>>} */ ($constructedBy($ConstructedBy, o => o.shape === Boolean));
 
 /**
- * @type {$Schema<undefined>}
+ * @type {Schema<undefined>}
  */
-const undefined_ = literal(undefined);
+const $undefined = $literal(undefined);
+const $$undefined = /** @type {Schema<Schema<undefined>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === undefined));
 
 /**
- * @type {$Schema<void>}
+ * @type {Schema<void>}
  */
-const void_ = undefined_;
+const $void = $literal(undefined);
+const $$void = /** @type {Schema<Schema<void>>} */ ($$undefined);
 
+const $null = $literal(null);
+const $$null = /** @type {Schema<Schema<null>>} */ ($constructedBy($Literal, o => o.shape.length === 1 && o.shape[0] === null));
+
+/**
+ * @type {Schema<number|string|null|boolean>}
+ */
+const $primitive = $union($number, $string, $null, $boolean);
+
+/**
+ * @typedef {JSON[]} JSONArray
+ */
+/**
+ * @typedef {Unwrap<$primitive>|JSONArray|{ [key:string]:JSON }} JSON
+ */
 /**
- * @type {$Schema<null>}
+ * @type {Schema<null|number|string|boolean|JSON[]|{[key:string]:JSON}>}
  */
-const null_ = literal(null);
+const $json = (() => {
+  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
+})();
 
 /* 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}
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
  */
 const assert = environment.production
   ? () => {}
   : (o, schema) => {
-      if (!schema.check(o)) {
-        throw error.create(`Expected value to be of type ${schema.constructor.name}.`)
+      const err = new ValidationError();
+      if (!schema.check(o, err)) {
+        throw error.create(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
       }
     };
 /* c8 ignore end */
 
+exports.$$any = $$any;
+exports.$$array = $$array;
+exports.$$bigint = $$bigint;
+exports.$$boolean = $$boolean;
+exports.$$constructedBy = $$constructedBy;
+exports.$$custom = $$custom;
+exports.$$instanceOf = $$instanceOf;
+exports.$$intersect = $$intersect;
+exports.$$lambda = $$lambda;
+exports.$$literal = $$literal;
+exports.$$never = $$never;
+exports.$$null = $$null;
+exports.$$number = $$number;
+exports.$$object = $$object;
+exports.$$optional = $$optional;
+exports.$$record = $$record;
+exports.$$schema = $$schema;
+exports.$$string = $$string;
+exports.$$stringTemplate = $$stringTemplate;
+exports.$$symbol = $$symbol;
+exports.$$tuple = $$tuple;
+exports.$$undefined = $$undefined;
+exports.$$union = $$union;
+exports.$$void = $$void;
 exports.$Array = $Array;
 exports.$ConstructedBy = $ConstructedBy;
+exports.$Custom = $Custom;
 exports.$InstanceOf = $InstanceOf;
 exports.$Intersection = $Intersection;
 exports.$Lambda = $Lambda;
 exports.$Literal = $Literal;
 exports.$Object = $Object;
 exports.$Record = $Record;
-exports.$Schema = $Schema;
+exports.$StringTemplate = $StringTemplate;
 exports.$Tuple = $Tuple;
 exports.$Union = $Union;
-exports.any = any;
-exports.array = array;
+exports.$any = $any;
+exports.$array = $array;
+exports.$arrayAny = $arrayAny;
+exports.$bigint = $bigint;
+exports.$boolean = $boolean;
+exports.$constructedBy = $constructedBy;
+exports.$custom = $custom;
+exports.$instanceOf = $instanceOf;
+exports.$intersect = $intersect;
+exports.$json = $json;
+exports.$lambda = $lambda;
+exports.$literal = $literal;
+exports.$never = $never;
+exports.$null = $null;
+exports.$number = $number;
+exports.$object = $object;
+exports.$objectAny = $objectAny;
+exports.$primitive = $primitive;
+exports.$record = $record;
+exports.$string = $string;
+exports.$stringTemplate = $stringTemplate;
+exports.$symbol = $symbol;
+exports.$tuple = $tuple;
+exports.$undefined = $undefined;
+exports.$union = $union;
+exports.$void = $void;
+exports.Schema = Schema;
 exports.assert = assert;
-exports.bigint = bigint;
-exports.constructedBy = constructedBy;
-exports.instance = instance;
-exports.intersect = intersect;
-exports.lambda = lambda;
-exports.literal = literal;
-exports["null"] = null_;
-exports.number = number;
-exports.object = object;
-exports.record = record;
-exports.string = string;
-exports.symbol = symbol;
-exports.tuple = tuple;
-exports["undefined"] = undefined_;
-exports.union = union;
-exports["void"] = void_;
 //# sourceMappingURL=schema.cjs.map