justus 0.0.1 → 0.0.5

package/src/dts-generator.ts

@@ -0,0 +1,276 @@
+import ts from 'typescript'
+import {
+  AllOfValidator,
+  AnyArrayValidator,
+  AnyNumberValidator,
+  AnyObjectValidator,
+  AnyStringValidator,
+  AnyValidator,
+  ArrayValidator,
+  assertSchema,
+  BooleanValidator,
+  ConstantValidator,
+  DateValidator,
+  getValidator,
+  NumberValidator,
+  ObjectValidator,
+  OneOfValidator,
+  StringValidator,
+  TupleValidator,
+  URLValidator,
+  Validation,
+  Validator,
+} from './index'
+
+/* ========================================================================== *
+ * LOCAL TYPES                                                                *
+ * ========================================================================== */
+
+/** A function taking a `Validator` and producing its `TypeNode`. */
+type TypeGenerator<V extends Validator = Validator> = (
+  validator: V,
+  references: ReadonlyMap<Validator, string>
+) => ts.TypeNode
+
+/** The generic constructor of a `Validator` instance. */
+type ValidatorConstructor<V extends Validator = Validator> = { // <T = any> = {
+  new (...args: any[]): V
+}
+
+/* ========================================================================== *
+ * GENERATE TYPES FOR VALIDATORS                                              *
+ * ========================================================================== */
+
+/** Registry of all `Validator` constructors and related `TypeGenerator`s. */
+const generators = new Map<Function, TypeGenerator<any>>()
+
+/** Register a `TypeGenerator` function for a `Validator`. */
+export function registerTypeGenerator<V extends Validator>(
+    validator: ValidatorConstructor<V>,
+    generator: TypeGenerator<V>,
+): void {
+  assertSchema(validator.prototype instanceof Validator, 'Not a `Validator` class')
+  generators.set(validator, generator)
+}
+
+/** Generate typings for the given `Validation`s. */
+export function generateTypes(validations: Record<string, Validation>): string {
+  // Create two maps (one mapping "string -> validator" and another mapping
+  // "validator -> string"). The first map will serve as our "exports" map,
+  // while the second will make sure that any exported validator gets referenced
+  // in the generated DTS, rather than being re-generated
+  const validators = new Map<string, Validator>()
+  const references = new Map<Validator, string>()
+
+  Object.entries(validations).forEach(([ name, validation ]) => {
+    const validator = getValidator(validation)
+    // References will be added only once, first one takes precedence!
+    if (! references.has(validator)) references.set(validator, name)
+    validators.set(name, validator)
+  })
+
+  // Create the array of type alias declarations to be printed and exported
+  const types: ts.TypeAliasDeclaration[] = []
+  for (const [ name, validator ] of validators.entries()) {
+    // Clone our references map, and remove the validator being exported. This
+    // will make sure that we don't have any loops in our types
+    const referenceable = new Map(references)
+    if (referenceable.get(validator) === name) {
+      referenceable.delete(validator)
+    }
+
+    // Generate the type of the validator, with our stripped reference table
+    const type = generateTypeNode(validator, referenceable)
+
+    // Create a type alias declaration with the name of the export
+    const modifiers = [ ts.factory.createModifier(ts.SyntaxKind.ExportKeyword) ]
+    const decl = ts.factory.createTypeAliasDeclaration(undefined, modifiers, name, [], type)
+    types.push(decl)
+  }
+
+  // Print out all our type aliases
+  return ts.createPrinter().printList(
+      ts.ListFormat.SourceFileStatements,
+      ts.factory.createNodeArray(types),
+      ts.createSourceFile('types.d.ts', '', ts.ScriptTarget.Latest))
+}
+
+/* ========================================================================== *
+ * TYPE GENERATORS                                                            *
+ * ========================================================================== */
+
+/** Generate a TypeScript `TypeNode` for the given validator instance. */
+function generateTypeNode(
+    validator: Validator,
+    references: ReadonlyMap<Validator, string>,
+): ts.TypeNode {
+  const reference = references.get(validator)
+  if (reference) return ts.factory.createTypeReferenceNode(reference)
+
+  const generator = generators.get(validator.constructor)
+  assertSchema(!! generator, `Type generator for "${validator.constructor.name}" not found`)
+  return generator(validator, references)
+}
+
+/* ========================================================================== */
+
+// Simple nodes
+
+const anyType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+const anyArrayType = ts.factory.createArrayTypeNode(anyType)
+const booleanType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword)
+const numberType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)
+const neverType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)
+const stringType = ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)
+const recordType = ts.factory.createMappedTypeNode(
+    undefined, // readonly
+    ts.factory.createTypeParameterDeclaration('key', stringType),
+    undefined, // name type
+    undefined, // question token
+    anyType, // type of the mapped key
+    undefined) // members
+
+// Modifiers and tokens
+
+const readonlyKeyword = [ ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword) ]
+const optionalKeyword = ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+
+
+/* ========================================================================== */
+
+// Simple generator returning nodes
+
+registerTypeGenerator(AnyValidator, () => anyType)
+registerTypeGenerator(AnyArrayValidator, () => anyArrayType)
+registerTypeGenerator(AnyNumberValidator, () => numberType)
+registerTypeGenerator(AnyObjectValidator, () => recordType)
+registerTypeGenerator(AnyStringValidator, () => stringType)
+registerTypeGenerator(BooleanValidator, () => booleanType)
+registerTypeGenerator(DateValidator, () => ts.factory.createTypeReferenceNode('Date'))
+registerTypeGenerator(URLValidator, () => ts.factory.createTypeReferenceNode('URL'))
+
+/* ========================================================================== */
+
+// Complex generator functions...
+
+registerTypeGenerator(ArrayValidator, (validator, references) => {
+  const itemType = generateTypeNode(validator.items, references)
+  return ts.factory.createArrayTypeNode(itemType)
+})
+
+registerTypeGenerator(ConstantValidator, (validator) => {
+  const literal =
+    typeof validator.constant === 'number' ? ts.factory.createNumericLiteral(validator.constant) :
+    typeof validator.constant === 'string' ? ts.factory.createStringLiteral(validator.constant) :
+    validator.constant === false ? ts.factory.createFalse() :
+    validator.constant === true ? ts.factory.createTrue() :
+    validator.constant === null ? ts.factory.createNull() :
+    undefined
+
+  assertSchema(!! literal, `Invalid constant "${validator.constant}"`)
+  return ts.factory.createLiteralTypeNode(literal)
+})
+
+registerTypeGenerator(NumberValidator, (validator: NumberValidator) => {
+  if (! validator.brand) return numberType
+
+  const signature = ts.factory.createPropertySignature(undefined, `__brand_${validator.brand}`, undefined, neverType)
+  const literal = ts.factory.createTypeLiteralNode([ signature ])
+  return ts.factory.createIntersectionTypeNode([ numberType, literal ])
+})
+
+registerTypeGenerator(StringValidator, (validator: StringValidator) => {
+  if (! validator.brand) return stringType
+
+  const signature = ts.factory.createPropertySignature(undefined, `__brand_${validator.brand}`, undefined, neverType)
+  const literal = ts.factory.createTypeLiteralNode([ signature ])
+  return ts.factory.createIntersectionTypeNode([ stringType, literal ])
+})
+
+registerTypeGenerator(TupleValidator, (validator: TupleValidator<any>, references) => {
+  const members = validator.members
+
+  // count how many rest parameters do we have..
+  const { count, first, next } =
+      members.reduce(({ count, first, next }, { single }, i) => {
+        if (! single) {
+          if (i < first) first = i
+          next = i + 1
+          count += 1
+        }
+        return { count, first, next }
+      }, { count: 0, first: members.length, next: -1 })
+
+  // if we have zero or one rest parameter, things are easy...
+  if (count < 2) {
+    const types = members.map(({ single, validator }) => {
+      const memberType = generateTypeNode(validator, references)
+
+      if (single) return generateTypeNode(validator, references)
+
+      const arrayType = ts.factory.createArrayTypeNode(memberType)
+      return ts.factory.createRestTypeNode(arrayType)
+    })
+
+    return ts.factory.createTupleTypeNode(types)
+  }
+
+  // We have two or more rest parameters... we need combine everything between
+  // the first and the last one in a giant union!
+  const before = members.slice(0, first)
+      .map(({ validator }) => generateTypeNode(validator, references))
+  const types = members.slice(first, next)
+      .map(({ validator }) => generateTypeNode(validator, references))
+  const after = members.slice(next)
+      .map(({ validator }) => generateTypeNode(validator, references))
+
+  const union = ts.factory.createUnionTypeNode(types)
+  const array = ts.factory.createArrayTypeNode(union)
+  const rest = ts.factory.createRestTypeNode(array)
+
+  return ts.factory.createTupleTypeNode([ ...before, rest, ...after ])
+})
+
+registerTypeGenerator(AllOfValidator, (validator, references) => {
+  const members = validator.validators.map((validator) => generateTypeNode(validator, references))
+  return ts.factory.createIntersectionTypeNode(members)
+})
+
+registerTypeGenerator(OneOfValidator, (validator, references) => {
+  const members = validator.validators.map((validator) => generateTypeNode(validator, references))
+  return ts.factory.createUnionTypeNode(members)
+})
+
+registerTypeGenerator(ObjectValidator, (validator, references) => {
+  const properties: ts.PropertySignature[] = []
+
+  for (const [ key, property ] of validator.properties.entries()) {
+    const { validator, readonly, optional } = property || { optional: true }
+    const type = validator ? generateTypeNode(validator, references) : neverType
+
+    const signature = ts.factory.createPropertySignature(
+          readonly ? readonlyKeyword : undefined,
+          key,
+          optional ? optionalKeyword : undefined,
+          type)
+
+    properties.push(signature)
+  }
+
+  if (validator.additionalProperties) {
+    const extra = ts.factory.createMappedTypeNode(
+        undefined, // readonly
+        ts.factory.createTypeParameterDeclaration('key', stringType),
+        undefined, // name type
+        undefined, // question token
+        generateTypeNode(validator.additionalProperties, references),
+        undefined) // members
+
+    if (properties.length == 0) return extra
+
+    const type = ts.factory.createTypeLiteralNode(properties)
+    return ts.factory.createIntersectionTypeNode([ type, extra ])
+  } else {
+    return ts.factory.createTypeLiteralNode(properties)
+  }
+})

