@nejs/basic-extensions 2.6.0 → 2.8.0

package/src/global.this.js

@@ -0,0 +1,304 @@
+import { Patch } from '@nejs/extension'
+import { FunctionExtensions } from './function.extensions.js'
+
+const { isClass, isFunction } = FunctionExtensions.patches
+const CustomInspect = Symbol.for('nodejs.util.inspect.custom')
+
+export const GlobalFunctionsAndProps = new Patch(globalThis, {
+  [Patch.kMutablyHidden]: {
+    /**
+     * The `isThenElse` function is a utility function that behaves like a
+     * ternary operator. It takes three arguments: `boolValue`, `thenValue`,
+     * and `elseValue`.
+     *
+     * It first checks the truthiness of `boolValue`.
+     *
+     * If `boolValue` is truthy, it returns `thenValue`; otherwise,
+     * it returns `elseValue`.
+     *
+     * If `thenValue` or `elseValue` is a function, it will be invoked with
+     * `boolValue` as an argument.
+     *
+     * If `elseValue` is not provided, it returns `boolValue` or `thenValue`
+     * depending on the truthiness of `boolValue`.
+     *
+     * If only `boolValue` is provided, it simply returns `boolValue`.
+     *
+     * @param {any} boolValue - Any object or value that is tested for
+     * truthiness.
+     * @param {function | any} [thenValue] - The value to return if `boolValue`
+     * is truthy. If a function, it's invoked with `boolValue`.
+     * @param {function | any} [elseValue] - The value to return if `boolValue`
+     * is falsy. If a function, it's invoked with `boolValue`.
+     * @returns {boolean | any} The result of the ternary operation.
+     *
+     * @example
+     * // Using values
+     * isThenElse(true, 'yes', 'no');  // Returns: 'yes'
+     * isThenElse(false, 'yes', 'no'); // Returns: 'no'
+     *
+     * // Using functions
+     * isThenElse(true, val => val ? 'yes' : 'no');  // Returns: 'yes'
+     * isThenElse(false, val => val ? 'yes' : 'no'); // Returns: 'no'
+     */
+    isThenElse(boolValue, thenValue, elseValue) {
+      if (arguments.length > 1) {
+        const _then = isFunction(thenValue) ? thenValue(boolValue) : thenValue
+
+        if (arguments.length > 2) {
+          const _else = isFunction(elseValue) ? thenValue(boolValue) : elseValue
+
+          return boolValue ? _then : _else
+        }
+
+        return boolValue || _then
+      }
+
+      return boolValue
+    },
+
+    /**
+     * Transforms an object to mimic a specified prototype, altering its type
+     * conversion and inspection behaviors. This function is especially useful
+     * for creating objects that need to behave like different primitive types
+     * under various operations.
+     *
+     * @param {Object} object - The object to be transformed.
+     * @param {Function|Object} [prototype=String.prototype] - The prototype or
+     * class to emulate. If a function is provided, its prototype is used.
+     * Defaults to String.prototype.
+     * @param {Function} [toPrimitive=(hint, val) => String(val)] - A function
+     * defining how the object should be converted to a primitive value. It
+     * receives a type hint ('number', 'string', or 'default') and the object,
+     * returning the primitive value.
+     * @returns {Object|null} The transformed object, or null if neither a class
+     * nor a prototype could be derived from the provided prototype parameter.
+     */
+    maskAs(object, classPrototype, options) {
+      const {
+        prototype,
+        toPrimitive
+      } = GenericMask({...options, prototype: classPrototype})
+
+      const base = { configurable: true, enumerable: false }
+      const proto = isFunction(prototype) ? prototype.prototype : prototype
+      const klass = isClass(prototype) ? prototype : proto?.constructor
+
+      if (!klass && !proto) {
+        return null
+      }
+
+      Object.setPrototypeOf(object, proto)
+      Object.defineProperties(object, {
+        valueOf: {
+          value() { return String(toPrimitive('default', object)) }, ...base },
+
+        [Symbol.toPrimitive]: {
+          value(hint) { return toPrimitive(hint, object) }, ...base
+        },
+        [Symbol.toStringTag]: { value: klass.name, ...base },
+        [Symbol.species]: { get() { return klass }, ...base },
+        [CustomInspect]: { ...base, value(depth, opts, inspect) {
+          return inspect(this[Symbol.toPrimitive](), { ...opts, depth })
+        }}
+      })
+
+      return object
+    },
+
+    /**
+     * Masks an object as a string-like object by setting its prototype to
+     * String and defining how it converts to primitive types. This is
+     * particularly useful when an object needs to behave like a string in
+     * certain contexts, such as type coercion or logging.
+     *
+     * @param {Object} object - The object to be masked as a string.
+     * @param {string} [stringKey='value'] - The object property key used for
+     * the string representation. Defaults to 'value'.
+     * @param {Function} [toPrimitive] - Optional custom function for primitive
+     * conversion. If omitted, a default function handling various conversion
+     * hints is used.
+     * @returns {Object|null} The string-masked object, or null if the object
+     * doesn't have the specified stringKey property.
+     */
+    maskAsString(
+      object,
+      stringKey,
+      toPrimitive
+    ) {
+      if (object && Reflect.has(object, stringKey)) {
+        return maskAs(object, StringMask(stringKey ?? 'value', toPrimitive))
+      }
+
+      return null
+    },
+
+    /**
+     * Masks an object as a number-like object. This allows the object to
+     * behave like a number in operations like arithmetic and type coercion.
+     * It sets the prototype to Number and defines custom conversion behavior.
+     *
+     * @param {Object} object - The object to be masked as a number
+     * representation. Defaults to 'value'.
+     * @param {Function} [toPrimitive] - Optional custom function for primitive
+     * conversion. If not provided, a default function handling different
+     * conversion hints is used.
+     * @returns {Object|null} The number-masked object, or null if the object
+     * doesn't have the specified numberKey property.
+     */
+    maskAsNumber(
+      object,
+      numberKey,
+      toPrimitive
+    ) {
+      if (object && Reflect.has(object, numberKey)) {
+        return maskAs(object, NumberMask(numberKey ?? 'value', toPrimitive))
+      }
+
+      return null
+    },
+
+    /**
+     * Generates options for generic masking of an object, providing defaults for
+     * prototype and toPrimitive function if not specified.
+     *
+     * @param {Object} options - The options object including prototype,
+     * targetKey, and toPrimitive function.
+     * @returns {Object} The options object with defaults applied as necessary.
+     */
+    GenericMask({ prototype, targetKey = 'value', toPrimitive }) {
+      const options = { targetKey, toPrimitive, prototype };
+
+      if (!isFunction(toPrimitive)) {
+        options.toPrimitive = (hint, object) => {
+          let property = object[targetKey];
+          let isNum = (
+            (typeof property === 'number' && Number.isFinite(property)) ||
+            (typeof property === 'string' &&
+              !isNaN(parseFloat(property)) && isFinite(property)
+            )
+          );
+
+          switch (hint) {
+            case 'string':
+              return isNum ? String(property) : (property ?? String(object));
+            case 'number':
+              return isNum ? Number(property) : NaN;
+            case 'default':
+            default:
+              return isNum ? Number(property) : property;
+          }
+        }
+      }
+
+      return options;
+    },
+
+    /**
+     * Generates options for string masking of an object, providing a default
+     * toPrimitive function if not specified.
+     *
+     * @param {string} targetKey - The object property key for string
+     * representation.
+     * @param {Function} toPrimitive - Custom function for primitive conversion.
+     * @returns {Object} Options for string masking.
+     */
+    StringMask(targetKey, toPrimitive) {
+      const options = { targetKey, toPrimitive, prototype: String.prototype }
+
+      if (!isFunction(toPrimitive)) {
+        options.toPrimitive = function toPrimitive(hint, object) {
+          switch (hint) {
+            case 'default': return object[targetKey]
+            case 'number': return parseInt(object[targetKey], 36)
+            case 'string': return String(object[targetKey])
+            default: return object
+          }
+        }
+      }
+
+      return options
+    },
+
+    /**
+     * Generates options for number masking of an object, providing a default
+     * toPrimitive function if not specified.
+     *
+     * @param {string} targetKey - The object property key for number
+     * representation.
+     * @param {Function} toPrimitive - Custom function for primitive conversion.
+     * @returns {Object} Options for number masking.
+     */
+    NumberMask(targetKey, toPrimitive) {
+      const options = { targetKey, toPrimitive, prototype: Number.prototype }
+
+      if (!isFunction(toPrimitive)) {
+        options.toPrimitive = function toPrimitive(hint, object) {
+          switch (hint) {
+            case 'default': return object[targetKey]
+            case 'number': return Number(object[targetKey])
+            case 'string': return String(object[targetKey])
+            default: return object
+          }
+        }
+      }
+
+      return options
+    },
+
+    /**
+     * Blends the properties of multiple objects into a new object. This
+     * function creates a new object that inherits the prototype from the
+     * root object and the properties of the other objects and their parent
+     * prototypes.
+     *
+     * @param {Object} root - The root object to blend prototypes into.
+     * @param {...Object} objects - The objects whose prototypes to blend.
+     * @returns {Object} The new object with blended prototypes.
+     *
+     * @example
+     * // Define some objects with properties
+     * const obj1 = { prop1: 'value1' }
+     * const obj2 = { prop2: 'value2' }
+     * const obj3 = { prop3: 'value3' }
+     *
+     * // Blend the prototypes of obj2 and obj3 into obj1
+     * const blended = blendProtos(obj1, obj2, obj3)
+     *
+     * // Now blended has properties from obj1, obj2, and obj3
+     * console.log(blended.prop1) // Outputs: 'value1'
+     * console.log(blended.prop2) // Outputs: 'value2'
+     * console.log(blended.prop3) // Outputs: 'value3'
+     */
+    blendProtos(root, ...objects) {
+      const descriptor = (o, k) => Object.getOwnPropertyDescriptor(o,k)
+      const parent = o => Object.getPrototypeOf(o)
+      const all = o => (Reflect
+        .ownKeys(o)
+        .reduce((a, k)=>({ ...a, [k]: descriptor(o,k) }), { })
+      )
+
+      const newRoot = Object.create(parent(root), objects.reduce)
+      const protos = objects.map(object => parent(object))
+
+      let descriptors = Object.create(null)
+      let uniques = new Set
+
+      for (let object of protos) {
+        let current = object
+
+        while (current) {
+          if (!uniques.has(current)) {
+            uniques.add(current)
+            descriptors = { ...descriptors, ...all(current) }
+          }
+          current = parent(current)
+        }
+      }
+
+      const blendedPrototype = Object.create(parent(root), descriptors)
+
+      return Object.setPrototypeOf(newRoot, blendedPrototype)
+    },
+  },
+})

