preconditions 3.0.2 → 4.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+    branches: [master, main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [24.x, 25.x]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v6
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+      - run: npm install
+      - run: npm test

package/README.md

@@ -2,7 +2,7 @@
 
 [![view on npm](http://img.shields.io/npm/v/preconditions.svg)](https://www.npmjs.org/package/preconditions)
 [![npm module downloads](http://img.shields.io/npm/dt/preconditions.svg)](https://www.npmjs.org/package/preconditions)
-[![Build Status](https://travis-ci.org/corybill/preconditions.svg?branch=master)](https://travis-ci.org/corybill/Preconditions)
+[![CI](https://github.com/corybill/preconditions/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/corybill/preconditions/actions/workflows/ci.yml)
 [![Gitter](https://badges.gitter.im/corybill/preconditions.svg)](https://gitter.im/corybill/preconditions?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 
 #### Support for Precondition error checking in Node.js

package/eslint.config.js

@@ -0,0 +1,32 @@
+import js from "@eslint/js";
+import globals from "globals";
+
+export default [
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2024,
+      sourceType: "module",
+      globals: {
+        ...globals.node,
+        ...globals.mocha
+      }
+    },
+    rules: {
+      "indent": ["error", 2, { "SwitchCase": 1 }],
+      "quotes": ["error", "double"],
+      "semi": ["error", "always"],
+      "no-var": "error",
+      "prefer-const": "error",
+      "eqeqeq": ["error", "smart"],
+      "curly": ["error", "all"],
+      "no-throw-literal": "warn"
+    }
+  },
+  {
+    files: ["spec/**/*.js"],
+    rules: {
+      "prefer-const": "off"
+    }
+  }
+];

package/lib/constants.js

@@ -1,43 +1,43 @@
-exports.ShouldBeDefined = "Variable should be defined.";
-exports.ShouldBeUndefined = "Variable should be undefined.";
+export const ShouldBeDefined = "Variable should be defined.";
+export const ShouldBeUndefined = "Variable should be undefined.";
 
-exports.ShouldBeArray = "Variable should be of type Array.";
-exports.ShouldNotBeArray = "Variable should NOT be of type Array.";
+export const ShouldBeArray = "Variable should be of type Array.";
+export const ShouldNotBeArray = "Variable should NOT be of type Array.";
 
-exports.ShouldBeObject = "Variable should be of type Object.";
-exports.ShouldNotBeObject = "Variable should NOT be of type Object.";
+export const ShouldBeObject = "Variable should be of type Object.";
+export const ShouldNotBeObject = "Variable should NOT be of type Object.";
 
-exports.ShouldBeEmpty = "Array or object should be empty.";
-exports.ShouldNotBeEmpty = "Array or object should NOT be empty.";
+export const ShouldBeEmpty = "Array or object should be empty.";
+export const ShouldNotBeEmpty = "Array or object should NOT be empty.";
 
-exports.ShouldBeFunction = "Variable should be a Function.";
-exports.ShouldNotBeFunction = "Variable should NOT be a Function.";
+export const ShouldBeFunction = "Variable should be a Function.";
+export const ShouldNotBeFunction = "Variable should NOT be a Function.";
 
-exports.ShouldBeString = "Variable should be a String.";
-exports.ShouldNotBeString = "Variable should NOT be a String.";
+export const ShouldBeString = "Variable should be a String.";
+export const ShouldNotBeString = "Variable should NOT be a String.";
 
-exports.ShouldBeNumber = "Variable should be a Number.";
-exports.ShouldNotBeNumber = "Variable should NOT be a Number.";
+export const ShouldBeNumber = "Variable should be a Number.";
+export const ShouldNotBeNumber = "Variable should NOT be a Number.";
 
-exports.ShouldBeFinite = "Variable should be Finite (i.e. not infinity).";
-exports.ShouldBeInfinite = "Variable should be Infinite.";
+export const ShouldBeFinite = "Variable should be Finite (i.e. not infinity).";
+export const ShouldBeInfinite = "Variable should be Infinite.";
 
-exports.ShouldBeBoolean = "Variable should be a Boolean.";
-exports.ShouldNotBeBoolean = "Variable should NOT be a Boolean.";
+export const ShouldBeBoolean = "Variable should be a Boolean.";
+export const ShouldNotBeBoolean = "Variable should NOT be a Boolean.";
 
-exports.ShouldBeDate = "Variable should be a Date.";
-exports.ShouldNotBeDate = "Variable should NOT be a Date.";
+export const ShouldBeDate = "Variable should be a Date.";
+export const ShouldNotBeDate = "Variable should NOT be a Date.";
 
-exports.ShouldBeRegExp = "Variable should be a RegExp.";
-exports.ShouldNotBeRegExp = "Variable should NOT be a RegExp.";
+export const ShouldBeRegExp = "Variable should be a RegExp.";
+export const ShouldNotBeRegExp = "Variable should NOT be a RegExp.";
 
-exports.ShouldBeFalsey = "Variable should be falsey.";
-exports.ShouldNotBeFalsey = "Variable should NOT be falsey.";
+export const ShouldBeFalsey = "Variable should be falsey.";
+export const ShouldNotBeFalsey = "Variable should NOT be falsey.";
 
-exports.IllegalArgument = "Illegal Argument.";
-exports.IllegalState = "Illegal State.";
+export const IllegalArgument = "Illegal Argument.";
+export const IllegalState = "Illegal State.";
 
-exports.ShouldHaveValidIndex = "Index should be between between 0 (inclusive) and size (exclusive).";
-exports.ShouldHaveValidPosition = "Index should be between index between 0 (inclusive) and size (inclusive).";
-exports.ShouldHaveValidPositions = "Start and End should be between valid sub range between 0 (inclusive) and size (inclusive).";
-exports.StartBeforeEnd = "Start value should be less than the end value.";
+export const ShouldHaveValidIndex = "Index should be between between 0 (inclusive) and size (exclusive).";
+export const ShouldHaveValidPosition = "Index should be between index between 0 (inclusive) and size (inclusive).";
+export const ShouldHaveValidPositions = "Start and End should be between valid sub range between 0 (inclusive) and size (inclusive).";
+export const StartBeforeEnd = "Start value should be less than the end value.";

package/lib/err/instance-validator.js

@@ -1,6 +1,4 @@
-"use strict";
-
-var errValidation = require("./singleton-validator");
+import errValidation from "./singleton-validator.js";
 
 /**
  *
@@ -21,10 +19,10 @@ class InstanceValidator {
   }
 
   _validate_(configPath, verification, message) {
-    var variables = configPath.split(".");
+    const variables = configPath.split(".");
 
-    var current = this.out || {};
-    var count = 0;
+    let current = this.out || {};
+    let count = 0;
 
     variables.forEach((variable) => {
       // If statement needed because we need to be able to verify shouldBeUndefined.
@@ -541,4 +539,4 @@ class InstanceValidator {
   }
 }
 
-module.exports = InstanceValidator;
+export default InstanceValidator;

package/lib/err/singleton-validator.js

@@ -1,9 +1,14 @@
-"use strict";
+import { format } from "node:util";
 
-var constants = require("./../constants"),
-  validate = require("../validator/validate");
+import * as constants from "../constants.js";
+import validate from "../validator/validate.js";
 
-var util = require("util");
+function formatMessage(message, template) {
+  if (template === undefined) {
+    return message;
+  }
+  return format(message, ...template);
+}
 
 /**
  * Validate single value with a chainable interface.
@@ -23,10 +28,7 @@ class SingletonValidator {
    */
   static shouldBeDefined(val, message, template) {
     if (validate.shouldBeDefined(val)) {
-      var msg = message || constants.ShouldBeDefined;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeDefined, template));
     }
     return this;
   }
@@ -41,10 +43,7 @@ class SingletonValidator {
    */
   static shouldBeUndefined(val, message, template) {
     if (validate.shouldBeUndefined(val)) {
-      var msg = message || constants.ShouldBeUndefined;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeUndefined, template));
     }
     return this;
   }
@@ -59,10 +58,7 @@ class SingletonValidator {
    */
   static shouldBeArray(val, message, template) {
     if (validate.shouldBeArray(val)) {
-      var msg = message || constants.ShouldBeArray;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeArray, template));
     }
     return this;
   }
@@ -77,10 +73,7 @@ class SingletonValidator {
    */
   static shouldNotBeArray(val, message, template) {
     if (validate.shouldNotBeArray(val)) {
-      var msg = message || constants.ShouldNotBeArray;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeArray, template));
     }
     return this;
   }
@@ -95,10 +88,7 @@ class SingletonValidator {
    */
   static shouldBeObject(val, message, template) {
     if (validate.shouldBeObject(val)) {
-      var msg = message || constants.ShouldBeObject;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeObject, template));
     }
     return this;
   }
@@ -113,10 +103,7 @@ class SingletonValidator {
    */
   static shouldNotBeObject(val, message, template) {
     if (validate.shouldNotBeObject(val)) {
-      var msg = message || constants.ShouldNotBeObject;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeObject, template));
     }
     return this;
   }
@@ -131,10 +118,7 @@ class SingletonValidator {
    */
   static shouldBeEmpty(val, message, template) {
     if (validate.shouldBeEmpty(val)) {
-      var msg = message || constants.ShouldBeEmpty;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeEmpty, template));
     }
     return this;
   }
@@ -149,10 +133,7 @@ class SingletonValidator {
    */
   static shouldNotBeEmpty(val, message, template) {
     if (validate.shouldNotBeEmpty(val)) {
-      var msg = message || constants.ShouldNotBeEmpty;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeEmpty, template));
     }
     return this;
   }
