@nejs/basic-extensions 1.6.1 → 1.7.0

package/dist/mjs/objectextensions.js

@@ -1,13 +1,24 @@
 import { Patch } from '@nejs/extension';
 /**
- * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class. It
- * adds utility methods to the `Object` class without modifying the global namespace
- * directly. This patch includes methods for key validation, object type checking,
- * and retrieving the string tag of an object. These methods are useful for
- * enhancing the capabilities of the standard `Object` class with additional
- * utility functions.
+ * `ObjectExtensions` is a patch for the JavaScript built-in `Object` class.
+ * It adds utility methods to the `Object` class without modifying the global
+ * namespace directly. This patch includes methods for key validation, object
+ * type checking, and retrieving the string tag of an object. These methods
+ * are useful for enhancing the capabilities of the standard `Object` class
+ * with additional utility functions.
  */
 export const ObjectExtensions = new Patch(Object, {
+    /**
+     * The function checks if a value is either `undefined` or `null`.
+     *
+     * @param {any} value - The parameter "value" is a variable that can hold
+     * any value.
+     * @returns {boolean} `true` if the value is either `undefined` or `null`,
+     * and `false` otherwise.
+     */
+    isNullDefined(value) {
+        return value === undefined || value === null;
+    },
     /**
      * Checks to see if the supplied `value` is both an object, and has the
      * appropriate symbol defined.
@@ -20,18 +31,25 @@ export const ObjectExtensions = new Patch(Object, {
         return Object.isObject(value) && Reflect.has(value, Symbol.toStringTag);
     },
     /**
-     * Retrieves the string tag of an object. The string tag is a representation of
-     * the object's type, as defined by its `Object.prototype.toString` method. This
-     * utility method is helpful for getting a more descriptive type of an object than
-     * what is returned by the `typeof` operator, especially for custom objects.
+     * Retrieves the string tag of an object. The string tag is a representation
+     * of the object's type, as defined by its `Object.prototype.toString`
+     * method. This utility method is helpful for getting a more descriptive
+     * type of an object than what is returned by the `typeof` operator,
+     * especially for custom objects.
      *
      * @param {*} value - The object whose string tag is to be retrieved.
+     * @param {boolean} strict - if this is set to true, undefined will be
+     * returned whenever a supplied object does not have a
+     * `Symbol.toStringTag` defined, period. if false, the default,
      * @returns {string} - The string tag of the object, indicating its type.
      */
-    getStringTag(value) {
+    getStringTag(value, strict = false) {
         if (Object.hasStringTag(value)) {
             return value[Symbol.toStringTag];
         }
+        if (strict) {
+            return undefined;
+        }
         if (value && (typeof value === 'function')) {
             return value.name;
         }
@@ -49,13 +67,13 @@ export const ObjectExtensions = new Patch(Object, {
      *
      * @param {any} value - The value whose type is to be determined.
      * @param {object} [owner=globalThis] - The object in which to look up the
-     * constructor corresponding to the string tag. Defaults to `globalThis`, which
-     * covers global constructors like `Array`, `Object`, etc.
-     * @returns {Function|object|null|undefined} - Returns the constructor or type
-     * of the value based on its string tag. For 'Null' and 'Undefined', it returns
-     * `null` and `undefined`, respectively. For other types, it returns the
-     * corresponding constructor (e.g., `Array` for arrays) if available in the
-     * `owner` object.
+     * constructor corresponding to the string tag. Defaults to `globalThis`,
+     * which covers global constructors like `Array`, `Object`, etc.
+     * @returns {Function|object|null|undefined} - Returns the constructor or
+     * type of the value based on its string tag. For 'Null' and 'Undefined',
+     * it returns `null` and `undefined`, respectively. For other types, it
+     * returns the corresponding constructor (e.g., `Array` for arrays) if
+     * available in the `owner` object.
      */
     getType(value, owner = globalThis) {
         const stringTag = Object.getStringTag(value);
@@ -67,13 +85,14 @@ export const ObjectExtensions = new Patch(Object, {
         }
     },
     /**
-     * Determines if the provided value is an object. This method checks whether the
-     * value is an instance of `Object` or if its type is 'object'. It's a utility
-     * method for type-checking, ensuring that a value is an object before performing
-     * operations that are specific to objects.
+     * Determines if the provided value is an object. This method checks whether
+     * the value is an instance of `Object` or if its type is 'object'. It's a
+     * utility method for type-checking, ensuring that a value is an object
+     * before performing operations that are specific to objects.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} - Returns `true` if the value is an object, otherwise `false`.
+     * @returns {boolean} - Returns `true` if the value is an object,
+     * otherwise `false`.
      */
     isObject(value) {
         return value && (value instanceof Object || typeof value === 'object');
@@ -105,13 +124,14 @@ export const ObjectExtensions = new Patch(Object, {
         }
     },
     /**
-     * Checks if the given value is a valid key for an object. In JavaScript, a valid
-     * key can be either a string or a symbol. This method is useful for validating
-     * object keys before using them in operations like setting or getting object properties.
+     * Checks if the given value is a valid key for an object. In JavaScript, a
+     * valid key can be either a string or a symbol. This method is useful for
+     * validating object keys before using them in operations like setting or
+     * getting object properties.
      *
      * @param {*} value - The value to be checked.
-     * @returns {boolean} - Returns `true` if the value is a valid object key (string or symbol),
-     *                      otherwise `false`.
+     * @returns {boolean} - Returns `true` if the value is a valid object key
+     * (string or symbol), otherwise `false`.
      */
     isValidKey(value) {
         return (typeof value === 'string' || typeof value === 'symbol');
@@ -123,33 +143,55 @@ export const ObjectExtensions = new Patch(Object, {
      * @param {object} object the object to pare down
      * @param {Array<string|symbol>} keys the keys that should appear in the
      * final reduced object
-     * @param {boolean} [bindAccessors = true] if this value is true
-     * then any accessors from the source object will continue to have their
-     * `this` value bound to the source. If the getter or setter on that object
-     * is defined using an arrow function, this will not work as intended.
-     * @returns {object} an object containing only the keys and symbols specified
-     * in the `keys` parameter.
+     * @param {boolean} [bindAccessors = true] if this value is true then any
+     * accessors from the source object will continue to have their `this`
+     * value bound to the source. If the getter or setter on that object is
+     * defined using an arrow function, this will not work as intended.
+     * @returns {object} an object containing only the keys and symbols
+     * specified in the `keys` parameter.
      */
     stripTo(object, keys, bindAccessors = true) {
+        if (!object || typeof object !== 'object') {
+            throw new TypeError('Object.stripTo requires an object to strip. Received', object);
+        }
         const result = {};
         if (!Array.isArray(keys)) {
             return result;
         }
         for (let key of keys) {
             if (Reflect.has(object, key)) {
-                const descriptor = Object.getOwnPropertyDescriptor(object, key);
-                if (Reflect.has(descriptor, 'get') || Reflect.has(descriptor, 'set')) {
+                const originalDescriptor = Object.getOwnPropertyDescriptor(object, key);
+                const descriptor = { ...originalDescriptor };
+                if (typeof descriptor.get === 'function' ||
+                    typeof descriptor.set === 'function') {
                     if (bindAccessors) {
-                        descriptor.get = descriptor?.get?.bind(object);
-                        descriptor.set = descriptor?.set?.bind(object);
+                        descriptor.get = descriptor.get?.bind(object);
+                        descriptor.set = descriptor.set?.bind(object);
                     }
-                    Object.defineProperty(result, descriptor);
-                }
-                else {
-                    Object.defineProperty(result, descriptor);
                 }
+                Object.defineProperty(result, key, descriptor);
             }
         }
         return result;
     },
 });
+export const ObjectPrototypeExtensions = new Patch(Object.prototype, {
+    /**
+     * Strips an object down to only the keys specified. Optionally, any
+     * accessors can be made to retain their context on the source object.
+     * This is a passthrough to the static {@link Object.stripTo} function
+     *
+     * @param {Array<string|symbol>} keys the keys that should appear in the
+     * final reduced object
+     * @param {boolean} [bindAccessors = true] if this value is true then any
+     * accessors from the source object will continue to have their `this`
+     * value bound to the source. If the getter or setter on that object is
+     * defined using an arrow function, this will not work as intended.
+     * @returns {object} an object containing only the keys and symbols
+     * specified in the `keys` parameter.
+     */
+    stripTo(keys, bindAccessors = true) {
+        return Object.stripTo(this, keys, bindAccessors);
+    }
+});
+//# sourceMappingURL=objectextensions.js.map

package/dist/mjs/objectextensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectextensions.js","sourceRoot":"","sources":["../../src/objectextensions.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;IAChD;;;;;;;OAOG;IACH,aAAa,CAAC,KAAK;QACjB,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,CAAA;IAC9C,CAAC;IAED;;;;;;;OAOG;IACH,YAAY,CAAC,KAAK;QAChB,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,WAAW,CAAC,CAAA;IACzE,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;QAChC,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAA;QAClC,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,SAAS,CAAA;QAClB,CAAC;QAED,IAAI,KAAK,IAAI,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC,EAAE,CAAC;YAC3C,OAAO,KAAK,CAAC,IAAI,CAAA;QACnB,CAAC;QAED,OAAO,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU;QAC/B,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;QAE5C,QAAQ,SAAS,EAAE,CAAC;YAClB,KAAK,MAAM,CAAC,CAAC,OAAO,IAAI,CAAA;YACxB,KAAK,WAAW,CAAC,CAAC,OAAO,SAAS,CAAA;YAClC;gBACE,OAAO,KAAK,CAAC,SAAS,CAAC,CAAA;QAC3B,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK;QACZ,OAAO,KAAK,IAAI,CAAC,KAAK,YAAY,MAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,KAAK;QACf,uDAAuD;QACvD,cAAc;QACd,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,6BAA6B;QAC7B,QAAQ,OAAO,KAAK,EAAE,CAAC;YACrB,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ,CAAC;YACd,KAAK,SAAS,CAAC;YACf,KAAK,WAAW,CAAC;YACjB,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC;YACd;gBACE,OAAO,KAAK,CAAC;QACjB,CAAC;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,UAAU,CAAC,KAAK;QACd,OAAO,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,IAAI;QACxC,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC1C,MAAM,IAAI,SAAS,CACjB,sDAAsD,EACtD,MAAM,CACP,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAG,EAAE,CAAC;QAElB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,KAAK,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;YACrB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;gBAC7B,MAAM,kBAAkB,GAAG,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;gBACxE,MAAM,UAAU,GAAG,EAAE,GAAG,kBAAkB,EAAE,CAAC;gBAE7C,IACE,OAAO,UAAU,CAAC,GAAG,KAAK,UAAU;oBACpC,OAAO,UAAU,CAAC,GAAG,KAAK,UAAU,EACpC,CAAC;oBACD,IAAI,aAAa,EAAE,CAAC;wBAClB,UAAU,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;wBAC9C,UAAU,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;oBAChD,CAAC;gBACH,CAAC;gBAED,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE;IACnE;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;QAChC,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,CAAA;IAClD,CAAC;CACF,CAAC,CAAA"}

package/dist/mjs/reflectextensions.js

@@ -1,5 +1,6 @@
 import { Patch } from '@nejs/extension';
 import { ObjectExtensions } from './objectextensions.js';
+const { isObject } = ObjectExtensions.patches;
 /**
  * The `ReflectExtensions` class is a patch applied to the built-in JavaScript
  * `Reflect` object. It extends `Reflect` with additional utility methods that
@@ -28,23 +29,25 @@ export const ReflectExtensions = new Patch(Reflect, {
             .map(key => Reflect.has(object, key))
             .every(has => has));
     },
+    /**
+     * Fetches all descriptors of an object, including those mapped to a
+     * symbol descriptor value.
+     *
+     * @param {object} object the object from whose descriptors need to be
+     * retrieved.
+     * @returns {object} with keys mapped to object descriptors
+     * @throws {TypeError} if the supplied `object` is null or not an object
+     * a TypeError exception will be thrown
+     */
     ownDescriptors(object) {
-        const result = {};
-        const revertOnDone = () => revertOnDone.doIt ? ObjectExtensions.revert() : '';
-        revertOnDone.doIt = false;
-        if (!Object.isObject) {
-            revertOnDone.doIt = true;
-            ObjectExtensions.apply();
-        }
-        if (!Object.isObject(object)) {
-            revertOnDone();
-            return {};
+        if (!isObject(object)) {
+            throw new TypeError('The supplied object must be non-null and an object');
         }
+        const result = {};
         const keys = Reflect.ownKeys(object);
         for (const key of keys) {
             result[key] = Object.getOwnPropertyDescriptor(key);
         }
-        revertOnDone();
         return result;
     },
     /**
@@ -59,7 +62,7 @@ export const ReflectExtensions = new Patch(Reflect, {
      * at least one of the keys provided as arguments exists in the given object.
      */
     hasSome(object, ...keys) {
-        return Object.isObject(object) && (keys.flat(Infinity)
+        return isObject(object) && (keys.flat(Infinity)
             .map(key => Reflect.has(object, key))
             .some(has => has));
     },
@@ -102,3 +105,4 @@ export const ReflectExtensions = new Patch(Reflect, {
         return Reflect.entries.map(([, value]) => value);
     }
 });
+//# sourceMappingURL=reflectextensions.js.map

package/dist/mjs/reflectextensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflectextensions.js","sourceRoot":"","sources":["../../src/reflectextensions.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAExD,MAAM,EAAE,QAAQ,EAAE,GAAG,gBAAgB,CAAC,OAAO,CAAA;AAE7C;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE;IAClD;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,EAAE,GAAG,IAAI;QACpB,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;aACnD,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;aACpC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CACnB,CAAA;IACH,CAAC;IAED;;;;;;;;;OASG;IACH,cAAc,CAAC,MAAM;QACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAA;QAC3E,CAAC;QAED,MAAM,MAAM,GAAG,EAAE,CAAA;QAEjB,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAEpC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAA;QACpD,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI;QACrB,OAAO,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;aAC5C,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;aACpC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAClB,CAAA;IACH,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM;QACZ,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAAC,OAAO,EAAE,CAAA;QAAC,CAAC;QAExD,OAAO,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACxC,GAAG,EAAE,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC;SAClD,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,MAAM;QACX,OAAO,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAA;IACjD,CAAC;CACF,CAAC,CAAA"}

package/dist/mjs/stringextensions.js

@@ -22,3 +22,4 @@ export const StringExtensions = new Patch(String, {
         return false;
     },
 });
+//# sourceMappingURL=stringextensions.js.map

package/dist/mjs/stringextensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringextensions.js","sourceRoot":"","sources":["../../src/stringextensions.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK;QACZ,IAAI,KAAK,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,YAAY,MAAM,CAAC,EAAE,CAAC;YACpE,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;QACzB,CAAC;QACD,OAAO,KAAK,CAAA;IACd,CAAC;CACF,CAAC,CAAC"}

package/dist/mjs/symbolextensions.js

@@ -56,9 +56,11 @@ export const SymbolExtensions = new Patch(Symbol, {
      * spec static symbols (`toStringTag`, `iterator`, etc...), and any symbols
      * created by passing a value directly to the `Symbol` function, such as
      * `Symbol('name')`
-     * @returns
+     * @returns true if the `value` in question is both a `symbol` and has
+     * returns `undefined` if passed to `Symbol.keyFor`
      */
     isNonRegistered(value, allowOnlySymbols = false) {
         return !Symbol.isRegistered(value, allowOnlySymbols);
     },
 });
+//# sourceMappingURL=symbolextensions.js.map

package/dist/mjs/symbolextensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbolextensions.js","sourceRoot":"","sources":["../../src/symbolextensions.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;IAChD;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK;QACZ,OAAO,KAAK,IAAI,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,KAAK,EAAE,gBAAgB,GAAG,KAAK;QAC1C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,IAAI,gBAAgB,EAAE,CAAC;gBACrB,MAAM,IAAI,SAAS,CAAC,mDAAmD,CAAC,CAAA;YAC1E,CAAC;YACD,OAAO,KAAK,CAAA;QACd,CAAC;QAED,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS,CAAA;IAC3C,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,KAAK;QAC7C,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAA;IACtD,CAAC;CACF,CAAC,CAAC"}

package/dist/mjs/weakrefextensions.js

@@ -13,3 +13,4 @@ export const WeakRefExtensions = new Patch(WeakRef, {
             (value === null || value === undefined));
     },
 });
+//# sourceMappingURL=weakrefextensions.js.map

package/dist/mjs/weakrefextensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weakrefextensions.js","sourceRoot":"","sources":["../../src/weakrefextensions.js"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAEvC,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,KAAK,CAAC,OAAO,EAAE;IAClD;;;;;;OAMG;IACH,gBAAgB,CAAC,KAAK;QACpB,OAAO,CAAC,CACN,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC;YACjE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC;YACxD,CAAC,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC,CACxC,CAAA;IACH,CAAC;CACF,CAAC,CAAA"}

package/docs/assets/anchor.js

@@ -0,0 +1,350 @@
+/*!
+ * AnchorJS - v4.0.0 - 2017-06-02
+ * https://github.com/bryanbraun/anchorjs
+ * Copyright (c) 2017 Bryan Braun; Licensed MIT
+ */
+/* eslint-env amd, node */
+
+// https://github.com/umdjs/umd/blob/master/templates/returnExports.js
+(function (root, factory) {
+  'use strict';
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define([], factory);
+  } else if (typeof module === 'object' && module.exports) {
+    // Node. Does not work with strict CommonJS, but
+    // only CommonJS-like environments that support module.exports,
+    // like Node.
+    module.exports = factory();
+  } else {
+    // Browser globals (root is window)
+    root.AnchorJS = factory();
+    root.anchors = new root.AnchorJS();
+  }
+})(this, function () {
+  'use strict';
+  function AnchorJS(options) {
+    this.options = options || {};
+    this.elements = [];
+
+    /**
+     * Assigns options to the internal options object, and provides defaults.
+     * @param {Object} opts - Options object
+     */
+    function _applyRemainingDefaultOptions(opts) {
+      opts.icon = opts.hasOwnProperty('icon') ? opts.icon : '\ue9cb'; // Accepts characters (and also URLs?), like  '#', '¶', '❡', or '§'.
+      opts.visible = opts.hasOwnProperty('visible') ? opts.visible : 'hover'; // Also accepts 'always' & 'touch'
+      opts.placement = opts.hasOwnProperty('placement')
+        ? opts.placement
+        : 'right'; // Also accepts 'left'
+      opts.class = opts.hasOwnProperty('class') ? opts.class : ''; // Accepts any class name.
+      // Using Math.floor here will ensure the value is Number-cast and an integer.
+      opts.truncate = opts.hasOwnProperty('truncate')
+        ? Math.floor(opts.truncate)
+        : 64; // Accepts any value that can be typecast to a number.
+    }
+
+    _applyRemainingDefaultOptions(this.options);
+
+    /**
+     * Checks to see if this device supports touch. Uses criteria pulled from Modernizr:
+     * https://github.com/Modernizr/Modernizr/blob/da22eb27631fc4957f67607fe6042e85c0a84656/feature-detects/touchevents.js#L40
+     * @returns {Boolean} - true if the current device supports touch.
+     */
+    this.isTouchDevice = function () {
+      return !!(
+        'ontouchstart' in window ||
+        (window.DocumentTouch && document instanceof DocumentTouch)
+      );
+    };
+
+    /**
+     * Add anchor links to page elements.
+     * @param  {String|Array|Nodelist} selector - A CSS selector for targeting the elements you wish to add anchor links
+     *                                            to. Also accepts an array or nodeList containing the relavant elements.
+     * @returns {this}                           - The AnchorJS object
+     */
+    this.add = function (selector) {
+      var elements,
+        elsWithIds,
+        idList,
+        elementID,
+        i,
+        index,
+        count,
+        tidyText,
+        newTidyText,
+        readableID,
+        anchor,
+        visibleOptionToUse,
+        indexesToDrop = [];
+
+      // We reapply options here because somebody may have overwritten the default options object when setting options.
+      // For example, this overwrites all options but visible:
+      //
+      // anchors.options = { visible: 'always'; }
+      _applyRemainingDefaultOptions(this.options);
+
+      visibleOptionToUse = this.options.visible;
+      if (visibleOptionToUse === 'touch') {
+        visibleOptionToUse = this.isTouchDevice() ? 'always' : 'hover';
+      }
+
+      // Provide a sensible default selector, if none is given.
+      if (!selector) {
+        selector = 'h2, h3, h4, h5, h6';
+      }
+
+      elements = _getElements(selector);
+
+      if (elements.length === 0) {
+        return this;
+      }
+
+      _addBaselineStyles();
+
+      // We produce a list of existing IDs so we don't generate a duplicate.
+      elsWithIds = document.querySelectorAll('[id]');
+      idList = [].map.call(elsWithIds, function assign(el) {
+        return el.id;
+      });
+
+      for (i = 0; i < elements.length; i++) {
+        if (this.hasAnchorJSLink(elements[i])) {
+          indexesToDrop.push(i);
+          continue;
+        }
+
+        if (elements[i].hasAttribute('id')) {
+          elementID = elements[i].getAttribute('id');
+        } else if (elements[i].hasAttribute('data-anchor-id')) {
+          elementID = elements[i].getAttribute('data-anchor-id');
+        } else {
+          tidyText = this.urlify(elements[i].textContent);
+
+          // Compare our generated ID to existing IDs (and increment it if needed)
+          // before we add it to the page.
+          newTidyText = tidyText;
+          count = 0;
+          do {
+            if (index !== undefined) {
+              newTidyText = tidyText + '-' + count;
+            }
+
+            index = idList.indexOf(newTidyText);
+            count += 1;
+          } while (index !== -1);
+          index = undefined;
+          idList.push(newTidyText);
+
+          elements[i].setAttribute('id', newTidyText);
+          elementID = newTidyText;
+        }
+
+        readableID = elementID.replace(/-/g, ' ');
+
+        // The following code builds the following DOM structure in a more effiecient (albeit opaque) way.
+        // '<a class="anchorjs-link ' + this.options.class + '" href="#' + elementID + '" aria-label="Anchor link for: ' + readableID + '" data-anchorjs-icon="' + this.options.icon + '"></a>';
+        anchor = document.createElement('a');
+        anchor.className = 'anchorjs-link ' + this.options.class;
+        anchor.href = '#' + elementID;
+        anchor.setAttribute('aria-label', 'Anchor link for: ' + readableID);
+        anchor.setAttribute('data-anchorjs-icon', this.options.icon);
+
+        if (visibleOptionToUse === 'always') {
+          anchor.style.opacity = '1';
+        }
+
+        if (this.options.icon === '\ue9cb') {
+          anchor.style.font = '1em/1 anchorjs-icons';
+
+          // We set lineHeight = 1 here because the `anchorjs-icons` font family could otherwise affect the
+          // height of the heading. This isn't the case for icons with `placement: left`, so we restore
+          // line-height: inherit in that case, ensuring they remain positioned correctly. For more info,
+          // see https://github.com/bryanbraun/anchorjs/issues/39.
+          if (this.options.placement === 'left') {
+            anchor.style.lineHeight = 'inherit';
+          }
+        }
+
+        if (this.options.placement === 'left') {
+          anchor.style.position = 'absolute';
+          anchor.style.marginLeft = '-1em';
+          anchor.style.paddingRight = '0.5em';
+          elements[i].insertBefore(anchor, elements[i].firstChild);
+        } else {
+          // if the option provided is `right` (or anything else).
+          anchor.style.paddingLeft = '0.375em';
+          elements[i].appendChild(anchor);
+        }
+      }
+
+      for (i = 0; i < indexesToDrop.length; i++) {
+        elements.splice(indexesToDrop[i] - i, 1);
+      }
+      this.elements = this.elements.concat(elements);
+
+      return this;
+    };
+
+    /**
+     * Removes all anchorjs-links from elements targed by the selector.
+     * @param  {String|Array|Nodelist} selector - A CSS selector string targeting elements with anchor links,
+     *                                            OR a nodeList / array containing the DOM elements.
+     * @returns {this}                           - The AnchorJS object
+     */
+    this.remove = function (selector) {
+      var index,
+        domAnchor,
+        elements = _getElements(selector);
+
+      for (var i = 0; i < elements.length; i++) {
+        domAnchor = elements[i].querySelector('.anchorjs-link');
+        if (domAnchor) {
+          // Drop the element from our main list, if it's in there.
+          index = this.elements.indexOf(elements[i]);
+          if (index !== -1) {
+            this.elements.splice(index, 1);
+          }
+          // Remove the anchor from the DOM.
+          elements[i].removeChild(domAnchor);
+        }
+      }
+      return this;
+    };
+
+    /**
+     * Removes all anchorjs links. Mostly used for tests.
+     */
+    this.removeAll = function () {
+      this.remove(this.elements);
+    };
+
+    /**
+     * Urlify - Refine text so it makes a good ID.
+     *
+     * To do this, we remove apostrophes, replace nonsafe characters with hyphens,
+     * remove extra hyphens, truncate, trim hyphens, and make lowercase.
+     *
+     * @param  {String} text - Any text. Usually pulled from the webpage element we are linking to.
+     * @returns {String}      - hyphen-delimited text for use in IDs and URLs.
+     */
+    this.urlify = function (text) {
+      // Regex for finding the nonsafe URL characters (many need escaping): & +$,:;=?@"#{}|^~[`%!'<>]./()*\
+      var nonsafeChars = /[& +$,:;=?@"#{}|^~[`%!'<>\]\.\/\(\)\*\\]/g,
+        urlText;
+
+      // The reason we include this _applyRemainingDefaultOptions is so urlify can be called independently,
+      // even after setting options. This can be useful for tests or other applications.
+      if (!this.options.truncate) {
+        _applyRemainingDefaultOptions(this.options);
+      }
+
+      // Note: we trim hyphens after truncating because truncating can cause dangling hyphens.
+      // Example string:                                  // " ⚡⚡ Don't forget: URL fragments should be i18n-friendly, hyphenated, short, and clean."
+      urlText = text
+        .trim() // "⚡⚡ Don't forget: URL fragments should be i18n-friendly, hyphenated, short, and clean."
+        .replace(/\'/gi, '') // "⚡⚡ Dont forget: URL fragments should be i18n-friendly, hyphenated, short, and clean."
+        .replace(nonsafeChars, '-') // "⚡⚡-Dont-forget--URL-fragments-should-be-i18n-friendly--hyphenated--short--and-clean-"
+        .replace(/-{2,}/g, '-') // "⚡⚡-Dont-forget-URL-fragments-should-be-i18n-friendly-hyphenated-short-and-clean-"
+        .substring(0, this.options.truncate) // "⚡⚡-Dont-forget-URL-fragments-should-be-i18n-friendly-hyphenated-"
+        .replace(/^-+|-+$/gm, '') // "⚡⚡-Dont-forget-URL-fragments-should-be-i18n-friendly-hyphenated"
+        .toLowerCase(); // "⚡⚡-dont-forget-url-fragments-should-be-i18n-friendly-hyphenated"
+
+      return urlText;
+    };
+
+    /**
+     * Determines if this element already has an AnchorJS link on it.
+     * Uses this technique: http://stackoverflow.com/a/5898748/1154642
+     * @param    {HTMLElemnt}  el - a DOM node
+     * @returns   {Boolean}     true/false
+     */
+    this.hasAnchorJSLink = function (el) {
+      var hasLeftAnchor =
+          el.firstChild &&
+          (' ' + el.firstChild.className + ' ').indexOf(' anchorjs-link ') > -1,
+        hasRightAnchor =
+          el.lastChild &&
+          (' ' + el.lastChild.className + ' ').indexOf(' anchorjs-link ') > -1;
+
+      return hasLeftAnchor || hasRightAnchor || false;
+    };
+
+    /**
+     * Turns a selector, nodeList, or array of elements into an array of elements (so we can use array methods).
+     * It also throws errors on any other inputs. Used to handle inputs to .add and .remove.
+     * @param  {String|Array|Nodelist} input - A CSS selector string targeting elements with anchor links,
+     *                                         OR a nodeList / array containing the DOM elements.
+     * @returns {Array} - An array containing the elements we want.
+     */
+    function _getElements(input) {
+      var elements;
+      if (typeof input === 'string' || input instanceof String) {
+        // See https://davidwalsh.name/nodelist-array for the technique transforming nodeList -> Array.
+        elements = [].slice.call(document.querySelectorAll(input));
+        // I checked the 'input instanceof NodeList' test in IE9 and modern browsers and it worked for me.
+      } else if (Array.isArray(input) || input instanceof NodeList) {
+        elements = [].slice.call(input);
+      } else {
+        throw new Error('The selector provided to AnchorJS was invalid.');
+      }
+      return elements;
+    }
+
+    /**
+     * _addBaselineStyles
+     * Adds baseline styles to the page, used by all AnchorJS links irregardless of configuration.
+     */
+    function _addBaselineStyles() {
+      // We don't want to add global baseline styles if they've been added before.
+      if (document.head.querySelector('style.anchorjs') !== null) {
+        return;
+      }
+
+      var style = document.createElement('style'),
+        linkRule =
+          ' .anchorjs-link {' +
+          '   opacity: 0;' +
+          '   text-decoration: none;' +
+          '   -webkit-font-smoothing: antialiased;' +
+          '   -moz-osx-font-smoothing: grayscale;' +
+          ' }',
+        hoverRule =
+          ' *:hover > .anchorjs-link,' +
+          ' .anchorjs-link:focus  {' +
+          '   opacity: 1;' +
+          ' }',
+        anchorjsLinkFontFace =
+          ' @font-face {' +
+          '   font-family: "anchorjs-icons";' + // Icon from icomoon; 10px wide & 10px tall; 2 empty below & 4 above
+          '   src: url(data:n/a;base64,AAEAAAALAIAAAwAwT1MvMg8yG2cAAAE4AAAAYGNtYXDp3gC3AAABpAAAAExnYXNwAAAAEAAAA9wAAAAIZ2x5ZlQCcfwAAAH4AAABCGhlYWQHFvHyAAAAvAAAADZoaGVhBnACFwAAAPQAAAAkaG10eASAADEAAAGYAAAADGxvY2EACACEAAAB8AAAAAhtYXhwAAYAVwAAARgAAAAgbmFtZQGOH9cAAAMAAAAAunBvc3QAAwAAAAADvAAAACAAAQAAAAEAAHzE2p9fDzz1AAkEAAAAAADRecUWAAAAANQA6R8AAAAAAoACwAAAAAgAAgAAAAAAAAABAAADwP/AAAACgAAA/9MCrQABAAAAAAAAAAAAAAAAAAAAAwABAAAAAwBVAAIAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAMCQAGQAAUAAAKZAswAAACPApkCzAAAAesAMwEJAAAAAAAAAAAAAAAAAAAAARAAAAAAAAAAAAAAAAAAAAAAQAAg//0DwP/AAEADwABAAAAAAQAAAAAAAAAAAAAAIAAAAAAAAAIAAAACgAAxAAAAAwAAAAMAAAAcAAEAAwAAABwAAwABAAAAHAAEADAAAAAIAAgAAgAAACDpy//9//8AAAAg6cv//f///+EWNwADAAEAAAAAAAAAAAAAAAAACACEAAEAAAAAAAAAAAAAAAAxAAACAAQARAKAAsAAKwBUAAABIiYnJjQ3NzY2MzIWFxYUBwcGIicmNDc3NjQnJiYjIgYHBwYUFxYUBwYGIwciJicmNDc3NjIXFhQHBwYUFxYWMzI2Nzc2NCcmNDc2MhcWFAcHBgYjARQGDAUtLXoWOR8fORYtLTgKGwoKCjgaGg0gEhIgDXoaGgkJBQwHdR85Fi0tOAobCgoKOBoaDSASEiANehoaCQkKGwotLXoWOR8BMwUFLYEuehYXFxYugC44CQkKGwo4GkoaDQ0NDXoaShoKGwoFBe8XFi6ALjgJCQobCjgaShoNDQ0NehpKGgobCgoKLYEuehYXAAAADACWAAEAAAAAAAEACAAAAAEAAAAAAAIAAwAIAAEAAAAAAAMACAAAAAEAAAAAAAQACAAAAAEAAAAAAAUAAQALAAEAAAAAAAYACAAAAAMAAQQJAAEAEAAMAAMAAQQJAAIABgAcAAMAAQQJAAMAEAAMAAMAAQQJAAQAEAAMAAMAAQQJAAUAAgAiAAMAAQQJAAYAEAAMYW5jaG9yanM0MDBAAGEAbgBjAGgAbwByAGoAcwA0ADAAMABAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAH//wAP) format("truetype");' +
+          ' }',
+        pseudoElContent =
+          ' [data-anchorjs-icon]::after {' +
+          '   content: attr(data-anchorjs-icon);' +
+          ' }',
+        firstStyleEl;
+
+      style.className = 'anchorjs';
+      style.appendChild(document.createTextNode('')); // Necessary for Webkit.
+
+      // We place it in the head with the other style tags, if possible, so as to
+      // not look out of place. We insert before the others so these styles can be
+      // overridden if necessary.
+      firstStyleEl = document.head.querySelector('[rel="stylesheet"], style');
+      if (firstStyleEl === undefined) {
+        document.head.appendChild(style);
+      } else {
+        document.head.insertBefore(style, firstStyleEl);
+      }
+
+      style.sheet.insertRule(linkRule, style.sheet.cssRules.length);
+      style.sheet.insertRule(hoverRule, style.sheet.cssRules.length);
+      style.sheet.insertRule(pseudoElContent, style.sheet.cssRules.length);
+      style.sheet.insertRule(anchorjsLinkFontFace, style.sheet.cssRules.length);
+    }
+  }
+
+  return AnchorJS;
+});