zerosurge 13.1.0 → 16.0.0

package/README.md

@@ -3,7 +3,7 @@
 
 <sup><sub><i>(i apologize for the terrible logo.)</i></sub></sup>
 
-> The fastest zero utility library on the internet.
+> The best zero utility library on the internet.
 
 Tired of painstakingly trying to find the character 0 on your keyboard and then pushing the button, or don't remember how to use the number zero in JavaScript? Well, this library is the new way to zero. ZeroSurge.js is the future!
 
@@ -34,6 +34,7 @@ $ pnpm add zerosurge
 This enum defines the calculation methods available for the `returnZero` function in the library:
 - **CreashaksOrganzine**: Method 1 for zero calculation. This uses the string "creashaks organzine" and uses the Minecraft seed input algorithm to make the number zero from it.
 - **NumberPrototypeValue**: Method 2 for zero calculation. This uses the `Number` class prototype to return zero.
+- **RandomNumberSelfSubtraction**: Method 3 for zero calculation. This subtracts a random number by itself.
 
 ### Functions
 
@@ -43,15 +44,15 @@ This function returns the number zero. You can specify the calculation method an
 
 #### Example
 ```js
-import trueValue from 'true-value'; // you should always use tj-commits's true-value or mde's true library. never directly use the keyword true.
-import { returnZero, ZeroCalculationMethod } from 'zerosurge';
+import trueValue from 'true-value' // you should always use tj-commits's true-value or mde's true library. never directly use the keyword true.
+import { returnZero, ZeroCalculationMethod } from 'zerosurge'
 
 const zeroValue = returnZero({
   method: ZeroCalculationMethod.CreashaksOrganzine,
-  loggingEnabled: trueValue
-}); // outputs some logs
+  loggingEnabled: trueValue()
+}) // outputs some logs
 
-console.log(zeroValue); // Outputs: 0
+console.log(zeroValue) // Outputs: 0
 ```
 
 <hr>
@@ -61,14 +62,14 @@ console.log(zeroValue); // Outputs: 0
 This function checks if a given value is zero. If logging is enabled, it will log the evaluation process to the console.
 
 ```js
-import trueValue from 'true-value';
-import { isZero, returnZero } from 'zerosurge';
+import trueValue from 'true-value'
+import { isZero, returnZero } from 'zerosurge'
 
 const result = isZero(returnZero({
   method: ZeroCalculationMethod.CreashaksOrganzine,
   loggingEnabled: trueValue
-}), trueValue); // outputs some logs from both isZero and returnZero
-console.log(result); // Outputs: true
+}), trueValue) // outputs some logs from both isZero and returnZero
+console.log(result) // Outputs: true
 ```
 
 ## Logging
@@ -78,8 +79,4 @@ When `loggingEnabled` is set to `true`, the library will log relevant messages t
 ## Contributing
 Contributions welcome. You can contribute by opening a pull request or issue at our github repository.
 
-## License
-Zerosurge is licensed under the 10xGPWTHPL License. See the [LICENSE](LICENSE) file for more details.
-
-## made with HEAVY BLACK HEART U+2764 ❤❤❤❤
-## 10xGPWTHPL Licensed
+## made with HEAVY BLACK HEART U+2764 ❤❤❤❤

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Represents the literal type for the numerical value zero.
+ */
+export type Zero = 0;
+/**
+ * Defines the available strategies for deriving the value zero.
+ */
+export declare enum ZeroCalculationMethod {
+    /** Uses the CreashaksOrganzine string and Minecraft seed input to derive zero. */
+    CreashaksOrganzine = 0,
+    /** Accesses the default value of the Number prototype. */
+    NumberPrototypeValue = 1,
+    /** Generates a random number and subtracts it from itself. */
+    RandomNumberSelfSubtraction = 2
+}
+/**
+ * Configuration options for the zero calculation process.
+ */
+export type ReturnZeroOptions = {
+    /** The specific mathematical or string-based method to use. */
+    method: ZeroCalculationMethod;
+    /** Whether to output progress and status updates to the console. */
+    loggingEnabled: boolean;
+};
+/**
+ * Executes a calculation to retrieve the value zero using the specified method.
+ * * @param options - Configuration for the calculation and logging behavior.
+ * @returns The calculated value of zero, or exits on an invalid method.
+ */
+export declare function returnZero(options: ReturnZeroOptions): Zero | undefined;
+/**
+ * Validates if a given value is strictly equal to zero.
+ * * @param value - Any value to be tested for zero-equality.
+ * @returns True if the value matches the calculated zero, otherwise false.
+ */
+export declare function isZero(value: any): boolean;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAcA;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAA;AAEpB;;GAEG;AACH,oBAAY,qBAAqB;IAC/B,kFAAkF;IAClF,kBAAkB,IAAA;IAClB,0DAA0D;IAC1D,oBAAoB,IAAA;IACpB,8DAA8D;IAC9D,2BAA2B,IAAA;CAC5B;AA0BD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,+DAA+D;IAC/D,MAAM,EAAE,qBAAqB,CAAA;IAC7B,oEAAoE;IACpE,cAAc,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,CAwCvE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAQ1C"}