@@ -167,10 +148,7 @@ class SingletonValidator {
    */
   static shouldBeFunction(val, message, template) {
     if (validate.shouldBeFunction(val)) {
-      var msg = message || constants.ShouldBeFunction;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeFunction, template));
     }
     return this;
   }
@@ -185,10 +163,7 @@ class SingletonValidator {
    */
   static shouldNotBeFunction(val, message, template) {
     if (validate.shouldNotBeFunction(val)) {
-      var msg = message || constants.ShouldNotBeFunction;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeFunction, template));
     }
     return this;
   }
@@ -203,10 +178,7 @@ class SingletonValidator {
    */
   static shouldBeString(val, message, template) {
     if (validate.shouldBeString(val)) {
-      var msg = message || constants.ShouldBeString;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeString, template));
     }
     return this;
   }
@@ -221,10 +193,7 @@ class SingletonValidator {
    */
   static shouldNotBeString(val, message, template) {
     if (validate.shouldNotBeString(val)) {
-      var msg = message || constants.ShouldNotBeString;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeString, template));
     }
     return this;
   }
@@ -239,10 +208,7 @@ class SingletonValidator {
    */
   static shouldBeNumber(val, message, template) {
     if (validate.shouldBeNumber(val)) {
-      var msg = message || constants.ShouldBeNumber;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeNumber, template));
     }
     return this;
   }
