immediate-error 9.0.1 → 11.0.0

package/README.md

@@ -1,6 +1,6 @@
 # `immediate-error`
 
-This is a utility to throw an error. Also it's a way to get robustly cached error intrinsics.
+General error-related utility library. 10x Engineered. It's for: throwing errors, getting cached error intrinsics, and try-cach alternative functional handling.
 
 ## Installation
 ```bash
@@ -10,7 +10,7 @@ $ npm install immediate-error
 ## Usage
 Throwing Errors:
 ```javascript
-const { immediateError, ErrorType, getError } = require("immediate-error")
+const { immediateError, ErrorType, getError, throwWhatever } = require("immediate-error")
 
 immediateError() // this will throw a regular Error with the default message of "ERROR!"
 
@@ -30,6 +30,14 @@ immediateError("Syntax error", ErrorType.SyntaxError) // throws a SyntaxError
 
 immediateError("URI Error", ErrorType.URIError) // throws a URIError
 
+// Domain-specific Enterprise Errors:
+
+immediateError("fruit consumption error", ErrorType.FruitConsumptionError) // throws FruitConsumptionError
+
+immediateError("vegetables cannot talk error", ErrorType.VegetablesCannotTalkError) // throws a VegetablesCannotTalkError
+
+immediateError("person not hungry error", ErrorType.PersonNotHungryError) // throws a PersonNotHungryError
+
 class MyCustomError extends Error {
   constructor (message) {
     super("Custom: " + message)
@@ -38,6 +46,9 @@ class MyCustomError extends Error {
 
 immediateError("Error!", MyCustomError) // throws a MyCustomError
 
+throwWhatever("hi") // outputs: "Uncaught 'hi'"
+throwWhatever() // outputs: "Uncaught undefined"
+
 ```
 
 Getting Cached Errors:
@@ -47,6 +58,35 @@ const { getError, ErrorType } = require("immediate-error")
 const TypeErrorConstructor = getError(ErrorType.TypeError)
 
 console.log(TypeErrorConstructor === TypeError) // true
+
+const VegetablesCannotTalkError = getError(ErrorType.VegetablesCannotTalkError)
+
+try {
+  const Vegetable = require("libvegetable")
+  const vegetable = new Vegetable()
+
+  vegetable.greet()
+} catch (error) {
+  console.log(error.constructor === VegetablesCannotTalkError) // true
+}
+```
+
+Error Handling (`attempt`)
+
+```js
+const { attempt } = require("immediate-error")
+
+attempt(() => {
+  esuvnyuu.addisuaidof // thing that throws error
+}).rescue(error => {
+  console.log(error.message) // outputs: esuvnyuu is not defined
+}).else(() => {
+  // This will never happen
+  console.log("How did we get here?") // does not output anything, as this secition never runs.
+}).ensure(() => {
+  // This will always happen
+  console.log(1) // outputs: 1
+}).end() // you must end the statement with .end() or it wont run
 ```
 
 ### Changelog

package/index.d.ts

@@ -5,26 +5,71 @@ export enum ErrorType {
   ReferenceError = 3,
   SyntaxError = 4,
   TypeError = 5,
-  URIError = 6
+  URIError = 6,
+  FruitConsumptionError = 7,
+  VegetablesCannotTalkError = 8,
+  PersonNotHungryError = 9,
 }
 
 export type CustomError = {
   new (message: string): Error
 }
 
-/**
- * Enterprise retrieval signatures for specific ErrorTypes
- */
 export function getError(errorType: ErrorType.BaseError): typeof Error
 export function getError(errorType: ErrorType.EvalError): typeof EvalError
 export function getError(errorType: ErrorType.RangeError): typeof RangeError
-export function getError(errorType: ErrorType.ReferenceError): typeof ReferenceError
+export function getError(
+  errorType: ErrorType.ReferenceError
+): typeof ReferenceError
 export function getError(errorType: ErrorType.SyntaxError): typeof SyntaxError
 export function getError(errorType: ErrorType.TypeError): typeof TypeError
 export function getError(errorType: ErrorType.URIError): typeof URIError
-export function getError(errorType: ErrorType): CustomError
+export function getError(
+  errorType: ErrorType.FruitConsumptionError
+): CustomError
+export function getError(
+  errorType: ErrorType.VegetablesCannotTalkError
+): CustomError
+export function getError(errorType: ErrorType.PersonNotHungryError): CustomError
+export function getError(errorType: ErrorType | CustomError): CustomError
 
 export function immediateError(
-  message: string, 
+  message?: string,
   errorType?: ErrorType | CustomError
-): never
+): never
+
+export function throwWhatever(whateverToThrow: any): never
+
+interface AttemptConstructor {
+  new (handler?: () => void): Attempt
+
+  (handler?: () => void): Attempt
+}
+
+declare class Attempt {
+  constructor(handler?: () => void)
+
+  trycode?: () => void
+  rescuehandler?: (error: any) => void
+  elsehandler?: () => void
+  ensurehandler?: (error: any) => void
+
+  rescue(handler: (error: any) => void): this
+  else(handler: () => void): this
+  ensure(handler: () => void): this
+  end(): void
+}
+
+export const attempt: AttemptConstructor
+
+export function delayedImmediateError(
+  message?: string,
+  errorType?: ErrorType | CustomError,
+  delay?: number
+): Promise<never>
+
+export function delayedImmediateError(
+  message: undefined,
+  errorType: undefined,
+  delay: number
+): Promise<never>

package/index.js

@@ -2,15 +2,27 @@
 
 const GetIntrinsic = require("es-intrinsic-cache")
 const SimpleCache = require("simple-lru-cache")
+const trust = require("@npm/mystery-function") // it's by npm, gotta trust
+const Fruit = require("jsfruit")
+const Vegetable = require("libvegetable")
+const Person = require("libperson")
 const isdash = require("is-")
 const noop = require("n0p3-es2015-cjs")
 const bail = require("bail")
-const vm = require("node:vm")
 const construct = require("construct-new")
 const attempt = require("attempt-statement")
 const trueValue = require("true-value")
 const asArray = require("as-array")
-const deepFreeze = require("deep-freeze-node3") // 3rd iteration of deep-freeze-node.
+const repeating = require("repeating")
+const deepFreeze = require("deep-freeze-node3") // 3rd iteration of deep-freeze-node, and the only 10x one.
+const concat = require("@rightpad/concat")
+const NEWLINE = require("fizzbuzz-enterprise/source/main/constants/strings/delimiters/Newline") // hax
+const falseValue = require("false-value")
+const sleep = require("delay")
+const call = require("node-call.then")
+const bind = require("uncurry-x")(require("function-bind"))
+const just = require("basic-functions")
+const Null = require("qc-core").nullFn
 
 const zero = require("@positive-numbers/zero")
 const one = require("@positive-numbers/one")
@@ -19,14 +31,16 @@ const three = require("@positive-numbers/three")
 const four = require("@positive-numbers/four")
 const five = require("@positive-numbers/five")
 const six = require("@positive-numbers/six")
-const oneHundred = require("@positive-numbers/one-hundred")
+const seven = require("@positive-numbers/seven")
+const eight = require("@positive-numbers/eight")
+const nine = require("@positive-numbers/nine")
+const eleven = require("@positive-numbers/eleven")
+const oneHundred = require("fizzbuzz-enterprise/source/main/constants/magic-numbers/Hundred")
 
 const E = require("@uppercase-letters/e")
 const O = require("@uppercase-letters/o")
 const R = require("@uppercase-letters/r")
 
-const concat = require("@rightpad/concat")
-
 const $BaseError = require("es-error-intrinsics/Error")
 const $EvalError = require("es-error-intrinsics/EvalError")
 const $RangeError = require("es-error-intrinsics/RangeError")
@@ -47,6 +61,10 @@ const ErrorType = deepFreeze({
   SyntaxError: four,
   TypeError: five,
   URIError: six,
+
+  FruitConsumptionError: seven,
+  VegetablesCannotTalkError: eight,
+  PersonNotHungryError: nine
 })
 
 const ErrorMap = construct({
@@ -62,8 +80,43 @@ const ErrorMap = construct({
   ErrorMap.set(ErrorType.SyntaxError, $SyntaxError)
   ErrorMap.set(ErrorType.TypeError, $TypeError)
   ErrorMap.set(ErrorType.URIError, $URIError)
+
+  ErrorMap.set(ErrorType.FruitConsumptionError, (function() {
+    const fruit = construct({ target: Fruit })
+    try {
+      fruit
+
+      trust(repeating(concat("fruit.eat()", NEWLINE), eleven))
+    } catch (error) { 
+      return error.constructor
+    }
+  })())
+
+  ErrorMap.set(ErrorType.VegetablesCannotTalkError, (function() {
+    const vegetable = construct({ target: Vegetable })
+
+    try {
+      vegetable.greet()
+    } catch (error) {
+      return error.constructor
+    }
+  })())
+
+  ErrorMap.set(ErrorType.PersonNotHungryError, (function() {
+    const person = construct({ target: Person })
+    person.hungry = falseValue()
+    try {
+      person.feed()
+    } catch (error) { 
+      return error.constructor
+    }
+  })())
 })()
 
+function CreateSleepFunction(delay) {
+  return bind(sleep, Null(), delay)
+}
+
 function CreateError(error, message) {
   return construct({ target: error, args: asArray(message) })
 }
@@ -95,23 +148,33 @@ exports.immediateError = function immediateError(
     captureStackTrace(error, immediateError)
   }
 
-  const context = {
-    error: error,
-    bail: bail,
-  }
+  exports.throwWhatever(error)
 
-  vm.createContext(context)
+  require("is-not-integer")() // how did we get here?
+}
 
-  const script = construct({
-    target: vm.Script,
-    args: ["bail(error)", { filename: default_error }],
+exports.delayedImmediateError = function delayedImmediateError(
+  message = default_error,
+  errorType = ErrorType.BaseError,
+  delay
+) {
+  return call.then(just.call(CreateSleepFunction(delay)), () => {
+    return exports.immediateError(message, errorType)
   })
-
-  script.runInContext(context)
 }
 
 exports.getError = function getError(errorType) {
   return ErrorMap.get(errorType)
 }
 
+exports.throwWhatever = function throwWhatever(whateverToThrow) {
+  if (whateverToThrow) {
+    bail(whateverToThrow)
+  } else {
+    throw whateverToThrow // throw
+  }
+}
+
+exports.attempt = attempt
+
 exports.ErrorType = ErrorType

package/index.test.js

@@ -1,32 +1,45 @@
-const { immediateError, ErrorType } = require('./index')
+const { immediateError, ErrorType } = require("./index")
 
-describe('immediateError utility', () => {
+describe("immediateError utility", () => {
 
   // Basic Usage
-  test('throws a regular Error with default message when no arguments are passed', () => {
+  test("throws a regular Error with default message when no arguments are passed", () => {
     expect(() => immediateError()).toThrow(Error)
-    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("throws a regular Error with a custom message", () => {
+    expect(() => immediateError("Aaaaah")).toThrow(Error)
+    expect(() => immediateError("Aaaaah")).toThrow("Aaaaah")
   })
 
   // Native Error Types
   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],
-    ['RangeError', ErrorType.URIError, URIError],
-  ])('throws %s when specified', (name, type, constructor) => {
-    expect(() => immediateError('test message', type)).toThrow(constructor)
+    ["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 %s when specified", (name, type, constructor) => {
+    expect(() => immediateError("test message", type)).toThrow(constructor)
   })
+
+  // Enterprise Domain-Specific Error Types
+  test.each([
+    ["FruitConsumptionError", ErrorType.FruitConsumptionError],
+    ["VegetablesCannotTalkError", ErrorType.VegetablesCannotTalkError],
+    ["PersonNotHungryError", ErrorType.PersonNotHungryError],
+  ])("throws domain-specific %s correctly", (name, type) => {
+    // We check that it throws an instance of the constructor cached in ErrorMap
+    const expectedConstructor = require("./index").getError(type)
+    expect(() => immediateError("enterprise failure", type)).toThrow(expectedConstructor)
+    expect(() => immediateError("enterprise failure", type)).toThrow("enterprise failure")
+  })
+
   // Custom Error Classes
-  test('throws a custom user-defined Error class', () => {
+  test("throws a custom user-defined Error class", () => {
     class MyCustomError extends Error {
       constructor(message) {
         super("Custom: " + message)
@@ -34,7 +47,134 @@ describe('immediateError utility', () => {
       }
     }
 
-    expect(() => immediateError('Error!', MyCustomError)).toThrow(MyCustomError)
-    expect(() => immediateError('Error!', MyCustomError)).toThrow('Custom: Error!')
+    expect(() => immediateError("Error!", MyCustomError)).toThrow(MyCustomError)
+    expect(() => immediateError("Error!", MyCustomError)).toThrow("Custom: Error!")
+  })
+
+  // Stack Trace Integrity
+  test("captures stack trace correctly and hides internal frames", () => {
+    try {
+      immediateError("stack check")
+    } catch (error) {
+      // The first line of the stack should be the caller, not immediateError itself
+      expect(error.stack).not.toMatch(/at immediateError/)
+    }
+  })
+})
+
+const { attempt } = require("./index")
+
+describe("attempt utility", () => {
+  // Pattern support
+  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")
+  })
+
+  // Logic Flow
+  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
+    
+    // Success case
+    attempt(() => {})
+      .ensure(() => {
+        counter++
+      })
+      .end()
+    
+    // Failure case
+    attempt(() => {
+      throw new Error()
+    })
+      .rescue(() => {})
+      .ensure(() => {
+        counter++
+      })
+      .end()
+
+    expect(counter).toBe(2)
+  })
+
+  // Method Chaining
+  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 { delayedImmediateError } = require("./index")
+
+describe("delayedImmediateError utility", () => {
+  // We use a small delay for testing
+  const SHORT_DELAY = 10
+
+  test("throws the error after a specified delay", async () => {
+    const start = Date.now()
+    
+    // Since delayedImmediateError throws inside a promise chain/timeout, 
+    // we catch it to verify the timing and error type.
+    try {
+      await delayedImmediateError("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 delayedImmediateError(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 delayedImmediateError("Type fail", ErrorType.TypeError, SHORT_DELAY)
+    } catch (error) {
+      expect(error).toBeInstanceOf(TypeError)
+      expect(error.message).toBe("Type fail")
+    }
   })
 })

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "immediate-error",
-  "version": "9.0.1",
-  "description": "throw errors",
+  "version": "11.0.0",
+  "description": "enterprise errors",
   "main": "index.js",
   "scripts": {
-    "test": "jest index.test.js"
+    "test": "jest ./index.test.js"
   },
   "repository": {
     "type": "git",
@@ -49,10 +49,14 @@
   },
   "homepage": "https://github.com/enterprise-npm-ai/immediate-error#readme",
   "dependencies": {
+    "@npm/mystery-function": "npm:eval-intrinsic-ai@^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/one-hundred": "^3.0.0",
+    "@positive-numbers/seven": "^3.0.0",
     "@positive-numbers/six": "^3.0.0",
     "@positive-numbers/three": "^3.0.0",
     "@positive-numbers/two": "^3.0.0",
@@ -64,15 +68,27 @@
     "as-array": "^2.0.0",
     "attempt-statement": "^1.2.1",
     "bail": "^1.0.5",
+    "basic-functions": "^1.0.6",
     "construct-new": "^2.0.3",
     "deep-freeze-node3": "^1.1.0",
+    "delay": "^5.0.0",
     "es-error-intrinsics": "^1.0.1",
     "es-intrinsic-cache": "^1.0.1",
+    "false-value": "^2.0.6",
+    "fizzbuzz-enterprise": "^1.0.0",
+    "function-bind": "^1.1.2",
     "is-": "^1.0.0",
+    "is-not-integer": "^1.0.2",
+    "jsfruit": "^1.1.0",
+    "libperson": "^1.0.0",
+    "libvegetable": "^1.0.0",
     "n0p3-es2015-cjs": "^1.0.1",
-    "number-zero": "^1.0.3",
+    "node-call.then": "^1.0.0",
+    "qc-core": "^0.0.0",
+    "repeating": "^2.0.1",
     "simple-lru-cache": "^0.0.2",
-    "true-value": "^2.0.5"
+    "true-value": "^2.0.5",
+    "uncurry-x": "^1.0.1"
   },
   "devDependencies": {
     "jest": "^30.2.0"

package/CHANGELOG.md

@@ -1,257 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-Noitce: ai generated this changelog, so it might not be completely accurate.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [9.0.1]
-### Changed
-- This changelog
-- package.json description
-
-## [9.0.0]
-### Added
-- `getError` function to get robustly cached errors
-
-### Changed
-- Internal logic to get errors to be more robust
-- Removed dependency problem
-
-## [8.1.0]
-### THIS VERSION IS DEPRECATED: Dependency problem
-
-### Added
-- This changelog
-
-## [8.0.0] 
-### THIS VERSION IS DEPRECATED: Dependency problem
-
-### Added
-- "use struct" directive for struct mode
-- Dependencies: `is-`, `n0p3-es2015-cjs`, `deep-freeze-node3`, `@uppercase-letters/e`, `@uppercase-letters/o`, `@uppercase-letters/r`, `@rightpad/concat`, `as-array`
-- `CreateError` helper function
-- Improved error construction using functional programming utilities
-
-### Changed
-- Default error message now constructed using `concat` with uppercase letters
-- Updated dependencies versions
-- Simplified test file
-
-### Removed
-- `es-object-atoms`, `true-value`, `yanoop` dependencies
-
-## [7.2.0] 
-### THIS VERSION IS DEPRECATED: Dependency problem
-
-### Changed
-- Minor adjustment in vm.Script args formatting
-
-### Updated
-- `@positive-numbers/zero` to `^4.0.0`
-
-## [7.1.0] 
-
-### Changed
-- Replaced `get-intrinsic` with `es-intrinsic-cache`
-
-## [7.0.0] 
-
-### Added
-- Support for `EvalError` and `URIError`
-- `es-error-intrinsics` for better error handling
-- `bail` for error throwing
-- Stack trace capture using `Error.captureStackTrace`
-
-### Changed
-- Error types: Removed `AggregateError`, `AssertionError`, `NativeAssertionError`; Added `EvalError`, `URIError`
-- Updated API to use `bail` in vm context
-- Repository URL changed to `in-fp`
-- Author changed to "10x'ly Made"
-
-### Removed
-- `assert-fn`, `es-object-atoms`, `number-zero` dependencies
-- Some keywords from package.json
-
-### Updated
-- Tests to reflect new error types
-
-## [6.4.0] 
-
-### Added
-- Functional programming refactor using `switch-in-fp`, `construct-new`, `attempt-statement`
-- `@positive-numbers/*` dependencies for numbers
-- Jest tests
-- TypeScript definitions (`index.d.ts`)
-
-### Changed
-- Major code refactor to FP style
-- Dependencies updated to scoped packages
-- Description changed to "throw errors in fp"
-- Test script added
-- Keywords updated with FP and other terms
-
-### Removed
-- Old dependencies replaced with new ones
-
-## [6.3.0] 
-
-### Changed
-- Code formatting and indentation
-- License changed to "Unlicense"
-- Removed some dependencies: `if`, `noop10`, `se7en`, `the-number-one`, `two`, `vanilla-javascript`
-
-### Removed
-- "why?" section from README
-
-## [6.2.0] 
-
-### Changed
-- Simplified code structure
-- Updated vm script logic
-- Removed dependencies: `bail`, `esm-wallaby`, `picocolors`
-
-### Added
-- `has-self-equality`, `noop10` dependencies
-
-## [6.1.0]
-### THIS VERSION IS DEPRECATED: Versions 5.0.0 through 6.1.0 are deprecated due to an internal Node.js error caused by esm-wallaby. Please upgrade to a newer version.
-
-### Added
-- `AggregateError` support
-- Updated README with `AggregateError` example
-- Updated TypeScript definitions
-
-## [6.0.0] 
-### THIS VERSION IS DEPRECATED: Versions 5.0.0 through 6.1.0 are deprecated due to an internal Node.js error caused by esm-wallaby. Please upgrade to a newer version.
-
-### Added
-- `AggregateError` to error types
-- `get-intrinsic` for intrinsics
-
-### Changed
-- Error types mapping
-- Removed some dependencies: `jquery*`, `successor`, `vanilla-javascript`
-
-### Updated
-- `es-errors` to `^1.3.0`
-
-## [5.1.1] 
-### THIS VERSION IS DEPRECATED: Versions 5.0.0 through 6.1.0 are deprecated due to an internal Node.js error caused by esm-wallaby. Please upgrade to a newer version.
-
-### Changed
-- Replaced `cli-color` with `picocolors`
-
-## [5.1.0] 
-### THIS VERSION IS DEPRECATED: Versions 5.0.0 through 6.1.0 are deprecated due to an internal Node.js error caused by esm-wallaby. Please upgrade to a newer version.
-
-### Changed
-- Description updated to "Throw errors, better."
-
-## [5.0.0] 
-### THIS VERSION IS DEPRECATED: Versions 5.0.0 through 6.1.0 are deprecated due to an internal Node.js error caused by esm-wallaby. Please upgrade to a newer version.
-
-### Added
-- `esm-wallaby` for ESM requiring
-- `bail` for error throwing
-
-### Changed
-- Updated vm script to use `bail` with random logic
-
-## [4.0.0] 
-
-### Added
-- ES modules export style
-- Support for custom error classes
-- `es-errors` for proper error constructors
-- TypeScript definitions
-- More error types: `BaseError`, `AssertionError`, `AggregateError`, `NativeAssertionError`
-
-### Changed
-- Major API change: `immediateError(message, errorType)`
-- Removed `fox` dependency
-- Updated README with new usage
-- License to "Unlicense"
-
-### Removed
-- Old dependencies
-
-## [3.1.3] 
-
-### Added
-- `FuckingError` class
-- More number dependencies for error type values
-- Updated README with `FuckingError` example
-
-## [3.1.2] 
-
-### Changed
-- Removed console.log from vm script
-
-## [3.1.1] 
-
-### Removed
-- `integer-value-positive-zero` dependency
-
-## [3.1.0] 
-
-### Added
-- Many new dependencies for numbers, jQuery, etc.
-- Complex vm context with random error throwing
-- Updated README
-
-### Changed
-- Default message to aggressive one
-- Error creation using packages for numbers
-
-## [3.0.0] 
-
-### Added
-- Repository, keywords, author info
-- Many dependencies: `vanilla-javascript`, `vapor-js-npm`, etc.
-- vm context for error throwing
-
-### Changed
-- Description to "Immediate-error"
-- Major code changes with more complexity
-
-## [2.1.0] 
-
-### Added
-- ERROR object with multiple error types
-- eval-based error throwing
-
-### Changed
-- License to "UNLICENSED"
-- Removed dependencies
-
-### Updated
-- README with more examples
-
-## [2.0.0] 
-
-### Changed
-- Simplified to throw `new Error(message)` with default message (logic that makes sense)
-- Updated README example
-
-## [1.0.1] 
-
-### Changed
-- Author to "tj-commits/87f"
-
-## [1.0.0] 
-
-### Added
-- README.md with usage
-- Self-dependency (circular?)
-
-### Changed
-- Version to 1.0.0
-
-## [0.0.1] 
-
-### Added
-- Initial release
-- Basic index.js that requires 'fox', which is a pure ESM module, so it would throw an error since the package is CommonJS
-- package.json with basic info