@vope/utils 1.6.7 → 1.7.0

package/dist/index.cjs.js

@@ -36,6 +36,7 @@ __export(index_exports, {
   Union: () => Union,
   WeekLastUnit: () => WeekLastUnit,
   WildcardUnit: () => WildcardUnit,
+  asyncLock: () => async_lock_default,
   calc: () => calc_default,
   clamp: () => clamp,
   classnames: () => classnames,
@@ -61,11 +62,13 @@ __export(index_exports, {
   desensDecrypt: () => desensDecrypt,
   desensEncrypt: () => desensEncrypt,
   desensReplace: () => desensReplace,
+  disableEnumerable: () => disable_enumerable_default,
   flatURLParams: () => flatURLParams,
   getEncoding: () => getEncoding,
   hash8json: () => hash8json,
   hash8object: () => hash8object,
   hash8strings: () => hash8strings,
+  indexSort: () => index_sort_default,
   inputRegex: () => inputRegex,
   isAggUnit: () => isAggUnit,
   isCalc: () => isCalc,
@@ -89,19 +92,69 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/calc.ts
+// src/async-lock.ts
 var import_lodash_es = require("lodash-es");
+var isAccessor = (sp) => {
+  return sp !== void 0 && "value" in sp && (0, import_lodash_es.isBoolean)(sp.value);
+};
+var async_lock_default = (callback, {
+  validate: validate2,
+  sp = { value: false }
+} = {}) => {
+  const isA = isAccessor(sp);
+  const getter = () => isA ? sp.value : sp.get();
+  const setter = (value) => isA ? sp.value = value : sp.set(value);
+  let lock = false;
+  let local;
+  return {
+    get spin() {
+      return getter();
+    },
+    async callback(...args) {
+      if (getter() || lock) return local;
+      setter(true);
+      local = callback(...args).then((result) => {
+        if ((0, import_lodash_es.isFunction)(validate2)) {
+          lock = validate2(result);
+        } else if (validate2 !== void 0) {
+          lock = validate2 === result;
+        }
+        return result;
+      });
+      await local;
+      setter(false);
+      return local;
+    },
+    unlock() {
+      lock = false;
+    }
+  };
+};
+
+// src/calc.ts
+var import_lodash_es2 = require("lodash-es");
 var { parseFloat } = Number;
-var formatter = (value) => (0, import_lodash_es.isNumber)(value) ? value && `${value}px` : value;
-var isCalc = (value) => value.slice(0, 5) === "calc(" && value.slice(-1) === ")";
-var re_numerical = /^(-?(?:\.\d+|\d+(?:\.\d+)?))([a-zA-Z]+|%)$/;
+var re_numerical = /^(-?(?:\.\d+|\d+(?:\.\d+)?)(?:e\d+)?)([a-zA-Z]+|%)$/;
 var re_zero = /^0[a-zA-Z]+$/;
+var re_method_start = /[a-z]/i;
+var re_method_next = /^\w*\(/;
+var formatter = (value) => {
+  if ((0, import_lodash_es2.isNumber)(value)) {
+    return value && `${value}px`;
+  }
+  const matchs = value.match(re_numerical) || (isCalc(value) ? value.slice(5, -1).match(re_numerical) : null);
+  if (matchs) {
+    return matchs[1] === "0" ? 0 : matchs[1] + matchs[2];
+  }
+  return value;
+};
+var isCalc = (value) => value.slice(0, 5) === "calc(" && value.slice(-1) === ")";
 var Memory = class {
   data = {};
   memory = {};
   add(index, value, unit) {
     const { data, memory } = this;
-    if (!(0, import_lodash_es.isNumber)(value)) {
+    if (!(0, import_lodash_es2.isNumber)(value)) {
       data[index] = { value };
     } else {
       const point = memory[unit];
@@ -119,7 +172,7 @@ var Manager = class {
   memory = new Memory();
   push(value, index) {
     const { memory } = this;
-    if ((0, import_lodash_es.isNumber)(value)) return memory.add(index, value, "px");
+    if ((0, import_lodash_es2.isNumber)(value)) return memory.add(index, value, "px");
     const matchs = value.match(re_numerical);
     if (matchs) return memory.add(index, parseFloat(matchs[1]), matchs[2]);
     if (!isCalc(value)) return memory.add(index, value);
@@ -136,34 +189,93 @@ var calc = (...list) => {
   if (size === 1) return formatter(list[0]);
   const manager = new Manager();
   list.forEach((value2, index) => manager.push(value2, index));
+  let count = 0;
   const value = list.reduce((caches, _, index) => {
     const data = manager.at(index);
     if (!data || data.value === 0) return caches;
     const { value: value2, unit } = data;
     let tmp;
-    if ((0, import_lodash_es.isNumber)(value2)) {
+    if ((0, import_lodash_es2.isNumber)(value2)) {
       tmp = value2 + unit;
     } else {
       tmp = value2;
     }
     if (!caches) return tmp;
+    count++;
     return tmp[0] === "-" ? `${caches} - ${tmp.slice(1)}` : `${caches} + ${tmp}`;
   }, "");
-  return !value || re_zero.test(value) ? 0 : `calc(${value})`;
+  return !value ? 0 : count === 0 ? re_zero.test(value) ? 0 : value : `calc(${value})`;
+};
+var exp_max_method_name = null;
+var isMethod = (value) => {
+  if (!re_method_start.test(value)) {
+    exp_max_method_name = null;
+    return false;
+  }
+  const matchs = value.slice(1).match(re_method_next);
+  if (!matchs || value.slice(-1) !== ")") {
+    exp_max_method_name = null;
+    return false;
+  }
+  const size = matchs[0].length;
+  let count = 0;
+  for (let i = size + 1; i < value.length - 1; i++) {
+    const c = value[i];
+    if (c === "(") {
+      count++;
+    } else if (c === ")" && count-- === 0) {
+      exp_max_method_name = null;
+      return false;
+    }
+  }
+  if (count === 0) {
+    exp_max_method_name = value.slice(0, size);
+    return true;
+  } else {
+    exp_max_method_name = null;
+    return false;
+  }
+};
+calc.getExpMN = (value) => {
+  isMethod(value);
+  return exp_max_method_name;
+};
+calc.multiply = (value, multiple) => {
+  if (value === 0 || multiple === 0) return 0;
+  if ((0, import_lodash_es2.isNumber)(value)) return `${value * multiple}px`;
+  if (multiple === 1) return value;
+  const tmp = formatter(value);
+  if (!tmp) return 0;
+  const matchs = tmp.match(re_numerical);
+  return matchs ? parseFloat(matchs[1]) * multiple + matchs[2] : isCalc(tmp) ? `calc(${tmp.slice(4)} * ${multiple})` : isMethod(tmp) ? `calc(${tmp} * ${multiple})` : `calc((${value}) * ${multiple})`;
+};
+calc.divide = (value, divisor) => {
+  if (divisor === 0) throw new Error("The divisor cannot be 0");
+  if (value === 0) return 0;
+  if (divisor === 1) return formatter(value);
+  const tmp = formatter(value);
+  if (!tmp) return 0;
+  const matchs = tmp.match(re_numerical);
+  return matchs ? parseFloat(matchs[1]) / divisor + matchs[2] : isCalc(tmp) ? `calc(${tmp.slice(4)} / ${divisor})` : isMethod(tmp) ? `calc(${tmp} / ${divisor})` : `calc((${value}) / ${divisor})`;
 };
 calc.formatter = formatter;
 var zero = "0px";
 var u = void 0;
 calc.clamp = (value, { min, max }) => {
-  const val = calc.formatter(value);
+  const val = formatter(value) || zero;
   if (min !== u && max !== u) {
-    return `clamp(${calc.formatter(min) || zero}, ${val || zero}, ${calc.formatter(max) || zero})`;
-  } else if (max !== u) {
-    return `max(${calc.formatter(max) || zero}, ${val || zero})`;
+    min = formatter(min) || zero;
+    max = formatter(max) || zero;
+    return min === max ? max : `clamp(${min}, ${val}, ${max})`;
+  }
+  if (max !== u) {
+    max = formatter(max) || zero;
+    return max === zero ? val : `max(${max}, ${val})`;
   } else if (min !== u) {
-    return `min(${calc.formatter(min) || zero}, ${val || zero})`;
+    min = formatter(min) || zero;
+    return min === val ? val : `min(${min}, ${val})`;
   } else {
-    return val;
+    return val === zero ? 0 : val;
   }
 };
 var calc_default = calc;
@@ -179,14 +291,14 @@ var clamp = (value, min, max) => {
 };
 
 // src/classnames.ts
-var import_lodash_es2 = require("lodash-es");
+var import_lodash_es3 = require("lodash-es");
 var add = (a, b) => a ? a + " " + b : b;
 var classnames = (...list) => list.reduce((caches, data) => {
-  if ((0, import_lodash_es2.isString)(data)) {
+  if ((0, import_lodash_es3.isString)(data)) {
     data && (caches = add(caches, data));
   } else if (Array.isArray(data)) {
-    data.forEach((value) => value && (0, import_lodash_es2.isString)(value) && (caches = add(caches, value)));
-  } else if (!(0, import_lodash_es2.isBoolean)(data)) {
+    data.forEach((value) => value && (0, import_lodash_es3.isString)(value) && (caches = add(caches, value)));
+  } else if (!(0, import_lodash_es3.isBoolean)(data)) {
     for (const key in data) {
       key && data[key] && (caches = add(caches, key));
     }
@@ -258,7 +370,7 @@ var hash8object = (list, key) => list.reduce((caches, data) => {
 }, /* @__PURE__ */ new Map());
 
 // src/cron.ts
-var import_lodash_es3 = require("lodash-es");
+var import_lodash_es4 = require("lodash-es");
 var {
   parseInt,
   isInteger,
@@ -574,7 +686,7 @@ var AggUnit = class {
     if (Array.isArray(values)) {
       tmp = values.reduce((caches, data) => {
         let tmp2;
-        if ((0, import_lodash_es3.isNumber)(data)) {
+        if ((0, import_lodash_es4.isNumber)(data)) {
           tmp2 = `${data}`;
         } else {
           tmp2 = data.text();
@@ -638,7 +750,7 @@ var formaterAgg = (value, min, max) => {
     value.some((data) => {
       if (validate(data, min, max)) {
         tmp.push(
-          (0, import_lodash_es3.isNumber)(data) ? data : new RangeUnit(data[0], data[1])
+          (0, import_lodash_es4.isNumber)(data) ? data : new RangeUnit(data[0], data[1])
         );
         return false;
       } else {
@@ -658,7 +770,7 @@ var formaterAggByLast = (value, min, max, prototype) => {
     const tmp = [];
     const list = Array.isArray(value) ? value : [value];
     list.some((data) => {
-      if ((0, import_lodash_es3.isString)(data)) {
+      if ((0, import_lodash_es4.isString)(data)) {
         const result = parseAgg(data);
         if (result.length === 1 && result[0] instanceof prototype && validate(result[0].value, min, max - 1)) {
           tmp.push(result[0]);
@@ -666,7 +778,7 @@ var formaterAggByLast = (value, min, max, prototype) => {
         }
       } else if (validate(data, min, max)) {
         tmp.push(
-          (0, import_lodash_es3.isNumber)(data) ? data : new RangeUnit(data[0], data[1])
+          (0, import_lodash_es4.isNumber)(data) ? data : new RangeUnit(data[0], data[1])
         );
         return false;
       }
@@ -904,7 +1016,7 @@ var Cron = class {
 };
 
 // src/desens.ts
-var import_lodash_es4 = require("lodash-es");
+var import_lodash_es5 = require("lodash-es");
 var desensEncrypt = (plaintext, encrypt) => {
   const rules = [];
   let point = -1;
@@ -943,7 +1055,7 @@ var desensReplace = (ciphertext, rules, replacer = "*") => {
   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_es4.isString)(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
+    const replaceValue = (0, import_lodash_es5.isString)(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
     cache += ciphertext.slice(from, start + offset) + replaceValue;
     from = start + offset + modify;
     offset += modify - size;
@@ -952,7 +1064,7 @@ var desensReplace = (ciphertext, rules, replacer = "*") => {
 };
 
 // src/dic.ts
-var import_lodash_es5 = require("lodash-es");
+var import_lodash_es6 = require("lodash-es");
 var DicRollup = class _DicRollup {
   #list;
   #default;
@@ -989,7 +1101,7 @@ var DicRollup = class _DicRollup {
     if (!data) return;
     const custom = this.#customLabel;
     if (!custom) return data.label;
-    if (!mode && (0, import_lodash_es5.isFunction)(custom)) {
+    if (!mode && (0, import_lodash_es6.isFunction)(custom)) {
       return custom(data);
     } else if (mode) {
       const tmp = custom[mode];
@@ -1043,6 +1155,18 @@ var DicRollup = class _DicRollup {
 };
 var dic_default = DicRollup;
 
+// src/disable-enumerable.ts
+var disable_enumerable_default = (data, key) => {
+  const descriptor = Object.getOwnPropertyDescriptor(data, key) || {
+    configurable: true,
+    writable: true
+  };
+  Object.defineProperty(data, key, {
+    ...descriptor,
+    enumerable: false
+  });
+};
+
 // src/encoding.ts
 var utf8_first_prefix = /^1{2,}/g;
 var utf8_other_prefix = /^10/;
@@ -1098,6 +1222,39 @@ var getEncoding = (uint, limit = 1024) => {
   return { encoding, offset };
 };
 
+// src/index-sort.ts
+var index_sort_default = (list, key) => {
+  const { length } = list;
+  if (length < 2) return list;
+  const first = list[0][key];
+  const caches = { [first]: first };
+  let isA = false;
+  let max = first;
+  let min = first;
+  for (let i = 1; i < length; i++) {
+    const value = list[i][key];
+    if (value === Math.trunc(value) && value in caches === false) {
+      if (value > max) {
+        max = value;
+      } else if (value < min) {
+        min = value;
+      }
+      caches[value] = value;
+    } else {
+      isA = true;
+      break;
+    }
+  }
+  if (!isA && max - min === length - 1) {
+    return list.reduce((cache, data) => {
+      cache[data[key] - min] = data;
+      return cache;
+    }, []);
+  } else {
+    return list.sort((a, b) => a[key] - b[key]);
+  }
+};
+
 // src/input-regex.ts
 var RE_REGEX = /[$()*+.[?\\^{|]/g;
 var RE_STRING = /[$()*+.[?\\^{|-]/g;
@@ -1146,38 +1303,53 @@ var loadImage = (src) => {
 };
 
 // src/memory/basic.ts
-var MemoryBasic = class {
+var PUSH = 1;
+var RESET = 2;
+var DELETE = 0;
+var LIST_SYMBOL = Symbol();
+var MEMORYS_SYMBOL = Symbol();
+var MemoryBasic = class _MemoryBasic {
   /**
-   * @param key 用于对数据进行分类的key
-   * @param config 
+   * @param key     用于对数据进行分类的key
+   * @param config  配置项
    */
   constructor(key, config) {
     this.key = key;
     this.#mount = config.mount;
     this.#reflex = config.reflex;
+    this.#emit = config.emit;
   }
+  static PUSH = PUSH;
+  static RESET = RESET;
+  static DELETE = DELETE;
   #mount;
   #reflex;
-  list = [];
-  memorys = /* @__PURE__ */ new Map();
+  #emit;
+  [LIST_SYMBOL] = [];
+  [MEMORYS_SYMBOL] = /* @__PURE__ */ new Map();
   /**
    * 返回存储长度
    */
   get size() {
-    return this.list.length;
+    return this[LIST_SYMBOL].length;
   }
   getType(data) {
     const { key } = this;
     return typeof key === "function" ? key(data) : data[key];
   }
-  push(...list) {
-    const { memorys } = this;
-    list.forEach((data) => {
+  /**
+   * 添加数据
+   */
+  push(...values) {
+    const memorys = this[MEMORYS_SYMBOL];
+    const list = this[LIST_SYMBOL];
+    values.forEach((data) => {
       const type = this.getType(data);
       const memory = memorys.get(type);
-      const index = this.list.push(data) - 1;
+      const index = list.push(data) - 1;
       const result = this.#mount(index, memory);
       memory === result || memorys.set(type, result);
+      this.#emit?.(PUSH, data);
     });
     return this;
   }
@@ -1185,24 +1357,25 @@ var MemoryBasic = class {
    * 返回位于指定索引处的项
    */
   at(index) {
-    const { list } = this;
+    const list = this[LIST_SYMBOL];
     if (index < 0) {
       index += list.length;
     }
-    return this.list.at(index);
+    return list.at(index);
   }
   /**
    * 遍历所有存储数据(按入栈顺序)
    */
   forEach(callback) {
-    this.list.forEach(callback);
+    this[LIST_SYMBOL].forEach(callback);
     return this;
   }
   /**
    * 遍历所有存储类型
    */
   forType(callback) {
-    const { memorys, list } = this;
+    const memorys = this[MEMORYS_SYMBOL];
+    const list = this[LIST_SYMBOL];
     for (const [type, memory] of memorys) {
       const caches = this.#reflex(memory).map((index) => list[index]);
       callback(caches, type);
@@ -1213,38 +1386,39 @@ var MemoryBasic = class {
    * some(按入栈顺序)
    */
   some(callback) {
-    return this.list.some(callback);
+    return this[LIST_SYMBOL].some(callback);
   }
   /**
    * map(按入栈顺序)
    */
   map(callback) {
-    return this.list.map(callback);
+    return this[LIST_SYMBOL].map(callback);
   }
   /**
    * reduce(按入栈顺序)
    */
   reduce(callback, initialValue) {
-    return this.list.reduce(callback, initialValue);
+    return this[LIST_SYMBOL].reduce(callback, initialValue);
   }
   /**
    * 判断存储是否包含指定类型
    */
   includes(type) {
-    return this.memorys.has(type);
+    return this[MEMORYS_SYMBOL].has(type);
   }
   /**
    * 获取指定类型存储数据
    */
   get(type) {
-    const memory = this.memorys.get(type);
-    return memory === void 0 ? null : this.#reflex(memory).map((count) => this.list[count]);
+    const memory = this[MEMORYS_SYMBOL].get(type);
+    return memory === void 0 ? null : this.#reflex(memory).map((count) => this[LIST_SYMBOL][count]);
   }
   /**
    * 删除指定存储数据
    */
   delete(data) {
-    const { memorys, list } = this;
+    const memorys = this[MEMORYS_SYMBOL];
+    const list = this[LIST_SYMBOL];
     let index = -1;
     if (!list.some((value, i) => {
       if (data === value) {
@@ -1280,42 +1454,46 @@ var MemoryBasic = class {
         memorys.set(type, reactor);
       }
     }
+    this.#emit?.(DELETE, index);
     return this;
   }
   /**
    * 删除指定类型存储数据
    */
   deleteType(type) {
-    const { memorys, list } = this;
+    const memorys = this[MEMORYS_SYMBOL];
+    const list = this[LIST_SYMBOL];
     if (!memorys.has(type)) return this;
     const local = hash8strings(this.#reflex(memorys.get(type)));
-    const Memory2 = this.constructor;
-    const imitator = new Memory2(this.key, {
+    const imitator = new _MemoryBasic(this.key, {
       mount: this.#mount,
       reflex: this.#reflex
     });
     list.forEach((data, index) => {
       index in local || imitator.push(data);
     });
-    this.list = imitator.list;
-    this.memorys = imitator.memorys;
+    const tmp = this[LIST_SYMBOL] = imitator[LIST_SYMBOL];
+    this[MEMORYS_SYMBOL] = imitator[MEMORYS_SYMBOL];
+    this.#emit?.(RESET, tmp.slice(0));
     return this;
   }
   /**
    * 清理存储
    */
   clear() {
-    this.list = [];
-    this.memorys.clear();
+    this[LIST_SYMBOL] = [];
+    this[MEMORYS_SYMBOL].clear();
+    this.#emit?.(RESET, []);
   }
 };
 
 // src/memory/list.ts
 var MemoryList = class extends MemoryBasic {
-  constructor(key) {
+  constructor(key, emit) {
     super(key, {
       mount: (index, reactor) => reactor ? (reactor.push(index), reactor) : [index],
-      reflex: (reactor) => reactor
+      reflex: (reactor) => reactor,
+      emit
     });
   }
 };
@@ -1343,10 +1521,11 @@ var deconPowersSum = (sum, sort) => {
 
 // src/memory/power.ts
 var MemoryPower = class extends MemoryBasic {
-  constructor(key) {
+  constructor(key, emit) {
     super(key, {
       mount: (index, reactor) => (reactor || 0) + 2 ** index,
-      reflex: (reactor) => deconPowersSum(reactor, "asc")
+      reflex: (reactor) => deconPowersSum(reactor, "asc"),
+      emit
     });
   }
 };
@@ -1785,12 +1964,12 @@ var once = (func, thisArg) => {
 };
 
 // src/parse/num.ts
-var import_lodash_es6 = require("lodash-es");
+var import_lodash_es7 = require("lodash-es");
 var { MAX_SAFE_INTEGER: MAX_SAFE_INTEGER2, NaN } = Number;
 var pow = Math.floor(Math.log10(MAX_SAFE_INTEGER2));
 var re_num2 = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
 var parseNum = (num) => {
-  if ((0, import_lodash_es6.isNumber)(num) || typeof num === "bigint") return num;
+  if ((0, import_lodash_es7.isNumber)(num) || typeof num === "bigint") return num;
   const match = num.match(re_num2);
   if (!match) return NaN;
   const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
@@ -1819,7 +1998,7 @@ var parseNum = (num) => {
 var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
 
 // src/serialize/url-params.ts
-var import_lodash_es7 = require("lodash-es");
+var import_lodash_es8 = require("lodash-es");
 var cubes = {
   string: (text) => text,
   boolean: (text) => text === "true",
@@ -1844,7 +2023,7 @@ var cubeURLParams = (text, serializes) => {
   for (const [key, value] of params) {
     const serialize = serializes[key];
     if (!serialize) continue;
-    if ((0, import_lodash_es7.isString)(serialize) && isKey(serialize, cubes)) {
+    if ((0, import_lodash_es8.isString)(serialize) && isKey(serialize, cubes)) {
       result[key] = cubes[serialize](value);
     } else {
       result[key] = serialize.cube(value);
@@ -1862,21 +2041,21 @@ var flatURLParams = (data, serializes) => {
     if (!serialize) continue;
     params.append(
       key,
-      (0, import_lodash_es7.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+      (0, import_lodash_es8.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
     );
   }
   return params.toString();
 };
 
 // src/style/css.ts
-var import_lodash_es8 = require("lodash-es");
+var import_lodash_es9 = 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_es8.isString)(data)) {
+    if ((0, import_lodash_es9.isString)(data)) {
       list.push(data);
     } else if (Array.isArray(data)) {
       const result = css(...data);
@@ -1939,7 +2118,7 @@ var Subscriber = class {
           listeners[name].splice(index, 1);
           return true;
         }
-      }) && once2[name].some((value, index) => {
+      }) && once2[name]?.some((value, index) => {
         if (value === count) {
           listeners[name].splice(index, 1);
           return true;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { default as asyncLock } from './async-lock';
 export { type Calc, isCalc, default as calc } from './calc';
 export { clamp } from './clamp';
 export { classnames } from './classnames';
@@ -9,14 +10,16 @@ export { hash8strings } from './convert/strings';
 export { weekDic, default_max_second, default_min_second, default_max_minute, default_min_minute, default_max_hour, default_min_hour, default_max_day, default_min_day, default_max_month, default_min_month, default_max_week, default_min_week, createCronRegexText, InvalidUnit, isInvalidUnit, DayLastUnit, isDayLastUnit, WeekLastUnit, isWeekLastUnit, WildcardUnit, isWildcardUnit, RangeUnit, isRangeUnit, AggUnit, isAggUnit, Cron } from './cron';
 export { type DesensDecrypt, type DesensEncrypt, desensEncrypt, desensDecrypt, desensReplace } from './desens';
 export { type Dic, default as DicRollup } from './dic';
+export { default as disableEnumerable } from './disable-enumerable';
 export { getEncoding } from './encoding';
+export { default as indexSort } from './index-sort';
 export { inputRegex } from './input-regex';
 export { isClass } from './is/class';
 export { isEmpty } from './is/empty';
 export { isKey } from './is/key';
 export { isNull } from './is/null';
 export { loadImage } from './load/image';
-export { MemoryBasic } from './memory/basic';
+export { type Memory, MemoryBasic } from './memory/basic';
 export { MemoryList } from './memory/list';
 export { MemoryPower } from './memory/power';
 export { MemorySimple } from './memory/simple';