@@ -257,10 +223,7 @@ class SingletonValidator {
    */
   static shouldNotBeNumber(val, message, template) {
     if (validate.shouldNotBeNumber(val)) {
-      var msg = message || constants.ShouldNotBeNumber;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeNumber, template));
     }
     return this;
   }
@@ -275,10 +238,7 @@ class SingletonValidator {
    */
   static shouldBeFinite(val, message, template) {
     if (validate.shouldBeFinite(val)) {
-      var msg = message || constants.ShouldBeFinite;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeFinite, template));
     }
     return this;
   }
@@ -293,10 +253,7 @@ class SingletonValidator {
    */
   static shouldBeInfinite(val, message, template) {
     if (validate.shouldBeInfinite(val)) {
-      var msg = message || constants.ShouldBeInfinite;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeInfinite, template));
     }
     return this;
   }
@@ -311,10 +268,7 @@ class SingletonValidator {
    */
   static shouldBeBoolean(val, message, template) {
     if (validate.shouldBeBoolean(val)) {
-      var msg = message || constants.ShouldBeBoolean;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeBoolean, template));
     }
     return this;
   }
@@ -329,10 +283,7 @@ class SingletonValidator {
    */
   static shouldNotBeBoolean(val, message, template) {
     if (validate.shouldNotBeBoolean(val)) {
-      var msg = message || constants.ShouldNotBeBoolean;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeBoolean, template));
     }
     return this;
   }
@@ -347,10 +298,7 @@ class SingletonValidator {
    */
   static shouldBeDate(val, message, template) {
     if (validate.shouldBeDate(val)) {
-      var msg = message || constants.ShouldBeDate;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeDate, template));
     }
     return this;
   }
@@ -365,10 +313,7 @@ class SingletonValidator {
    */
   static shouldNotBeDate(val, message, template) {
     if (validate.shouldNotBeDate(val)) {
-      var msg = message || constants.ShouldNotBeDate;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeDate, template));
     }
     return this;
   }
@@ -383,10 +328,7 @@ class SingletonValidator {
    */
   static shouldBeRegExp(val, message, template) {
     if (validate.shouldBeRegExp(val)) {
-      var msg = message || constants.ShouldBeRegExp;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeRegExp, template));
     }
     return this;
   }
@@ -401,10 +343,7 @@ class SingletonValidator {
    */
   static shouldNotBeRegExp(val, message, template) {
     if (validate.shouldNotBeRegExp(val)) {
-      var msg = message || constants.ShouldNotBeRegExp;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeRegExp, template));
     }
     return this;
   }
@@ -419,10 +358,7 @@ class SingletonValidator {
    */
   static shouldBeFalsey(val, message, template) {
     if (validate.shouldBeFalsey(val)) {
-      var msg = message || constants.ShouldBeFalsey;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldBeFalsey, template));
     }
     return this;
   }
@@ -437,10 +373,7 @@ class SingletonValidator {
    */
   static shouldNotBeFalsey(val, message, template) {
     if (validate.shouldNotBeFalsey(val)) {
-      var msg = message || constants.ShouldNotBeFalsey;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldNotBeFalsey, template));
     }
     return this;
   }
@@ -503,10 +436,7 @@ class SingletonValidator {
    */
   static checkArgument(expression, message, template) {
     if (validate.checkArgument(expression)) {
-      var msg = message || constants.IllegalArgument;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.IllegalArgument, template));
     }
     return this;
   }
@@ -521,10 +451,7 @@ class SingletonValidator {
    */
   static checkState(expression, message, template) {
     if (validate.checkState(expression)) {
-      var msg = message || constants.IllegalState;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.IllegalState, template));
     }
     return this;
   }
@@ -540,10 +467,7 @@ class SingletonValidator {
    */
   static checkElementIndex(index, size, message, template) {
     if (validate.checkElementIndex(index, size)) {
-      var msg = message || constants.ShouldHaveValidIndex;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldHaveValidIndex, template));
     }
     return this;
   }
@@ -559,10 +483,7 @@ class SingletonValidator {
    */
   static checkPositionIndex(index, size, message, template) {
     if (validate.checkPositionIndex(index, size)) {
-      var msg = message || constants.ShouldHaveValidPosition;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldHaveValidPosition, template));
     }
     return this;
   }
@@ -579,13 +500,10 @@ class SingletonValidator {
    */
   static checkPositionIndexes(start, end, size, message, template) {
     if (validate.checkPositionIndexes(start, end, size)) {
-      var msg = message || constants.ShouldHaveValidPositions;
-
-      msg = (template === undefined) ? msg : util.format.apply(this, [msg].concat(template));
-      throw new Error(msg);
+      throw new Error(formatMessage(message || constants.ShouldHaveValidPositions, template));
     }
     return this;
   }
 }
 
-module.exports = SingletonValidator;
+export default SingletonValidator;

package/lib/errr/decorator.js