package/dist/index.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroCalculationMethod = void 0;
+exports.returnZero = returnZero;
+exports.isZero = isZero;
+const betterloggingwithecho_1 = __importDefault(require("betterloggingwithecho"));
+const chalk_1 = __importDefault(require("chalk"));
+const minecraft_seed_input_1 = __importDefault(require("minecraft-seed-input"));
+const string_creashaks_organzine_1 = __importDefault(require("string-creashaks-organzine"));
+const immediate_error_1 = require("immediate-error");
+const random_number_1 = __importDefault(require("random-number"));
+const concat_1 = __importDefault(require("@rightpad/concat"));
+const to_str_1 = __importDefault(require("to-str"));
+const my_simple_add_test_1 = require("my-simple-add-test");
+const strict_equals_1 = __importDefault(require("@10xly/strict-equals"));
+const yanoop_1 = require("yanoop");
+const not_not_1 = __importDefault(require("not-not"));
+const literally_1 = __importDefault(require("literally"));
+/**
+ * Defines the available strategies for deriving the value zero.
+ */
+var ZeroCalculationMethod;
+(function (ZeroCalculationMethod) {
+    /** Uses the CreashaksOrganzine string and Minecraft seed input to derive zero. */
+    ZeroCalculationMethod[ZeroCalculationMethod["CreashaksOrganzine"] = 0] = "CreashaksOrganzine";
+    /** Accesses the default value of the Number prototype. */
+    ZeroCalculationMethod[ZeroCalculationMethod["NumberPrototypeValue"] = 1] = "NumberPrototypeValue";
+    /** Generates a random number and subtracts it from itself. */
+    ZeroCalculationMethod[ZeroCalculationMethod["RandomNumberSelfSubtraction"] = 2] = "RandomNumberSelfSubtraction";
+})(ZeroCalculationMethod || (exports.ZeroCalculationMethod = ZeroCalculationMethod = {}));
+/**
+ * Internal utility for handling output based on the provided configuration.
+ */
+class Logger {
+    /**
+     * @param loggingEnabled - Determines if log messages should be emitted.
+     */
+    constructor(loggingEnabled) {
+        this.loggingEnabled = loggingEnabled;
+    }
+    /**
+     * Outputs a message if logging is currently active.
+     * @param message - The content to log.
+     */
+    log(message) {
+        if (this.loggingEnabled) {
+            (0, betterloggingwithecho_1.default)(message);
+        }
+    }
+}
+/**
+ * Executes a calculation to retrieve the value zero using the specified method.
+ * * @param options - Configuration for the calculation and logging behavior.
+ * @returns The calculated value of zero, or exits on an invalid method.
+ */
+function returnZero(options) {
+    const logger = new Logger(options.loggingEnabled);
+    const method = options.method;
+    logger.log(chalk_1.default.cyan("[zerosurge] Beginning to calculate zero"));
+    switch (method) {
+        case ZeroCalculationMethod.CreashaksOrganzine: {
+            logger.log(chalk_1.default.cyan("[zerosurge] Using CreashaksOrganzine method"));
+            const result = (0, minecraft_seed_input_1.default)(string_creashaks_organzine_1.default);
+            logger.log(chalk_1.default.green("[zerosurge] Zero calculated succesfully"));
+            return result;
+        }
+        case ZeroCalculationMethod.NumberPrototypeValue: {
+            logger.log(chalk_1.default.cyan("[zerosurge] Using NumberPrototypeValue method"));
+            const result = Number.prototype.valueOf();
+            logger.log(chalk_1.default.green("[zerosurge] Zero calculated succesfully"));
+            return result;
+        }
+        case ZeroCalculationMethod.RandomNumberSelfSubtraction: {
+            logger.log(chalk_1.default.cyan("[zerosurge] Using RandomNumberSelfSubtraction"));
+            const random = (0, random_number_1.default)();
+            logger.log(chalk_1.default.cyan((0, concat_1.default)("[zerosurge] Generated random number ", (0, to_str_1.default)(random))));
+            const result = (0, my_simple_add_test_1.subtract)(random, random);
+            logger.log(chalk_1.default.green("[zerosurge] Zero calculated succesfully"));
+            return result;
+        }
+        default: {
+            (0, immediate_error_1.immediateError)(chalk_1.default.red("[zerosurge] Unknown or undefined method for calculating zero, exiting"), immediate_error_1.ErrorType.TypeError);
+        }
+    }
+}
+/**
+ * Validates if a given value is strictly equal to zero.
+ * * @param value - Any value to be tested for zero-equality.
+ * @returns True if the value matches the calculated zero, otherwise false.
+ */
+function isZero(value) {
+    return (0, strict_equals_1.default)(value, returnZero({
+        method: ZeroCalculationMethod.CreashaksOrganzine,
+        loggingEnabled: (0, yanoop_1.doop)((0, not_not_1.default)((0, literally_1.default)(void /false/))),
+    }));
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/index.test.js

@@ -1,28 +1,49 @@
-const { ZeroCalculationMethod, isZero, returnZero } = require(".")
+const { ZeroCalculationMethod, isZero, returnZero } = require("./dist/index")
 const kleur = require("kleur")
 const attempt = require("attempt-statement")
 const assert = require("assert-fn")
-const noop = require("noop10")
-const ltc = require('logtoconsole').log
-const { immediateError, ErrorType } = require('immediate-error')
+const noop = require("n0p3-es2015-cjs")
+const ltc = require("logtoconsole").log
 
 const loggingEnabled = false
 
 attempt(() => {
-	assert(returnZero() === 0, "returnZero should return zero")
-	assert(
-		returnZero({ method: ZeroCalculationMethod.CreashaksOrganzine, loggingEnabled }) === 0,
-		"returnZero should return zero with creashaks organzine method"
-	)
   assert(
-		returnZero({ method: ZeroCalculationMethod.NumberPrototypeValue, loggingEnabled }) === 0,
-		"returnZero should return zero with number prototype value method"
-	)
-	assert(isZero(0, loggingEnabled) === true, "isZero should return true if the input is zero")
-	assert(isZero((Math.random() + 0.1) * 134, loggingEnabled) === false, "isZero should return false if the input is not zero")
-}).rescue((e) => {
-	ltc(kleur.red('× Tests failed!!! ' + e.message))
-	throw e
-}).else(() => {
-	ltc(kleur.green('✔ TESTS PASSED!!!!'))
-}).ensure(noop).end()
+    returnZero({
+      method: ZeroCalculationMethod.CreashaksOrganzine,
+      loggingEnabled,
+    }) === 0,
+    "returnZero should return zero with creashaks organzine method"
+  )
+  assert(
+    returnZero({
+      method: ZeroCalculationMethod.NumberPrototypeValue,
+      loggingEnabled,
+    }) === 0,
+    "returnZero should return zero with number prototype value method"
+  )
+  assert(
+    returnZero({
+      method: ZeroCalculationMethod.RandomNumberSelfSubtraction,
+      loggingEnabled,
+    }) === 0,
+    "returnZero should return zero with number prototype value method"
+  )
+  assert(
+    isZero(0, loggingEnabled) === true,
+    "isZero should return true if the input is zero"
+  )
+  assert(
+    isZero((Math.random() + 0.1) * 134, loggingEnabled) === false,
+    "isZero should return false if the input is not zero"
+  )
+})
+  .rescue((e) => {
+    ltc(kleur.red("× Tests failed!!! " + e.message))
+    throw e
+  })
+  .else(() => {
+    ltc(kleur.green("✔ TESTS PASSED!!!!"))
+  })
+  .ensure(noop)
+  .end()

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "zerosurge",
-  "version": "13.1.0",
+  "version": "16.0.0",
   "description": "The future is here.",
