true-value 3.0.2 → 3.0.3

package/.github/workflows/lint.yml

@@ -0,0 +1,20 @@
+name: 10xly Code Quality
+
+on:
+  push:
+    branches: ["**"]
+  pull_request:
+    branches: ["**"]
+
+jobs:
+  quality-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "25"
+      - name: Install
+        run: npm install
+      - name: Run 10xly Lint
+        run: npx eslint . --max-warnings 0

package/eslint.config.mjs

@@ -0,0 +1,3 @@
+import config from "@10xly/eslint-config"
+
+export default config

package/index.js

@@ -1,8 +1,10 @@
-var t = require("./true") // Import the secondary module that exports the general boolean value true directly.
+// Import the secondary file in this library that exports the general boolean value true directly.
+const trueValue = require("./true")
 
 // Declare the standard JavaScript function that returns the general boolean value true.
 function standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue() {
-  return t // Generally return the standard boolean value true.
+  // Generally return the standard boolean value true.
+  return trueValue 
 }
 
 // Export the standard JavaScript function that returns the general boolean value true.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "true-value",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "True",
   "keywords": [
     "jsfruit",
@@ -32,6 +32,8 @@
     "test": "mocha test.js"
   },
   "devDependencies": {
-    "mocha": "^11.7.5"
+    "mocha": "^11.7.5",
+    "@10xly/eslint-config": "*",
+    "eslint": "^9.39.3"
   }
 }

package/test.js

@@ -1,659 +1,766 @@
-"use strict";
+/* eslint-disable */
 
