@koine/utils 2.0.0-beta.13 → 2.0.0-beta.15

package/cjs/isWeakMap.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWeakMap = void 0;
+var getType_1 = require("./getType");
+function isWeakMap(payload) {
+    return (0, getType_1.default)(payload) === "WeakMap";
+}
+exports.isWeakMap = isWeakMap;
+exports.default = isWeakMap;

package/cjs/isWeakSet.d.ts

@@ -0,0 +1,2 @@
+export declare function isWeakSet(payload: any): payload is WeakSet<any>;
+export default isWeakSet;

package/cjs/isWeakSet.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWeakSet = void 0;
+var getType_1 = require("./getType");
+function isWeakSet(payload) {
+    return (0, getType_1.default)(payload) === "WeakSet";
+}
+exports.isWeakSet = isWeakSet;
+exports.default = isWeakSet;

package/cjs/kbToBytes.d.ts

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

package/cjs/kbToBytes.js

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

package/cjs/location.d.ts

@@ -0,0 +1 @@
+export type AnyQueryParams = undefined | null | Record<string | number, unknown>;

package/cjs/location.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/lowercase.d.ts

@@ -0,0 +1,2 @@
+export declare const lowercase: <T extends string>(str?: T | null | undefined) => Lowercase<T>;
+export default lowercase;

package/cjs/lowercase.js

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

package/cjs/mapListBy.d.ts

@@ -0,0 +1,2 @@
+export declare function mapListBy<T extends Record<string | number | symbol, any>>(array?: T[], key?: keyof T): Record<T[keyof T], T>;
+export default mapListBy;

package/cjs/mapListBy.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapListBy = void 0;
+function mapListBy(array, key) {
+    if (array === void 0) { array = []; }
+    if (key === void 0) { key = ""; }
+    return array.reduce(function (obj, item) {
+        obj[item[key]] = item;
+        return obj;
+    }, {});
+}
+exports.mapListBy = mapListBy;
+exports.default = mapListBy;

package/cjs/matchSorter.d.ts

@@ -0,0 +1,54 @@
+type KeyAttributes = {
+    threshold?: Ranking;
+    maxRanking: Ranking;
+    minRanking: Ranking;
+};
+interface RankingInfo {
+    rankedValue: string;
+    rank: Ranking;
+    keyIndex: number;
+    keyThreshold: Ranking | undefined;
+}
+interface ValueGetterKey<ItemType> {
+    (item: ItemType): string | Array<string>;
+}
+interface IndexedItem<ItemType> {
+    item: ItemType;
+    index: number;
+}
+interface RankedItem<ItemType> extends RankingInfo, IndexedItem<ItemType> {
+}
+interface BaseSorter<ItemType> {
+    (a: RankedItem<ItemType>, b: RankedItem<ItemType>): number;
+}
+interface Sorter<ItemType> {
+    (matchItems: Array<RankedItem<ItemType>>): Array<RankedItem<ItemType>>;
+}
+interface KeyAttributesOptions<ItemType> {
+    key?: string | ValueGetterKey<ItemType>;
+    threshold?: Ranking;
+    maxRanking?: Ranking;
+    minRanking?: Ranking;
+}
+type KeyOption<ItemType> = KeyAttributesOptions<ItemType> | ValueGetterKey<ItemType> | string;
+interface MatchSorterOptions<ItemType = unknown> {
+    keys?: ReadonlyArray<KeyOption<ItemType>>;
+    threshold?: Ranking;
+    baseSort?: BaseSorter<ItemType>;
+    keepDiacritics?: boolean;
+    sorter?: Sorter<ItemType>;
+}
+declare const RANKING_CASE_SENSITIVE_EQUAL = 7;
+declare const RANKING_EQUAL = 6;
+declare const RANKING_STARTS_WITH = 5;
+declare const RANKING_WORD_STARTS_WITH = 4;
+declare const RANKING_CONTAINS = 3;
+declare const RANKING_ACRONYM = 2;
+declare const RANKING_MATCHES = 1;
+declare const RANKING_NO_MATCH = 0;
+type Ranking = typeof RANKING_CASE_SENSITIVE_EQUAL | typeof RANKING_EQUAL | typeof RANKING_STARTS_WITH | typeof RANKING_WORD_STARTS_WITH | typeof RANKING_CONTAINS | typeof RANKING_ACRONYM | typeof RANKING_MATCHES | typeof RANKING_NO_MATCH;
+declare const defaultBaseSortFn: BaseSorter<unknown>;
+declare function matchSorter<ItemType = string>(items: ReadonlyArray<ItemType>, value: string, options?: MatchSorterOptions<ItemType>): Array<ItemType>;
+export { matchSorter, defaultBaseSortFn };
+export type { MatchSorterOptions, KeyAttributesOptions, KeyOption, KeyAttributes, RankingInfo, ValueGetterKey, };
+export default matchSorter;

package/cjs/matchSorter.js

