@vope/utils 1.6.0 → 1.6.2

package/dist/index.cjs.js

@@ -20,23 +20,43 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Cron: () => Cron,
+  DayLastValue: () => DayLastValue,
+  DigitsValue: () => DigitsValue,
   FlexTable: () => FlexTable,
+  InvalidValue: () => InvalidValue,
   MemoryBasic: () => MemoryBasic,
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
   MemorySimple: () => MemorySimple,
   Neo4j: () => Neo4j,
   Neo4jAhchors: () => Neo4jAhchors,
+  RangeValue: () => RangeValue,
   Subscriber: () => Subscriber,
   Union: () => Union,
+  WeekLastValue: () => WeekLastValue,
+  WildcardValue: () => WildcardValue,
   clamp: () => clamp,
   classnames: () => classnames,
   compareVersion: () => compareVersion,
   connectURLParams: () => connectURLParams,
+  createCronRegexText: () => createCronRegexText,
   css: () => css,
   cubeURLParams: () => cubeURLParams,
   deconPowersSum: () => deconPowersSum,
   deepWeakEqual: () => deepWeakEqual,
+  default_max_day: () => default_max_day,
+  default_max_hour: () => default_max_hour,
+  default_max_minute: () => default_max_minute,
+  default_max_month: () => default_max_month,
+  default_max_second: () => default_max_second,
+  default_max_week: () => default_max_week,
+  default_min_day: () => default_min_day,
+  default_min_hour: () => default_min_hour,
+  default_min_minute: () => default_min_minute,
+  default_min_month: () => default_min_month,
+  default_min_second: () => default_min_second,
+  default_min_week: () => default_min_week,
   desensDecrypt: () => desensDecrypt,
   desensEncrypt: () => desensEncrypt,
   desensReplace: () => desensReplace,
