@ivujs/i-utils 1.1.16 → 1.1.17

package/dist/es/string/index.mjs

@@ -1,339 +0,0 @@
-/* 字符串处理 */
-/**
- * 字符串中是否包含指定的元素
- * @param {String} value 包含的元素
- * @param {String} str 查找的字符串
- * @returns {Boolean} 返回true和false
- */
-function inString(value, str) {
-    return str.includes(value);
-}
-/**
- * 去除字符串前后位置空格
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function trim(value) {
-    return value.replace(/(^\s*)|(\s*$)/g, "");
-}
-/**
- * 去除字符串开始位置的空格
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function trimStart(value) {
-    return value.replace(/(^\s*)/g, "");
-}
-/**
- * 去除字符串结束位置的空格
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function trimEnd(value) {
-    return value.replace(/(\s*$)/g, "");
-}
-/**
- * 去除字符串中全部的空格
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function trimAll(value) {
-    return value.replace(/\s+/g, "");
-}
-/**
- * 替换所有指定字符串为新的字符串
- * @param {String} value 参数
- * @param {String} oldSubstr 需要替换的字符串
- * @param {String} newSubstr 替换后的字符串
- * @returns {String} 返回处理后的字符串
- */
-function replaceAll(value, oldSubstr, newSubstr) {
-    return value.replace(new RegExp(oldSubstr, "gm"), newSubstr);
-}
-/* 字符串转换 */
-/**
- * 字符串转大写
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function toUpperCase(value) {
-    return String(value).toLocaleUpperCase();
-}
-/**
- * 字符串转小写
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function toLowerCase(value) {
-    String(value).toLocaleLowerCase();
-}
-/**
- * 转为 snake_case 下划线命名
- * @description 支持 驼峰命名，短横命名，帕斯卡命名
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function toSnakeCase(value) {
-    // 驼峰
-    if (/^[a-z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
-        return value.replace(/([A-Z])/g, "_$1").toLowerCase();
-    }
-    // 短横
-    if (value.indexOf("-") > 0) {
-        return value.replace(/-/g, "_").toLowerCase();
-    }
-    // 帕斯卡
-    if (/^[A-Z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
-        value = value.charAt(0).toLowerCase() + value.slice(1);
-        return value.replace(/([A-Z])/g, "_$1").toLowerCase();
-    }
-}
-/**
- * 转为 kebab-case 短横命名
- * @description 支持 下划线，驼峰命名，帕斯卡命名
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function toKebabCase(value) {
-    // 下划线
-    if (value.indexOf("_") > 0) {
-        return value.replace(/_/g, "-").toLowerCase();
-    }
-    // 驼峰
-    if (/^[a-z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
-        return value.replace(/([A-Z])/g, "-$1").toLowerCase();
-    }
-    // 帕斯卡
-    if (/^[A-Z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
-        let newStr = value.charAt(0).toLowerCase() + value.slice(1);
-        return newStr.replace(/([A-Z])/g, "-$1").toLowerCase();
-    }
-}
-/**
- * 转为 camelCase 驼峰命名
- * @description 支持 下划线命名，短横命名，帕斯卡命名
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function toCamelCase(value) {
-    // 下划线
-    if (value.indexOf("_") > 0) {
-        return value.replace(/\_(\w)/g, function (all, letter) {
-            return letter.toUpperCase();
-        });
-    }
-    // 短横
-    else if (value.indexOf("-") > 0) {
-        return value.replace(/\-(\w)/g, function (all, letter) {
-            return letter.toUpperCase();
-        });
-    }
-    // 帕斯卡
-    else if (/^[A-Z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
-        return value.charAt(0).toLowerCase() + value.slice(1);
-    }
-    // 返回自身
-    else {
-        return value;
-    }
-}
-/**
- * 转为 PascalCase 帕斯卡命名
- * @description 支持 下划线命名，短横命名，驼峰命名
- * @param {String} value 参数
- * @returns {String} 返回处理后的字符串
- */
-function toPascalCase(value) {
-    // 下划线
-    if (value.indexOf("_") > 0) {
-        let newStr = value.replace(/\_(\w)/g, function (all, letter) {
-            return letter.toUpperCase();
-        });
-        return newStr.charAt(0).toUpperCase() + newStr.slice(1);
-    }
-    // 短横
-    else if (value.indexOf("-") > 0) {
-        let newStr = value.replace(/\-(\w)/g, function (all, letter) {
-            return letter.toUpperCase();
-        });
-        return newStr.charAt(0).toUpperCase() + newStr.slice(1);
-    }
-    // 驼峰
-    else if (/^[a-z]$/.test(value.charAt(0)) && !(value.indexOf("-") > 0 || value.indexOf("_") > 0)) {
-        return value.charAt(0).toUpperCase() + value.slice(1);
-    }
-    // 返回自身
-    else {
-        return value;
-    }
-}
-/* 字符串格式化 */
-/**
- * 数字前补齐0达到指定位数
- * @description 相当于原生的 padStart(2,'0')
- * @param {Number|String} value 补零的数字
- * @param {Number} maxLength 补齐0后的最大长度，默认2位
- * @returns {String} 返回补0后指定位数的字符串
- */
-function zeroStart(value, maxLength = 2) {
-    let len = value.toString().length;
-    while (len < maxLength) {
-        value = "0" + value;
-        len++;
-    }
-    return value;
-}
-/**
- * 数字后补齐0达到指定位数
- * @description 相当于原生的 padEnd(2,'0')
- * @param {Number|String} value 补零的数字
- * @param {Number} maxLength 补齐0后的最大长度，默认2位
- * @returns {String} 返回补0后指定位数的字符串
- */
-function zeroEnd(value, maxLength = 2) {
-    let len = value.toString().length;
-    while (len < maxLength) {
-        value = value + "0";
-        len++;
-    }
-    return value;
-}
-/**
- * 格式化为标题样式
- * @param {String} value 字符串值
- * @returns {String} 返回格式化后的标题样式
- */
-function formatTitle(value) {
-    if (!value)
-        return "";
-    return value
-        .split(/(?=[A-Z])|[\.\-\s_]/)
-        .map((s) => s.trim())
-        .filter((s) => !!s)
-        .map((s) => toPascalCase(s.toLowerCase()))
-        .join(" ");
-}
-/**
- * 格式化字符串模版
- * @param {String} value 字符串值
- * @param {Object} data 模版数据
- * @returns {String} 返回格式化后的模版字符串
- */
-function formatTemplate(value, data) {
-    if (!value)
-        return "";
-    return Array.from(value.matchAll(/\{\{(.+?)\}\}/g)).reduce((acc, match) => {
-        return acc.replace(match[0], data[match[1]]);
-    }, value);
-}
-/**
- * 格式化千分位数字
- * @description 支持任意数据传参，如果非数字则不会格式化，并返回原数据
- * @param {Number|String} num 数字
- * @returns {String} 返回格式化后的千分位数字
- */
-function formatThousand(num) {
-    if (!parseFloat(num))
-        return num;
-    num = String(num);
-    let regex = num.indexOf(".") > -1 ? /(\d)(?=(\d{3})+\.)/g : /(\d)(?=(?:\d{3})+$)/g;
-    return num.replace(regex, "$1,");
-}
-/**
- * 格式化人民币金额大写
- * @param {Number|String} money 金额
- * @returns {String} 返回金额大写
- */
-function formatRmbChinese(money) {
-    // 汉字的数字
-    let cnNums = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
-    // 基本单位
-    let cnIntRadiance = ["", "拾", "佰", "仟"];
-    // 对应整数部分扩展单位
-    let cnIntUnits = ["", "万", "亿", "兆"];
-    // 对应小数部分单位
-    let cnDecUnits = ["角", "分", "毫", "厘"];
-    // 整数金额时后面跟的字符
-    let cnInteger = "整";
-    // 整型完以后的单位
-    let cnIntLast = "元";
-    // 最大处理的数字
-    let maxNum = Number("999999999999999.9999");
-    // 金额整数部分
-    let integerNum;
-    // 金额小数部分
-    let decimalNum;
-    // 输出的中文金额字符串
-    let chineseStr = "";
-    // 分离金额后用的数组，预定义
-    let parts;
-    if (money === "") {
-        // 不能用==
-        return "";
-    }
-    money = parseFloat(money);
-    if (money >= maxNum) {
-        // 超出最大处理数字，抛出异常
-        throw new Error("Calculated number overflow!");
-    }
-    if (money === 0) {
-        chineseStr = cnNums[0] + cnIntLast + cnInteger;
-        return chineseStr;
-    }
-    // 转换为字符串
-    money = money.toString();
-    if (money.indexOf(".") === -1) {
-        integerNum = money;
-        decimalNum = "";
-    }
-    else {
-        parts = money.split(".");
-        integerNum = parts[0];
-        decimalNum = parts[1].substr(0, 4);
-    }
-    // 获取整型部分转换
-    if (parseInt(integerNum, 10) > 0) {
-        let zeroCount = 0;
-        let IntLen = integerNum.length;
-        for (let i = 0; i < IntLen; i++) {
-            let n = integerNum.substr(i, 1);
-            let p = IntLen - i - 1;
-            let q = p / 4;
-            let m = p % 4;
-            if (n === "0") {
-                zeroCount++;
-            }
-            else {
-                if (zeroCount > 0) {
-                    chineseStr += cnNums[0];
-                }
-                // 归零
-                zeroCount = 0;
-                chineseStr += cnNums[parseInt(n)] + cnIntRadiance[m];
-            }
-            if (m === 0 && zeroCount < 4) {
-                chineseStr += cnIntUnits[q];
-            }
-        }
-        chineseStr += cnIntLast;
-    }
-    // 小数部分
-    if (decimalNum !== "") {
-        let decLen = decimalNum.length;
-        for (let i = 0; i < decLen; i++) {
-            let n = decimalNum.substr(i, 1);
-            if (n !== "0") {
-                chineseStr += cnNums[Number(n)] + cnDecUnits[i];
-            }
-        }
-    }
-    if (chineseStr === "") {
-        chineseStr += cnNums[0] + cnIntLast + cnInteger;
-    }
-    else if (decimalNum === "") {
-        chineseStr += cnInteger;
-    }
-    return chineseStr;
-}
-
-export { formatRmbChinese, formatTemplate, formatThousand, formatTitle, inString, replaceAll, toCamelCase, toKebabCase, toLowerCase, toPascalCase, toSnakeCase, toUpperCase, trim, trimAll, trimEnd, trimStart, zeroEnd, zeroStart };

