utilitish 0.0.18 → 0.0.20

package/dist/array/array-constructor.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("../utils/core.utils");
-const core_utils_2 = require("./../utils/core.utils");
+import { defineStaticIfNotExists } from '../utils/core.utils';
+import { utilitishError } from './../utils/core.utils';
 /**
  * @see Array.zip
  */
-(0, core_utils_1.defineStaticIfNotExists)(Array, 'zip', function (...arrays) {
+defineStaticIfNotExists(Array, 'zip', function (...arrays) {
     if (arrays.length === 0)
         return [];
     const maxLen = Math.max(...arrays.map((arr) => arr.length));
@@ -14,13 +12,13 @@ const core_utils_2 = require("./../utils/core.utils");
 /**
  * @see Array.range
  */
-(0, core_utils_1.defineStaticIfNotExists)(Array, 'range', function (start, end, step = 1) {
+defineStaticIfNotExists(Array, 'range', function (start, end, step = 1) {
     if (end === undefined) {
         end = start;
         start = 0;
     }
     if (step === 0)
-        (0, core_utils_2.utilitishError)('Array.range', 'step must not be 0', undefined, RangeError);
+        utilitishError('Array.range', 'step must not be 0', undefined, RangeError);
     const result = [];
     const condition = step > 0 ? (i) => i < end : (i) => i > end;
     for (let i = start; condition(i); i += step) {
@@ -31,19 +29,19 @@ const core_utils_2 = require("./../utils/core.utils");
 /**
  * @see Array.repeat
  */
-(0, core_utils_1.defineStaticIfNotExists)(Array, 'repeat', function (length, value) {
+defineStaticIfNotExists(Array, 'repeat', function (length, value) {
     if (typeof length !== 'number')
-        (0, core_utils_2.utilitishError)('Array.repeat', 'n must be a number', length);
+        utilitishError('Array.repeat', 'n must be a number', length);
     if (!Number.isInteger(length))
-        (0, core_utils_2.utilitishError)('Array.repeat', 'n must be an integer', length);
+        utilitishError('Array.repeat', 'n must be an integer', length);
     if (length < 0)
-        (0, core_utils_2.utilitishError)('Array.repeat', 'n must be non-negative', length, RangeError);
+        utilitishError('Array.repeat', 'n must be non-negative', length, RangeError);
     return Array.from({ length }, () => (typeof value === 'function' ? value() : value));
 });
 /**
  * @see Array.create
  */
-(0, core_utils_1.defineStaticIfNotExists)(Array, 'create', function (valueOrFactory, ...sizes) {
+defineStaticIfNotExists(Array, 'create', function (valueOrFactory, ...sizes) {
     if (sizes.length === 0)
         return [];
     if (!sizes.every((s) => Number.isInteger(s) && s >= 0)) {

package/dist/array/array-constructor.spec.js

@@ -1,7 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../array/array-constructor");
-require("./array-constructor");
+import '../array/array-constructor';
+import './array-constructor';
 describe('Array', () => {
     describe('range()', () => {
         it('should generate a range from 0 to n-1 if only start is given', () => {

package/dist/array/array-prototype.js

@@ -1,47 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("../utils/core.utils");
-const logic_utils_1 = require("../utils/logic.utils");
+import { defineIfNotExists, isNumberOrString, resolveSelector, utilitishError } from '../utils/core.utils';
+import { sortBy } from '../utils/logic.utils';
 /**
  * @see Array.prototype.first
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'first', function () {
+defineIfNotExists(Array.prototype, 'first', function () {
     return this[0];
 });
 /**
  * @see Array.prototype.last
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'last', function () {
+defineIfNotExists(Array.prototype, 'last', function () {
     return this[this.length - 1];
 });
 /**
  * @see Array.prototype.sum
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'sum', function (selector) {
+defineIfNotExists(Array.prototype, 'sum', function (selector) {
     if (this.length === 0)
         return 0;
-    const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+    const getValue = resolveSelector(selector, (item) => item);
     if (!this.every((item) => typeof getValue(item) === 'number')) {
-        (0, core_utils_1.utilitishError)('Array.prototype.sum', 'requires a selector that returns a number unless array is number[]');
+        utilitishError('Array.prototype.sum', 'requires a selector that returns a number unless array is number[]');
     }
     return this.reduce((acc, item) => getValue(item) + acc, 0);
 });
 /**
  * @see Array.prototype.unique
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'unique', function () {
+defineIfNotExists(Array.prototype, 'unique', function () {
     return [...new Set(this)];
 });
 /**
  * @see Array.prototype.chunk
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'chunk', function (size) {
+defineIfNotExists(Array.prototype, 'chunk', function (size) {
     if (typeof size !== 'number')
-        (0, core_utils_1.utilitishError)('Array.prototype.chunk', 'size must be a number', size);
+        utilitishError('Array.prototype.chunk', 'size must be a number', size);
     if (!Number.isInteger(size))
-        (0, core_utils_1.utilitishError)('Array.prototype.chunk', 'size must be an integer', size);
+        utilitishError('Array.prototype.chunk', 'size must be an integer', size);
     if (size <= 0)
-        (0, core_utils_1.utilitishError)('Array.prototype.chunk', 'size must be positive', size, RangeError);
+        utilitishError('Array.prototype.chunk', 'size must be positive', size, RangeError);
     const result = [];
     for (let i = 0; i < this.length; i += size) {
         result.push(this.slice(i, i + size));
@@ -51,20 +49,20 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.average
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'average', function (selector) {
+defineIfNotExists(Array.prototype, 'average', function (selector) {
     if (this.length === 0)
         return 0;
-    const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+    const getValue = resolveSelector(selector, (item) => item);
     if (!this.every((item) => typeof getValue(item) === 'number')) {
-        (0, core_utils_1.utilitishError)('Array.prototype.average', 'requires a selector that returns a number unless array is number[]');
+        utilitishError('Array.prototype.average', 'requires a selector that returns a number unless array is number[]');
     }
     return this.reduce((acc, item) => getValue(item) + acc, 0) / this.length;
 });
 /**
  * @see Array.prototype.groupBy
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'groupBy', function (selector) {
-    const getKey = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+defineIfNotExists(Array.prototype, 'groupBy', function (selector) {
+    const getKey = resolveSelector(selector, (item) => item);
     const map = new Map();
     for (const item of this) {
         const key = getKey(item);
@@ -78,31 +76,31 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.compact
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'compact', function () {
+defineIfNotExists(Array.prototype, 'compact', function () {
     return this.filter(Boolean);
 });
 /**
  * @see Array.prototype.enumerate
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'enumerate', function () {
+defineIfNotExists(Array.prototype, 'enumerate', function () {
     return this.map((value, index) => [value, index]);
 });
 /**
  * @see Array.prototype.sortAsc
  * @see Array.prototype.sortDesc
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'sortBy', function (direction, selector) {
+defineIfNotExists(Array.prototype, 'sortBy', function (direction, selector) {
     if (this.length === 0)
         return this.slice();
-    const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
-    if (!selector && !this.every((item) => (0, core_utils_1.isNumberOrString)(item))) {
-        (0, core_utils_1.utilitishError)('Array.prototype.sortBy', 'array elements must be number or string if no selector is provided');
+    const getValue = resolveSelector(selector, (item) => item);
+    if (!selector && !this.every((item) => isNumberOrString(item))) {
+        utilitishError('Array.prototype.sortBy', 'array elements must be number or string if no selector is provided');
     }
     return this.slice().sort((a, b) => {
         const valA = getValue(a);
         const valB = getValue(b);
-        if (!(0, core_utils_1.isNumberOrString)(valA) || !(0, core_utils_1.isNumberOrString)(valB)) {
-            (0, core_utils_1.utilitishError)('Array.prototype.sortBy', 'selector must return number or string');
+        if (!isNumberOrString(valA) || !isNumberOrString(valB)) {
+            utilitishError('Array.prototype.sortBy', 'selector must return number or string');
         }
         if (valA > valB)
             return direction === 'asc' ? 1 : -1;
@@ -114,31 +112,31 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.sortAsc
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'sortAsc', function (selector) {
-    return (0, logic_utils_1.sortBy)(this, 'asc', selector);
+defineIfNotExists(Array.prototype, 'sortAsc', function (selector) {
+    return sortBy(this, 'asc', selector);
 });
 /**
  * @see Array.prototype.sortDesc
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'sortDesc', function (selector) {
-    return (0, logic_utils_1.sortBy)(this, 'desc', selector);
+defineIfNotExists(Array.prototype, 'sortDesc', function (selector) {
+    return sortBy(this, 'desc', selector);
 });
 /**
  * @see Array.prototype.swap
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'swap', function (i, j) {
+defineIfNotExists(Array.prototype, 'swap', function (i, j) {
     if (typeof i !== 'number')
-        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'i must be a number', i);
+        utilitishError('Array.prototype.swap', 'i must be a number', i);
     if (typeof j !== 'number')
-        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'j must be a number', j);
+        utilitishError('Array.prototype.swap', 'j must be a number', j);
     if (!Number.isInteger(i))
-        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'i must be an integer', i);
+        utilitishError('Array.prototype.swap', 'i must be an integer', i);
     if (!Number.isInteger(j))
-        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'j must be an integer', j);
+        utilitishError('Array.prototype.swap', 'j must be an integer', j);
     if (i < 0 || i >= this.length)
-        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'i is out of bounds', i, RangeError);
+        utilitishError('Array.prototype.swap', 'i is out of bounds', i, RangeError);
     if (j < 0 || j >= this.length)
-        (0, core_utils_1.utilitishError)('Array.prototype.swap', 'j is out of bounds', j, RangeError);
+        utilitishError('Array.prototype.swap', 'j is out of bounds', j, RangeError);
     if (i !== j) {
         const temp = this[i];
         this[i] = this[j];
@@ -149,7 +147,7 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.shuffle
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'shuffle', function () {
+defineIfNotExists(Array.prototype, 'shuffle', function () {
     const arr = this.slice();
     for (let i = arr.length - 1; i > 0; i--) {
         const j = Math.floor(Math.random() * (i + 1));
@@ -160,13 +158,13 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.toMap
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'toMap', function (keySelector, valueSelector) {
+defineIfNotExists(Array.prototype, 'toMap', function (keySelector, valueSelector) {
     if (!keySelector && this.length && this.every((item) => Array.isArray(item) && item.length === 2)) {
         return new Map(this);
     }
     const map = new Map();
-    const getKey = (0, core_utils_1.resolveSelector)(keySelector, (_, index) => index);
-    const getValue = (0, core_utils_1.resolveSelector)(valueSelector, (item) => item);
+    const getKey = resolveSelector(keySelector, (_, index) => index);
+    const getValue = resolveSelector(valueSelector, (item) => item);
     for (let i = 0; i < this.length; i++) {
         const item = this[i];
         const key = getKey(item, i);
@@ -178,14 +176,14 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.toObject
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'toObject', function (keySelector, valueSelector) {
+defineIfNotExists(Array.prototype, 'toObject', function (keySelector, valueSelector) {
     let entries;
     if (!keySelector && this.length && this.every((item) => Array.isArray(item) && item.length === 2)) {
         entries = this;
     }
     else {
-        const getKey = (0, core_utils_1.resolveSelector)(keySelector, (_, index) => index);
-        const getValue = (0, core_utils_1.resolveSelector)(valueSelector, (item) => item);
+        const getKey = resolveSelector(keySelector, (_, index) => index);
+        const getValue = resolveSelector(valueSelector, (item) => item);
         entries = this.map((item, index) => [getKey(item, index), getValue(item)]);
     }
     // Validate keys
@@ -203,15 +201,15 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.toSet
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'toSet', function (selector) {
-    const getValue = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+defineIfNotExists(Array.prototype, 'toSet', function (selector) {
+    const getValue = resolveSelector(selector, (item) => item);
     return new Set(this.map(getValue));
 });
 /**
  * @see Array.prototype.countBy
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'countBy', function (selector) {
-    const getKey = (0, core_utils_1.resolveSelector)(selector, (item) => item);
+defineIfNotExists(Array.prototype, 'countBy', function (selector) {
+    const getKey = resolveSelector(selector, (item) => item);
     const map = new Map();
     for (const item of this) {
         const key = getKey(item);
@@ -222,21 +220,21 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.slugifyIncludes
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'slugifyIncludes', function (value) {
+defineIfNotExists(Array.prototype, 'slugifyIncludes', function (value) {
     if (typeof value !== 'string')
-        (0, core_utils_1.utilitishError)('Array.prototype.slugifyIncludes', 'must be a string', value);
+        utilitishError('Array.prototype.slugifyIncludes', 'must be a string', value);
     const slugified = value.slugify();
     return this.some((item) => {
         if (typeof item !== 'string')
-            (0, core_utils_1.utilitishError)('Array.prototype.slugifyIncludes', 'all array items must be strings', item);
+            utilitishError('Array.prototype.slugifyIncludes', 'all array items must be strings', item);
         return item.slugify() === slugified;
     });
 });
 /**
  * @see Array.prototype.groupByMany
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'groupByMany', function (selector) {
-    const getKeys = (0, core_utils_1.resolveSelector)(selector);
+defineIfNotExists(Array.prototype, 'groupByMany', function (selector) {
+    const getKeys = resolveSelector(selector);
     const result = new Map();
     for (const item of this) {
         const keys = getKeys(item);
@@ -251,10 +249,10 @@ const logic_utils_1 = require("../utils/logic.utils");
 /**
  * @see Array.prototype.classify
  */
-(0, core_utils_1.defineIfNotExists)(Array.prototype, 'classify', function (predicates) {
+defineIfNotExists(Array.prototype, 'classify', function (predicates) {
     if (typeof predicates !== 'object' || predicates === null)
-        (0, core_utils_1.utilitishError)('Array.prototype.classify', 'predicates must be a non-null object', predicates);
-    const resolvedPredicates = Object.fromEntries(Object.entries(predicates).map(([key, fn]) => [key, (0, core_utils_1.resolveSelector)(fn)]));
+        utilitishError('Array.prototype.classify', 'predicates must be a non-null object', predicates);
+    const resolvedPredicates = Object.fromEntries(Object.entries(predicates).map(([key, fn]) => [key, resolveSelector(fn)]));
     const entries = Object.entries(resolvedPredicates);
     const result = new Map(entries.map(([key]) => [key, []]));
     for (const item of this) {

package/dist/array/array-prototype.spec.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./array-prototype");
+import './array-prototype';
 describe('Array.prototype', () => {
     describe('first()', () => {
         it('should return first element of non-empty array', () => {

package/dist/index.js

@@ -1,14 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSlugifyConfig = exports.resetSlugifyConfig = exports.getSlugifyConfig = void 0;
-require("./array/array-constructor");
-require("./array/array-prototype");
-require("./map/map-prototype");
-require("./object/object-prototype");
-require("./set/set-prototype");
-require("./string/string-prototype");
+import './array/array-constructor';
+import './array/array-prototype';
+import './map/map-prototype';
+import './object/object-prototype';
+import './set/set-prototype';
+import './string/string-prototype';
 // Export slugify configuration functions
-var slugify_config_1 = require("./utils/slugify.config");
-Object.defineProperty(exports, "getSlugifyConfig", { enumerable: true, get: function () { return slugify_config_1.getSlugifyConfig; } });
-Object.defineProperty(exports, "resetSlugifyConfig", { enumerable: true, get: function () { return slugify_config_1.resetSlugifyConfig; } });
-Object.defineProperty(exports, "setSlugifyConfig", { enumerable: true, get: function () { return slugify_config_1.setSlugifyConfig; } });
+export { getSlugifyConfig, resetSlugifyConfig, setSlugifyConfig } from './utils/slugify.config';

package/dist/map/map-prototype.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("../utils/core.utils");
+import { defineIfNotExists, utilitishError } from '../utils/core.utils';
 /**
  * @see Map.prototype.toList
  */
-(0, core_utils_1.defineIfNotExists)(Map.prototype, 'toList', function (type = 'entries') {
+defineIfNotExists(Map.prototype, 'toList', function (type = 'entries') {
     switch (type) {
         case 'keys':
             return Array.from(this.keys());
@@ -14,7 +12,7 @@ const core_utils_1 = require("../utils/core.utils");
             const obj = {};
             for (const [key, value] of this) {
                 if (typeof key !== 'string' && typeof key !== 'number' && typeof key !== 'symbol') {
-                    (0, core_utils_1.utilitishError)('Map.prototype.toList', `only supports string, number, or symbol keys`, key);
+                    utilitishError('Map.prototype.toList', `only supports string, number, or symbol keys`, key);
                 }
                 obj[String(key)] = value;
             }
@@ -23,22 +21,22 @@ const core_utils_1 = require("../utils/core.utils");
         case 'entries':
             return Array.from(this.entries());
         default:
-            return (0, core_utils_1.utilitishError)('Map.prototype.toList', `unknown type`, type);
+            return utilitishError('Map.prototype.toList', `unknown type`, type);
     }
 });
 /**
  * @see Map.prototype.toObject
  */
-(0, core_utils_1.defineIfNotExists)(Map.prototype, 'toObject', function () {
+defineIfNotExists(Map.prototype, 'toObject', function () {
     const entries = Array.from(this.entries());
     for (const [key] of entries) {
         if (key === null)
-            (0, core_utils_1.utilitishError)('Map.prototype.toObject', 'key cannot be null');
+            utilitishError('Map.prototype.toObject', 'key cannot be null');
         if (key === undefined)
-            (0, core_utils_1.utilitishError)('Map.prototype.toObject', 'key cannot be undefined');
+            utilitishError('Map.prototype.toObject', 'key cannot be undefined');
         const keyType = typeof key;
         if (keyType !== 'string' && keyType !== 'number' && keyType !== 'symbol') {
-            (0, core_utils_1.utilitishError)('Map.prototype.toObject', `keys must be string, number, or symbol`, key);
+            utilitishError('Map.prototype.toObject', `keys must be string, number, or symbol`, key);
         }
     }
     return Object.fromEntries(entries);
@@ -46,18 +44,18 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Map.prototype.ensureArray
  */
-(0, core_utils_1.defineIfNotExists)(Map.prototype, 'ensureArray', function (key) {
+defineIfNotExists(Map.prototype, 'ensureArray', function (key) {
     if (key === null)
-        (0, core_utils_1.utilitishError)('Map.prototype.ensureArray', 'key cannot be null');
+        utilitishError('Map.prototype.ensureArray', 'key cannot be null');
     if (key === undefined)
-        (0, core_utils_1.utilitishError)('Map.prototype.ensureArray', 'key cannot be undefined');
+        utilitishError('Map.prototype.ensureArray', 'key cannot be undefined');
     let arr = this.get(key);
     if (arr === undefined) {
         arr = [];
         this.set(key, arr);
     }
     if (!Array.isArray(arr)) {
-        (0, core_utils_1.utilitishError)('Map.prototype.ensureArray', 'value for the key is not an array', arr);
+        utilitishError('Map.prototype.ensureArray', 'value for the key is not an array', arr);
     }
     return arr;
 });

package/dist/map/map-prototype.spec.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../map/map-prototype");
+import '../map/map-prototype';
 describe('Map.prototype', () => {
     describe('toList()', () => {
         describe('type: entries', () => {

package/dist/object/object-prototype.js

@@ -1,20 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("../utils/core.utils");
+import { defineIfNotExists, utilitishError } from '../utils/core.utils';
 /**
  * @see Object.prototype.deepClone
  */
-(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepClone', function () {
+defineIfNotExists(Object.prototype, 'deepClone', function () {
     return structuredClone(this);
 });
 /**
  * @see Object.prototype.deepMerge
  */
-(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepMerge', function (source) {
+defineIfNotExists(Object.prototype, 'deepMerge', function (source) {
     if (typeof source !== 'object')
-        (0, core_utils_1.utilitishError)('Object.prototype.deepMerge', 'source must be an object', source);
+        utilitishError('Object.prototype.deepMerge', 'source must be an object', source);
     if (source === null)
-        (0, core_utils_1.utilitishError)('Object.prototype.deepMerge', 'source cannot be null', source);
+        utilitishError('Object.prototype.deepMerge', 'source cannot be null', source);
     const isObject = (val) => val !== null && typeof val === 'object' && !Array.isArray(val);
     const merge = (target, source) => {
         for (const key of Object.keys(source)) {
@@ -34,7 +32,7 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Object.prototype.deepEquals
  */
-(0, core_utils_1.defineIfNotExists)(Object.prototype, 'deepEquals', function (other) {
+defineIfNotExists(Object.prototype, 'deepEquals', function (other) {
     function eq(a, b) {
         // Functions: always false (even if code is the same)
         if (typeof a === 'function' || typeof b === 'function') {
@@ -89,7 +87,7 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Object.prototype.stableStringify
  */
-(0, core_utils_1.defineIfNotExists)(Object.prototype, 'stableStringify', function () {
+defineIfNotExists(Object.prototype, 'stableStringify', function () {
     const stringify = (v) => {
         if (v === null || typeof v !== 'object') {
             return JSON.stringify(v);
@@ -107,7 +105,7 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Object.prototype.stableHash
  */
-(0, core_utils_1.defineIfNotExists)(Object.prototype, 'stableHash', function () {
+defineIfNotExists(Object.prototype, 'stableHash', function () {
     const str = this.stableStringify();
     let hash = 2166136261;
     for (let i = 0; i < str.length; i++) {

package/dist/object/object-prototype.spec.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("./object-prototype");
+import './object-prototype';
 describe('Object.prototype', () => {
     describe('deepClone()', () => {
         it('should deeply clone a plain object', () => {

package/dist/set/set-prototype.js

@@ -1,19 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_utils_1 = require("../utils/core.utils");
+import { defineIfNotExists, utilitishError } from '../utils/core.utils';
 /**
  * @see Set.prototype.toList
  */
-(0, core_utils_1.defineIfNotExists)(Set.prototype, 'toList', function () {
+defineIfNotExists(Set.prototype, 'toList', function () {
     // Always returns a new array, even for empty sets
     return Array.from(this);
 });
 /**
  * @see Set.prototype.hasAny
  */
-(0, core_utils_1.defineIfNotExists)(Set.prototype, 'hasAny', function (...items) {
+defineIfNotExists(Set.prototype, 'hasAny', function (...items) {
     if (!Array.isArray(items))
-        (0, core_utils_1.utilitishError)('Set.prototype.hasAny', 'arguments must be an array', items);
+        utilitishError('Set.prototype.hasAny', 'arguments must be an array', items);
     if (items.length === 0)
         return false;
     return items.some((item) => this.has(item));
@@ -21,7 +19,7 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Set.prototype.includes
  */
-(0, core_utils_1.defineIfNotExists)(Set.prototype, 'includes', function (...args) {
+defineIfNotExists(Set.prototype, 'includes', function (...args) {
     let values;
     if (args.length === 0)
         return true; // empty means "all included" (like [].every)
@@ -32,17 +30,17 @@ const core_utils_1 = require("../utils/core.utils");
         values = args;
     }
     if (!Array.isArray(values))
-        (0, core_utils_1.utilitishError)('Set.prototype.includes', 'arguments must be an array or a Set', args);
+        utilitishError('Set.prototype.includes', 'arguments must be an array or a Set', args);
     return values.every((item) => this.has(item));
 });
 /**
  * @see Set.prototype.union
  */
-(0, core_utils_1.defineIfNotExists)(Set.prototype, 'union', function (...others) {
+defineIfNotExists(Set.prototype, 'union', function (...others) {
     const result = new Set(this);
     for (const other of others) {
         if (!(other instanceof Set))
-            (0, core_utils_1.utilitishError)('Set.prototype.union', 'arguments must be Sets', other);
+            utilitishError('Set.prototype.union', 'arguments must be Sets', other);
         for (const item of other) {
             result.add(item);
         }
@@ -52,9 +50,9 @@ const core_utils_1 = require("../utils/core.utils");
 /**
  * @see Set.prototype.intersection
  */
-(0, core_utils_1.defineIfNotExists)(Set.prototype, 'intersection', function (...others) {
+defineIfNotExists(Set.prototype, 'intersection', function (...others) {
     if (others.some((s) => !(s instanceof Set)))
-        (0, core_utils_1.utilitishError)('Set.prototype.intersection', 'arguments must be Sets', others);
+        utilitishError('Set.prototype.intersection', 'arguments must be Sets', others);
     const result = new Set();
     for (const item of this) {
         if (others.every((set) => set.has(item))) {

package/dist/set/set-prototype.spec.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("../set/set-prototype");
+import '../set/set-prototype';
 describe('Set.prototype', () => {
     describe('toList()', () => {
         it('should return array with all values in insertion order', () => {