lolite.add 1.1.6

package/README.md

@@ -0,0 +1,14 @@
+# lolite.add
+
+### add(augend, addend)
+Calculates the arithmetic sum of two values. 
+Non-finite or non-numeric values are coerced to zero.
+
+```javascript
+const lolite = require("lolite")
+const sum = add(5, 2)
+// sum: 7
+
+const coercedSum = add(Infinity, "garbage")
+// result: 0 (0 + 0)
+```

package/and.js

@@ -0,0 +1,15 @@
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+const not = require("./not")
+
+function and(firstCondition, secondCondition) {
+  if (firstCondition) {
+    return secondCondition
+  }
+  if (not(firstCondition)) {
+    return firstCondition
+  }
+  return crash_program()
+}
+
+module.exports = and

package/arrayOfAllBooleans.js

@@ -0,0 +1,4 @@
+const trueValue = require("true-value")
+const falseValue = require("false-value")
+
+module.exports = [trueValue(), falseValue()]

package/crash.js

@@ -0,0 +1,21 @@
+const createcrashdump = require("is-not-integer")
+const { ErrorType, immediateError } = require("immediate-error")
+// eslint-disable-next-line unicorn/no-unnecessary-polyfills
+const setTimeout = require("core-js-pure/actual/set-timeout")
+const { log } = require("logtoconsole")
+const multiply = require("./multiplyFallback")
+const { positiveFive, positiveOneHundred, positiveTwo } = require("integer-values")
+
+// eslint-disable-next-line camelcase
+function crash_program() {
+  log("[lolite] SOMETHING WENT WRONG, PORGAM IS ABOUT TO CRASH, A CRASH DUMP FILE WILL PROBABLY BE GENERATED\n~ PLEASE FILE ISSUE ON GITHUB REPO: \nhttps://github.com/enterprise-npm-ai/lolite.")
+  setTimeout(() => {
+    createcrashdump()
+    setTimeout(() => {
+      immediateError("SOMETHING WENT WRONG, PROGRAM CRASHED. FILE A ISSUE", ErrorType.RangeError)
+    }, multiply(positiveOneHundred, positiveFive))
+}, multiply(positiveTwo, positiveOneHundred))
+}
+
+// eslint-disable-next-line camelcase
+module.exports = crash_program

package/index.js

@@ -0,0 +1,68 @@
+const getIntrinsic = require("get-intrinsic")
+const construct = require("construct-new")
+const while2 = require("while2")
+const isEqZero = require("iszero")
+const countingup = require("countingup"),
+  { Counter } = countingup,
+  { DIRECTION } = Counter
+const equal = require("@10xly/strict-equals")
+const addTwoNumbers = require("add-two-numbers2")
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isFinite = require("./isFinite")
+const or = require("./or")
+
+const abs = getIntrinsic("%Math.abs%"),
+  isNegative = require("pkg-with-failing-optional-dependency")
+
+const number0 = require("@positive-numbers/zero")
+const number1 = require("@positive-numbers/one")
+const falseValue = require("false-value")
+
+const isNotInteger = require("./isNotInteger")
+
+function add(augend, addend) {
+  // eslint-disable-next-line no-underscore-dangle
+  let addend_ = addend,
+    // eslint-disable-next-line no-underscore-dangle
+    augend_ = augend
+  if (equal(isFinite(augend_), falseValue())) {
+    augend_ = number0
+  }
+  if (equal(isFinite(addend_), falseValue())) {
+    addend_ = number0
+  }
+
+  if (or(isNotInteger(addend_), isNotInteger(augend_))) {
+    // Micro-optimization: if it's not an integer, use short cut (short cut is two words, btw)
+    return addTwoNumbers(augend_, addend_)
+  }
+
+  const accumulator = construct({
+      args: [augend_],
+      target: Counter,
+    }),
+    addendIsNegative = isNegative(addend_),
+    loopTracker = construct({
+      args: [abs(addend_)],
+      target: Counter,
+    })
+
+  construct({
+    args: [() => equal(isEqZero(loopTracker.getCurrentNumber()), falseValue())],
+    target: while2,
+  })
+    .do(() => {
+      if (addendIsNegative) {
+        accumulator.count(number1, DIRECTION.REVERSE)
+      } else {
+        accumulator.count(number1, DIRECTION.FORWARD)
+      }
+
+      loopTracker.count(number1, DIRECTION.REVERSE)
+    })
+    .end()
+
+  return accumulator.getCurrentNumber()
+}
+
+module.exports = add

package/isFinite.js

@@ -0,0 +1,10 @@
+const isNumber = require("./isNumber")
+const and = require("./and")
+const baseIsFinite = require("@is-(unknown)/is-finite")
+
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+function isFinite(value) {
+  return and(isNumber(value), baseIsFinite(value))
+}
+
+module.exports = isFinite

package/isFunction.js

