@maiyunnet/kebab 2.0.0

package/lib/text.js

@@ -0,0 +1,452 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGEXP_ASCII = exports.REGEXP_DOMAIN = exports.REGEXP_IPV6 = exports.REGEXP_IPV4 = exports.REGEXP_EMAIL = void 0;
+exports.sizeFormat = sizeFormat;
+exports.parseUrl = parseUrl;
+exports.urlResolve = urlResolve;
+exports.urlAtom = urlAtom;
+exports.isEMail = isEMail;
+exports.isIPv4 = isIPv4;
+exports.isIPv6 = isIPv6;
+exports.isDomain = isDomain;
+exports.isAscii = isAscii;
+exports.nlReplace = nlReplace;
+exports.parseDomain = parseDomain;
+exports.match = match;
+exports.isPhoneCN = isPhoneCN;
+exports.isIdCardCN = isIdCardCN;
+exports.queryStringify = queryStringify;
+exports.queryParse = queryParse;
+exports.htmlescape = htmlescape;
+exports.isRealPath = isRealPath;
+exports.getFilename = getFilename;
+exports.stringifyResult = stringifyResult;
+exports.parseJson = parseJson;
+exports.stringifyJson = stringifyJson;
+exports.str2int = str2int;
+exports.int2str = int2str;
+const kebab = __importStar(require("~/index"));
+const fs = __importStar(require("./fs"));
+function sizeFormat(size, spliter = ' ') {
+    const units = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    let i = 0;
+    for (; i < 6 && size >= 1024.0; ++i) {
+        size /= 1024.0;
+    }
+    return (Math.round(size * 100) / 100).toString() + spliter + units[i];
+}
+function parseUrl(url) {
+    const rtn = {
+        'protocol': null,
+        'auth': null,
+        'user': null,
+        'pass': null,
+        'host': null,
+        'hostname': null,
+        'port': null,
+        'pathname': '/',
+        'path': null,
+        'query': null,
+        'hash': null
+    };
+    const hash = url.indexOf('#');
+    if (hash > -1) {
+        rtn['hash'] = url.slice(hash + 1);
+        url = url.slice(0, hash);
+    }
+    const query = url.indexOf('?');
+    if (query > -1) {
+        rtn['query'] = url.slice(query + 1);
+        url = url.slice(0, query);
+    }
+    const protocol = url.indexOf(':');
+    if (protocol > -1) {
+        rtn['protocol'] = url.slice(0, protocol + 1).toLowerCase();
+        url = url.slice(protocol + 1);
+        if (url.startsWith('//')) {
+            url = url.slice(2);
+        }
+        let path = url.indexOf('/');
+        if (path === -1) {
+            path = url.indexOf('\\');
+        }
+        if (path > -1) {
+            rtn['pathname'] = url.slice(path);
+            url = url.slice(0, path);
+        }
+        const auth = url.indexOf('@');
+        if (auth > -1) {
+            const authStr = url.slice(0, auth);
+            const authSplit = authStr.indexOf(':');
+            if (authSplit > -1) {
+                rtn['user'] = authStr.slice(0, authSplit);
+                rtn['pass'] = authStr.slice(authSplit + 1);
+                rtn['auth'] = rtn['user'] + ':' + rtn['pass'];
+            }
+            else {
+                rtn['user'] = authStr;
+                rtn['auth'] = authStr;
+            }
+            url = url.slice(auth + 1);
+        }
+        if (url) {
+            const port = url.indexOf(':');
+            if (port > -1) {
+                rtn['hostname'] = url.slice(0, port).toLowerCase();
+                rtn['port'] = url.slice(port + 1);
+                rtn['host'] = rtn['hostname'] + (rtn['port'] ? ':' + rtn['port'] : '');
+            }
+            else {
+                rtn['hostname'] = url.toLowerCase();
+                rtn['host'] = rtn['hostname'];
+            }
+        }
+    }
+    else {
+        rtn['pathname'] = url;
+    }
+    rtn['path'] = rtn['pathname'] + (rtn['query'] ? '?' + rtn['query'] : '');
+    return rtn;
+}
+function urlResolve(from, to) {
+    from = from.replace('\\', '/');
+    to = to.replace('\\', '/');
+    if (to === '') {
+        return urlAtom(from);
+    }
+    const f = parseUrl(from);
+    if (to.startsWith('//')) {
+        return urlAtom(f.protocol ? f.protocol + to : to);
+    }
+    if (f.protocol) {
+        from = f.protocol + from.slice(f.protocol.length);
+    }
+    const t = parseUrl(to);
+    if (t.protocol) {
+        return urlAtom(t.protocol + to.slice(t.protocol.length));
+    }
+    if (to.startsWith('#') || to.startsWith('?')) {
+        const sp = from.indexOf(to[0]);
+        if (sp !== -1) {
+            return urlAtom(from.slice(0, sp) + to);
+        }
+        else {
+            return urlAtom(from + to);
+        }
+    }
+    let abs = (f.auth ? f.auth + '@' : '') + (f.host ?? '');
+    if (to.startsWith('/')) {
+        abs += to;
+    }
+    else {
+        const path = f.pathname.replace(/\/[^/]*$/g, '');
+        abs += path + '/' + to;
+    }
+    if (f.protocol && (f.protocol !== 'file:') && !f.host) {
+        return urlAtom(f.protocol + abs);
+    }
+    else {
+        return urlAtom((f.protocol ? f.protocol + '//' : '') + abs);
+    }
+}
+function urlAtom(url) {
+    while (url.includes('/./')) {
+        url = url.replace(/\/\.\//g, '/');
+    }
+    while (/\/(?!\.\.)[^/]+\/\.\.\//.test(url)) {
+        url = url.replace(/\/(?!\.\.)[^/]+\/\.\.\//g, '/');
+    }
+    url = url.replace(/\.\.\//g, '');
+    return url;
+}
+exports.REGEXP_EMAIL = /^[-_\w.]+@[-_\w.]+\.([a-zA-Z]+)$/i;
+function isEMail(email) {
+    return exports.REGEXP_EMAIL.test(email);
+}
+exports.REGEXP_IPV4 = /^[0-9]{1,3}(\.[0-9]{1,3}){3}$/i;
+function isIPv4(ip) {
+    return exports.REGEXP_IPV4.test(ip);
+}
+exports.REGEXP_IPV6 = /^(\w*?:){2,7}[\w.]*$/i;
+function isIPv6(ip) {
+    return exports.REGEXP_IPV6.test(ip + ':');
+}
+exports.REGEXP_DOMAIN = /^.+?\.((?![0-9]).)+$/i;
+function isDomain(domain) {
+    return exports.REGEXP_DOMAIN.test(domain);
+}
+exports.REGEXP_ASCII = /^[\x20-\x7E]*$/;
+function isAscii(text) {
+    return exports.REGEXP_ASCII.test(text);
+}
+function nlReplace(str, to = '\n') {
+    str = str.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    if (to !== '\n') {
+        str = str.replace(/\n/g, to);
+    }
+    return str;
+}
+let tldList;
+async function parseDomain(domain) {
+    const rtn = {
+        tld: null,
+        sld: null,
+        domain: null,
+        sub: null
+    };
+    if (!isDomain(domain)) {
+        return rtn;
+    }
+    const arr = domain.split('.');
+    if (arr.length === 1) {
+        rtn.tld = arr[0].toLowerCase();
+        rtn.domain = rtn.tld;
+    }
+    else {
+        if (!tldList) {
+            tldList = JSON.parse(await fs.getContent(kebab.LIB_PATH + 'text/tld.json', 'utf8') ?? '[]');
+        }
+        const last2 = (arr[arr.length - 2] + '.' + arr[arr.length - 1]).toLowerCase();
+        if (tldList.includes(last2)) {
+            rtn.tld = last2;
+            if (arr.length === 2) {
+                rtn.domain = last2;
+                return rtn;
+            }
+            rtn.sld = arr[arr.length - 3].toLowerCase();
+            rtn.domain = rtn.sld + '.' + rtn.tld;
+            if (arr.length === 3) {
+                return rtn;
+            }
+            arr.splice(-3);
+            rtn.sub = arr.join('.').toLowerCase();
+        }
+        else {
+            rtn.tld = arr[arr.length - 1].toLowerCase();
+            rtn.sld = arr[arr.length - 2].toLowerCase();
+            rtn.domain = rtn.sld + '.' + rtn.tld;
+            if (arr.length === 2) {
+                return rtn;
+            }
+            arr.splice(-2);
+            rtn.sub = arr.join('.').toLowerCase();
+        }
+    }
+    return rtn;
+}
+function match(str, regs) {
+    for (const reg of regs) {
+        if (reg.test(str)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isPhoneCN(p) {
+    return /^1[0-9]{10}$/.test(p);
+}
+function isIdCardCN(idcard) {
+    if (idcard.length !== 18) {
+        return false;
+    }
+    const idcardBase = idcard.slice(0, 17);
+    const verifyCode = idcard.slice(17, 18);
+    const factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+    const verifyCodeList = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2'];
+    let total = BigInt(0);
+    for (let i = 0; i < 17; i++) {
+        total += BigInt(idcardBase.slice(i, i + 1)) * BigInt(factor[i]);
+    }
+    const mod = total % BigInt(11);
+    if (verifyCode === verifyCodeList[Number(mod)]) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function queryStringify(query, encode = true) {
+    if (encode) {
+        return Object.entries(query).map(([k, v]) => {
+            if (Array.isArray(v)) {
+                return v.map((i) => `${encodeURIComponent(k)}=${encodeURIComponent(i)}`).join('&');
+            }
+            return `${encodeURIComponent(k)}=${encodeURIComponent(v)}`;
+        }).join('&');
+    }
+    return Object.entries(query).map(([k, v]) => {
+        if (Array.isArray(v)) {
+            return v.map((i) => `${k}=${i}}`).join('&');
+        }
+        return `${k}=${v}`;
+    }).join('&');
+}
+function queryParse(query) {
+    const ret = {};
+    const arrayKeys = {};
+    const arr = query.split('&');
+    for (const i of arr) {
+        if (!i.length) {
+            continue;
+        }
+        const pos = i.indexOf('=');
+        const key = decodeURIComponent(pos === -1 ? i : i.slice(0, pos));
+        let value = '';
+        try {
+            value = pos === -1 ? '' : decodeURIComponent(i.slice(pos + 1));
+        }
+        catch {
+            value = pos === -1 ? '' : i.slice(pos + 1);
+        }
+        if (arrayKeys[key]) {
+            ret[key].push(value);
+        }
+        else if (undefined === ret[key]) {
+            ret[key] = value;
+        }
+        else {
+            ret[key] = [ret[key], value];
+            arrayKeys[key] = true;
+        }
+    }
+    return ret;
+}
+function htmlescape(html) {
+    const type = typeof html;
+    if (type !== 'string') {
+        return '[' + type + ']';
+    }
+    return html.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/'/g, '&quot;');
+}
+function isRealPath(path) {
+    path = path.replace(/\\/g, '/');
+    if (path.startsWith('/')) {
+        return true;
+    }
+    return /[a-z]+:/i.test(path.split('/')[0]) ? true : false;
+}
+function getFilename(path) {
+    path = path.replace(/\\/g, '/');
+    const lio = path.lastIndexOf('/');
+    if (lio === -1) {
+        return path;
+    }
+    return path.slice(lio + 1);
+}
+function stringifyResult(rtn) {
+    if (Array.isArray(rtn)) {
+        if (rtn.length === 0) {
+            return JSON.stringify({
+                'result': 0,
+                'msg': 'ERROR'
+            });
+        }
+        if (typeof rtn[0] === 'number') {
+            const json = { 'result': rtn[0] };
+            if (rtn[1] !== undefined) {
+                if (typeof rtn[1] === 'object') {
+                    for (let i = 1; i < rtn.length; ++i) {
+                        Object.assign(json, rtn[i]);
+                    }
+                }
+                else {
+                    json['msg'] = rtn[1];
+                    for (let i = 2; i < rtn.length; ++i) {
+                        Object.assign(json, rtn[i]);
+                    }
+                }
+            }
+            return JSON.stringify(json);
+        }
+        return JSON.stringify(rtn);
+    }
+    return JSON.stringify(rtn);
+}
+function parseJson(str) {
+    try {
+        str = str.replace(/("[\w-]+?" *: *)([-+0-9]+)([ \r\n]*[,}]|$)/g, (v, v1, v2, v3) => {
+            return v1 + '"-mybigint-' + v2 + '"' + v3;
+        });
+        return JSON.parse(str, (k, v) => {
+            if (typeof v !== 'string') {
+                return v;
+            }
+            if (!v.startsWith('-mybigint-')) {
+                return v;
+            }
+            const ints = v.slice(10);
+            const int = parseInt(ints);
+            if (int <= Number.MAX_SAFE_INTEGER) {
+                return int;
+            }
+            return BigInt(ints);
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function stringifyJson(obj, space) {
+    return JSON.stringify(obj, (k, v) => {
+        if (typeof v === 'bigint') {
+            return '-mybigint-' + v.toString();
+        }
+        return v;
+    }, space).replace(/"-mybigint-([-+0-9]+?)"/g, '$1');
+}
+function str2int(str, digits = 3) {
+    const num = parseFloat(str);
+    const factor = Math.pow(10, digits);
+    return Math.round(num * factor);
+}
+function int2str(int, digits = 4, decimal = 2) {
+    const sign = int < 0 ? '-' : '';
+    const absInt = Math.abs(int);
+    let intStr = absInt.toString();
+    while (intStr.length < digits + 1) {
+        intStr = '0' + intStr;
+    }
+    const intPart = intStr.slice(0, intStr.length - digits);
+    const decPart = intStr.slice(intStr.length - digits);
+    const decNum = parseInt(decPart);
+    const div = Math.pow(10, digits - decimal);
+    const round = Math.round(decNum / div);
+    const carry = Math.floor(round / Math.pow(10, decimal));
+    const newDecPart = round % Math.pow(10, decimal);
+    const intNum = parseInt(intPart, 10) + carry;
+    const decResult = newDecPart.toString().padStart(decimal, '0');
+    return `${sign}${intNum}${decResult ? `.${decResult}` : ''}`;
+}