@powfix/core-js 0.22.1 → 0.23.0

package/dist/shared/utils/global/between.cjs

@@ -0,0 +1,6 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var between = function(value, from, to) {
+    return value >= from && value <= to;
+};
+exports.between = between;

package/dist/shared/utils/global/between.d.ts

@@ -0,0 +1,3 @@
+declare const between: (value: number, from: number, to: number) => boolean;
+
+export { between };

package/dist/shared/utils/global/between.js

@@ -0,0 +1,5 @@
+import '../../../chunk-PKBMQBKP.js';
+var between = function(value, from, to) {
+    return value >= from && value <= to;
+};
+export { between };

package/dist/shared/utils/global/btoa.cjs

@@ -0,0 +1,12 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var base64 = require('base-64');
+function _interopDefault(e) {
+    return e && e.__esModule ? e : {
+        default: e
+    };
+}
+var base64__default = /*#__PURE__*/ _interopDefault(base64);
+var _base64__default_default = base64__default.default, decode = _base64__default_default.decode, encode = _base64__default_default.encode;
+var btoa = encode;
+exports.btoa = btoa;

package/dist/shared/utils/global/btoa.d.ts

@@ -0,0 +1,5 @@
+import base64 from 'base-64';
+
+declare const btoa: typeof base64.encode;
+
+export { btoa };

package/dist/shared/utils/global/btoa.js

@@ -0,0 +1,5 @@
+import '../../../chunk-PKBMQBKP.js';
+import base64 from 'base-64';
+var decode = base64.decode, encode = base64.encode;
+var btoa = encode;
+export { btoa };

package/dist/shared/utils/global/castArray.cjs

@@ -0,0 +1,8 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+function castArray(value) {
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+exports.castArray = castArray;

package/dist/shared/utils/global/castArray.d.ts

@@ -0,0 +1,3 @@
+declare function castArray<T>(value: T | T[]): T[];
+
+export { castArray };

package/dist/shared/utils/global/castArray.js

@@ -0,0 +1,7 @@
+import '../../../chunk-PKBMQBKP.js';
+function castArray(value) {
+    return Array.isArray(value) ? value : [
+        value
+    ];
+}
+export { castArray };

package/dist/shared/utils/global/circularDistance.cjs

@@ -0,0 +1,13 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+function circularDistance(value, target, min, max) {
+    var range = max - min;
+    var from = value - min;
+    var to = target - min;
+    if (to >= from) {
+        return to - from;
+    } else {
+        return range - from + to;
+    }
+}
+exports.circularDistance = circularDistance;

package/dist/shared/utils/global/circularDistance.d.ts

@@ -0,0 +1,3 @@
+declare function circularDistance(value: number, target: number, min: number, max: number): number;
+
+export { circularDistance };

package/dist/shared/utils/global/circularDistance.js

@@ -0,0 +1,12 @@
+import '../../../chunk-PKBMQBKP.js';
+function circularDistance(value, target, min, max) {
+    var range = max - min;
+    var from = value - min;
+    var to = target - min;
+    if (to >= from) {
+        return to - from;
+    } else {
+        return range - from + to;
+    }
+}
+export { circularDistance };

package/dist/shared/utils/global/fallbackIfMatch.cjs

@@ -0,0 +1,13 @@
+'use strict';
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+require('../../../chunk-ETV4XYOV.cjs');
+function fallbackIfMatch(value, condition, fallback) {
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === (typeof condition === "undefined" ? "undefined" : _type_of(condition)) && value === condition) {
+        return fallback;
+    }
+    return value;
+}
+exports.fallbackIfMatch = fallbackIfMatch;

package/dist/shared/utils/global/fallbackIfMatch.d.ts

@@ -0,0 +1,3 @@
+declare function fallbackIfMatch<V, C, F>(value: V, condition: C, fallback: F): V | F;
+
+export { fallbackIfMatch };

package/dist/shared/utils/global/fallbackIfMatch.js

@@ -0,0 +1,12 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import '../../../chunk-PKBMQBKP.js';
+function fallbackIfMatch(value, condition, fallback) {
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === (typeof condition === "undefined" ? "undefined" : _type_of(condition)) && value === condition) {
+        return fallback;
+    }
+    return value;
+}
+export { fallbackIfMatch };

package/dist/shared/utils/global/fallbackIfNull.cjs