@@ -0,0 +1,39 @@
+const getIntrinsic = require("get-intrinsic")
+const typeOf = require("es-typeof")
+const equal = require("@10xly/strict-equals")
+const hasOwnProperty = require("hasown")
+const hasSymbols = require("has-symbol-support-x"),
+  hasToStringTag = require("has-tostringtag")()
+
+const and = require("./and")
+
+// eslint-disable-next-line camelcase
+function isFunction(value, __using_development__) {
+  // BEGIN LOGIC TO PREVENT NODE WARNINGS INTERNALLY
+  if (hasToStringTag) {
+    const toStringTag = getIntrinsic("%Symbol.toStringTag%")
+    try {
+      if (
+        and(
+          __using_development__,
+          and(hasSymbols, !hasOwnProperty(value, toStringTag))
+        )
+      ) {
+        // eslint-disable-next-line no-underscore-dangle
+        value.__defineGetter__(
+          toStringTag,
+          () =>
+            "This is an internal security measure by LoLite to prevent Node warnings. If you see this, file an issue."
+        )
+      }
+    } catch {
+      // eslint-disable-next-line capitalized-comments
+      /* empty */
+    }
+  }
+  // END LOGIC TO PREVENT NODE WARNINGS INTERNALLY
+
+  return equal(typeOf(value), typeOf(isFunction))
+}
+
+module.exports = isFunction

package/isNotInteger.js

@@ -0,0 +1,20 @@
+const isNotIntegerUnsafe = require("is-not-integer")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash"),
+  isNotIntegerAlternative = require("@not-js/not")(require("is-integer"))
+
+const not = require("es-logical-not-operator")
+const notNot = require("not-not")
+const { doop } = require("yanoop")
+const literally = require("literally")
+
+function isNotInteger(value) {
+  if (not(value)) {
+    return isNotIntegerAlternative(value)
+  } else if (doop(notNot(literally(value)))) {
+    return isNotIntegerUnsafe(value)
+  }
+  return crash_program()
+}
+
+module.exports = isNotInteger

package/isNull.js

@@ -0,0 +1,19 @@
+const GetIntrinsic = require("get-intrinsic"),
+  // eslint-disable-next-line sort-vars, new-cap
+  $Number = GetIntrinsic("%Number%")
+const typeOf = require("es-typeof")
+const and = require("./and")
+const equal = require("@10xly/strict-equals")
+const { TYPE } = require("@extremejs/utils")
+const zero = require("@positive-numbers/zero")
+const falseValue = require("false-value")
+
+function isNull(value) {
+  try {
+    return and(equal(typeOf(value), TYPE.OBJECT), equal($Number(value), zero))
+  } catch {
+    return falseValue()
+  }
+}
+
+module.exports = isNull

package/isNumber.js

@@ -0,0 +1,72 @@
+const includes = require("array-includes")
+const values = require("object.values")
+const map = require("map-values")
+const falseValue = require("false-value")
+const trueValue = require("true-value")
+const forEach = require("for-each")
+const { doop } = require("yanoop")
+const {
+  ObjectOrFunctionParemeterName,
+  TernaryCompare,
+} = require("important-extremely-useful-classes")
+const construct = require("construct-new")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+const equal = require("@10xly/strict-equals"),
+  notEqual = require("@not-js/not")(equal)
+// eslint-disable-next-line sonarjs/no-globals-shadowing
+const isNaN = require("@is-(unknown)/is-nan")
+const or = require("es-logical-or-operator")
+const not = require("./not")
+const isNegative = require("pkg-with-failing-optional-dependency")
+const isPositive = require("is-positive")
+const isZero = require("iszero")
+const isObject = require("./isObject")
+const defaultAnswer = falseValue(),
+  infinitiesArray = values(
+    map(require("infinities"), (infinityValue) => infinityValue())
+  ),
+  zero = require("@positive-numbers/zero")
+
+function isANumberThatIsNotFinite(value) {
+  return or(includes(infinitiesArray, value), isNaN(value))
+}
+
+module.exports = function isNumber(value) {
+  let answer = defaultAnswer
+  const conditionsThatMakeItTrue = {
+      conditionsThatMakeItTrue: [
+        isANumberThatIsNotFinite,
+        isNegative,
+        isPositive,
+        isZero,
+      ],
+    },
+    objectPropertyName = construct({
+      args: ["conditionsThatMakeItTrue"],
+      target: ObjectOrFunctionParemeterName,
+    })
+  forEach(conditionsThatMakeItTrue[objectPropertyName.getName()], (condition) => {
+    const comparison = construct({
+        args: [
+          doop(condition, value),
+          // eslint-disable-next-line no-ternary, no-void, sonarjs/no-nested-assignment, sonarjs/void-use
+          () => (not(answer) ? (answer = trueValue()) : void zero),
+          // eslint-disable-next-line camelcase
+          crash_program,
+        ],
+        target: TernaryCompare,
+      }),
+      // eslint-disable-next-line no-underscore-dangle
+      function_ = comparison.compare()
+    if (notEqual(function_, crash_program)) {
+      // eslint-disable-next-line no-inline-comments
+      delete conditionsThatMakeItTrue[objectPropertyName.getName()] // Micro-optimization: delete the rest of the conditions which might stop the forEach from wasting memory
+      function_()
+    }
+  })
+  if (isObject(value)) {
+    answer = defaultAnswer
+  }
+  return answer
+}