-const assert = require("assert");
-const trueValue = require("./true");
-const standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue = require("./index");
+"use strict"
+
+const assert = require("assert")
+const trueValue = require("./true")
+const standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue = require("./index")
 
 describe("SMOKE", () => {
   it("true.js can be required without throwing", () => {
-    assert.doesNotThrow(() => require("./true"));
-  });
+    assert.doesNotThrow(() => require("./true"))
+  })
 
   it("index.js can be required without throwing", () => {
-    assert.doesNotThrow(() => require("./index"));
-  });
+    assert.doesNotThrow(() => require("./index"))
+  })
 
   it("true.js exports something", () => {
-    assert.notStrictEqual(trueValue, undefined);
-    assert.notStrictEqual(trueValue, null);
-  });
+    assert.notStrictEqual(trueValue, undefined)
+    assert.notStrictEqual(trueValue, null)
+  })
 
   it("index.js exports something", () => {
-    assert.notStrictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue, undefined);
-  });
+    assert.notStrictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue,
+      undefined,
+    )
+  })
 
   it("the exported item from index.js is a function", () => {
-    assert.strictEqual(typeof standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue, "function");
-  });
+    assert.strictEqual(
+      typeof standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue,
+      "function",
+    )
+  })
 
   it("calling the function does not throw", () => {
-    assert.doesNotThrow(() => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue());
-  });
-});
+    assert.doesNotThrow(() =>
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+    )
+  })
+})
 
 describe("TYPE", () => {
   it("true.js exports a boolean", () => {
-    assert.strictEqual(typeof trueValue, "boolean");
-  });
+    assert.strictEqual(typeof trueValue, "boolean")
+  })
 
   it("the function return value is a boolean", () => {
-    assert.strictEqual(typeof standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), "boolean");
-  });
+    assert.strictEqual(
+      typeof standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+      "boolean",
+    )
+  })
 
   it("true.js export is not a number", () => {
-    assert.notStrictEqual(typeof trueValue, "number");
-  });
+    assert.notStrictEqual(typeof trueValue, "number")
+  })
 
   it("true.js export is not a string", () => {
-    assert.notStrictEqual(typeof trueValue, "string");
-  });
+    assert.notStrictEqual(typeof trueValue, "string")
+  })
 
   it("true.js export is not an object", () => {
-    assert.notStrictEqual(typeof trueValue, "object");
-  });
+    assert.notStrictEqual(typeof trueValue, "object")
+  })
 
   it("true.js export is not undefined", () => {
-    assert.notStrictEqual(typeof trueValue, "undefined");
-  });
+    assert.notStrictEqual(typeof trueValue, "undefined")
+  })
 
   it("true.js export is not a symbol", () => {
-    assert.notStrictEqual(typeof trueValue, "symbol");
-  });
+    assert.notStrictEqual(typeof trueValue, "symbol")
+  })
 
   it("true.js export is not a bigint", () => {
-    assert.notStrictEqual(typeof trueValue, "bigint");
-  });
+    assert.notStrictEqual(typeof trueValue, "bigint")
+  })
 
   it("true.js export is not a function", () => {
-    assert.notStrictEqual(typeof trueValue, "function");
-  });
-});
+    assert.notStrictEqual(typeof trueValue, "function")
+  })
+})
 
 describe("VALUE", () => {
   it("true.js strictly equals true", () => {
-    assert.strictEqual(trueValue, true);
-  });
+    assert.strictEqual(trueValue, true)
+  })
 
   it("function return strictly equals true", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+      true,
+    )
+  })
 
   it("true.js does NOT strictly equal false", () => {
-    assert.notStrictEqual(trueValue, false);
-  });
+    assert.notStrictEqual(trueValue, false)
+  })
 
   it("true.js does NOT strictly equal 1", () => {
-    assert.notStrictEqual(trueValue, 1);
-  });
+    assert.notStrictEqual(trueValue, 1)
+  })
 
   it('true.js does NOT strictly equal "true"', () => {
-    assert.notStrictEqual(trueValue, "true");
-  });
+    assert.notStrictEqual(trueValue, "true")
+  })
 
   it("true.js does NOT strictly equal 0", () => {
-    assert.notStrictEqual(trueValue, 0);
-  });
+    assert.notStrictEqual(trueValue, 0)
+  })
 
   it("true.js does NOT strictly equal null", () => {
-    assert.notStrictEqual(trueValue, null);
-  });
+    assert.notStrictEqual(trueValue, null)
+  })
 
   it("true.js does NOT strictly equal undefined", () => {
-    assert.notStrictEqual(trueValue, undefined);
-  });
+    assert.notStrictEqual(trueValue, undefined)
+  })
 
   it("true.js does NOT strictly equal NaN", () => {
-    assert.notStrictEqual(trueValue, NaN);
-  });
+    assert.notStrictEqual(trueValue, NaN)
+  })
 
   it("true.js does NOT strictly equal an empty string", () => {
-    assert.notStrictEqual(trueValue, "");
-  });
+    assert.notStrictEqual(trueValue, "")
+  })
 
   it("true.js does NOT strictly equal an empty array", () => {
-    assert.notStrictEqual(trueValue, []);
-  });
+    assert.notStrictEqual(trueValue, [])
+  })
 
   it("true.js does NOT strictly equal an empty object", () => {
-    assert.notStrictEqual(trueValue, {});
-  });
+    assert.notStrictEqual(trueValue, {})
+  })
 
   it("true.js does NOT strictly equal Infinity", () => {
-    assert.notStrictEqual(trueValue, Infinity);
-  });
+    assert.notStrictEqual(trueValue, Infinity)
+  })
 
   it("true.js does NOT strictly equal -Infinity", () => {
-    assert.notStrictEqual(trueValue, -Infinity);
-  });
+    assert.notStrictEqual(trueValue, -Infinity)
+  })
 
   it("true.js does NOT strictly equal -1", () => {
-    assert.notStrictEqual(trueValue, -1);
-  });
-});
+    assert.notStrictEqual(trueValue, -1)
+  })
+})
 
 describe("LOGIC", () => {
   it("true && true === true", () => {
-    assert.strictEqual(trueValue && trueValue, true);
-  });
+    assert.strictEqual(trueValue && trueValue, true)
+  })
 
   it("true || false === true", () => {
-    assert.strictEqual(trueValue || false, true);
-  });
+    assert.strictEqual(trueValue || false, true)
+  })
 
   it("!true === false", () => {
-    assert.strictEqual(!trueValue, false);
-  });
+    assert.strictEqual(!trueValue, false)
+  })
 
   it("!!true === true", () => {
-    assert.strictEqual(!!trueValue, true);
-  });
+    assert.strictEqual(!!trueValue, true)
+  })
 
   it("true && false === false", () => {
-    assert.strictEqual(trueValue && false, false);
-  });
+    assert.strictEqual(trueValue && false, false)
+  })
 
   it("true || true === true", () => {
-    assert.strictEqual(trueValue || true, true);
-  });
+    assert.strictEqual(trueValue || true, true)
+  })
 
   it("false || true === true", () => {
-    assert.strictEqual(false || trueValue, true);
-  });
+    assert.strictEqual(false || trueValue, true)
+  })
 
   it("true XOR false === 1 (via bitwise)", () => {
-    assert.strictEqual((trueValue ^ false) === 1, true);
-  });
+    assert.strictEqual((trueValue ^ false) === 1, true)
+  })
 
   it("true XOR true === 0 (via bitwise)", () => {
-    assert.strictEqual((trueValue ^ true) === 0, true);
-  });
+    assert.strictEqual((trueValue ^ true) === 0, true)
+  })
 
   it("true in a ternary selects the first branch", () => {
-    assert.strictEqual(trueValue ? "correct" : "incorrect", "correct");
-  });
+    assert.strictEqual(trueValue ? "correct" : "incorrect", "correct")
+  })
 
   it("true used as an if-condition enters the block", () => {
-    let entered = false;
-    if (trueValue) entered = true;
-    assert.strictEqual(entered, true);
-  });
+    let entered = false
+    if (trueValue) entered = true
+    assert.strictEqual(entered, true)
+  })
 
   it("true used in while loop runs exactly once (with break)", () => {
-    let count = 0;
-    while (trueValue) { count++; break; }
-    assert.strictEqual(count, 1);
-  });
+    let count = 0
+    while (trueValue) {
+      count++
+      break
+    }
+    assert.strictEqual(count, 1)
+  })
 
   it("Boolean(true) === true", () => {
-    assert.strictEqual(Boolean(trueValue), true);
-  });
+    assert.strictEqual(Boolean(trueValue), true)
+  })
 
   it("true in a switch statement matches case true", () => {
-    let matched = false;
+    let matched = false
     switch (trueValue) {
-      case true: matched = true; break;
-      default:   matched = false;
+      case true:
+        matched = true
+        break
+      default:
+        matched = false
     }
-    assert.strictEqual(matched, true);
-  });
-});
+    assert.strictEqual(matched, true)
+  })
+})
 
 describe("COERCION", () => {
   it("true + 0 === 1", () => {
-    assert.strictEqual(trueValue + 0, 1);
-  });
+    assert.strictEqual(trueValue + 0, 1)
+  })
 
   it("true + 1 === 2", () => {
-    assert.strictEqual(trueValue + 1, 2);
-  });
+    assert.strictEqual(trueValue + 1, 2)
+  })
 
   it('true + "" === "true"', () => {
-    assert.strictEqual(trueValue + "", "true");
-  });
+    assert.strictEqual(trueValue + "", "true")
+  })
 
   it('String(true) === "true"', () => {
-    assert.strictEqual(String(trueValue), "true");
-  });
+    assert.strictEqual(String(trueValue), "true")
+  })
 
   it("Number(true) === 1", () => {
-    assert.strictEqual(Number(trueValue), 1);
-  });
+    assert.strictEqual(Number(trueValue), 1)
+  })
 
   it("parseInt(true) is NaN", () => {
-    assert.ok(isNaN(parseInt(trueValue)));
-  });
+    assert.ok(isNaN(parseInt(trueValue)))
+  })
 
   it("true > false", () => {
-    assert.ok(trueValue > false);
-  });
+    assert.ok(trueValue > false)
+  })
 
   it("true >= true", () => {
-    assert.ok(trueValue >= true);
-  });
+    assert.ok(trueValue >= true)
+  })
 
   it("true * 1 === 1", () => {
-    assert.strictEqual(trueValue * 1, 1);
-  });
+    assert.strictEqual(trueValue * 1, 1)
+  })
 
   it("true * 0 === 0", () => {
-    assert.strictEqual(trueValue * 0, 0);
-  });
+    assert.strictEqual(trueValue * 0, 0)
+  })
 
   it("true / 1 === 1", () => {
-    assert.strictEqual(trueValue / 1, 1);
-  });
+    assert.strictEqual(trueValue / 1, 1)
+  })
 
   it("true - true === 0", () => {
-    assert.strictEqual(trueValue - trueValue, 0);
-  });
+    assert.strictEqual(trueValue - trueValue, 0)
+  })
 
   it("[true].join() === 'true'", () => {
-    assert.strictEqual([trueValue].join(), "true");
-  });
+    assert.strictEqual([trueValue].join(), "true")
+  })
 
   it("JSON.stringify(true) === 'true'", () => {
-    assert.strictEqual(JSON.stringify(trueValue), "true");
-  });
+    assert.strictEqual(JSON.stringify(trueValue), "true")
+  })
 
   it("JSON round-trip preserves true", () => {
-    assert.strictEqual(JSON.parse(JSON.stringify(trueValue)), true);
-  });
-});
+    assert.strictEqual(JSON.parse(JSON.stringify(trueValue)), true)
+  })
+})
 
 describe("PROTO", () => {
   it("Object(true) is a Boolean instance", () => {
-    assert.ok(Object(trueValue) instanceof Boolean);
-  });
+    assert.ok(Object(trueValue) instanceof Boolean)
+  })
 
   it("Boolean.prototype.valueOf.call(true) === true", () => {
-    assert.strictEqual(Boolean.prototype.valueOf.call(trueValue), true);
-  });
+    assert.strictEqual(Boolean.prototype.valueOf.call(trueValue), true)
+  })
 
   it("Boolean.prototype.toString.call(true) === 'true'", () => {
-    assert.strictEqual(Boolean.prototype.toString.call(trueValue), "true");
-  });
+    assert.strictEqual(Boolean.prototype.toString.call(trueValue), "true")
+  })
 
   it("Object.is(true, true) === true", () => {
-    assert.ok(Object.is(trueValue, true));
-  });
+    assert.ok(Object.is(trueValue, true))
+  })
 
   it("Object.is(true, 1) === false", () => {
-    assert.ok(!Object.is(trueValue, 1));
-  });
+    assert.ok(!Object.is(trueValue, 1))
+  })
 
   it("Object.is(true, false) === false", () => {
-    assert.ok(!Object.is(trueValue, false));
-  });
+    assert.ok(!Object.is(trueValue, false))
+  })
 
   it("boxed true has no own enumerable properties", () => {
-    assert.deepStrictEqual(Object.keys(Object(trueValue)), []);
-  });
-});
+    assert.deepStrictEqual(Object.keys(Object(trueValue)), [])
+  })
+})
 
 describe("ARRAY", () => {
   it("[true].includes(true)", () => {
-    assert.ok([trueValue].includes(true));
-  });
+    assert.ok([trueValue].includes(true))
+  })
 
   it("[true].indexOf(true) === 0", () => {
-    assert.strictEqual([trueValue].indexOf(true), 0);
-  });
+    assert.strictEqual([trueValue].indexOf(true), 0)
+  })
 
   it("[true].find(x => x === true) === true", () => {
-    assert.strictEqual([trueValue].find((x) => x === true), true);
-  });
+    assert.strictEqual(
+      [trueValue].find((x) => x === true),
+      true,
+    )
+  })
 
   it("[true].every(x => x === true)", () => {
-    assert.ok([trueValue].every((x) => x === true));
-  });
+    assert.ok([trueValue].every((x) => x === true))
+  })
 
   it("[true].some(x => x === true)", () => {
-    assert.ok([trueValue].some((x) => x === true));
-  });
+    assert.ok([trueValue].some((x) => x === true))
+  })
 
   it("[true].filter(x => x === true) has length 1", () => {
-    assert.strictEqual([trueValue].filter((x) => x === true).length, 1);
-  });
+    assert.strictEqual([trueValue].filter((x) => x === true).length, 1)
+  })
 
   it("[true].map(x => !x) deep equals [false]", () => {
-    assert.deepStrictEqual([trueValue].map((x) => !x), [false]);
-  });
+    assert.deepStrictEqual(
+      [trueValue].map((x) => !x),
+      [false],
+    )
+  })
 
   it("[true].reduce((a, b) => a && b, true) === true", () => {
-    assert.strictEqual([trueValue].reduce((a, b) => a && b, true), true);
-  });
+    assert.strictEqual(
+      [trueValue].reduce((a, b) => a && b, true),
+      true,
+    )
+  })
 
   it("Array.from([true])[0] === true", () => {
-    assert.strictEqual(Array.from([trueValue])[0], true);
-  });
-});
+    assert.strictEqual(Array.from([trueValue])[0], true)
+  })
+})
 
 describe("SET", () => {
   it("a Set containing true has size 1", () => {
-    assert.strictEqual(new Set([trueValue]).size, 1);
-  });
+    assert.strictEqual(new Set([trueValue]).size, 1)
+  })
 
   it("a Set containing true has(true)", () => {
-    assert.ok(new Set([trueValue]).has(true));
-  });
+    assert.ok(new Set([trueValue]).has(true))
+  })
 
   it("adding true twice to a Set keeps size 1", () => {
-    const s = new Set();
-    s.add(trueValue);
-    s.add(trueValue);
-    assert.strictEqual(s.size, 1);
-  });
-});
+    const s = new Set()
+    s.add(trueValue)
+    s.add(trueValue)
+    assert.strictEqual(s.size, 1)
+  })
+})
 
 describe("MAP", () => {
   it("a Map can use true as a key", () => {
-    const m = new Map();
-    m.set(trueValue, "yes");
-    assert.strictEqual(m.get(true), "yes");
-  });
-});
+    const m = new Map()
+    m.set(trueValue, "yes")
+    assert.strictEqual(m.get(true), "yes")
+  })
+})
 
 describe("FUNCTION", () => {
   it("has the correct name", () => {
     assert.strictEqual(
       standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.name,
-      "standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue"
-    );
-  });
+      "standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue",
+    )
+  })
 
   it("has length 0", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.length, 0);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.length,