@@ -47,16 +67,23 @@ __export(index_exports, {
   hash8strings: () => hash8strings,
   inputRegex: () => inputRegex,
   isClass: () => isClass,
+  isDayLastValue: () => isDayLastValue,
+  isDigitsValue: () => isDigitsValue,
   isEmpty: () => isEmpty,
+  isInvalidValue: () => isInvalidValue,
   isKey: () => isKey,
   isNull: () => isNull,
+  isRangeValue: () => isRangeValue,
+  isWeekLastValue: () => isWeekLastValue,
+  isWildcardValue: () => isWildcardValue,
   joinPaths: () => joinPaths,
   loadImage: () => loadImage,
   once: () => once,
   parseNum: () => parseNum,
   rotateAngle: () => rotateAngle,
   rotateRad: () => rotateRad,
-  wait: () => wait
+  wait: () => wait,
+  weekDic: () => weekDic
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -149,8 +176,654 @@ var hash8object = (list, key) => list.reduce((caches, data) => {
   return caches;
 }, /* @__PURE__ */ new Map());
 
-// src/desens.ts
+// src/cron.ts
 var import_lodash_es2 = require("lodash-es");
+var {
+  parseInt,
+  isInteger,
+  MAX_SAFE_INTEGER
+} = Number;
+var Dic = class {
+  constructor(dics) {
+    this.dics = dics;
+    this.keys = hash8json(dics, "key");
+    this.values = hash8json(dics, "value");
+  }
+  keys;
+  values;
+  item(key) {
+    return this.keys[key]?.value;
+  }
+  at(value) {
+    return this.values[value]?.key;
+  }
+  reduce(callbackfn, initialValue) {
+    return this.dics.reduce(callbackfn, initialValue);
+  }
+};
+var weekDic = new Dic([
+  {
+    key: "SUN",
+    value: 0
+  },
+  {
+    key: "MON",
+    value: 1
+  },
+  {
+    key: "TUE",
+    value: 2
+  },
+  {
+    key: "WED",
+    value: 3
+  },
+  {
+    key: "THU",
+    value: 4
+  },
+  {
+    key: "FRI",
+    value: 5
+  },
+  {
+    key: "SAT",
+    value: 6
+  }
+]);
+var place_value = 0;
+var default_max_second = 59;
+var default_min_second = 0;
+var default_max_minute = default_max_second;
+var default_min_minute = default_min_second;
+var default_max_hour = 23;
+var default_min_hour = 0;
+var default_max_day = 31;
+var default_min_day = 1;
+var default_max_month = 12;
+var default_min_month = 1;
+var default_max_week = 6;
+var default_min_week = 0;
+var re_single_number_text = "\\d";
+var createCronRegexText = (options = {}) => {
+  const {
+    enableSlot = true,
+    enableSecond = true,
+    enableYear = true,
+    enableMax = true,
+    enableInvalid = true,
+    enableDayLast = true,
+    enableWeekLast = true,
+    enableWeekSupport7 = true,
+    enableWeekSupportDic = true,
+    enableDicEnumSupportMixin = true,
+    enablePrefixZero
+  } = options;
+  const enableMaxSplit = enableMax && (options.enableIncrementMax ?? true);
+  const singleNumberMatch = (end, fromZero) => {
+    const start = fromZero ? 0 : 1;
+    if (end === start) {
+      return `${end}`;
+    } else if (end < 3 + start) {
+      let text = "";
+      for (let i = start; i <= end; i++) {
+        text += i;
+      }
+      return `[${text}]`;
+    } else if (start === 0 && end === 9) {
+      return re_single_number_text;
+    } else {
+      return `[${start}-${end}]`;
+    }
+  };
+  const numberMatch = (max, fromZero) => {
+    if (max === place_value) return `[1-9]${re_single_number_text}*`;
+    if (max < 10) return singleNumberMatch(max, fromZero);
+    const mod = max % 10;
+    const quot = (max - mod) / 10;
+    let text = "";
+    if (fromZero) {
+      text = re_single_number_text;
+    } else {
+      text = singleNumberMatch(9);
+    }
+    text += "|";
+    if (mod === 9) {
+      text += singleNumberMatch(quot) + re_single_number_text;
+    } else {
+      if (quot > 1) {
+        text += singleNumberMatch(quot - 1) + re_single_number_text + "|";
+      }
+      text += `${quot}${singleNumberMatch(mod, true)}`;
+    }
+    return `(?:${text})`;
+  };
+  const numberMatchByPrefix = (max, fromZero) => {
+    const text = numberMatch(max, fromZero);
+    return enablePrefixZero ? "0*" + text : text;
+  };
+  const mixin = (text) => {
+    let tmp = "";
+    for (const char of text) {
+      const code = char.charCodeAt(0);
+      if (code > 64 && code < 91) {
+        tmp += `[${char.toLocaleLowerCase()}${char}]`;
+      } else if (code > 96 && code < 123) {
+        tmp += `[${char}${char.toLocaleUpperCase()}]`;
+      } else {
+        tmp += char;
+      }
+    }
+    return tmp;
+  };
+  const generate = ({
+    type,
+    max,
+    split,
+    dic,
+    invalid,
+    last,
+    fromZero
+  }) => {
+    const list = [];
+    invalid && list.push("\\?");
+    const template = [numberMatchByPrefix(max, fromZero)];
+    let lastTemplate;
+    if (last) {
+      if (type === "D") {
+        lastTemplate = `L(?:-${numberMatchByPrefix(max - 1)})?`;
+      } else if (type === "w") {
+        lastTemplate = `${numberMatchByPrefix(max, true)}L`;
+      }
+    }
+    if (type === "w" && dic) {
+      template.push(
+        dic.reduce((tmp2, { key }) => {
+          const text = enableDicEnumSupportMixin ? mixin(key) : key;
+          return tmp2 ? tmp2 + "|" + text : text;
+        }, "")
+      );
+    }
+    let tmp = template.length > 1 ? `(?:${template.join("|")})` : template[0];
+    if (lastTemplate) {
+      tmp = `(?:\\*|(?:${lastTemplate}|${tmp}(?:-${tmp})?)(?:,(?:${lastTemplate}|${tmp}(?:-${tmp})?))*)`;
+    } else {
+      tmp = `(?:\\*|${tmp}(?:-${tmp})?(?:,${tmp}(?:-${tmp})?)*)`;
+    }
+    list.push(`${tmp}(?:\\/${numberMatchByPrefix(split)})?`);
+    return list.join("|");
+  };
+  let regex = "";
+  const join = (config, isLast) => {
+    const space = "\\s+";
+    let code = generate(config);
+    if (enableSlot) {
+      code = `(?<${config.type}>${code})`;
+    } else {
+      code = `(${code})`;
+    }
+    if (!isLast) {
+      code += space;
+    }
+    if (config.partial) {
+      if (isLast) {
+        regex = regex.slice(0, space.length * -1) + `(?:${space}${code})?`;
+        return;
+      } else {
+        code = `(?:${code})?`;
+      }
+    }
+    regex += code;
+  };
+  enableSecond && join({
+    type: "s",
+    max: enableMax ? default_max_second : place_value,
+    split: enableMaxSplit ? default_max_second : place_value,
+    fromZero: !default_min_second
+  });
+  join({
+    type: "m",
+    max: enableMax ? default_max_minute : place_value,
+    split: enableMaxSplit ? default_max_minute : place_value,
+    fromZero: !default_min_minute
+  });
+  join({
+    type: "h",
+    max: enableMax ? default_max_hour : place_value,
+    split: enableMaxSplit ? default_max_hour : place_value,
+    fromZero: !default_min_hour
+  });
+  join({
+    type: "D",
+    max: enableMax ? default_max_day : place_value,
+    split: enableMaxSplit ? default_max_day : place_value,
+    invalid: enableInvalid,
+    last: enableDayLast,
+    fromZero: !default_min_day
+  });
+  join({
+    type: "M",
+    max: enableMax ? default_max_month : place_value,
+    split: enableMaxSplit ? default_max_month : place_value,
+    fromZero: !default_min_month
+  });
+  join((() => {
+    const max = enableWeekSupport7 ? 7 : default_max_week;
+    const config = {
+      type: "w",
+      max: enableMax ? max : place_value,
+      split: enableMaxSplit ? 7 : place_value,
+      fromZero: !default_min_week,
+      invalid: enableInvalid,
+      last: enableWeekLast
+    };
+    if (enableWeekSupportDic) {
+      config.dic = weekDic;
+    }
+    return config;
+  })(), !enableYear);
+  enableYear && join({
+    type: "Y",
+    max: place_value,
+    split: place_value,
+    fromZero: true,
+    partial: true
+  }, true);
+  return {
+    regex,
+    enableSlot,
+    enableSecond,
+    enableYear,
+    enableDayLast,
+    enableWeekLast,
+    enableInvalid
+  };
+};
+var InvalidValue = class {
+  constructor(isEnableInvalid) {
+    this.isEnableInvalid = isEnableInvalid;
+  }
+  text() {
+    return this.isEnableInvalid ? "?" : "*";
+  }
+};
+var isInvalidValue = (value) => value instanceof InvalidValue;
+var LastValue = class {
+  constructor(value) {
+    this.value = value;
+  }
+};
+var DayLastValue = class extends LastValue {
+  text() {
+    const { value } = this;
+    return "L" + (value ? `-${value}` : "");
+  }
+};
+var isDayLastValue = (value) => value instanceof DayLastValue;
+var WeekLastValue = class extends LastValue {
+  text() {
+    return `${this.value}L`;
+  }
+};
+var isWeekLastValue = (value) => value instanceof WeekLastValue;
+var WildcardValue = class {
+  text() {
+    return "*";
+  }
+};
+var isWildcardValue = (value) => value instanceof WildcardValue;
+var RangeValue = class {
+  constructor(start, stop) {
+    this.start = start;
+    this.stop = stop;
+  }
+  text() {
+    return `${this.start}-${this.stop}`;
+  }
+};
+var isRangeValue = (value) => value instanceof RangeValue;
+var DigitsValue = class {
+  constructor(values, increment) {
+    this.values = values;
+    this.increment = increment;
+  }
+  text() {
+    const { values, increment } = this;
+    let tmp;
+    if (Array.isArray(values)) {
+      tmp = values.reduce((caches, data) => {
+        let tmp2;
+        if ((0, import_lodash_es2.isNumber)(data)) {
+          tmp2 = `${data}`;
+        } else {
+          tmp2 = data.text();
+        }
+        return caches ? caches + "," + tmp2 : tmp2;
+      }, "");
+    } else {
+      tmp = values.text();
+    }
+    return increment ? `${tmp}/${increment}` : tmp;
+  }
+};
+var isDigitsValue = (value) => value instanceof DigitsValue;
+var re_num = /\d/;
+var parseDigit = (text) => {
+  if (re_num.test(text[0])) {
+    return parseInt(text);
+  } else {
+    return weekDic.item(text.toLocaleUpperCase());
+  }
+};
+var parseDigits = (text) => {
+  return text.split(",").map((text2) => {
+    const [a, b] = text2.split("-");
+    if (a === "L" && b === void 0) {
+      return new DayLastValue(0);
+    } else if (b === void 0) {
+      if (a.slice(-1) === "L") {
+        return new WeekLastValue(parseInt(a.slice(0, -1)));
+      } else {
+        return parseDigit(a);
+      }
+    } else {
+      if (a === "L") {
+        return new DayLastValue(parseInt(b));
+      } else {
+        return new RangeValue(parseDigit(a), parseDigit(b));
+      }
+    }
+  });
+};
+var validate = (value, min, max) => {
+  if (isInteger(value)) {
+    return value >= min && value <= max;
+  } else if (Array.isArray(value)) {
+    if (value.length !== 2) return false;
+    const [a, b] = value;
+    return isInteger(a) && isInteger(b) && a <= b && a >= min && b <= max;
+  }
+  return false;
+};
+var validateIncrement = (value, min, max) => {
+  return isInteger(value) && value > 0 && value >= min && value <= max;
+};
+var formaterDigits = (value, min, max) => {
+  let values;
+  if (value === "*") {
+    values = new WildcardValue();
+  } else if (Array.isArray(value)) {
+    const tmp = [];
+    value.some((data) => {
+      if (validate(data, min, max)) {
+        tmp.push(
+          (0, import_lodash_es2.isNumber)(data) ? data : new RangeValue(data[0], data[1])
+        );
+        return false;
+      } else {
+        return true;
+      }
+    }) || (values = tmp);
+  } else if (validate(value, min, max)) {
+    values = [value];
+  }
+  return values;
+};
+var formaterLastDigits = (value, min, max, prototype) => {
+  let values;
+  if (value === "*") {
+    values = new WildcardValue();
+  } else {
+    const tmp = [];
+    const list = Array.isArray(value) ? value : [value];
+    list.some((data) => {
+      if ((0, import_lodash_es2.isString)(data)) {
+        const result = parseDigits(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_es2.isNumber)(data) ? data : new RangeValue(data[0], data[1])
+        );
+        return false;
+      }
+      return true;
+    }) || (values = tmp);
+  }
+  return values;
+};
+var Parse = class {
+  constructor(second, minute, hour, day, month, week, year, cron) {
+    this.cron = cron;
+    if (second) {
+      this.second = this.parse(second);
+    }
+    this.minute = this.parse(minute);
+    this.hour = this.parse(hour);
+    this.day = this.parse(day);
+    this.month = this.parse(month);
+    this.week = this.parse(week);
+    if (year) {
+      this.year = this.parse(year);
+    }
+  }
+  second;
+  minute;
+  hour;
+  day;
+  month;
+  week;
+  year;
+  parse(text) {
+    if (text === "?") return new InvalidValue(this.cron.isEnableInvalid);
+    const [slices, increment] = text.split("/");
+    return new DigitsValue(
+      slices === "*" ? new WildcardValue() : parseDigits(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);
+    if (!values) return false;
+    const second = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_second, default_max_second)) {
+      second.increment = increment;
+    }
+    this.second = second;
+    return true;
+  }
+  setMinute(value, increment) {
+    const values = formaterDigits(value, default_min_minute, default_max_minute);
+    if (!values) return false;
+    const minute = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_minute, default_max_minute)) {
+      minute.increment = increment;
+    }
+    this.minute = minute;
+    return true;
+  }
+  setHour(value, increment) {
+    const values = formaterDigits(value, default_min_hour, default_max_hour);
+    if (!values) return false;
+    const hour = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_hour, default_max_hour)) {
+      hour.increment = increment;
+    }
+    this.hour = hour;
+    return true;
+  }
+  setDayInvalid() {
+    this.day = new InvalidValue(this.cron.isEnableInvalid);
+    if (this.week instanceof InvalidValue) {
+      this.week = new DigitsValue(new WildcardValue());
+    }
+  }
+  setDay(value, increment) {
+    let values;
+    if (value === "?") {
+      this.setDayInvalid();
+      return true;
+    } else {
+      const tmp2 = formaterLastDigits(value, default_min_day, default_max_day, DayLastValue);
+      if (!tmp2) return false;
+      values = tmp2;
+    }
+    const tmp = new DigitsValue(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 (this.cron.isEnableInvalid) {
+        this.week = new InvalidValue(true);
+      } else {
+        week.values = new WildcardValue();
+        week.increment = void 0;
+      }
+    }
+    return true;
+  }
+  setMonth(value, increment) {
+    const values = formaterDigits(value, default_min_month, default_max_month);
+    if (!values) return false;
+    const month = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_month, default_max_month)) {
+      month.increment = increment;
+    }
+    this.month = month;
+    return true;
+  }
+  setWeekInvalid() {
+    this.week = new InvalidValue(this.cron.isEnableInvalid);
+    if (this.day instanceof InvalidValue) {
+      this.day = new DigitsValue(new WildcardValue());
+    }
+  }
+  setWeek(value, increment) {
+    let values;
+    if (value === "?") {
+      this.setWeekInvalid();
+      return true;
+    } else {
+      const tmp2 = formaterLastDigits(value, default_min_week, default_max_week, WeekLastValue);
+      if (!tmp2) return false;
+      values = tmp2;
+    }
+    const tmp = new DigitsValue(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 (this.cron.isEnableInvalid) {
+        this.day = new InvalidValue(true);
+      } else {
+        day.values = new WildcardValue();
+        day.increment = void 0;
+      }
+    }
+    return true;
+  }
+  setYear(value, increment) {
+    if (!this.cron.isEnableYear) return false;
+    const values = formaterDigits(value, 0, MAX_SAFE_INTEGER);
+    if (!values) return false;
+    const year = new DigitsValue(values);
+    if (validateIncrement(increment, 0, MAX_SAFE_INTEGER)) {
+      year.increment = increment;
+    }
+    this.year = year;
+    return true;
+  }
+  text() {
+    const { cron, second, year } = this;
+    const list = [];
+    if (cron.isEnableSecond) {
+      list.push(second ? second.text() : "0");
+    }
+    list.push(this.minute.text());
+    list.push(this.hour.text());
+    list.push(this.day.text());
+    list.push(this.month.text());
+    list.push(this.week.text());
+    if (cron.isEnableYear && year) {
+      list.push(year.text());
+    }
+    return list.join(" ");
+  }
+};
+var Cron = class {
+  #options;
+  #regex;
+  get isEnableSecond() {
+    return this.#options.enableSecond;
+  }
+  get isEnableYear() {
+    return this.#options.enableYear;
+  }
+  get isEnableDayLast() {
+    return this.#options.enableDayLast;
+  }
+  get isEnableWeekLast() {
+    return this.#options.enableWeekLast;
+  }
+  get isEnableInvalid() {
+    return this.#options.enableInvalid;
+  }
+  constructor(options) {
+    const { regex } = this.#options = createCronRegexText(options);
+    this.#regex = new RegExp(`^${regex}$`);
+  }
+  parse(text) {
+    const matchs = text.trim().match(this.#regex);
+    if (!matchs) return;
+    const config = this.#options;
+    const { enableSecond, enableYear } = config;
+    let second;
+    let minute;
+    let hour;
+    let day;
+    let month;
+    let week;
+    let year;
+    if (config.enableSlot) {
+      const groups = matchs.groups;
+      if (enableSecond) {
+        second = groups.s;
+      }
+      minute = groups.m;
+      hour = groups.h;
+      day = groups.D;
+      month = groups.M;
+      week = groups.w;
+      if (enableYear) {
+        year = groups.Y;
+      }
+    } else {
+      let count = 1;
+      if (enableSecond) {
+        second = matchs[count++];
+      }
+      minute = matchs[count++];
+      hour = matchs[count++];
+      day = matchs[count++];
+      month = matchs[count++];
+      week = matchs[count++];
+      if (enableYear) {
+        year = matchs[count++];
+      }
+    }
+    return new Parse(second, minute, hour, day, month, week, year, this);
+  }
+};
+
+// src/desens.ts
+var import_lodash_es3 = require("lodash-es");
 var desensEncrypt = (plaintext, encrypt) => {
   const rules = [];
   let point = -1;
@@ -189,7 +862,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_es2.isString)(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
+    const replaceValue = (0, import_lodash_es3.isString)(replacer) ? replacer.repeat(size) : replacer[Symbol.replace](part, size);
     cache += ciphertext.slice(from, start + offset) + replaceValue;
     from = start + offset + modify;
     offset += modify - size;
@@ -939,12 +1612,12 @@ var once = (func, thisArg) => {
 };
 
 // src/parse/num.ts
-var import_lodash_es3 = require("lodash-es");
+var import_lodash_es4 = require("lodash-es");
 var pow = Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
-var re_num = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
+var re_num2 = /^([-+]?)0*(\d+)(?:(n)|(?:\.(\d+))?(?:[Ee]([-+]?)(\d+))?)$/;
 var parseNum = (num) => {
-  if ((0, import_lodash_es3.isNumber)(num) || typeof num === "bigint") return num;
-  const match = num.match(re_num);
+  if ((0, import_lodash_es4.isNumber)(num) || typeof num === "bigint") return num;
+  const match = num.match(re_num2);
   if (!match) return Number.NaN;
   const [, valueSymbol, integer, bigint, decimal, powSymbol, powValue] = match;
   if (bigint === "n") return BigInt(valueSymbol + integer);
@@ -972,7 +1645,7 @@ var parseNum = (num) => {
 var rotateAngle = (from, angle, visit) => rotateRad(from, angle / 180 * Math.PI, visit);
 
 // src/serialize/url-params.ts
-var import_lodash_es4 = require("lodash-es");
+var import_lodash_es5 = require("lodash-es");
 var cubes = {
   string: (text) => text,
   boolean: (text) => text === "true",
@@ -997,7 +1670,7 @@ var cubeURLParams = (text, serializes) => {
   for (const [key, value] of params) {
     const serialize = serializes[key];
     if (!serialize) continue;
-    if ((0, import_lodash_es4.isString)(serialize) && isKey(serialize, cubes)) {
+    if ((0, import_lodash_es5.isString)(serialize) && isKey(serialize, cubes)) {
       result[key] = cubes[serialize](value);
     } else {
       result[key] = serialize.cube(value);
@@ -1015,21 +1688,21 @@ var flatURLParams = (data, serializes) => {
     if (!serialize) continue;
     params.append(
       key,
-      (0, import_lodash_es4.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
+      (0, import_lodash_es5.isString)(serialize) && isKey(serialize, flats) ? flats[serialize](value) : serialize.flat(value)
     );
   }
   return params.toString();
 };
 
 // src/style/css.ts
-var import_lodash_es5 = require("lodash-es");
+var import_lodash_es6 = 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_es5.isString)(data)) {
+    if ((0, import_lodash_es6.isString)(data)) {
       list.push(data);
     } else if (Array.isArray(data)) {
       const result = css(...data);
@@ -1256,8 +1929,18 @@ var joinPaths = (...list) => {
 };
 
 // src/url/params.ts
+var rasterize = (data) => {
+  const params = new URLSearchParams();
+  for (const key in data) {
+    params.append(
+      key,
+      data[key]
+    );
+  }
+  return params.toString();
+};
 var connectURLParams = (url, params, serializes) => {
-  const query = flatURLParams(params, serializes);
+  const query = serializes ? flatURLParams(params, serializes) : rasterize(params);
   return query ? url.includes("?") ? url + "&" + query : url + "?" + query : url;
 };