@@ -0,0 +1,7 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var fallbackIfMatch = require('./fallbackIfMatch');
+function fallbackIfNull(value, fallback) {
+    return fallbackIfMatch.fallbackIfMatch(value, null, fallback);
+}
+exports.fallbackIfNull = fallbackIfNull;

package/dist/shared/utils/global/fallbackIfNull.d.ts

@@ -0,0 +1,3 @@
+declare function fallbackIfNull<V, F>(value: V, fallback: F): V | F;
+
+export { fallbackIfNull };

package/dist/shared/utils/global/fallbackIfNull.js

@@ -0,0 +1,6 @@
+import '../../../chunk-PKBMQBKP.js';
+import { fallbackIfMatch } from './fallbackIfMatch';
+function fallbackIfNull(value, fallback) {
+    return fallbackIfMatch(value, null, fallback);
+}
+export { fallbackIfNull };

package/dist/shared/utils/global/fallbackIfNullish.cjs

@@ -0,0 +1,9 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+function fallbackIfNullish(value, fallback) {
+    if (value == null) {
+        return fallback;
+    }
+    return value;
+}
+exports.fallbackIfNullish = fallbackIfNullish;

package/dist/shared/utils/global/fallbackIfNullish.d.ts

@@ -0,0 +1,3 @@
+declare function fallbackIfNullish<T, F>(value: T | null | undefined, fallback: F): T | F;
+
+export { fallbackIfNullish };

package/dist/shared/utils/global/fallbackIfNullish.js

@@ -0,0 +1,8 @@
+import '../../../chunk-PKBMQBKP.js';
+function fallbackIfNullish(value, fallback) {
+    if (value == null) {
+        return fallback;
+    }
+    return value;
+}
+export { fallbackIfNullish };

package/dist/shared/utils/global/fallbackIfUndefined.cjs

@@ -0,0 +1,7 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+var fallbackIfMatch = require('./fallbackIfMatch');
+function fallbackIfUndefined(value, fallback) {
+    return fallbackIfMatch.fallbackIfMatch(value, void 0, fallback);
+}
+exports.fallbackIfUndefined = fallbackIfUndefined;

package/dist/shared/utils/global/fallbackIfUndefined.d.ts

@@ -0,0 +1,3 @@
+declare function fallbackIfUndefined<V, F>(value: V, fallback: F): V | F;
+
+export { fallbackIfUndefined };

package/dist/shared/utils/global/fallbackIfUndefined.js

@@ -0,0 +1,6 @@
+import '../../../chunk-PKBMQBKP.js';
+import { fallbackIfMatch } from './fallbackIfMatch';
+function fallbackIfUndefined(value, fallback) {
+    return fallbackIfMatch(value, void 0, fallback);
+}
+export { fallbackIfUndefined };

package/dist/shared/utils/global/firstNonNullish.cjs

@@ -0,0 +1,40 @@
+'use strict';
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+require('../../../chunk-ETV4XYOV.cjs');
+function firstNonNullish() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    if (args == null || !Array.isArray(args) || args.length === 0) {
+        return void 0;
+    }
+    if (args[0] != null) {
+        return args[0];
+    }
+    return firstNonNullish.apply(void 0, _to_consumable_array(args.slice(1)));
+}
+exports.firstNonNullish = firstNonNullish;

package/dist/shared/utils/global/firstNonNullish.d.ts

@@ -0,0 +1,3 @@
+declare function firstNonNullish<T>(...args: T[]): NonNullable<T> | undefined;
+
+export { firstNonNullish };

package/dist/shared/utils/global/firstNonNullish.js

@@ -0,0 +1,39 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import '../../../chunk-PKBMQBKP.js';
+function firstNonNullish() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    if (args == null || !Array.isArray(args) || args.length === 0) {
+        return void 0;
+    }
+    if (args[0] != null) {
+        return args[0];
+    }
+    return firstNonNullish.apply(void 0, _to_consumable_array(args.slice(1)));
+}
+export { firstNonNullish };

package/dist/shared/utils/global/flat.cjs

