@cowave-cli/utils 2.5.3

package/dist/node.cjs

@@ -0,0 +1,1883 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var axios = require('axios');
+
+/*
+ * @Description:	文件操作函数
+ * @Author: Zye
+ * @Date: 2024-03-11
+ */
+/**
+ * 创建文件夹
+ *
+ * @param path 文件夹路径
+ */
+const createDir = async (path) => {
+    await fs.mkdirSync(path);
+};
+/**
+ * 读取文件夹
+ *
+ * @param path 文件夹路径
+ * @returns {{dirs,files}}
+ */
+const readDir = async (path$1) => {
+    const list = await fs.readdirSync(path$1);
+    const dirs = [];
+    const files = [];
+    for (let i = 0; i < list.length; i++) {
+        const dirOrFile = path.join(path$1.toString(), list[i]);
+        const msg = await fs.statSync(dirOrFile);
+        if (msg.isFile()) {
+            files.push(dirOrFile);
+        }
+        else if (msg.isDirectory()) {
+            dirs.push(dirOrFile);
+        }
+    }
+    return {
+        dirs,
+        files,
+    };
+};
+/** 读取文件
+ *
+ * @param pathName 文件名
+ * @returns
+ */
+const readFile = async (pathName, encoding = 'utf-8') => {
+    const data = await fs.readFileSync(pathName, encoding);
+    return data;
+};
+/** 写入内容
+ *
+ * @param pathName 文件路径
+ * @param content 内容
+ */
+const writeFile = async (pathName, content) => {
+    // 如果不存在文件夹，先创建文件夹
+    const dirName = path.dirname(pathName.toString());
+    if (!fs.existsSync(dirName)) {
+        await fs.mkdirSync(dirName, { recursive: true });
+    }
+    await fs.writeFileSync(pathName, content);
+};
+/** 复制文件夹或者文件
+ *
+ * @param src 文件夹或者文件
+ * @param dest 目标文件夹
+ */
+const copyFileOrDir = async (src, dest) => {
+    const stats = await fs.lstatSync(src);
+    if (stats.isDirectory()) {
+        // 如果是目录，则创建目标目录并递归复制子项
+        if (!fs.existsSync(dest)) {
+            await fs.mkdirSync(dest, { recursive: true });
+        }
+        const entries = await fs.readdirSync(src, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(src.toString(), entry.name);
+            const destPath = path.join(dest.toString(), entry.name);
+            await copyFileOrDir(srcPath, destPath);
+        }
+    }
+    else {
+        // 如果是文件，则直接复制
+        await fs.copyFileSync(src, dest);
+    }
+};
+/** 删除文件夹或者文件
+ *
+ * @param path 路径
+ */
+const removeFileOrDir = async (path$1) => {
+    try {
+        const stats = await fs.lstatSync(path$1);
+        if (stats.isDirectory()) {
+            // 如果是目录，则递归删除其中所有文件和子目录
+            const files = await fs.readdirSync(path$1);
+            for (const file of files) {
+                const currentPath = path.join(path$1.toString(), file);
+                await removeFileOrDir(currentPath);
+            }
+            // 删除空目录（或内部文件已全部删除后的目录）
+            await fs.rmdirSync(path$1);
+        }
+        else {
+            // 如果是文件，则直接删除
+            await fs.unlinkSync(path$1);
+        }
+    }
+    catch (error) {
+        console.log('删除文件夹出错：' + error);
+    }
+};
+
+const noDisk = (fromPath1, toPath1) => fromPath1 != toPath1 && error('noDisk');
+const errorType = {
+    noDisk: '路径错误：导出文件不在同一根目录',
+};
+const error = (type) => {
+    throw new Error(errorType[type]);
+};
+
+/*
+ * @Description:	路径处理
+ * @Author: Zye
+ * @Date: 2024-03-11
+ */
+/**
+ * 判断从toPath引入fromPath的路径相对关系
+ *
+ * @param fromPath 源路径
+ * @param toPath 目标路径
+ * @example
+ *  relation('src/components', 'src/views/home.vue') // '../components/'
+ * @returns
+ */
+const relation = (fromPath, toPath) => {
+    const fromPathArr = fromPath.split(/[\\/]+/g).filter((path) => path && !path.includes('.'));
+    const toPathArr = (toPath.split(/[\\/]+/g)).filter((path) => path && !path.includes('.'));
+    noDisk(fromPathArr.shift(), toPathArr.shift());
+    while (fromPathArr.length && toPathArr.length && toPathArr[0] == fromPathArr[0]) {
+        toPathArr.shift();
+        fromPathArr.shift();
+    }
+    let path = '';
+    if (toPathArr.length) {
+        path += '../'.repeat(toPathArr.length);
+    }
+    else {
+        path += './';
+    }
+    if (fromPathArr.length) {
+        path += fromPathArr.join('/') + '/';
+    }
+    return path;
+};
+/**
+ * 过滤文件(仅过滤文件路径，不过滤文件夹路径)
+ *
+ * @param {string[]} files 文件名列表
+ * @returns {} { includeFiles, excludeFiles }
+ */
+const filter = async (files, basePath, includePath, excludePath) => {
+    if (!includePath?.length && !excludePath?.length)
+        return { include: files, exclude: [] };
+    const includeRegexList = (includePath || []).map((item) => new RegExp(typeof item == 'string' ? item.replace(/[\\/]+/g, '[\\\\/]+') : item));
+    const excludeRegexList = (excludePath || []).map((item) => new RegExp(typeof item == 'string' ? item.replace(/[\\/]+/g, '[\\\\/]+') : item));
+    let includeFiles = [];
+    let excludeFiles = [];
+    for (const file of files) {
+        let isMatchedInclude = false;
+        let isMatchedExclude = false;
+        let subPath = basePath ? file.replace(basePath, '') : file;
+        // 检查文件路径是否符合包含规则
+        if (!includePath?.length) {
+            isMatchedInclude = true;
+        }
+        for (const includeRegex of includeRegexList) {
+            if (includeRegex.test(subPath)) {
+                isMatchedInclude = true;
+                break;
+            }
+        }
+        // 检查文件路径是否符合排除规则
+        for (const excludeRegex of excludeRegexList) {
+            if (excludeRegex.test(subPath)) {
+                isMatchedExclude = true;
+                break;
+            }
+        }
+        // 根据匹配结果将文件分类
+        if (isMatchedInclude && !isMatchedExclude) {
+            includeFiles.push(file);
+        }
+        else {
+            excludeFiles.push(file);
+        }
+    }
+    return { include: includeFiles, exclude: excludeFiles };
+};
+/**
+ * 遍历寻找src目录下的所有文件
+ * @param dirs
+ * @returns
+ */
+const findFiles = async (srcs, includePath, excludePath) => {
+    const allFiles = [];
+    const fn = async (dir, src) => {
+        // 读取文件夹
+        const { dirs, files } = await readDir(dir);
+        allFiles.push(...(await filter(files, src, includePath, excludePath)).include);
+        // 递归 过滤文件夹路径
+        for (let dir of (await filter(dirs, src, [], excludePath)).include) {
+            await fn(dir, src);
+        }
+    };
+    // 源文件夹
+    for (const src of srcs) {
+        await fn(src, src);
+    }
+    return allFiles;
+};
+
+/*
+ * @Description:	字符串处理
+ * @Author: Zye
+ * @Date: 2024-03-11
+ */
+/**
+ * @deprecated 这个函数已弃用，请使用 toHump() 代替
+ */
+const pathToHump = (path, isGreatHump = true) => {
+    if (isGreatHump) {
+        path = path.replace(/^([a-z])/g, (_, p1) => p1.toUpperCase());
+    }
+    path = path.replace(/-([a-z])/g, (_, p1) => p1.toUpperCase());
+    return path;
+};
+/**
+ * 将连接符字符串转换为驼峰字符串
+ *
+ * @param strings 字符串(列表)
+ * @param hyphenType 连接符
+ * @param isGreatHump 是否为大驼峰
+ * @returns humpString
+ */
+const toHump = (strings, hyphenType = '-', isGreatHump = false) => {
+    hyphenType = hyphenType || '-';
+    const results = (typeof strings === 'string' ? [strings] : strings).map(string => {
+        if (isGreatHump) {
+            string = string.replace(/^([a-z])/g, (_, p1) => p1.toUpperCase());
+        }
+        string = string.replace(new RegExp(hyphenType + '([a-z])', 'g'), (_, p1) => p1.toUpperCase());
+        return string;
+    });
+    return typeof strings === 'string' ? results[0] : results;
+};
+/**
+ * 将驼峰字符串转换为连接符字符串
+ *
+ * @param strings 字符串(列表)
+ * @param hyphenType 连接符
+ * @returns hyphenString
+ */
+const toHyphen = (strings, hyphenType = '-') => {
+    const results = (typeof strings === 'string' ? [strings] : strings).map(string => {
+        string = string.replace(/^([A-Z])/g, (_, p1) => p1.toLowerCase());
+        string = string.replace(/([A-Z])/g, (_, p1) => hyphenType + p1.toLowerCase());
+    });
+    return typeof strings === 'string' ? results[0] : results;
+};
+// 字符串拼接
+/**
+ * 将object转换成query参数
+ *
+ * @param keyValue 对象
+ * @returns query参数
+ */
+const query = (keyValue) => {
+    return keyValue
+        ? '?' +
+            Object.keys(keyValue)
+                .filter((key) => keyValue[key] !== undefined && keyValue[key] !== null)
+                .map((key) => encodeURIComponent(key) + '=' + encodeURIComponent(keyValue[key]))
+                .join('&')
+        : '';
+};
+/**
+ *
+ * 将url 传参转成data格式
+ *
+ * @param url (?********)
+ * @returns
+ */
+const urlToData = (url) => {
+    const res = [];
+    const index = url.indexOf('?');
+    if (index === -1)
+        return [{ key: '', value: '' }];
+    url
+        .slice(index + 1)
+        .split('&')
+        .forEach((v) => {
+        res.push({
+            key: decodeURI(v.split('=')[0]),
+            value: decodeURI(v.split('=')[1]),
+        });
+    });
+    return [
+        ...res,
+        {
+            key: '',
+            value: '',
+        },
+    ];
+};
+/**
+ *
+ *  判断url格式
+ *
+ * @param url
+ * @returns
+ */
+const isUrl = (path) => {
+    const reg = /^(https?:\/\/)([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)\/?(\?[^\s#]*)?$/;
+    return reg.test(path);
+};
+
+/*
+ * @Description:	时间处理
+ * @Author: Zye
+ * @Date: 2024-03-11
+ *
+ * setTime(time)  time -> 服务器时间
+ * getTime()    返回服务器时间戳
+ *
+ */
+// 服务器时间戳 减去 客户端时间戳
+let _time_diff = 0;
+// 同步时间
+/**
+ * @param callback 获取服务器时间的回调函数，需要返回服务器时间
+ *
+ * @example
+ *
+ * setTime(async () => {
+ *  return await getServerTime()
+ * })
+ *
+ */
+const setTime = async (callback) => {
+    let _time_before, _time_after, _time_server;
+    _time_before = new Date().getTime();
+    _time_server = new Date(await callback()).getTime();
+    _time_after = new Date().getTime();
+    _time_diff = _time_diff
+        ? (_time_diff + _time_server - _time_before / 2 - _time_after / 2) / 2
+        : _time_server - _time_before / 2 - _time_after / 2;
+};
+// 获取本地时间戳
+const _local_time = () => new Date().getTime();
+/**
+ * 获取服务器时间戳
+ *
+ * @returns 服务器时间戳
+ */
+const getTime = () => _local_time() + _time_diff;
+/** 时间格式化 （参考dayjs）
+ *
+ * @param date 时间
+ * @param formatStr 格式如下
+ * @returns 格式化后的时间
+ *
+ * @formatStr
+ *
+ * |格式	|输出|	描述|
+ * |----|----|----|
+ * |YY|	18	|两位数年份|
+ * |YYYY|	2018	|四位数年份|
+ * |M|	1-12	|月份，从 1 开始|
+ * |MM	|01-12	|月份，2 位数字|
+ * |D	|1-31	|该月的哪一天|
+ * |DD|	01-31|	月份中的日期，2 位数字|
+ * |h|	0-23|	小时|
+ * |hh	|00-23	|小时，2 位数字|
+ * |m|	0-59|	分钟|
+ * |mm	|00-59	|分钟，2 位数字|
+ * |s	|0-59|	秒钟|
+ * |ss	|00-59	|秒钟，2 位数字|
+ */
+const getDate = (date, formatStr) => {
+    if (!date)
+        date = getTime();
+    if (typeof date == 'string' || typeof date == 'number') {
+        date = new Date(date);
+    }
+    if (!formatStr)
+        return new Date(date);
+    let ret;
+    let d = {
+        year: date.getFullYear().toString(),
+        month: (date.getMonth() + 1).toString(),
+        day: date.getDate().toString(),
+        hour: date.getHours().toString(),
+        minutes: date.getMinutes().toString(),
+        seconds: date.getSeconds().toString(),
+        week: ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六'][date.getDay()],
+    };
+    let keys = {
+        'YYYY': d.year,
+        'YY': d.year.slice(2),
+        'M+': d.month,
+        'D+': d.day,
+        '[Hh]+': d.hour,
+        'm+': d.minutes,
+        's+': d.seconds,
+        '[Ww]+': d.week,
+    };
+    for (let key in keys) {
+        ret = new RegExp('(' + key + ')').exec(formatStr);
+        if (ret) {
+            formatStr = formatStr.replace(ret[1], keys[key].padStart(ret[1].length, '0'));
+        }
+    }
+    return formatStr;
+};
+/** 获取特殊时间节点
+ *
+ * @param {'weekstart' | 'weekend' | 'monthstart' | 'monthend' | 'yearstart' | 'yearend' | 'weekbefore' |'weekafter'| 'monthbefore' | 'yearbefore' | 'yearafter'} dateType  获取特殊时间
+ * @param  {string } formatter 格式字符串或预设方案数字
+ *
+ * dateType:
+ *
+ *  - weekstart  —— 本周起始日期
+ *
+ *  - weekend    —— 本周结束日期
+ *
+ *  - weekbefore —— 一周前日期
+ *
+ *  - weekafter —— 一周后日期
+ *
+ *  - monthstart —— 本月起始日期
+ *
+ *  - monthend   —— 本月结束日期
+ *
+ *  - monthbefore—— 一个月前日期
+ *
+ *  - yearstart  —— 今年1月1日
+ *
+ *  - yearend    —— 今年12月31日
+ *
+ *  - yearbefore —— 一年前日期
+ *
+ *  - yearafter —— 一年后日期
+ *
+ * formatter: 参考 getDate
+ *
+ * @returns {Date | string}
+ */
+const getSpecialDate = (dateType, date, formatter) => {
+    // 是否为开始时间
+    let isStart = true;
+    let time = new Date(date || getTime());
+    const setTime = () => {
+        if (isStart) {
+            time.setHours(0);
+            time.setMinutes(0);
+            time.setSeconds(0);
+        }
+        else {
+            time.setHours(23);
+            time.setMinutes(59);
+            time.setSeconds(59);
+        }
+    };
+    switch (dateType) {
+        case 'daybefore':
+            time = new Date(time.getTime() - 24 * 60 * 60 * 1000);
+            break;
+        case 'dayafter':
+            isStart = false;
+            time = new Date(time.getTime() + 24 * 60 * 60 * 1000);
+            break;
+        case 'weekstart':
+            time = new Date(time.getTime() - (time.getDay() - 1) * 24 * 60 * 60 * 1000);
+            break;
+        case 'weekstart7': //从周日开始
+            time = new Date(time.getTime() - time.getDay() * 24 * 60 * 60 * 1000);
+            break;
+        case 'weekend':
+            isStart = false;
+            time = new Date(time.getTime() + (7 - time.getDay()) * 24 * 60 * 60 * 1000);
+            break;
+        case 'weekbefore':
+            time = new Date(time.getTime() - 7 * 24 * 60 * 60 * 1000);
+            break;
+        case 'weekafter':
+            isStart = false;
+            time = (new Date(time.getTime() + 7 * 24 * 60 * 60 * 1000));
+            break;
+        case 'monthstart':
+            time = (new Date(time.getFullYear(), time.getMonth(), 1));
+            break;
+        case 'monthend':
+            isStart = false;
+            time = new Date(time.getFullYear(), time.getMonth() + 1, 0);
+            break;
+        case 'monthbefore':
+            time.setMonth(time.getMonth() - 1);
+            break;
+        case 'monthafter':
+            isStart = false;
+            time.setMonth(time.getMonth() + 1);
+            break;
+        case 'yearstart':
+            time.setMonth(0);
+            time.setDate(1);
+            break;
+        case 'yearend':
+            isStart = false;
+            time.setMonth(11);
+            time.setDate(31);
+            break;
+        case 'yearbefore':
+            time.setFullYear(time.getFullYear() - 1);
+            break;
+        case 'yearafter':
+            isStart = false;
+            time.setFullYear(time.getFullYear() + 1);
+            break;
+    }
+    setTime();
+    return getDate(time, formatter);
+};
+
+/*
+ * @Description: 对象处理
+ * @Author: Zye
+ * @Date: 2022-09-08
+ */
+/**
+ * 从对象数组中获取匹配特定键值对的对象。
+ * @param objectArr 对象数组，每个对象至少包含一个键值对。
+ * @param keyName 需要匹配的键的名称。
+ * @param keyValue 需要匹配的键对应的值。可以是具体值或函数，如果为函数，则会将函数应用于数组中每个对象的键值进行匹配。
+ * @param foundKeyName 如果找到匹配的对象，从该对象中返回的键的名称。如果未指定，则返回整个对象。
+ * @returns 如果找到匹配的对象且指定了`foundKeyName`，则返回该键的值；如果未指定`foundKeyName`，则返回整个匹配的对象。如果没有找到匹配的对象，则返回一个空对象。
+ */
+const getObject = (objectArr, keyName, keyValue, foundKeyName) => {
+    // 使用find方法查找数组中匹配的元素，如果未找到则返回一个空对象
+    let obj = objectArr.find((v) => (typeof keyValue == 'function' ? keyValue(v[keyName]) : v[keyName] == keyValue)) || new Object();
+    // 根据是否指定了foundKeyName返回不同的结果
+    return foundKeyName ? obj[foundKeyName] : obj;
+};
+/**
+ * 将源对象[src]的属性分配到目标对象[dist]，并递归地合并它们的属性。
+ * 如果源对象的属性是一个对象（且不是数组），则会递归地将其属性分配到目标对象的相应属性中。
+ * 如果源对象的属性是数组或其他类型，则直接覆盖目标对象的相应属性。
+ *
+ * @param dist 目标对象，其属性将被源对象的属性覆盖或合并。
+ * @param src 源对象，其属性将覆盖或合并到目标对象中。
+ * @returns 返回合并后的目标对象。
+ * @template T 目标对象和源对象的类型，该类型必须是可深度写入的对象类型。
+ */
+const assignObject = (dist, src) => {
+    const obj = {};
+    for (const [key, value] of Object.entries(dist)) {
+        if (typeof value !== 'object' || value === null) {
+            obj[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(src)) {
+        if (!dist[key] || typeof value !== 'object' || value === null) {
+            obj[key] = value;
+        }
+        else {
+            // 如果源对象中的键值是可深度写入的对象，则递归调用assignObject函数进行合并
+            obj[key] = assignObject(dist[key], value);
+        }
+    }
+    return obj;
+};
+/**
+ * 此函数用来处理中间件向上透传方法 (仅用于Vue组件封装)
+ *
+ * @example
+ *
+ * com.vue
+ * !暴露form表单的所有方法，table表格的所有方法，以及onClick
+ * defineExpose( { onClick: () => { console.log('click') } }, formRef,tableRef)
+ * !父组件调用
+ * com.value.change() //调用表单change方法
+ * com.value.onClick() //调用onClick方法
+ *
+ * @param callback 回调函数，传onMounted
+ * @param option 默认暴露对象
+ * @param refs 要暴露的组件
+ * @returns 暴露对象
+ */
+const expose = (option, ...refs) => {
+    return new Proxy(option, {
+        get(_, prop) {
+            for (const ref of refs) {
+                if (ref.value && prop in ref.value) {
+                    return ref.value?.[prop];
+                }
+            }
+        },
+        has(_, prop) {
+            for (const ref of refs) {
+                if (ref.value && prop in ref.value) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    });
+};
+/**
+ * 此函数用来处理中间件向上透传事件 (仅用于Vue组件封装)
+ *
+ * @param emit emit
+ * @param emitStrs
+ * @returns
+ */
+const on = (emit, emitStrs) => {
+    const emits = {};
+    if (!Array.isArray(emitStrs)) {
+        emitStrs = Object.keys(emitStrs);
+    }
+    emitStrs.forEach(key => {
+        emits[key] = (...args) => {
+            emit(key, ...args);
+        };
+    });
+    return emits;
+};
+
+/*
+ * @Description: 逻辑处理
+ * @Author: Zye
+ * @Date: 2022-11-21
+ */
+const setValue = (condition, value, def = undefined) => {
+    return condition ? value : def;
+};
+
+/*
+ * @Description: 全屏
+ * @Author: Zye
+ * @Date: 2022-09-29
+ */
+/**
+ * 是否全屏
+ *
+ * @returns boolean
+ */
+function isFullscreen() {
+    return !!(document.fullscreenElement ||
+        document.mozFullScreenElement ||
+        document.webkitFullscreenElement ||
+        document.msFullscreenElement);
+}
+/**
+ * 进入全屏
+ *
+ * @param { HTMLElement } el  需要进入全屏的元素
+ *
+ */
+function inFullscreen(el = document.querySelector('body')) {
+    if (el.requestFullscreen) {
+        el.requestFullscreen();
+    }
+    else if (el.mozRequestFullScreen) {
+        // Firefox
+        el.mozRequestFullScreen();
+    }
+    else if (el.webkitRequestFullscreen) {
+        // Chrome, Safari, Opera
+        el.webkitRequestFullscreen();
+    }
+    else if (el.msRequestFullscreen) {
+        // IE/Edge
+        el.msRequestFullscreen();
+    }
+}
+/**
+ * 退出全屏
+ *
+ */
+function exitFullscreen() {
+    if (document.exitFullscreen) {
+        document.exitFullscreen();
+    }
+    else if (document.mozCancelFullScreen) {
+        // Firefox
+        document.mozCancelFullScreen();
+    }
+    else if (document.webkitExitFullscreen) {
+        // Chrome, Safari, Opera
+        document.webkitExitFullscreen();
+    }
+    else if (document.msExitFullscreen) {
+        // IE/Edge
+        document.msExitFullscreen();
+    }
+}
+/**
+ * 切换全屏显示
+ *
+ * @param { HTMLElement } el 需要进入全屏的元素
+ */
+function fullscreen(el = document.querySelector('body')) {
+    isFullscreen() ? exitFullscreen() : inFullscreen(el);
+}
+
+/*
+ * @Description: 数字处理
+ * @Author: Zye
+ * @Date: 2021-11-04
+ */
+/**
+ * 取近似值，取整
+ *
+ * @param num 数字
+ * @param factor 近似因子
+ * @returns 数字
+ *
+ * @ep
+ *
+ * Num(13,5)  // 15
+ *
+ * Num(1.264,0.01)  //1.26
+ *
+ */
+const Num = (num, factor) => {
+    if (!num)
+        return 0;
+    if (typeof num == 'string') {
+        num = parseFloat(num);
+    }
+    return factor ? Math.round(num / factor) * factor : num;
+};
+
+/**
+ * 浏览器引擎判断
+ *
+ * Gecke 火狐（Firefox）
+ * Blink (谷歌, 欧朋)
+ * WebKit （苹果，老版谷歌）
+ * Unknown （其他）
+ */
+function browserEngine() {
+    var userAgent = navigator.userAgent;
+    var isGecko = /Gecko\/\d+\.\d+/i.test(userAgent) && !/like Gecko/.test(userAgent);
+    var isBlink = /Chrome\/[\d.]+/.test(userAgent) && /Safari\/[\d.]+/.test(userAgent);
+    var isWebKit = /AppleWebKit\/[\d.]+/.test(userAgent) && !isBlink;
+    if (isGecko) {
+        return 'Gecko';
+    }
+    else if (isBlink) {
+        return 'Blink';
+    }
+    else if (isWebKit) {
+        return 'WebKit';
+    }
+    else {
+        return 'Unknown';
+    }
+}
+
+/**
+ *
+ * @param px 像素或者数字
+ * @returns
+ */
+function addPx(px) {
+    return typeof px === 'number' ? px + 'px' : px;
+}
+
+/**
+ *
+ * @param config 配置 （如配置 baseUrl、timeout 等 ）
+ * @param request 请求拦截
+ * @param response 响应成功拦截
+ * @param reject 响应错误拦截 (正常情况用不到)
+ * @returns
+ */
+const createHttp = ({ config = {}, request = config => config, response = data => data, reject = error => Promise.reject(error), }) => {
+    // 创建Axios
+    const axiosClone = axios.create({ timeout: 1000 * 60 * 5, ...(config || {}) });
+    // 请求
+    axiosClone.interceptors.request.use((config) => {
+        return request(config);
+    });
+    // 响应
+    axiosClone.interceptors.response.use((res) => {
+        // 处理文件
+        const contentType = res.headers['content-type'];
+        if ((contentType && contentType.includes('application/octet-stream')) || contentType.includes('file'))
+            return res.data;
+        // 处理数据
+        return response(res.data, res);
+    }, (error) => {
+        return Promise.reject(reject(error));
+    });
+    // 重写http
+    const http = (config) => {
+        return axiosClone(config);
+    };
+    const get = (method) => {
+        return http[method] = (url, params = {}, config = {}) => {
+            return axiosClone[method](url, {
+                ...config,
+                params,
+            });
+        };
+    };
+    const post = (method) => {
+        return http[method] = (url, data = {}, config = {}) => {
+            return axiosClone[method](url, data, config);
+        };
+    };
+    http.get = get('get');
+    http.delete = get('delete');
+    http.head = get('head');
+    http.post = post('post');
+    http.put = post('put');
+    http.patch = post('patch');
+    return http;
+};
+
+let trimLeft = /^\s+/;
+let trimRight = /\s+$/;
+let mathRound = Math.round;
+let mathMin = Math.min;
+let mathMax = Math.max;
+let mathRandom = Math.random;
+class TinyColor {
+    matchers;
+    names;
+    _originalInput;
+    _r;
+    _g;
+    _b;
+    _a;
+    _roundA;
+    _format;
+    _gradientType;
+    _ok;
+    isDark;
+    isLight;
+    isValid;
+    constructor(color, opts) {
+        // If input is already a tinycolor, return itself
+        if (color instanceof TinyColor) {
+            return color;
+        }
+        this.init(color, opts);
+    }
+    init(color, opts) {
+        this.matchers = this.initMatchers();
+        this.names = TinyColor.initNames();
+        const rgb = this.inputToRGB(color);
+        this._originalInput = typeof color !== 'undefined' ? color : '';
+        this._r = rgb.r;
+        this._g = rgb.g;
+        this._b = rgb.b;
+        this._a = rgb.a;
+        this._roundA = mathRound(100 * this._a) / 100;
+        // this._format = typeof opts !== 'undefined' && typeof opts.format !== 'undefined' ? opts.format : rgb.format || ''
+        this._format = opts?.format || rgb?.format || '';
+        // this._gradientType = typeof opts !== 'undefined' && typeof opts.gradientType !== 'undefined' ? opts.gradientType : ''
+        this._gradientType = opts?.gradientType || '';
+        // Don't let the range of [0,255] come back in [0,1].
+        // Potentially lose a little bit of precision here, but will fix issues where
+        // .5 gets interpreted as half of the total, instead of half of 1
+        // If it was supposed to be 128, this was already taken care of by `inputToRgb`
+        if (this._r < 1) {
+            this._r = mathRound(this._r);
+        }
+        if (this._g < 1) {
+            this._g = mathRound(this._g);
+        }
+        if (this._b < 1) {
+            this._b = mathRound(this._b);
+        }
+        this._ok = rgb.ok;
+        this.initAttr();
+    }
+    initAttr() {
+        this.isDark = this.getBrightness() < 128;
+        this.isLight = !this.isDark;
+        this.isValid = this._ok;
+    }
+    static initNames() {
+        // Big List of Colors
+        // ------------------
+        // <http://www.w3.org/TR/css3-color/#svg-color>
+        return {
+            aliceblue: 'f0f8ff',
+            antiquewhite: 'faebd7',
+            aqua: '0ff',
+            aquamarine: '7fffd4',
+            azure: 'f0ffff',
+            beige: 'f5f5dc',
+            bisque: 'ffe4c4',
+            black: '000',
+            blanchedalmond: 'ffebcd',
+            blue: '00f',
+            blueviolet: '8a2be2',
+            brown: 'a52a2a',
+            burlywood: 'deb887',
+            burntsienna: 'ea7e5d',
+            cadetblue: '5f9ea0',
+            chartreuse: '7fff00',
+            chocolate: 'd2691e',
+            coral: 'ff7f50',
+            cornflowerblue: '6495ed',
+            cornsilk: 'fff8dc',
+            crimson: 'dc143c',
+            cyan: '0ff',
+            darkblue: '00008b',
+            darkcyan: '008b8b',
+            darkgoldenrod: 'b8860b',
+            darkgray: 'a9a9a9',
+            darkgreen: '006400',
+            darkgrey: 'a9a9a9',
+            darkkhaki: 'bdb76b',
+            darkmagenta: '8b008b',
+            darkolivegreen: '556b2f',
+            darkorange: 'ff8c00',
+            darkorchid: '9932cc',
+            darkred: '8b0000',
+            darksalmon: 'e9967a',
+            darkseagreen: '8fbc8f',
+            darkslateblue: '483d8b',
+            darkslategray: '2f4f4f',
+            darkslategrey: '2f4f4f',
+            darkturquoise: '00ced1',
+            darkviolet: '9400d3',
+            deeppink: 'ff1493',
+            deepskyblue: '00bfff',
+            dimgray: '696969',
+            dimgrey: '696969',
+            dodgerblue: '1e90ff',
+            firebrick: 'b22222',
+            floralwhite: 'fffaf0',
+            forestgreen: '228b22',
+            fuchsia: 'f0f',
+            gainsboro: 'dcdcdc',
+            ghostwhite: 'f8f8ff',
+            gold: 'ffd700',
+            goldenrod: 'daa520',
+            gray: '808080',
+            green: '008000',
+            greenyellow: 'adff2f',
+            grey: '808080',
+            honeydew: 'f0fff0',
+            hotpink: 'ff69b4',
+            indianred: 'cd5c5c',
+            indigo: '4b0082',
+            ivory: 'fffff0',
+            khaki: 'f0e68c',
+            lavender: 'e6e6fa',
+            lavenderblush: 'fff0f5',
+            lawngreen: '7cfc00',
+            lemonchiffon: 'fffacd',
+            lightblue: 'add8e6',
+            lightcoral: 'f08080',
+            lightcyan: 'e0ffff',
+            lightgoldenrodyellow: 'fafad2',
+            lightgray: 'd3d3d3',
+            lightgreen: '90ee90',
+            lightgrey: 'd3d3d3',
+            lightpink: 'ffb6c1',
+            lightsalmon: 'ffa07a',
+            lightseagreen: '20b2aa',
+            lightskyblue: '87cefa',
+            lightslategray: '789',
+            lightslategrey: '789',
+            lightsteelblue: 'b0c4de',
+            lightyellow: 'ffffe0',
+            lime: '0f0',
+            limegreen: '32cd32',
+            linen: 'faf0e6',
+            magenta: 'f0f',
+            maroon: '800000',
+            mediumaquamarine: '66cdaa',
+            mediumblue: '0000cd',
+            mediumorchid: 'ba55d3',
+            mediumpurple: '9370db',
+            mediumseagreen: '3cb371',
+            mediumslateblue: '7b68ee',
+            mediumspringgreen: '00fa9a',
+            mediumturquoise: '48d1cc',
+            mediumvioletred: 'c71585',
+            midnightblue: '191970',
+            mintcream: 'f5fffa',
+            mistyrose: 'ffe4e1',
+            moccasin: 'ffe4b5',
+            navajowhite: 'ffdead',
+            navy: '000080',
+            oldlace: 'fdf5e6',
+            olive: '808000',
+            olivedrab: '6b8e23',
+            orange: 'ffa500',
+            orangered: 'ff4500',
+            orchid: 'da70d6',
+            palegoldenrod: 'eee8aa',
+            palegreen: '98fb98',
+            paleturquoise: 'afeeee',
+            palevioletred: 'db7093',
+            papayawhip: 'ffefd5',
+            peachpuff: 'ffdab9',
+            peru: 'cd853f',
+            pink: 'ffc0cb',
+            plum: 'dda0dd',
+            powderblue: 'b0e0e6',
+            purple: '800080',
+            rebeccapurple: '663399',
+            red: 'f00',
+            rosybrown: 'bc8f8f',
+            royalblue: '4169e1',
+            saddlebrown: '8b4513',
+            salmon: 'fa8072',
+            sandybrown: 'f4a460',
+            seagreen: '2e8b57',
+            seashell: 'fff5ee',
+            sienna: 'a0522d',
+            silver: 'c0c0c0',
+            skyblue: '87ceeb',
+            slateblue: '6a5acd',
+            slategray: '708090',
+            slategrey: '708090',
+            snow: 'fffafa',
+            springgreen: '00ff7f',
+            steelblue: '4682b4',
+            tan: 'd2b48c',
+            teal: '008080',
+            thistle: 'd8bfd8',
+            tomato: 'ff6347',
+            turquoise: '40e0d0',
+            violet: 'ee82ee',
+            wheat: 'f5deb3',
+            white: 'fff',
+            whitesmoke: 'f5f5f5',
+            yellow: 'ff0',
+            yellowgreen: '9acd32',
+        };
+    }
+    initMatchers() {
+        // <http://www.w3.org/TR/css3-values/#integers>
+        const CSS_INTEGER = '[-\\+]?\\d+%?';
+        // <http://www.w3.org/TR/css3-values/#number-value>
+        const CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?';
+        // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
+        const CSS_UNIT = '(?:' + CSS_NUMBER + ')|(?:' + CSS_INTEGER + ')';
+        // Actual matching.
+        // Parentheses and commas are optional, but not required.
+        // Whitespace can take the place of commas or opening paren
+        const PERMISSIVE_MATCH3 = '[\\s|\\(]+(' + CSS_UNIT + ')[,|\\s]+(' + CSS_UNIT + ')[,|\\s]+(' + CSS_UNIT + ')\\s*\\)?';
+        const PERMISSIVE_MATCH4 = '[\\s|\\(]+(' + CSS_UNIT + ')[,|\\s]+(' + CSS_UNIT + ')[,|\\s]+(' + CSS_UNIT + ')[,|\\s]+(' + CSS_UNIT + ')\\s*\\)?';
+        return {
+            CSS_UNIT: new RegExp(CSS_UNIT),
+            rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
+            rgba: new RegExp('rgba' + PERMISSIVE_MATCH4),
+            hsl: new RegExp('hsl' + PERMISSIVE_MATCH3),
+            hsla: new RegExp('hsla' + PERMISSIVE_MATCH4),
+            hsv: new RegExp('hsv' + PERMISSIVE_MATCH3),
+            hsva: new RegExp('hsva' + PERMISSIVE_MATCH4),
+            hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+            hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+            hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+            hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+        };
+    }
+    getBrightness() {
+        //http://www.w3.org/TR/AERT#color-contrast
+        const rgb = this.toRgb();
+        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
+    }
+    toRgb() {
+        return {
+            r: mathRound(this._r),
+            g: mathRound(this._g),
+            b: mathRound(this._b),
+            a: this._a,
+        };
+    }
+    static getNames() {
+        return this.initNames();
+    }
+    getOriginalInput() {
+        return this._originalInput;
+    }
+    getFormat() {
+        return this._format;
+    }
+    getAlpha() {
+        return this._a;
+    }
+    getLuminance() {
+        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+        const rgb = this.toRgb();
+        let RsRGB, GsRGB, BsRGB, R, G, B;
+        RsRGB = rgb.r / 255;
+        GsRGB = rgb.g / 255;
+        BsRGB = rgb.b / 255;
+        if (RsRGB <= 0.03928) {
+            R = RsRGB / 12.92;
+        }
+        else {
+            R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
+        }
+        if (GsRGB <= 0.03928) {
+            G = GsRGB / 12.92;
+        }
+        else {
+            G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
+        }
+        if (BsRGB <= 0.03928) {
+            B = BsRGB / 12.92;
+        }
+        else {
+            B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
+        }
+        return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+    }
+    setAlpha(value) {
+        this._a = this.boundAlpha(value);
+        this._roundA = mathRound(100 * this._a) / 100;
+        return this;
+    }
+    toHsv() {
+        let hsv = this.rgbToHsv(this._r, this._g, this._b);
+        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
+    }
+    toHsvString() {
+        let hsv = this.rgbToHsv(this._r, this._g, this._b);
+        let h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
+        return this._a == 1 ? 'hsv(' + h + ', ' + s + '%, ' + v + '%)' : 'hsva(' + h + ', ' + s + '%, ' + v + '%, ' + this._roundA + ')';
+    }
+    toHsl() {
+        let hsl = this.rgbToHsl(this._r, this._g, this._b);
+        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
+    }
+    toHslString() {
+        let hsl = this.rgbToHsl(this._r, this._g, this._b);
+        let h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
+        return this._a == 1 ? 'hsl(' + h + ', ' + s + '%, ' + l + '%)' : 'hsla(' + h + ', ' + s + '%, ' + l + '%, ' + this._roundA + ')';
+    }
+    toHex(allow3Char) {
+        return this.rgbToHex(this._r, this._g, this._b, allow3Char);
+    }
+    toHexString(allow3Char) {
+        return '#' + this.toHex(allow3Char);
+    }
+    toHex8(allow4Char) {
+        return this.rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
+    }
+    toHex8String(allow4Char) {
+        return '#' + this.toHex8(allow4Char);
+    }
+    toRgbString() {
+        return this._a == 1
+            ? 'rgb(' + mathRound(this._r) + ', ' + mathRound(this._g) + ', ' + mathRound(this._b) + ')'
+            : 'rgba(' + mathRound(this._r) + ', ' + mathRound(this._g) + ', ' + mathRound(this._b) + ', ' + this._roundA + ')';
+    }
+    toPercentageRgb() {
+        return {
+            r: mathRound(this.bound01(this._r, 255) * 100) + '%',
+            g: mathRound(this.bound01(this._g, 255) * 100) + '%',
+            b: mathRound(this.bound01(this._b, 255) * 100) + '%',
+            a: this._a,
+        };
+    }
+    toPercentageRgbString() {
+        return this._a == 1
+            ? 'rgb(' +
+                mathRound(this.bound01(this._r, 255) * 100) +
+                '%, ' +
+                mathRound(this.bound01(this._g, 255) * 100) +
+                '%, ' +
+                mathRound(this.bound01(this._b, 255) * 100) +
+                '%)'
+            : 'rgba(' +
+                mathRound(this.bound01(this._r, 255) * 100) +
+                '%, ' +
+                mathRound(this.bound01(this._g, 255) * 100) +
+                '%, ' +
+                mathRound(this.bound01(this._b, 255) * 100) +
+                '%, ' +
+                this._roundA +
+                ')';
+    }
+    toName() {
+        if (this._a === 0) {
+            return 'transparent';
+        }
+        if (this._a < 1) {
+            return false;
+        }
+        return this._flip()[this.rgbToHex(this._r, this._g, this._b, true)] || false;
+    }
+    toFilter(secondColor) {
+        let hex8String = '#' + this.rgbaToArgbHex(this._r, this._g, this._b, this._a);
+        let secondHex8String = hex8String;
+        let gradientType = this._gradientType ? 'GradientType = 1, ' : '';
+        if (secondColor) {
+            const tinyColorObj = new TinyColor(secondColor);
+            secondHex8String = '#' + this.rgbaToArgbHex(tinyColorObj._r, tinyColorObj._g, tinyColorObj._b, tinyColorObj._a);
+        }
+        return ('progid:DXImageTransform.Microsoft.gradient(' +
+            gradientType +
+            'startColorstr=' +
+            hex8String +
+            ',endColorstr=' +
+            secondHex8String +
+            ')');
+    }
+    toString(format) {
+        let formatSet = !!format;
+        format = format || this._format;
+        let formattedString = '';
+        let hasAlpha = this._a < 1 && this._a >= 0;
+        let needsAlphaFormat = !formatSet &&
+            hasAlpha &&
+            (format === 'hex' || format === 'hex6' || format === 'hex3' || format === 'hex4' || format === 'hex8' || format === 'name');
+        if (needsAlphaFormat) {
+            if (format === 'name' && this._a === 0) {
+                return this.toName();
+            }
+            return this.toRgbString();
+        }
+        if (format === 'rgb') {
+            formattedString = this.toRgbString();
+        }
+        if (format === 'prgb') {
+            formattedString = this.toPercentageRgbString();
+        }
+        if (format === 'hex' || format === 'hex6') {
+            formattedString = this.toHexString();
+        }
+        if (format === 'hex3') {
+            formattedString = this.toHexString(true);
+        }
+        if (format === 'hex4') {
+            formattedString = this.toHex8String(true);
+        }
+        if (format === 'hex8') {
+            formattedString = this.toHex8String();
+        }
+        if (format === 'name') {
+            formattedString = this.toName();
+        }
+        if (format === 'hsl') {
+            formattedString = this.toHslString();
+        }
+        if (format === 'hsv') {
+            formattedString = this.toHsvString();
+        }
+        return formattedString || this.toHexString();
+    }
+    clone() {
+        return new TinyColor(this.toString());
+    }
+    _applyModification(fn, args) {
+        let color = fn.apply(null, [this].concat([].slice.call(args)));
+        this._r = color._r;
+        this._g = color._g;
+        this._b = color._b;
+        this.setAlpha(color._a);
+        return this;
+    }
+    _lighten(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        let hsl = new TinyColor(color).toHsl();
+        hsl.l += amount / 100;
+        hsl.l = color.clamp01(hsl.l);
+        return new TinyColor(hsl);
+    }
+    lighten(...args) {
+        return this._applyModification(this._lighten, args);
+    }
+    _brighten(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        let rgb = new TinyColor(color).toRgb();
+        rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * -(amount / 100))));
+        rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * -(amount / 100))));
+        rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * -(amount / 100))));
+        return new TinyColor(rgb);
+    }
+    brighten(...args) {
+        return this._applyModification(this._brighten, args);
+    }
+    _darken(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        let hsl = new TinyColor(color).toHsl();
+        hsl.l -= amount / 100;
+        hsl.l = color.clamp01(hsl.l);
+        return new TinyColor(hsl);
+    }
+    darken(...args) {
+        return this._applyModification(this._darken, args);
+    }
+    _desaturate(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        let hsl = new TinyColor(color).toHsl();
+        hsl.s -= amount / 100;
+        hsl.s = color.clamp01(hsl.s);
+        return new TinyColor(hsl);
+    }
+    desaturate(...args) {
+        return this._applyModification(this._desaturate, args);
+    }
+    _saturate(color, amount) {
+        amount = amount === 0 ? 0 : amount || 10;
+        let hsl = new TinyColor(color).toHsl();
+        hsl.s += amount / 100;
+        hsl.s = color.clamp01(hsl.s);
+        return new TinyColor(hsl);
+    }
+    saturate(...args) {
+        return this._applyModification(this._saturate, args);
+    }
+    _greyscale(color) {
+        return new TinyColor(color).desaturate(100);
+    }
+    greyscale(...args) {
+        return this._applyModification(this._greyscale, args);
+    }
+    _spin(color, amount) {
+        let hsl = new TinyColor(color).toHsl();
+        let hue = (hsl.h + amount) % 360;
+        hsl.h = hue < 0 ? 360 + hue : hue;
+        return new TinyColor(hsl);
+    }
+    spin(...args) {
+        return this._applyModification(this._spin, args);
+    }
+    _applyCombination(fn, args) {
+        return fn.apply(null, [this].concat([].slice.call(args)));
+    }
+    _analogous(color, results, slices) {
+        results = results || 6;
+        slices = slices || 30;
+        let hsl = new TinyColor(color).toHsl();
+        let part = 360 / slices;
+        let ret = [new TinyColor(color)];
+        for (hsl.h = (hsl.h - ((part * results) >> 1) + 720) % 360; --results;) {
+            hsl.h = (hsl.h + part) % 360;
+            ret.push(new TinyColor(hsl));
+        }
+        return ret;
+    }
+    analogous(...args) {
+        return this._applyCombination(this._analogous, args);
+    }
+    _complement(color) {
+        let hsl = new TinyColor(color).toHsl();
+        hsl.h = (hsl.h + 180) % 360;
+        return new TinyColor(hsl);
+    }
+    complement(...args) {
+        return this._applyCombination(this._complement, args);
+    }
+    _monochromatic(color, results) {
+        results = results || 6;
+        let hsv = new TinyColor(color).toHsv();
+        let h = hsv.h, s = hsv.s, v = hsv.v;
+        let ret = [];
+        let modification = 1 / results;
+        while (results--) {
+            ret.push(new TinyColor({ h: h, s: s, v: v }));
+            v = (v + modification) % 1;
+        }
+        return ret;
+    }
+    monochromatic(...args) {
+        return this._applyCombination(this._monochromatic, args);
+    }
+    _splitcomplement(color) {
+        let hsl = new TinyColor(color).toHsl();
+        let h = hsl.h;
+        return [
+            new TinyColor(color),
+            new TinyColor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),
+            new TinyColor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l }),
+        ];
+    }
+    splitcomplement(...args) {
+        return this._applyCombination(this._splitcomplement, args);
+    }
+    _triad(color) {
+        let hsl = new TinyColor(color).toHsl();
+        let h = hsl.h;
+        return [
+            new TinyColor(color),
+            new TinyColor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
+            new TinyColor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l }),
+        ];
+    }
+    triad(...args) {
+        return this._applyCombination(this._triad, args);
+    }
+    _tetrad(obj) {
+        let hsl = new TinyColor(obj).toHsl();
+        let h = hsl.h;
+        return [
+            new TinyColor(obj),
+            new TinyColor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
+            new TinyColor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
+            new TinyColor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l }),
+        ];
+    }
+    tetrad(...args) {
+        return this._applyCombination(this._tetrad, args);
+    }
+    static fromRatio(color, opts) {
+        if (typeof color == 'object') {
+            let newColor = {};
+            for (let i in color) {
+                if (color.hasOwnProperty(i)) {
+                    if (i === 'a') {
+                        newColor[i] = color[i];
+                    }
+                    else {
+                        newColor[i] = TinyColor.convertToPercentage(color[i]);
+                    }
+                }
+            }
+            color = newColor;
+        }
+        return new TinyColor(color, opts);
+    }
+    static equals(color1, color2) {
+        if (!color1 || !color2) {
+            return false;
+        }
+        return new TinyColor(color1).toRgbString() == new TinyColor(color2).toRgbString();
+    }
+    static random() {
+        return TinyColor.fromRatio({
+            r: mathRandom(),
+            g: mathRandom(),
+            b: mathRandom(),
+        });
+    }
+    static mix(color1, color2, amount) {
+        amount = amount === 0 ? 0 : amount || 50;
+        let rgb1 = new TinyColor(color1).toRgb();
+        let rgb2 = new TinyColor(color2).toRgb();
+        let p = amount / 100;
+        let rgba = {
+            r: (rgb2.r - rgb1.r) * p + rgb1.r,
+            g: (rgb2.g - rgb1.g) * p + rgb1.g,
+            b: (rgb2.b - rgb1.b) * p + rgb1.b,
+            a: (rgb2.a - rgb1.a) * p + rgb1.a,
+        };
+        return new TinyColor(rgba);
+    }
+    static readability(color1, color2) {
+        let c1 = new TinyColor(color1);
+        let c2 = new TinyColor(color2);
+        return (Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) / (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05);
+    }
+    static isReadable(color1, color2, wcag2) {
+        let readability = TinyColor.readability(color1, color2);
+        let wcag2Parms, out;
+        out = false;
+        wcag2Parms = TinyColor.validateWCAG2Parms(wcag2);
+        switch (wcag2Parms.level + wcag2Parms.size) {
+            case 'AAsmall':
+            case 'AAAlarge':
+                out = readability >= 4.5;
+                break;
+            case 'AAlarge':
+                out = readability >= 3;
+                break;
+            case 'AAAsmall':
+                out = readability >= 7;
+                break;
+        }
+        return out;
+    }
+    static mostReadable(baseColor, colorList, args) {
+        let bestColor = '';
+        let bestScore = 0;
+        let readability;
+        let includeFallbackColors, level, size;
+        args = args || {};
+        includeFallbackColors = args.includeFallbackColors;
+        level = args.level;
+        size = args.size;
+        for (let item of colorList) {
+            readability = TinyColor.readability(baseColor, item);
+            if (readability > bestScore) {
+                bestScore = readability;
+                bestColor = new TinyColor(item);
+            }
+        }
+        if (TinyColor.isReadable(baseColor, bestColor, {
+            level: level,
+            size: size,
+        }) ||
+            !includeFallbackColors) {
+            return bestColor;
+        }
+        else {
+            args.includeFallbackColors = false;
+            return TinyColor.mostReadable(baseColor, ['#fff', '#000'], args);
+        }
+    }
+    clamp01(val) {
+        return mathMin(1, mathMax(0, val));
+    }
+    _flip() {
+        let flipped = {};
+        let allName = TinyColor.initNames();
+        for (let i in allName) {
+            if (allName.hasOwnProperty(i)) {
+                flipped[allName[i]] = i;
+            }
+        }
+        return flipped;
+    }
+    isValidCSSUnit(color) {
+        return !!this.matchers.CSS_UNIT.exec(color);
+    }
+    isOnePointZero(n) {
+        return typeof n == 'string' && n.indexOf('.') != -1 && parseFloat(n) === 1;
+    }
+    isPercentage(n) {
+        return typeof n === 'string' && n.indexOf('%') != -1;
+    }
+    pad2(c) {
+        return c.length == 1 ? '0' + c : '' + c;
+    }
+    bound01(n, max) {
+        if (this.isOnePointZero(n)) {
+            n = '100%';
+        }
+        let processPercent = this.isPercentage(n);
+        n = mathMin(max, mathMax(0, parseFloat(n)));
+        // Automatically convert percentage into number
+        if (processPercent) {
+            n = parseInt('' + n * max, 10) / 100;
+        }
+        // Handle floating point rounding errors
+        if (Math.abs(n - max) < 0.000001) {
+            return 1;
+        }
+        // Convert into [0, 1] range if it isn't already
+        return (n % max) / parseFloat(max);
+    }
+    convertDecimalToHex(d) {
+        return Math.round(parseFloat(d) * 255).toString(16);
+    }
+    rgbToRgb(r, g, b) {
+        return {
+            r: this.bound01(r, 255) * 255,
+            g: this.bound01(g, 255) * 255,
+            b: this.bound01(b, 255) * 255,
+        };
+    }
+    hsvToRgb(h, s, v) {
+        h = this.bound01(h, 360) * 6;
+        s = this.bound01(s, 100);
+        v = this.bound01(v, 100);
+        let i = Math.floor(h), f = h - i, p = v * (1 - s), q = v * (1 - f * s), t = v * (1 - (1 - f) * s), mod = i % 6, r = [v, q, p, p, t, v][mod], g = [t, v, v, q, p, p][mod], b = [p, p, t, v, v, q][mod];
+        return { r: r * 255, g: g * 255, b: b * 255 };
+    }
+    hslToRgb(h, s, l) {
+        let r, g, b;
+        h = this.bound01(h, 360);
+        s = this.bound01(s, 100);
+        l = this.bound01(l, 100);
+        function hue2rgb(p, q, t) {
+            if (t < 0)
+                t += 1;
+            if (t > 1)
+                t -= 1;
+            if (t < 1 / 6)
+                return p + (q - p) * 6 * t;
+            if (t < 1 / 2)
+                return q;
+            if (t < 2 / 3)
+                return p + (q - p) * (2 / 3 - t) * 6;
+            return p;
+        }
+        if (s === 0) {
+            r = g = b = l; // achromatic
+        }
+        else {
+            let q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            let p = 2 * l - q;
+            r = hue2rgb(p, q, h + 1 / 3);
+            g = hue2rgb(p, q, h);
+            b = hue2rgb(p, q, h - 1 / 3);
+        }
+        return { r: r * 255, g: g * 255, b: b * 255 };
+    }
+    rgbToHsl(r, g, b) {
+        r = this.bound01(r, 255);
+        g = this.bound01(g, 255);
+        b = this.bound01(b, 255);
+        let max = mathMax(r, g, b), min = mathMin(r, g, b);
+        let h, s, l = (max + min) / 2;
+        if (max == min) {
+            h = s = 0; // achromatic
+        }
+        else {
+            let d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+            switch (max) {
+                case r:
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                    break;
+                case g:
+                    h = (b - r) / d + 2;
+                    break;
+                case b:
+                    h = (r - g) / d + 4;
+                    break;
+            }
+            h /= 6;
+        }
+        return { h: h, s: s, l: l };
+    }
+    rgbToHsv(r, g, b) {
+        r = this.bound01(r, 255);
+        g = this.bound01(g, 255);
+        b = this.bound01(b, 255);
+        let max = mathMax(r, g, b), min = mathMin(r, g, b);
+        let h, s, v = max;
+        let d = max - min;
+        s = max === 0 ? 0 : d / max;
+        if (max == min) {
+            h = 0; // achromatic
+        }
+        else {
+            switch (max) {
+                case r:
+                    h = (g - b) / d + (g < b ? 6 : 0);
+                    break;
+                case g:
+                    h = (b - r) / d + 2;
+                    break;
+                case b:
+                    h = (r - g) / d + 4;
+                    break;
+            }
+            h /= 6;
+        }
+        return { h: h, s: s, v: v };
+    }
+    rgbToHex(r, g, b, allow3Char) {
+        let hex = [this.pad2(mathRound(r).toString(16)), this.pad2(mathRound(g).toString(16)), this.pad2(mathRound(b).toString(16))];
+        // Return a 3 character hex if possible
+        if (allow3Char &&
+            hex[0].charAt(0) == hex[0].charAt(1) &&
+            hex[1].charAt(0) == hex[1].charAt(1) &&
+            hex[2].charAt(0) == hex[2].charAt(1)) {
+            return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+        }
+        return hex.join('');
+    }
+    rgbaToHex(r, g, b, a, allow4Char) {
+        let hex = [
+            this.pad2(mathRound(r).toString(16)),
+            this.pad2(mathRound(g).toString(16)),
+            this.pad2(mathRound(b).toString(16)),
+            this.pad2(this.convertDecimalToHex('' + a)),
+        ];
+        // Return a 4 character hex if possible
+        if (allow4Char &&
+            hex[0].charAt(0) == hex[0].charAt(1) &&
+            hex[1].charAt(0) == hex[1].charAt(1) &&
+            hex[2].charAt(0) == hex[2].charAt(1) &&
+            hex[3].charAt(0) == hex[3].charAt(1)) {
+            return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
+        }
+        return hex.join('');
+    }
+    rgbaToArgbHex(r, g, b, a) {
+        let hex = [
+            this.pad2(this.convertDecimalToHex('' + a)),
+            this.pad2(mathRound(r).toString(16)),
+            this.pad2(mathRound(g).toString(16)),
+            this.pad2(mathRound(b).toString(16)),
+        ];
+        return hex.join('');
+    }
+    static convertToPercentage(n) {
+        if (n <= 1) {
+            n = n * 100 + '%';
+        }
+        return n;
+    }
+    boundAlpha(a) {
+        a = parseFloat(a);
+        if (isNaN(a) || a < 0 || a > 1) {
+            a = 1;
+        }
+        return a;
+    }
+    inputToRGB(color) {
+        let rgb = { r: 0, g: 0, b: 0 };
+        let a = 1;
+        let s = null;
+        let v = null;
+        let l = null;
+        let ok = false;
+        let format = '';
+        if (color === null) {
+            color = '';
+        }
+        if (typeof color == 'string') {
+            color = this.stringInputToObject(color);
+        }
+        if (typeof color == 'object') {
+            if (this.isValidCSSUnit(color.r) && this.isValidCSSUnit(color.g) && this.isValidCSSUnit(color.b)) {
+                rgb = this.rgbToRgb(color.r, color.g, color.b);
+                ok = true;
+                format = String(color.r).substr(-1) === '%' ? 'prgb' : 'rgb';
+            }
+            else if (this.isValidCSSUnit(color.h) && this.isValidCSSUnit(color.s) && this.isValidCSSUnit(color.v)) {
+                s = TinyColor.convertToPercentage(color.s);
+                v = TinyColor.convertToPercentage(color.v);
+                rgb = this.hsvToRgb(color.h, s, v);
+                ok = true;
+                format = 'hsv';
+            }
+            else if (this.isValidCSSUnit(color.h) && this.isValidCSSUnit(color.s) && this.isValidCSSUnit(color.l)) {
+                s = TinyColor.convertToPercentage(color.s);
+                l = TinyColor.convertToPercentage(color.l);
+                rgb = this.hslToRgb(color.h, s, l);
+                ok = true;
+                format = 'hsl';
+            }
+            if (color.hasOwnProperty('a')) {
+                a = color.a;
+            }
+        }
+        a = this.boundAlpha(a);
+        return {
+            ok: ok,
+            format: color.format || format,
+            r: mathMin(255, mathMax(rgb.r, 0)),
+            g: mathMin(255, mathMax(rgb.g, 0)),
+            b: mathMin(255, mathMax(rgb.b, 0)),
+            a: a,
+        };
+    }
+    parseIntFromHex(val) {
+        return parseInt(val, 16);
+    }
+    convertHexToDecimal(h) {
+        return this.parseIntFromHex(h) / 255;
+    }
+    stringInputToObject(color) {
+        color = color.replace(trimLeft, '').replace(trimRight, '').toLowerCase();
+        let named = false;
+        if (this.names[color]) {
+            color = this.names[color];
+            named = true;
+        }
+        else if (color == 'transparent') {
+            return { r: 0, g: 0, b: 0, a: 0, format: 'name' };
+        }
+        // Try to match string input using regular expressions.
+        // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
+        // Just return an object and let the conversion functions handle that.
+        // This way the result will be the same whether the tinycolor is initialized with string or object.
+        let match;
+        if ((match = this.matchers.rgb.exec(color))) {
+            return { r: match[1], g: match[2], b: match[3] };
+        }
+        if ((match = this.matchers.rgba.exec(color))) {
+            return { r: match[1], g: match[2], b: match[3], a: match[4] };
+        }
+        if ((match = this.matchers.hsl.exec(color))) {
+            return { h: match[1], s: match[2], l: match[3] };
+        }
+        if ((match = this.matchers.hsla.exec(color))) {
+            return { h: match[1], s: match[2], l: match[3], a: match[4] };
+        }
+        if ((match = this.matchers.hsv.exec(color))) {
+            return { h: match[1], s: match[2], v: match[3] };
+        }
+        if ((match = this.matchers.hsva.exec(color))) {
+            return { h: match[1], s: match[2], v: match[3], a: match[4] };
+        }
+        if ((match = this.matchers.hex8.exec(color))) {
+            return {
+                r: this.parseIntFromHex(match[1]),
+                g: this.parseIntFromHex(match[2]),
+                b: this.parseIntFromHex(match[3]),
+                a: this.convertHexToDecimal(match[4]),
+                format: named ? 'name' : 'hex8',
+            };
+        }
+        if ((match = this.matchers.hex6.exec(color))) {
+            return {
+                r: this.parseIntFromHex(match[1]),
+                g: this.parseIntFromHex(match[2]),
+                b: this.parseIntFromHex(match[3]),
+                format: named ? 'name' : 'hex',
+            };
+        }
+        if ((match = this.matchers.hex4.exec(color))) {
+            return {
+                r: this.parseIntFromHex(match[1] + '' + match[1]),
+                g: this.parseIntFromHex(match[2] + '' + match[2]),
+                b: this.parseIntFromHex(match[3] + '' + match[3]),
+                a: this.convertHexToDecimal(match[4] + '' + match[4]),
+                format: named ? 'name' : 'hex8',
+            };
+        }
+        if ((match = this.matchers.hex3.exec(color))) {
+            return {
+                r: this.parseIntFromHex(match[1] + '' + match[1]),
+                g: this.parseIntFromHex(match[2] + '' + match[2]),
+                b: this.parseIntFromHex(match[3] + '' + match[3]),
+                format: named ? 'name' : 'hex',
+            };
+        }
+        return false;
+    }
+    static validateWCAG2Parms(parms) {
+        // return valid WCAG2 parms for isReadable.
+        // If input parms are invalid, return {"level":"AA", "size":"small"}
+        let level, size;
+        parms = parms || { level: 'AA', size: 'small' };
+        level = (parms.level || 'AA').toUpperCase();
+        size = (parms.size || 'small').toLowerCase();
+        if (level !== 'AA' && level !== 'AAA') {
+            level = 'AA';
+        }
+        if (size !== 'small' && size !== 'large') {
+            size = 'small';
+        }
+        return { level: level, size: size };
+    }
+}
+
+exports.Num = Num;
+exports.TinyColor = TinyColor;
+exports.addPx = addPx;
+exports.assignObject = assignObject;
+exports.browserEngine = browserEngine;
+exports.copyFileOrDir = copyFileOrDir;
+exports.createDir = createDir;
+exports.createHttp = createHttp;
+exports.exitFullscreen = exitFullscreen;
+exports.expose = expose;
+exports.filter = filter;
+exports.findFiles = findFiles;
+exports.fullscreen = fullscreen;
+exports.getDate = getDate;
+exports.getObject = getObject;
+exports.getSpecialDate = getSpecialDate;
+exports.getTime = getTime;
+exports.inFullscreen = inFullscreen;
+exports.isFullscreen = isFullscreen;
+exports.isUrl = isUrl;
+exports.on = on;
+exports.pathToHump = pathToHump;
+exports.query = query;
+exports.readDir = readDir;
+exports.readFile = readFile;
+exports.relation = relation;
+exports.removeFileOrDir = removeFileOrDir;
+exports.setTime = setTime;
+exports.setValue = setValue;
+exports.toHump = toHump;
+exports.toHyphen = toHyphen;
+exports.urlToData = urlToData;
+exports.writeFile = writeFile;