@@ -0,0 +1,259 @@
+"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;
+var RANKING_WORD_STARTS_WITH = 4;
+var RANKING_CONTAINS = 3;
+var RANKING_ACRONYM = 2;
+var RANKING_MATCHES = 1;
+var RANKING_NO_MATCH = 0;
+var defaultBaseSortFn = function (a, b) {
+    return String(a.rankedValue).localeCompare(String(b.rankedValue));
+};
+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) {
+        return matchedItems.sort(function (a, b) { return sortRankedValues(a, b, baseSort); });
+    } : _c;
+    var matchedItems = items.reduce(reduceItemsToRanked, []);
+    return sorter(matchedItems).map(function (_a) {
+        var item = _a.item;
+        return item;
+    });
+    function reduceItemsToRanked(matches, item, index) {
+        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(tslib_1.__assign(tslib_1.__assign({}, rankingInfo), { item: item, index: index }));
+        }
+        return matches;
+    }
+}
+exports.matchSorter = matchSorter;
+function getHighestRanking(item, keys, value, options) {
+    if (!keys) {
+        var stringItem = item;
+        return {
+            rankedValue: stringItem,
+            rank: getMatchRanking(stringItem, value, options),
+            keyIndex: -1,
+            keyThreshold: options.threshold,
+        };
+    }
+    var valuesToRank = getAllValuesToRank(item, keys);
+    return valuesToRank.reduce(function (_a, _b, i) {
+        var rank = _a.rank, rankedValue = _a.rankedValue, keyIndex = _a.keyIndex, keyThreshold = _a.keyThreshold;
+        var itemValue = _b.itemValue, attributes = _b.attributes;
+        var newRank = getMatchRanking(itemValue, value, options);
+        var newRankedValue = rankedValue;
+        var minRanking = attributes.minRanking, maxRanking = attributes.maxRanking, threshold = attributes.threshold;
+        if (newRank < minRanking && newRank >= RANKING_MATCHES) {
+            newRank = minRanking;
+        }
+        else if (newRank > maxRanking) {
+            newRank = maxRanking;
+        }
+        if (newRank > rank) {
+            rank = newRank;
+            keyIndex = i;
+            keyThreshold = threshold;
+            newRankedValue = itemValue;
+        }
+        return { rankedValue: newRankedValue, rank: rank, keyIndex: keyIndex, keyThreshold: keyThreshold };
+    }, {
+        rankedValue: item,
+        rank: RANKING_NO_MATCH,
+        keyIndex: -1,
+        keyThreshold: options.threshold,
+    });
+}
+function getMatchRanking(testString, stringToRank, options) {
+    testString = prepareValueForComparison(testString, options);
+    stringToRank = prepareValueForComparison(stringToRank, options);
+    if (stringToRank.length > testString.length) {
+        return RANKING_NO_MATCH;
+    }
+    if (testString === stringToRank) {
+        return RANKING_CASE_SENSITIVE_EQUAL;
+    }
+    testString = testString.toLowerCase();
+    stringToRank = stringToRank.toLowerCase();
+    if (testString === stringToRank) {
+        return RANKING_EQUAL;
+    }
+    if (testString.startsWith(stringToRank)) {
+        return RANKING_STARTS_WITH;
+    }
+    if (testString.includes(" ".concat(stringToRank))) {
+        return RANKING_WORD_STARTS_WITH;
+    }
+    if (testString.includes(stringToRank)) {
+        return RANKING_CONTAINS;
+    }
+    else if (stringToRank.length === 1) {
+        return RANKING_NO_MATCH;
+    }
+    if (getAcronym(testString).includes(stringToRank)) {
+        return RANKING_ACRONYM;
+    }
+    return getClosenessRanking(testString, stringToRank);
+}
+function getAcronym(string) {
+    var acronym = "";
+    var wordsInString = string.split(" ");
+    wordsInString.forEach(function (wordInString) {
+        var splitByHyphenWords = wordInString.split("-");
+        splitByHyphenWords.forEach(function (splitByHyphenWord) {
+            acronym += splitByHyphenWord.substring(0, 1);
+        });
+    });
+    return acronym;
+}
+function getClosenessRanking(testString, stringToRank) {
+    var matchingInOrderCharCount = 0;
+    var charNumber = 0;
+    function findMatchingCharacter(matchChar, string, index) {
+        for (var j = index, J = string.length; j < J; j++) {
+            var stringChar = string[j];
+            if (stringChar === matchChar) {
+                matchingInOrderCharCount += 1;
+                return j + 1;
+            }
+        }
+        return -1;
+    }
+    function getRanking(spread) {
+        var spreadPercentage = 1 / spread;
+        var inOrderPercentage = matchingInOrderCharCount / stringToRank.length;
+        var ranking = RANKING_MATCHES + inOrderPercentage * spreadPercentage;
+        return ranking;
+    }
+    var firstIndex = findMatchingCharacter(stringToRank[0], testString, 0);
+    if (firstIndex < 0) {
+        return RANKING_NO_MATCH;
+    }
+    charNumber = firstIndex;
+    for (var i = 1, I = stringToRank.length; i < I; i++) {
+        var matchChar = stringToRank[i];
+        charNumber = findMatchingCharacter(matchChar, testString, charNumber);
+        var found = charNumber > -1;
+        if (!found) {
+            return RANKING_NO_MATCH;
+        }
+    }
+    var spread = charNumber - firstIndex;
+    return getRanking(spread);
+}
+function sortRankedValues(a, b, baseSort) {
+    var aFirst = -1;
+    var bFirst = 1;
+    var aRank = a.rank, aKeyIndex = a.keyIndex;
+    var bRank = b.rank, bKeyIndex = b.keyIndex;
+    var same = aRank === bRank;
+    if (same) {
+        if (aKeyIndex === bKeyIndex) {
+            return baseSort(a, b);
+        }
+        else {
+            return aKeyIndex < bKeyIndex ? aFirst : bFirst;
+        }
+    }
+    else {
+        return aRank > bRank ? aFirst : bFirst;
+    }
+}
+function prepareValueForComparison(value, _a) {
+    var keepDiacritics = _a.keepDiacritics;
+    value = "".concat(value);
+    if (!keepDiacritics) {
+        value = (0, removeAccents_1.default)(value);
+    }
+    return value;
+}
+function getItemValues(item, key) {
+    if (typeof key === "object") {
+        key = key.key;
+    }
+    var value;
+    if (typeof key === "function") {
+        value = key(item);
+    }
+    else if (item == null) {
+        value = null;
+    }
+    else if (Object.hasOwnProperty.call(item, key)) {
+        value = item[key];
+    }
+    else if (key.includes(".")) {
+        return getNestedValues(key, item);
+    }
+    else {
+        value = null;
+    }
+    if (value == null) {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return [String(value)];
+}
+function getNestedValues(path, item) {
+    var keys = path.split(".");
+    var values = [item];
+    for (var i = 0, I = keys.length; i < I; i++) {
+        var nestedKey = keys[i];
+        var nestedValues = [];
+        for (var j = 0, J = values.length; j < J; j++) {
+            var nestedItem = values[j];
+            if (nestedItem == null)
+                continue;
+            if (Object.hasOwnProperty.call(nestedItem, nestedKey)) {
+                var nestedValue = nestedItem[nestedKey];
+                if (nestedValue != null) {
+                    nestedValues.push(nestedValue);
+                }
+            }
+            else if (nestedKey === "*") {
+                nestedValues = nestedValues.concat(nestedItem);
+            }
+        }
+        values = nestedValues;
+    }
+    if (Array.isArray(values[0])) {
+        var result = [];
+        return result.concat.apply(result, values);
+    }
+    return values;
+}
+function getAllValuesToRank(item, keys) {
+    var allValues = [];
+    for (var j = 0, J = keys.length; j < J; j++) {
+        var key = keys[j];
+        var attributes = getKeyAttributes(key);
+        var itemValues = getItemValues(item, key);
+        for (var i = 0, I = itemValues.length; i < I; i++) {
+            allValues.push({
+                itemValue: itemValues[i],
+                attributes: attributes,
+            });
+        }
+    }
+    return allValues;
+}
+var defaultKeyAttributes = {
+    maxRanking: Infinity,
+    minRanking: -Infinity,
+};
+function getKeyAttributes(key) {
+    if (typeof key === "string") {
+        return defaultKeyAttributes;
+    }
+    return tslib_1.__assign(tslib_1.__assign({}, defaultKeyAttributes), key);
+}
+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], 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 item = items.splice(idxFrom, 1)[0];
+    items.splice(idxTo, 0, item);
+    return tslib_1.__spreadArray([], items, true);
+}
+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/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/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/cjs/parseCookie.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCookie = void 0;
+function tryDecode(str, decode) {
+    try {
+        return decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+}
+function parseCookie(str, attributes) {
+    if (attributes === void 0) { attributes = {}; }
+    if (typeof str !== "string") {
+        throw new TypeError("argument str must be a string");
+    }
+    var obj = {};
+    var pairs = str.split(";");
+    var _a = attributes.decode, decode = _a === void 0 ? decodeURIComponent : _a;
+    for (var i = 0; i < pairs.length; i++) {
+        var pair = pairs[i];
+        var index = pair.indexOf("=");
+        if (index < 0) {
+            continue;
+        }
+        var key = pair.substring(0, index).trim();
+        if (undefined == obj[key]) {
+            var val = pair.substring(index + 1, pair.length).trim();
+            if (val[0] === '"') {
+                val = val.slice(1, -1);
+            }
+            obj[key] = tryDecode(val, decode);
+        }
+    }
+    return obj;
+}
+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/cjs/parseURL.js

@@ -0,0 +1,18 @@
+"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,
+        protocol: match[1],
+        host: match[2],
+        hostname: match[3],
+        port: match[4],
+        pathname: match[5],
+        search: match[6],
+        hash: match[7],
+    });
+}
+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];
+})[];