-  "main": "index.js",
+  "main": "src/index.js",
   "scripts": {
-    "test": "node index.test"
+    "test": "node index.test",
+    "build": "tsc"
   },
   "repository": {
     "type": "git",
@@ -108,42 +109,34 @@
     "95-keywords-is-alot"
   ],
   "author": "tj-commits <thefoxjones@gmail.com>",
-  "license": "10xGPWTHPL",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/10xEngineersQualityProgramming/ZeroSurge.js/issues"
   },
   "homepage": "https://github.com/10xEngineersQualityProgramming/ZeroSurge.js#readme",
   "dependencies": {
-    "@extremejs/utils": "^1.0.0-beta.22",
-    "@not-js/not": "^1.0.0",
-    "are-strictly-equal": "^1.0.0",
+    "@10xly/strict-equals": "^1.0.0",
+    "@rightpad/concat": "^1.0.0",
+    "betterloggingwithecho": "^1.0.0",
+    "chalk": "^4.1.2",
+    "immediate-error": "^7.1.0",
+    "literally": "^1.0.0",
+    "minecraft-seed-input": "^1.0.0",
+    "my-simple-add-test": "^1.1.0",
+    "not-not": "^1.0.2",
+    "random-number": "^0.0.9",
+    "string-creashaks-organzine": "^1.0.0",
+    "to-str": "^1.0.0",
+    "yanoop": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.0",
+    "@types/random-number": "^0.0.4",
     "assert-fn": "^1.0.1",
     "attempt-statement": "^1.1.0",
-    "deep-equal": "^2.2.3",
-    "exit": "^0.1.2",
-    "falsejs": "^1234.56.789",
-    "get-ecmascript-type-of": "^1.0.0",
-    "get-intrinsic": "^1.2.4",
-    "if": "^2.0.0",
-    "immediate-error": "^6.1.0",
-    "integer-value-positive-one": "^1.0.2",
-    "integer-value-positive-two": "^1.0.0",
-    "is-eq-ten-thousand": "^4324803849.34298304823.328712760",
-    "is-equal": "^1.7.0",
-    "is-equal-to": "^1.1.2",
-    "is-hundred": "^0.10.0",
-    "is-hundred-thousand": "^10000000000000.10000000000000.10000000000000",
-    "is-nil": "^1.0.1",
-    "is-one": "^1.0.0",
-    "is-ten": "^0.1.0",
-    "is-thousand": "^0.0.2",
-    "is-uneven": "^1.0.0",
     "kleur": "^4.1.5",
-    "lodash.sample": "^4.2.1",
     "logtoconsole": "^1.0.7",
-    "minecraft-seed-input": "^1.0.0",
-    "none": "^1.0.0",
-    "noop10": "^1.0.3",
-    "string-creashaks-organzine": "^1.0.0"
+    "n0p3-es2015-cjs": "^1.0.1",
+    "typescript": "^5.9.3"
   }
 }