@@ -0,0 +1,102 @@
+'use strict';
+require('../../../chunk-ETV4XYOV.cjs');
+function isBuffer(obj) {
+    return !!(obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+function flatten(target) {
+    var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var delimiter = opts.delimiter || ".";
+    var maxDepth = opts.maxDepth;
+    var transformKey = opts.transformKey || keyIdentity;
+    var output = {};
+    function step(object, prev) {
+        var currentDepth = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
+        Object.keys(object).forEach(function(key) {
+            var value = object[key];
+            var isarray = opts.safe && Array.isArray(value);
+            var type = Object.prototype.toString.call(value);
+            var isbuffer = isBuffer(value);
+            var isobject = type === "[object Object]" || type === "[object Array]";
+            var newKey = prev ? "".concat(prev).concat(delimiter).concat(transformKey(key)) : transformKey(key);
+            if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+        });
+    }
+    step(target);
+    return output;
+}
+function unflatten(target) {
+    var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var delimiter = opts.delimiter || ".";
+    var overwrite = opts.overwrite || false;
+    var transformKey = opts.transformKey || keyIdentity;
+    var result = {};
+    if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") {
+        return target;
+    }
+    function getkey(key) {
+        var parsedKey = Number(key);
+        return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+    }
+    function addKeys(keyPrefix, recipient, target3) {
+        return Object.keys(target3).reduce(function(res, key) {
+            res["".concat(keyPrefix).concat(delimiter).concat(key)] = target3[key];
+            return res;
+        }, recipient);
+    }
+    function isEmpty(val) {
+        var type = Object.prototype.toString.call(val);
+        var isArray = type === "[object Array]";
+        var isObject = type === "[object Object]";
+        if (!val) {
+            return true;
+        } else if (isArray) {
+            return !val.length;
+        } else if (isObject) {
+            return !Object.keys(val).length;
+        }
+        return false;
+    }
+    var target2 = Object.keys(target).reduce(function(res, key) {
+        var value = target[key];
+        var type = Object.prototype.toString.call(value);
+        var isObject = type === "[object Object]" || type === "[object Array]";
+        if (!isObject || isEmpty(value)) {
+            res[key] = value;
+            return res;
+        } else {
+            return addKeys(key, res, flatten(value, opts));
+        }
+    }, {});
+    Object.keys(target2).forEach(function(key) {
+        var split = key.split(delimiter).map(transformKey);
+        var key1 = getkey(split.shift());
+        var key2 = getkey(split[0]);
+        var recipient = result;
+        while(key2 !== void 0){
+            if (key1 === "__proto__") return;
+            var type = Object.prototype.toString.call(recipient[key1]);
+            var isobject = type === "[object Object]" || type === "[object Array]";
+            if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
+                return;
+            }
+            if (overwrite && !isobject || !overwrite && recipient[key1] == null) {
+                recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+            }
+            recipient = recipient[key1];
+            if (split.length > 0) {
+                key1 = getkey(split.shift());
+                key2 = getkey(split[0]);
+            }
+        }
+        recipient[key1] = unflatten(target2[key], opts);
+    });
+    return result;
+}
+exports.flatten = flatten;
+exports.unflatten = unflatten;

package/dist/shared/utils/global/flat.d.ts

@@ -0,0 +1,16 @@
+interface FlattenOptions {
+    delimiter?: string;
+    maxDepth?: number;
+    safe?: boolean;
+    transformKey?: (key: string) => string;
+}
+interface UnflattenOptions {
+    delimiter?: string;
+    object?: boolean;
+    overwrite?: boolean;
+    transformKey?: (key: string) => string;
+}
+declare function flatten<T extends object>(target: T, opts?: FlattenOptions): Record<string, any>;
+declare function unflatten<T extends object>(target: T, opts?: UnflattenOptions): any;
+
+export { type FlattenOptions, type UnflattenOptions, flatten, unflatten };

package/dist/shared/utils/global/flat.js

