true-value 3.0.0 → 3.0.2

package/README.md

@@ -1,18 +1,52 @@
 # true-value
 
-Returns the boolean value true using quantum computing/qubit circuit simulation
+Node.js module published on NPM that exports and provides a standard JavaScript function that returns the general boolean value true.
 
 ## Installation
+Using NPM:
 ```bash
 npm install true-value
 ```
+Using Yarn:
+```bash
+yarn add true-value
+```
+Using PNPM:
+```bash
+pnpm add true-value
+```
 
 ## Usage
+Import with CommonJS:
 ```js
 const trueValue = require("true-value")
+```
+Or you can use ESM:
+```js
+import * as trueValue from "true-value"
+```
+Example:
+```js
+const trueValue = require("true-value")
+
+console.log(trueValue()) // Outputs the standard boolean value true to the default terminal output stream.
+
+const assert = require("assert-fn") // Import standard library for quality assertions.
+
+assert(trueValue() === true) // Assert that the boolean value true is the same as trueValue().
 
-console.log(trueValue()) // true
+const booleanTrue = require("true-value/true") // Import the boolean value true directly without calling a function.
+
+assert(booleanTrue === true) // Assert that the boolean value true is the same as booleanTrue.
 ```
 
+## Why?
+This is useful in environments where:
+- The global boolean value `true` doesn't exist ([see this issue on mde's true library](https://github.com/mde/true/issues/19)), and NPM package [true](https://github.com/mde/true) by mde uses true directly, which could be a problem
+- Serious enterprise corporations need ultimate business reliability when it comes to standardized boolean values.
+
 ## Contributing
-please contribute.
+Please contribute. Please
+
+## Tests
+`true-value` has lots of enterprise-grade tests. Simply clone the repo, `npm install` and run `npm test` to run them

package/index.js

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

package/package.json

@@ -1,21 +1,37 @@
 {
   "name": "true-value",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "True",
-  "main": "index.js",
-  "scripts": {
-    "test": "jake test"
+  "keywords": [
+    "jsfruit",
+    "is-ten-thousand",
+    "is-hundred",
+    "true",
+    "mde",
+    "boolean",
+    "reliability",
+    "integer-values",
+    "is-not-integer",
+    "high-availability-testing",
+    "rest-in-peace-edge"
+  ],
+  "homepage": "https://github.com/10xly/true-value",
+  "bugs": {
+    "url": "https://github.com/10xly/true-value/issues"
   },
-  "author": "",
-  "license": "UNLICENSED",
-  "homepage": "https://github.com/tj-commits/true-value",
   "repository": {
-    "url": "git+https://github.com/tj-commits/true-value.git",
+    "url": "git+https://github.com/10xly/true-value.git",
     "type": "git"
   },
-  "bugs": "https://github.com/tj-commits/true-value/issues",
-  "dependencies": {
-    "construct-new-second": "^1.0.0",
-    "literally": "^1.0.0"
+  "license": "EGPSL10X-1.0",
+  "author": "10x'ly Made",
+  "type": "commonjs",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "test": "mocha test.js"
+  },
+  "devDependencies": {
+    "mocha": "^11.7.5"
   }
 }

package/test.js

@@ -0,0 +1,659 @@
+"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"));
+  });
+
+  it("index.js can be required without throwing", () => {
+    assert.doesNotThrow(() => require("./index"));
+  });
+
+  it("true.js exports something", () => {
+    assert.notStrictEqual(trueValue, undefined);
+    assert.notStrictEqual(trueValue, null);
+  });
+
+  it("index.js exports something", () => {
+    assert.notStrictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue, undefined);
+  });
+
+  it("the exported item from index.js is a function", () => {
+    assert.strictEqual(typeof standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue, "function");
+  });
+
+  it("calling the function does not throw", () => {
+    assert.doesNotThrow(() => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue());
+  });
+});
+
+describe("TYPE", () => {
+  it("true.js exports a boolean", () => {
+    assert.strictEqual(typeof trueValue, "boolean");
+  });
+
+  it("the function return value is a boolean", () => {
+    assert.strictEqual(typeof standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), "boolean");
+  });
+
+  it("true.js export is not a number", () => {
+    assert.notStrictEqual(typeof trueValue, "number");
+  });
+
+  it("true.js export is not a string", () => {
+    assert.notStrictEqual(typeof trueValue, "string");
+  });
+
+  it("true.js export is not an object", () => {
+    assert.notStrictEqual(typeof trueValue, "object");
+  });
+
+  it("true.js export is not undefined", () => {
+    assert.notStrictEqual(typeof trueValue, "undefined");
+  });
+
+  it("true.js export is not a symbol", () => {
+    assert.notStrictEqual(typeof trueValue, "symbol");
+  });
+
+  it("true.js export is not a bigint", () => {
+    assert.notStrictEqual(typeof trueValue, "bigint");
+  });
+
+  it("true.js export is not a function", () => {
+    assert.notStrictEqual(typeof trueValue, "function");
+  });
+});
+
+describe("VALUE", () => {
+  it("true.js strictly equals true", () => {
+    assert.strictEqual(trueValue, true);
+  });
+
+  it("function return strictly equals true", () => {
+    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+  });
+
+  it("true.js does NOT strictly equal false", () => {
+    assert.notStrictEqual(trueValue, false);
+  });
+
+  it("true.js does NOT strictly equal 1", () => {
+    assert.notStrictEqual(trueValue, 1);
+  });
+
+  it('true.js does NOT strictly equal "true"', () => {
+    assert.notStrictEqual(trueValue, "true");
+  });
+
+  it("true.js does NOT strictly equal 0", () => {
+    assert.notStrictEqual(trueValue, 0);
+  });
+
+  it("true.js does NOT strictly equal null", () => {
+    assert.notStrictEqual(trueValue, null);
+  });
+
+  it("true.js does NOT strictly equal undefined", () => {
+    assert.notStrictEqual(trueValue, undefined);
+  });
+
+  it("true.js does NOT strictly equal NaN", () => {
+    assert.notStrictEqual(trueValue, NaN);
+  });
+
+  it("true.js does NOT strictly equal an empty string", () => {
+    assert.notStrictEqual(trueValue, "");
+  });
+
+  it("true.js does NOT strictly equal an empty array", () => {
+    assert.notStrictEqual(trueValue, []);
+  });
+
+  it("true.js does NOT strictly equal an empty object", () => {
+    assert.notStrictEqual(trueValue, {});
+  });
+
+  it("true.js does NOT strictly equal Infinity", () => {
+    assert.notStrictEqual(trueValue, Infinity);
+  });
+
+  it("true.js does NOT strictly equal -Infinity", () => {
+    assert.notStrictEqual(trueValue, -Infinity);
+  });
+
+  it("true.js does NOT strictly equal -1", () => {
+    assert.notStrictEqual(trueValue, -1);
+  });
+});
+
+describe("LOGIC", () => {
+  it("true && true === true", () => {
+    assert.strictEqual(trueValue && trueValue, true);
+  });
+
+  it("true || false === true", () => {
+    assert.strictEqual(trueValue || false, true);
+  });
+
+  it("!true === false", () => {
+    assert.strictEqual(!trueValue, false);
+  });
+
+  it("!!true === true", () => {
+    assert.strictEqual(!!trueValue, true);
+  });
+
+  it("true && false === false", () => {
+    assert.strictEqual(trueValue && false, false);
+  });
+
+  it("true || true === true", () => {
+    assert.strictEqual(trueValue || true, true);
+  });
+
+  it("false || true === true", () => {
+    assert.strictEqual(false || trueValue, true);
+  });
+
+  it("true XOR false === 1 (via bitwise)", () => {
+    assert.strictEqual((trueValue ^ false) === 1, true);
+  });
+
+  it("true XOR true === 0 (via bitwise)", () => {
+    assert.strictEqual((trueValue ^ true) === 0, true);
+  });
+
+  it("true in a ternary selects the first branch", () => {
+    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);
+  });
+
+  it("true used in while loop runs exactly once (with break)", () => {
+    let count = 0;
+    while (trueValue) { count++; break; }
+    assert.strictEqual(count, 1);
+  });
+
+  it("Boolean(true) === true", () => {
+    assert.strictEqual(Boolean(trueValue), true);
+  });
+
+  it("true in a switch statement matches case true", () => {
+    let matched = false;
+    switch (trueValue) {
+      case true: matched = true; break;
+      default:   matched = false;
+    }
+    assert.strictEqual(matched, true);
+  });
+});
+
+describe("COERCION", () => {
+  it("true + 0 === 1", () => {
+    assert.strictEqual(trueValue + 0, 1);
+  });
+
+  it("true + 1 === 2", () => {
+    assert.strictEqual(trueValue + 1, 2);
+  });
+
+  it('true + "" === "true"', () => {
+    assert.strictEqual(trueValue + "", "true");
+  });
+
+  it('String(true) === "true"', () => {
+    assert.strictEqual(String(trueValue), "true");
+  });
+
+  it("Number(true) === 1", () => {
+    assert.strictEqual(Number(trueValue), 1);
+  });
+
+  it("parseInt(true) is NaN", () => {
+    assert.ok(isNaN(parseInt(trueValue)));
+  });
+
+  it("true > false", () => {
+    assert.ok(trueValue > false);
+  });
+
+  it("true >= true", () => {
+    assert.ok(trueValue >= true);
+  });
+
+  it("true * 1 === 1", () => {
+    assert.strictEqual(trueValue * 1, 1);
+  });
+
+  it("true * 0 === 0", () => {
+    assert.strictEqual(trueValue * 0, 0);
+  });
+
+  it("true / 1 === 1", () => {
+    assert.strictEqual(trueValue / 1, 1);
+  });
+
+  it("true - true === 0", () => {
+    assert.strictEqual(trueValue - trueValue, 0);
+  });
+
+  it("[true].join() === 'true'", () => {
+    assert.strictEqual([trueValue].join(), "true");
+  });
+
+  it("JSON.stringify(true) === 'true'", () => {
+    assert.strictEqual(JSON.stringify(trueValue), "true");
+  });
+
+  it("JSON round-trip preserves true", () => {
+    assert.strictEqual(JSON.parse(JSON.stringify(trueValue)), true);
+  });
+});
+
+describe("PROTO", () => {
+  it("Object(true) is a Boolean instance", () => {
+    assert.ok(Object(trueValue) instanceof Boolean);
+  });
+
+  it("Boolean.prototype.valueOf.call(true) === true", () => {
+    assert.strictEqual(Boolean.prototype.valueOf.call(trueValue), true);
+  });
+
+  it("Boolean.prototype.toString.call(true) === 'true'", () => {
+    assert.strictEqual(Boolean.prototype.toString.call(trueValue), "true");
+  });
+
+  it("Object.is(true, true) === true", () => {
+    assert.ok(Object.is(trueValue, true));
+  });
+
+  it("Object.is(true, 1) === false", () => {
+    assert.ok(!Object.is(trueValue, 1));
+  });
+
+  it("Object.is(true, false) === false", () => {
+    assert.ok(!Object.is(trueValue, false));
+  });
+
+  it("boxed true has no own enumerable properties", () => {
+    assert.deepStrictEqual(Object.keys(Object(trueValue)), []);
+  });
+});
+
+describe("ARRAY", () => {
+  it("[true].includes(true)", () => {
+    assert.ok([trueValue].includes(true));
+  });
+
+  it("[true].indexOf(true) === 0", () => {
+    assert.strictEqual([trueValue].indexOf(true), 0);
+  });
+
+  it("[true].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));
+  });
+
+  it("[true].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);
+  });
+
+  it("[true].map(x => !x) deep equals [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);
+  });
+
+  it("Array.from([true])[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);
+  });
+
+  it("a Set containing true 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);
+  });
+});
+
+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");
+  });
+});
+
+describe("FUNCTION", () => {
+  it("has the correct name", () => {
+    assert.strictEqual(
+      standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.name,
+      "standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue"
+    );
+  });
+
+  it("has length 0", () => {
+    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.length, 0);
+  });
+
+  it("calling with no arguments returns true", () => {
+    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+  });
+
+  it("calling with one argument still returns 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
+    );
+  });
+
+  it("calling 1000 times always returns 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);
+  });
+
+  it("is callable via .apply()", () => {
+    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.apply(null, []), true);
+  });
+
+  it("is callable via .bind()()", () => {
+    assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue.bind(null)(), true);
+  });
+
+  it("works wrapped in a closure", () => {
+    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]
+    );
+  });
+
+  it("works when passed to Array.prototype.filter", () => {
+    assert.deepStrictEqual(
+      [1, 2, 3].filter(() => standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue()),
+      [1, 2, 3]
+    );
+  });
+
+  it("works inside a Promise", () => {
+    return Promise.resolve().then(() => {
+      assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+    });
+  });
+
+  it("works inside async/await", async () => {
+    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"));
+  });
+
+  it("requiring index.js twice returns same function reference", () => {
+    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);
+  });
+});
+
+describe("COMPETITOR", () => {
+  it("our true equals Boolean(1)", () => {
+    assert.strictEqual(trueValue, Boolean(1));
+  });
+
+  it("our true equals !!1", () => {
+    assert.strictEqual(trueValue, !!1);
+  });
+
+  it("our true equals !!{}", () => {
+    assert.strictEqual(trueValue, !!{});
+  });
+
+  it('our true equals !!"nonempty"', () => {
+    assert.strictEqual(trueValue, !!"nonempty");
+  });
+
+  it("our true equals (1 === 1)", () => {
+    assert.strictEqual(trueValue, 1 === 1);
+  });
+
+  it("our true equals Array.isArray([])", () => {
+    assert.strictEqual(trueValue, Array.isArray([]));
+  });
+
+  it("our true equals 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);
+  });
+
+  it("true can be stored and retrieved from a plain object", () => {
+    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);
+  });
+
+  it("true survives spread operator", () => {
+    assert.strictEqual({ ...{ truth: trueValue } }.truth, true);
+  });
+
+  it("true survives structuredClone", () => {
+    assert.strictEqual(structuredClone({ truth: trueValue }).truth, true);
+  });
+
+  it("true is truthy", () => {
+    assert.ok(trueValue);
+  });
+
+  it("!true is falsy", () => {
+    assert.ok(!(!trueValue));
+  });
+
+  it("true.toString() returns 'true'", () => {
+    assert.strictEqual(trueValue.toString(), "true");
+  });
+
+  it("true.valueOf() returns true", () => {
+    assert.strictEqual(trueValue.valueOf(), true);
+  });
+
+  it("typeof true is 'boolean'", () => {
+    assert.strictEqual(typeof trueValue, "boolean");
+  });
+
+  it("true as array index accesses index 1, not 0", () => {
+    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");
+  });
+
+  it("true ?? false returns true", () => {
+    assert.strictEqual(trueValue ?? false, true);
+  });
+
+  it("optional chaining with true works fine", () => {
+    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);
+  });
+
+  it("true survives 500 double-negations", () => {
+    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);
+  });
+
+  it("true works inside Symbol.iterator protocol", () => {
+    const iterable = {
+      [Symbol.iterator]() {
+        let done = false;
+        return {
+          next() {
+            if (!done) { done = true; return { value: standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), done: false }; }
+            return { value: undefined, done: true };
+          },
+        };
+      },
+    };
+    const [first] = iterable;
+    assert.strictEqual(first, true);
+  });
+});
+
+describe("SECURITY", () => {
+  it("monkey-patching Boolean does not corrupt true", () => {
+    const OriginalBoolean = Boolean;
+    try {
+      global.Boolean = () => false;
+      assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+    } finally {
+      global.Boolean = OriginalBoolean;
+    }
+  });
+
+  it("cached primitive cannot be retroactively tampered with", () => {
+    assert.strictEqual(trueValue, true);
+  });
+
+  it("prototype pollution does not affect the primitive true", () => {
+    try {
+      Object.prototype.truth = false;
+      assert.strictEqual(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue(), true);
+    } finally {
+      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);
+  });
+
+  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);
+  });
+});
+
+describe("REGRESSION", () => {
+  it("true.js does not return false", () => {
+    assert.notStrictEqual(trueValue, false);
+  });
+
+  it("true.js does not return 0", () => {
+    assert.notStrictEqual(trueValue, 0);
+  });
+
+  it("true.js does not return null", () => {
+    assert.notStrictEqual(trueValue, null);
+  });
+
+  it("true.js does not return undefined", () => {
+    assert.notStrictEqual(trueValue, undefined);
+  });
+
+  it('true.js does not return the string "false"', () => {
+    assert.notStrictEqual(trueValue, "false");
+  });
+
+  it("the exported function is truthy", () => {
+    assert.ok(standardJavaScriptFunctionThatReturnsTheGeneralBooleanValueTrue);
+  });
+});
+
+describe("INTEGRATION", () => {
+  it("end-to-end truth pipeline", () => {
+    const foundation = require("./true");
+    assert.strictEqual(foundation, true);
+
+    const fn = require("./index");
+    assert.strictEqual(typeof fn, "function");
+
+    const output = fn();
+    assert.strictEqual(output, true);
+
+    assert.strictEqual(foundation, output);
+
+    assert.strictEqual(output ? "truth works" : "something is very wrong", "truth works");
+  });
+});