package/src/index.js

@@ -1,42 +1,62 @@
-import { FunctionExtensions, FunctionPrototypeExtensions } from './functionextensions.js'
-import { ObjectExtensions, ObjectPrototypeExtensions } from './objectextensions.js'
-import { MapPrototypeExtensions } from './mapextensions.js'
-import { SetPrototypeExtensions } from './setextensions.js'
-import { ReflectExtensions } from './reflectextensions.js'
-import { StringExtensions, StringPrototypeExtensions } from './stringextensions.js'
-import { SymbolExtensions } from './symbolextensions.js'
-import { ArrayPrototypeExtensions } from './arrayextensions.js'
-import { DescriptorExtensions, Descriptor } from './newClasses/descriptor.js'
-import { GlobalFunctionsAndProps } from './globals.js'
-import { RefSetExtensions } from './newClasses/refset.js'
-import { RefMapExtensions } from './newClasses/refmap.js'
-import { DeferredExtension } from './newClasses/deferred.js'
+import { ArrayExtensions, ArrayPrototypeExtensions } from './array.extensions.js'
+import { BigIntExtensions, BigIntPrototypeExtensions } from './big.int.extension.js'
+import { FunctionExtensions, FunctionPrototypeExtensions } from './function.extensions.js'
+import { GlobalFunctionsAndProps } from './global.this.js'
+import { JSONExtensions } from './json.extensions.js'
+import { MapExtensions, MapPrototypeExtensions } from './map.extensions.js'
+import { NumberExtensions, NumberPrototypeExtensions } from './number.extension.js'
+import { ObjectExtensions, ObjectPrototypeExtensions } from './object.extensions.js'
+import { ReflectExtensions } from './reflect.extensions.js'
+import { RegExpExtensions } from './regular.expression.extensions.js'
+import { SetExtensions, SetPrototypeExtensions } from './set.extensions.js'
+import { StringExtensions, StringPrototypeExtensions } from './string.extensions.js'
+import { SymbolExtensions, SymbolPrototypeExtensions } from './symbol.extensions.js'
+
+import { DeferredExtension } from './classes/deferred.js'
+import { DescriptorExtensions, Descriptor } from './classes/descriptor.js'
+import { IntrospectorExtensions } from './classes/introspector.js'
+import { IteratorExtensions, IterableExtensions } from './classes/iterable.js'
+import { ParamParserExtensions } from './classes/param.parser.js'
+import {
+  PluggableProxyExtensions,
+  ProxyHandlerExtensions,
+  PluggableProxyExtensionSet
+} from './classes/pluggable.proxy.js'
+import { RefMapExtensions } from './classes/refmap.js'
+import { RefSetExtensions } from './classes/refset.js'
+import { SymkeysExtension } from './classes/symkeys.js'
+import { TypeExtensions } from './classes/type.js'
 
 import {
   AsyncIteratorExtensions,
   AsyncIterableExtensions
-} from './newClasses/asyncIterable.js'
-
-import {
-  IteratorExtensions,
-  IterableExtensions
-} from './newClasses/iterable.js'
+} from './classes/asyncIterable.js'
 
 const StaticPatches = [
-  [Object, ObjectExtensions, Object.name],
+  [Array, ArrayExtensions, Array.name],
+  [BigInt, BigIntExtensions, BigInt.name],
   [Function, FunctionExtensions, Function.name],
+  [JSON, JSONExtensions, 'JSON'],                // Missing a .name property
+  [Map, MapExtensions, Map.name],
+  [Number, NumberExtensions, Number.name],
+  [Object, ObjectExtensions, Object.name],
   [Reflect, ReflectExtensions, 'Reflect'],       // Missing a .name property
+  [RegExp, RegExpExtensions, RegExp.name],
+  [Set, SetExtensions, Set.name],
   [String, StringExtensions, String.name],
   [Symbol, SymbolExtensions, 'Symbol'],          // Missing a .name property
 ]
 
 const InstancePatches = [
-  [Object.prototype, ObjectPrototypeExtensions, Object.name],
-  [String.prototype, StringPrototypeExtensions, String.name],
-  [Function.prototype, FunctionPrototypeExtensions, Function.name],
   [Array.prototype, ArrayPrototypeExtensions, Array.name],
+  [BigInt.prototype, BigIntPrototypeExtensions, BigInt.name],
+  [Function.prototype, FunctionPrototypeExtensions, Function.name],
   [Map.prototype, MapPrototypeExtensions, Map.name],
+  [Number.prototype, NumberPrototypeExtensions, Number.name],
+  [Object.prototype, ObjectPrototypeExtensions, Object.name],
   [Set.prototype, SetPrototypeExtensions, Set.name],
+  [String.prototype, StringPrototypeExtensions, String.name],
+  [Symbol.prototype, SymbolPrototypeExtensions, Symbol.name],
 ]
 
 const Patches = new Map([
@@ -49,12 +69,25 @@ const Extensions = {
   [AsyncIteratorExtensions.key]: AsyncIteratorExtensions,
   [DeferredExtension.key]: DeferredExtension,
   [DescriptorExtensions.key]: DescriptorExtensions,
+  [IntrospectorExtensions.key]: IntrospectorExtensions,
   [IterableExtensions.key]: IterableExtensions,
   [IteratorExtensions.key]: IteratorExtensions,
+  [ParamParserExtensions.key]: ParamParserExtensions,
+  [PluggableProxyExtensions.key]: PluggableProxyExtensions,
+  [ProxyHandlerExtensions.key]: ProxyHandlerExtensions,
   [RefMapExtensions.key]: RefMapExtensions,
   [RefSetExtensions.key]: RefSetExtensions,
+  [SymkeysExtension.key]: SymkeysExtension,
+  [TypeExtensions.key]: TypeExtensions,
 }
 
+export const Classes = {}
+for (const extension of Object.values(Extensions)) {
+  const fnOrClass = extension.class || extension.function
+  Classes[fnOrClass.name] = fnOrClass
+}
+
+
 const Controls = {}
 
 Object.assign(Controls, {

package/src/json.extensions.js

@@ -0,0 +1,108 @@
+import { Patch } from '@nejs/extension'
+
+export const JSONExtensions = new Patch(JSON, {
+  [Patch.kMutablyHidden]: {
+    /**
+     * The `extractFrom` method attempts to extract a JSON object from a string.
+     * It uses a regular expression to identify potential JSON objects in the
+     * string and attempts to parse them. If a valid JSON object is found, it is
+     * returned. If no valid JSON object is found, the method returns undefined.
+     *
+     * NOTE: This method will only find JSON from an iterated upon start spot
+     * until the end of the string. So `'JSON follows {"count": 0}'` will
+     * return `{count: 0}` but `'JSON follows {"count": 0} and more'` will
+     * fail to locate any JSON in the String. You've been warned.
+     *
+     * @param {string} string - The string from which to extract a JSON object.
+     * @returns {Object|undefined} - The first valid JSON object found in the
+     * string, or undefined if no valid JSON object is found.
+     *
+     * @example
+     * // Suppose we have a string with embedded JSON
+     * const str1 = 'Hello {"name":"John", "age":30} World'
+     * const str2 = 'Hello {"name": "John", "age": 30}'
+     *
+     * // Using `extractFrom`
+     * console.log(JSON.extractFrom(str1))  // Output: undefined
+     * console.log(JSON.extractFrom(str2))  // Output: {name: 'John', age: 30}
+     */
+    extractFrom(string) {
+      const pattern = /([\w\{\[\"]+) ?/g
+      const decoder = part => {
+        try { return JSON.parse(part) } catch (_) { return undefined }
+      }
+
+      for (
+        let part = pattern.exec(string);
+        part;
+        part = pattern.exec(string)
+      ) {
+        if (part && part?.index) {
+          const decoded = decoder(string.substring(part.index))
+          if (decoded) {
+            return decoded
+          }
+        }
+      }
+
+      return undefined
+    },
+
+    /**
+     * The `mightContain` method checks if a string might contain a JSON object.
+     * It uses the `JSONStartPattern` regular expression to search for potential
+     * JSON objects in the string. If a potential JSON object is found, the method
+     * returns true. If no potential JSON object is found, the method returns false.
+     *
+     * @param {string} string - The string to check for potential JSON objects.
+     * @returns {boolean} - Returns true if the string might contain a JSON object,
+     * false otherwise.
+     *
+     * @example
+     * // Suppose we have a string with embedded JSON
+     * const str = 'Hello {"name":"John", "age":30} World'
+     *
+     * // Using `mightContain`
+     * console.log(JSON.mightContain(str))  // Output: true
+     */
+    mightContain(string) {
+      return !!this.JSONStartPattern.exec(string)
+    },
+
+    /**
+     * Getter method for the JSONStartPattern.
+     *
+     * This method constructs a regular expression pattern that is used to
+     * identify potential JSON objects in a string. The pattern is designed
+     * to match various JSON data types including null, boolean, number,
+     * string, object, and array.
+     *
+     * The pattern is constructed using an array of strings, each representing
+     * a part of the pattern. The array is then joined into a single string
+     * and passed to the RegExp constructor to create the pattern.
+     *
+     * @returns {RegExp} - The constructed regular expression pattern.
+     *
+     * @example
+     * // Using `JSONStartPattern`
+     * const pattern = JSONStartPattern;
+     * const str = 'Hello {"name":"John", "age":30} World';
+     * const match = pattern.exec(str);
+     * console.log(match[0]);  // Output: '{"name":"John", "age":30}'
+     */
+    get JSONStartPattern() {
+      const pattern = new RegExp([
+        '(?:',                    // Start with a non-capturing group and match
+          '(null)|',              // ...a null
+          '(true|false)|',        // ...a bool
+          '(\\d+\\.?\\d*)|',      // ...a number (including floats)
+          '("[^\\"]*(?:[^:])")|', // ...a double quote (start of string)
+          '((?:\\{.*\\})+)|',     // ...an open curly brace (object)
+          '((?:\\[.*\\]+))',      // ...an open square bracket (array)
+        ')+',                     // End of the groups
+      ].join(''), 'gm')
+
+      return pattern
+    },
+  }
+})

package/src/map.extensions.js

@@ -0,0 +1,144 @@
+import { Patch } from '@nejs/extension'
+
+export const MapExtensions = new Patch(Map, {
+  [Patch.kMutablyHidden]: {
+    /**
+     * Determines if the supplied `value` is a `Map` object. This check
+     * is performed by first looking for the `Symbol.toStringTag` on the
+     * `value` and checking to see if it is equal to the string "Map".
+     * If that check fails, `instanceof` is used as a fallback to check
+     * the prototype chain.
+     *
+     * @param {any} value the value that needs to be checked to determine
+     * if it is a `Map` object or not
+     * @returns {boolean} `true` if the supplied `value` is a `Map`
+     * object, `false` otherwise
+     *
+     * @example
+     * const map = new Map()
+     * isMap(map) // true
+     * isMap(new Set()) // false
+     * isMap([]) // false
+     * isMap({}) // false
+     */
+    isMap(value) {
+      return value?.[Symbol.toStringTag] === Map.name && value instanceof Map
+    },
+
+    /**
+     * Conditionally returns a value based on whether the supplied
+     * `value` is a `Map` object or not. If the `value` is a `Map`
+     * object, the `thenValue` will be returned. If it is not a `Map`
+     * object, the `elseValue` will be returned instead.
+     *
+     * @param {any} value the value to check to determine if it is a
+     * `Map` object
+     * @param {any} thenValue the value to return if the supplied
+     * `value` is a `Map` object
+     * @param {any} elseValue the value to return if the supplied
+     * `value` is not a `Map` object
+     * @returns {any} either the `thenValue` or `elseValue` depending
+     * on if the supplied `value` is a `Map` object
+     *
+     * @example
+     * const map = new Map()
+     * const set = new Set()
+     * ifMap(map, 'is a map', 'not a map') // 'is a map'
+     * ifMap(set, 'is a map', 'not a map') // 'not a map'
+     */
+    ifMap(value, thenValue, elseValue) {
+      return isThenElse(this.isMap(value), thenValue, elseValue)
+    },
+  }
+})
+
+const { isMap: pIsMap, ifMap: pIfMap } = MapExtensions.patches
+
+export const MapPrototypeExtensions = new Patch(Map.prototype, {
+  [Patch.kMutablyHidden]: {
+    /**
+     * Determines if the current object is a `Map` object
+     *
+     * This is a getter that uses the `isMap` function from the
+     * `MapExtensions` patch to check if the current object (`this`) is
+     * a `Map` object
+     *
+     * @type {boolean}
+     * @readonly
+     *
+     * @example
+     * const map = new Map()
+     * console.log(map.isMap) // Output: true
+     *
+     * const notMap = {}
+     * console.log(notMap.isMap) // Output: false
+     */
+    get isMap() {
+      return pIsMap(this)
+    },
+
+    /**
+     * Conditionally returns a value based on whether the current
+     * object is a `Map` object or not
+     *
+     * If the current object is a `Map` object, the `thenValue` will
+     * be returned. If it is not a `Map` object, the `elseValue` will
+     * be returned instead.
+     *
+     * @param {any} thenValue the value to return if the current
+     * object is a `Map` object
+     * @param {any} elseValue the value to return if the current
+     * object is not a `Map` object
+     * @returns {any} either the `thenValue` or `elseValue` depending
+     * on if the current object is a `Map` object
+     *
+     * @example
+     * const map = new Map()
+     * map.ifMap('is a map', 'not a map') // 'is a map'
+     *
+     * const notMap = {}
+     * notMap.ifMap('is a map', 'not a map') // 'not a map'
+     */
+    ifMap(thenValue, elseValue) {
+      return pIfMap(this, thenValue, elseValue)
+    },
+
+    /**
+     * The function `getKey` returns the key associated with a given value
+     * in a map.
+     *
+     * @param {any} value - The value parameter is the value that you want to
+     * find the corresponding key for in the map.
+     * @param [strict=true] - The "strict" parameter is a boolean value that
+     * determines whether strict equality (===) or loose equality (==) should
+     * be used when comparing the "value" parameter with the values in the
+     * entries of the object. If "strict" is set to true, strict equality will
+     * be used.
+     * @returns the key associated with the given value. If a matching key is
+     * found, it is returned. If no matching key is found, null is returned.
+     */
+    getKey(value, strict = true) {
+      for (const [key, entryValue] of this) {
+        if (
+          (strict && value === entryValue) &&
+          (!strict && value == entryValue)
+        ) {
+          return key
+        }
+
+        return null
+      }
+    },
+  },
+})
+
+// NOTE to self; this is repeated here otherwise a circular reference from
+// Object<->Function<->Global occurs. See original source in global.this.js
+// {@see globalThis.isThenElse}
+function isThenElse(bv, tv, ev) {
+  if (arguments.length > 1) {
+    var _then = isFunction(tv) ? tv(bv) : tv; if (arguments.length > 2) {
+      var _else = isFunction(ev) ? tv(bv) : ev; return bv ? _then : _else
+    } return bv || _then;
+  } return bv
+}