@vope/utils 1.4.5 → 1.4.6

package/cjs/index.js

@@ -25,30 +25,35 @@ __export(src_exports, {
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
   Union: () => Union,
-  clamp: () => clamp_default,
-  classnames: () => classnames_default,
-  compareVersion: () => version_default,
-  connectURLParams: () => params_default,
-  deconPowersSum: () => decon_default,
-  deepWeakEqual: () => weak_equal_default,
-  getEncoding: () => encoding_default,
-  hash8json: () => json_default,
-  hash8object: () => object_default,
-  hash8strings: () => strings_default,
-  inputRegex: () => input_regex_default,
-  isClass: () => class_default,
-  isEmpty: () => empty_default,
-  isNull: () => null_default,
-  joinPaths: () => join_default,
-  once: () => once_default,
-  rotateAngle: () => angle_default,
-  rotateRad: () => rad_default,
-  wait: () => wait_default
+  clamp: () => clamp,
+  classnames: () => classnames,
+  compareVersion: () => compareVersion,
+  connectURLParams: () => connectURLParams,
+  css: () => css,
+  deconPowersSum: () => deconPowersSum,
+  deepWeakEqual: () => deepWeakEqual,
+  desensDecrypt: () => desensDecrypt,
+  desensEncrypt: () => desensEncrypt,
+  desensReplace: () => desensReplace,
+  getEncoding: () => getEncoding,
+  hash8json: () => hash8json,
+  hash8object: () => hash8object,
+  hash8strings: () => hash8strings,
+  inputRegex: () => inputRegex,
+  isClass: () => isClass,
+  isEmpty: () => isEmpty,
+  isNull: () => isNull,
+  joinPaths: () => joinPaths,
+  loadImage: () => loadImage,
+  once: () => once,
+  rotateAngle: () => rotateAngle,
+  rotateRad: () => rotateRad,
+  wait: () => wait
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/clamp.ts
-var clamp_default = (value, min, max) => {
+var clamp = (value, min, max) => {
   if (min > max) {
     const swap = max;
     max = min;
@@ -60,7 +65,7 @@ var clamp_default = (value, min, max) => {
 // src/classnames.ts
 var import_lodash_es = require("lodash-es");
 var add = (a, b) => a ? a + " " + b : b;
-var classnames_default = (...list) => list.reduce((caches, data) => {
+var classnames = (...list) => list.reduce((caches, data) => {
   if ((0, import_lodash_es.isString)(data)) {
     data && (caches = add(caches, data));
   } else if (Array.isArray(data)) {
@@ -88,7 +93,6 @@ var compareVersion = (from, to) => {
   }
   return 0;
 };
-var version_default = compareVersion;
 
 // src/compare/weak-equal.ts
 var deepWeakEqual = (from, to) => {
@@ -121,28 +125,72 @@ var deepWeakEqual = (from, to) => {
   }
   return true;
 };
-var weak_equal_default = deepWeakEqual;
 
 // src/convert/json.ts
 var hash8json = (list, key) => list.reduce((caches, data) => {
   caches[data[key]] = data;
   return caches;
 }, {});
-var json_default = hash8json;
 
 // src/convert/object.ts
 var hash8object = (list, key) => list.reduce((caches, data) => {
   caches.set(data[key], data);
   return caches;
 }, /* @__PURE__ */ new Map());
-var object_default = hash8object;
 
 // src/convert/strings.ts
 var hash8strings = (list) => list.reduce((caches, data, index) => {
   caches[data] = index;
   return caches;
 }, {});
-var strings_default = hash8strings;
+
+// src/desens.ts
+var import_lodash_es2 = require("lodash-es");
+var 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
+  };
+};
+var 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);
+};
+var 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_es2.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);
+};
 
 // src/encoding.ts
 var utf8_first_prefix = /^1{2,}/g;
@@ -153,28 +201,29 @@ var Encodes = {
   UTF_16BE: "utf-16be",
   GBK: "gbk"
 };
-var defaults = {
-  utf8: [239, 187, 191]
+var BOM = {
+  UTF_8: [239, 187, 191],
+  UTF_16LE: [255, 254],
+  UTF_16BE: [254, 255]
 };
 var equal = (uint, list) => {
-  if (uint.length !== list.length)
-    return false;
-  return !uint.some((value, index) => value !== list[index]);
+  return uint.length === list.length ? !uint.some((value, index) => value !== list[index]) : false;
 };
 var getEncoding = (uint, limit = 1024) => {
   let encoding;
   let offset = 0;
-  if (equal(uint.slice(0, 3), defaults.utf8)) {
-    offset = defaults.utf8.length;
-    encoding = Encodes.UTF_8;
-  } else if (equal(uint.slice(0, 2), [255, 254])) {
-    encoding = Encodes.UTF_16LE;
-  } else if (equal(uint.slice(0, 2), [254, 255])) {
-    encoding = Encodes.UTF_16BE;
-  } else {
+  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; i < Math.min(uint.length, limit); i++) {
+      for (let i = 0, max = Math.min(uint.length, limit); i < max; i++) {
         const data = uint[i];
         if (data < 128)
           continue;
@@ -198,7 +247,6 @@ var getEncoding = (uint, limit = 1024) => {
   }
   return { encoding, offset };
 };
-var encoding_default = getEncoding;
 
 // src/input-regex.ts
 var RE_REGEX = /[$()*+.[?\\^{|]/g;
@@ -206,7 +254,6 @@ var RE_STRING = /[$()*+.[?\\^{|-]/g;
 function inputRegex(text, flags) {
   return flags === false ? text.replace(RE_STRING, ($0) => "\\" + $0) : new RegExp(text.replace(RE_REGEX, ($0) => "\\" + $0), flags);
 }
-var input_regex_default = inputRegex;
 
 // src/is/class.ts
 var re_anonymous = /^function\s+\(|^function\s+anonymous\(/;
@@ -234,15 +281,22 @@ var isClass = (value, strict = true) => {
   }
   return false;
 };
-var class_default = isClass;
 
 // src/is/null.ts
 var isNull = (value) => value === void 0 || value === null;
-var null_default = isNull;
 
 // src/is/empty.ts
-var isEmpty = (value) => null_default(value) || value === "";
-var empty_default = isEmpty;
+var isEmpty = (value) => isNull(value) || value === "";
+
+// src/load/image.ts
+var loadImage = (src) => {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(null);
+    img.src = src;
+  });
+};
 
 // src/memory/basic.ts
 var MemoryBasic = class {
@@ -361,7 +415,7 @@ var MemoryBasic = class {
     const { memorys, list } = this;
     if (!memorys.has(type))
       return this;
-    const local = strings_default(this.#reflex(memorys.get(type)));
+    const local = hash8strings(this.#reflex(memorys.get(type)));
     const Memory = this.constructor;
     const imitator = new Memory(this.key);
     list.forEach((data, index) => {
@@ -410,20 +464,19 @@ var deconPowersSum = (sum, sort) => {
   }
   return sort === "asc" ? list.reverse() : list;
 };
-var decon_default = deconPowersSum;
 
 // src/memory/power.ts
 var MemoryPower = class extends MemoryBasic {
   constructor(key) {
     super(key, {
       mount: (index, reactor) => (reactor || 0) + 2 ** index,
-      reflex: (reactor) => decon_default(reactor, "asc")
+      reflex: (reactor) => deconPowersSum(reactor, "asc")
     });
   }
 };
 
 // src/once.ts
-var once_default = (func, thisArg) => {
+var once = (func, thisArg) => {
   let local;
   let inited = false;
   return (...list) => inited ? local : (inited = true, local = func.apply(thisArg, list));
@@ -438,11 +491,33 @@ var rotateRad = (from, rad, visit = [0, 0]) => {
     y * Math.cos(rad) - x * Math.sin(rad) + visit[1]
   ];
 };
-var rad_default = rotateRad;
 
 // src/rotate/angle.ts
-var rotateAngle = (from, angle, visit) => rad_default(from, angle / 180 * Math.PI, visit);
-var angle_default = rotateAngle;
+var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
+
+// src/style/css.ts
+var import_lodash_es3 = require("lodash-es");
+var hump = /[A-Z]/g;
+var css = (...args) => {
+  const list = [];
+  for (let i = 0; i < args.length; i++) {
+    const data = args[i];
+    if (!data)
+      continue;
+    if ((0, import_lodash_es3.isString)(data)) {
+      list.push(data);
+    } else if (Array.isArray(data)) {
+      const result = css(...data);
+      result && list.push(result);
+    } else {
+      for (const key in data) {
+        const value = data[key];
+        isNull(value) || list.push(`${key.replace(hump, ($0) => "-" + $0.toLocaleLowerCase())}: ${value}`);
+      }
+    }
+  }
+  return list.join(";");
+};
 
 // src/table/flex.ts
 var FlexTable = class {
@@ -575,7 +650,6 @@ var joinPaths = (...list) => {
     return "";
   return length === 1 ? list[0] : list.join("/").replace(re, ($0, $1) => `${$1}/`);
 };
-var join_default = joinPaths;
 
 // src/url/params.ts
 var connectURLParams = (url, params, isOpenType) => {
@@ -599,7 +673,6 @@ var connectURLParams = (url, params, isOpenType) => {
   const caches = list.join("&");
   return url.includes("?") ? url + "&" + caches : url + "?" + caches;
 };
-var params_default = connectURLParams;
 
 // src/wait.ts
-var wait_default = (delay = 0) => new Promise((resolve) => setTimeout(resolve, delay));
+var wait = (delay = 0) => new Promise((resolve) => setTimeout(resolve, delay));

package/lib/clamp.js

@@ -1,4 +1,4 @@
-var clamp_default = (value, min, max) => {
+const clamp = (value, min, max) => {
   if (min > max) {
     const swap = max;
     max = min;
@@ -7,5 +7,5 @@ var clamp_default = (value, min, max) => {
   return Math.min(max, Math.max(min, value));
 };
 export {
-  clamp_default as default
+  clamp
 };

package/lib/classnames.js

@@ -1,6 +1,6 @@
 import { isBoolean, isString } from "lodash-es";
 const add = (a, b) => a ? a + " " + b : b;
-var classnames_default = (...list) => list.reduce((caches, data) => {
+const classnames = (...list) => list.reduce((caches, data) => {
   if (isString(data)) {
     data && (caches = add(caches, data));
   } else if (Array.isArray(data)) {
@@ -13,5 +13,5 @@ var classnames_default = (...list) => list.reduce((caches, data) => {
   return caches;
 }, "");
 export {
-  classnames_default as default
+  classnames
 };

package/lib/compare/version.js

@@ -12,7 +12,6 @@ const compareVersion = (from, to) => {
   }
   return 0;
 };
-var version_default = compareVersion;
 export {
-  version_default as default
+  compareVersion
 };

package/lib/compare/weak-equal.js

@@ -28,7 +28,6 @@ const deepWeakEqual = (from, to) => {
   }
   return true;
 };
-var weak_equal_default = deepWeakEqual;
 export {
-  weak_equal_default as default
+  deepWeakEqual
 };

package/lib/convert/json.js

@@ -2,7 +2,6 @@ const hash8json = (list, key) => list.reduce((caches, data) => {
   caches[data[key]] = data;
   return caches;
 }, {});
-var json_default = hash8json;
 export {
-  json_default as default
+  hash8json
 };

package/lib/convert/object.js

@@ -2,7 +2,6 @@ const hash8object = (list, key) => list.reduce((caches, data) => {
   caches.set(data[key], data);
   return caches;
 }, /* @__PURE__ */ new Map());
-var object_default = hash8object;
 export {
-  object_default as default
+  hash8object
 };

package/lib/convert/strings.js

@@ -2,7 +2,6 @@ const hash8strings = (list) => list.reduce((caches, data, index) => {
   caches[data] = index;
   return caches;
 }, {});
-var strings_default = hash8strings;
 export {
-  strings_default as default
+  hash8strings
 };

package/lib/desens.js

@@ -0,0 +1,51 @@
+import { isString } from "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 = 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);
+};
+export {
+  desensDecrypt,
+  desensEncrypt,
+  desensReplace
+};

package/lib/encoding.js

@@ -6,28 +6,29 @@ const Encodes = {
   UTF_16BE: "utf-16be",
   GBK: "gbk"
 };
-const defaults = {
-  utf8: [239, 187, 191]
+const BOM = {
+  UTF_8: [239, 187, 191],
+  UTF_16LE: [255, 254],
+  UTF_16BE: [254, 255]
 };
 const equal = (uint, list) => {
-  if (uint.length !== list.length)
-    return false;
-  return !uint.some((value, index) => value !== list[index]);
+  return uint.length === list.length ? !uint.some((value, index) => value !== list[index]) : false;
 };
 const getEncoding = (uint, limit = 1024) => {
   let encoding;
   let offset = 0;
-  if (equal(uint.slice(0, 3), defaults.utf8)) {
-    offset = defaults.utf8.length;
-    encoding = Encodes.UTF_8;
-  } else if (equal(uint.slice(0, 2), [255, 254])) {
-    encoding = Encodes.UTF_16LE;
-  } else if (equal(uint.slice(0, 2), [254, 255])) {
-    encoding = Encodes.UTF_16BE;
-  } else {
+  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; i < Math.min(uint.length, limit); i++) {
+      for (let i = 0, max = Math.min(uint.length, limit); i < max; i++) {
         const data = uint[i];
         if (data < 128)
           continue;
@@ -51,7 +52,6 @@ const getEncoding = (uint, limit = 1024) => {
   }
   return { encoding, offset };
 };
-var encoding_default = getEncoding;
 export {
-  encoding_default as default
+  getEncoding
 };

package/lib/index.js

@@ -1,50 +1,58 @@
-import { default as default2 } from "./clamp";
-import { default as default3 } from "./classnames";
-import { default as default4 } from "./compare/version";
-import { default as default5 } from "./compare/weak-equal";
-import { default as default6 } from "./convert/json";
-import { default as default7 } from "./convert/object";
-import { default as default8 } from "./convert/strings";
-import { default as default9 } from "./encoding";
-import { default as default10 } from "./input-regex";
-import { default as default11 } from "./is/class";
-import { default as default12 } from "./is/empty";
-import { default as default13 } from "./is/null";
-import { default as default14 } from "./memory/basic";
-import { default as default15 } from "./memory/list";
-import { default as default16 } from "./memory/power";
-import { default as default17 } from "./once";
-import { default as default18 } from "./power/decon";
-import { default as default19 } from "./rotate/angle";
-import { default as default20 } from "./rotate/rad";
-import { default as default21 } from "./table/flex";
-import { default as default22 } from "./union";
-import { default as default23 } from "./url/join";
-import { default as default24 } from "./url/params";
-import { default as default25 } from "./wait";
+import { clamp } from "./clamp";
+import { classnames } from "./classnames";
+import { compareVersion } from "./compare/version";
+import { deepWeakEqual } from "./compare/weak-equal";
+import { hash8json } from "./convert/json";
+import { hash8object } from "./convert/object";
+import { hash8strings } from "./convert/strings";
+import { desensEncrypt, desensDecrypt, desensReplace } from "./desens";
+import { getEncoding } from "./encoding";
+import { inputRegex } from "./input-regex";
+import { isClass } from "./is/class";
+import { isEmpty } from "./is/empty";
+import { isNull } from "./is/null";
+import { loadImage } from "./load/image";
+import { MemoryBasic } from "./memory/basic";
+import { MemoryList } from "./memory/list";
+import { MemoryPower } from "./memory/power";
+import { once } from "./once";
+import { deconPowersSum } from "./power/decon";
+import { rotateAngle } from "./rotate/angle";
+import { rotateRad } from "./rotate/rad";
+import { css } from "./style/css";
+import { FlexTable } from "./table/flex";
+import { Union } from "./union";
+import { joinPaths } from "./url/join";
+import { connectURLParams } from "./url/params";
+import { wait } from "./wait";
 export {
-  default21 as FlexTable,
-  default14 as MemoryBasic,
-  default15 as MemoryList,
-  default16 as MemoryPower,
-  default22 as Union,
-  default2 as clamp,
-  default3 as classnames,
-  default4 as compareVersion,
-  default24 as connectURLParams,
-  default18 as deconPowersSum,
-  default5 as deepWeakEqual,
-  default9 as getEncoding,
-  default6 as hash8json,
-  default7 as hash8object,
-  default8 as hash8strings,
-  default10 as inputRegex,
-  default11 as isClass,
-  default12 as isEmpty,
-  default13 as isNull,
-  default23 as joinPaths,
-  default17 as once,
-  default19 as rotateAngle,
-  default20 as rotateRad,
-  default25 as wait
+  FlexTable,
+  MemoryBasic,
+  MemoryList,
+  MemoryPower,
+  Union,
+  clamp,
+  classnames,
+  compareVersion,
+  connectURLParams,
+  css,
+  deconPowersSum,
+  deepWeakEqual,
+  desensDecrypt,
+  desensEncrypt,
+  desensReplace,
+  getEncoding,
+  hash8json,
+  hash8object,
+  hash8strings,
+  inputRegex,
+  isClass,
+  isEmpty,
+  isNull,
+  joinPaths,
+  loadImage,
+  once,
+  rotateAngle,
+  rotateRad,
+  wait
 };

package/lib/input-regex.js

@@ -3,7 +3,6 @@ const RE_STRING = /[$()*+.[?\\^{|-]/g;
 function inputRegex(text, flags) {
   return flags === false ? text.replace(RE_STRING, ($0) => "\\" + $0) : new RegExp(text.replace(RE_REGEX, ($0) => "\\" + $0), flags);
 }
-var input_regex_default = inputRegex;
 export {
-  input_regex_default as default
+  inputRegex
 };

package/lib/is/class.js

@@ -23,7 +23,6 @@ const isClass = (value, strict = true) => {
   }
   return false;
 };
-var class_default = isClass;
 export {
-  class_default as default
+  isClass
 };

package/lib/is/empty.js

@@ -1,6 +1,5 @@
-import isNull from "./null";
+import { isNull } from "./null";
 const isEmpty = (value) => isNull(value) || value === "";
-var empty_default = isEmpty;
 export {
-  empty_default as default
+  isEmpty
 };

package/lib/is/null.js

@@ -1,5 +1,4 @@
 const isNull = (value) => value === void 0 || value === null;
-var null_default = isNull;
 export {
-  null_default as default
+  isNull
 };

package/lib/load/image.js

@@ -0,0 +1,11 @@
+const loadImage = (src) => {
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = () => resolve(null);
+    img.src = src;
+  });
+};
+export {
+  loadImage
+};