package/src/errors.ts

@@ -1,4 +1,4 @@
-type ValidationErrors = { path: (string | number)[], message: string }[]
+export type ValidationErrors = { path: (string | number)[], message: string }[]
 
 /** Combine the components of a _path_ into a human readable string */
 function pathToString(path: (string | number)[]): string {
@@ -86,8 +86,8 @@ export class ValidationErrorBuilder {
    * @param key - The key in an object, or index in an array where the
    *              vaildation error was encountered
    */
-  record(error: any, key?: string | number): this {
-    const path = key === undefined ? [] : [ key ]
+  record(error: any, ...key: (string | number)[]): this {
+    const path = [ ...key ]
     if (error instanceof ValidationError) {
       error.errors.forEach(({ path: subpath, message }) => {
         this.errors.push({ path: [ ...path, ...subpath ], message })

package/src/index.ts

@@ -9,16 +9,17 @@ export * from './types'
 export * from './utilities'
 
 // Validators
-export { allOf, oneOf, AllOfValidator, OneOfValidator } from './validators/union'
+export { allOf, oneOf, AllOfValidator, InferAllOfValidationType, InferOneOfValidationType, OneOfValidator, UnionArguments } from './validators/union'
 export { any, AnyValidator } from './validators/any'
-export { array, arrayOf, ArrayValidator } from './validators/array'
+export { _array, array, arrayOf, AnyArrayValidator, ArrayConstraints, ArrayValidator } from './validators/array'
 export { boolean, BooleanValidator } from './validators/boolean'
 export { constant, ConstantValidator } from './validators/constant'
-export { date, DateValidator } from './validators/date'
-export { number, NumberValidator } from './validators/number'
-export { object, ObjectValidator } from './validators/object'
-export { string, StringValidator } from './validators/string'
-export { tuple, TupleValidator } from './validators/tuple'
+export { _date, date, DateConstraints, DateValidator } from './validators/date'
+export { _number, number, AnyNumberValidator, BrandedNumberConstraints, NumberConstraints, NumberValidator } from './validators/number'
+export { _object, object, AnyObjectValidator, ObjectProperty, ObjectValidator } from './validators/object'
+export { _string, string, AnyStringValidator, BrandedStringConstraints, StringConstraints, StringValidator } from './validators/string'
+export { tuple, TupleMember, TupleValidator } from './validators/tuple'
+export { _url, url, URLConstraints, URLValidator } from './validators/url'
 
 /* ========================================================================== *
  * VALIDATE FUNCTION (our main entry point)                                   *
@@ -32,7 +33,12 @@ export type ValidateOptions = {
   -readonly [ key in keyof ValidationOptions ]?: ValidationOptions[key] | undefined
 }
 
-/** Validate a _value_ using the specified `Validation` */
+/**
+ * Validate a _value_ using the specified `Validation`.
+ *
+ * By default additional and forbidden properties will _not_ be stripped and
+ * reported as an error.
+ */
 export function validate<V extends Validation>(
     validation: V,
     value: any,
@@ -46,3 +52,21 @@ export function validate<V extends Validation>(
 
   return getValidator(validation).validate(value, opts)
 }
+
+/**
+ * Validate a _value_ using the specified `Validation`, automatically stripping
+ * additional properties (but not forbidden ones).
+ */
+export function strip<V extends Validation>(
+    validation: V,
+    value: any,
+    options: ValidateOptions = {},
+): InferValidation<V> {
+  const opts: ValidationOptions = {
+    stripAdditionalProperties: true,
+    stripForbiddenProperties: false,
+    ...options,
+  }
+
+  return getValidator(validation).validate(value, opts)
+}

package/src/schema.ts

@@ -19,12 +19,12 @@ import {
  * ========================================================================== */
 
 /** Internal definition of `allowAdditionalProperties(...)` */
-function _allowAdditionalProperties(): AdditionalProperties<Validator<any>>
-function _allowAdditionalProperties(allow: true): AdditionalProperties<Validator<any>>
-function _allowAdditionalProperties(allow: false): AdditionalProperties<false>
-function _allowAdditionalProperties<V extends Validation>(validation: V): AdditionalProperties<Validator<InferValidation<V>>>
+export function _allowAdditionalProperties(): AdditionalProperties<Validator<any>>
+export function _allowAdditionalProperties(allow: true): AdditionalProperties<Validator<any>>
+export function _allowAdditionalProperties(allow: false): AdditionalProperties<false>
+export function _allowAdditionalProperties<V extends Validation>(validation: V): AdditionalProperties<Validator<InferValidation<V>>>
 
-function _allowAdditionalProperties(options?: Validation | boolean): AdditionalProperties<Validator | false> {
+export function _allowAdditionalProperties(options?: Validation | boolean): AdditionalProperties<Validator | false> {
   if (options === false) return { [additionalValidator]: false }
   if (options === true) return { [additionalValidator]: any }
 
@@ -49,7 +49,7 @@ allowAdditionalProperties[additionalValidator] = any
  * SCHEMA KEYS MODIFIERS                                                      *
  * ========================================================================== */
 
-type CombineModifiers<M1 extends Modifier, M2 extends Modifier> =
+export type CombineModifiers<M1 extends Modifier, M2 extends Modifier> =
   M1 extends ReadonlyModifier ?
     M2 extends ReadonlyModifier<infer V> ? ReadonlyModifier<V> :
     M2 extends OptionalModifier<infer V> ? CombinedModifier<V> :

package/src/types.ts

@@ -115,7 +115,7 @@ export type InferValidation<V> =
  * ========================================================================== */
 
 /** Infer the type validated by a `Validation` or `TupleRestParameter` */
-type InferValidationOrTupleRest<T> =
+export type InferValidationOrTupleRest<T> =
   T extends TupleRestParameter<infer X> ? X :
   T extends Validation ? InferValidation<T> :
   never
@@ -237,7 +237,7 @@ export type InferSchema<S extends Schema> =
 /* -------------------------------------------------------------------------- */
 
 /** Infer the type of keys associated with `Validation`s */
-type InferRequired<S extends Schema> = {
+export type InferRequired<S extends Schema> = {
   [ key in keyof S as
       key extends string ?
         S[key] extends Validation ? key :
@@ -251,7 +251,7 @@ type InferRequired<S extends Schema> = {
 /* -------------------------------------------------------------------------- */
 
 /** Infer the type of _read only_ `Schema` properties  */
-type InferReadonlyModifiers<S extends Schema> = {
+export type InferReadonlyModifiers<S extends Schema> = {
   readonly [ key in keyof S as
     key extends string ?
       S[key] extends OptionalModifier<Validator> ? never :
@@ -263,7 +263,7 @@ type InferReadonlyModifiers<S extends Schema> = {
 }
 
 /** Infer the type of _optional_ `Schema` properties  */
-type InferOptionalModifiers<S extends Schema> = {
+export type InferOptionalModifiers<S extends Schema> = {
   [ key in keyof S as
     key extends string ?
       S[key] extends ReadonlyModifier<Validator> ? never :
@@ -275,7 +275,7 @@ type InferOptionalModifiers<S extends Schema> = {
 }
 
 /** Infer the type of  _read only_ **and** _optional_ `Schema` properties  */
-type InferCombinedModifiers<S extends Schema> = {
+export type InferCombinedModifiers<S extends Schema> = {
   readonly [ key in keyof S as
     key extends string ?
       S[key] extends CombinedModifier ? key :
@@ -288,7 +288,7 @@ type InferCombinedModifiers<S extends Schema> = {
 /* -------------------------------------------------------------------------- */
 
 /** Ensure that we properly type `never` properties */
-type InferNever<S extends Schema> =
+export type InferNever<S extends Schema> =
   { [ key in keyof S as
       key extends string ?
         S[key] extends typeof never ? key :
@@ -296,3 +296,12 @@ type InferNever<S extends Schema> =
       never
     ] : never
   }
+
+/* ========================================================================== *
+ * TYPE BRANDING                                                              *
+ * ========================================================================== */
+
+/** Utility type to infer primitive branding according to a string */
+export type Branding<S extends string> = {
+  [ key in keyof { __brand: never } as `__brand_${S}` ] : never
+}

package/src/validators/array.ts

@@ -20,9 +20,16 @@ export interface ArrayConstraints<V extends Validation> {
   items?: V,
 }
 
-/**
- * A validator for `Array` instances.
- */
+/** Basic validator for `Array` instances. */
+export class AnyArrayValidator<T = any> extends Validator<T[]> {
+  validate(value: unknown, options: ValidationOptions): T[] {
+    void options
+    assertValidation(Array.isArray(value), 'Value is not an "array"')
+    return [ ...value ]
+  }
+}
+
+/** A validator for `Array` instances with constraints. */
 export class ArrayValidator<T> extends Validator<T[]> {
   readonly maxItems: number
   readonly minItems: number
@@ -80,19 +87,14 @@ export class ArrayValidator<T> extends Validator<T[]> {
   }
 }
 
-const anyArrayValidator = new class extends Validator<any[]> {
-  validate(value: unknown): any[] {
-    assertValidation(Array.isArray(value), 'Value is not an "array"')
-    return value
-  }
-}
+const anyArrayValidator = new AnyArrayValidator()
 
 /* -------------------------------------------------------------------------- */
 
-function _array(): Validator<any[]>
-function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>
+export function _array(): Validator<any[]>
+export function _array<V extends Validation>(constraints: ArrayConstraints<V>): ArrayValidator<InferValidation<V>>
 
-function _array(options?: ArrayConstraints<Validation>): Validator<any[]> {
+export function _array(options?: ArrayConstraints<Validation>): Validator<any[]> {
   if (! options) return anyArrayValidator
 
   const items = getValidator(options.items)

package/src/validators/date.ts

@@ -67,10 +67,10 @@ export class DateValidator extends Validator<Date> {
 
 const anyDateValidator = new DateValidator()
 
-function _date(): DateValidator
-function _date(constraints: DateConstraints): DateValidator
+export function _date(): DateValidator
+export function _date(constraints: DateConstraints): DateValidator
 
-function _date(constraints?: DateConstraints): DateValidator {
+export function _date(constraints?: DateConstraints): DateValidator {
   return constraints ? new DateValidator(constraints) : anyDateValidator
 }
 

package/src/validators/number.ts

@@ -1,6 +1,23 @@
-import { Validator } from '../types'
+import { Branding, Validator } from '../types'
 import { assertSchema, assertValidation } from '../errors'
 import { makeTupleRestIterable } from './tuple'
+import { ValidationError } from '..'
+
+/* ========================================================================== */
+
+const PRECISION = 6 // our default precision, in decimal digits
+const MULTIPLIER = Math.pow(10, PRECISION) // multiplier for precision
+
+function countDecimals(n: number): number {
+  // match the parts of the exponential form of the number
+  const match = n.toExponential().match(/^\d+(\.\d+)?e([+-]\d+)$/)
+  if (! match) throw new RangeError(`Can't calculate digits for number "${n}"`)
+  // number of digits in the absolute value, minus whatever is the exp
+  const digits = ((match[1] || '.').length - 1) - (parseInt(match[2]))
+  return digits < 0 ? 0 : digits
+}
+
+/* ========================================================================== */
 
 /** Constraints to validate a `number` with. */
 export interface NumberConstraints {
@@ -18,7 +35,22 @@ export interface NumberConstraints {
   allowNaN?: boolean,
 }
 
-/** A `Validator` validating `number`s. */
+/** Constraints to validate a `number` with extra branding information. */
+export interface BrandedNumberConstraints<B extends string> extends NumberConstraints {
+  /** The _brand_ of the string (will generate a `__brand_${B}` type property */
+  brand: B
+}
+
+/** A `Validator` validating any `number`. */
+export class AnyNumberValidator extends Validator<number> {
+  validate(value: unknown): number {
+    assertValidation(typeof value == 'number', 'Value is not a "number"')
+    assertValidation(! isNaN(value), 'Number is "NaN"')
+    return value
+  }
+}
+
+/** A `Validator` validating `number`s with constaints. */
 export class NumberValidator<N extends number = number> extends Validator<N> {
   #isMultipleOf?: ((value: number) => boolean)
 
@@ -28,6 +60,7 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
   readonly maximum: number
   readonly minimum: number
   readonly multipleOf?: number
+  readonly brand?: string
 
   constructor(constraints: NumberConstraints = {}) {
     super()
@@ -41,6 +74,8 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
       multipleOf,
     } = constraints
 
+    if ('brand' in constraints) this.brand = (<any> constraints).brand
+
     assertSchema(maximum >= minimum, `Constraint "minimum" (${minimum}) is greater than "maximum" (${maximum})`)
 
     if (exclusiveMaximum !== undefined) {
@@ -60,18 +95,21 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
 
     if (multipleOf !== undefined) {
       assertSchema(multipleOf > 0, `Constraint "multipleOf" (${multipleOf}) must be greater than zero`)
+      const decimals = countDecimals(multipleOf)
 
-      // Split the multiple of in integer and fraction
-      const bigMultipleOf = multipleOf * NumberValidator.PRECISION
-      const bigInteger = bigMultipleOf % NumberValidator.PRECISION
-      const bigDecimal = bigMultipleOf - Math.trunc(bigMultipleOf)
-
-      if (bigInteger === 0) {
+      if (decimals === 0) {
         // Easy case is when we only have to deal with integers...
         this.#isMultipleOf = (value): boolean => ! (value % multipleOf)
-      } else if (bigDecimal === 0) {
+      } else if (decimals <= PRECISION) {
         // We have some "decimal" part (max 6 decimal digits), multiply...
-        this.#isMultipleOf = (value): boolean => ! ((value * NumberValidator.PRECISION) % bigMultipleOf)
+        this.#isMultipleOf = (value): boolean => {
+          try {
+            if (countDecimals(value) > PRECISION) return false
+            return ! ((value * MULTIPLIER) % (multipleOf * MULTIPLIER))
+          } catch (error: any) {
+            throw new ValidationError(error.message)
+          }
+        }
       } else {
         // Required precision was too much (more than 6 decimal digits)
         assertSchema(false, `Constraint "multipleOf" (${multipleOf}) requires too much precision`)
@@ -108,22 +146,16 @@ export class NumberValidator<N extends number = number> extends Validator<N> {
 
     return value as N
   }
-
-  static readonly PRECISION = 1000000
 }
 
-const anyNumberValidator = new class extends Validator<number> {
-  validate(value: unknown): number {
-    assertValidation(typeof value == 'number', 'Value is not a "number"')
-    assertValidation(! isNaN(value), 'Number is "NaN"')
-    return value
-  }
-}
+const anyNumberValidator = new AnyNumberValidator()
 
-function _number(): Validator<number>
-function _number<N extends number = number>(constraints?: NumberConstraints): NumberValidator<N>
+export function _number(): Validator<number>
+export function _number(constraints?: NumberConstraints): NumberValidator<number>
+export function _number<N extends number>(constraints?: NumberConstraints): NumberValidator<N>
+export function _number<B extends string>(constraints: BrandedNumberConstraints<B>): NumberValidator<number & Branding<B>>
 
-function _number(constraints?: NumberConstraints): Validator<number> {
+export function _number(constraints?: NumberConstraints): Validator<number> {
   return constraints ? new NumberValidator(constraints) : anyNumberValidator
 }