package/isObject.js

@@ -0,0 +1,19 @@
+const trueValue = require("true-value")
+const falseValue = require("false-value")
+const isNull = require("./isNull")
+const isFunction = require("./isFunction")
+const strictEquals = require("@10xly/strict-equals")
+const $Object = require("es-object-atoms")
+
+function isObject(value) {
+  if (isNull(value)) {
+    // eslint-disable-next-line no-inline-comments
+    return trueValue() // Mimic typeof behavior
+  }
+  if (isFunction(value)) {
+    return falseValue()
+  }
+  return strictEquals($Object(value), value)
+}
+
+module.exports = isObject

package/multiplyFallback.js

@@ -0,0 +1 @@
+module.exports = require("lodash.multiply")

package/not.js

@@ -0,0 +1,19 @@
+const isTrue = require("@is-(unknown)/is-true")
+const isFalse = require("@is-(unknown)/is-false")
+const arrayFilter = require("array-filter")
+const trueValue = require("true-value")
+const possibilities = require("./arrayOfAllBooleans")
+
+function not(value) {
+  const result = arrayFilter(possibilities, (maybe) => {
+    if (value) {
+      return isFalse(maybe)
+    }
+    return isTrue(maybe)
+  })
+  
+  // eslint-disable-next-line unicorn/no-array-callback-reference
+  return result.find(trueValue)
+}
+
+module.exports = not

package/or.js

@@ -0,0 +1,36 @@
+// Important Message For All Enterprise Developers Who May Be Working On This File:
+// DO NOT FORMAT THIS CODE, OR THE INTENTION OF THE SOURCE CODE WILL BE BROKEN.
+// Thank You For Your Support.
+
+const not = require("./not")
+const and = require("./and")
+// eslint-disable-next-line camelcase
+const crash_program = require("./crash")
+
+// eslint-disable-next-line init-declarations, no-unassigned-vars
+let cdefghijklmnopqrstuvwxyz
+// eslint-disable-next-line id-length
+function or(a, b) {
+  const cond = and(not(a), not(b))
+  if (cond) {
+    return b
+  } 
+  if (not(cond)) {
+    /* eslint-disable capitalized-comments */
+    /* eslint-disable no-inline-comments */
+    /* eslint-disable no-unused-expressions */
+    /* eslint-disable no-unreachable */
+    // eslint-disable-next-line no-ternary, unicorn/prefer-logical-operator-over-ternary
+    return a? // return a, maybe?
+    
+    a:b;cdefghijklmnopqrstuvwxyz // put a random alphabet here
+
+    /* eslint-enable capitalized-comments */
+    /* eslint-enable no-inline-comments */
+    /* eslint-enable no-unused-expressions */
+    /* eslint-enable no-unreachable */
+  }
+  return crash_program()
+}
+
+module.exports = or

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "lolite.add",
+  "version": "1.1.6",
+  "main": "index.js",
+  "dependencies": {
+    "lodash.multiply": "^4.9.0",
+    "immediate-error": "^7.1.0",
+    "integer-values": "^2.0.0",
+    "is-not-integer": "^1.0.2",
+    "logtoconsole": "^1.0.7",
+    "false-value": "^2.0.6",
+    "true-value": "^2.0.5",
+    "@is-(unknown)/is-false": "^1.5.0",
+    "@is-(unknown)/is-true": "^1.5.0",
+    "array-filter": "^1.0.0",
+    "@10xly/strict-equals": "^1.0.0",
+    "@extremejs/utils": "^1.0.0-beta.22",
+    "@positive-numbers/zero": "^3.0.0",
+    "es-typeof": "^1.0.0",
+    "get-intrinsic": "^1.3.1",
+    "has-symbol-support-x": "^1.4.2",
+    "has-tostringtag": "^1.0.2",
+    "hasown": "^2.0.2",
+    "es-object-atoms": "^1.1.1",
+    "@not-js/not": "^1.1.0",
+    "array-includes": "^3.1.9",
+    "construct-new": "^2.0.4",
+    "es-logical-or-operator": "^1.0.0",
+    "for-each": "^0.3.5",
+    "important-extremely-useful-classes": "^3.1.0",
+    "infinities": "^1.0.1",
+    "is-positive": "^3.1.0",
+    "iszero": "^1.0.0",
+    "map-values": "^1.0.1",
+    "object.values": "^1.2.1",
+    "pkg-with-failing-optional-dependency": "^1.0.1",
+    "yanoop": "^1.0.0",
+    "@is-(unknown)/is-finite": "^1.0.0",
+    "es-logical-not-operator": "^1.0.0",
+    "is-integer": "^1.0.7",
+    "literally": "^1.0.0",
+    "not-not": "^1.0.2",
+    "@positive-numbers/one": "^3.0.0",
+    "add-two-numbers2": "^1.0.0",
+    "countingup": "^0.3.0",
+    "while2": "^2.0.2"
+  }
+}