@vope/utils 1.6.3 → 1.6.4

package/dist/index.cjs.js

@@ -19,22 +19,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AggUnit: () => AggUnit,
   Cron: () => Cron,
-  DayLastValue: () => DayLastValue,
-  DigitsValue: () => DigitsValue,
+  DayLastUnit: () => DayLastUnit,
+  DicRollup: () => DicRollup,
   FlexTable: () => FlexTable,
-  InvalidValue: () => InvalidValue,
+  InvalidUnit: () => InvalidUnit,
   MemoryBasic: () => MemoryBasic,
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
   MemorySimple: () => MemorySimple,
   Neo4j: () => Neo4j,
   Neo4jAhchors: () => Neo4jAhchors,
-  RangeValue: () => RangeValue,
+  RangeUnit: () => RangeUnit,
   Subscriber: () => Subscriber,
   Union: () => Union,
-  WeekLastValue: () => WeekLastValue,
-  WildcardValue: () => WildcardValue,
+  WeekLastUnit: () => WeekLastUnit,
+  WildcardUnit: () => WildcardUnit,
   calc: () => calc,
   clamp: () => clamp,
   classnames: () => classnames,
@@ -66,17 +67,17 @@ __export(index_exports, {
   hash8object: () => hash8object,
   hash8strings: () => hash8strings,
   inputRegex: () => inputRegex,
+  isAggUnit: () => isAggUnit,
   isCalc: () => isCalc,
   isClass: () => isClass,
-  isDayLastValue: () => isDayLastValue,
-  isDigitsValue: () => isDigitsValue,
+  isDayLastUnit: () => isDayLastUnit,
   isEmpty: () => isEmpty,
-  isInvalidValue: () => isInvalidValue,
+  isInvalidUnit: () => isInvalidUnit,
   isKey: () => isKey,
   isNull: () => isNull,
-  isRangeValue: () => isRangeValue,
-  isWeekLastValue: () => isWeekLastValue,
-  isWildcardValue: () => isWildcardValue,
+  isRangeUnit: () => isRangeUnit,
+  isWeekLastUnit: () => isWeekLastUnit,
+  isWildcardUnit: () => isWildcardUnit,
   joinPaths: () => joinPaths,
   loadImage: () => loadImage,
   once: () => once,
@@ -460,7 +461,7 @@ var createCronRegexText = (options = {}) => {
     enableInvalid
   };
 };
-var InvalidValue = class {
+var InvalidUnit = class {
   constructor(isEnableInvalid) {
     this.isEnableInvalid = isEnableInvalid;
   }
@@ -468,32 +469,32 @@ var InvalidValue = class {
     return this.isEnableInvalid ? "?" : "*";
   }
 };
-var isInvalidValue = (value) => value instanceof InvalidValue;
+var isInvalidUnit = (value) => value instanceof InvalidUnit;
 var LastValue = class {
   constructor(value) {
     this.value = value;
   }
 };
-var DayLastValue = class extends LastValue {
+var DayLastUnit = class extends LastValue {
   text() {
     const { value } = this;
     return "L" + (value ? `-${value}` : "");
   }
 };
-var isDayLastValue = (value) => value instanceof DayLastValue;
-var WeekLastValue = class extends LastValue {
+var isDayLastUnit = (value) => value instanceof DayLastUnit;
+var WeekLastUnit = class extends LastValue {
   text() {
     return `${this.value}L`;
   }
 };
-var isWeekLastValue = (value) => value instanceof WeekLastValue;
-var WildcardValue = class {
+var isWeekLastUnit = (value) => value instanceof WeekLastUnit;
+var WildcardUnit = class {
   text() {
     return "*";
   }
 };
-var isWildcardValue = (value) => value instanceof WildcardValue;
-var RangeValue = class {
+var isWildcardUnit = (value) => value instanceof WildcardUnit;
+var RangeUnit = class {
   constructor(start, stop) {
     this.start = start;
     this.stop = stop;
@@ -502,8 +503,8 @@ var RangeValue = class {
     return `${this.start}-${this.stop}`;
   }
 };
-var isRangeValue = (value) => value instanceof RangeValue;
-var DigitsValue = class {
+var isRangeUnit = (value) => value instanceof RangeUnit;
+var AggUnit = class {
   constructor(values, increment) {
     this.values = values;
     this.increment = increment;
@@ -527,7 +528,7 @@ var DigitsValue = class {
     return increment ? `${tmp}/${increment}` : tmp;
   }
 };
-var isDigitsValue = (value) => value instanceof DigitsValue;
+var isAggUnit = (value) => value instanceof AggUnit;
 var re_num = /\d/;
 var parseDigit = (text) => {
   if (re_num.test(text[0])) {
@@ -536,22 +537,22 @@ var parseDigit = (text) => {
     return weekDic.item(text.toLocaleUpperCase());
   }
 };
-var parseDigits = (text) => {
+var parseAgg = (text) => {
   return text.split(",").map((text2) => {
     const [a, b] = text2.split("-");
     if (a === "L" && b === void 0) {
-      return new DayLastValue(0);
+      return new DayLastUnit(0);
     } else if (b === void 0) {
       if (a.slice(-1) === "L") {
-        return new WeekLastValue(parseInt(a.slice(0, -1)));
+        return new WeekLastUnit(parseInt(a.slice(0, -1)));
       } else {
         return parseDigit(a);
       }
     } else {
       if (a === "L") {
-        return new DayLastValue(parseInt(b));
+        return new DayLastUnit(parseInt(b));
       } else {
-        return new RangeValue(parseDigit(a), parseDigit(b));
+        return new RangeUnit(parseDigit(a), parseDigit(b));
       }
     }
   });
@@ -569,16 +570,16 @@ var validate = (value, min, max) => {
 var validateIncrement = (value, min, max) => {
   return isInteger(value) && value > 0 && value >= min && value <= max;
 };
-var formaterDigits = (value, min, max) => {
+var formaterAgg = (value, min, max) => {
   let values;
   if (value === "*") {
-    values = new WildcardValue();
+    values = new WildcardUnit();
   } else if (Array.isArray(value)) {
     const tmp = [];
     value.some((data) => {
       if (validate(data, min, max)) {
         tmp.push(
-          (0, import_lodash_es3.isNumber)(data) ? data : new RangeValue(data[0], data[1])
+          (0, import_lodash_es3.isNumber)(data) ? data : new RangeUnit(data[0], data[1])
         );
         return false;
       } else {
@@ -590,23 +591,23 @@ var formaterDigits = (value, min, max) => {
   }
   return values;
 };
-var formaterLastDigits = (value, min, max, prototype) => {
+var formaterAggByLast = (value, min, max, prototype) => {
   let values;
   if (value === "*") {
-    values = new WildcardValue();
+    values = new WildcardUnit();
   } else {
     const tmp = [];
     const list = Array.isArray(value) ? value : [value];
     list.some((data) => {
       if ((0, import_lodash_es3.isString)(data)) {
-        const result = parseDigits(data);
+        const result = parseAgg(data);
         if (result.length === 1 && result[0] instanceof prototype && validate(result[0].value, min, max - 1)) {
           tmp.push(result[0]);
           return false;
         }
       } else if (validate(data, min, max)) {
         tmp.push(
-          (0, import_lodash_es3.isNumber)(data) ? data : new RangeValue(data[0], data[1])
+          (0, import_lodash_es3.isNumber)(data) ? data : new RangeUnit(data[0], data[1])
         );
         return false;
       }
@@ -638,18 +639,18 @@ var Parse = class {
   week;
   year;
   parse(text) {
-    if (text === "?") return new InvalidValue(this.cron.isEnableInvalid);
+    if (text === "?") return new InvalidUnit(this.cron.isEnableInvalid);
     const [slices, increment] = text.split("/");
-    return new DigitsValue(
-      slices === "*" ? new WildcardValue() : parseDigits(slices),
+    return new AggUnit(
+      slices === "*" ? new WildcardUnit() : parseAgg(slices),
       increment ? parseInt(increment) : void 0
     );
   }
   setSecond(value, increment) {
     if (!this.cron.isEnableSecond) return false;
-    const values = formaterDigits(value, default_min_second, default_max_second);
+    const values = formaterAgg(value, default_min_second, default_max_second);
     if (!values) return false;
-    const second = new DigitsValue(values);
+    const second = new AggUnit(values);
     if (validateIncrement(increment, default_min_second, default_max_second)) {
       second.increment = increment;
     }
@@ -657,9 +658,9 @@ var Parse = class {
     return true;
   }
   setMinute(value, increment) {
-    const values = formaterDigits(value, default_min_minute, default_max_minute);
+    const values = formaterAgg(value, default_min_minute, default_max_minute);
     if (!values) return false;
-    const minute = new DigitsValue(values);
+    const minute = new AggUnit(values);
     if (validateIncrement(increment, default_min_minute, default_max_minute)) {
       minute.increment = increment;
     }
@@ -667,9 +668,9 @@ var Parse = class {
     return true;
   }
   setHour(value, increment) {
-    const values = formaterDigits(value, default_min_hour, default_max_hour);
+    const values = formaterAgg(value, default_min_hour, default_max_hour);
     if (!values) return false;
-    const hour = new DigitsValue(values);
+    const hour = new AggUnit(values);
     if (validateIncrement(increment, default_min_hour, default_max_hour)) {
       hour.increment = increment;
     }
@@ -677,9 +678,9 @@ var Parse = class {
     return true;
   }
   setDayInvalid() {
-    this.day = new InvalidValue(this.cron.isEnableInvalid);
-    if (this.week instanceof InvalidValue) {
-      this.week = new DigitsValue(new WildcardValue());
+    this.day = new InvalidUnit(this.cron.isEnableInvalid);
+    if (this.week instanceof InvalidUnit) {
+      this.week = new AggUnit(new WildcardUnit());
     }
   }
   setDay(value, increment) {
@@ -688,30 +689,30 @@ var Parse = class {
       this.setDayInvalid();
       return true;
     } else {
-      const tmp2 = formaterLastDigits(value, default_min_day, default_max_day, DayLastValue);
+      const tmp2 = formaterAggByLast(value, default_min_day, default_max_day, DayLastUnit);
       if (!tmp2) return false;
       values = tmp2;
     }
-    const tmp = new DigitsValue(values);
+    const tmp = new AggUnit(values);
     if (validateIncrement(increment, default_min_day, default_max_day)) {
       tmp.increment = increment;
     }
     this.day = tmp;
     const { week } = this;
-    if (isDigitsValue(week) && (week.increment !== void 0 || !isWildcardValue(week.values))) {
+    if (isAggUnit(week) && (week.increment !== void 0 || !isWildcardUnit(week.values))) {
       if (this.cron.isEnableInvalid) {
-        this.week = new InvalidValue(true);
+        this.week = new InvalidUnit(true);
       } else {
-        week.values = new WildcardValue();
+        week.values = new WildcardUnit();
         week.increment = void 0;
       }
     }
     return true;
   }
   setMonth(value, increment) {
-    const values = formaterDigits(value, default_min_month, default_max_month);
+    const values = formaterAgg(value, default_min_month, default_max_month);
     if (!values) return false;
-    const month = new DigitsValue(values);
+    const month = new AggUnit(values);
     if (validateIncrement(increment, default_min_month, default_max_month)) {
       month.increment = increment;
     }
@@ -719,9 +720,9 @@ var Parse = class {
     return true;
   }
   setWeekInvalid() {
-    this.week = new InvalidValue(this.cron.isEnableInvalid);
-    if (this.day instanceof InvalidValue) {
-      this.day = new DigitsValue(new WildcardValue());
+    this.week = new InvalidUnit(this.cron.isEnableInvalid);
+    if (this.day instanceof InvalidUnit) {
+      this.day = new AggUnit(new WildcardUnit());
     }
   }
   setWeek(value, increment) {
@@ -730,21 +731,21 @@ var Parse = class {
       this.setWeekInvalid();
       return true;
     } else {
-      const tmp2 = formaterLastDigits(value, default_min_week, default_max_week, WeekLastValue);
+      const tmp2 = formaterAggByLast(value, default_min_week, default_max_week, WeekLastUnit);
       if (!tmp2) return false;
       values = tmp2;
     }
-    const tmp = new DigitsValue(values);
+    const tmp = new AggUnit(values);
     if (validateIncrement(increment, default_min_week, default_max_week)) {
       tmp.increment = increment;
     }
     this.week = tmp;
     const { day } = this;
-    if (isDigitsValue(day) && (day.increment !== void 0 || !isWildcardValue(day.values))) {
+    if (isAggUnit(day) && (day.increment !== void 0 || !isWildcardUnit(day.values))) {
       if (this.cron.isEnableInvalid) {
-        this.day = new InvalidValue(true);
+        this.day = new InvalidUnit(true);
       } else {
-        day.values = new WildcardValue();
+        day.values = new WildcardUnit();
         day.increment = void 0;
       }
     }
@@ -752,9 +753,9 @@ var Parse = class {
   }
   setYear(value, increment) {
     if (!this.cron.isEnableYear) return false;
-    const values = formaterDigits(value, 0, MAX_SAFE_INTEGER);
+    const values = formaterAgg(value, 0, MAX_SAFE_INTEGER);
     if (!values) return false;
-    const year = new DigitsValue(values);
+    const year = new AggUnit(values);
     if (validateIncrement(increment, 0, MAX_SAFE_INTEGER)) {
       year.increment = increment;
     }
@@ -891,6 +892,97 @@ var desensReplace = (ciphertext, rules, replacer = "*") => {
   }, "") + ciphertext.slice(from);
 };
 
+// src/dic.ts
+var import_lodash_es5 = require("lodash-es");
+var DicRollup = class _DicRollup {
+  #list;
+  #default;
+  #customLabel;
+  memory;
+  constructor(list, {
+    defaultValue,
+    customLabel
+  } = {}) {
+    this.#list = list;
+    this.#default = defaultValue;
+    this.#customLabel = customLabel;
+    const getter = () => hash8json(list, "value");
+    Object.defineProperty(this, "memory", {
+      get() {
+        return getter();
+      }
+    });
+  }
+  get size() {
+    return this.#list.length;
+  }
+  get default() {
+    return this.#default;
+  }
+  get list() {
+    return this.#list;
+  }
+  includes(key) {
+    return key in this.memory;
+  }
+  label(key, mode) {
+    const data = this.memory[key];
+    if (!data) return;
+    const custom = this.#customLabel;
+    if (!custom) return data.label;
+    if (!mode && (0, import_lodash_es5.isFunction)(custom)) {
+      return custom(data);
+    } else if (mode) {
+      const tmp = custom[mode];
+      return tmp ? tmp(data) : data.label;
+    } else {
+      return data.label;
+    }
+  }
+  get(key, property) {
+    return this.memory[key]?.[property];
+  }
+  item(key) {
+    return this.memory[key];
+  }
+  map(callback) {
+    return this.#list.map(callback);
+  }
+  reduce(callback, initialValue) {
+    return this.#list.reduce(callback, initialValue);
+  }
+  copy(keys, options) {
+    const tmp = hash8strings(keys);
+    const opts = Object.assign({
+      defaultValue: this.#default,
+      customLabel: this.#customLabel
+    }, options);
+    const { defaultValue } = opts;
+    if (defaultValue !== void 0 && defaultValue in tmp === false) {
+      opts.defaultValue = void 0;
+    }
+    return new _DicRollup(
+      this.#list.filter((data) => data.value in tmp),
+      opts
+    );
+  }
+  copyAnti(keys, options) {
+    const tmp = hash8strings(keys);
+    const opts = Object.assign({
+      defaultValue: this.#default,
+      customLabel: this.#customLabel
+    }, options);
+    const { defaultValue } = opts;
+    if (defaultValue !== void 0 && defaultValue in tmp) {
+      opts.defaultValue = void 0;
+    }
+    return new _DicRollup(
+      this.#list.filter((data) => data.value in tmp === false),
+      opts
+    );
+  }
+};
+
 // src/encoding.ts
 var utf8_first_prefix = /^1{2,}/g;
 var utf8_other_prefix = /^10/;
@@ -1633,17 +1725,18 @@ var once = (func, thisArg) => {
 };
 
 // src/parse/num.ts
-var import_lodash_es5 = require("lodash-es");
-var pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
+var import_lodash_es6 = 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_es5.isNumber)(num) || typeof num === "bigint") return num;
+  if ((0, import_lodash_es6.isNumber)(num) || typeof num === "bigint") return num;
   const match = num.match(re_num2);
-  if (!match) return Number.NaN;
+  if (!match) return NaN;
   const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
   if (bigint === "n") return BigInt(valueSymbol + integer);
   const powSize = integer.length - 1 + (powValue ? powSymbol === "-" ? -powValue : +powValue : 0);
-  if (powSize < pow || powSize === pow && +integer.slice(0, -1) < Number.MAX_SAFE_INTEGER / 10) return +num;
+  if (powSize < pow || powSize === pow && +integer.slice(0, -1) < MAX_SAFE_INTEGER2 / 10) return +num;
   try {
     const bigValue = BigInt(integer.slice(0, powSize + 1).padEnd(powSize + 1, "0"));
     let smallValue;
@@ -1658,7 +1751,7 @@ var parseNum = (num) => {
     const value = bigValue + smallValue;
     return valueSymbol === "-" ? value * BigInt(-1) : value;
   } catch {
-    return Number.NaN;
+    return NaN;
   }
 };
 
@@ -1666,7 +1759,7 @@ var parseNum = (num) => {
 var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
 
 // src/serialize/url-params.ts
-var import_lodash_es6 = require("lodash-es");
+var import_lodash_es7 = require("lodash-es");
 var cubes = {
   string: (text) => text,
   boolean: (text) => text === "true",
@@ -1691,7 +1784,7 @@ var cubeURLParams = (text, serializes) => {
   for (const [key, value] of params) {
     const serialize = serializes[key];
     if (!serialize) continue;
-    if ((0, import_lodash_es6.isString)(serialize) && isKey(serialize, cubes)) {
+    if ((0, import_lodash_es7.isString)(serialize) && isKey(serialize, cubes)) {
       result[key] = cubes[serialize](value);
     } else {
       result[key] = serialize.cube(value);
@@ -1709,21 +1802,21 @@ var flatURLParams = (data, serializes) => {
     if (!serialize) continue;
     params.append(
       key,
-      (0, import_lodash_es6.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+      (0, import_lodash_es7.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
     );
   }
   return params.toString();
 };
 
 // src/style/css.ts
-var import_lodash_es7 = require("lodash-es");
+var import_lodash_es8 = 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_es7.isString)(data)) {
+    if ((0, import_lodash_es8.isString)(data)) {
       list.push(data);
     } else if (Array.isArray(data)) {
       const result = css(...data);

package/dist/index.d.ts

@@ -6,8 +6,9 @@ export { deepWeakEqual } from './compare/weak-equal';
 export { hash8json } from './convert/json';
 export { hash8object } from './convert/object';
 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, InvalidValue, isInvalidValue, DayLastValue, isDayLastValue, WeekLastValue, isWeekLastValue, WildcardValue, isWildcardValue, RangeValue, isRangeValue, DigitsValue, isDigitsValue, Cron } from './cron';
+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 { getEncoding } from './encoding';
 export { inputRegex } from './input-regex';
 export { isClass } from './is/class';

package/dist/index.js

@@ -6,8 +6,9 @@ import { deepWeakEqual } from "./compare/weak-equal";
 import { hash8json } from "./convert/json";
 import { hash8object } from "./convert/object";
 import { hash8strings } from "./convert/strings";
-import { 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, InvalidValue, isInvalidValue, DayLastValue, isDayLastValue, WeekLastValue, isWeekLastValue, WildcardValue, isWildcardValue, RangeValue, isRangeValue, DigitsValue, isDigitsValue, Cron } from "./cron";
+import { 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";
 import { desensEncrypt, desensDecrypt, desensReplace } from "./desens";
+import { default as default2 } from "./dic";
 import { getEncoding } from "./encoding";
 import { inputRegex } from "./input-regex";
 import { isClass } from "./is/class";
@@ -19,8 +20,8 @@ import { MemoryBasic } from "./memory/basic";
 import { MemoryList } from "./memory/list";
 import { MemoryPower } from "./memory/power";
 import { MemorySimple } from "./memory/simple";
-import { default as default2 } from "./neo4j-anchors";
-import { default as default3 } from "./neo4j";
+import { default as default3 } from "./neo4j-anchors";
+import { default as default4 } from "./neo4j";
 import { once } from "./once";
 import { parseNum } from "./parse/num";
 import { deconPowersSum } from "./power/decon";
@@ -28,29 +29,30 @@ import { rotateAngle } from "./rotate/angle";
 import { rotateRad } from "./rotate/rad";
 import { cubeURLParams, flatURLParams } from "./serialize/url-params";
 import { css } from "./style/css";
-import { default as default4 } from "./subscriber";
+import { default as default5 } from "./subscriber";
 import { FlexTable } from "./table/flex";
 import { Union } from "./union";
 import { joinPaths } from "./url/join";
 import { connectURLParams } from "./url/params";
 import { wait } from "./wait";
 export {
+  AggUnit,
   Cron,
-  DayLastValue,
-  DigitsValue,
+  DayLastUnit,
+  default2 as DicRollup,
   FlexTable,
-  InvalidValue,
+  InvalidUnit,
   MemoryBasic,
   MemoryList,
   MemoryPower,
   MemorySimple,
-  default3 as Neo4j,
-  default2 as Neo4jAhchors,
-  RangeValue,
-  default4 as Subscriber,
+  default4 as Neo4j,
+  default3 as Neo4jAhchors,
+  RangeUnit,
+  default5 as Subscriber,
   Union,
-  WeekLastValue,
-  WildcardValue,
+  WeekLastUnit,
+  WildcardUnit,
   calc,
   clamp,
   classnames,
@@ -82,17 +84,17 @@ export {
   hash8object,
   hash8strings,
   inputRegex,
+  isAggUnit,
   isCalc,
   isClass,
-  isDayLastValue,
-  isDigitsValue,
+  isDayLastUnit,
   isEmpty,
-  isInvalidValue,
+  isInvalidUnit,
   isKey,
   isNull,
-  isRangeValue,
-  isWeekLastValue,
-  isWildcardValue,
+  isRangeUnit,
+  isWeekLastUnit,
+  isWildcardUnit,
   joinPaths,
   loadImage,
   once,

package/dist/parse/num.js

@@ -1,14 +1,15 @@
 import { isNumber } from "lodash-es";
-const pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
+const { MAX_SAFE_INTEGER, NaN } = Number;
+const pow = Math.floor(Math.log10(MAX_SAFE_INTEGER));
 const re_num = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
 const parseNum = (num) => {
   if (isNumber(num) || typeof num === "bigint") return num;
   const match = num.match(re_num);
-  if (!match) return Number.NaN;
+  if (!match) return NaN;
   const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
   if (bigint === "n") return BigInt(valueSymbol + integer);
   const powSize = integer.length - 1 + (powValue ? powSymbol === "-" ? -powValue : +powValue : 0);
-  if (powSize < pow || powSize === pow && +integer.slice(0, -1) < Number.MAX_SAFE_INTEGER / 10) return +num;
+  if (powSize < pow || powSize === pow && +integer.slice(0, -1) < MAX_SAFE_INTEGER / 10) return +num;
   try {
     const bigValue = BigInt(integer.slice(0, powSize + 1).padEnd(powSize + 1, "0"));
     let smallValue;
@@ -23,7 +24,7 @@ const parseNum = (num) => {
     const value = bigValue + smallValue;
     return valueSymbol === "-" ? value * BigInt(-1) : value;
   } catch {
-    return Number.NaN;
+    return NaN;
   }
 };
 export {