immediate-error 12.2.1 → 12.2.2

package/README.md

@@ -40,6 +40,8 @@ immediateError("person not hungry error", ErrorType.PersonNotHungryError) // thr
 
 immediateError("portions error", ErrorType.PortionsError) // throws a PortionsError
 
+immediateError("falsejs validation failed to pass error", ErrorType.FalseJSValidationFailedToPassError) // throws a FalseJSValidationFailedToPassError
+
 class MyCustomError extends Error {
   constructor (message) {
     super("Custom: " + message)
@@ -107,6 +109,7 @@ console.log(MESSAGES.DOMAIN.VEGETABLES_DO_NOT_TALK_ERROR.VEGETABLES_CAN_NOT_TALK
 console.log(MESSAGES.DOMAIN.PERSON_NOT_HUNGRY_ERROR.IS_NOT_HUNGRY_AND_CANNOT_BE_FED) // "% is not hungry and cannot be fed"
 console.log(MESSAGES.DOMAIN.PORTIONS_ERROR.PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER) // "Portion size expected to be a positive integer"
 console.log(MESSAGES.DOMAIN.PORTIONS_ERROR.TOO_MANY_PORTIONS) // "Too many portions"
+console.log(MESSAGES.DOMAIN.FALSEJS_VALIDATION_FAILED_TO_PASS_ERROR.VALIDATION_FAILED_TO_PASS) // "Validation failed to pass"
 ```
 
 ## `immediate-error` 2.0.0

package/index.d.ts

@@ -11,6 +11,7 @@ export enum ErrorType {
   VegetablesDoNotTalkError = 8,
   PersonNotHungryError = 9,
   PortionsError = 10,
+  FalseJSValidationFailedToPassError = 11
 }
 export type CustomError = {
   new (message: string): Error
@@ -32,6 +33,7 @@ export function getError(
 ): CustomError
 export function getError(errorType: ErrorType.PersonNotHungryError): CustomError
 export function getError(errorType: ErrorType.PortionsError): CustomError
+export function getError(errorType: ErrorType.FalseJSValidationFailedToPassError): CustomError
 export function getError(errorType: ErrorType | CustomError): CustomError
 export function immediateError(
   message?: string,
@@ -78,6 +80,9 @@ export const MESSAGES: {
     PORTIONS_ERROR: {
       PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER: "Portion size expected to be a positive integer",
       TOO_MANY_PORTIONS: "Too many portions"
+    },
+    FALSEJS_VALIDATION_FAILED_TO_PASS_ERROR: {
+      VALIDATION_FAILED_TO_PASS: "Validation failed to pass"
     }
   }
 }

package/index.js

@@ -114,6 +114,8 @@ const $SyntaxError = require("es-error-intrinsics/SyntaxError")
 const $TypeError = require("es-error-intrinsics/TypeError")
 const $URIError = require("es-error-intrinsics/URIError")
 
+const FalseJSValidationFailedToPassError = require("@falsejs/validation-failed-to-pass-error")
+
 const captureStackTrace = GetIntrinsic("%Error.captureStackTrace%", trueValue())
 
 const default_error = concat(E, R, R, O, R, EXCLAMATION_POINT)
@@ -130,6 +132,7 @@ const ErrorType = deepFreeze({
   VegetablesDoNotTalkError: eight,
   PersonNotHungryError: nine,
   PortionsError: ten,
+  FalseJSValidationFailedToPassError: eleven
 })
 
 const ErrorMap = construct({
@@ -285,6 +288,8 @@ objGetMember(
       return result
     }),
   )
+
+  ErrorMap.set(ErrorType.FalseJSValidationFailedToPassError, FalseJSValidationFailedToPassError)
 })
 
 function CreateSleepFunction(delay) {
@@ -399,6 +404,9 @@ exports.MESSAGES = {
     PORTIONS_ERROR: {
       PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER: portionSizeExpectedToBeAPositiveIntegerMessage,
       TOO_MANY_PORTIONS: tooManyPortionsMessage
+    },
+    FALSEJS_VALIDATION_FAILED_TO_PASS_ERROR: {
+      VALIDATION_FAILED_TO_PASS: "Validation failed to pass" // use the error message directly as we don't want to install FalseJS because it is really heavy.
     }
   }
 }

package/index.test.js

@@ -1,257 +1,265 @@
-// tests
-
-const {
-  immediateError,
-  ErrorType,
-  throwWhatever,
-  getError,
-  MESSAGES
-} = require("./index")
-
-describe("immediateError utility", () => {
-  test("throws a regular Error with default message when no arguments are passed", () => {
-    expect(() => immediateError()).toThrow(Error)
-    expect(() => immediateError()).toThrow("ERROR!")
-  })
-
-  test("throws a regular Error with a custom message", () => {
-    expect(() => immediateError("Aaaaah")).toThrow(Error)
-    expect(() => immediateError("Aaaaah")).toThrow("Aaaaah")
-  })
-
-  test.each([
-    ["BaseError", ErrorType.BaseError, Error],
-    ["EvalError", ErrorType.EvalError, EvalError],
-    ["RangeError", ErrorType.RangeError, RangeError],
-    ["ReferenceError", ErrorType.ReferenceError, ReferenceError],
-    ["SyntaxError", ErrorType.SyntaxError, SyntaxError],
-    ["TypeError", ErrorType.TypeError, TypeError],
-    ["URIError", ErrorType.URIError, URIError],
-  ])("throws % when specified", (name, type, constructor) => {
-    expect(() => immediateError("test message", type)).toThrow(constructor)
-  })
-
- test.each([
-    ["FruitConsumptionError", ErrorType.FruitConsumptionError],
-    ["VegetablesDoNotTalkError", ErrorType.VegetablesDoNotTalkError],
-    ["PersonNotHungryError", ErrorType.PersonNotHungryError],
-    ["PortionsError", ErrorType.PortionsError],
-  ])("throws domain-specific % correctly", (name, type) => {
-    const expectedConstructor = getError(type)
-    expect(() => immediateError("enterprise failure", type)).toThrow(expectedConstructor)
-    expect(() => immediateError("enterprise failure", type)).toThrow("enterprise failure")
-  })
-
-  test("throws a custom user-defined Error class", () => {
-    class MyCustomError extends Error {
-      constructor(message) {
-        super("Custom: " + message)
-        this.name = "MyCustomError"
-      }
-    }
-
-    expect(() => immediateError("Error!", MyCustomError)).toThrow(MyCustomError)
-    expect(() => immediateError("Error!", MyCustomError)).toThrow(
-      "Custom: Error!",
-    )
-  })
-
-  test("captures stack trace correctly and hides internal frames", () => {
-    try {
-      immediateError("stack check")
-    } catch (error) {
-      expect(error.stack).not.toMatch(/at immediateError/)
-    }
-  })
-})
-
-const { attempt } = require("./index")
-
-describe("attempt utility", () => {
-  test("works as a standard function", () => {
-    let called = false
-    attempt(() => {
-      called = true
-    }).end()
-    expect(called).toBe(true)
-  })
-
-  test("works as a constructor returning an instance", () => {
-    const instance = new attempt(() => {})
-    expect(instance).toBeDefined()
-    expect(typeof instance.rescue).toBe("function")
-  })
-
-  test("triggers rescue when the handler fails", () => {
-    let errorCaught = false
-    attempt(() => {
-      throw new Error("fail")
-    })
-      .rescue((e) => {
-        errorCaught = true
-        expect(e.message).toBe("fail")
-      })
-      .end()
-    expect(errorCaught).toBe(true)
-  })
-
-  test("triggers else only when the handler succeeds", () => {
-    let elseCalled = false
-    attempt(() => {
-      return "success"
-    })
-      .else(() => {
-        elseCalled = true
-      })
-      .end()
-    expect(elseCalled).toBe(true)
-  })
-
-  test("triggers ensure regardless of success or failure", () => {
-    let counter = 0
-
-    attempt(() => {})
-      .ensure(() => {
-        counter++
-      })
-      .end()
-
-    attempt(() => {
-      throw new Error()
-    })
-      .rescue(() => {})
-      .ensure(() => {
-        counter++
-      })
-      .end()
-
-    expect(counter).toBe(2)
-  })
-
-  test("returns this (the instance) from chaining methods", () => {
-    const a = attempt(() => {})
-    const b = a.rescue(() => {})
-    const c = b.else(() => {})
-    const d = c.ensure(() => {})
-
-    expect(a).toBe(d)
-  })
-})
-
-const { delayedError } = require("./index")
-
-describe("delayedError utility", () => {
-  const SHORT_DELAY = 10
-
-  test("throws the error after a specified delay", async () => {
-    const start = Date.now()
-
-    try {
-      await delayedError("Delayed fail", ErrorType.BaseError, SHORT_DELAY)
-    } catch (error) {
-      const duration = Date.now() - start
-      expect(duration).toBeGreaterThanOrEqual(SHORT_DELAY)
-      expect(error.message).toBe("Delayed fail")
-    }
-  })
-
-  test("uses default error message and type if only delay is provided", async () => {
-    try {
-      await delayedError(undefined, undefined, SHORT_DELAY)
-    } catch (error) {
-      expect(error.message).toBe("ERROR!")
-      expect(error).toBeInstanceOf(Error)
-    }
-  })
-
-  test("respects custom error types in delayed mode", async () => {
-    try {
-      await delayedError("Type fail", ErrorType.TypeError, SHORT_DELAY)
-    } catch (error) {
-      expect(error).toBeInstanceOf(TypeError)
-      expect(error.message).toBe("Type fail")
-    }
-  })
-})
-
-describe("throwWhatever utility", () => {
-  test("throws a standard error object when passed", () => {
-    const err = new Error("standard fail")
-    expect(() => throwWhatever(err)).toThrow("standard fail")
-  })
-
-  test("throws primitive false when passed false", () => {
-    try {
-      throwWhatever(false)
-    } catch (e) {
-      expect(e).toBe(false)
-    }
-  })
-
-  test("throws primitive zero when passed 0", () => {
-    try {
-      throwWhatever(0)
-    } catch (e) {
-      expect(e).toBe(0)
-    }
-  })
-
-  test("throws a string directly when passed a string", () => {
-    expect(() => throwWhatever("Direct String")).toThrow("Direct String")
-  })
-
-  test("integrates with getError for custom domain errors", () => {
-    const FruitError = getError(ErrorType.FruitConsumptionError)
-    const err = new FruitError("Too many apples")
-    expect(() => throwWhatever(err)).toThrow(FruitError)
-  })
-})
-
-describe("getError utility", () => {
-  test("returns the intrinsic Error constructor for BaseError", () => {
-    const result = getError(ErrorType.BaseError)
-    expect(result).toBe(Error)
-  })
-
-  test("returns the intrinsic TypeError constructor for TypeError", () => {
-    const result = getError(ErrorType.TypeError)
-    expect(result).toBe(TypeError)
-  })
-
-  test("successfully extracts FruitConsumptionError from jsfruit logic", () => {
-    const FruitError = getError(ErrorType.FruitConsumptionError)
-    expect(typeof FruitError).toBe("function")
-    const instance = new FruitError("test")
-    expect(instance).toBeInstanceOf(Error)
-  })
-
-  test("successfully extracts PersonNotHungryError from libperson logic", () => {
-    const HungerError = getError(ErrorType.PersonNotHungryError)
-    expect(typeof HungerError).toBe("function")
-    expect(new HungerError()).toBeDefined()
-  })
-
-  test("successfully extracts PortionsError from libguacamole logic", () => {
-    const GuacError = getError(ErrorType.PortionsError)
-    expect(typeof GuacError).toBe("function")
-    expect(GuacError.name).toBe("PortionsError")
-  })
-
-  test("returns the same constructor when passed a constructor (identity)", () => {
-    class MyError extends Error {}
-    const result = getError(MyError)
-    expect(result).toBe(MyError)
-  })
-})
-
-describe("error messages", () => {
-  test.each([
-    ["no fruit left", MESSAGES.DOMAIN.FRUIT_CONSUMPTION_ERROR.NO_FRUIT_LEFT],
-    ["vegetables can not talk", MESSAGES.DOMAIN.VEGETABLES_DO_NOT_TALK_ERROR.VEGETABLES_CAN_NOT_TALK],
-    ["% is not hungry and cannot be fed", MESSAGES.DOMAIN.PERSON_NOT_HUNGRY_ERROR.IS_NOT_HUNGRY_AND_CANNOT_BE_FED],
-    ["Portion size expected to be a positive integer", MESSAGES.DOMAIN.PORTIONS_ERROR.PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER],
-    ["Too many portions", MESSAGES.DOMAIN.PORTIONS_ERROR.TOO_MANY_PORTIONS]
-  ])("provides error message \"%s\" correctly", (a, b) => {
-    expect(a).toEqual(b)
-  })
-})
+// tests
+
+const {
+  immediateError,
+  ErrorType,
+  throwWhatever,
+  getError,
+  MESSAGES
+} = require("./index")
+
+describe("immediateError utility", () => {
+  test("throws a regular Error with default message when no arguments are passed", () => {
+    expect(() => immediateError()).toThrow(Error)
+    expect(() => immediateError()).toThrow("ERROR!")
+  })
+
+  test("throws a regular Error with a custom message", () => {
+    expect(() => immediateError("Aaaaah")).toThrow(Error)
+    expect(() => immediateError("Aaaaah")).toThrow("Aaaaah")
+  })
+
+  test.each([
+    ["BaseError", ErrorType.BaseError, Error],
+    ["EvalError", ErrorType.EvalError, EvalError],
+    ["RangeError", ErrorType.RangeError, RangeError],
+    ["ReferenceError", ErrorType.ReferenceError, ReferenceError],
+    ["SyntaxError", ErrorType.SyntaxError, SyntaxError],
+    ["TypeError", ErrorType.TypeError, TypeError],
+    ["URIError", ErrorType.URIError, URIError],
+  ])("throws % when specified", (name, type, constructor) => {
+    expect(() => immediateError("test message", type)).toThrow(constructor)
+  })
+
+ test.each([
+    ["FruitConsumptionError", ErrorType.FruitConsumptionError],
+    ["VegetablesDoNotTalkError", ErrorType.VegetablesDoNotTalkError],
+    ["PersonNotHungryError", ErrorType.PersonNotHungryError],
+    ["PortionsError", ErrorType.PortionsError],
+    ["FalseJSValidationFailedToPassError", ErrorType.FalseJSValidationFailedToPassError]
+  ])("throws domain-specific % correctly", (name, type) => {
+    const expectedConstructor = getError(type)
+    expect(() => immediateError("enterprise failure", type)).toThrow(expectedConstructor)
+    expect(() => immediateError("enterprise failure", type)).toThrow("enterprise failure")
+  })
+
+  test("throws a custom user-defined Error class", () => {
+    class MyCustomError extends Error {
+      constructor(message) {
+        super("Custom: " + message)
+        this.name = "MyCustomError"
+      }
+    }
+
+    expect(() => immediateError("Error!", MyCustomError)).toThrow(MyCustomError)
+    expect(() => immediateError("Error!", MyCustomError)).toThrow(
+      "Custom: Error!",
+    )
+  })
+
+  test("captures stack trace correctly and hides internal frames", () => {
+    try {
+      immediateError("stack check")
+    } catch (error) {
+      expect(error.stack).not.toMatch(/at immediateError/)
+    }
+  })
+})
+
+const { attempt } = require("./index")
+
+describe("attempt utility", () => {
+  test("works as a standard function", () => {
+    let called = false
+    attempt(() => {
+      called = true
+    }).end()
+    expect(called).toBe(true)
+  })
+
+  test("works as a constructor returning an instance", () => {
+    const instance = new attempt(() => {})
+    expect(instance).toBeDefined()
+    expect(typeof instance.rescue).toBe("function")
+  })
+
+  test("triggers rescue when the handler fails", () => {
+    let errorCaught = false
+    attempt(() => {
+      throw new Error("fail")
+    })
+      .rescue((e) => {
+        errorCaught = true
+        expect(e.message).toBe("fail")
+      })
+      .end()
+    expect(errorCaught).toBe(true)
+  })
+
+  test("triggers else only when the handler succeeds", () => {
+    let elseCalled = false
+    attempt(() => {
+      return "success"
+    })
+      .else(() => {
+        elseCalled = true
+      })
+      .end()
+    expect(elseCalled).toBe(true)
+  })
+
+  test("triggers ensure regardless of success or failure", () => {
+    let counter = 0
+
+    attempt(() => {})
+      .ensure(() => {
+        counter++
+      })
+      .end()
+
+    attempt(() => {
+      throw new Error()
+    })
+      .rescue(() => {})
+      .ensure(() => {
+        counter++
+      })
+      .end()
+
+    expect(counter).toBe(2)
+  })
+
+  test("returns this (the instance) from chaining methods", () => {
+    const a = attempt(() => {})
+    const b = a.rescue(() => {})
+    const c = b.else(() => {})
+    const d = c.ensure(() => {})
+
+    expect(a).toBe(d)
+  })
+})
+
+const { delayedError } = require("./index")
+
+describe("delayedError utility", () => {
+  const SHORT_DELAY = 10
+
+  test("throws the error after a specified delay", async () => {
+    const start = Date.now()
+
+    try {
+      await delayedError("Delayed fail", ErrorType.BaseError, SHORT_DELAY)
+    } catch (error) {
+      const duration = Date.now() - start
+      expect(duration).toBeGreaterThanOrEqual(SHORT_DELAY)
+      expect(error.message).toBe("Delayed fail")
+    }
+  })
+
+  test("uses default error message and type if only delay is provided", async () => {
+    try {
+      await delayedError(undefined, undefined, SHORT_DELAY)
+    } catch (error) {
+      expect(error.message).toBe("ERROR!")
+      expect(error).toBeInstanceOf(Error)
+    }
+  })
+
+  test("respects custom error types in delayed mode", async () => {
+    try {
+      await delayedError("Type fail", ErrorType.TypeError, SHORT_DELAY)
+    } catch (error) {
+      expect(error).toBeInstanceOf(TypeError)
+      expect(error.message).toBe("Type fail")
+    }
+  })
+})
+
+describe("throwWhatever utility", () => {
+  test("throws a standard error object when passed", () => {
+    const err = new Error("standard fail")
+    expect(() => throwWhatever(err)).toThrow("standard fail")
+  })
+
+  test("throws primitive false when passed false", () => {
+    try {
+      throwWhatever(false)
+    } catch (e) {
+      expect(e).toBe(false)
+    }
+  })
+
+  test("throws primitive zero when passed 0", () => {
+    try {
+      throwWhatever(0)
+    } catch (e) {
+      expect(e).toBe(0)
+    }
+  })
+
+  test("throws a string directly when passed a string", () => {
+    expect(() => throwWhatever("Direct String")).toThrow("Direct String")
+  })
+
+  test("integrates with getError for custom domain errors", () => {
+    const FruitError = getError(ErrorType.FruitConsumptionError)
+    const err = new FruitError("Too many apples")
+    expect(() => throwWhatever(err)).toThrow(FruitError)
+  })
+})
+
+describe("getError utility", () => {
+  test("returns the intrinsic Error constructor for BaseError", () => {
+    const result = getError(ErrorType.BaseError)
+    expect(result).toBe(Error)
+  })
+
+  test("returns the intrinsic TypeError constructor for TypeError", () => {
+    const result = getError(ErrorType.TypeError)
+    expect(result).toBe(TypeError)
+  })
+
+  test("successfully extracts FruitConsumptionError from jsfruit logic", () => {
+    const FruitError = getError(ErrorType.FruitConsumptionError)
+    expect(typeof FruitError).toBe("function")
+    const instance = new FruitError("test")
+    expect(instance).toBeInstanceOf(Error)
+  })
+
+  test("successfully extracts PersonNotHungryError from libperson logic", () => {
+    const HungerError = getError(ErrorType.PersonNotHungryError)
+    expect(typeof HungerError).toBe("function")
+    expect(new HungerError()).toBeDefined()
+  })
+
+  test("successfully extracts PortionsError from libguacamole logic", () => {
+    const GuacError = getError(ErrorType.PortionsError)
+    expect(typeof GuacError).toBe("function")
+    expect(GuacError.name).toBe("PortionsError")
+  })
+
+  test("successfully extracts FalseJSValidationFailedToPassError", () => {
+    const FalseJSValidationFailedToPassError = getError(ErrorType.FalseJSValidationFailedToPassError)
+    expect(typeof FalseJSValidationFailedToPassError).toBe("function")
+    expect(FalseJSValidationFailedToPassError.name).toBe("FalseJSValidationFailedToPassError")
+  })
+
+  test("returns the same constructor when passed a constructor (identity)", () => {
+    class MyError extends Error {}
+    const result = getError(MyError)
+    expect(result).toBe(MyError)
+  })
+})
+
+describe("error messages", () => {
+  test.each([
+    ["no fruit left", MESSAGES.DOMAIN.FRUIT_CONSUMPTION_ERROR.NO_FRUIT_LEFT],
+    ["vegetables can not talk", MESSAGES.DOMAIN.VEGETABLES_DO_NOT_TALK_ERROR.VEGETABLES_CAN_NOT_TALK],
+    ["% is not hungry and cannot be fed", MESSAGES.DOMAIN.PERSON_NOT_HUNGRY_ERROR.IS_NOT_HUNGRY_AND_CANNOT_BE_FED],
+    ["Portion size expected to be a positive integer", MESSAGES.DOMAIN.PORTIONS_ERROR.PORTION_SIZE_EXPECTED_TO_BE_A_POSITIVE_INTEGER],
+    ["Too many portions", MESSAGES.DOMAIN.PORTIONS_ERROR.TOO_MANY_PORTIONS],
+    ["Validation failed to pass", MESSAGES.DOMAIN.FALSEJS_VALIDATION_FAILED_TO_PASS_ERROR.VALIDATION_FAILED_TO_PASS]
+  ])("provides error message \"%s\" correctly", (a, b) => {
+    expect(a).toEqual(b)
+  })
+})

package/package.json

@@ -1,139 +1,140 @@
-{
-  "name": "immediate-error",
-  "version": "12.2.1",
-  "description": "enterprise errors",
-  "main": "index.js",
-  "scripts": {
-    "test": "jest index.test.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/enterprise-npm-ai/immediate-error.git"
-  },
-  "keywords": [
-    "error",
-    "throw",
-    "immediate-error",
-    "tool",
-    "10x'ness",
-    "10x'ly made",
-    "10x",
-    "10x-engineer",
-    "10x engineer",
-    "10x engineering",
-    "jsfruit",
-    "libperson",
-    "libvegetable",
-    "bail",
-    "throw-error",
-    "sigma",
-    "lifesaver",
-    "framework",
-    "js",
-    "ecmascript",
-    "javascript",
-    "licensed",
-    "jest",
-    "67",
-    "fp",
-    "enterprise-npm-ai",
-    "sigmaskibidi",
-    "tj-commits",
-    "skibidi-toilet-hacker",
-    "stevelib"
-  ],
-  "author": "10x'ly Made",
-  "license": "EGPSL10X-1.0",
-  "bugs": {
-    "url": "https://github.com/enterprise-npm-ai/immediate-error/issues"
-  },
-  "homepage": "https://github.com/enterprise-npm-ai/immediate-error#readme",
-  "dependencies": {
-    "@10xly/strict-equals": "1.0.1",
-    "@characters/right-parenthesis": "2.1.0",
-    "@extra-array/head": "^2.10.19",
-    "@extra-array/last": "^2.10.19",
-    "@is-(unknown)/is-false": "1.5.0",
-    "@is-(unknown)/is-nan": "1.0.0",
-    "@is-(unknown)/is-negative-zero": "1.0.0",
-    "@is-(unknown)/is-nil": "1.2.0",
-    "@is-(unknown)/is-null": "1.3.0",
-    "@is-(unknown)/is-string": "^1.0.0",
-    "@is-(unknown)/is-undefined": "1.3.0",
-    "@negative-numbers/eighty-seven": "^1.0.0",
-    "@negative-numbers/zero": "1.0.0",
-    "@positive-numbers/eight": "^3.0.0",
-    "@positive-numbers/eleven": "^3.0.0",
-    "@positive-numbers/five": "^3.0.0",
-    "@positive-numbers/four": "^3.0.0",
-    "@positive-numbers/nine": "^3.0.0",
-    "@positive-numbers/one": "^3.0.0",
-    "@positive-numbers/seven": "^3.0.0",
-    "@positive-numbers/seventeen": "^3.0.0",
-    "@positive-numbers/six": "^3.0.0",
-    "@positive-numbers/ten": "^3.0.0",
-    "@positive-numbers/thirty-three": "^3.0.0",
-    "@positive-numbers/three": "^3.0.0",
-    "@positive-numbers/twenty-five": "^4.0.0",
-    "@positive-numbers/twenty-nine": "^3.0.0",
-    "@positive-numbers/two": "^3.0.0",
-    "@positive-numbers/zero": "^5.0.0",
-    "@redux-saga/delay-p": "^1.3.1",
-    "@rightpad/concat": "^1.0.0",
-    "@rightpad/convert2string": "^1.0.0",
-    "@uppercase-letters/e": "^3.0.0",
-    "@uppercase-letters/o": "^3.0.0",
-    "@uppercase-letters/r": "^3.0.0",
-    "array-get-member": "^1.0.4",
-    "array.prototype.join": "^1.0.4",
-    "attempt-statement": "^1.2.1",
-    "bail": "^1.0.5",
-    "basic-functions": "^1.0.6",
-    "bigint-intrinsic-ai": "1.0.0",
-    "construct-new": "^2.0.8",
-    "deep-freeze-node3": "^1.1.0",
-    "empty-string": "1.1.1",
-    "es-error-intrinsics": "^1.0.1",
-    "es-intrinsic-cache": "^1.0.1",
-    "es-logical-nullish-coalescing-operator": "^1.0.0",
-    "false-value": "^2.0.6",
-    "fizzbuzz-enterprise": "^1.0.0",
-    "for-each": "^0.3.5",
-    "function-bind": "^1.1.2",
-    "get-member": "^1337.69.420",
-    "is-": "^1.0.0",
-    "is-not-integer": "^1.0.2",
-    "jsfruit": "^1.1.0",
-    "libguacamole": "^1.0.0",
-    "libperson": "^1.0.0",
-    "libvegetable": "^1.0.0",
-    "lodash.stubarray": "^4.13.0",
-    "lolite.__private.multiplyfallback": "^1.1.17",
-    "node-call.then": "^1.0.0",
-    "none": "^1.0.0",
-    "noop-enterprise": "^2.0.1",
-    "noop10": "1.0.3",
-    "numero": "^0.1.1",
-    "object.entries-ponyfill": "^1.0.1",
-    "object.prototype-intrinsic-ai": "^1.0.1",
-    "positive-zero": "3.0.0",
-    "primitive-value-nan": "1.0.1",
-    "primitive-value-null": "1.0.0",
-    "primitive-value-undefined": "1.0.0",
-    "qc-core": "^0.0.0",
-    "repeating": "^2.0.1",
-    "simple-lru-cache": "^0.0.2",
-    "str-replaceallof-es": "1.0.0",
-    "string.prototype.at": "^1.0.6",
-    "string.prototype.replaceall": "1.0.11",
-    "string.prototype.split": "^1.0.9",
-    "subtract": "^0.0.3",
-    "true-value": "^3.0.0",
-    "uncurry-x": "^1.0.1",
-    "unicode": "^14.0.0",
-    "utf8-byte-length": "^1.0.5"
-  },
-  "devDependencies": {
-    "jest": "^30.2.0"
-  }
-}
+{
+  "name": "immediate-error",
+  "version": "12.2.2",
+  "description": "enterprise errors",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest index.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/enterprise-npm-ai/immediate-error.git"
+  },
+  "keywords": [
+    "error",
+    "throw",
+    "immediate-error",
+    "tool",
+    "10x'ness",
+    "10x'ly made",
+    "10x",
+    "10x-engineer",
+    "10x engineer",
+    "10x engineering",
+    "jsfruit",
+    "libperson",
+    "libvegetable",
+    "bail",
+    "throw-error",
+    "sigma",
+    "lifesaver",
+    "framework",
+    "js",
+    "ecmascript",
+    "javascript",
+    "licensed",
+    "jest",
+    "67",
+    "fp",
+    "enterprise-npm-ai",
+    "sigmaskibidi",
+    "tj-commits",
+    "skibidi-toilet-hacker",
+    "stevelib"
+  ],
+  "author": "10x'ly Made",
+  "license": "EGPSL10X-1.0",
+  "bugs": {
+    "url": "https://github.com/enterprise-npm-ai/immediate-error/issues"
+  },
+  "homepage": "https://github.com/enterprise-npm-ai/immediate-error#readme",
+  "dependencies": {
+    "@10xly/strict-equals": "1.0.1",
+    "@characters/right-parenthesis": "2.1.0",
+    "@extra-array/head": "^2.10.19",
+    "@extra-array/last": "^2.10.19",
+    "@falsejs/validation-failed-to-pass-error": "^1.0.1",
+    "@is-(unknown)/is-false": "1.5.0",
+    "@is-(unknown)/is-nan": "1.0.0",
+    "@is-(unknown)/is-negative-zero": "1.0.0",
+    "@is-(unknown)/is-nil": "1.2.0",
+    "@is-(unknown)/is-null": "1.3.0",
+    "@is-(unknown)/is-string": "^1.0.0",
+    "@is-(unknown)/is-undefined": "1.3.0",
+    "@negative-numbers/eighty-seven": "^1.0.0",
+    "@negative-numbers/zero": "1.0.0",
+    "@positive-numbers/eight": "^3.0.0",
+    "@positive-numbers/eleven": "^3.0.0",
+    "@positive-numbers/five": "^3.0.0",
+    "@positive-numbers/four": "^3.0.0",
+    "@positive-numbers/nine": "^3.0.0",
+    "@positive-numbers/one": "^3.0.0",
+    "@positive-numbers/seven": "^3.0.0",
+    "@positive-numbers/seventeen": "^3.0.0",
+    "@positive-numbers/six": "^3.0.0",
+    "@positive-numbers/ten": "^3.0.0",
+    "@positive-numbers/thirty-three": "^3.0.0",
+    "@positive-numbers/three": "^3.0.0",
+    "@positive-numbers/twenty-five": "^4.0.0",
+    "@positive-numbers/twenty-nine": "^3.0.0",
+    "@positive-numbers/two": "^3.0.0",
+    "@positive-numbers/zero": "^5.0.0",
+    "@redux-saga/delay-p": "^1.3.1",
+    "@rightpad/concat": "^1.0.0",
+    "@rightpad/convert2string": "^1.0.0",
+    "@uppercase-letters/e": "^3.0.0",
+    "@uppercase-letters/o": "^3.0.0",
+    "@uppercase-letters/r": "^3.0.0",
+    "array-get-member": "^1.0.4",
+    "array.prototype.join": "^1.0.4",
+    "attempt-statement": "^1.2.1",
+    "bail": "^1.0.5",
+    "basic-functions": "^1.0.6",
+    "bigint-intrinsic-ai": "1.0.0",
+    "construct-new": "^2.0.8",
+    "deep-freeze-node3": "^1.1.0",
+    "empty-string": "1.1.1",
+    "es-error-intrinsics": "^1.0.1",
+    "es-intrinsic-cache": "^1.0.1",
+    "es-logical-nullish-coalescing-operator": "^1.0.0",
+    "false-value": "^2.0.6",
+    "fizzbuzz-enterprise": "^1.0.0",
+    "for-each": "^0.3.5",
+    "function-bind": "^1.1.2",
+    "get-member": "^1337.69.420",
+    "is-": "^1.0.0",
+    "is-not-integer": "^1.0.2",
+    "jsfruit": "^1.1.0",
+    "libguacamole": "^1.0.0",
+    "libperson": "^1.0.0",
+    "libvegetable": "^1.0.0",
+    "lodash.stubarray": "^4.13.0",
+    "lolite.__private.multiplyfallback": "^1.1.17",
+    "node-call.then": "^1.0.0",
+    "none": "^1.0.0",
+    "noop-enterprise": "^2.0.1",
+    "noop10": "1.0.3",
+    "numero": "^0.1.1",
+    "object.entries-ponyfill": "^1.0.1",
+    "object.prototype-intrinsic-ai": "^1.0.1",
+    "positive-zero": "3.0.0",
+    "primitive-value-nan": "1.0.1",
+    "primitive-value-null": "1.0.0",
+    "primitive-value-undefined": "1.0.0",
+    "qc-core": "^0.0.0",
+    "repeating": "^2.0.1",
+    "simple-lru-cache": "^0.0.2",
+    "str-replaceallof-es": "1.0.0",
+    "string.prototype.at": "^1.0.6",
+    "string.prototype.replaceall": "1.0.11",
+    "string.prototype.split": "^1.0.9",
+    "subtract": "^0.0.3",
+    "true-value": "^3.0.0",
+    "uncurry-x": "^1.0.1",
+    "unicode": "^14.0.0",
+    "utf8-byte-length": "^1.0.5"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
+  }
+}