@vope/utils 1.6.0-bate.6 → 1.6.0-bate.7

package/dist/clamp.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clamp_exports = {};
+__export(clamp_exports, {
+  clamp: () => clamp
+});
+module.exports = __toCommonJS(clamp_exports);
+const clamp = (value, min, max) => {
+  if (min > max) {
+    const swap = max;
+    max = min;
+    min = swap;
+  }
+  return Math.min(max, Math.max(min, value));
+};

package/dist/classnames.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var classnames_exports = {};
+__export(classnames_exports, {
+  classnames: () => classnames
+});
+module.exports = __toCommonJS(classnames_exports);
+var import_lodash_es = require("lodash-es");
+const add = (a, b) => a ? a + " " + b : b;
+const classnames = (...list) => list.reduce((caches, data) => {
+  if ((0, import_lodash_es.isString)(data)) {
+    data && (caches = add(caches, data));
+  } else if (Array.isArray(data)) {
+    data.forEach((value) => value && (0, import_lodash_es.isString)(value) && (caches = add(caches, value)));
+  } else if (!(0, import_lodash_es.isBoolean)(data)) {
+    for (const key in data) {
+      key && data[key] && (caches = add(caches, key));
+    }
+  }
+  return caches;
+}, "");

package/dist/compare/version.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var version_exports = {};
+__export(version_exports, {
+  compareVersion: () => compareVersion
+});
+module.exports = __toCommonJS(version_exports);
+const CHAR = ".";
+const compareVersion = (from, to) => {
+  const froms = from.split(CHAR);
+  const tos = to.split(CHAR);
+  for (let i = 0, max = Math.max(froms.length, tos.length); i < max; i++) {
+    const fromV = +froms[i] || 0;
+    const toV = +tos[i] || 0;
+    if (fromV > toV) return -1;
+    if (fromV < toV) return 1;
+  }
+  return 0;
+};

