tspo 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# tspo ✈️
+# 🟦 tspo
 
 [![npm](https://img.shields.io/npm/v/tspo?label=npm&color=0ea5e9)](https://www.npmjs.com/package/tspo)
 [![downloads](https://img.shields.io/npm/dm/tspo?label=downloads&color=38bdf8)](https://www.npmjs.com/package/tspo)
@@ -6,4 +6,10 @@
 [![bundle size](https://img.shields.io/bundlephobia/minzip/tspo?label=bundle&color=0f172a)](https://bundlephobia.com/package/tspo)
 [![license](https://img.shields.io/npm/l/tspo?label=license&color=334155)](LICENSE)
 
+> `tspo (TypeScript Plain Object)` is a collection of utilities for handling both runtime and compile-time behavior for plain-objects.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/seanpmaxwell/tspo/master/screenshot.png" alt="tspo screenshot" />
+</p>
+
 Please refer to the official <a href="https://github.com/seanpmaxwell/tspo">github repo</a> for the most up-to-date documentation.

package/dist/cjs/tspo.js

@@ -2,20 +2,43 @@ import isPlainObject, {} from './isPlainObject.js';
 import compare from './utils/compare.js';
 import copy from './utils/copy.js';
 import iterate from './utils/iterate.js';
+const hop = Object.prototype.hasOwnProperty;
 function omit(obj, keys) {
-    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    const retVal = {};
+    const dict = obj;
+    if (Array.isArray(keys)) {
+        const set = new Set(keys);
+        for (const key in obj) {
+            if (!set.has(key)) {
+                retVal[key] = dict[key];
+            }
+        }
+        return retVal;
+    }
+    const omittedKey = keys;
     for (const key in obj) {
-        if (!set.has(key)) {
-            retVal[key] = obj[key];
+        if (key !== omittedKey) {
+            retVal[key] = dict[key];
         }
     }
     return retVal;
 }
 function pick(obj, keys) {
-    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    const retVal = {};
+    const dict = obj;
+    if (Array.isArray(keys)) {
+        const set = new Set(keys);
+        for (const key in obj) {
+            if (set.has(key)) {
+                retVal[key] = dict[key];
+            }
+        }
+        return retVal;
+    }
+    const pickedKey = keys;
     for (const key in obj) {
-        if (set.has(key)) {
-            retVal[key] = obj[key];
+        if (key === pickedKey) {
+            retVal[key] = dict[key];
         }
     }
     return retVal;
@@ -61,17 +84,23 @@ function reverseIndex(obj, value) {
     return retVal;
 }
 function safeReverseIndex(obj, value) {
-    const retVal = [];
+    let found = false;
+    let retVal;
     for (const key in obj) {
         if (obj[key] === value) {
-            retVal.push(key);
+            if (found) {
+                throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
+                    String(value));
+            }
+            found = true;
+            retVal = key;
         }
     }
-    if (retVal.length !== 1) {
+    if (!found) {
         throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
             String(value));
     }
-    return retVal[0];
+    return retVal;
 }
 function isKey(obj, arg) {
     const keyArr = Array.isArray(arg) ? arg : [arg];
@@ -82,9 +111,23 @@ function isKey(obj, arg) {
     return true;
 }
 function isValue(obj, arg) {
-    const valArr = Array.isArray(arg) ? arg : [arg], valSet = new Set(Object.values(obj));
-    for (const val of valArr) {
-        if (!valSet.has(val))
+    const dict = obj;
+    if (!Array.isArray(arg)) {
+        for (const key in obj) {
+            if (hop.call(obj, key) && sameValueZero(dict[key], arg))
+                return true;
+        }
+        return false;
+    }
+    for (const val of arg) {
+        let found = false;
+        for (const key in obj) {
+            if (hop.call(obj, key) && sameValueZero(dict[key], val)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found)
             return false;
     }
     return true;
@@ -99,7 +142,16 @@ function entries(obj) {
     return Object.entries(obj);
 }
 function firstEntry(obj) {
-    return Object.entries(obj)[0];
+    const dict = obj;
+    for (const key in obj) {
+        if (hop.call(obj, key)) {
+            return [key, dict[key]];
+        }
+    }
+    return undefined;
+}
+function sameValueZero(a, b) {
+    return a === b || (a !== a && b !== b);
 }
 function toDict(obj) {
     if (!isPlainObject(obj)) {

package/dist/cjs/utils/compare.js

@@ -7,16 +7,22 @@ function compare(a, b) {
     return comparePlainObjects(a, b);
 }
 function comparePlainObjects(a, b) {
-    const aKeys = Object.keys(a), bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    for (const key of aKeys) {
+    let aSize = 0;
+    for (const key in a) {
+        if (!hop.call(a, key))
+            continue;
+        aSize++;
         if (!hop.call(b, key))
             return false;
         if (!compareValue(a[key], b[key]))
             return false;
     }
-    return true;
+    let bSize = 0;
+    for (const key in b) {
+        if (hop.call(b, key))
+            bSize++;
+    }
+    return aSize === bSize;
 }
 function compareValue(a, b) {
     if (Object.is(a, b))

package/dist/cjs/utils/copy.js

@@ -1,28 +1,28 @@
 import isPlainObject, {} from '../isPlainObject.js';
-import {} from '../utility-types.js';
 const hop = Object.prototype.hasOwnProperty;
 function copy(value, options) {
     if (!isPlainObject(value)) {
         throw new TypeError('copy only accepts a plain-object as the root value');
     }
     const resetDates = options?.resetDates === true;
-    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+    const deepCloneAll = options?.deepCloneAll === true;
+    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates, deepCloneAll);
 }
-function clonePlainObject(source, proto, resetDates) {
+function clonePlainObject(source, proto, resetDates, deepCloneAll) {
     const out = proto === null ? Object.create(null) : {};
     for (const key in source) {
         if (!hop.call(source, key))
             continue;
-        out[key] = cloneValue(source[key], resetDates);
+        out[key] = cloneValue(source[key], resetDates, deepCloneAll);
     }
     return out;
 }
-function cloneValue(value, resetDates) {
+function cloneValue(value, resetDates, deepCloneAll) {
     if (isPlainObject(value)) {
-        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates, deepCloneAll);
     }
     if (Array.isArray(value)) {
-        return cloneArray(value, resetDates);
+        return cloneArray(value, resetDates, deepCloneAll);
     }
     if (value instanceof Date) {
         if (resetDates) {
@@ -31,15 +31,18 @@ function cloneValue(value, resetDates) {
         return new Date(value.getTime());
     }
     if (typeof value === 'object' && value !== null) {
+        if (deepCloneAll) {
+            return cloneNonPlainDeep(value, resetDates);
+        }
         return cloneNonPlainShallow(value);
     }
     return value;
 }
-function cloneArray(source, resetDates) {
+function cloneArray(source, resetDates, deepCloneAll) {
     const len = source.length;
     const out = new Array(len);
     for (let i = 0; i < len; i++) {
-        out[i] = cloneValue(source[i], resetDates);
+        out[i] = cloneValue(source[i], resetDates, deepCloneAll);
     }
     return out;
 }
@@ -72,4 +75,44 @@ function cloneNonPlainShallow(value) {
     }
     return out;
 }
+function cloneNonPlainDeep(value, resetDates) {
+    if (value instanceof RegExp) {
+        const re = new RegExp(value.source, value.flags);
+        re.lastIndex = value.lastIndex;
+        return re;
+    }
+    if (value instanceof Map) {
+        const out = new Map();
+        for (const [key, val] of value) {
+            out.set(cloneValue(key, resetDates, true), cloneValue(val, resetDates, true));
+        }
+        return out;
+    }
+    if (value instanceof Set) {
+        const out = new Set();
+        for (const entry of value) {
+            out.add(cloneValue(entry, resetDates, true));
+        }
+        return out;
+    }
+    if (ArrayBuffer.isView(value)) {
+        const anyVal = value;
+        if (typeof anyVal.slice === 'function')
+            return anyVal.slice();
+        if (value instanceof DataView) {
+            return new DataView(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+        }
+        return new anyVal.constructor(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    const proto = Object.getPrototypeOf(value);
+    const out = Object.create(proto);
+    for (const key in value) {
+        if (!hop.call(value, key))
+            continue;
+        out[key] = cloneValue(value[key], resetDates, true);
+    }
+    return out;
+}
 export default copy;

package/dist/cjs/utils/iterate.js

@@ -1,4 +1,5 @@
 import isPlainObject, {} from '../isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
 function iterate(root, cb) {
     if (!isPlainObject(root))
         return;
@@ -6,25 +7,31 @@ function iterate(root, cb) {
 }
 function iterateHelper(node, path, cb) {
     if (Array.isArray(node)) {
-        let i = 0;
-        for (const [key, value] of node.entries()) {
+        for (let i = 0; i < node.length; i++) {
+            const value = node[i];
+            cb({ parent: node, key: i, value, path: copyPath(path) });
             if (isPlainObject(value) || Array.isArray(value)) {
-                iterateHelper(value, [...path, key, i], cb);
+                path.push(i);
+                iterateHelper(value, path, cb);
+                path.pop();
             }
-            else {
-                cb({ parent: node, key, value, path });
-            }
-            i++;
         }
         return;
     }
-    for (const [key, value] of Object.entries(node)) {
+    const dict = node;
+    for (const key in dict) {
+        if (!hop.call(dict, key))
+            continue;
+        const value = dict[key];
+        cb({ parent: dict, key, value, path: copyPath(path) });
         if (isPlainObject(value) || Array.isArray(value)) {
-            iterateHelper(value, [...path, key], cb);
-        }
-        else {
-            cb({ parent: node, key, value, path });
+            path.push(key);
+            iterateHelper(value, path, cb);
+            path.pop();
         }
     }
 }
+function copyPath(path) {
+    return path.slice();
+}
 export default iterate;

package/dist/esm/tspo.js

@@ -2,20 +2,43 @@ import isPlainObject, {} from './isPlainObject.js';
 import compare from './utils/compare.js';
 import copy from './utils/copy.js';
 import iterate from './utils/iterate.js';
+const hop = Object.prototype.hasOwnProperty;
 function omit(obj, keys) {
-    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    const retVal = {};
+    const dict = obj;
+    if (Array.isArray(keys)) {
+        const set = new Set(keys);
+        for (const key in obj) {
+            if (!set.has(key)) {
+                retVal[key] = dict[key];
+            }
+        }
+        return retVal;
+    }
+    const omittedKey = keys;
     for (const key in obj) {
-        if (!set.has(key)) {
-            retVal[key] = obj[key];
+        if (key !== omittedKey) {
+            retVal[key] = dict[key];
         }
     }
     return retVal;
 }
 function pick(obj, keys) {
-    const retVal = {}, set = new Set(Array.isArray(keys) ? keys : [keys]);
+    const retVal = {};
+    const dict = obj;
+    if (Array.isArray(keys)) {
+        const set = new Set(keys);
+        for (const key in obj) {
+            if (set.has(key)) {
+                retVal[key] = dict[key];
+            }
+        }
+        return retVal;
+    }
+    const pickedKey = keys;
     for (const key in obj) {
-        if (set.has(key)) {
-            retVal[key] = obj[key];
+        if (key === pickedKey) {
+            retVal[key] = dict[key];
         }
     }
     return retVal;
@@ -61,17 +84,23 @@ function reverseIndex(obj, value) {
     return retVal;
 }
 function safeReverseIndex(obj, value) {
-    const retVal = [];
+    let found = false;
+    let retVal;
     for (const key in obj) {
         if (obj[key] === value) {
-            retVal.push(key);
+            if (found) {
+                throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
+                    String(value));
+            }
+            found = true;
+            retVal = key;
         }
     }
-    if (retVal.length !== 1) {
+    if (!found) {
         throw new Error('.safeReverseIndex found 0 or more than 1 keys for value: ' +
             String(value));
     }
-    return retVal[0];
+    return retVal;
 }
 function isKey(obj, arg) {
     const keyArr = Array.isArray(arg) ? arg : [arg];
@@ -82,9 +111,23 @@ function isKey(obj, arg) {
     return true;
 }
 function isValue(obj, arg) {
-    const valArr = Array.isArray(arg) ? arg : [arg], valSet = new Set(Object.values(obj));
-    for (const val of valArr) {
-        if (!valSet.has(val))
+    const dict = obj;
+    if (!Array.isArray(arg)) {
+        for (const key in obj) {
+            if (hop.call(obj, key) && sameValueZero(dict[key], arg))
+                return true;
+        }
+        return false;
+    }
+    for (const val of arg) {
+        let found = false;
+        for (const key in obj) {
+            if (hop.call(obj, key) && sameValueZero(dict[key], val)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found)
             return false;
     }
     return true;
@@ -99,7 +142,16 @@ function entries(obj) {
     return Object.entries(obj);
 }
 function firstEntry(obj) {
-    return Object.entries(obj)[0];
+    const dict = obj;
+    for (const key in obj) {
+        if (hop.call(obj, key)) {
+            return [key, dict[key]];
+        }
+    }
+    return undefined;
+}
+function sameValueZero(a, b) {
+    return a === b || (a !== a && b !== b);
 }
 function toDict(obj) {
     if (!isPlainObject(obj)) {

package/dist/esm/utils/compare.js

@@ -7,16 +7,22 @@ function compare(a, b) {
     return comparePlainObjects(a, b);
 }
 function comparePlainObjects(a, b) {
-    const aKeys = Object.keys(a), bKeys = Object.keys(b);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    for (const key of aKeys) {
+    let aSize = 0;
+    for (const key in a) {
+        if (!hop.call(a, key))
+            continue;
+        aSize++;
         if (!hop.call(b, key))
             return false;
         if (!compareValue(a[key], b[key]))
             return false;
     }
-    return true;
+    let bSize = 0;
+    for (const key in b) {
+        if (hop.call(b, key))
+            bSize++;
+    }
+    return aSize === bSize;
 }
 function compareValue(a, b) {
     if (Object.is(a, b))

package/dist/esm/utils/copy.js

@@ -1,28 +1,28 @@
 import isPlainObject, {} from '../isPlainObject.js';
-import {} from '../utility-types.js';
 const hop = Object.prototype.hasOwnProperty;
 function copy(value, options) {
     if (!isPlainObject(value)) {
         throw new TypeError('copy only accepts a plain-object as the root value');
     }
     const resetDates = options?.resetDates === true;
-    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+    const deepCloneAll = options?.deepCloneAll === true;
+    return clonePlainObject(value, Object.getPrototypeOf(value), resetDates, deepCloneAll);
 }
-function clonePlainObject(source, proto, resetDates) {
+function clonePlainObject(source, proto, resetDates, deepCloneAll) {
     const out = proto === null ? Object.create(null) : {};
     for (const key in source) {
         if (!hop.call(source, key))
             continue;
-        out[key] = cloneValue(source[key], resetDates);
+        out[key] = cloneValue(source[key], resetDates, deepCloneAll);
     }
     return out;
 }
-function cloneValue(value, resetDates) {
+function cloneValue(value, resetDates, deepCloneAll) {
     if (isPlainObject(value)) {
-        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates);
+        return clonePlainObject(value, Object.getPrototypeOf(value), resetDates, deepCloneAll);
     }
     if (Array.isArray(value)) {
-        return cloneArray(value, resetDates);
+        return cloneArray(value, resetDates, deepCloneAll);
     }
     if (value instanceof Date) {
         if (resetDates) {
@@ -31,15 +31,18 @@ function cloneValue(value, resetDates) {
         return new Date(value.getTime());
     }
     if (typeof value === 'object' && value !== null) {
+        if (deepCloneAll) {
+            return cloneNonPlainDeep(value, resetDates);
+        }
         return cloneNonPlainShallow(value);
     }
     return value;
 }
-function cloneArray(source, resetDates) {
+function cloneArray(source, resetDates, deepCloneAll) {
     const len = source.length;
     const out = new Array(len);
     for (let i = 0; i < len; i++) {
-        out[i] = cloneValue(source[i], resetDates);
+        out[i] = cloneValue(source[i], resetDates, deepCloneAll);
     }
     return out;
 }
@@ -72,4 +75,44 @@ function cloneNonPlainShallow(value) {
     }
     return out;
 }
+function cloneNonPlainDeep(value, resetDates) {
+    if (value instanceof RegExp) {
+        const re = new RegExp(value.source, value.flags);
+        re.lastIndex = value.lastIndex;
+        return re;
+    }
+    if (value instanceof Map) {
+        const out = new Map();
+        for (const [key, val] of value) {
+            out.set(cloneValue(key, resetDates, true), cloneValue(val, resetDates, true));
+        }
+        return out;
+    }
+    if (value instanceof Set) {
+        const out = new Set();
+        for (const entry of value) {
+            out.add(cloneValue(entry, resetDates, true));
+        }
+        return out;
+    }
+    if (ArrayBuffer.isView(value)) {
+        const anyVal = value;
+        if (typeof anyVal.slice === 'function')
+            return anyVal.slice();
+        if (value instanceof DataView) {
+            return new DataView(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+        }
+        return new anyVal.constructor(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    const proto = Object.getPrototypeOf(value);
+    const out = Object.create(proto);
+    for (const key in value) {
+        if (!hop.call(value, key))
+            continue;
+        out[key] = cloneValue(value[key], resetDates, true);
+    }
+    return out;
+}
 export default copy;

package/dist/esm/utils/iterate.js

@@ -1,4 +1,5 @@
 import isPlainObject, {} from '../isPlainObject.js';
+const hop = Object.prototype.hasOwnProperty;
 function iterate(root, cb) {
     if (!isPlainObject(root))
         return;
@@ -6,25 +7,31 @@ function iterate(root, cb) {
 }
 function iterateHelper(node, path, cb) {
     if (Array.isArray(node)) {
-        let i = 0;
-        for (const [key, value] of node.entries()) {
+        for (let i = 0; i < node.length; i++) {
+            const value = node[i];
+            cb({ parent: node, key: i, value, path: copyPath(path) });
             if (isPlainObject(value) || Array.isArray(value)) {
-                iterateHelper(value, [...path, key, i], cb);
+                path.push(i);
+                iterateHelper(value, path, cb);
+                path.pop();
             }
-            else {
-                cb({ parent: node, key, value, path });
-            }
-            i++;
         }
         return;
     }
-    for (const [key, value] of Object.entries(node)) {
+    const dict = node;
+    for (const key in dict) {
+        if (!hop.call(dict, key))
+            continue;
+        const value = dict[key];
+        cb({ parent: dict, key, value, path: copyPath(path) });
         if (isPlainObject(value) || Array.isArray(value)) {
-            iterateHelper(value, [...path, key], cb);
-        }
-        else {
-            cb({ parent: node, key, value, path });
+            path.push(key);
+            iterateHelper(value, path, cb);
+            path.pop();
         }
     }
 }
+function copyPath(path) {
+    return path.slice();
+}
 export default iterate;

package/dist/types/tspo.d.ts

@@ -1,5 +1,5 @@
 import isPlainObject, { type Dict, type PlainObject } from './isPlainObject.js';
-import type { DeepWiden, EntriesTuple, KeysParam, KeyTuple, KeyUnion, Mutable, OmitKeys, PickKeys, SetToNever, ValueTuple } from './utility-types.js';
+import type { DeepWiden, EntriesTuple, Entry, KeysParam, KeyTuple, KeyUnion, OmitKeys, PickKeys, SetToNever, ValueTuple } from './utility-types.js';
 import compare from './utils/compare.js';
 import copy from './utils/copy.js';
 import iterate from './utils/iterate.js';
@@ -23,12 +23,12 @@ declare function pick<T extends PlainObject, K extends KeysParam<T>>(obj: T, key
 /**
  * Merge two object together and return a new type.
  */
-declare function merge<T extends PlainObject, U extends PlainObject>(a: T, b: U): CollapseType<Mutable<Omit<T, keyof U> & U>>;
+declare function merge<T extends PlainObject, U extends PlainObject>(a: T, b: U): CollapseType<Omit<T, keyof U> & U>;
 /**
  * Fill the missing entries in a partial, will the values from a 'defaults'
  * object.
  */
-declare function fill<const T extends object>(defaults: T, partial?: Partial<DeepWiden<T>>): CollapseType<Mutable<DeepWiden<T>>>;
+declare function fill<const T extends object>(defaults: T, partial?: Partial<DeepWiden<T>>): CollapseType<DeepWiden<T>>;
 /**
  * Append one object to another, modifying the reference to the original
  * object.
@@ -81,7 +81,7 @@ declare function entries<T extends object>(obj: T): EntriesTuple<T>;
 /**
  * Get a type-safe array of the object e
  */
-declare function firstEntry<T extends object, K extends keyof T>(obj: T): [K, T[K]];
+declare function firstEntry<T extends object>(obj: T): Entry<T>;
 /**
  * Check if something is a plain
  */

package/dist/types/utility-types.d.ts

@@ -2,9 +2,9 @@ export type KeysParam<T extends object> = keyof T | (keyof T)[];
 export type KeyUnion<T extends object, K extends KeysParam<T>> = K extends (keyof T)[] ? K[number] : K;
 export type OmitKeys<T extends object, K extends KeysParam<T>> = Omit<T, KeyUnion<T, K>>;
 export type PickKeys<T extends object, K extends KeysParam<T>> = Pick<T, KeyUnion<T, K>>;
-export type Mutable<T> = {
-    -readonly [K in keyof T]: T[K];
-};
+export type Entry<T extends object> = T extends object ? {
+    [K in keyof T]-?: [K, T[K]];
+}[keyof T] : never;
 export type SetToNever<T, K extends PropertyKey> = T & {
     [P in K]: never;
 };

package/dist/types/utils/copy.d.ts

@@ -1,7 +1,10 @@
 import { type PlainObject } from '../isPlainObject.js';
-import { type Mutable } from '../utility-types.js';
 type CopyOptions = {
     resetDates?: boolean;
+    deepCloneAll?: boolean;
+};
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K];
 };
 /**
  * Deep clones ONLY plain-objects (incl. null-prototype).
@@ -10,7 +13,8 @@ type CopyOptions = {
  * - Recursion descends only into plain-objects and arrays.
  * - Nested Date values are copied by epoch.
  * - `resetDates` resets all nested Date values to current time.
- * - Other nested non-plain objects are shallow-cloned.
+ * - Other nested non-plain objects are shallow-cloned by default.
+ * - `deepCloneAll` deep-clones all nested object values.
  */
 declare function copy<T extends PlainObject>(value: T, options?: CopyOptions): Mutable<T>;
 export default copy;

package/dist/types/utils/iterate.d.ts

@@ -16,10 +16,10 @@ type IterateCb = (args: {
 ******************************************************************************/
 /**
  * Recursively walks plain-objects and arrays, and calls a callback for
- * every key whose value is neither a plain-object nor an array.
+ * every key before descending into nested values.
  *
  * - Descends into a value if it is a plain-object or array.
- * - Fires callback for every non-descended value.
+ * - Fires callback for every entry (including plain-objects/arrays).
  */
 declare function iterate(root: unknown, cb: IterateCb): void;
 /******************************************************************************

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tspo",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A collection of utilities for handling both runtime and compile-time behavior for plain-objects.",
   "keywords": [
     "typescript",