type-enforcer-test-helper 1.3.8 → 1.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "type-enforcer-test-helper",
-	"version": "1.3.8",
+	"version": "1.3.10",
 	"description": "Test data and helper functions for type-enforcer and addons",
 	"keywords": [],
 	"license": "MIT",
@@ -18,7 +18,10 @@
 		"url": "https://github.com/DarrenPaulWright/type-enforcer-test-helper/issues"
 	},
 	"main": "index.js",
+	"type": "module",
+	"types": "types/index.d.ts",
 	"files": [
+		"/types",
 		"/src"
 	],
 	"badges": {
@@ -46,32 +49,33 @@
 		}
 	},
 	"scripts": {
-		"test": "karma start karma.conf.cjs --single-run",
-		"test-watch": "karma start karma.conf.cjs",
+		"test": "",
+		"test-watch": "",
 		"preversion": "npm test && npm run docs && git add --all && git diff HEAD --quiet || git commit -m \"Updating docs\"",
 		"postversion": "npm publish",
 		"postpublish": "git push --follow-tags",
 		"pre-clean": "rm -rf node_modules && del /f package-lock.json",
 		"clean": "npm run pre-clean && npm install && npm audit fix",
-		"update": "ncu -u --dep prod && git diff --quiet || npm install && npm audit fix",
+		"update": "ncu -u && git diff --quiet || npm install && npm audit fix",
 		"update-clean": "npm run pre-clean && npm run update",
 		"update-commit": "npm run update && npm test && git add --all && git diff HEAD --quiet || git commit -m \"Updating dependencies\"",
 		"update-patch": "npm run update && npm test && git add --all && git diff HEAD --quiet || git commit -m \"Updating dependencies\" && npm version patch",
 		"docs:readme": "jsdoc2md ./index.js src/**/*.js > README.md -t node_modules/dmd-readable/overview.hbs --plugin dmd-readable/overview-plugin.js",
 		"docs:main": "exec-each --out docs/{basefile}.md src/*.js jsdoc2md -- {path} -t node_modules/dmd-readable/docs.hbs --plugin dmd-readable",
 		"docs:data": "exec-each --out docs/{basefile}.md src/data/*.js jsdoc2md -- {path} -t node_modules/dmd-readable/docs.hbs --plugin dmd-readable",
+		"docs:types": "rm -rf types && tsc",
 		"docs": "run-p docs:*"
 	},
 	"dependencies": {
-		"display-value": "^1.8.5",
-		"object-agent": "^1.5.0",
-		"type-enforcer": "^1.2.1"
+		"display-value": "^2.2.0",
+		"object-agent": "^1.6.0",
+		"type-enforcer": "^1.2.4"
 	},
 	"devDependencies": {
 		"dmd-readable": "^1.2.4",
 		"exec-each": "0.0.3",
-		"jsdoc-to-markdown": "^7.0.1",
-		"karma-webpack-bundle": "^1.1.0",
-		"npm-run-all": "^4.1.5"
+		"jsdoc-to-markdown": "^8.0.0",
+		"npm-run-all": "^4.1.5",
+		"typescript": "^5.2.2"
 	}
 }

package/src/data/TestClass.js

@@ -2,7 +2,7 @@
  * @class TestClass
  * @classdesc A simple class for testing things like instanceof
  *