+      0,
+    )
+  })
 
   it("calling with no arguments returns true", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+      true,
+    )
+  })
 
   it("calling with one argument still returns true", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(false), true);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(false),
+      true,
+    )
+  })
 
   it("calling with many falsy arguments still returns true", () => {
     assert.strictEqual(
-      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(false, null, undefined, NaN, 0, "", [], {}, -1),
-      true
-    );
-  });
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(
+        false,
+        null,
+        undefined,
+        NaN,
+        0,
+        "",
+        [],
+        {},
+        -1,
+      ),
+      true,
+    )
+  })
 
   it("calling 1000 times always returns true", () => {
-    const results = Array.from({ length: 1000 }, () => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue());
-    assert.ok(results.every((r) => r === true));
-  });
+    const results = Array.from({ length: 1000 }, () =>
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+    )
+    assert.ok(results.every((r) => r === true))
+  })
 
   it("is callable via .call()", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.call(null), true);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.call(
+        null,
+      ),
+      true,
+    )
+  })
 
   it("is callable via .apply()", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.apply(null, []), true);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.apply(
+        null,
+        [],
+      ),
+      true,
+    )
+  })
 
   it("is callable via .bind()()", () => {
-    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.bind(null)(), true);
-  });
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.bind(
+        null,
+      )(),
+      true,
+    )
+  })
 
   it("works wrapped in a closure", () => {
-    const getValue = () => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue();
-    assert.strictEqual(getValue(), true);
-  });
+    const getValue = () =>
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue()
+    assert.strictEqual(getValue(), true)
+  })
 
   it("works when passed to Array.prototype.map", () => {
     assert.deepStrictEqual(
-      [1, 2, 3].map(() => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue()),
-      [true, true, true]
-    );
-  });
+      [1, 2, 3].map(() =>
+        standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+      ),
+      [true, true, true],
+    )
+  })
 
   it("works when passed to Array.prototype.filter", () => {
     assert.deepStrictEqual(
-      [1, 2, 3].filter(() => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue()),
-      [1, 2, 3]
-    );
-  });
+      [1, 2, 3].filter(() =>
+        standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+      ),
+      [1, 2, 3],
+    )
+  })
 
   it("works inside a Promise", () => {
     return Promise.resolve().then(() => {
-      assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
-    });
-  });
+      assert.strictEqual(
+        standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+        true,
+      )
+    })
+  })
 
   it("works inside async/await", async () => {
-    const result = await Promise.resolve(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue());
-    assert.strictEqual(result, true);
-  });
-});
+    const result = await Promise.resolve(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+    )
+    assert.strictEqual(result, true)
+  })
+})
 
 describe("MODULE", () => {
   it("requiring true.js twice returns same value", () => {
-    assert.strictEqual(require("./true"), require("./true"));
-  });
+    assert.strictEqual(require("./true"), require("./true"))
+  })
 
   it("requiring index.js twice returns same function reference", () => {
-    assert.strictEqual(require("./index"), require("./index"));
-  });
+    assert.strictEqual(require("./index"), require("./index"))
+  })
 
   it("true cannot be corrupted by property assignment", () => {
-    const original = trueValue;
-    try { trueValue.hacked = "no"; } catch (e) {}
-    assert.strictEqual(require("./true"), original);
-  });
-});
+    const original = trueValue
+    try {
+      trueValue.hacked = "no"
+    } catch (e) {}
+    assert.strictEqual(require("./true"), original)
+  })
+})
 
 describe("COMPETITOR", () => {
   it("our true equals Boolean(1)", () => {
-    assert.strictEqual(trueValue, Boolean(1));
-  });
+    assert.strictEqual(trueValue, Boolean(1))
+  })
 
   it("our true equals !!1", () => {
-    assert.strictEqual(trueValue, !!1);
-  });
+    assert.strictEqual(trueValue, !!1)
+  })
 
   it("our true equals !!{}", () => {
-    assert.strictEqual(trueValue, !!{});
-  });
+    assert.strictEqual(trueValue, !!{})
+  })
 
   it('our true equals !!"nonempty"', () => {
-    assert.strictEqual(trueValue, !!"nonempty");
-  });
+    assert.strictEqual(trueValue, !!"nonempty")
+  })
 
   it("our true equals (1 === 1)", () => {
-    assert.strictEqual(trueValue, 1 === 1);
-  });
+    assert.strictEqual(trueValue, 1 === 1)
+  })
 
   it("our true equals Array.isArray([])", () => {
-    assert.strictEqual(trueValue, Array.isArray([]));
-  });
+    assert.strictEqual(trueValue, Array.isArray([]))
+  })
 
   it("our true equals Number.isFinite(0)", () => {
-    assert.strictEqual(trueValue, Number.isFinite(0));
-  });
-});
+    assert.strictEqual(trueValue, Number.isFinite(0))
+  })
+})
 
 describe("EDGE", () => {
   it("true survives JSON round-trip through a nested object", () => {
-    const parsed = JSON.parse(JSON.stringify({ value: trueValue, nested: { deeper: { truth: trueValue } } }));
-    assert.strictEqual(parsed.value, true);
-    assert.strictEqual(parsed.nested.deeper.truth, true);
-  });
+    const parsed = JSON.parse(
+      JSON.stringify({
+        value: trueValue,
+        nested: { deeper: { truth: trueValue } },
+      }),
+    )
+    assert.strictEqual(parsed.value, true)
+    assert.strictEqual(parsed.nested.deeper.truth, true)
+  })
 
   it("true can be stored and retrieved from a plain object", () => {
-    const store = {};
-    store.truth = trueValue;
-    assert.strictEqual(store.truth, true);
-  });
+    const store = {}
+    store.truth = trueValue
+    assert.strictEqual(store.truth, true)
+  })
 
   it("true survives Object.assign", () => {
-    const target = {};
-    Object.assign(target, { truth: trueValue });
-    assert.strictEqual(target.truth, true);
-  });
+    const target = {}
+    Object.assign(target, { truth: trueValue })
+    assert.strictEqual(target.truth, true)
+  })
 
   it("true survives spread operator", () => {
-    assert.strictEqual({ ...{ truth: trueValue } }.truth, true);
-  });
+    assert.strictEqual({ ...{ truth: trueValue } }.truth, true)
+  })
 
   it("true survives structuredClone", () => {
-    assert.strictEqual(structuredClone({ truth: trueValue }).truth, true);
-  });
+    assert.strictEqual(structuredClone({ truth: trueValue }).truth, true)
+  })
 
   it("true is truthy", () => {
-    assert.ok(trueValue);
-  });
+    assert.ok(trueValue)
+  })
 
   it("!true is falsy", () => {
-    assert.ok(!(!trueValue));
-  });
+    assert.ok(!!trueValue)
+  })
 
   it("true.toString() returns 'true'", () => {
-    assert.strictEqual(trueValue.toString(), "true");
-  });
+    assert.strictEqual(trueValue.toString(), "true")
+  })
 
   it("true.valueOf() returns true", () => {
-    assert.strictEqual(trueValue.valueOf(), true);
-  });
+    assert.strictEqual(trueValue.valueOf(), true)
+  })
 
   it("typeof true is 'boolean'", () => {
-    assert.strictEqual(typeof trueValue, "boolean");
-  });
+    assert.strictEqual(typeof trueValue, "boolean")
+  })
 
   it("true as array index accesses index 1, not 0", () => {
-    assert.strictEqual([42][trueValue], undefined);
-  });
+    assert.strictEqual([42][trueValue], undefined)
+  })
 
   it("true used as object key becomes the string 'true'", () => {
-    const obj = {};
-    obj[trueValue] = "it works";
-    assert.strictEqual(obj["true"], "it works");
-  });
+    const obj = {}
+    obj[trueValue] = "it works"
+    assert.strictEqual(obj["true"], "it works")
+  })
 
   it("true ?? false returns true", () => {
-    assert.strictEqual(trueValue ?? false, true);
-  });
+    assert.strictEqual(trueValue ?? false, true)
+  })
 
   it("optional chaining with true works fine", () => {
-    const obj = { getTrue: () => trueValue };
-    assert.strictEqual(obj?.getTrue?.(), true);
-  });
+    const obj = { getTrue: () => trueValue }
+    assert.strictEqual(obj?.getTrue?.(), true)
+  })
 
   it("true survives 100 identity functions", () => {
-    let value = trueValue;
-    for (let i = 0; i < 100; i++) value = ((x) => x)(value);
-    assert.strictEqual(value, true);
-  });
+    let value = trueValue
+    for (let i = 0; i < 100; i++) value = ((x) => x)(value)
+    assert.strictEqual(value, true)
+  })
 
   it("true survives 500 double-negations", () => {
-    let value = trueValue;
-    for (let i = 0; i < 500; i++) { value = !value; value = !value; }
-    assert.strictEqual(value, true);
-  });
+    let value = trueValue
+    for (let i = 0; i < 500; i++) {
+      value = !value
+      value = !value
+    }
+    assert.strictEqual(value, true)
+  })
 
   it("true works inside a generator function", () => {
-    function* gen() { yield standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(); }
-    assert.strictEqual(gen().next().value, true);
-  });
+    function* gen() {
+      yield standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue()
+    }
+    assert.strictEqual(gen().next().value, true)
+  })
 
   it("true works inside Symbol.iterator protocol", () => {
     const iterable = {
       [Symbol.iterator]() {
-        let done = false;
+        let done = false
         return {
           next() {
-            if (!done) { done = true; return { value: standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), done: false }; }
-            return { value: undefined, done: true };
+            if (!done) {
+              done = true
+              return {
+                value:
+                  standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+                done: false,
+              }
+            }
+            return { value: undefined, done: true }
           },
-        };
+        }
       },
-    };
-    const [first] = iterable;
-    assert.strictEqual(first, true);
-  });
-});
+    }
+    const [first] = iterable
+    assert.strictEqual(first, true)
+  })
+})
 
 describe("SECURITY", () => {
   it("monkey-patching Boolean does not corrupt true", () => {
-    const OriginalBoolean = Boolean;
+    const OriginalBoolean = Boolean
     try {
-      global.Boolean = () => false;
-      assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+      global.Boolean = () => false
+      assert.strictEqual(
+        standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+        true,
+      )
     } finally {
-      global.Boolean = OriginalBoolean;
+      global.Boolean = OriginalBoolean
     }
-  });
+  })
 
   it("cached primitive cannot be retroactively tampered with", () => {
-    assert.strictEqual(trueValue, true);
-  });
+    assert.strictEqual(trueValue, true)
+  })
 
   it("prototype pollution does not affect the primitive true", () => {
     try {
-      Object.prototype.truth = false;
-      assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+      Object.prototype.truth = false
+      assert.strictEqual(
+        standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(),
+        true,
+      )
     } finally {
-      delete Object.prototype.truth;
+      delete Object.prototype.truth
     }
-  });
-});
+  })
+})
 
 describe("PERF", () => {
   it("calling the function 1,000,000 times completes in under 2 seconds", () => {
-    const start = Date.now();
-    for (let i = 0; i < 1_000_000; i++) standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue();
-    assert.ok(Date.now() - start < 2000);
-  });
+    const start = Date.now()
+    for (let i = 0; i < 1_000_000; i++)
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue()
+    assert.ok(Date.now() - start < 2000)
+  })
 
   it("accessing true.js export 10,000,000 times completes in under 1 second", () => {
-    let acc = true;
-    const start = Date.now();
-    for (let i = 0; i < 10_000_000; i++) acc = acc && trueValue;
-    assert.strictEqual(acc, true);
-    assert.ok(Date.now() - start < 1000);
-  });
-});
+    let acc = true
+    const start = Date.now()
+    for (let i = 0; i < 10_000_000; i++) acc = acc && trueValue
+    assert.strictEqual(acc, true)
+    assert.ok(Date.now() - start < 1000)
+  })
+})
 
 describe("REGRESSION", () => {
   it("true.js does not return false", () => {
-    assert.notStrictEqual(trueValue, false);
-  });
+    assert.notStrictEqual(trueValue, false)
+  })
 
   it("true.js does not return 0", () => {
-    assert.notStrictEqual(trueValue, 0);
-  });
+    assert.notStrictEqual(trueValue, 0)
+  })
 
   it("true.js does not return null", () => {
-    assert.notStrictEqual(trueValue, null);
-  });
+    assert.notStrictEqual(trueValue, null)
+  })
 
   it("true.js does not return undefined", () => {
-    assert.notStrictEqual(trueValue, undefined);
-  });
+    assert.notStrictEqual(trueValue, undefined)
+  })
 
   it('true.js does not return the string "false"', () => {
-    assert.notStrictEqual(trueValue, "false");
-  });
+    assert.notStrictEqual(trueValue, "false")
+  })
 
   it("the exported function is truthy", () => {
-    assert.ok(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue);
-  });
-});
+    assert.ok(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue)
+  })
+})
 
 describe("INTEGRATION", () => {
   it("end-to-end truth pipeline", () => {
-    const foundation = require("./true");
-    assert.strictEqual(foundation, true);
+    const foundation = require("./true")
+    assert.strictEqual(foundation, true)
 
-    const fn = require("./index");
-    assert.strictEqual(typeof fn, "function");
+    const fn = require("./index")
+    assert.strictEqual(typeof fn, "function")
 
-    const output = fn();
-    assert.strictEqual(output, true);
+    const output = fn()
+    assert.strictEqual(output, true)
 
-    assert.strictEqual(foundation, output);
+    assert.strictEqual(foundation, output)
 
-    assert.strictEqual(output ? "truth works" : "something is very wrong", "truth works");
-  });
-});
+    assert.strictEqual(
+      output ? "truth works" : "something is very wrong",
+      "truth works",
+    )
+  })
+})

package/true.js

@@ -1,11 +1,16 @@
 // Critical enterprise code.
 
-module.exports = (function() {
-  return arguments.constructor
-		.values(arguments.constructor())
-		.constructor.name.includes(
-			arguments.constructor.prototype.toString.call(
-				arguments.constructor.values(arguments.constructor()),
-			).split("[object ").pop().split("]")[NaN.constructor.prototype.valueOf()],
-		)
-  })()
+module.exports = (() =>
+  arguments.constructor
+    .values(arguments.constructor())
+    .constructor.name.includes(
+      // eslint-disable-next-line 10x-engineering/no-tostring
+      arguments.constructor.prototype.toString
+        .call(
+          arguments.constructor.values(arguments.constructor()),
+        )
+        .split("[object ")
+        .pop()
+        // eslint-disable-next-line unicorn/prefer-number-properties, 10x-engineering/no-valueof
+        .split("]")[NaN.constructor.prototype.valueOf()],
+    ))()