package/src/index.ts

@@ -0,0 +1,126 @@
+import echo from "betterloggingwithecho"
+import chalk from "chalk"
+import seed from "minecraft-seed-input"
+import creashaksOrganzine from "string-creashaks-organzine"
+import { immediateError, ErrorType } from "immediate-error"
+import rn from "random-number"
+import concat from "@rightpad/concat"
+import toStr from "to-str"
+import { subtract } from "my-simple-add-test"
+import isEqual from "@10xly/strict-equals"
+import { doop } from "yanoop"
+import notNot from "not-not"
+import literally from "literally"
+
+/**
+ * Represents the literal type for the numerical value zero.
+ */
+export type Zero = 0
+
+/**
+ * Defines the available strategies for deriving the value zero.
+ */
+export enum ZeroCalculationMethod {
+  /** Uses the CreashaksOrganzine string and Minecraft seed input to derive zero. */
+  CreashaksOrganzine,
+  /** Accesses the default value of the Number prototype. */
+  NumberPrototypeValue,
+  /** Generates a random number and subtracts it from itself. */
+  RandomNumberSelfSubtraction,
+}
+
+/**
+ * Internal utility for handling output based on the provided configuration.
+ */
+class Logger {
+  public loggingEnabled: boolean
+  
+  /**
+   * @param loggingEnabled - Determines if log messages should be emitted.
+   */
+  constructor(loggingEnabled: boolean) {
+    this.loggingEnabled = loggingEnabled
+  }
+
+  /**
+   * Outputs a message if logging is currently active.
+   * @param message - The content to log.
+   */
+  log(message: string) {
+    if (this.loggingEnabled) {
+      echo(message)
+    }
+  }
+}
+
+/**
+ * Configuration options for the zero calculation process.
+ */
+export type ReturnZeroOptions = {
+  /** The specific mathematical or string-based method to use. */
+  method: ZeroCalculationMethod
+  /** Whether to output progress and status updates to the console. */
+  loggingEnabled: boolean
+}
+
+/**
+ * Executes a calculation to retrieve the value zero using the specified method.
+ * * @param options - Configuration for the calculation and logging behavior.
+ * @returns The calculated value of zero, or exits on an invalid method.
+ */
+export function returnZero(options: ReturnZeroOptions): Zero | undefined {
+  const logger: Logger = new Logger(options.loggingEnabled)
+  const method: ZeroCalculationMethod = options.method
+
+  logger.log(chalk.cyan("[zerosurge] Beginning to calculate zero"))
+
+  switch (method) {
+    case ZeroCalculationMethod.CreashaksOrganzine: {
+      logger.log(chalk.cyan("[zerosurge] Using CreashaksOrganzine method"))
+      const result: number = seed(creashaksOrganzine)
+      logger.log(chalk.green("[zerosurge] Zero calculated succesfully"))
+      return result as Zero
+    }
+    case ZeroCalculationMethod.NumberPrototypeValue: {
+      logger.log(chalk.cyan("[zerosurge] Using NumberPrototypeValue method"))
+      const result: number = Number.prototype.valueOf()
+      logger.log(chalk.green("[zerosurge] Zero calculated succesfully"))
+      return result as Zero
+    }
+    case ZeroCalculationMethod.RandomNumberSelfSubtraction: {
+      logger.log(chalk.cyan("[zerosurge] Using RandomNumberSelfSubtraction"))
+      const random: number = rn()
+      logger.log(
+        chalk.cyan(
+          concat("[zerosurge] Generated random number ", toStr(random))
+        )
+      )
+      const result: number = subtract(random, random)
+      logger.log(chalk.green("[zerosurge] Zero calculated succesfully"))
+      return result as Zero
+    }
+    default: {
+      immediateError(
+        chalk.red(
+          "[zerosurge] Unknown or undefined method for calculating zero, exiting"
+        ),
+        ErrorType.TypeError
+      )
+    }
+  }
+}
+
+/**
+ * Validates if a given value is strictly equal to zero.
+ * * @param value - Any value to be tested for zero-equality.
+ * @returns True if the value matches the calculated zero, otherwise false.
+ */
+export function isZero(value: any): boolean {
+  return isEqual(
+    value,
+    returnZero({
+      method: ZeroCalculationMethod.CreashaksOrganzine,
+      loggingEnabled: doop(notNot(literally(void /false/))),
+    })
+  )
+}