package/dist/compare/weak-equal.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var weak_equal_exports = {};
+__export(weak_equal_exports, {
+  deepWeakEqual: () => deepWeakEqual
+});
+module.exports = __toCommonJS(weak_equal_exports);
+var import_strings = require("../convert/strings");
+const deepWeakEqual = (from, to, exclude) => {
+  if (typeof from !== "object" || from === null || typeof to !== "object" || to === null) return from === to;
+  if (Array.isArray(from) && Array.isArray(to)) {
+    if (from.length !== to.length) return false;
+    return !from.some((t1, index) => {
+      if (!deepWeakEqual(t1, to[index])) {
+        return true;
+      }
+    });
+  } else {
+    const caches = {};
+    const excludeCaches = exclude && (0, import_strings.hash8strings)(exclude);
+    for (const key in from) {
+      if (excludeCaches && key in excludeCaches) continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      } else {
+        caches[key] = key;
+      }
+    }
+    for (const key in to) {
+      if (excludeCaches && key in excludeCaches || key in caches) continue;
+      if (!deepWeakEqual(from[key], to[key])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};

package/dist/convert/json.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_exports = {};
+__export(json_exports, {
+  hash8json: () => hash8json
+});
+module.exports = __toCommonJS(json_exports);
+const hash8json = (list, key) => list.reduce((caches, data) => {
+  caches[data[key]] = data;
+  return caches;
+}, {});

package/dist/convert/object.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var object_exports = {};
+__export(object_exports, {
+  hash8object: () => hash8object
+});
+module.exports = __toCommonJS(object_exports);
+const hash8object = (list, key) => list.reduce((caches, data) => {
+  caches.set(data[key], data);
+  return caches;
+}, /* @__PURE__ */ new Map());

package/dist/convert/strings.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var strings_exports = {};
+__export(strings_exports, {
+  hash8strings: () => hash8strings
+});
+module.exports = __toCommonJS(strings_exports);
+const hash8strings = (list) => list.reduce((caches, data, index) => {
+  caches[data] = index;
+  return caches;
+}, {});

package/dist/desens.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var desens_exports = {};
+__export(desens_exports, {
+  desensDecrypt: () => desensDecrypt,
+  desensEncrypt: () => desensEncrypt,
+  desensReplace: () => desensReplace
+});
+module.exports = __toCommonJS(desens_exports);
+var import_lodash_es = require("lodash-es");
+const desensEncrypt = (plaintext, encrypt) => {
+  const rules = [];
+  let point = -1;
+  let ciphertext = encrypt(plaintext).reduce((cache, { range, ciphertext: ciphertext2 }) => {
+    cache += plaintext.slice(point + 1, range[0]) + ciphertext2;
+    point = range[1];
+    rules.push({
+      range,
+      modify: ciphertext2.length
+    });
+    return cache;
+  }, "");
+  if (point !== -1) {
+    ciphertext += plaintext.slice(point + 1);
+  }
+  return {
+    ciphertext,
+    rules
+  };
+};
+const desensDecrypt = (ciphertext, rules, decrypt) => {
+  Array.isArray(rules) || (rules = [rules]);
+  let offset = 0;
+  let from = 0;
+  return rules.reduce((cache, { range: [start, stop], modify }) => {
+    cache += ciphertext.slice(from, start + offset) + decrypt(ciphertext.slice(start + offset, start + offset + modify));
+    from = start + offset + modify;
+    offset += modify - (stop + 1 - start);
+    return cache;
+  }, "") + ciphertext.slice(from);
+};
+const desensReplace = (ciphertext, rules, replacer = "*") => {
+  Array.isArray(rules) || (rules = [rules]);
+  let offset = 0;
+  let from = 0;
+  return rules.reduce((cache, { range: [start, stop], modify }) => {
+    const part = ciphertext.slice(start + offset, start + offset + modify);
+    const size = stop + 1 - start;
+    const replaceValue = (0, import_lodash_es.isString)(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
+    cache += ciphertext.slice(from, start + offset) + replaceValue;
+    from = start + offset + modify;
+    offset += modify - size;
+    return cache;
+  }, "") + ciphertext.slice(from);
+};

package/dist/encoding.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encoding_exports = {};
+__export(encoding_exports, {
+  getEncoding: () => getEncoding
+});
+module.exports = __toCommonJS(encoding_exports);
+const utf8_first_prefix = /^1{2,}/g;
+const utf8_other_prefix = /^10/;
+const Encodes = {
+  UTF_8: "utf-8",
+  UTF_16LE: "utf-16le",
+  UTF_16BE: "utf-16be",
+  GBK: "gbk"
+};
+const BOM = {
+  UTF_8: [239, 187, 191],
+  UTF_16LE: [255, 254],
+  UTF_16BE: [254, 255]
+};
+const equal = (uint, list) => {
+  return uint.length === list.length ? !uint.some((value, index) => value !== list[index]) : false;
+};
+const getEncoding = (uint, limit = 1024) => {
+  let encoding;
+  let offset = 0;
+  for (const key in BOM) {
+    const head = BOM[key];
+    if (equal(uint.slice(0, head.length), head)) {
+      offset = head.length;
+      encoding = Encodes[key];
+      break;
+    }
+  }
+  if (!encoding) {
+    let isBreak = false;
+    top:
+      for (let i = 0, max = Math.min(uint.length, limit); i < max; i++) {
+        const data = uint[i];
+        if (data < 128) continue;
+        const match = data.toString(2).match(utf8_first_prefix);
+        if (match) {
+          for (let m = 0; m < match[0].length - 1; m++) {
+            const target = uint[++i];
+            if (target == void 0 || !utf8_other_prefix.test(target.toString(2))) {
+              encoding = Encodes.GBK;
+              isBreak = true;
+              break top;
+            }
+          }
+        } else {
+          encoding = Encodes.GBK;
+          isBreak = true;
+          break;
+        }
+      }
+    isBreak || (encoding = Encodes.UTF_8);
+  }
+  return { encoding, offset };
+};