@tstdl/base 0.87.13 → 0.88.0-alpha1

package/schema/constraints/maximum-date.js

@@ -1,49 +1,26 @@
-"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_date_exports = {};
-__export(maximum_date_exports, {
-  MaximumDate: () => MaximumDate,
-  MaximumDateConstraint: () => MaximumDateConstraint
-});
-module.exports = __toCommonJS(maximum_date_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_decorators = require("../decorators/index.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_types = require("../types/types.js");
-class MaximumDateConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  maximum;
-  suitableTypes = Number;
-  expects;
-  constructor(maximum) {
-    super();
-    this.maximum = (0, import_type_guards.isNumber)(maximum) ? new Date(maximum) : maximum;
-    this.expects = `<= ${this.maximum.toISOString()}`;
-    (0, import_type_guards.assertValidDate)(this.maximum);
-  }
-  validate(value, path, context) {
-    if (value > this.maximum) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, value.toISOString(), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { assertValidDate, isNumber } from '../../utils/type-guards.js';
+import { createSchemaValueConstraintDecorator } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { typeSchema } from '../types/types.js';
+export class MaximumDateConstraint extends SchemaValueConstraint {
+    maximum;
+    suitableTypes = Number;
+    expects;
+    constructor(maximum) {
+        super();
+        this.maximum = isNumber(maximum) ? new Date(maximum) : maximum;
+        this.expects = `<= ${this.maximum.toISOString()}`;
+        assertValidDate(this.maximum);
+    }
+    validate(value, path, context) {
+        if (value > this.maximum) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toISOString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function MaximumDate(maximum) {
-  return (0, import_decorators.createSchemaValueConstraintDecorator)(new MaximumDateConstraint(maximum), { schema: (0, import_types.typeSchema)(Number) });
+export function MaximumDate(maximum) {
+    return createSchemaValueConstraintDecorator(new MaximumDateConstraint(maximum), { schema: typeSchema(Number) });
 }

package/schema/constraints/maximum-length.js

@@ -1,48 +1,25 @@
-"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, {
-  MaximumLength: () => MaximumLength,
-  MaximumLengthConstraint: () => MaximumLengthConstraint
-});
-module.exports = __toCommonJS(maximum_length_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_utils = require("../decorators/utils.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-class MaximumLengthConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  maximumLength;
-  suitableTypes = [String, Array, ArrayBuffer, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
-  expects;
-  constructor(maximumLength) {
-    super();
-    this.maximumLength = maximumLength;
-    this.expects = `a maximum length of ${this.maximumLength}`;
-  }
-  validate(value, path, context) {
-    const length = (0, import_type_guards.isArrayBuffer)(value) || (0, import_type_guards.isArrayBufferView)(value) ? value.byteLength : value.length;
-    if (length > this.maximumLength) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, `a length of ${length}`, path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { isArrayBuffer, isArrayBufferView } from '../../utils/type-guards.js';
+import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+export class MaximumLengthConstraint extends SchemaValueConstraint {
+    maximumLength;
+    suitableTypes = [String, Array, ArrayBuffer, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+    expects;
+    constructor(maximumLength) {
+        super();
+        this.maximumLength = maximumLength;
+        this.expects = `a maximum length of ${this.maximumLength}`;
+    }
+    validate(value, path, context) {
+        const length = (isArrayBuffer(value) || isArrayBufferView(value)) ? value.byteLength : value.length;
+        if (length > this.maximumLength) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, `a length of ${length}`, path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function MaximumLength(maximumLength) {
-  return (0, import_utils.createSchemaValueConstraintDecorator)(new MaximumLengthConstraint(maximumLength));
+export function MaximumLength(maximumLength) {
+    return createSchemaValueConstraintDecorator(new MaximumLengthConstraint(maximumLength));
 }

package/schema/constraints/maximum.js

@@ -1,47 +1,24 @@
-"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_exports = {};
-__export(maximum_exports, {
-  Maximum: () => Maximum,
-  MaximumConstraint: () => MaximumConstraint
-});
-module.exports = __toCommonJS(maximum_exports);
-var import_decorators = require("../decorators/index.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_types = require("../types/types.js");
-class MaximumConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  maximum;
-  suitableTypes = Number;
-  expects;
-  constructor(maximum) {
-    super();
-    this.maximum = maximum;
-    this.expects = `<= ${this.maximum}`;
-  }
-  validate(value, path, context) {
-    if (value > this.maximum) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaValueConstraintDecorator } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { typeSchema } from '../types/types.js';
+export class MaximumConstraint extends SchemaValueConstraint {
+    maximum;
+    suitableTypes = Number;
+    expects;
+    constructor(maximum) {
+        super();
+        this.maximum = maximum;
+        this.expects = `<= ${this.maximum}`;
+    }
+    validate(value, path, context) {
+        if (value > this.maximum) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function Maximum(maximum) {
-  return (0, import_decorators.createSchemaValueConstraintDecorator)(new MaximumConstraint(maximum), { schema: (0, import_types.typeSchema)(Number) });
+export function Maximum(maximum) {
+    return createSchemaValueConstraintDecorator(new MaximumConstraint(maximum), { schema: typeSchema(Number) });
 }

package/schema/constraints/minimum-date.js

@@ -1,49 +1,26 @@
-"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_date_exports = {};
-__export(minimum_date_exports, {
-  MinimumDate: () => MinimumDate,
-  MinimumDateConstraint: () => MinimumDateConstraint
-});
-module.exports = __toCommonJS(minimum_date_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_decorators = require("../decorators/index.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_types = require("../types/types.js");
-class MinimumDateConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  minimum;
-  suitableTypes = Number;
-  expects;
-  constructor(minimum) {
-    super();
-    this.minimum = (0, import_type_guards.isNumber)(minimum) ? new Date(minimum) : minimum;
-    this.expects = `>= ${this.minimum.toISOString()}`;
-    (0, import_type_guards.assertValidDate)(this.minimum);
-  }
-  validate(value, path, context) {
-    if (value > this.minimum) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, value.toISOString(), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { assertValidDate, isNumber } from '../../utils/type-guards.js';
+import { createSchemaValueConstraintDecorator } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { typeSchema } from '../types/types.js';
+export class MinimumDateConstraint extends SchemaValueConstraint {
+    minimum;
+    suitableTypes = Number;
+    expects;
+    constructor(minimum) {
+        super();
+        this.minimum = isNumber(minimum) ? new Date(minimum) : minimum;
+        this.expects = `>= ${this.minimum.toISOString()}`;
+        assertValidDate(this.minimum);
+    }
+    validate(value, path, context) {
+        if (value > this.minimum) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toISOString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function MinimumDate(minimum) {
-  return (0, import_decorators.createSchemaValueConstraintDecorator)(new MinimumDateConstraint(minimum), { schema: (0, import_types.typeSchema)(Number) });
+export function MinimumDate(minimum) {
+    return createSchemaValueConstraintDecorator(new MinimumDateConstraint(minimum), { schema: typeSchema(Number) });
 }

package/schema/constraints/minimum-length.js

@@ -1,48 +1,25 @@
-"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, {
-  MinimumLength: () => MinimumLength,
-  MinimumLengthConstraint: () => MinimumLengthConstraint
-});
-module.exports = __toCommonJS(minimum_length_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_utils = require("../decorators/utils.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-class MinimumLengthConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  minimumLength;
-  suitableTypes = [String, Array, ArrayBuffer, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
-  expects;
-  constructor(minimumLength) {
-    super();
-    this.minimumLength = minimumLength;
-    this.expects = `a minimum length of ${this.minimumLength}`;
-  }
-  validate(value, path, context) {
-    const length = (0, import_type_guards.isArrayBuffer)(value) || (0, import_type_guards.isArrayBufferView)(value) ? value.byteLength : value.length;
-    if (length < this.minimumLength) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, `a length of ${length}`, path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { isArrayBuffer, isArrayBufferView } from '../../utils/type-guards.js';
+import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+export class MinimumLengthConstraint extends SchemaValueConstraint {
+    minimumLength;
+    suitableTypes = [String, Array, ArrayBuffer, Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+    expects;
+    constructor(minimumLength) {
+        super();
+        this.minimumLength = minimumLength;
+        this.expects = `a minimum length of ${this.minimumLength}`;
+    }
+    validate(value, path, context) {
+        const length = (isArrayBuffer(value) || isArrayBufferView(value)) ? value.byteLength : value.length;
+        if (length < this.minimumLength) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, `a length of ${length}`, path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function MinimumLength(minimumLength) {
-  return (0, import_utils.createSchemaValueConstraintDecorator)(new MinimumLengthConstraint(minimumLength));
+export function MinimumLength(minimumLength) {
+    return createSchemaValueConstraintDecorator(new MinimumLengthConstraint(minimumLength));
 }

package/schema/constraints/minimum.js

@@ -1,47 +1,24 @@
-"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_exports = {};
-__export(minimum_exports, {
-  Minimum: () => Minimum,
-  MinimumConstraint: () => MinimumConstraint
-});
-module.exports = __toCommonJS(minimum_exports);
-var import_utils = require("../decorators/utils.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_types = require("../types/types.js");
-class MinimumConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  minimum;
-  suitableTypes = Number;
-  expects;
-  constructor(minimum) {
-    super();
-    this.minimum = minimum;
-    this.expects = `>= ${this.minimum}`;
-  }
-  validate(value, path, context) {
-    if (value < this.minimum) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { typeSchema } from '../types/types.js';
+export class MinimumConstraint extends SchemaValueConstraint {
+    minimum;
+    suitableTypes = Number;
+    expects;
+    constructor(minimum) {
+        super();
+        this.minimum = minimum;
+        this.expects = `>= ${this.minimum}`;
+    }
+    validate(value, path, context) {
+        if (value < this.minimum) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function Minimum(minimum) {
-  return (0, import_utils.createSchemaValueConstraintDecorator)(new MinimumConstraint(minimum), { schema: (0, import_types.typeSchema)(Number) });
+export function Minimum(minimum) {
+    return createSchemaValueConstraintDecorator(new MinimumConstraint(minimum), { schema: typeSchema(Number) });
 }

package/schema/constraints/pattern.js

@@ -1,49 +1,26 @@
-"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 pattern_exports = {};
-__export(pattern_exports, {
-  Pattern: () => Pattern,
-  PatternConstraint: () => PatternConstraint
-});
-module.exports = __toCommonJS(pattern_exports);
-var import_utils = require("../decorators/utils.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_types = require("../types/types.js");
-class PatternConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  pattern;
-  patternName;
-  suitableTypes = String;
-  expects;
-  constructor(pattern, patternName = "a pattern") {
-    super();
-    this.pattern = pattern;
-    this.patternName = patternName;
-    this.expects = `matching ${this.patternName}`;
-  }
-  validate(value, path, context) {
-    if (!this.pattern.test(value)) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, `"${value}"`, path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { typeSchema } from '../types/types.js';
+export class PatternConstraint extends SchemaValueConstraint {
+    pattern;
+    patternName;
+    suitableTypes = String;
+    expects;
+    constructor(pattern, patternName = 'a pattern') {
+        super();
+        this.pattern = pattern;
+        this.patternName = patternName;
+        this.expects = `matching ${this.patternName}`;
+    }
+    validate(value, path, context) {
+        if (!this.pattern.test(value)) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, `"${value}"`, path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-function Pattern(pattern, patternName) {
-  return (0, import_utils.createSchemaValueConstraintDecorator)(new PatternConstraint(pattern, patternName), { schema: (0, import_types.typeSchema)(String) });
+export function Pattern(pattern, patternName) {
+    return createSchemaValueConstraintDecorator(new PatternConstraint(pattern, patternName), { schema: typeSchema(String) });
 }

package/schema/decorators/class.js

@@ -1,27 +1,5 @@
-"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 class_exports = {};
-__export(class_exports, {
-  Class: () => Class
-});
-module.exports = __toCommonJS(class_exports);
-var import_reflection = require("../../reflection/index.js");
-function Class(options = {}) {
-  return (0, import_reflection.createClassDecorator)({ data: { schema: options }, mergeData: true });
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createClassDecorator } from '../../reflection/index.js';
+export function Class(options = {}) {
+    return createClassDecorator({ data: { schema: options }, mergeData: true });
 }

package/schema/decorators/coerce.js

@@ -1,27 +1,5 @@
-"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 coerce_exports = {};
-__export(coerce_exports, {
-  Coerce: () => Coerce
-});
-module.exports = __toCommonJS(coerce_exports);
-var import_utils = require("./utils.js");
-function Coerce() {
-  return (0, import_utils.createSchemaPropertyDecorator)({ coerce: true });
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaPropertyDecorator } from './utils.js';
+export function Coerce() {
+    return createSchemaPropertyDecorator({ coerce: true });
 }

package/schema/decorators/constraint.js

@@ -1,29 +1,7 @@
-"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 constraint_exports = {};
-__export(constraint_exports, {
-  Constraint: () => Constraint
-});
-module.exports = __toCommonJS(constraint_exports);
-var import_generic = require("../constraints/generic.js");
-var import_utils = require("./utils.js");
-function Constraint(constraintFunction, expects) {
-  const constraint = new import_generic.GenericConstraint(constraintFunction, expects);
-  return (0, import_utils.createSchemaValueConstraintDecorator)(constraint);
+import { GenericConstraint } from '../constraints/generic.js';
+import { createSchemaValueConstraintDecorator } from './utils.js';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function Constraint(constraintFunction, expects) {
+    const constraint = new GenericConstraint(constraintFunction, expects);
+    return createSchemaValueConstraintDecorator(constraint);
 }