@nejs/basic-extensions 1.4.1 → 1.5.0

package/src/refset.js

@@ -0,0 +1,414 @@
+import { Extension } from '@nejs/extension'
+
+/**
+ * RefSet class extends the standard Set object to manage a collection of
+ * WeakRef objects. It provides additional functionality such as objectification
+ * of values and various utility methods.
+ *
+ * Unlike standard Sets or Arrays, RefSet stores weak references to objects,
+ * allowing them to be garbage-collected if there are no other references to
+ * them. This behavior is different from Arrays and standard Sets, which
+ * maintain strong references to their elements.
+ *
+ * @extends Set
+ */
+class RefSet extends Set {
+  /**
+   * Private field to track whether the RefSet should objectify primitive
+   * values.
+   *
+   * @private
+   */
+  #objectifyValues = false
+
+  /**
+   * Method to control whether the RefSet should objectify its values. When
+   * objectifying, primitive values (number, string, boolean, bigint) are
+   * converted to their respective object types, which allows them to be used as
+   * WeakRef targets.
+   *
+   * @param {boolean} setObjectification - Flag to enable or disable
+   * objectification.
+   * @returns {RefSet} - The current RefSet instance to allow method chaining.
+   */
+  objectifying(setObjectification = true) {
+    this.objectifyValues = setObjectification
+    return this
+  }
+
+  /**
+   * Returns the state indicating whether or not `RefSet` will attempt to
+   * convert non-valid primitives into targets that are valid input for
+   * new `WeakRef` object instances. If this value is `false` then no
+   * *objectification* will occur.
+   *
+   * @returns {boolean} The current state of objectifyValues.
+   */
+  get objectifyValues() {
+    return this.#objectifyValues
+  }
+
+  /**
+   * Setting this value to true, will cause all added values to the Set to
+   * be analyzed for validity as a candidate to be wrapped in a `WeakRef`
+   * object. If true, and if possible, the object will be turned into an
+   * `Object` variant first. This will also enable less rigid variable
+   * comparison in the `.has()` method (i.e. `==` instead of `===`).
+   *
+   * @param {boolean} value - The new state to set for objectifyValues.
+   */
+  set objectifyValues(value) {
+    this.#objectifyValues = !!value
+  }
+
+  /**
+   * Overrides the add method of Set. Adds a value to the RefSet, converting it
+   * to a WeakRef. Throws an error if the value is not a valid WeakRef target
+   * (e.g., null, undefined, or a registered symbol). If `objectifyValues` is
+   * enabled, an attempt to convert primitives to their object variants will be
+   * made. These are numbers, strings, boolean values and big integers.
+   *
+   * @param {*} value - The value to be added to the RefSet.
+   * @throws {TypeError} If the value is not a valid WeakRef target.
+   */
+  add(value) {
+    // Objectify the value if needed
+    if (this.#objectifyValues && (
+      typeof value === 'number' ||
+      typeof value === 'string' ||
+      typeof value === 'boolean' ||
+      typeof value === 'bigint'
+    )) {
+      value = Object(value);
+    }
+
+    // Check if the value is an object, and if it's a symbol, ensure it's not registered
+    if (typeof value === 'symbol' && Symbol.keyFor(value) !== undefined) {
+      throw new TypeError('RefSet cannot accept registered symbols as values');
+    }
+
+    if (typeof value !== 'object' && typeof value !== 'symbol') {
+      throw new TypeError(
+        'RefSet values must be objects, non-registered symbols, or objectified primitives'
+      );
+    }
+
+    // If the value is null or undefined, throw an error
+    if (value === null || value === undefined) {
+      throw new TypeError('RefSet values cannot be null or undefined');
+    }
+
+    super.add(new WeakRef(value));
+  }
+
+  /**
+   * Adds multiple values to the RefSet. The supplied `values` should be
+   * iterable and truthy. This function defers to `.add()` for its logic so
+   * each value from the supplied collection of values will also be subject
+   * to the criteria of that function.
+   *
+   * @param {Iterable} values - An iterable of values to add to the RefSet.
+   * @throws {TypeError} If the supplied values are falsey or non-iterable.
+   */
+  addAll(values) {
+    if (
+      !values ||
+      (typeof values !== 'object') ||
+      !Reflect.has(values, Symbol.iterator)
+    ) {
+      throw new TypeError('The supplied values are either falsey or non-iterable')
+    }
+
+    for (const value of values) {
+      this.add(value)
+    }
+  }
+
+  /**
+   * Removes all elements from the RefSet that have been garbage collected
+   * (i.e., their WeakRef no longer points to an object).
+   *
+   * @returns {RefSet} - The current RefSet instance to allow method chaining.
+   */
+  clean() {
+    for (const ref of this) {
+      if (!ref.deref()) {
+        this.delete(ref)
+      }
+    }
+
+    return this
+  }
+
+/**
+ * Executes a provided function once for each value in the RefSet. The callback
+ * function receives the dereferenced value, the value again (as RefSet doesn't
+ * use keys), and the RefSet itself. This method provides a way to iterate over
+ * and apply operations to the values stored in the RefSet, taking into account
+ * that they are weak references and may have been garbage-collected.
+ *
+ * @param {Function} forEachFn - Function to execute for each element. It
+ * takes three arguments: element, element (again, as RefSet has no key), and
+ * the RefSet itself.
+ * @param {*} thisArg - Value to use as `this` when executing `forEachFn`.
+ */
+entries() {
+    const refEntries = super.entries()
+
+    return refEntries
+      .map(([_, ref]) => [ref.deref(), ref.deref()])
+      .filter(([_, value]) => !!value)
+  }
+
+  forEach(forEachFn, thisArg) {
+    const set = this
+
+    super.forEach(function(ref) {
+      const value = ref.deref()
+
+      if (!value) {
+        return
+      }
+
+      forEachFn.call(thisArg, value, value, set)
+    })
+  }
+
+  /**
+   * Returns an iterator for the values in the RefSet. Each value is
+   * dereferenced from its WeakRef before being returned. This method allows
+   * iterating over he set's values, similar to how one would iterate over
+   * values in a standard Set or Array, but with the understanding that the
+   * values are weakly referenced and may no longer exist (in which case
+   * they are skipped).
+   *
+   * @returns {Iterator} An iterator for the values.
+   */
+  values() {
+    const values = []
+
+    for (const value of this) {
+      const dereferenced = value.deref()
+
+      if (dereferenced) {
+        values.push(dereferenced)
+      }
+    }
+
+    return values
+  }
+
+  /**
+   * Returns an iterator for the keys of the RefSet. In RefSet, keys and
+   * values are identical, so this method behaves the same as `values()`. It
+   * provides compatibility with the standard Set interface and allows use in
+   * contexts where keys are expected, despite RefSet not differentiating
+   * between keys and values.
+   *
+   * @returns {Iterator} An iterator for the keys.
+   */
+  keys() {
+    return this.values()
+  }
+
+  /**
+   * Determines whether an element with the specified value exists in the
+   * `RefSet`. For non-objectified sets, this method checks if the dereferenced
+   * values of the set include the specified value.
+   *
+   * For objectified sets, it uses the `contains` method which accounts for
+   * the objectification. This method differs from standard Set `has` in that
+   * it works with weak references and considers objectification settings.
+   *
+   * @param {*} value - The value to check for presence in the RefSet.
+   * @returns {boolean} - True if an element with the specified value exists
+   * in the RefSet, false otherwise.
+   */
+  has(value) {
+    if (this.#objectifyValues) {
+      return this.contains(value)
+    }
+
+    for (const item of this.values()) {
+      if (item === value) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Checks if the RefSet contains a value that is equal to the specified
+   * value. This method is used primarily in objectified RefSets to determine
+   * the presence of a value, taking into account objectification. It differs
+   * from the `has` method in that it's tailored for sets that have
+   * transformed their primitive values into objects, whereas `has` is more
+   * general-purpose.
+   *
+   * @param {*} value - The value to search for in the RefSet.
+   * @returns {boolean} - True if the RefSet contains the value, false otherwise.
+   */
+  contains(value) {
+    return !!(Array.from(this.values())
+      .filter(dereferencedValue => {
+       return value == dereferencedValue
+      })
+      .length
+    )
+  }
+
+  /**
+   * Creates a new array with all elements that pass the test implemented by
+   * the provided function. This method iterates over each element,
+   * dereferences it, and applies the filter function. Unlike Array `filter`,
+   * the callback receives the dereferenced value and not an index or array,
+   * reflecting the non-indexed nature of RefSet. Useful for selectively
+   * creating arrays from the set based on certain conditions, especially when
+   * dealing with weak references.
+   *
+   * @param {Function} filterFn - Function to test each element of the RefSet.
+   * The function receives the dereferenced value.
+   * @param {*} thisArg - Value to use as `this` when executing `filterFn`.
+   * @returns {Array} - A new array with the elements that pass the test.
+   */
+  filter(filterFn, thisArg) {
+    const results = []
+
+    for (const value of this) {
+      const dereferenced = value?.deref()
+
+      if (dereferenced) {
+        const include = filterFn.call(thisArg, dereferenced, NaN, this)
+
+        if (include) {
+          results.push(dereferenced)
+        }
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Returns the value of the first element in the RefSet that satisfies the
+   * provided testing function. Similar to Array `find`, this method iterates
+   * over the RefSet, dereferencing each value and applying the testing
+   * function. The non-indexed nature of RefSet is considered, as the
+   * callback does not receive an index. This method is useful for finding a
+   * specific element based on a condition.
+   *
+   * @param {*} thisArg - Value to use as this when executing findFn.
+   * @returns {*} - The value of the first element in the RefSet that satisfies
+   * the testing function, or undefined if none found.
+   * @returns
+   */
+  find(findFn, thisArg) {
+    for (const value of this) {
+      const dereferenced = value?.deref()
+
+      if (dereferenced) {
+        const found = findFn.call(thisArg, dereferenced, NaN, this)
+
+        if (found) {
+          return dereferenced
+        }
+      }
+    }
+
+    return undefined
+  }
+
+  /**
+   * Creates a new array or `RefSet` with the results of calling a provided
+   * function on every element in the calling `RefSet`. This method dereferences
+   * each value, applies the `mapFn`, and collects the results. If `toRefSet` is
+   * `true`, a new `RefSet` is returned; otherwise, an array. This method
+   * differs from `Array.map` in handling weak references and the potential to
+   * return a new `RefSet` instead of an array.
+   *
+   * @param {Function} mapFn - Function that produces an element of the new
+   * array or `RefSet`, taking three arguments.
+   * @param {*} thisArg - Value to use as this when executing mapFn.
+   * @param {boolean} toRefSet - Determines if the output should be a new
+   * `RefSet` (`true`) or an array (`false`).
+   * @param {boolean} mirrorObjectification - If `true` and `toRefSet` is
+   * `true`, the new `RefSet` mirrors the objectification setting of the
+   * original.
+   * @returns {Array|RefSet} - A new array or `RefSet` with each element being
+   * the result of the `mapFn`.
+   */
+  map(mapFn, thisArg, toRefSet, mirrorObjectification) {
+    const mapped = []
+
+    let validRefSetOutput = true
+    let validRefSetOutputIfObjectified = true
+
+    for (const value of this) {
+      const dereferenced = value?.deref()
+
+      if (dereferenced) {
+        const mappedItem = mapFn.call(thisArg, dereferenced, NaN, this)
+
+        if (validRefSetOutput || validRefSetOutputIfObjectified) {
+          const weakReferenceable = this.#validWeakRefTarget(mappedItem)
+
+          if (!weakReferenceable) {
+            validRefSetOutput = false
+
+            if (validRefSetOutputIfObjectified) {
+              validRefSetOutputIfObjectified =
+                this.#validWeakRefTarget(Object(mappedItem))
+            }
+          }
+        }
+
+        mapped.push(mappedItem)
+      }
+    }
+
+    if (toRefSet) {
+      if (validRefSetOutput) {
+        return new RefSet(mapped).objectifying(
+          mirrorObjectification ? this.objectifyValues : false
+        )
+      }
+
+      if (validRefSetOutputIfObjectified) {
+        return new RefSet(mapped.map(value => {
+          return this.#validWeakRefTarget(value) ? value : Object(value)
+        })).objectifying()
+      }
+    }
+
+    return mapped
+  }
+
+  /**
+   * Ensures that the constructor of this object instance's name
+   * is returned if the string tag for this instance is queried
+   *
+   * @returns {string} the name of the class
+   */
+  get [Symbol.toStringTag]() {
+    return this.constructor.name
+  }
+
+  /**
+   * Private method to check if a given value is a valid target for a WeakRef.
+   *
+   * @param {*} value - The value to check for validity as a WeakRef target.
+   * @returns {boolean} - True if the value is a valid WeakRef target,
+   * false otherwise.
+   * @private
+   */
+  #validWeakRefTarget(value) {
+    return !(
+      (typeof value === 'symbol' && Symbol.keyFor(value) === undefined) ||
+      (typeof value !== 'object' && typeof value !== 'symbol') ||
+      (value === null || value === undefined)
+    )
+  }
+}
+
+export const RefSetExtensions = new Extension(RefSet)

package/src/symbolextensions.js

@@ -19,4 +19,50 @@ export const SymbolExtensions = new Patch(Symbol, {
   isSymbol(value) {
     return value && (typeof value === 'symbol');
   },
+
+  /**
+   * Returns true if the supplied value is a Symbol created using
+   * `Symbol.for()`.
+   *
+   * @param {any} value assumption is that the supplied value is of type
+   * 'symbol' however, unless `allowOnlySymbols` is set to `true`, `false`
+   * will be returned for any non-symbol values.
+   * @param {boolean} allowOnlySymbols true if an error should be thrown
+   * if the supplied value is not of type 'symbol'
+   * @returns true if the symbol is registered, meaning, none of the spec
+   * static symbols (`toStringTag`, `iterator`, etc...), and no symbols
+   * created by passing a value directly to the Symbol function, such as
+   * `Symbol('name')`
+   */
+  isRegistered(value, allowOnlySymbols = false) {
+    if (!Symbol.isSymbol(value)) {
+      if (allowOnlySymbols) {
+        throw new TypeError('allowOnlySymbols specified; value is not a symbol')
+      }
+      return false
+    }
+
+    return Symbol.keyFor(value) !== undefined
+  },
+
+  /**
+   * A function that returns true if the symbol is not registered, meaning,
+   * any of the spec static symbols (`toStringTag`, `iterator`, etc...), and
+   * any symbols created by passing a value directly to the `Symbol` function,
+   * such as `Symbol('name')`.
+   *
+   * @param {any} value assumption is that the supplied value is of type
+   * 'symbol' however, unless allowOnlySymbols is set to true, false will
+   * be returned for any non-symbol values.
+   * @param {boolean} allowOnlySymbols true if an error should be thrown
+   * if the supplied value is not of type 'symbol'
+   * @returns true if the symbol is not registered, meaning, any of the
+   * spec static symbols (`toStringTag`, `iterator`, etc...), and any symbols
+   * created by passing a value directly to the `Symbol` function, such as
+   * `Symbol('name')`
+   * @returns
+   */
+  isNonRegistered(value, allowOnlySymbols = false) {
+    return !Symbol.isRegistered(value, allowOnlySymbols)
+  },
 });

package/src/weakrefextensions.js

@@ -0,0 +1,18 @@
+import { Patch } from '@nejs/extension'
+
+export const WeakRefExtensions = new Patch(WeakRef, {
+  /**
+   * A static method to check if a given value is a valid target for a WeakRef.
+   *
+   * @param {*} value - The value to check for validity as a WeakRef target.
+   * @returns {boolean} - True if the value is a valid WeakRef target,
+   * false otherwise.
+   */
+  isValidReference(value) {
+    return !(
+      (typeof value === 'symbol' && Symbol.keyFor(value) === undefined) ||
+      (typeof value !== 'object' && typeof value !== 'symbol') ||
+      (value === null || value === undefined)
+    )
+  },
+})

package/tests/asyncIterable.test.js

@@ -0,0 +1,44 @@
+const { enableAll, disableAll } = require('../dist/cjs/index.js')
+
+describe('AsyncIterable', () => {
+  beforeAll(() => { enableAll() })
+  afterAll(() => { disableAll() })
+
+  test('should create an async iterable from an array of promises', async () => {
+    const promises = [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)];
+    const asyncIterable = new AsyncIterable(promises);
+    const result = [];
+
+    for await (const item of asyncIterable) {
+      result.push(item);
+    }
+
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  test('should create an async iterable from individual promises', async () => {
+    const asyncIterable = new AsyncIterable(Promise.resolve(1), Promise.resolve(2), Promise.resolve(3));
+    const result = [];
+
+    for await (const item of asyncIterable) {
+      result.push(item);
+    }
+
+    expect(result).toEqual([1, 2, 3]);
+  });
+
+  test('isAsyncIterable should return true for async generator function', async () => {
+    async function* gen() {
+      yield Promise.resolve(1);
+    }
+    const asyncIterable = new AsyncIterable(gen);
+
+    expect(AsyncIterable.isAsyncIterable(asyncIterable)).toBeTruthy();
+  });
+
+  test('isAsyncIterable should return false for non-async iterables', () => {
+    const nonAsyncIterable = new Iterable([1, 2, 3]);
+
+    expect(AsyncIterable.isAsyncIterable(nonAsyncIterable)).toBeFalsy();
+  });
+});

package/tests/iterable.test.js

@@ -0,0 +1,45 @@
+const { enableAll, disableAll } = require('../dist/cjs/index.js')
+
+describe('Iterable', () => {
+  beforeAll(() => { enableAll() })
+  afterAll(() => { disableAll() })
+
+  test('should create an iterable from an array', () => {
+    const array = [1, 2, 3];
+    const iterable = new Iterable(array);
+
+    expect([...iterable]).toEqual(array);
+  });
+
+  test('should create an iterable from individual elements', () => {
+    const iterable = new Iterable(1, 2, 3);
+
+    expect([...iterable]).toEqual([1, 2, 3]);
+  });
+
+  test('should work with for...of loop', () => {
+    const iterable = new Iterable('a', 'b', 'c');
+    const result = [];
+
+    for (const item of iterable) {
+      result.push(item);
+    }
+
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+
+  test('isIterable should return true for generator function', () => {
+    function* gen() {
+      yield 1;
+    }
+    const iterable = new Iterable(gen);
+
+    expect(Iterable.isIterable(iterable)).toBeTruthy();
+  });
+
+  test('isIterable should return false for non-iterables', () => {
+    const nonIterable = {};
+
+    expect(Iterable.isIterable(nonIterable)).toBeFalsy();
+  });
+});

package/tests/refset.test.js

@@ -0,0 +1,58 @@
+const { enableAll, disableAll } = require('../dist/cjs/index.js')
+
+describe('RefSet', () => {
+  beforeAll(() => { enableAll() })
+  afterAll(() => { disableAll() })
+
+  let refSet;
+
+  beforeEach(() => {
+    refSet = new RefSet();
+  });
+
+  describe('objectification behavior', () => {
+    test('should objectify primitive values when objectification is enabled', () => {
+      refSet.objectifying(true).add(123)
+
+      expect([...refSet].length).toBe(1);
+      expect(typeof [...refSet][0]).toBe('object');
+    });
+
+    test('should not objectify primitive values when objectification is disabled', () => {
+      expect(() => refSet.objectifying(false).add(123)).toThrow()
+    });
+  });
+
+  describe('add method', () => {
+    test('should add non-null objects and non-registered symbols', () => {
+      const obj = {};
+      const symbol = Symbol('test');
+      refSet.add(obj);
+      refSet.add(symbol);
+
+      expect(refSet.has(obj)).toBeTruthy();
+      expect(refSet.has(symbol)).toBeTruthy();
+    });
+
+    test('should throw for null, undefined, and registered symbols', () => {
+      expect(() => refSet.add(null)).toThrow(TypeError);
+      expect(() => refSet.add(undefined)).toThrow(TypeError);
+      expect(() => refSet.add(Symbol.for('test'))).toThrow(TypeError);
+    });
+  });
+
+  describe('addAll method', () => {
+    test('should add all elements from an iterable', () => {
+      const values = [1, 2, 3];
+      refSet.objectifying().addAll(values);
+
+      expect(refSet.size).toBe(values.length);
+    });
+
+    test('should throw for non-iterable values', () => {
+      expect(() => refSet.addAll(null)).toThrow(TypeError);
+    });
+  });
+
+});
+

package/dist/@nejs/basic-extensions.bundle.1.4.0.js

@@ -1,2 +0,0 @@
-var nejsBasicExtensions=(()=>{var R=Object.defineProperty;var F=Object.getOwnPropertyDescriptor;var C=Object.getOwnPropertyNames;var I=Object.prototype.hasOwnProperty;var B=(e,t)=>{for(var s in t)R(e,s,{get:t[s],enumerable:!0})},K=(e,t,s,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of C(t))!I.call(e,i)&&i!==s&&R(e,i,{get:()=>t[i],enumerable:!(r=F(t,i))||r.enumerable});return e};var Y=e=>K(R({},"__esModule",{value:!0}),e);var J={};B(J,{ArrayPrototypeExtensions:()=>D,DescriptorExtension:()=>E,FunctionExtensions:()=>d,GlobalFunctionsAndProps:()=>x,ObjectExtensions:()=>p,ReflectExtensions:()=>b,StringExtensions:()=>y,SymbolExtensions:()=>v,all:()=>W,disableAll:()=>H,enableAll:()=>U});var k=e=>/(\w+)]/.exec(Object.prototype.toString.call(e))[1],f=class extends Error{constructor(t,s){super(`${k(t)} disallows tampering with ${s}.`),Object.assign(this,{owner:t,key:s})}get[Symbol.toStringTag](){return this.constructor.name}};var M=e=>/(\w+)]/.exec(Object.prototype.toString.call(e))[1],h=class extends Error{constructor(t,s){super(`${M(t)} does not have a property named '${s}'.`),Object.assign(this,{owner:t,key:s})}get[Symbol.toStringTag](){return this.constructor.name}};var g=class{constructor(t,s=!1){this.started=!1,this.preventRevert=s,this.patch=t,this.patchName=t.owner?.name??t.owner?.constructor?.name??/(\w+)]/.exec(Object.prototype.toString.call(t.owner))[1],this.state={needsApplication:!1,needsReversion:!1}}start(){return this.started||(this.state.needsApplication=!this.patch.applied,this.state.needsReversion=this.patch.applied,this.started=!0,this.state.needsApplication&&this.patch.apply()),this}stop(){return this.started&&((this.preventRevert||this.patch.applied)&&this.patch.revert(),this.state.needsApplication=!1,this.state.needsReversion=!1,this.started=!1),this}get[Symbol.toStringTag](){return`${this.constructor.name}:${this.patchName}`}[Symbol.for("nodejs.util.inspect.custom")](t,s,r){let i=this[Symbol.toStringTag],n=`(started: ${this.started} needed: ${this.state.needsApplication})`;return r(`${i} ${n}`,{...s,depth:t})}};var c=class e{constructor(t,s,r={}){Object.assign(this,{owner:t,options:r,applied:!1}),this.patchConflicts={},this.patchEntries={},this.patchesOwner=s,Reflect.ownKeys(s).forEach(i=>{this.patchEntries[i]=new e.#t(i,this.patchesOwner),Reflect.has(this.owner,i)&&(this.patchConflicts[i]=new e.#t(i,this.owner))}),e.patches.has(t)||e.patches.set(t,[]),e.patches.get(t).push(this)}get patches(){return Reflect.ownKeys(this.patchEntries).map(t=>[t,this.patchEntries[t]])}get conflicts(){return Reflect.ownKeys(this.patchConflicts).map(t=>[t,this.patchConflicts[t]])}apply(){this.applied||(this.patches.forEach(([,t])=>{Object.defineProperty(this.owner,t.key,t.descriptor)}),this.applied=!0)}createToggle(t=!1){return new g(this,t)}revert(){this.applied&&(this.patches.forEach(([,t])=>{delete this.owner[t.key]}),this.conflicts.forEach(([,t])=>{Object.defineProperty(this.owner,t.key,t.descriptor)}),this.applied=!1)}release(){let t=e.patches.get(this.owner);t.splice(t.find(s=>s===this),1)}owner=null;options=null;static patches=new Map;static enableFor(t){if(e.patches.has(t))for(let s of e.patches.get(t))s.apply()}static disableFor(t){if(e.patches.has(t))for(let s of e.patches.get(t))s.revert()}static#t=class{constructor(t,s=globalThis){Object.assign(this,{key:t,descriptor:Object.getOwnPropertyDescriptor(s,t),owner:s})}get computed(){return this.isAccessor?this.descriptor.get.bind(this.owner).call():this.descriptor.value}get isData(){return Reflect.has(this.descriptor,"value")}get isAccessor(){return Reflect.has(this.descriptor,"get")}get isReadOnly(){return Reflect.has(this.descriptor,"configurable")&&!this.descriptor.configurable||Reflect.has(this.descriptor,"writable")&&!this.descriptor.writable}get[Symbol.toStringTag](){return this.constructor.name}[Symbol.for("nodejs.util.inspect.custom")](t,s,r){return`PatchEntry<${this.key}, ${this.isData?"Data":"Accessor"}${this.isReadOnly?" [ReadOnly]":""}>`}}};var m=class e extends c{constructor(t,s,r=globalThis,i={}){let{key:n,extension:o,valid:a}=e.determineInput(t);if(o=s||o,!a)throw new h(r,n);let l=Object.getOwnPropertyDescriptor(r,n);if(l&&(Reflect.has(l,"writable")&&!l.writable||Reflect.has(l,"configurable")&&!l.configurable))throw new f(r,n);super(r,{[n]:o},i),this.key=n}static determineInput(t){let s={key:null,extension:null,valid:!1};return t instanceof Function?s={key:t.name,extension:t,valid:!0}:(typeof t=="string"||t instanceof String)&&(s={key:t,extension:null,valid:!0}),s}[Symbol.for("nodejs.util.inspect.custom")](t,s,r){return`Extension<${this.key}>`}get[Symbol.toStringTag](){return this.constructor.name}};var d=new c(Function,{isClass(e){return e instanceof Function&&!!/^class\s/.exec(String(e))},isFunction(e){return e instanceof Function},isAsync(e){let t=/(\w+)]/g.exec(Object.prototype.toString.call(e))[1];return e instanceof Function&&t.includes("Async")},isBigArrow(e){return e instanceof Function&&String(e).includes("=>")&&!String(e).startsWith("bound")&&!Reflect.has(e,"prototype")},isBound(e){return e instanceof Function&&String(e).startsWith("bound")&&!Reflect.has(e,"prototype")}});var p=new c(Object,{getStringTag(e){return/\s(.+)]/.exec(Object.prototype.toString.call(e))[1]},getType(e,t=globalThis){let s=Object.getStringTag(e);switch(s){case"Null":return null;case"Undefined":return;default:return t[s]}},isObject(e){return e&&(e instanceof Object||typeof e=="object")},isPrimitive(e){if(e===null)return!0;switch(typeof e){case"string":case"number":case"bigint":case"boolean":case"undefined":case"symbol":return!0;default:return!1}},isValidKey(e){return typeof e=="string"||typeof e=="symbol"},stripTo(e,t,s=!0){let r={};if(!Array.isArray(t))return r;for(let i of t)if(Reflect.has(e,i)){let n=Object.getOwnPropertyDescriptor(e,i);(Reflect.has(n,"get")||Reflect.has(n,"set"))&&s&&(n.get=n?.get?.bind(e),n.set=n?.set?.bind(e)),Object.defineProperty(r,n)}return r}});var b=new c(Reflect,{hasAll(e,...t){return Object.isObject(e)&&t.flat(1/0).map(s=>Reflect.has(e,s)).every(s=>s)},ownDescriptors(e){let t={},s=()=>s.doIt?p.revert():"";if(s.doIt=!1,Object.isObject||(s.doIt=!0,p.apply()),!Object.isObject(e))return s(),{};let r=Reflect.ownKeys(e);for(let i of r)t[i]=Object.getOwnPropertyDescriptor(i);return s(),t},hasSome(e,...t){return Object.isObject(e)&&t.flat(1/0).map(s=>Reflect.has(e,s)).some(s=>s)},entries(e){return!e||typeof e!="object"?[]:Reflect.ownKeys(e).map(t=>[t,Object.getOwnPropertyDescriptor(e,t)])},values(e){return Reflect.entries.map(([,t])=>t)}});var y=new c(String,{isString(e){return e&&(typeof e=="string"||e instanceof String)?e.length>0:!1}});var v=new c(Symbol,{isSymbol(e){return e&&typeof e=="symbol"}});var D=new c(Array.prototype,{contains(e){return!!this.find(t=>t===e)},findEntry(e){let t=this.entries(),s=1;for(let r of t)if(e(r[s]))return r},get first(){return this[0]},get last(){return this[this.length-1]}});var S=p.patchEntries?.isObject?.computed,P=p.patchEntries?.isValidKey?.computed,G=y.patchEntries?.isString?.computed,w=b.patchEntries?.hasSome?.computed,T=class e{#t=e.enigmatic;constructor(t,s){if(this.#t=t,S(t)&&P(s)&&(this.#t=Object.getOwnPropertyDescriptor(t,s)),!this.isDescriptor)throw new Error("Not a valid descriptor:",this.#t)}get isAccessor(){return e.isAccessor(this.#t)}get isData(){return e.isData(this.#t)}get isDescriptor(){return e.isDescriptor(this.#t)}get configurable(){return!!this.#t?.configurable}set configurable(t){(this.#t||{}).configurable=!!t}get enumerable(){return this.#t?.enumerable}set enumerable(t){(this.#t||{}).enumerable=t}get writable(){return this.#t?.writable}set writable(t){(this.#t||{}).writable=t}get value(){return this.#t?.value}set value(t){(this.#t||{}).value=t}get get(){return this.#t?.get}set get(t){(this.#t||{}).get=t}get set(){return this.#t?.writable}set set(t){(this.#t||{}).set=t}static for(t,s){return!S(t)&&!P(s)?null:Object.getOwnPropertyDescriptor(t,s)}applyTo(t,s){if(!S(t)||!P(s))throw new Error("Cannot apply descriptor to non-object or invalid key");return Object.defineProperty(t,s,this.#t)}[Symbol.toPrimitive](t){switch(t){case"string":if(this.isAccessor){let s=Reflect.has(this.#t,"get")?"getter":"",r=Reflect.has(this.#t,"set")?"setter":"";return`Accessor (${s}${s&&r?", ":""}${r})`}else if(this.isData){let s=Reflect.has(this.#t,"value")?"value":"",r=Reflect.has(this.#t,"writable")?"writable":"";return`Data (${s}${s&&r?", ":""}${r})`}break;case"number":return NaN;default:return this.#t}}static getData(t,s){if(!S(t)||!G(s))return null;let r=e.all(t);if(r.has(s)){let i=r.get(s);if(e.isData(i))return i.value}}static getAccessor(t,s){if(!S(t))return null;let[r,i,n]=[0,1,2],o=[void 0,void 0,void 0],a=this.all(t),l=e.isDescriptor(t);if(a.has(s)||l){let u=l?t:a.get(s);if(e.isAccessor(u))return o[n]=a.object(s),o[r]=u?.get,o[i]=u?.set,Object.assign(o,{get(){this[r].bind(this[n])()},set(A){this[i].bind(this[n])(A)},get accessor(){return!0},get descriptor(){return u},get boundDescriptor(){return{...u,get:u.get?.bind(t),set:u.set?.bind(t)}}}),o}}static base(t=!1,s=!1){return{enumerable:t,configurable:s}}static accessor(t,s,{enumerable:r,configurable:i}=e.base()){return{get:t,set:s,enumerable:r,configurable:i}}static data(t,s=!0,{enumerable:r,configurable:i}=e.base()){return{value:t,enumerable:r,writable:s,configurable:i}}static isDescriptor(t){let s=[...e.SHARED_KEYS,...e.ACCESSOR_KEYS,...e.DATA_KEYS];return w(t,s)}static isData(t,s){let i=(typeof t=="object"||t instanceof Object)&&s instanceof String?e.for(t,s):t,{ACCESSOR_KEYS:n,DATA_KEYS:o}=this,a=!1;return w(i,n)?a=!1:w(i,o)&&(a=!0),a}static isAccessor(t,s){let i=t&&s&&(typeof t=="object"||t instanceof Object)&&(s instanceof String||typeof s=="symbol")?e.for(t,s):t,{ACCESSOR_KEYS:n,DATA_KEYS:o}=this,a=!1;return w(i,o)?a=!1:w(i,n)&&(a=!0),a}static get flexible(){return this.base(!0,!0)}static get enigmatic(){return this.base(!1,!0)}static get intrinsic(){return this.base(!1,!1)}static get transparent(){return this.base(!0,!1)}static get SHARED_KEYS(){return["configurable","enumerable"]}static get ACCESSOR_KEYS(){return["get","set"]}static get DATA_KEYS(){return["value","writable"]}},E=new m(T);var{isClass:V,isFunction:O}=d.patchEntries.isClass.computed,N=Symbol.for("nodejs.util.inspect.custom"),x=new c(globalThis,{asBigIntObject(e){let t={configurable:!0,enumerable:!1},s={value:e};return Object.defineProperties(s,{[Symbol.toPrimitive]:{value:function(){return e},...t},[Symbol.toStringTag]:{value:BigInt.name,...t},[Symbol.species]:{get(){return BigInt},...t},[N]:{...t,value(r,i,n){return n(this[Symbol.toPrimitive](),{...i,depth:r})}}}),Object.setPrototypeOf(s,BigInt.prototype),Reflect.ownKeys(BigInt.prototype).forEach(r=>{typeof s[r]=="function"&&(s[r]=function(...i){return BigInt.prototype[r].apply(this,i)}.bind(s.value))}),s},maskAs(e,t,s){let{prototype:r,toPrimitive:i}=GenericMask({...s,prototype:t}),n={configurable:!0,enumerable:!1},o=O(r)?r.prototype:r,a=V(r)?r:o?.constructor;return!a&&!o?null:(Object.setPrototypeOf(e,o),Object.defineProperties(e,{valueOf:{value(){return String(i("default",e))},...n},[Symbol.toPrimitive]:{value(l){return i(l,e)},...n},[Symbol.toStringTag]:{value:a.name,...n},[Symbol.species]:{get(){return a},...n},[N]:{...n,value(l,u,A){return A(this[Symbol.toPrimitive](),{...u,depth:l})}}}),e)},maskAsString(e,t,s){return e&&Reflect.has(e,t)?maskAs(e,StringMask(t??"value",s)):null},maskAsNumber(e,t,s){return e&&Reflect.has(e,t)?maskAs(e,NumberMask(t??"value",s)):null},GenericMask({prototype:e,targetKey:t="value",toPrimitive:s}){let r={targetKey:t,toPrimitive:s,prototype:e};return O(s)||(r.toPrimitive=(i,n)=>{let o=n[t],a=typeof o=="number"&&Number.isFinite(o)||typeof o=="string"&&!isNaN(parseFloat(o))&&isFinite(o);switch(i){case"string":return a?String(o):o??String(n);case"number":return a?Number(o):NaN;case"default":default:return a?Number(o):o}}),r},StringMask(e,t){let s={targetKey:e,toPrimitive:t,prototype:String.prototype};return O(t)||(s.toPrimitive=function(i,n){switch(i){case"default":return n[e];case"number":return parseInt(n[e],36);case"string":return String(n[e]);default:return n}}),s},NumberMask(e,t){let s={targetKey:e,toPrimitive:t,prototype:Number.prototype};return O(t)||(s.toPrimitive=function(i,n){switch(i){case"default":return n[e];case"number":return Number(n[e]);case"string":return String(n[e]);default:return n}}),s}});var $=[Object,Function,Reflect,String,Symbol,Array.prototype],j=[x,E];function U(e){let t=e||$;if(!t)throw new Error("Unable to enable features without owners list");t.forEach(s=>{c.enableFor(s)}),j.forEach(s=>{s.apply()})}function H(e){let t=e||$;if(!t)throw new Error("Unable to disable features without owners list");t.forEach(s=>{c.disableFor(s)}),j.forEach(s=>{s.revert()})}var W=[p,d,b,y,v,D,x,E].reduce((s,r)=>(Reflect.ownKeys(r.patchEntries).reduce((i,n)=>(s[n]=r.patchEntries[n].computed,s),s),s),{});return Y(J);})();
-//# sourceMappingURL=basic-extensions.bundle.1.4.0.js.map