package/dist/es/url/index.d.ts

@@ -1,118 +0,0 @@
-/**
- * 获得协议名
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回协议名
- */
-export function getProtocol(url?: string): string;
-/**
- * 获得主机地址
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回主机地址
- */
-export function getHost(url?: string): string;
-/**
- * 获得主机名称
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回主机名称
- */
-export function getHostName(url?: string): string;
-/**
- * 获得端口号
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回端口号
- */
-export function getPort(url?: string): string;
-/**
- * 获得地址路径
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回地址路径
- */
-export function getUrlPath(url?: string): string;
-/**
- * 获得hash字符串
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回hash字符串
- */
-export function getUrlHash(url?: string): string;
-/**
- * 获得查询参数字符串
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-export function getSearchString(url?: string): string;
-/**
- * 查询参数字符串中是否包含某个参数
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @returns {Boolean} 返回结果
- */
-export function hasSearchParam(url: string, name: string): boolean;
-/**
- * 查询参数字符串中获得某个参数的值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @returns {String} 返回查询到的值
- */
-export function getSearchParam(url?: string, name?: string): string;
-/**
- * 查询参数字符串中设置某个参数的值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-export function setSearchParam(url: string, name: string, value: any): string;
-/**
- * 查询参数字符串转为对象
- * @param {String} url url地址，默认当前url地址
- * @returns {Object} 返回参数对象
- */
-export function parseSearchParam(url?: string): Object;
-/**
- * 对象转为查询参数字符串
- *  @param {Object} params 参数对象
- *  @param {String} url url地址，如果不为空，则会拼接好查询参数字符串的url地址
- *  @returns {String,Object} 返回参数字符串或参数对象
- */
-export function stringifySearchParam(params: Object, url?: string): string;
-/**
- * 查询参数字符串中在最前面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @returns {String} 返回查询参数字符串
- */
-export function prependSearchParam(url: string, name: string, value: any): string;
-/**
- * 查询参数字符串中在某个参数的前面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} beforeParam 在前面追加参数的名称
- * @returns {String} 返回查询参数字符串
- */
-export function prependToSearchParam(url: string, beforeParam: string, name: string, value: any): string;
-/**
- * 查询参数字符串中在最后面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @returns {String} 返回查询参数字符串
- */
-export function appendSearchParam(url: string, name: string, value: any): string;
-/**
- * 查询参数字符串中在某个参数的后面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} afterName 在后面追加参数的名称
- * @returns {String} 返回查询参数字符串
- */
-export function appendToSearchParam(url: string, afterName: string, name: string, value: any): string;
-/**
- * 查询参数字符串中移除某个参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @returns {String} 返回查询参数字符串
- */
-export function removeSearchParam(url: string, name: string): string;