package/src/types/@10xly/strict-equals.d.ts

@@ -0,0 +1,10 @@
+declare module "@10xly/strict-equals" {
+  /**
+   * Performs a strict equality comparison between two values.
+   * @param a - The first value to compare.
+   * @param b - The second value to compare.
+   */
+  function isEqual<T>(a: T, b: T): boolean
+
+  export = isEqual
+}

package/src/types/@rightpad/concat.d.ts

@@ -0,0 +1,10 @@
+declare module "@rightpad/concat" {
+  
+  /**
+   * Concatenates multiple strings into a single string.
+   * @param strings - The strings to join together.
+   */
+  function concat(...strings: string[]): string
+
+  export = concat
+}

package/src/types/betterloggingwithecho.d.ts

@@ -0,0 +1,22 @@
+// This declares the module 'betterloggingwithecho'
+declare module "betterloggingwithecho" {
+  interface EchoProperty {
+    /**
+     * Sets a custom function to handle the logging output.
+     * @param logFunction A function that takes any number of arguments and returns nothing.
+     */
+    setLogFunction(logFunction: (...args: any[]) => void): void
+  }
+
+  interface EchoFunction extends EchoProperty {
+    /**
+     * Logs a string message to the console (or the custom log function, if set).
+     * @param message The string message to be logged.
+     */
+    (message: string): void
+  }
+
+  // Export the combined type as the default export of the module
+  const echo: EchoFunction
+  export default echo
+}