package/true.js

@@ -1,8 +1,11 @@
-const QubitCircuit = require("./qubit-circuit")
-const construct = require("construct-new-second")
+// Critical enterprise code.
 
-module.exports = (function returnTrue() {
-  let qc = construct(QubitCircuit)
-  qc = qc.x()
-  return qc.measure()
-})()
+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()],
+		)
+  })()

package/qubit-circuit.js

@@ -1,162 +0,0 @@
-const C = {
-  I: [0, 1],
-  ZERO: [0, 0],
-  ONE: [1, 0],
-  NEG_ONE: [-1, 0],
-  INV_SQRT2: [1 / Math.sqrt(2), 0],
-  NEG_INV_SQRT2: [-1 / Math.sqrt(2), 0],
-
-  add: function ([ar, ai], [br, bi]) {
-    return [ar + br, ai + bi]
-  },
-  sub: function ([ar, ai], [br, bi]) {
-    return [ar - br, ai - bi]
-  },
-  multiply: function ([ar, ai], [br, bi]) {
-    return [ar * br - ai * bi, ar * bi + ar * bi]
-  },
-  scale: function ([r, i], s) {
-    return [r * s, i * s]
-  },
-
-  conjugate: function ([r, i]) {
-    return [r, -i]
-  },
-  magnitudeSquared: function ([r, i]) {
-    return r * r + i * i
-  },
-  format: function ([r, i]) {
-    if (Math.abs(i) < 1e-9) return `${r.toFixed(4)}`
-    if (Math.abs(r) < 1e-9) return `${i.toFixed(4)}i`
-    return `${r.toFixed(4)}${i >= 0 ? "+" : ""}${i.toFixed(4)}i`
-  },
-}
-
-const GATES = {
-  X: [
-    [C.ZERO, C.ONE],
-    [C.ONE, C.ZERO],
-  ],
-  Y: [
-    [C.ZERO, C.scale(C.I, -1)],
-    [C.I, C.ZERO],
-  ],
-  Z: [
-    [C.ONE, C.ZERO],
-    [C.ZERO, C.NEG_ONE],
-  ],
-  H: [
-    [C.INV_SQRT2, C.INV_SQRT2],
-    [C.INV_SQRT2, C.multiply(C.INV_SQRT2, C.NEG_ONE)],
-  ],
-  S: [
-    [C.ONE, C.ZERO],
-    [C.ZERO, C.I],
-  ],
-  T: [
-    [C.ONE, C.ZERO],
-    [
-      C.ZERO,
-      C.multiply(
-        C.scale(C.ONE, Math.cos(Math.PI / 4)),
-        C.add(C.ONE, C.scale(C.I, Math.tan(Math.PI / 4)))
-      ),
-    ],
-  ],
-
-  Rz: (theta) => {
-    const h_t = theta / 2
-    const cos_t = [Math.cos(h_t), 0]
-    const sin_t = [Math.sin(h_t), 0]
-    const neg_i_sin_t = C.multiply(C.scale(C.I, -1), sin_t)
-
-    return [
-      [C.add(cos_t, neg_i_sin_t), C.ZERO],
-      [C.ZERO, C.sub(cos_t, neg_i_sin_t)],
-    ]
-  },
-}
-
-class QubitCircuit {
-  static get GATES() {
-    return GATES
-  }
-
-  constructor() {
-    this.state = [C.ONE, C.ZERO]
-    this.history = []
-  }
-
-  apply(gate) {
-    const term00 = C.multiply(gate[0][0], this.state[0])
-    const term01 = C.multiply(gate[0][1], this.state[1])
-    const newAlpha = C.add(term00, term01)
-
-    const term10 = C.multiply(gate[1][0], this.state[0])
-    const term11 = C.multiply(gate[1][1], this.state[1])
-    const newBeta = C.add(term10, term11)
-
-    this.state = [newAlpha, newBeta]
-    this.history.push(gate)
-    return this
-  }
-
-  getProbabilities() {
-    const p0 = C.magnitudeSquared(this.state[0])
-    const p1 = C.magnitudeSquared(this.state[1])
-    return { 0: p0, 1: p1 }
-  }
-
-  measure() {
-    const p1 = C.magnitudeSquared(this.state[1])
-    const result = Math.random() < p1
-
-    if (result) {
-      this.state = [C.ZERO, C.ONE]
-    } else {
-      this.state = [C.ONE, C.ZERO]
-    }
-
-    return result
-  }
-
-  sample(shots = 1000) {
-    const counts = { 0: 0, 1: 0 }
-    const p1 = C.magnitudeSquared(this.state[1])
-
-    for (let i = 0; i < shots; i++) {
-      if (Math.random() < p1) {
-        counts["1"]++
-      } else {
-        counts["0"]++
-      }
-    }
-    return counts
-  }
-
-  toString() {
-    const [alpha, beta] = this.state
-    return `${C.format(alpha)}|0> + ${C.format(beta)}|1>`
-  }
-
-  x() {
-    return this.apply(GATES.X)
-  }
-  h() {
-    return this.apply(GATES.H)
-  }
-  z() {
-    return this.apply(GATES.Z)
-  }
-  s() {
-    return this.apply(GATES.S)
-  }
-  t() {
-    return this.apply(GATES.T)
-  }
-  rz(theta) {
-    return this.apply(GATES.Rz(theta))
-  }
-}
-
-module.exports = QubitCircuit