package/dist/es/url/index.mjs

@@ -1,240 +0,0 @@
-import { REGEXP } from '../constants/regexp.mjs';
-import { isArray } from '../validate/index.mjs';
-import { arrayInsertBefore, arrayInsertAfter } from '../array/index.mjs';
-
-/**
- * 获得协议名
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回协议名
- */
-function getProtocol(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return match[1] || "";
-    }
-}
-/**
- * 获得主机地址
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回主机地址
- */
-function getHost(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return (match[2] || "") + (match[3] ? ":" + match[3] : "");
-    }
-}
-/**
- * 获得主机名称
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回主机名称
- */
-function getHostName(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return match[2] || "";
-    }
-}
-/**
- * 获得端口号
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回端口号
- */
-function getPort(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return match[3] || "";
-    }
-}
-/**
- * 获得地址路径
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回地址路径
- */
-function getUrlPath(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return match[4] || "";
-    }
-}
-/**
- * 获得hash字符串
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回hash字符串
- */
-function getUrlHash(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return match[6] || "";
-    }
-}
-/**
- * 获得查询参数字符串
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function getSearchString(url = window.location.href) {
-    let match = url.match(REGEXP.URL);
-    if (match) {
-        return match[5] || "";
-    }
-}
-/**
- * 查询参数字符串中是否包含某个参数
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @returns {Boolean} 返回结果
- */
-function hasSearchParam(url = window.location.href, name) {
-    let params = parseSearchParam(url);
-    return params[name] !== undefined;
-}
-/**
- * 查询参数字符串中获得某个参数的值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @returns {String} 返回查询到的值
- */
-function getSearchParam(url = window.location.href, name = "") {
-    name = name.replace(/[[\]]/g, "\\$&");
-    url = getSearchString(url);
-    let reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
-    let match = url.substring(0).match(reg);
-    if (match) {
-        return decodeURIComponent(match[2]);
-    }
-}
-/**
- * 查询参数字符串中设置某个参数的值
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} url url地址，默认当前url地址
- * @returns {String} 返回查询参数字符串
- */
-function setSearchParam(url = window.location.href, name = "", value) {
-    let params = parseSearchParam(url);
-    params[name] = value;
-    // 返回替换后的url
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + stringifySearchParam(params));
-}
-/**
- * 查询参数字符串转为对象
- * @param {String} url url地址，默认当前url地址
- * @returns {Object} 返回参数对象
- */
-function parseSearchParam(url = window.location.href) {
-    let searchString = getSearchString(url);
-    let searchArr = searchString.split("&");
-    let param = {};
-    for (let i = 0; i < searchArr.length; i++) {
-        let arr = searchArr[i].split("=");
-        param[decodeURIComponent(arr[0])] = decodeURIComponent(arr[1] || "");
-    }
-    return param;
-}
-/**
- * 对象转为查询参数字符串
- *  @param {Object} params 参数对象
- *  @param {String} url url地址，如果不为空，则会拼接好查询参数字符串的url地址
- *  @returns {String,Object} 返回参数字符串或参数对象
- */
-function stringifySearchParam(params, url = undefined) {
-    if (typeof params !== "object")
-        return params;
-    let arr = [];
-    for (let key in params) {
-        let value = params[key];
-        if (isArray(value)) {
-            for (let i = 0; i < value.length; ++i) {
-                arr.push(encodeURIComponent(key + "[" + i + "]") + "=" + encodeURIComponent(value[i]));
-            }
-        }
-        else {
-            arr.push(encodeURIComponent(key) + "=" + encodeURIComponent(params[key]));
-        }
-    }
-    // 如果url不为空，则会返回拼接好url字符串
-    if (url) {
-        return url.replace(/(\?.+?)(?=#|$)/, "?" + arr.join("&"));
-    }
-    else {
-        return arr.join("&");
-    }
-}
-/**
- * 查询参数字符串中在最前面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @returns {String} 返回查询参数字符串
- */
-function prependSearchParam(url = window.location.href, name, value) {
-    let searchArr = getSearchString(url).split("&");
-    if (isArray(value)) {
-        let arr = [];
-        for (let i = 0; i < value.length; i++) {
-            arr.push(`${encodeURIComponent(name)}[${i}]=${encodeURIComponent(value[i])}`);
-        }
-        searchArr.unshift(...arr);
-    }
-    else {
-        searchArr.unshift(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
-    }
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
-}
-/**
- * 查询参数字符串中在某个参数的前面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} beforeParam 在前面追加参数的名称
- * @returns {String} 返回查询参数字符串
- */
-function prependToSearchParam(url = window.location.href, beforeParam, name, value) {
-    let searchArr = getSearchString(url).split("&");
-    let beforeIndex = searchArr.findIndex((v) => v.includes(beforeParam));
-    let beforeArr = arrayInsertBefore(searchArr, beforeIndex, `${name}=${value}`);
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + beforeArr.join("&"));
-}
-/**
- * 查询参数字符串中在最后面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @returns {String} 返回查询参数字符串
- */
-function appendSearchParam(url = window.location.href, name, value) {
-    let searchArr = getSearchString(url).split("&");
-    searchArr.push(`${name}=${value}`);
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
-}
-/**
- * 查询参数字符串中在某个参数的后面追加新参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @param {String,Number,Array} value 参数值，如果是数组，则解析为：&ids[0]=1&ids[2]=2
- * @param {String} afterName 在后面追加参数的名称
- * @returns {String} 返回查询参数字符串
- */
-function appendToSearchParam(url = window.location.href, afterName, name, value) {
-    let searchArr = getSearchString(url).split("&");
-    let beforeIndex = searchArr.findIndex((v) => v.includes(afterName));
-    let afterArr = arrayInsertAfter(searchArr, beforeIndex, `${name}=${value}`);
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + afterArr.join("&"));
-}
-/**
- * 查询参数字符串中移除某个参数和值
- * @param {String} url url地址，默认当前url地址
- * @param {String} name 参数名
- * @returns {String} 返回查询参数字符串
- */
-function removeSearchParam(url = window.location.href, name) {
-    let searchArr = getSearchString(url).split("&");
-    let delIndex = searchArr.findIndex((v) => v.includes(name));
-    if (delIndex > -1) {
-        searchArr.splice(delIndex, 1);
-    }
-    return url.replace(/(\?.+?)(?=#|$)/, "?" + searchArr.join("&"));
-}
-
-export { appendSearchParam, appendToSearchParam, getHost, getHostName, getPort, getProtocol, getSearchParam, getSearchString, getUrlHash, getUrlPath, hasSearchParam, parseSearchParam, prependSearchParam, prependToSearchParam, removeSearchParam, setSearchParam, stringifySearchParam };