@@ -1,6 +1,4 @@
-"use strict";
-
-const Errr = require("errr");
+import Errr from "errr";
 
 /**
  * Error Builder allows you to use optional functions to build an error object.  The error can have appended stack traces and debug params to assist with debugging.
@@ -61,7 +59,7 @@ class ErrrDecorator {
   setAll(object) {
     const keys = Object.keys(object);
 
-    for (let key of keys) {
+    for (const key of keys) {
       this._setValues_.push({ key, value: object[key] });
     }
 
@@ -84,7 +82,7 @@ class ErrrDecorator {
    */
   test() {
     if (this._failsTest_()) {
-      let errr = Errr.newError(this._message_, this._templateParams_)
+      const errr = Errr.newError(this._message_, this._templateParams_)
         .debug(this._debugParams_, this._shouldDebug_)
         .appendTo(this._appendTo_);
 
@@ -99,9 +97,9 @@ class ErrrDecorator {
   /**
    * Synonym for the test function.
    */
-  t() { // eslint-disable-line
+  t() {  
     this.test();
   }
 }
 
-module.exports = ErrrDecorator;
+export default ErrrDecorator;

package/lib/errr/validator.js

@@ -1,8 +1,6 @@
-"use strict";
-
-var constants = require("./../constants"),
-  ErrrDecorator = require("./decorator"),
-  CoreUtilIs = require("core-util-is");
+import * as constants from "../constants.js";
+import ErrrDecorator from "./decorator.js";
+import * as typeChecks from "../util/type-checks.js";
 
 /**
  * Validate single value with a buildable interface on top of the errr node module.
@@ -23,7 +21,7 @@ class ErrrValidator {
    */
   static shouldBeDefined(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isUndefined(val);
+      return typeChecks.isUndefined(val);
     }
 
     message = message || constants.ShouldBeDefined;
@@ -39,7 +37,7 @@ class ErrrValidator {
    */
   static shouldBeUndefined(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isUndefined(val);
+      return !typeChecks.isUndefined(val);
     }
 
     message = message || constants.ShouldBeUndefined;
@@ -56,7 +54,7 @@ class ErrrValidator {
    */
   static shouldBeArray(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isArray(val);
+      return !typeChecks.isArray(val);
     }
 
     message = message || constants.ShouldBeArray;
@@ -72,7 +70,7 @@ class ErrrValidator {
    */
   static shouldNotBeArray(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isArray(val);
+      return typeChecks.isArray(val);
     }
 
     message = message || constants.ShouldNotBeArray;
@@ -122,7 +120,7 @@ class ErrrValidator {
    */
   static shouldBeEmpty(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isEmpty(val);
+      return !typeChecks.isEmpty(val);
     }
 
     message = message || constants.ShouldBeEmpty;
@@ -138,7 +136,7 @@ class ErrrValidator {
    */
   static shouldNotBeEmpty(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isEmpty(val);
+      return typeChecks.isEmpty(val);
     }
 
     message = message || constants.ShouldNotBeEmpty;
@@ -155,7 +153,7 @@ class ErrrValidator {
    */
   static shouldBeFunction(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isFunction(val);
+      return !typeChecks.isFunction(val);
     }
 
     message = message || constants.ShouldBeFunction;
@@ -171,7 +169,7 @@ class ErrrValidator {
    */
   static shouldNotBeFunction(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isFunction(val);
+      return typeChecks.isFunction(val);
     }
 
     message = message || constants.ShouldNotBeFunction;
@@ -188,7 +186,7 @@ class ErrrValidator {
    */
   static shouldBeString(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isString(val);
+      return !typeChecks.isString(val);
     }
 
     message = message || constants.ShouldBeString;
@@ -204,7 +202,7 @@ class ErrrValidator {
    */
   static shouldNotBeString(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isString(val);
+      return typeChecks.isString(val);
     }
 
     message = message || constants.ShouldNotBeString;
@@ -221,7 +219,7 @@ class ErrrValidator {
    */
   static shouldBeNumber(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isNumber(val);
+      return !typeChecks.isNumber(val);
     }
 
     message = message || constants.ShouldBeNumber;
@@ -237,7 +235,7 @@ class ErrrValidator {
    */
   static shouldNotBeNumber(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isNumber(val);
+      return typeChecks.isNumber(val);
     }
 
     message = message || constants.ShouldNotBeNumber;
@@ -254,7 +252,7 @@ class ErrrValidator {
    */
   static shouldBeFinite(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isFinite(val);
+      return !typeChecks.isFinite(val);
     }
 
     message = message || constants.ShouldBeFinite;
@@ -270,7 +268,7 @@ class ErrrValidator {
    */
   static shouldBeInfinite(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isFinite(val);
+      return typeChecks.isFinite(val);
     }
 
     message = message || constants.ShouldBeInfinite;
@@ -287,7 +285,7 @@ class ErrrValidator {
    */
   static shouldBeBoolean(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isBoolean(val);
+      return !typeChecks.isBoolean(val);
     }
 
     message = message || constants.ShouldBeBoolean;
@@ -303,7 +301,7 @@ class ErrrValidator {
    */
   static shouldNotBeBoolean(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isBoolean(val);
+      return typeChecks.isBoolean(val);
     }
 
     message = message || constants.ShouldNotBeBoolean;
@@ -320,7 +318,7 @@ class ErrrValidator {
    */
   static shouldBeDate(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isDate(val);
+      return !typeChecks.isDate(val);
     }
 
     message = message || constants.ShouldBeDate;
@@ -336,7 +334,7 @@ class ErrrValidator {
    */
   static shouldNotBeDate(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isDate(val);
+      return typeChecks.isDate(val);
     }
 
     message = message || constants.ShouldNotBeDate;
@@ -353,7 +351,7 @@ class ErrrValidator {
    */
   static shouldBeRegExp(val, message, template) {
     function doesFail() {
-      return !CoreUtilIs.isRegExp(val);
+      return !typeChecks.isRegExp(val);
     }
 
     message = message || constants.ShouldBeRegExp;
@@ -369,7 +367,7 @@ class ErrrValidator {
    */
   static shouldNotBeRegExp(val, message, template) {
     function doesFail() {
-      return CoreUtilIs.isRegExp(val);
+      return typeChecks.isRegExp(val);
     }
 
     message = message || constants.ShouldNotBeRegExp;
@@ -541,4 +539,4 @@ class ErrrValidator {
   }
 }
 
-module.exports = ErrrValidator;
+export default ErrrValidator;

package/lib/preconditions.cjs

@@ -0,0 +1,5 @@
+"use strict";
+
+const mod = require("./preconditions.js");
+
+module.exports = mod.default ?? mod;

package/lib/preconditions.js

@@ -1,8 +1,6 @@
-"use strict";
-
-var InstanceValidator = require("./err/instance-validator"),
-  SingletonValidator = require("./err/singleton-validator"),
-  ErrrValidator = require("./errr/validator");
+import InstanceValidator from "./err/instance-validator.js";
+import SingletonValidator from "./err/singleton-validator.js";
+import ErrrValidator from "./errr/validator.js";
 
 /**
  * Preconditions entry point interface.
@@ -51,4 +49,4 @@ class Preconditions {
   }
 }
 
-module.exports = Preconditions;
+export default Preconditions;

package/lib/util/type-checks.js

@@ -0,0 +1,45 @@
+export function isUndefined(val) {
+  return val === undefined;
+}
+
+export function isArray(val) {
+  return Array.isArray(val);
+}
+
+export function isEmpty(val) {
+  if (!val) {
+    return true;
+  }
+  if (Array.isArray(val) || typeof val === "string") {
+    return val.length === 0;
+  }
+  return Object.keys(val).length === 0;
+}
+
+export function isFunction(val) {
+  return typeof val === "function";
+}
+
+export function isString(val) {
+  return typeof val === "string";
+}
+
+export function isNumber(val) {
+  return typeof val === "number";
+}
+
+export function isFinite(val) {
+  return typeof val === "number" && globalThis.isFinite(val);
+}
+
+export function isBoolean(val) {
+  return typeof val === "boolean";
+}
+
+export function isDate(val) {
+  return val instanceof Date;
+}
+
+export function isRegExp(val) {
+  return val instanceof RegExp;
+}

package/lib/validator/validate.js

@@ -1,108 +1,106 @@
-"use strict";
+import * as typeChecks from "../util/type-checks.js";
 
-var CoreUtilIs = require("core-util-is");
-
-var validate = {
-  shouldBeDefined: function (val) {
-    return CoreUtilIs.isUndefined(val);
+const validate = {
+  shouldBeDefined(val) {
+    return typeChecks.isUndefined(val);
   },
-  shouldBeUndefined: function (val) {
-    return !CoreUtilIs.isUndefined(val);
+  shouldBeUndefined(val) {
+    return !typeChecks.isUndefined(val);
   },
 
-  shouldBeArray: function (val) {
-    return !CoreUtilIs.isArray(val);
+  shouldBeArray(val) {
+    return !typeChecks.isArray(val);
   },
-  shouldNotBeArray: function (val) {
-    return CoreUtilIs.isArray(val);
+  shouldNotBeArray(val) {
+    return typeChecks.isArray(val);
   },
 
-  shouldBeObject: function (val) {
+  shouldBeObject(val) {
     return !(val !== null && (typeof val === "object" || typeof val === "function"));
   },
-  shouldNotBeObject: function (val) {
+  shouldNotBeObject(val) {
     return (val !== null && (typeof val === "object" || typeof val === "function"));
   },
 
-  shouldBeEmpty: function (val) {
-    return !CoreUtilIs.isEmpty(val);
+  shouldBeEmpty(val) {
+    return !typeChecks.isEmpty(val);
   },
-  shouldNotBeEmpty: function (val) {
-    return CoreUtilIs.isEmpty(val);
+  shouldNotBeEmpty(val) {
+    return typeChecks.isEmpty(val);
   },
 
-  shouldBeFunction: function (val) {
-    return !CoreUtilIs.isFunction(val);
+  shouldBeFunction(val) {
+    return !typeChecks.isFunction(val);
   },
-  shouldNotBeFunction: function (val) {
-    return CoreUtilIs.isFunction(val);
+  shouldNotBeFunction(val) {
+    return typeChecks.isFunction(val);
   },
 
-  shouldBeString: function (val) {
-    return !CoreUtilIs.isString(val);
+  shouldBeString(val) {
+    return !typeChecks.isString(val);
   },
-  shouldNotBeString: function (val) {
-    return CoreUtilIs.isString(val);
+  shouldNotBeString(val) {
+    return typeChecks.isString(val);
   },
 
-  shouldBeNumber: function (val) {
-    return !CoreUtilIs.isNumber(val);
+  shouldBeNumber(val) {
+    return !typeChecks.isNumber(val);
   },
-  shouldNotBeNumber: function (val) {
-    return CoreUtilIs.isNumber(val);
+  shouldNotBeNumber(val) {
+    return typeChecks.isNumber(val);
   },
 
-  shouldBeFinite: function (val) {
-    return !CoreUtilIs.isFinite(val);
+  shouldBeFinite(val) {
+    return !typeChecks.isFinite(val);
   },
-  shouldBeInfinite: function (val) {
-    return CoreUtilIs.isFinite(val);
+  shouldBeInfinite(val) {
+    return typeChecks.isFinite(val);
   },
 
-  shouldBeBoolean: function (val) {
-    return !CoreUtilIs.isBoolean(val);
+  shouldBeBoolean(val) {
+    return !typeChecks.isBoolean(val);
   },
-  shouldNotBeBoolean: function (val) {
-    return CoreUtilIs.isBoolean(val);
+  shouldNotBeBoolean(val) {
+    return typeChecks.isBoolean(val);
   },
 
-  shouldBeDate: function (val) {
-    return !CoreUtilIs.isDate(val);
+  shouldBeDate(val) {
+    return !typeChecks.isDate(val);
   },
-  shouldNotBeDate: function (val) {
-    return CoreUtilIs.isDate(val);
+  shouldNotBeDate(val) {
+    return typeChecks.isDate(val);
   },
 
-  shouldBeRegExp: function (val) {
-    return !CoreUtilIs.isRegExp(val);
+  shouldBeRegExp(val) {
+    return !typeChecks.isRegExp(val);
   },
-  shouldNotBeRegExp: function (val) {
-    return CoreUtilIs.isRegExp(val);
+  shouldNotBeRegExp(val) {
+    return typeChecks.isRegExp(val);
   },
 
-  shouldBeFalsey: function (val) {
+  shouldBeFalsey(val) {
     return !!val;
   },
-  shouldNotBeFalsey: function (val) {
+  shouldNotBeFalsey(val) {
     return !val;
   },
 
-  checkArgument: function (val) {
+  checkArgument(val) {
     return !val;
   },
-  checkState: function (val) {
+  checkState(val) {
     return !val;
   },
 
-  checkElementIndex: function (index, size) {
+  checkElementIndex(index, size) {
     return (index < 0 || index >= size);
   },
-  checkPositionIndex: function (index, size) {
+  checkPositionIndex(index, size) {
     return (index < 0 || index > size);
   },
-  checkPositionIndexes: function (start, end, size) {
+  checkPositionIndexes(start, end, size) {
     return ((end < start) || (start < 0 || end > size));
   }
 };
 
-module.exports = validate;
+export default validate;

package/package.json

@@ -1,44 +1,35 @@
 {
   "name": "preconditions",
   "author": "Cory Parrish",
-  "main": "./lib/preconditions.js",
-  "version": "3.0.2",
+  "type": "module",
+  "main": "./lib/preconditions.cjs",
+  "exports": {
+    ".": {
+      "import": "./lib/preconditions.js",
+      "require": "./lib/preconditions.cjs",
+      "default": "./lib/preconditions.js"
+    }
+  },
+  "version": "4.0.0",
   "description": "Support for Precondition error checking in Node.js.",
   "homepage": "https://github.com/corybill/preconditions",
   "bugs": {
     "url": "https://github.com/corybill/preconditions/issues"
   },
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "scripts": {
     "test": "npm run ut && npm run lint",
-    "ut": "./node_modules/mocha/bin/_mocha ./spec/unit",
+    "ut": "mocha ./spec/unit",
     "perf": "env perf=true env test=false maddox ./spec/unit",
     "uap": "env perf=true test=true maddox ./spec/unit",
-    "coverage": "./bin/maddox-cov.js",
-    "lint": "./node_modules/eslint/bin/eslint.js ./spec/ ./lib",
-    "docs": " ./node_modules/jsdoc-to-markdown/bin/cli.js \"./lib/**/*.js\" > api.md"
+    "lint": "eslint ./spec/ ./lib",
+    "docs": "jsdoc-to-markdown \"./lib/**/*.js\" > api.md"
   },
   "keywords": [
-    "StriveNine",
-    "Strive9",
     "preconditions",
     "Guava",
-    "Throw Error",
-    "Errr",
-    "Error",
-    "Error Factory",
-    "Error Builder",
-    "Stack Trace",
-    "Appendable stack trace",
-    "append stack trace",
-    "concat strack trace",
-    "concatenate strack trace",
-    "Appendable error",
-    "append error",
-    "concat error",
-    "concatenate error",
-    "Debug Params",
-    "Promise",
-    "Promise Chain",
     "errr"
   ],
   "license": "MIT",
@@ -47,15 +38,26 @@
     "url": "https://github.com/corybill/preconditions.git"
   },
   "dependencies": {
-    "core-util-is": "1.x",
-    "errr": "2.x"
+    "errr": "^5.0.0"
   },
   "devDependencies": {
-    "chai": "3.x",
-    "chance": "1.x",
-    "eslint": "7.x",
-    "jsdoc-to-markdown": "7.x",
-    "maddox": "2.x",
-    "mocha": "9.x"
+    "@eslint/js": "^9.39.1",
+    "chai": "^5.2.0",
+    "chance": "^1.1.13",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
+    "jsdoc-to-markdown": "^9.1.3",
+    "maddox": "^4.0.4",
+    "mocha": "^11.7.5"
+  },
+  "overrides": {
+    "maddox": {
+      "mocha": "$mocha"
+    },
+    "debug": "^4.4.0",
+    "diff": "^8.0.3",
+    "js-yaml": "^4.1.0",
+    "minimatch": "^9.0.5",
+    "serialize-javascript": "^7.0.5"
   }
 }

package/.eslintrc

@@ -1,145 +0,0 @@
-{
-  "rules": {
-    // common
-    "indent": [2, 2, {"SwitchCase": 1}], // specify tab or space width for your code
-    "quotes": [2, "double"], // specify whether backticks, double or single quotes should be used
-    "linebreak-style": [2, "unix"], // disallow mixed 'LF' and 'CRLF' as linebreaks
-    "semi": [2, "always"], // require or disallow use of semicolons instead of ASI
-    // errors
-    "no-extra-parens": [2, "functions"], // disallow unnecessary parentheses
-    "no-unexpected-multiline": [2], // Avoid code that looks like two expressions but is actually one
-    "valid-jsdoc": [0], // Ensure JSDoc comments are valid
-    // best practices
-    "accessor-pairs": [0], // Enforces getter/setter pairs in objects
-    "block-scoped-var": [2], // treat var statements as if they were block scoped
-    "complexity": [0], // specify the maximum cyclomatic complexity allowed in a program
-    "consistent-return": [2], // require return statements to either always or never specify values
-    "curly": [2, "all"], // specify curly brace conventions for all control statements
-    "default-case": [2], // require default case in switch statements
-    "dot-notation": [2], // encourages use of dot notation whenever possible
-    "dot-location": [2, "property"], // enforces consistent newlines before or after dots
-    "eqeqeq": [2, "smart"], // require the use of === and !==
-    "guard-for-in": [2], // make sure for-in loops have an if statement
-    "no-alert": [2], // disallow the use of alert, confirm, and prompt
-    "no-caller": [2], // disallow use of arguments.caller or arguments.callee
-    "no-div-regex": [0], // disallow division operators explicitly at beginning of regular expression
-    "no-else-return": [0], // disallow else after a return in an if
-    "no-eq-null": [2], // disallow comparisons to null without a type-checking operator
-    "no-eval": [2], // disallow use of eval()
-    "no-extend-native": [2], // disallow adding to native types
-    "no-extra-bind": [2], // disallow unnecessary function binding
-    "no-fallthrough": [2], // disallow fallthrough of case statements (recommended)
-    "no-floating-decimal": [2], // disallow the use of leading or trailing decimal points in numeric literals
-    "no-implicit-coercion": [0], // disallow the type conversions with shorter notations
-    "no-implied-eval": [2], // disallow use of eval()-like methods
-    "no-invalid-this": [0], // disallow this keywords outside of classes or class-like objects
-    "no-iterator": [2], // disallow usage of __iterator__ property
-    "no-labels": [2], // disallow use of labeled statements
-    "no-lone-blocks": [2], // disallow unnecessary nested blocks
-    "no-loop-func": [2], // disallow creation of functions within loops
-    "no-multi-spaces": [2], // disallow use of multiple spaces
-    "no-multi-str": [2], // disallow use of multiline strings
-    "no-native-reassign": [2], // disallow reassignments of native objects
-    "no-new-func": [2], // disallow use of new operator for Function object
-    "no-new-wrappers": [0], // disallows creating new instances of String,Number, and Boolean
-    "no-new": [2], // disallow use of the new operator when not part of an assignment or comparison
-    "no-octal-escape": [2], // disallow use of octal escape sequences in string literals, such as var foo = "Copyright \251";
-    "no-octal": [2], // disallow use of octal literals (recommended)
-    "no-param-reassign": [0, {"props": false}], // disallow reassignment of function parameters
-    "no-process-env": [0], // disallow use of process.env
-    "no-proto": [2], // disallow usage of __proto__ property
-    "no-redeclare": [2, {"builtinGlobals": true}], // disallow declaring the same variable more than once (recommended)
-    "no-return-assign": [0], // disallow use of assignment in return statement
-    "no-script-url": [2], // disallow use of javascript: urls.
-    "no-self-compare": [2], // disallow comparisons where both sides are exactly the same
-    "no-sequences": [2], // disallow use of the comma operator
-    "no-throw-literal": [1], // restrict what can be thrown as an exception
-    "no-unused-expressions": [2], // disallow usage of expressions in statement position
-    "no-useless-call": [2], // disallow unnecessary .call() and .apply()
-    "no-useless-concat": [2], // disallow unnecessary concatenation of literals or template literals
-    "no-void": [2], // disallow use of the void operator
-    "no-warning-comments": [0, {"terms": ["todo", "fixme"], "location": "start"}], // disallow usage of configurable warning terms in comments": [2], // e.g. TODO or FIXME
-    "no-with": [2], // disallow use of the with statement
-    "radix": [2], // require use of the second argument for parseInt()
-    "vars-on-top": [0], // require declaration of all vars at the top of their containing scope
-    "wrap-iife": [2], // require immediate function invocation to be wrapped in parentheses
-    "yoda": [0, "never"], // require or disallow Yoda conditions
-    // Variables
-    "init-declarations": [0], // enforce or disallow variable initializations at definition
-    "no-catch-shadow": [0], // disallow the catch clause parameter name being the same as a variable in the outer scope
-    "no-delete-var": [2], // disallow deletion of variables (recommended)
-    "no-label-var": [2], // disallow labels that share a name with a variable
-    "no-shadow-restricted-names": [2], // disallow shadowing of names such as arguments
-    "no-shadow": [2], // disallow declaration of variables already declared in the outer scope
-    "no-undef-init": [2], // disallow use of undefined when initializing variables
-    "no-undef": [2], // disallow use of undeclared variables unless mentioned in a /*global */ block (recommended)
-    "no-undefined": [0], // disallow use of undefined variable
-    "no-unused-vars": [2], // disallow declaration of variables that are not used in the code (recommended)
-    "no-use-before-define": [2, "nofunc"], // disallow use of variables before they are defined
-    // nodejs
-    "callback-return": [2, ["callback", "cb", "next"]], // enforce return after a callback
-    "handle-callback-err": [2, "^(err\\d?|error\\d?|^.+Err$|^.+Error$)$"], // enforce error handling in callbacks
-    "no-mixed-requires": [2, false], // disallow mixing regular variable and require declarations
-    "no-new-require": [2], // disallow use of new operator with the require function
-    "no-path-concat": [2], // disallow string concatenation with __dirname and __filename
-    "no-process-exit": [0], // disallow process.exit()
-    "no-restricted-modules": [0], // restrict usage of specified node modules
-    "no-sync": [2], // disallow use of synchronous methods
-    // Stylistic
-    "array-bracket-spacing": [2, "never"], // enforce spacing inside array brackets
-    "block-spacing": [2, "never"], // disallow or enforce spaces inside of single line blocks
-    "brace-style": [2, "1tbs", { "allowSingleLine": true }], // enforce one true brace style
-    "camelcase": [2, {"properties": "always"}], // require camel case names
-    "comma-spacing": [2, {"before": false, "after": true}], // enforce spacing before and after comma
-    "comma-style": [2, "last"], // enforce one true comma style
-    "computed-property-spacing": [2, "never"], // require or disallow padding inside computed properties
-    "consistent-this": [2, "self"], // enforce consistent naming when capturing the current execution context
-    "eol-last": [2], // enforce newline at the end of file, with no multiple empty lines
-    "func-names": [0], // require function expressions to have a name
-    "func-style": [2, "declaration"], // enforce use of function declarations or expressions
-    "id-length": [2, {"min": 3, "properties": "never", "exceptions": ["Q", "q", "_", "cb", "id", "i", "j"]}], // this option enforces minimum and maximum identifier lengths (variable names, property names etc.)
-    "id-match": [0], // require identifiers to match the provided regular expression
-    "key-spacing": [2, {"beforeColon": false, "afterColon": true}], // enforce spacing between keys and values in object literal properties
-    "keyword-spacing": [2, {}], // require a space after certain keywords
-    "lines-around-comment": [0], // enforce empty lines around comments
-    "max-nested-callbacks": [2, 6], // specify the maximum depth callbacks can be nested
-    "new-cap": [2, {"capIsNewExceptions": ["Router"]}], // require a capital letter for constructors
-    "new-parens": [2], // disallow the omission of parentheses when invoking a constructor with no arguments
-    "newline-after-var": [2, "always"], // require or disallow an empty newline after variable declarations
-    "no-array-constructor": [2], // disallow use of the Array constructor
-    "no-continue": [2], // disallow use of the continue statement
-    "no-inline-comments": [0], // disallow comments inline after code
-    "no-lonely-if": [0], // disallow if as the only statement in an else block
-    "no-mixed-spaces-and-tabs": [2], // disallow mixed spaces and tabs for indentation (recommended)
-    "no-multiple-empty-lines": [2, {"max": 1}], // disallow multiple empty lines
-    "no-nested-ternary": [2], // disallow nested ternary expressions
-    "no-new-object": [2], // disallow the use of the Object constructor
-    "no-spaced-func": [2], // disallow space between function identifier and application
-    "no-ternary": [0], // disallow the use of ternary operators
-    "no-trailing-spaces": [2, { "skipBlankLines": true }], // disallow trailing whitespace at the end of lines
-    "no-underscore-dangle": [0], // disallow dangling underscores in identifiers
-    "no-unneeded-ternary": [2], // disallow the use of Boolean literals in conditional expressions
-    "object-curly-spacing": [2, "always"], // require or disallow padding inside curly braces
-    "one-var": [0], // require or disallow one variable declaration per function
-    "operator-assignment": [0], // require assignment operator shorthand where possible or prohibit it entirely
-    "operator-linebreak": [2, "after"], // enforce operators to be placed before or after line breaks
-    "padded-blocks": [0, "never"], // enforce padding within blocks
-    "quote-props": [2, "consistent"], // require quotes around object literal property names
-    "semi-spacing": [2, {"before": false, "after": true}], // enforce spacing before and after semicolons
-    "sort-vars": [0], // sort variables within the same declaration block
-    "space-before-blocks": [2, "always"], // require or disallow a space before blocks
-    "space-before-function-paren": [2, {"anonymous": "always", "named": "never"}], // require or disallow a space before function opening parenthesis
-    "space-in-parens": [2, "never"], // require or disallow spaces inside parentheses
-    "space-infix-ops": [2, {"int32Hint": false}], // require spaces around operators
-    "space-return-throw-case": [0], // require a space after return, throw, and case
-    "space-unary-ops": [2, {"words": true, "nonwords": false}], // require or disallow spaces before/after unary operators
-    "spaced-comment": [2, "always"], // require or disallow a space immediately following the // or /* in a comment
-    "wrap-regex": [2] // require regex literals to be wrapped in parentheses
-  },
-  "env": {
-    "node": true,
-    "es6": true,
-    "mocha": true
-  },
-  "extends": "eslint:recommended"
-}

package/.travis.yml

@@ -1,16 +0,0 @@
-language: node_js
-os:
-  - linux
-dist: xenial
-node_js:
-  - lts/*
-  - 16.0
-  - 14.0
-  - 12.0
-notifications:
-  webhooks:
-    urls:
-      - https://webhooks.gitter.im/e/c27fddacc09aaa988b05
-    on_success: change  # options: [always|never|change] default: always
-    on_failure: always  # options: [always|never|change] default: always
-    on_start: never     # options: [always|never|change] default: always