@koine/utils 2.0.0-beta.2 → 2.0.0-beta.21

package/{matchSorter.mjs → cjs/matchSorter.js}

@@ -1,21 +1,8 @@
-import { __assign } from "tslib";
-/**
- * @file
- *
- * Slightly adapted from Kent C. Dodd's [match-sorter](https://github.com/kentcdodds/match-sorter)
- * differences are:
- * - less exports
- * - smaller output
- * - no external deps
- *
- * TODO: turn objects into arrays for smaller output?
- *
- * @name match-sorter
- * @license MIT license.
- * @copyright (c) 2020 Kent C. Dodds
- * @author Kent C. Dodds <me@kentcdodds.com> (https://kentcdodds.com)
- */
-import removeAccents from "./removeAccents";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBaseSortFn = exports.matchSorter = void 0;
+var tslib_1 = require("tslib");
+var removeAccents_1 = require("./removeAccents");
 var RANKING_CASE_SENSITIVE_EQUAL = 7;
 var RANKING_EQUAL = 6;
 var RANKING_STARTS_WITH = 5;
@@ -27,13 +14,7 @@ var RANKING_NO_MATCH = 0;
 var defaultBaseSortFn = function (a, b) {
     return String(a.rankedValue).localeCompare(String(b.rankedValue));
 };