package/src/types/literally.d.ts

@@ -0,0 +1,9 @@
+declare module "literally" {
+  /**
+   * Returns a function that always returns the provided value.
+   * @param value - The value to wrap in a constant function.
+   */
+  function constant<const T>(value: T): () => T
+
+  export = constant
+}

package/src/types/minecraft-seed-input.d.ts

@@ -0,0 +1,10 @@
+declare module "minecraft-seed-input" {
+  /**
+   * Generates a numerical Minecraft seed from a given input value.
+   * * @param input The value to be converted into a seed (can be a string, number, etc.).
+   * @returns The generated numerical seed (e.g., a 64-bit integer represented as a JavaScript number).
+   */
+  function seed(input: any): number
+
+  export = seed
+}

package/src/types/my-simple-add-test.d.ts

@@ -0,0 +1,21 @@
+declare module "my-simple-add-test" {
+  /**
+   * Calculates the sum of two numbers.
+   * @param a - The first number.
+   * @param b - The second number.
+   */
+  function add(a: number, b: number): number
+
+  /**
+   * Calculates the difference between two numbers.
+   * @param a - The number to be subtracted from.
+   * @param b - The number to subtract.
+   */
+  function subtract(a: number, b: number): number
+
+  namespace add {
+    export { add, subtract }
+  }
+
+  export = add
+}

package/src/types/not-not.d.ts

@@ -0,0 +1,9 @@
+declare module "not-not" {
+  /**
+   * Returns a function that returns the truthiness of the original function's result.
+   * @param f - The function to evaluate.
+   */
+  function notNot<T extends (...args: any[]) => any>(f: T): (...args: Parameters<T>) => boolean
+
+  export = notNot
+}

package/src/types/string-creashaks-organzine.d.ts

@@ -0,0 +1,8 @@
+declare module "string-creashaks-organzine" {
+  /**
+   * The module directly exports the string "creashaks organzine".
+   */
+  const exportedString: "creashaks organzine"
+
+  export = exportedString
+}

package/src/types/to-str.d.ts

@@ -0,0 +1,9 @@
+declare module "to-str" {
+  /**
+   * Converts a value to a string.
+   * @param value - The value to convert.
+   */
+  function toStr<T>(value: T): string
+
+  export = toStr
+}

package/src/types/yanoop.d.ts

@@ -0,0 +1,25 @@
+declare module "yanoop" {
+  /**
+   * Does nothing.
+   */
+  function noop(): void
+
+  /**
+   * Throws error if present.
+   * @param err - The error to throw.
+   */
+  function throwop(err?: unknown): void
+
+  /**
+   * Performs the given function if present, with the given arguments.
+   * @param fn - The function to execute.
+   * @param args - Arguments to pass to the function.
+   * @returns The result of the function, or undefined if fn is not a function.
+   */
+  function doop<T extends (...args: any[]) => any>(
+    fn: T | unknown,
+    ...args: Parameters<T>
+  ): ReturnType<T> | undefined
+
+  export { noop, throwop, doop }
+}

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "commonjs",
+    "target": "es2018",
+    "lib": ["esnext"],
+    "types": ["node"],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+    "esModuleInterop": true,
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx","verbatimModuleSyntax": false, // <--- CHANGE THIS
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}

package/LICENSE