- * @param {*} value - Adds a property "value" to an instance of TestClass, set to the value provided.
+ * @param {unknown} value - Adds a property "value" to an instance of TestClass, set to the value provided.
  */
 export default class TestClass {
 	constructor(value) {

package/src/data/testValues.js

@@ -12,7 +12,15 @@ import TestClass from './TestClass.js';
  * @constant {Array} validArrays
  */
 const arrayReference = Array(3);
-export const validArrays = [[1], [2], [], new Array(), Array(), arrayReference];
+export const validArrays = [
+	[1],
+	[2],
+	[],
+	new Array(),
+	new Array(12),
+	Array(),
+	arrayReference
+];
 
 /**
  * Booleans instantiated in different ways or with different values.
@@ -20,7 +28,13 @@ export const validArrays = [[1], [2], [], new Array(), Array(), arrayReference];
  * @constant {Array} validBooleans
  */
 const booleanReference = Boolean();
-export const validBooleans = [true, false, new Boolean(true), booleanReference]; // eslint-disable-line no-new-wrappers
+export const validBooleans = [
+	true,
+	false,
+	new Boolean(true), // eslint-disable-line no-new-wrappers
+	Boolean(1),
+	booleanReference
+];
 
 /**
  * Dates instantiated in different ways or with different values.
@@ -28,7 +42,10 @@ export const validBooleans = [true, false, new Boolean(true), booleanReference];
  * @constant {Array} validDates
  */
 const dateReference = new Date();
-export const validDates = [dateReference, new Date('01/15/2010')];
+export const validDates = [
+	dateReference,
+	new Date('01/15/2010')
+];
 
 /**
  * Functions instantiated in different ways.
@@ -37,13 +54,15 @@ export const validDates = [dateReference, new Date('01/15/2010')];
  */
 const namedFunctionExpression = function() {
 };
-export const validFunctions = [namedFunctionExpression,
+export const validFunctions = [
+	namedFunctionExpression,
 	function namedFunctionDeclaration() {
 	},
 	function() {
 	},
 	() => {
-	}];
+	}
+];
 
 /**
  * Different instances of TestClass with different values.
@@ -51,9 +70,11 @@ export const validFunctions = [namedFunctionExpression,
  * @constant {Array} validInstances
  */
 const classReference = new TestClass(1);
-export const validInstances = [classReference,
+export const validInstances = [
+	classReference,
 	new TestClass(1),
-	new TestClass(2)];
+	new TestClass(2)
+];
 
 /**
  * Integers instantiated in different ways or with different values.
@@ -61,7 +82,12 @@ export const validInstances = [classReference,
  * @constant {Array} validIntegers
  */
 const integerReference = Number(11);
-export const validIntegers = [1, 5, new Number(42), integerReference]; // eslint-disable-line no-new-wrappers
+export const validIntegers = [
+	1,
+	5,
+	new Number(42), // eslint-disable-line no-new-wrappers
+	integerReference
+];
 
 /**
  * Floats instantiated in different ways or with different values.
@@ -69,12 +95,14 @@ export const validIntegers = [1, 5, new Number(42), integerReference]; // eslint
  * @constant {Array} validFloats
  */
 const floatReference = Number(11.3);
-export const validFloats = [1.3,
+export const validFloats = [
+	1.3,
 	2.5,
 	-10.00000001,
 	3.14159,
 	new Number(42.2), // eslint-disable-line no-new-wrappers
-	floatReference];
+	floatReference
+];
 
 /**
  * Infinity and -Infinity
@@ -82,7 +110,10 @@ export const validFloats = [1.3,
  * @constant {Array} validInfinities
  */
 const infinityReference = Infinity;
-export const validInfinities = [infinityReference, -Infinity];
+export const validInfinities = [
+	infinityReference,
+	-Infinity
+];
 
 /**
  * An empty Map and a Map with data.
@@ -90,7 +121,10 @@ export const validInfinities = [infinityReference, -Infinity];
  * @constant {Array} validMaps
  */
 const mapReference = new Map().set('test', 12);
-export const validMaps = [new Map(), mapReference];
+export const validMaps = [
+	new Map(),
+	mapReference
+];
 
 /**
  * Plain objects instantiated in different ways or with different values.
@@ -98,7 +132,12 @@ export const validMaps = [new Map(), mapReference];
  * @constant {Array} validObjects
  */
 const objectReference = Object();
-export const validObjects = [{}, { test1: 1 }, new Object(), objectReference]; // eslint-disable-line no-new-object
+export const validObjects = [
+	{},
+	{ test1: 1 },
+	new Object(), // eslint-disable-line no-new-object
+	objectReference
+];
 
 /**
  * A normal Promise and Promise.all.
@@ -118,7 +157,11 @@ export const validPromises = [
  * @constant {Array} validRegExps
  */
 const regExpReference = RegExp(); // eslint-disable-line require-unicode-regexp
-export const validRegExps = [/asdf/g, new RegExp('test 2'), regExpReference]; // eslint-disable-line require-unicode-regexp
+export const validRegExps = [
+	/asdf/g, // eslint-disable-line require-unicode-regexp
+	new RegExp('test 2'), // eslint-disable-line require-unicode-regexp
+	regExpReference
+];
 
 /**
  * An empty Set and a Set with data.
@@ -126,7 +169,10 @@ export const validRegExps = [/asdf/g, new RegExp('test 2'), regExpReference]; //
  * @constant {Array} validSets
  */
 const setReference = new Set([1, 2]);
-export const validSets = [new Set(), setReference];
+export const validSets = [
+	new Set(),
+	setReference
+];
 
 /**
  * Strings instantiated in different ways or with different values.
@@ -134,7 +180,12 @@ export const validSets = [new Set(), setReference];
  * @constant {Array} validStrings
  */
 const stringReference = String('test3');
-export const validStrings = ['test', '', new String('test2'), stringReference]; // eslint-disable-line no-new-wrappers
+export const validStrings = [
+	'test',
+	'',
+	new String('test2'), // eslint-disable-line no-new-wrappers
+	stringReference
+];
 
 /**
  * A Symbol with a label and one without.
@@ -150,7 +201,10 @@ export const validSymbols = [Symbol(), symbolReference];
  * @constant {Array} validWeakMaps
  */
 const weakMapReference = new WeakMap().set({}, 12);
-export const validWeakMaps = [new WeakMap(), weakMapReference];
+export const validWeakMaps = [
+	new WeakMap(),
+	weakMapReference
+];
 
 /**
  * An empty WeakSet and a WeakSet with data.

package/src/multiTest.js

@@ -7,13 +7,13 @@ const getMessage = (settings, assertion) => {
 		return settings.message;
 	}
 	if (assertion === 'true') {
-		return (input) => `should return true for ${displayValue(input)}`;
+		return (input) => `should return true for ${ displayValue(input) }`;
 	}
 	if (assertion === 'false') {
-		return (input) => `should return false for ${displayValue(input)}`;
+		return (input) => `should return false for ${ displayValue(input) }`;
 	}
 
-	return (input, output) => `should return ${displayValue(output)} when set to ${input}`;
+	return (input, output) => `should return ${ displayValue(output) } when set to ${ input }`;
 };
 
 /**
@@ -29,7 +29,7 @@ const getMessage = (settings, assertion) => {
  * @param {Function}     [settings.message] - Provides two or three params, the input value(s) and the expected output value. Must return a string. It is recommended to use the display-value library on values for readability.
  * @param {string}       [settings.inputKey] - If values is an array of objects, this specifies which key to get the input value from.
  * @param {string}       [settings.outputKey] - If values is an array of objects, this specifies which key to get the expected output value from.
- * @param {*}            [settings.output] - The expected output value of all tests.
+ * @param {unknown}            [settings.output] - The expected output value of all tests.
  * @param {boolean}      [settings.eachPair=false] - Values must be an array, runs tests on every combination of two items from values.
  * @param {string}       [settings.assertion='equal'] - The type-enforcer assert function to run against all tests.
  */
@@ -47,7 +47,7 @@ export default (settings) => {
 	}
 
 	const buildDoubleMessage = settings.message || ((input1, input2, output) => {
-		return `should return ${displayValue(output)} when ${displayValue(input1)} and ${displayValue(input2)} are provided`;
+		return `should return ${ displayValue(output) } when ${ displayValue(input1) } and ${ displayValue(input2) } are provided`;
 	});
 
 	const testSingleValue = (input, output, value) => {

package/src/testMethod.js

@@ -35,8 +35,8 @@ const getSymbol = Symbol();
  * @param {Array} settings.true - An array of values that are valid for this method.
  * @param {Array} settings.false - An array of values that are NOT valid for this method.
  * @param {Array|false} [settings.coerce] - An array of objects with values that can be coerced by this method.
- * @param {*} settings.coerce[].value - The value to be coerced.
- * @param {*} settings.coerce[].coerced - The expected result of coercion.
+ * @param {unknown} settings.coerce[].value - The value to be coerced.
+ * @param {unknown} settings.coerce[].coerced - The expected result of coercion.
  * @param {Array} settings.coerceTrue - Alternatively, an array of values that are coercible by this method.
  * @param {Function} thisMethod - The function to test.
  * @param {object} method - An object that includes this function.
@@ -367,7 +367,7 @@ export default function(settings, thisMethod, method) {
 		runTests(TestConstructor2, settings.true[0], settings.true[1], settings.coerce || []);
 
 		settings.false.forEach((falseValue) => {
-			it(`should return ${displayValue(settings.true[0])} after attempting to set to ${displayValue(falseValue)}`, () => {
+			it(`should return ${ displayValue(settings.true[0]) } after attempting to set to ${ displayValue(falseValue) }`, () => {
 				const testConstructor = new TestConstructor2();
 
 				testConstructor.testMethod(falseValue);
@@ -406,7 +406,7 @@ export default function(settings, thisMethod, method) {
 			});
 
 			settings.coerceTrue.forEach((value) => {
-				it(`should return coerced ${displayValue(value)} after attempting to set to ${displayValue(value)}`, () => {
+				it(`should return coerced ${ displayValue(value) } after attempting to set to ${ displayValue(value) }`, () => {
 					const testConstructor = new TestConstructor2();
 
 					testConstructor.testMethod(value);
@@ -426,7 +426,7 @@ export default function(settings, thisMethod, method) {
 			});
 
 			settings.coerceTrue.forEach((value) => {
-				it(`should return coerced ${displayValue(value)} after attempting to set to ${displayValue(value)}`, () => {
+				it(`should return coerced ${ displayValue(value) } after attempting to set to ${ displayValue(value) }`, () => {
 					const testConstructor = new TestConstructor2();
 
 					testConstructor.testMethod(value);

package/types/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./src/data/testValues.js";
+export * from "./src/data/testData.js";
+export { default as TestClass } from "./src/data/TestClass.js";
+export { default as multiTest } from "./src/multiTest.js";
+export { default as testCheck } from "./src/testCheck.js";
+export { default as testEnforce } from "./src/testEnforce.js";
+export { default as testMethod } from "./src/testMethod.js";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":""}

package/types/src/data/TestClass.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @class TestClass
+ * @classdesc A simple class for testing things like instanceof
+ *
+ * @param {unknown} value - Adds a property "value" to an instance of TestClass, set to the value provided.
+ */
+export default class TestClass {
+    constructor(value: any);
+    value: any;
+}
+//# sourceMappingURL=TestClass.d.ts.map

package/types/src/data/TestClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestClass.d.ts","sourceRoot":"","sources":["../../../src/data/TestClass.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACC,wBAEC;IADA,WAAkB;CAEnB"}

package/types/src/data/coercible.d.ts

@@ -0,0 +1,7 @@
+export const coerceArrayTrue: string[];
+export const coerceInfinity: string[];
+export const coerceIntegerTrue: string[];
+export const coerceFloatTrue: string[];
+export const coerceNumberFalse: (string | number)[];
+export const coerceObjectTrue: string[];
+//# sourceMappingURL=coercible.d.ts.map

package/types/src/data/coercible.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coercible.d.ts","sourceRoot":"","sources":["../../../src/data/coercible.js"],"names":[],"mappings":"AAAA,uCAAkD;AAElD,sCAGE;AAEF,yCAuBO;AAEP,uCAGE;AAEF,oDA6CE;AAEF,wCAA0D"}

package/types/src/data/testData.d.ts

@@ -0,0 +1,289 @@
+export namespace arrayData {
+    export let value: ArrayConstructor;
+    export let name: string;
+    export { validArrays as true };
+    let _false: any;
+    export { _false as false };
+    export { coerceArrayTrue as coerceTrue };
+    export let coerceFalse: any;
+}
+export namespace booleanData {
+    let value_1: BooleanConstructor;
+    export { value_1 as value };
+    let name_1: string;
+    export { name_1 as name };
+    export { validBooleans as true };
+    let _false_1: any;
+    export { _false_1 as false };
+    export let coerceTrue: any;
+    let coerceFalse_1: any[];
+    export { coerceFalse_1 as coerceFalse };
+}
+export namespace dateData {
+    let value_2: DateConstructor;
+    export { value_2 as value };
+    let name_2: string;
+    export { name_2 as name };
+    export { validDates as true };
+    let _false_2: any;
+    export { _false_2 as false };
+    let coerceTrue_1: string[];
+    export { coerceTrue_1 as coerceTrue };
+    let coerceFalse_2: any;
+    export { coerceFalse_2 as coerceFalse };
+}
+export namespace functionData {
+    let value_3: FunctionConstructor;
+    export { value_3 as value };
+    let name_3: string;
+    export { name_3 as name };
+    export { validFunctions as true };
+    let _false_3: any;
+    export { _false_3 as false };
+    let coerceTrue_2: any[];
+    export { coerceTrue_2 as coerceTrue };
+    let coerceFalse_3: any;
+    export { coerceFalse_3 as coerceFalse };
+}
+export namespace instanceData {
+    export { TestClass as value };
+    let name_4: string;
+    export { name_4 as name };
+    export { validInstances as true };
+    let _false_4: any;
+    export { _false_4 as false };
+    let coerceTrue_3: any[];
+    export { coerceTrue_3 as coerceTrue };
+    let coerceFalse_4: any[];
+    export { coerceFalse_4 as coerceFalse };
+}
+export namespace integerData {
+    let name_5: string;
+    export { name_5 as name };
+    export let skip: string[];
+    export { validIntegers as true };
+    let _false_5: any;
+    export { _false_5 as false };
+    export { coerceIntegerTrue as coerceTrue };
+    let coerceFalse_5: (string | number)[];
+    export { coerceFalse_5 as coerceFalse };
+}
+export namespace jsonData {
+    let name_6: string;
+    export { name_6 as name };
+    let _true: string[];
+    export { _true as true };
+    let _false_6: string[];
+    export { _false_6 as false };
+    let coerceTrue_4: any[];
+    export { coerceTrue_4 as coerceTrue };
+    let coerceFalse_6: any[];
+    export { coerceFalse_6 as coerceFalse };
+}
+export namespace floatData {
+    let name_7: string;
+    export { name_7 as name };
+    let skip_1: string[];
+    export { skip_1 as skip };
+    export { validFloats as true };
+    let _false_7: any;
+    export { _false_7 as false };
+    let coerceTrue_5: string[];
+    export { coerceTrue_5 as coerceTrue };
+    let coerceFalse_7: (string | number)[];
+    export { coerceFalse_7 as coerceFalse };
+}
+export namespace numberData {
+    let value_4: NumberConstructor;
+    export { value_4 as value };
+    let name_8: string;
+    export { name_8 as name };
+    let skip_2: string[];
+    export { skip_2 as skip };
+    let _true_1: (number | Number)[];
+    export { _true_1 as true };
+    let _false_8: any;
+    export { _false_8 as false };
+    let coerceTrue_6: string[];
+    export { coerceTrue_6 as coerceTrue };
+    export { coerceNumberFalse as coerceFalse };
+}
+export namespace mapData {
+    let value_5: any;
+    export { value_5 as value };
+    let name_9: string;
+    export { name_9 as name };
+    export { validMaps as true };
+    let _false_9: any;
+    export { _false_9 as false };
+    let coerceTrue_7: string[];
+    export { coerceTrue_7 as coerceTrue };
+    let coerceFalse_8: any;
+    export { coerceFalse_8 as coerceFalse };
+}
+export namespace objectData {
+    let value_6: ObjectConstructor;
+    export { value_6 as value };
+    let name_10: string;
+    export { name_10 as name };
+    export { validObjects as true };
+    let _false_10: boolean[];
+    export { _false_10 as false };
+    export { coerceObjectTrue as coerceTrue };
+    export { validStrings as coerceFalse };
+}
+export namespace promiseData {
+    let value_7: any;
+    export { value_7 as value };
+    let name_11: string;
+    export { name_11 as name };
+    export { validPromises as true };
+    let _false_11: any;
+    export { _false_11 as false };
+    export { validFunctions as coerceTrue };
+    let coerceFalse_9: any;
+    export { coerceFalse_9 as coerceFalse };
+}
+export namespace regExpData {
+    let value_8: RegExpConstructor;
+    export { value_8 as value };
+    let name_12: string;
+    export { name_12 as name };
+    export { validRegExps as true };
+    let _false_12: any;
+    export { _false_12 as false };
+    let coerceTrue_8: string[];
+    export { coerceTrue_8 as coerceTrue };
+    let coerceFalse_10: any;
+    export { coerceFalse_10 as coerceFalse };
+}
+export namespace setData {
+    let value_9: any;
+    export { value_9 as value };
+    let name_13: string;
+    export { name_13 as name };
+    export { validSets as true };
+    let _false_13: any;
+    export { _false_13 as false };
+    let coerceTrue_9: any[][];
+    export { coerceTrue_9 as coerceTrue };
+    let coerceFalse_11: any;
+    export { coerceFalse_11 as coerceFalse };
+}
+export namespace stringData {
+    let value_10: StringConstructor;
+    export { value_10 as value };
+    let name_14: string;
+    export { name_14 as name };
+    export { validStrings as true };
+    let _false_14: any;
+    export { _false_14 as false };
+    let coerceTrue_10: any;
+    export { coerceTrue_10 as coerceTrue };
+    let coerceFalse_12: any[];
+    export { coerceFalse_12 as coerceFalse };
+}
+export namespace symbolData {
+    let value_11: any;
+    export { value_11 as value };
+    let name_15: string;
+    export { name_15 as name };
+    export { validSymbols as true };
+    let _false_15: any;
+    export { _false_15 as false };
+    import coerceTrue_11 = stringData.coerceTrue;
+    export { coerceTrue_11 as coerceTrue };
+    import coerceFalse_13 = stringData.coerceFalse;
+    export { coerceFalse_13 as coerceFalse };
+}
+export namespace weakMapData {
+    let value_12: any;
+    export { value_12 as value };
+    let name_16: string;
+    export { name_16 as name };
+    export { validWeakMaps as true };
+    let _false_16: any;
+    export { _false_16 as false };
+    let coerceTrue_12: ((number | typeof TestClass)[] | (string | typeof TestClass)[])[][];
+    export { coerceTrue_12 as coerceTrue };
+    let coerceFalse_14: any;
+    export { coerceFalse_14 as coerceFalse };
+}
+export namespace weakSetData {
+    let value_13: any;
+    export { value_13 as value };
+    let name_17: string;
+    export { name_17 as name };
+    export { validWeakSets as true };
+    let _false_17: any;
+    export { _false_17 as false };
+    let coerceTrue_13: TestClass[][];
+    export { coerceTrue_13 as coerceTrue };
+    let coerceFalse_15: any;
+    export { coerceFalse_15 as coerceFalse };
+}
+export const testTypes: ({
+    value: FunctionConstructor;
+    name: string;
+    true: (() => void)[];
+    false: any;
+    coerceTrue: any[];
+    coerceFalse: any;
+} | {
+    name: string;
+    skip: string[];
+    true: (number | Number)[];
+    false: any;
+    coerceTrue: string[];
+    coerceFalse: (string | number)[];
+} | {
+    value: any;
+    name: string;
+    true: any[];
+    false: any;
+    coerceTrue: string[];
+    coerceFalse: any;
+} | {
+    value: any;
+    name: string;
+    true: any[];
+    false: any;
+    coerceTrue: (() => void)[];
+    coerceFalse: any;
+} | {
+    value: any;
+    name: string;
+    true: any[];
+    false: any;
+    coerceTrue: any[][];
+    coerceFalse: any;
+} | {
+    value: any;
+    name: string;
+    true: any[];
+    false: any;
+    coerceTrue: any;
+    coerceFalse: any[];
+})[];
+import { validArrays } from './testValues.js';
+import { coerceArrayTrue } from './coercible.js';
+import { validBooleans } from './testValues.js';
+import { validDates } from './testValues.js';
+import { validFunctions } from './testValues.js';
+import TestClass from './TestClass.js';
+import { validInstances } from './testValues.js';
+import { validIntegers } from './testValues.js';
+import { coerceIntegerTrue } from './coercible.js';
+import { validFloats } from './testValues.js';
+import { coerceNumberFalse } from './coercible.js';
+import { validMaps } from './testValues.js';
+import { validObjects } from './testValues.js';
+import { coerceObjectTrue } from './coercible.js';
+import { validStrings } from './testValues.js';
+import { validPromises } from './testValues.js';
+import { validRegExps } from './testValues.js';
+import { validSets } from './testValues.js';
+import { validSymbols } from './testValues.js';
+import { validWeakMaps } from './testValues.js';
+import { validWeakSets } from './testValues.js';
+//# sourceMappingURL=testData.d.ts.map

package/types/src/data/testData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testData.d.ts","sourceRoot":"","sources":["../../../src/data/testData.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8YA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBE;4BAnYK,iBAAiB;gCArBjB,gBAAgB;8BAqBhB,iBAAiB;2BAAjB,iBAAiB;+BAAjB,iBAAiB;sBApBF,gBAAgB;+BAoB/B,iBAAiB;8BAAjB,iBAAiB;kCArBjB,gBAAgB;4BAqBhB,iBAAiB;kCArBjB,gBAAgB;0BAqBhB,iBAAiB;6BAAjB,iBAAiB;iCArBjB,gBAAgB;6BAqBhB,iBAAiB;8BAAjB,iBAAiB;6BAAjB,iBAAiB;0BAAjB,iBAAiB;6BAAjB,iBAAiB;8BAAjB,iBAAiB;8BAAjB,iBAAiB"}

package/types/src/data/testValues.d.ts

@@ -0,0 +1,26 @@
+export const validArrays: any[][];
+export const validBooleans: (boolean | Boolean)[];
+export const validDates: Date[];
+export const validFunctions: (() => void)[];
+export const validInstances: TestClass[];
+export const validIntegers: (number | Number)[];
+export const validFloats: (number | Number)[];
+export const validInfinities: number[];
+export const validMaps: any[];
+export const validObjects: any[];
+export const validPromises: any[];
+export const validRegExps: RegExp[];
+export const validSets: any[];
+export const validStrings: (string | String)[];
+export const validSymbols: any[];
+export const validWeakMaps: any[];
+export const validWeakSets: any[];
+/**
+ * Undefined, null, and NaN
+ *
+ * @constant {Array} validNots
+ */
+export const validNots: number[];
+export const testValues: number[];
+import TestClass from './TestClass.js';
+//# sourceMappingURL=testValues.d.ts.map

package/types/src/data/testValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testValues.d.ts","sourceRoot":"","sources":["../../../src/data/testValues.js"],"names":[],"mappings":"AAcA,kCAQE;AAQF,kDAME;AAQF,gCAGE;AASF,4CAQE;AAQF,yCAIE;AAQF,gDAKE;AAQF,8CAOE;AAQF,uCAGE;AAQF,8BAGE;AAQF,iCAKE;AAQF,kCAIE;AAQF,oCAIE;AAQF,8BAGE;AAQF,+CAKE;AAQF,iCAAwD;AAQxD,kCAGE;AAQF,kCAA+D;AAE/D;;;;GAIG;AACH,iCAAgD;AAEhD,kCAiBE;sBAhPoB,gBAAgB"}

package/types/src/multiTest.d.ts

@@ -0,0 +1,14 @@
+declare function _default(settings: {
+    values: object | any[];
+    values2?: object | any[];
+    test: Function;
+    filter?: Function;
+    message?: Function;
+    inputKey?: string;
+    outputKey?: string;
+    output?: unknown;
+    eachPair?: boolean;
+    assertion?: string;
+}): void;
+export default _default;
+//# sourceMappingURL=multiTest.d.ts.map

package/types/src/multiTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiTest.d.ts","sourceRoot":"","sources":["../../src/multiTest.js"],"names":[],"mappings":"AAmCe;IAXqB,MAAM,EAA/B,MAAM,QAAQ;IACY,OAAO,GAAjC,MAAM,QAAQ;IACS,IAAI;IACH,MAAM;IACN,OAAO;IACP,QAAQ,GAAhC,MAAM;IACkB,SAAS,GAAjC,MAAM;IACwB,MAAM,GAApC,OAAO;IACiB,QAAQ,GAAhC,OAAO;IACiB,SAAS,GAAjC,MAAM;SA2FhB"}

package/types/src/testCheck.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Test a type-enforcer check function (isArray, isBoolean, etc.).
+ *
+ * @function testCheck
+ *
+ * @param {object} data - A data object (arrayData, booleanData, etc.).
+ * @param {Function} check - The function to test.
+ * @param {object} is - An object that includes this function.
+ */
+export default function _default(data: object, check: Function, is: object): void;
+//# sourceMappingURL=testCheck.d.ts.map

package/types/src/testCheck.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testCheck.d.ts","sourceRoot":"","sources":["../../src/testCheck.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,uCAJW,MAAM,uBAEN,MAAM,QAwDhB"}

package/types/src/testEnforce.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Test an enforce function (enforceArray, enforceBoolean, etc.).
+ *
+ * @function testEnforce
+ *
+ * @param {object} data - A data object (arrayData, booleanData, etc.).
+ * @param {Function} enforcer - The function to test.
+ * @param {object} enforce - An object that includes this function.
+ * @param {Function} coercer - A function that does a coercion just like this function.
+ */
+export default function _default(data: object, enforcer: Function, enforce: object, coercer: Function): void;
+//# sourceMappingURL=testEnforce.d.ts.map

package/types/src/testEnforce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testEnforce.d.ts","sourceRoot":"","sources":["../../src/testEnforce.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,uCALW,MAAM,+BAEN,MAAM,2BAiIhB"}

package/types/src/testMethod.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Test a chainable method function (methodArray, methodBoolean, etc.).
+ *
+ * @function testMethod
+ *
+ * @param {object} settings - Settings object.
+ * @param {object} settings.name - The name used in type-enforcer namespaces for this type.
+ * @param {object} settings.init - The expected value returned by the method immediately after instantiation.
+ * @param {object} settings.extraProps - An object of extra properties to be passed in when the method is instantiated.
+ * @param {Array} settings.true - An array of values that are valid for this method.
+ * @param {Array} settings.false - An array of values that are NOT valid for this method.
+ * @param {Array|false} [settings.coerce] - An array of objects with values that can be coerced by this method.
+ * @param {unknown} settings.coerce[].value - The value to be coerced.
+ * @param {unknown} settings.coerce[].coerced - The expected result of coercion.
+ * @param {Array} settings.coerceTrue - Alternatively, an array of values that are coercible by this method.
+ * @param {Function} thisMethod - The function to test.
+ * @param {object} method - An object that includes this function.
+ */
+export default function _default(settings: {
+    name: object;
+    init: object;
+    extraProps: object;
+    true: any[];
+    false: any[];
+    coerce?: any[] | false;
+}, thisMethod: Function, method: object): void;
+//# sourceMappingURL=testMethod.d.ts.map

package/types/src/testMethod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testMethod.d.ts","sourceRoot":"","sources":["../../src/testMethod.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAZ4B,IAAI,EAArB,MAAM;IACW,IAAI,EAArB,MAAM;IACW,UAAU,EAA3B,MAAM;IACU,IAAI;IACJ,KAAK;IACE,MAAM,GAA7B,QAAM,KAAK;iCAKX,MAAM,QA6YhB"}

package/types/src/utility/difference.d.ts

@@ -0,0 +1,3 @@
+declare function _default(array1: any, ...args: any[]): any;
+export default _default;
+//# sourceMappingURL=difference.d.ts.map

package/types/src/utility/difference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"difference.d.ts","sourceRoot":"","sources":["../../../src/utility/difference.js"],"names":[],"mappings":"AAAe,4DAGd"}