-/**
- * Takes an array of items and a value and returns a new array with the items that match the given value
- * @param {Array} items - the items to sort
- * @param {String} value - the value to use for ranking
- * @param {Object} options - Some options to configure the sorter
- * @return {Array} - the new sorted array
- */
+exports.defaultBaseSortFn = defaultBaseSortFn;
 function matchSorter(items, value, options) {
     if (options === void 0) { options = {}; }
     var keys = options.keys, _a = options.threshold, threshold = _a === void 0 ? RANKING_MATCHES : _a, _b = options.baseSort, baseSort = _b === void 0 ? defaultBaseSortFn : _b, _c = options.sorter, sorter = _c === void 0 ? function (matchedItems) {
@@ -48,25 +29,16 @@ function matchSorter(items, value, options) {
         var rankingInfo = getHighestRanking(item, keys, value, options);
         var rank = rankingInfo.rank, _a = rankingInfo.keyThreshold, keyThreshold = _a === void 0 ? threshold : _a;
         if (rank >= keyThreshold) {
-            matches.push(__assign(__assign({}, rankingInfo), { item: item, index: index }));
+            matches.push(tslib_1.__assign(tslib_1.__assign({}, rankingInfo), { item: item, index: index }));
         }
         return matches;
     }
 }
-/**
- * Gets the highest ranking for value for the given item based on its values for the given keys
- * @param {*} item - the item to rank
- * @param {Array} keys - the keys to get values from the item for the ranking
- * @param {String} value - the value to rank against
- * @param {Object} options - options to control the ranking
- * @return {{rank: Number, keyIndex: Number, keyThreshold: Number}} - the highest ranking
- */
+exports.matchSorter = matchSorter;
 function getHighestRanking(item, keys, value, options) {
     if (!keys) {
-        // if keys is not specified, then we assume the item given is ready to be matched
         var stringItem = item;
         return {
-            // ends up being duplicate of 'item' in matches but consistent
             rankedValue: stringItem,
             rank: getMatchRanking(stringItem, value, options),
             keyIndex: -1,
@@ -100,63 +72,37 @@ function getHighestRanking(item, keys, value, options) {
         keyThreshold: options.threshold,
     });
 }
-/**
- * Gives a rankings score based on how well the two strings match.
- * @param {String} testString - the string to test against
- * @param {String} stringToRank - the string to rank
- * @param {Object} options - options for the match (like keepDiacritics for comparison)
- * @returns {Number} the ranking for how well stringToRank matches testString
- */
 function getMatchRanking(testString, stringToRank, options) {
     testString = prepareValueForComparison(testString, options);
     stringToRank = prepareValueForComparison(stringToRank, options);
-    // too long
     if (stringToRank.length > testString.length) {
         return RANKING_NO_MATCH;
     }
-    // case sensitive equals
     if (testString === stringToRank) {
         return RANKING_CASE_SENSITIVE_EQUAL;
     }
-    // Lower casing before further comparison
     testString = testString.toLowerCase();
     stringToRank = stringToRank.toLowerCase();
-    // case insensitive equals
     if (testString === stringToRank) {
         return RANKING_EQUAL;
     }
-    // starts with
     if (testString.startsWith(stringToRank)) {
         return RANKING_STARTS_WITH;
     }
-    // word starts with
     if (testString.includes(" ".concat(stringToRank))) {
         return RANKING_WORD_STARTS_WITH;
     }
-    // contains
     if (testString.includes(stringToRank)) {
         return RANKING_CONTAINS;
     }
     else if (stringToRank.length === 1) {
-        // If the only character in the given stringToRank
-        //   isn't even contained in the testString, then
-        //   it's definitely not a match.
         return RANKING_NO_MATCH;
     }
-    // acronym
     if (getAcronym(testString).includes(stringToRank)) {
         return RANKING_ACRONYM;
     }
-    // will return a number between RANKING_MATCHES and
-    // RANKING_MATCHES + 1 depending  on how close of a match it is.
     return getClosenessRanking(testString, stringToRank);
 }
-/**
- * Generates an acronym for a string.
- *
- * @param {String} string the string for which to produce the acronym
- * @returns {String} the acronym
- */
 function getAcronym(string) {
     var acronym = "";
     var wordsInString = string.split(" ");
@@ -168,16 +114,6 @@ function getAcronym(string) {
     });
     return acronym;
 }
-/**
- * Returns a score based on how spread apart the
- * characters from the stringToRank are within the testString.
- * A number close to RANKING_MATCHES represents a loose match. A number close
- * to RANKING_MATCHES + 1 represents a tighter match.
- * @param {String} testString - the string to test against
- * @param {String} stringToRank - the string to rank
- * @returns {Number} the number between RANKING_MATCHES and
- * RANKING_MATCHES + 1 for how well stringToRank matches testString
- */
 function getClosenessRanking(testString, stringToRank) {
     var matchingInOrderCharCount = 0;
     var charNumber = 0;
@@ -213,12 +149,6 @@ function getClosenessRanking(testString, stringToRank) {
     var spread = charNumber - firstIndex;
     return getRanking(spread);
 }
-/**
- * Sorts items that have a rank, index, and keyIndex
- * @param {Object} a - the first item to sort
- * @param {Object} b - the second item to sort
- * @return {Number} -1 if a should come first, 1 if b should come first, 0 if equal
- */
 function sortRankedValues(a, b, baseSort) {
     var aFirst = -1;
     var bFirst = 1;
@@ -227,7 +157,6 @@ function sortRankedValues(a, b, baseSort) {
     var same = aRank === bRank;
     if (same) {
         if (aKeyIndex === bKeyIndex) {
-            // use the base sort function as a tie-breaker
             return baseSort(a, b);
         }
         else {
@@ -238,28 +167,14 @@ function sortRankedValues(a, b, baseSort) {
         return aRank > bRank ? aFirst : bFirst;
     }
 }
-/**
- * Prepares value for comparison by stringifying it, removing diacritics (if specified)
- * @param {String} value - the value to clean
- * @param {Object} options - {keepDiacritics: whether to remove diacritics}
- * @return {String} the prepared value
- */
 function prepareValueForComparison(value, _a) {
     var keepDiacritics = _a.keepDiacritics;
-    // value might not actually be a string at this point (we don't get to choose)
-    // so part of preparing the value for comparison is ensure that it is a string
-    value = "".concat(value); // toString
+    value = "".concat(value);
     if (!keepDiacritics) {
-        value = removeAccents(value);
+        value = (0, removeAccents_1.default)(value);
     }
     return value;
 }
-/**
- * Gets value for key in item at arbitrarily nested keypath
- * @param {Object} item - the item
- * @param {Object|Function} key - the potentially nested keypath or property callback
- * @return {Array} - an array containing the value(s) at the nested keypath
- */
 function getItemValues(item, key) {
     if (typeof key === "object") {
         key = key.key;
@@ -275,13 +190,11 @@ function getItemValues(item, key) {
         value = item[key];
     }
     else if (key.includes(".")) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         return getNestedValues(key, item);
     }
     else {
         value = null;
     }
-    // because `value` can also be undefined
     if (value == null) {
         return [];
     }
@@ -290,13 +203,6 @@ function getItemValues(item, key) {
     }
     return [String(value)];
 }
-/**
- * Given path: "foo.bar.baz"
- * And item: {foo: {bar: {baz: 'buzz'}}}
- *   -> 'buzz'
- * @param path a dot-separated set of keys
- * @param item the item to get the value from
- */
 function getNestedValues(path, item) {
     var keys = path.split(".");
     var values = [item];
@@ -314,28 +220,17 @@ function getNestedValues(path, item) {
                 }
             }
             else if (nestedKey === "*") {
-                // ensure that values is an array
                 nestedValues = nestedValues.concat(nestedItem);
             }
         }
         values = nestedValues;
     }
     if (Array.isArray(values[0])) {
-        // keep allowing the implicit wildcard for an array of strings at the end of
-        // the path; don't use `.flat()` because that's not available in node.js v10
         var result = [];
-        return result.concat.apply(result, values);
+        return result.concat.apply(result, tslib_1.__spreadArray([], tslib_1.__read(values), false));
     }
-    // Based on our logic it should be an array of strings by now...
-    // assuming the user's path terminated in strings
     return values;
 }
-/**
- * Gets all the values for the given keys in the given item and returns an array of those values
- * @param item - the item from which the values will be retrieved
- * @param keys - the keys to use to retrieve the values
- * @return objects with {itemValue, attributes}
- */
 function getAllValuesToRank(item, keys) {
     var allValues = [];
     for (var j = 0, J = keys.length; j < J; j++) {
@@ -355,16 +250,10 @@ var defaultKeyAttributes = {
     maxRanking: Infinity,
     minRanking: -Infinity,
 };
-/**
- * Gets all the attributes for the given key
- * @param key - the key from which the attributes will be retrieved
- * @return object containing the key's attributes
- */
 function getKeyAttributes(key) {
     if (typeof key === "string") {
         return defaultKeyAttributes;
     }
-    return __assign(__assign({}, defaultKeyAttributes), key);
+    return tslib_1.__assign(tslib_1.__assign({}, defaultKeyAttributes), key);
 }
-export { matchSorter, defaultBaseSortFn };
-export default matchSorter;
+exports.default = matchSorter;

package/cjs/mbToBytes.d.ts

@@ -0,0 +1,2 @@
+export declare const mbToBytes: (bytes: number) => number;
+export default mbToBytes;

package/cjs/mbToBytes.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mbToBytes = void 0;
+var mbToBytes = function (bytes) { return bytes * 1000 * 1000; };
+exports.mbToBytes = mbToBytes;
+exports.default = exports.mbToBytes;

package/cjs/mergeObjects.d.ts

@@ -0,0 +1 @@
+export declare const mergeObjects: <T extends object = object>(target: T, ...sources: Partial<T>[]) => T;

package/cjs/mergeObjects.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeObjects = void 0;
+var tslib_1 = require("tslib");
+var isObject_1 = require("./isObject");
+var isUndefined_1 = require("./isUndefined");
+var mergeObjects = function (target) {
+    var sources = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sources[_i - 1] = arguments[_i];
+    }
+    if (!sources.length) {
+        return target;
+    }
+    var source = sources.shift();
+    if (source === undefined) {
+        return target;
+    }
+    if ((0, isObject_1.isObject)(target) && (0, isObject_1.isObject)(source)) {
+        Object.keys(source).forEach(function (_key) {
+            var key = _key;
+            if ((0, isObject_1.isObject)(source[key])) {
+                if (!target[key]) {
+                    target[key] = {};
+                }
+                (0, exports.mergeObjects)(target[key], source[key]);
+            }
+            else {
+                if (!(0, isUndefined_1.isUndefined)(source[key])) {
+                    target[key] = source[key];
+                }
+            }
+        });
+    }
+    return exports.mergeObjects.apply(void 0, tslib_1.__spreadArray([target], tslib_1.__read(sources), false));
+};
+exports.mergeObjects = mergeObjects;

package/cjs/mergeUrlQueryParams.d.ts

@@ -0,0 +1,3 @@
+import { type AnyQueryParams } from "./location";
+export declare function mergeUrlQueryParams<T extends AnyQueryParams>(oldParams?: NonNullable<AnyQueryParams>, newParams?: NonNullable<AnyQueryParams>): T;
+export default mergeUrlQueryParams;

package/cjs/mergeUrlQueryParams.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeUrlQueryParams = void 0;
+var isNull_1 = require("./isNull");
+function mergeUrlQueryParams(oldParams, newParams) {
+    if (oldParams === void 0) { oldParams = {}; }
+    if (newParams === void 0) { newParams = {}; }
+    for (var key in newParams) {
+        var value = newParams[key];
+        if (oldParams[key] && (0, isNull_1.default)(value)) {
+            delete oldParams[key];
+        }
+        else {
+            oldParams[key] = value;
+        }
+    }
+    return oldParams;
+}
+exports.mergeUrlQueryParams = mergeUrlQueryParams;
+exports.default = mergeUrlQueryParams;

package/cjs/moveSortableArrayItemByKey.d.ts

@@ -0,0 +1,2 @@
+export declare function moveSortableArrayItemByKey<T, K extends keyof T>(items: T[], key: K, fromItem: Pick<T, K>, toItem: Pick<T, K>): T[];
+export default moveSortableArrayItemByKey;

package/cjs/moveSortableArrayItemByKey.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveSortableArrayItemByKey = void 0;
+var tslib_1 = require("tslib");
+function moveSortableArrayItemByKey(items, key, fromItem, toItem) {
+    var itemsKeys = items.map(function (item) { return item[key]; });
+    var idxFrom = itemsKeys.indexOf(fromItem[key]);
+    var idxTo = itemsKeys.indexOf(toItem[key]);
+    var _a = tslib_1.__read(items.splice(idxFrom, 1), 1), item = _a[0];
+    items.splice(idxTo, 0, item);
+    return tslib_1.__spreadArray([], tslib_1.__read(items), false);
+}
+exports.moveSortableArrayItemByKey = moveSortableArrayItemByKey;
+exports.default = moveSortableArrayItemByKey;

package/cjs/noop.d.ts

@@ -0,0 +1,2 @@
+export declare const noop: () => void | undefined;
+export default noop;

package/cjs/noop.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = void 0;
+var noop = function () { return void 0; };
+exports.noop = noop;
+exports.default = exports.noop;

package/cjs/normaliseUrl.d.ts

@@ -0,0 +1,2 @@
+export declare function normaliseUrl(absoluteUrl?: string): string;
+export default normaliseUrl;

package/cjs/normaliseUrl.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normaliseUrl = void 0;
+var removeTrailingSlash_1 = require("./removeTrailingSlash");
+function normaliseUrl(absoluteUrl) {
+    if (absoluteUrl === void 0) { absoluteUrl = ""; }
+    return (0, removeTrailingSlash_1.default)(absoluteUrl.replace(/(:\/\/)|(\/)+/g, "$1$2"));
+}
+exports.normaliseUrl = normaliseUrl;
+exports.default = normaliseUrl;

package/cjs/normaliseUrlPathname.d.ts

@@ -0,0 +1,2 @@
+export declare function normaliseUrlPathname(pathname?: string): string;
+export default normaliseUrlPathname;

package/cjs/normaliseUrlPathname.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normaliseUrlPathname = void 0;
+var removeTrailingSlash_1 = require("./removeTrailingSlash");
+function normaliseUrlPathname(pathname) {
+    if (pathname === void 0) { pathname = ""; }
+    return (0, removeTrailingSlash_1.default)(pathname.replace(/\/+/g, "/"));
+}
+exports.normaliseUrlPathname = normaliseUrlPathname;
+exports.default = normaliseUrlPathname;

package/cjs/objectFlip.d.ts

@@ -0,0 +1,2 @@
+export declare function objectFlip<T extends PropertyKey, U extends PropertyKey>(input: Record<T, U>, keyTransformer?: (key: string) => T): Record<U, T>;
+export default objectFlip;

package/cjs/objectFlip.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectFlip = void 0;
+var tslib_1 = require("tslib");
+function objectFlip(input, keyTransformer) {
+    return Object.fromEntries(Object.entries(input).map(function (_a) {
+        var _b = tslib_1.__read(_a, 2), key = _b[0], value = _b[1];
+        return [
+            value,
+            keyTransformer ? keyTransformer(key) : key,
+        ];
+    }));
+}
+exports.objectFlip = objectFlip;
+exports.default = objectFlip;

package/cjs/objectOmit.d.ts

@@ -0,0 +1,2 @@
+export declare function objectOmit<T extends object, Keys extends (keyof T)[]>(object: T, keys: Keys): Omit<T, Keys[number]>;
+export default objectOmit;

package/cjs/objectOmit.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectOmit = void 0;
+function objectOmit(object, keys) {
+    return Object.keys(object).reduce(function (output, key) {
+        if (!keys.includes(key)) {
+            output[key] =
+                object[key];
+        }
+        return output;
+    }, {});
+}
+exports.objectOmit = objectOmit;
+exports.default = objectOmit;

package/cjs/objectPick.d.ts

@@ -0,0 +1,2 @@
+export declare function objectPick<T extends object, Keys extends (keyof T)[]>(object: T, keys: Keys): Pick<T, Keys[number]>;
+export default objectPick;

package/cjs/objectPick.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPick = void 0;
+function objectPick(object, keys) {
+    var output = {};
+    var len = keys.length;
+    while (len--) {
+        output[keys[len]] = object[keys[len]];
+    }
+    return output;
+}
+exports.objectPick = objectPick;
+exports.default = objectPick;

package/cjs/objectToArray.d.ts

@@ -0,0 +1,2 @@
+export declare const objectToArray: <T extends object, R>(obj: T, iterator: (key: keyof T, index: number) => R) => R[];
+export default objectToArray;

package/cjs/objectToArray.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectToArray = void 0;
+var objectToArray = function (obj, iterator) {
+    return Object.keys(obj).map(iterator);
+};
+exports.objectToArray = objectToArray;
+exports.default = exports.objectToArray;

package/cjs/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@koine/utils",
+  "sideEffects": false,
+  "main": "./index.js",
+  "types": "./index.d.ts"
+}

package/cjs/parseCookie.d.ts

@@ -0,0 +1,3 @@
+import { type CookieAttributesServer } from "./cookie";
+export declare function parseCookie<T extends Record<string, unknown> = Record<string, string>>(str: string, attributes?: CookieAttributesServer): T;
+export default parseCookie;

package/{parseCookie.mjs → cjs/parseCookie.js}

@@ -1,6 +1,6 @@
-/**
- * Try decoding a string using a decoding function.
- */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCookie = void 0;
 function tryDecode(str, decode) {
     try {
         return decode(str);
@@ -9,15 +9,7 @@ function tryDecode(str, decode) {
         return str;
     }
 }
-/**
- * Parse a cookie header.
- *
- * Parse the given cookie header string into an object
- * The object has the various cookies as keys(names) => values
- *
- * @category cookie
- */
-export function parseCookie(str, attributes) {
+function parseCookie(str, attributes) {
     if (attributes === void 0) { attributes = {}; }
     if (typeof str !== "string") {
         throw new TypeError("argument str must be a string");
@@ -28,15 +20,12 @@ export function parseCookie(str, attributes) {
     for (var i = 0; i < pairs.length; i++) {
         var pair = pairs[i];
         var index = pair.indexOf("=");
-        // skip things that don't look like key=value
         if (index < 0) {
             continue;
         }
         var key = pair.substring(0, index).trim();
-        // only assign once
         if (undefined == obj[key]) {
             var val = pair.substring(index + 1, pair.length).trim();
-            // quoted values
             if (val[0] === '"') {
                 val = val.slice(1, -1);
             }
@@ -45,4 +34,5 @@ export function parseCookie(str, attributes) {
     }
     return obj;
 }
-export default parseCookie;
+exports.parseCookie = parseCookie;
+exports.default = parseCookie;

package/cjs/parseURL.d.ts

@@ -0,0 +1,11 @@
+export declare function parseURL(url: string): {
+    href: string;
+    protocol: string;
+    host: string;
+    hostname: string;
+    port: string;
+    pathname: string;
+    search: string;
+    hash: string;
+} | null;
+export default parseURL;

package/{parseURL.mjs → cjs/parseURL.js}

@@ -1,10 +1,7 @@
-/**
- * Solution without DOM or specific env native methods
- *
- * @category location
- * @see https://stackoverflow.com/a/21553982/1938970
- */
-export function parseURL(url) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseURL = void 0;
+function parseURL(url) {
     var match = url.match(/^(https?:)\/\/(([^:/?#]*)(?::([0-9]+))?)([/]{0,1}[^?#]*)(\?[^#]*|)(#.*|)$/);
     return (match && {
         href: url,
@@ -17,4 +14,5 @@ export function parseURL(url) {
         hash: match[7],
     });
 }
-export default parseURL;
+exports.parseURL = parseURL;
+exports.default = parseURL;

package/cjs/quaranteneProps.d.ts

@@ -0,0 +1,7 @@
+export declare function quaranteneProps<TProps extends Record<never, never>, TSupectPropsKeys extends QuaranteneProps<TProps>>(props: TProps, propsKeysToQuarantene: TSupectPropsKeys): Omit<TProps, TSupectPropsKeys[number]> & {
+    _: Pick<TProps, TSupectPropsKeys[number]>;
+};
+export default quaranteneProps;
+type QuaranteneProps<TProps extends Record<never, never>> = readonly (keyof {
+    [K in keyof TProps]?: TProps[K];
+})[];

package/cjs/quaranteneProps.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quaranteneProps = void 0;
+function quaranteneProps(props, propsKeysToQuarantene) {
+    var healthyProps = {
+        _: {},
+    };
+    for (var key in props) {
+        var prop = props[key];
+        if (propsKeysToQuarantene.includes(key)) {
+            healthyProps._[key] = prop;
+        }
+        else {
+            healthyProps[key] = prop;
+        }
+    }
+    return healthyProps;
+}
+exports.quaranteneProps = quaranteneProps;
+exports.default = quaranteneProps;

package/cjs/randomInt.d.ts

@@ -0,0 +1,2 @@
+export declare function randomInt(min: number, max: number): number;
+export default randomInt;

package/cjs/randomInt.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomInt = void 0;
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+}
+exports.randomInt = randomInt;
+exports.default = randomInt;

package/cjs/randomKey.d.ts

@@ -0,0 +1,2 @@
+export declare function randomKey<T extends Record<string | number, unknown>>(obj: T): keyof T;
+export default randomKey;

package/cjs/randomKey.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomKey = void 0;
+function randomKey(obj) {
+    var keys = Object.keys(obj);
+    return keys[(keys.length * Math.random()) << 0];
+}
+exports.randomKey = randomKey;
+exports.default = randomKey;

package/cjs/readCookie.d.ts

@@ -0,0 +1,3 @@
+export declare function readCookie<T extends Record<string, unknown> = Record<string, string>>(name?: null): T;
+export declare function readCookie<T extends Record<string, unknown> = Record<string, string>, N extends keyof T = keyof T>(name: N): T[N];
+export default readCookie;