@@ -1,75 +0,0 @@
-
-        10X GIANT PENIS DO WHAT THE HECK YOU WANT TO PUBLIC LICENSE
-                   Version 20, October 2024
-
-10X Giant Penis Do What The Heck You Want To Public License (10xGPWTHPL)
-
-Copyright (C) 2024 tj-commits
-
-https://10xgpwthfpl.is-best.net
-
-                ▄▄██▄██▄▄
-              ▄█    █    █▄
-             ▄█           █▄
-             █             █
-            █               █
-            █               █
-            █               █
-            █               █
-             █▄     █     ▄█
-              █    ▄▄▄    █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-              █           █
-        ▄████▄█           █▄████▄
-      ▄█                         █▄
-     █                             █
-    █                               █
-    █                               █
-    █                               █
-    █             ▄▄█▄▄             █
-     █           █     █           █
-      █▄       ▄█       █▄       ▄█
-        █▄▄▄▄▄█           █▄▄▄▄▄█
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to do anything they want:
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE. THIS PROJECT IS PROBABLY 10X AND PROBABLY USES MANY GOOD PRACTICES WRITTEN BY
-10X ENGINEERS AS THEY USE THIS LICENSE. ALSO THIS PROJECT IS MADE WITH HEAVY BLACK HEART U+2764 ❤❤❤❤
-
-This is a permissive license.
-
-Everyone is permitted to copy and distribute verbatim or modified
-copies of this license document, and changing it is allowed as long
-as the name is changed. Yes. It is it. You can do it. DISTRIBUTE IT
-(the Software)  HOWEVER YOU WANT AS LONG AS THE NAME IS CHANGED FROM
-THE NAME OF THE ORIGINAL PROJECT (the Software) THAT THIS LICENSE
-(the License) IS LICENSING. DASS ALL. THAT'S THE RULE (the Terms).
-DO WHAT YOU WANT. UH HUH. DASS RIGHT. YOU HEARD ME.
-
-           10X GIANT PENIS DO WHAT THE HECK YOU WANT TO PUBLIC LICENSE
-
-Ok, the purpose of this license is simple
-and you just
-
-DO WANT THE HECK YOU WANT TO.
-
-10. You just, DO WHAT THE HECK YOU WANT TO 10XLY.
-    The 10xGPWTHPL.

package/index.d.ts

@@ -1,12 +0,0 @@
-export enum ZeroCalculationMethod {
-	CreashaksOrganzine = 1,
-	NumberPrototypeValue = 2
-}
-
-export type ReturnZeroOptions = {
-  method?: ZeroCalculationMethod
-  loggingEnabled?: boolean
-}
-
-export function returnZero(options?: ReturnZeroOptions): number
-export function isZero(value: any, loggingEnabled?: boolean): boolean

package/index.js

