@tstdl/base 0.85.14 → 0.86.0-beta2

package/rxjs/timing.js

@@ -1,63 +1,32 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var timing_exports = {};
-__export(timing_exports, {
-  animationFrame$: () => animationFrame$,
-  idle$: () => idle$,
-  immediate$: () => immediate$,
-  microtask$: () => microtask$,
-  nextTick$: () => nextTick$,
-  singleAnimationFrame$: () => singleAnimationFrame$,
-  singleIdle$: () => singleIdle$,
-  singleImmediate$: () => singleImmediate$,
-  singleNextTick$: () => singleNextTick$
-});
-module.exports = __toCommonJS(timing_exports);
-var import_rxjs = require("rxjs");
-const singleIdle$ = singleCallback((callback) => requestIdleCallback(callback), (handle) => cancelIdleCallback(handle));
-const idle$ = recursiveCallback((callback) => requestIdleCallback(callback), (handle) => cancelIdleCallback(handle));
-const singleAnimationFrame$ = singleCallback((callback) => requestAnimationFrame(callback), (handle) => cancelAnimationFrame(handle));
-const animationFrame$ = recursiveCallback((callback) => requestAnimationFrame(callback), (handle) => cancelAnimationFrame(handle));
-const singleImmediate$ = singleCallback((callback) => setImmediate(callback), (handle) => clearImmediate(handle));
-const immediate$ = recursiveCallback((callback) => setImmediate(callback), (handle) => clearImmediate(handle));
-const microtask$ = singleCallback((callback) => queueMicrotask(callback));
-const singleNextTick$ = singleCallback((callback) => process.nextTick(callback));
-const nextTick$ = recursiveCallback((callback) => process.nextTick(callback));
+import { Observable } from 'rxjs';
+export const singleIdle$ = singleCallback((callback) => requestIdleCallback(callback), (handle) => cancelIdleCallback(handle));
+export const idle$ = recursiveCallback((callback) => requestIdleCallback(callback), (handle) => cancelIdleCallback(handle));
+export const singleAnimationFrame$ = singleCallback((callback) => requestAnimationFrame(callback), (handle) => cancelAnimationFrame(handle));
+export const animationFrame$ = recursiveCallback((callback) => requestAnimationFrame(callback), (handle) => cancelAnimationFrame(handle));
+export const singleImmediate$ = singleCallback((callback) => setImmediate(callback), (handle) => clearImmediate(handle));
+export const immediate$ = recursiveCallback((callback) => setImmediate(callback), (handle) => clearImmediate(handle));
+export const microtask$ = singleCallback((callback) => queueMicrotask(callback));
+export const singleNextTick$ = singleCallback((callback) => process.nextTick(callback));
+export const nextTick$ = recursiveCallback((callback) => process.nextTick(callback));
 function singleCallback(scheduler, canceller) {
-  return new import_rxjs.Observable((subscriber) => {
-    const handle = scheduler((value) => {
-      subscriber.next(value);
-      subscriber.complete();
+    return new Observable((subscriber) => {
+        const handle = scheduler((value) => {
+            subscriber.next(value);
+            subscriber.complete();
+        });
+        return () => canceller?.(handle);
     });
-    return () => canceller?.(handle);
-  });
 }
 function recursiveCallback(scheduler, canceller) {
-  return new import_rxjs.Observable((subscriber) => {
-    let handle;
-    function schedule() {
-      handle = scheduler((value) => {
+    return new Observable((subscriber) => {
+        let handle;
+        function schedule() {
+            handle = scheduler((value) => {
+                schedule();
+                subscriber.next(value);
+            });
+        }
         schedule();
-        subscriber.next(value);
-      });
-    }
-    schedule();
-    return () => canceller?.(handle);
-  });
+        return () => canceller?.(handle);
+    });
 }

package/rxjs/touch.js

@@ -1,31 +1,12 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var touch_exports = {};
-__export(touch_exports, {
-  observeTouch: () => observeTouch
-});
-module.exports = __toCommonJS(touch_exports);
-var import_rxjs = require("rxjs");
-function observeTouch(element, options = {}) {
-  const start$ = (0, import_rxjs.fromEvent)(element, "touchstart", options).pipe((0, import_rxjs.startWith)(void 0));
-  const move$ = (0, import_rxjs.fromEvent)(element, "touchmove", options).pipe((0, import_rxjs.startWith)(void 0));
-  const end$ = (0, import_rxjs.fromEvent)(element, "touchend", options).pipe((0, import_rxjs.startWith)(void 0));
-  const cancel$ = (0, import_rxjs.fromEvent)(element, "touchcancel", options).pipe((0, import_rxjs.startWith)(void 0));
-  return start$.pipe((0, import_rxjs.switchMap)((start) => (0, import_rxjs.of)(start).pipe((0, import_rxjs.combineLatestWith)(move$, end$, cancel$))), (0, import_rxjs.map)(([start, move, end, cancel]) => ({ start, move, end, cancel })));
+import { combineLatestWith, fromEvent, map, of, startWith, switchMap } from 'rxjs';
+/**
+ * creates an observable that emits object with the latest state from all touch events. Values are reset on every new start event
+ * @param element element to observe touches on
+ */
+export function observeTouch(element, options = {}) {
+    const start$ = fromEvent(element, 'touchstart', options).pipe(startWith(undefined));
+    const move$ = fromEvent(element, 'touchmove', options).pipe(startWith(undefined));
+    const end$ = fromEvent(element, 'touchend', options).pipe(startWith(undefined));
+    const cancel$ = fromEvent(element, 'touchcancel', options).pipe(startWith(undefined));
+    return start$.pipe(switchMap((start) => of(start).pipe(combineLatestWith(move$, end$, cancel$))), map(([start, move, end, cancel]) => ({ start, move, end, cancel })));
 }

package/schema/array-constraints/index.js

@@ -1,19 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var array_constraints_exports = {};
-module.exports = __toCommonJS(array_constraints_exports);
-__reExport(array_constraints_exports, require("./maximum-length.js"), module.exports);
-__reExport(array_constraints_exports, require("./minimum-length.js"), module.exports);
+export * from './maximum-length.js';
+export * from './minimum-length.js';

package/schema/array-constraints/maximum-length.js

@@ -1,45 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var maximum_length_exports = {};
-__export(maximum_length_exports, {
-  ArrayMaximumLength: () => ArrayMaximumLength,
-  ArrayMaximumLengthConstraint: () => ArrayMaximumLengthConstraint
-});
-module.exports = __toCommonJS(maximum_length_exports);
-var import_decorators = require("../decorators/index.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_array_constraint = require("../types/schema-array-constraint.js");
-class ArrayMaximumLengthConstraint extends import_schema_array_constraint.SchemaArrayConstraint {
-  maximumLength;
-  expects;
-  constructor(maximumLength) {
-    super();
-    this.maximumLength = maximumLength;
-    this.expects = `a maximum array length of ${this.maximumLength}`;
-  }
-  validate(value, path, context) {
-    if (value.length > this.maximumLength) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaArrayConstraintDecorator } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
+export class ArrayMaximumLengthConstraint extends SchemaArrayConstraint {
+    maximumLength;
+    expects;
+    constructor(maximumLength) {
+        super();
+        this.maximumLength = maximumLength;
+        this.expects = `a maximum array length of ${this.maximumLength}`;
+    }
+    validate(value, path, context) {
+        if (value.length > this.maximumLength) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function ArrayMaximumLength(maximumLength) {
-  return (0, import_decorators.createSchemaArrayConstraintDecorator)(new ArrayMaximumLengthConstraint(maximumLength));
+export function ArrayMaximumLength(maximumLength) {
+    return createSchemaArrayConstraintDecorator(new ArrayMaximumLengthConstraint(maximumLength));
 }

package/schema/array-constraints/minimum-length.js

@@ -1,45 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var minimum_length_exports = {};
-__export(minimum_length_exports, {
-  MinimumArrayLength: () => MinimumArrayLength,
-  MinimumArrayLengthConstraint: () => MinimumArrayLengthConstraint
-});
-module.exports = __toCommonJS(minimum_length_exports);
-var import_decorators = require("../decorators/index.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_array_constraint = require("../types/schema-array-constraint.js");
-class MinimumArrayLengthConstraint extends import_schema_array_constraint.SchemaArrayConstraint {
-  minimumLength;
-  expects;
-  constructor(minimumLength) {
-    super();
-    this.minimumLength = minimumLength;
-    this.expects = `a minimum array length of ${this.minimumLength}`;
-  }
-  validate(value, path, context) {
-    if (value.length < this.minimumLength) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaArrayConstraintDecorator } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
+export class MinimumArrayLengthConstraint extends SchemaArrayConstraint {
+    minimumLength;
+    expects;
+    constructor(minimumLength) {
+        super();
+        this.minimumLength = minimumLength;
+        this.expects = `a minimum array length of ${this.minimumLength}`;
+    }
+    validate(value, path, context) {
+        if (value.length < this.minimumLength) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function MinimumArrayLength(minimumLength) {
-  return (0, import_decorators.createSchemaArrayConstraintDecorator)(new MinimumArrayLengthConstraint(minimumLength));
+export function MinimumArrayLength(minimumLength) {
+    return createSchemaArrayConstraintDecorator(new MinimumArrayLengthConstraint(minimumLength));
 }

package/schema/coercers/boolean.coercer.js

@@ -1,51 +1,27 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var boolean_coercer_exports = {};
-__export(boolean_coercer_exports, {
-  BooleanCoercer: () => BooleanCoercer,
-  booleanCoercer: () => booleanCoercer
-});
-module.exports = __toCommonJS(boolean_coercer_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class BooleanCoercer extends import_types.SchemaValueCoercer {
-  sourceType = [Number, String, BigInt];
-  targetType = Boolean;
-  coerce(value, path, context) {
-    const normalizedValue = (0, import_type_guards.isString)(value) ? value.toLowerCase() : value;
-    switch (normalizedValue) {
-      case 1:
-      case 1n:
-      case "true":
-      case "1":
-      case "yes":
-        return { success: true, value: true };
-      case 0:
-      case 0n:
-      case "false":
-      case "0":
-      case "no":
-        return { success: true, value: false };
-      default:
-        return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(Boolean, value.toString(), path, { fast: context.options.fastErrors }) };
+import { isString } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class BooleanCoercer extends SchemaValueCoercer {
+    sourceType = [Number, String, BigInt];
+    targetType = Boolean;
+    coerce(value, path, context) {
+        const normalizedValue = isString(value) ? value.toLowerCase() : value;
+        switch (normalizedValue) {
+            case 1:
+            case 1n:
+            case 'true':
+            case '1':
+            case 'yes':
+                return { success: true, value: true };
+            case 0:
+            case 0n:
+            case 'false':
+            case '0':
+            case 'no':
+                return { success: true, value: false };
+            default:
+                return { success: false, error: SchemaError.couldNotCoerce(Boolean, value.toString(), path, { fast: context.options.fastErrors }) };
+        }
     }
-  }
 }
-const booleanCoercer = new BooleanCoercer();
+export const booleanCoercer = new BooleanCoercer();

package/schema/coercers/date.coercer.js

@@ -1,40 +1,16 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var date_coercer_exports = {};
-__export(date_coercer_exports, {
-  DateCoercer: () => DateCoercer,
-  dateCoercer: () => dateCoercer
-});
-module.exports = __toCommonJS(date_coercer_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class DateCoercer extends import_types.SchemaValueCoercer {
-  sourceType = [Number, String, BigInt];
-  targetType = Date;
-  coerce(value, path, context) {
-    const parseValue = (0, import_type_guards.isBigInt)(value) ? Number(value) : value;
-    const date = new Date(parseValue);
-    if (Number.isNaN(date.getTime())) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors }) };
+import { isBigInt } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class DateCoercer extends SchemaValueCoercer {
+    sourceType = [Number, String, BigInt];
+    targetType = Date;
+    coerce(value, path, context) {
+        const parseValue = isBigInt(value) ? Number(value) : value;
+        const date = new Date(parseValue);
+        if (Number.isNaN(date.getTime())) {
+            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { success: true, value: date };
     }
-    return { success: true, value: date };
-  }
 }
-const dateCoercer = new DateCoercer();
+export const dateCoercer = new DateCoercer();

package/schema/coercers/index.js

@@ -1,23 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var coercers_exports = {};
-module.exports = __toCommonJS(coercers_exports);
-__reExport(coercers_exports, require("./boolean.coercer.js"), module.exports);
-__reExport(coercers_exports, require("./date.coercer.js"), module.exports);
-__reExport(coercers_exports, require("./number.coercer.js"), module.exports);
-__reExport(coercers_exports, require("./regexp.coercer.js"), module.exports);
-__reExport(coercers_exports, require("./string.coercer.js"), module.exports);
-__reExport(coercers_exports, require("./uint8-array.coercer.js"), module.exports);
+export * from './boolean.coercer.js';
+export * from './date.coercer.js';
+export * from './number.coercer.js';
+export * from './regexp.coercer.js';
+export * from './string.coercer.js';
+export * from './uint8-array.coercer.js';

package/schema/coercers/number.coercer.js

@@ -1,38 +1,14 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var number_coercer_exports = {};
-__export(number_coercer_exports, {
-  NumberCoercer: () => NumberCoercer,
-  numberCoercer: () => numberCoercer
-});
-module.exports = __toCommonJS(number_coercer_exports);
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class NumberCoercer extends import_types.SchemaValueCoercer {
-  sourceType = [String, BigInt, Boolean];
-  targetType = Number;
-  coerce(value, path, context) {
-    const result = Number(value);
-    if (Number.isNaN(result)) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors, customMessage: "Value is not a number." }) };
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class NumberCoercer extends SchemaValueCoercer {
+    sourceType = [String, BigInt, Boolean];
+    targetType = Number;
+    coerce(value, path, context) {
+        const result = Number(value);
+        if (Number.isNaN(result)) {
+            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors, customMessage: 'Value is not a number.' }) };
+        }
+        return { success: true, value: result };
     }
-    return { success: true, value: result };
-  }
 }
-const numberCoercer = new NumberCoercer();
+export const numberCoercer = new NumberCoercer();

package/schema/coercers/regexp.coercer.js

@@ -1,43 +1,20 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var regexp_coercer_exports = {};
-__export(regexp_coercer_exports, {
-  RegExpCoercer: () => RegExpCoercer,
-  regExpCoercer: () => regExpCoercer
-});
-module.exports = __toCommonJS(regexp_coercer_exports);
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class RegExpCoercer extends import_types.SchemaValueCoercer {
-  sourceType = String;
-  targetType = RegExp;
-  flags;
-  constructor(flags = "u") {
-    super();
-    this.flags = flags;
-  }
-  coerce(value, path, context) {
-    try {
-      return { success: true, value: RegExp(value, this.flags) };
-    } catch (error) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(this.targetType, "invalid regexp pattern", path, { fast: context.options.fastErrors, customMessage: error.message }) };
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class RegExpCoercer extends SchemaValueCoercer {
+    sourceType = String;
+    targetType = RegExp;
+    flags;
+    constructor(flags = 'u') {
+        super();
+        this.flags = flags;
+    }
+    coerce(value, path, context) {
+        try {
+            return { success: true, value: RegExp(value, this.flags) };
+        }
+        catch (error) {
+            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid regexp pattern', path, { fast: context.options.fastErrors, customMessage: error.message }) };
+        }
     }
-  }
 }
-const regExpCoercer = new RegExpCoercer();
+export const regExpCoercer = new RegExpCoercer();

package/schema/coercers/string.coercer.js

@@ -1,38 +1,14 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var string_coercer_exports = {};
-__export(string_coercer_exports, {
-  StringCoercer: () => StringCoercer,
-  stringCoercer: () => stringCoercer
-});
-module.exports = __toCommonJS(string_coercer_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class StringCoercer extends import_types.SchemaValueCoercer {
-  sourceType = [Number, Boolean, BigInt, Date];
-  targetType = String;
-  coerce(value, path, context) {
-    if ((0, import_type_guards.isDate)(value) && !(0, import_type_guards.isValidDate)(value)) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(this.targetType, "invalid date", path, { fast: context.options.fastErrors }) };
+import { isDate, isValidDate } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class StringCoercer extends SchemaValueCoercer {
+    sourceType = [Number, Boolean, BigInt, Date];
+    targetType = String;
+    coerce(value, path, context) {
+        if (isDate(value) && !isValidDate(value)) {
+            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid date', path, { fast: context.options.fastErrors }) };
+        }
+        return { success: true, value: value.toString() };
     }
-    return { success: true, value: value.toString() };
-  }
 }
-const stringCoercer = new StringCoercer();
+export const stringCoercer = new StringCoercer();