@@ -0,0 +1,100 @@
+import '../../../chunk-PKBMQBKP.js';
+function isBuffer(obj) {
+    return !!(obj && obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj));
+}
+function keyIdentity(key) {
+    return key;
+}
+function flatten(target) {
+    var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var delimiter = opts.delimiter || ".";
+    var maxDepth = opts.maxDepth;
+    var transformKey = opts.transformKey || keyIdentity;
+    var output = {};
+    function step(object, prev) {
+        var currentDepth = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1;
+        Object.keys(object).forEach(function(key) {
+            var value = object[key];
+            var isarray = opts.safe && Array.isArray(value);
+            var type = Object.prototype.toString.call(value);
+            var isbuffer = isBuffer(value);
+            var isobject = type === "[object Object]" || type === "[object Array]";
+            var newKey = prev ? "".concat(prev).concat(delimiter).concat(transformKey(key)) : transformKey(key);
+            if (!isarray && !isbuffer && isobject && Object.keys(value).length && (!maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+        });
+    }
+    step(target);
+    return output;
+}
+function unflatten(target) {
+    var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var delimiter = opts.delimiter || ".";
+    var overwrite = opts.overwrite || false;
+    var transformKey = opts.transformKey || keyIdentity;
+    var result = {};
+    if (isBuffer(target) || Object.prototype.toString.call(target) !== "[object Object]") {
+        return target;
+    }
+    function getkey(key) {
+        var parsedKey = Number(key);
+        return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object ? key : parsedKey;
+    }
+    function addKeys(keyPrefix, recipient, target3) {
+        return Object.keys(target3).reduce(function(res, key) {
+            res["".concat(keyPrefix).concat(delimiter).concat(key)] = target3[key];
+            return res;
+        }, recipient);
+    }
+    function isEmpty(val) {
+        var type = Object.prototype.toString.call(val);
+        var isArray = type === "[object Array]";
+        var isObject = type === "[object Object]";
+        if (!val) {
+            return true;
+        } else if (isArray) {
+            return !val.length;
+        } else if (isObject) {
+            return !Object.keys(val).length;
+        }
+        return false;
+    }
+    var target2 = Object.keys(target).reduce(function(res, key) {
+        var value = target[key];
+        var type = Object.prototype.toString.call(value);
+        var isObject = type === "[object Object]" || type === "[object Array]";
+        if (!isObject || isEmpty(value)) {
+            res[key] = value;
+            return res;
+        } else {
+            return addKeys(key, res, flatten(value, opts));
+        }
+    }, {});
+    Object.keys(target2).forEach(function(key) {
+        var split = key.split(delimiter).map(transformKey);
+        var key1 = getkey(split.shift());
+        var key2 = getkey(split[0]);
+        var recipient = result;
+        while(key2 !== void 0){
+            if (key1 === "__proto__") return;
+            var type = Object.prototype.toString.call(recipient[key1]);
+            var isobject = type === "[object Object]" || type === "[object Array]";
+            if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
+                return;
+            }
+            if (overwrite && !isobject || !overwrite && recipient[key1] == null) {
+                recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+            }
+            recipient = recipient[key1];
+            if (split.length > 0) {
+                key1 = getkey(split.shift());
+                key2 = getkey(split[0]);
+            }
+        }
+        recipient[key1] = unflatten(target2[key], opts);
+    });
+    return result;
+}
+export { flatten, unflatten };

package/dist/shared/utils/global/index.cjs

@@ -0,0 +1,136 @@
+'use strict';
+var atob = require('./atob');
+var base64 = require('./base64');
+var between = require('./between');
+var btoa = require('./btoa');
+var castArray = require('./castArray');
+var circularDistance = require('./circularDistance');
+var sleep = require('./sleep');
+var fallbackIfMatch = require('./fallbackIfMatch');
+var fallbackIfNull = require('./fallbackIfNull');
+var fallbackIfNullish = require('./fallbackIfNullish');
+var fallbackIfUndefined = require('./fallbackIfUndefined');
+var firstNonNullish = require('./firstNonNullish');
+var flat = require('./flat');
+var processFirstNonNullish = require('./processFirstNonNullish');
+var pureEnum = require('./pureEnum');
+Object.keys(atob).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return atob[k];
+        }
+    });
+});
+Object.keys(base64).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return base64[k];
+        }
+    });
+});
+Object.keys(between).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return between[k];
+        }
+    });
+});
+Object.keys(btoa).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return btoa[k];
+        }
+    });
+});
+Object.keys(castArray).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return castArray[k];
+        }
+    });
+});
+Object.keys(circularDistance).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return circularDistance[k];
+        }
+    });
+});
+Object.keys(sleep).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return sleep[k];
+        }
+    });
+});
+Object.keys(fallbackIfMatch).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return fallbackIfMatch[k];
+        }
+    });
+});
+Object.keys(fallbackIfNull).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return fallbackIfNull[k];
+        }
+    });
+});
+Object.keys(fallbackIfNullish).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return fallbackIfNullish[k];
+        }
+    });
+});
+Object.keys(fallbackIfUndefined).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return fallbackIfUndefined[k];
+        }
+    });
+});
+Object.keys(firstNonNullish).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return firstNonNullish[k];
+        }
+    });
+});
+Object.keys(flat).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return flat[k];
+        }
+    });
+});
+Object.keys(processFirstNonNullish).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return processFirstNonNullish[k];
+        }
+    });
+});
+Object.keys(pureEnum).forEach(function(k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function get() {
+            return pureEnum[k];
+        }
+    });
+});