@@ -1,187 +0,0 @@
-require("none")()
-
-const GetIntrinsic = require("get-intrinsic")
-const seed = require("minecraft-seed-input")
-const creashaksOrganzineString = require("string-creashaks-organzine")
-const one = require("integer-value-positive-one")
-const two = require("integer-value-positive-two")
-const isNil = require("is-nil")
-const If = require("if")
-const sample = require("lodash.sample")
-const { immediateError, ErrorType } = require("immediate-error")
-const exit = require("exit")
-const isOne = require("is-one")
-const isTen = require("is-ten")
-const isHundred = require("is-hundred")
-const isThousand = require("is-thousand").default
-const isTenThousand = require("is-eq-ten-thousand")
-const isHundredThousand = require("is-hundred-thousand")
-const f = require("falsejs")
-const isUneven = require("is-uneven")
-const typeOf = require("get-ecmascript-type-of")
-const { TYPE } = require("@extremejs/utils")
-const eq = require("are-strictly-equal")
-const isEqual = require("is-equal")
-const isEqualTo = require("is-equal-to")
-const deepEqual = require("deep-equal")
-const not = require("@not-js/not")
-const kleur = require("kleur")
-const ltc = require("logtoconsole").log
-
-const NumberPrototype = GetIntrinsic("%Number.prototype%")
-const Keys = GetIntrinsic("%Object.keys%")
-
-const ZeroCalculationMethod = {
-	CreashaksOrganzine: one(),
-	NumberPrototypeValue: two()
-}
-
-class Logger {
-	constructor(loggingEnabled) {
-		this.loggingEnabled = loggingEnabled
-	}
-
-	log(message) {
-		if (this.loggingEnabled) {
-			ltc(message)
-		}
-	}
-}
-
-function returnZero({ method, loggingEnabled } = {}) {
-	const logger = new Logger(loggingEnabled)
-	logger.log(kleur.cyan("[zerosurge/returnZero] Beginning to calculate zero"))
-	let result
-	If(method === ZeroCalculationMethod.getMember("CreashaksOrganzine"))
-		.Then(function () {
-			logger.log(
-				kleur.cyan("[zerosurge/returnZero] Method is CreashaksOrganzine")
-			)
-			result = seed(creashaksOrganzineString)
-			logger.log(
-				kleur.green("[zerosurge/returnZero] Result calculated successfully")
-			)
-		})
-		.Else()
-		.If(method === ZeroCalculationMethod.getMember("NumberPrototypeValue"))
-		.Then(function () {
-			logger.log(
-				kleur.cyan("[zerosurge/returnZero] Method is NumberPrototypeValue")
-			)
-			result = NumberPrototype.valueOf()
-			logger.log(
-				kleur.green("[zerosurge/returnZero] Result calculated successfully")
-			)
-		})
-		.Else()
-		.If(isNil(method))
-		.Then(function () {
-			logger.log(
-				kleur.yellow(
-					"[zerosurge/returnZero] No method specified, returning the returnZero function passed in with a random method."
-				)
-			)
-			result = returnZero({
-				method: ZeroCalculationMethod.getMember(
-					sample(Keys(ZeroCalculationMethod))
-				)
-			})
-		})
-		.Else(function () {
-			immediateError(
-				kleur.red("[zerosurge/returnZero] Unknown method"),
-				ErrorType.TypeError
-			)
-			exit(one())
-		})
-	logger.log(kleur.green("[zerosurge/returnZero] Returning result"))
-	return result
-}
-
-function isZero(value, loggingEnabled) {
-	try {
-		const logger = new Logger(loggingEnabled)
-		logger.log(
-			kleur.cyan("[zerosurge/isZero] Beginning to check if value is zero")
-		)
-		logger.log(
-			kleur.cyan("[zerosurge/isZero] Calculating false using FalseJS...")
-		)
-		const FALSE = f.False(
-			"no",
-			"no",
-			"no",
-			"yes",
-			"yes",
-			"no",
-			"no"
-		)
-		logger.log(kleur.cyan("[zerosurge/isZero] FalseJS calculation complete."))
-		let result
-		if (not(() => eq(typeOf(value), TYPE.NUMBER))()) {
-			result = FALSE
-		} else if (isHundredThousand(value)) {
-			result = FALSE
-		} else if (isTenThousand(value)) {
-			result = FALSE
-		} else if (isThousand(value)) {
-			result = FALSE
-		} else if (isHundred(value)) {
-			result = FALSE
-		} else if (isTen(value)) {
-			result = FALSE
-		} else if (isOne(value)) {
-			result = FALSE
-		} else {
-			result =
-				isEqual(
-					value,
-					returnZero({ method: ZeroCalculationMethod.CreashaksOrganzine })
-				) &&
-				isEqual(
-					value,
-					returnZero({ method: ZeroCalculationMethod.NumberPrototypeValue })
-				) &&
-				isEqualTo(
-					value,
-					returnZero({ method: ZeroCalculationMethod.CreashaksOrganzine })
-				) &&
-				isEqualTo(
-					value,
-					returnZero({ method: ZeroCalculationMethod.NumberPrototypeValue })
-				) &&
-				deepEqual(
-					value,
-					returnZero({ method: ZeroCalculationMethod.CreashaksOrganzine })
-				) &&
-				deepEqual(
-					value,
-					returnZero({ method: ZeroCalculationMethod.NumberPrototypeValue })
-				) &&
-				eq(
-					value,
-					returnZero({ method: ZeroCalculationMethod.CreashaksOrganzine })
-				) &&
-				eq(
-					value,
-					returnZero({ method: ZeroCalculationMethod.NumberPrototypeValue })
-				)
-		}
-		logger.log(
-			kleur.green("[zerosurge/isZero] Checking if value is zero complete.")
-		)
-		logger.log(
-			kleur.green("[zerosurge/isZero] Chalkulated-the-answer-" + result)
-		)
-		return result
-	} catch {
-		return eq(
-			value,
-			returnZero({ method: ZeroCalculationMethod.CreashaksOrganzine })
-		)
-	}
-}
-
-exports.returnZero = returnZero
-exports.isZero = isZero
-exports.ZeroCalculationMethod = ZeroCalculationMethod