phecda-core 2.0.0-alpha.7 → 2.0.1-alpha.0

package/dist/index.global.js

@@ -1,682 +0,0 @@
-"use strict";
-var Phecda = (() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to2, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to2, key) && key !== except)
-          __defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to2;
-  };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    Assign: () => Assign,
-    Bind: () => Bind,
-    Clear: () => Clear,
-    DataMap: () => DataMap,
-    Effect: () => Effect,
-    Empty: () => Empty,
-    Err: () => Err,
-    Expose: () => Expose,
-    Global: () => Global,
-    Ignore: () => Ignore,
-    Init: () => Init,
-    Inject: () => Inject,
-    Pipe: () => Pipe,
-    Provide: () => Provide,
-    Rule: () => Rule,
-    Storage: () => Storage,
-    Tag: () => Tag,
-    Watcher: () => Watcher,
-    activeInstance: () => activeInstance,
-    addDecoToClass: () => addDecoToClass,
-    classToValue: () => classToValue,
-    getBind: () => getBind,
-    getExposeKey: () => getExposeKey,
-    getHandler: () => getHandler,
-    getInitEvent: () => getInitEvent,
-    getModelState: () => getModelState,
-    getOwnExposeKey: () => getOwnExposeKey,
-    getOwnHandler: () => getOwnHandler,
-    getOwnIgnoreKey: () => getOwnIgnoreKey,
-    getOwnInitEvent: () => getOwnInitEvent,
-    getOwnModelState: () => getOwnModelState,
-    getOwnState: () => getOwnState,
-    getProperty: () => getProperty,
-    getState: () => getState,
-    getTag: () => getTag,
-    init: () => init,
-    injectProperty: () => injectProperty,
-    isArray: () => isArray,
-    isBoolean: () => isBoolean,
-    isCnName: () => isCnName,
-    isDate: () => isDate,
-    isEnName: () => isEnName,
-    isHexColor: () => isHexColor,
-    isIdCard: () => isIdCard,
-    isLandline: () => isLandline,
-    isMailBox: () => isMailBox,
-    isMobile: () => isMobile,
-    isNumber: () => isNumber,
-    isObject: () => isObject,
-    isOption: () => isOption,
-    isPhecda: () => isPhecda,
-    isPostalCode: () => isPostalCode,
-    isString: () => isString,
-    isWechat: () => isWechat,
-    plainToClass: () => plainToClass,
-    regisHandler: () => regisHandler,
-    regisInitEvent: () => regisInitEvent,
-    register: () => register,
-    registerAsync: () => registerAsync,
-    setExposeKey: () => setExposeKey,
-    setIgnoreKey: () => setIgnoreKey,
-    setModelVar: () => setModelVar,
-    setState: () => setState,
-    snapShot: () => snapShot,
-    to: () => to,
-    toNumber: () => toNumber,
-    toString: () => toString,
-    validate: () => validate
-  });
-
-  // src/core.ts
-  function isPhecda(target) {
-    return target && !!target.prototype._namespace;
-  }
-  __name(isPhecda, "isPhecda");
-  function init(target) {
-    if (!target)
-      return;
-    if (!target.hasOwnProperty("_namespace")) {
-      target._namespace = {
-        __INIT_EVENT__: /* @__PURE__ */ new Set(),
-        __EXPOSE_VAR__: /* @__PURE__ */ new Set(),
-        __IGNORE_VAR__: /* @__PURE__ */ new Set(),
-        __STATE_VAR__: /* @__PURE__ */ new Set(),
-        __STATE_HANDLER__: /* @__PURE__ */ new Map(),
-        __STATE_NAMESPACE__: /* @__PURE__ */ new Map()
-      };
-    }
-  }
-  __name(init, "init");
-  function regisInitEvent(target, key) {
-    init(target);
-    target._namespace.__INIT_EVENT__.add(key);
-  }
-  __name(regisInitEvent, "regisInitEvent");
-  function getOwnInitEvent(target) {
-    if (!target?._namespace)
-      return [];
-    return [
-      ...target._namespace.__INIT_EVENT__
-    ];
-  }
-  __name(getOwnInitEvent, "getOwnInitEvent");
-  function getInitEvent(target) {
-    let proto = Object.getPrototypeOf(target);
-    const set = /* @__PURE__ */ new Set();
-    while (proto?._namespace) {
-      proto._namespace.__INIT_EVENT__.forEach((item) => set.add(item));
-      proto = Object.getPrototypeOf(proto);
-    }
-    return [
-      ...set
-    ];
-  }
-  __name(getInitEvent, "getInitEvent");
-  function setModelVar(target, key) {
-    init(target);
-    target._namespace.__STATE_VAR__.add(key);
-    setExposeKey(target, key);
-  }
-  __name(setModelVar, "setModelVar");
-  function setExposeKey(target, key) {
-    init(target);
-    target._namespace.__EXPOSE_VAR__.add(key);
-  }
-  __name(setExposeKey, "setExposeKey");
-  function setIgnoreKey(target, key) {
-    init(target);
-    target._namespace.__IGNORE_VAR__.add(key);
-  }
-  __name(setIgnoreKey, "setIgnoreKey");
-  function getOwnModelState(target) {
-    target = Object.getPrototypeOf(target);
-    return [
-      ...target._namespace.__STATE_VAR__
-    ];
-  }
-  __name(getOwnModelState, "getOwnModelState");
-  function getModelState(target) {
-    let proto = Object.getPrototypeOf(target);
-    const set = /* @__PURE__ */ new Set();
-    while (proto?._namespace) {
-      proto._namespace.__STATE_VAR__.forEach((item) => set.add(item));
-      proto = Object.getPrototypeOf(proto);
-    }
-    return [
-      ...set
-    ];
-  }
-  __name(getModelState, "getModelState");
-  function getOwnExposeKey(target) {
-    target = Object.getPrototypeOf(target);
-    return [
-      ...target._namespace.__EXPOSE_VAR__
-    ].filter((item) => !target._namespace.__IGNORE_VAR__.has(item));
-  }
-  __name(getOwnExposeKey, "getOwnExposeKey");
-  function getExposeKey(target) {
-    let proto = Object.getPrototypeOf(target);
-    const set = /* @__PURE__ */ new Set();
-    while (proto?._namespace) {
-      [
-        ...proto._namespace.__EXPOSE_VAR__
-      ].forEach((item) => !proto._namespace.__IGNORE_VAR__.has(item) && set.add(item));
-      proto = Object.getPrototypeOf(proto);
-    }
-    return [
-      ...set
-    ];
-  }
-  __name(getExposeKey, "getExposeKey");
-  function getOwnIgnoreKey(target) {
-    if (!target?._namespace)
-      return [];
-    return [
-      ...target._namespace.__IGNORE_VAR__
-    ];
-  }
-  __name(getOwnIgnoreKey, "getOwnIgnoreKey");
-  function regisHandler(target, key, handler) {
-    init(target);
-    if (!target._namespace.__STATE_HANDLER__.has(key))
-      target._namespace.__STATE_HANDLER__.set(key, [
-        handler
-      ]);
-    else
-      target._namespace.__STATE_HANDLER__.get(key).push(handler);
-  }
-  __name(regisHandler, "regisHandler");
-  function getOwnHandler(target, key) {
-    if (!target?._namespace)
-      return [];
-    return target._namespace.__STATE_HANDLER__.get(key) || [];
-  }
-  __name(getOwnHandler, "getOwnHandler");
-  function getHandler(target, key) {
-    let proto = Object.getPrototypeOf(target);
-    const set = /* @__PURE__ */ new Set();
-    while (proto?._namespace) {
-      proto._namespace.__STATE_HANDLER__.get(key)?.forEach((item) => set.add(item));
-      proto = Object.getPrototypeOf(proto);
-    }
-    return [
-      ...set
-    ];
-  }
-  __name(getHandler, "getHandler");
-  function setState(target, key, state) {
-    init(target);
-    const namespace = target._namespace.__STATE_NAMESPACE__;
-    namespace.set(key, state);
-  }
-  __name(setState, "setState");
-  function getOwnState(target, key) {
-    target = Object.getPrototypeOf(target);
-    return target._namespace.__STATE_NAMESPACE__.get(key) || {};
-  }
-  __name(getOwnState, "getOwnState");
-  function getState(target, key) {
-    let proto = Object.getPrototypeOf(target);
-    let ret = {};
-    while (proto?._namespace) {
-      const state = proto._namespace.__STATE_NAMESPACE__.get(key);
-      if (state)
-        ret = {
-          ...state,
-          ...ret
-        };
-      proto = Object.getPrototypeOf(proto);
-    }
-    return ret;
-  }
-  __name(getState, "getState");
-  function register(instance) {
-    const stateVars = getExposeKey(instance);
-    for (const item of stateVars) {
-      const handlers = getHandler(instance, item);
-      for (const hanlder of handlers)
-        hanlder.init?.(instance);
-    }
-  }
-  __name(register, "register");
-  async function registerAsync(instance) {
-    const stateVars = getExposeKey(instance);
-    for (const item of stateVars) {
-      const handlers = getHandler(instance, item);
-      for (const hanlder of handlers)
-        await hanlder.init?.(instance);
-    }
-  }
-  __name(registerAsync, "registerAsync");
-
-  // src/decorators.ts
-  function Init(target, key) {
-    setModelVar(target, key);
-    regisHandler(target, key, {
-      async init(instance) {
-        instance[key]();
-      }
-    });
-  }
-  __name(Init, "Init");
-  function Bind(value) {
-    return (target, k) => {
-      setModelVar(target, k);
-      setState(target, k, {
-        value
-      });
-    };
-  }
-  __name(Bind, "Bind");
-  function Rule(rule, info, meta) {
-    return (obj, key) => {
-      setModelVar(obj, key);
-      regisHandler(obj, key, {
-        rule,
-        info,
-        meta
-      });
-    };
-  }
-  __name(Rule, "Rule");
-  function Ignore(target, key) {
-    setIgnoreKey(target, key);
-  }
-  __name(Ignore, "Ignore");
-  function Clear(target, key) {
-    init(target);
-    target._namespace.__INIT_EVENT__.delete(key);
-    target._namespace.__EXPOSE_VAR__.delete(key);
-    target._namespace.__IGNORE_VAR__.delete(key);
-    target._namespace.__STATE_VAR__.delete(key);
-    target._namespace.__STATE_HANDLER__.delete(key);
-    target._namespace.__STATE_NAMESPACE__.delete(key);
-  }
-  __name(Clear, "Clear");
-  function Err(cb) {
-    return (target, key) => {
-      setModelVar(target, key);
-      regisHandler(target, key, {
-        error: cb
-      });
-    };
-  }
-  __name(Err, "Err");
-  function Expose(target, key) {
-    setExposeKey(target, key);
-  }
-  __name(Expose, "Expose");
-  function Pipe(v) {
-    return (obj, key) => {
-      setModelVar(obj, key);
-      regisHandler(obj, key, {
-        async pipe(instance) {
-          const tasks = v.value;
-          for (const task of tasks)
-            instance[key] = await task(instance[key]);
-        }
-      });
-    };
-  }
-  __name(Pipe, "Pipe");
-  function Tag(tag) {
-    return (target) => {
-      target.prototype.__TAG__ = tag;
-    };
-  }
-  __name(Tag, "Tag");
-  function Assign(cb) {
-    return (target) => {
-      init(target.prototype);
-      setModelVar(target.prototype, "__CLASS");
-      regisHandler(target.prototype, "__CLASS", {
-        init: async (instance) => {
-          const value = await cb(instance);
-          if (value && typeof value === "object" && !Array.isArray(value)) {
-            for (const i in value)
-              instance[i] = value[i];
-          }
-        }
-      });
-    };
-  }
-  __name(Assign, "Assign");
-  function Global(target) {
-    init(target.prototype);
-    setModelVar(target.prototype, "__CLASS");
-    regisHandler(target.prototype, "__CLASS", {
-      init: async (instance) => {
-        const tag = instance.__TAG__;
-        if (!tag)
-          return;
-        if (!globalThis.__PHECDA__)
-          globalThis.__PHECDA__ = {};
-        globalThis.__PHECDA__[tag] = instance.constructor;
-      }
-    });
-  }
-  __name(Global, "Global");
-  function Empty(_target) {
-  }
-  __name(Empty, "Empty");
-  var DataMap = {};
-  function Provide(key, value) {
-    DataMap[key] = value;
-  }
-  __name(Provide, "Provide");
-  var EmptyProxy = new Proxy(Empty, {
-    apply() {
-      return EmptyProxy;
-    }
-  });
-  function Inject(key) {
-    return DataMap[key] || EmptyProxy;
-  }
-  __name(Inject, "Inject");
-
-  // src/utils.ts
-  async function validate(p, v) {
-    if (typeof p === "string" || typeof p === "number") {
-      if (v === p)
-        return true;
-    }
-    if (typeof p === "function")
-      return p(v);
-    if (p instanceof RegExp)
-      return p.test(v);
-    return false;
-  }
-  __name(validate, "validate");
-  function getTag(Model) {
-    return Model.prototype?.__TAG__;
-  }
-  __name(getTag, "getTag");
-
-  // src/helper.ts
-  function getBind(Model) {
-    const instance = new Model();
-    const keys = getModelState(instance);
-    const ret = {};
-    for (const item of keys) {
-      const state = getState(instance, item);
-      if (state.value)
-        ret[item] = state.value;
-    }
-    return ret;
-  }
-  __name(getBind, "getBind");
-  async function plainToClass(Model, input, options = {}) {
-    const data = new Model();
-    const err = [];
-    const stateVars = getModelState(data);
-    for (const item of stateVars) {
-      data[item] = input[item];
-      const handlers = getHandler(data, item);
-      if (handlers) {
-        if (options.collectError !== false) {
-          for (const handler of handlers) {
-            const rule = handler.rule;
-            const ret = await validate(rule, data[item]);
-            if (ret === "ok")
-              break;
-            if (rule && !ret) {
-              err.push(typeof handler.info === "function" ? handler.info(item) : handler.info);
-              if (!options.collectError)
-                break;
-            }
-          }
-        }
-        if (err.length > 0 && !options.transform)
-          return {
-            err,
-            data
-          };
-        if (options.transform !== false) {
-          for (const handler of handlers)
-            await handler.pipe?.(data);
-        }
-      }
-    }
-    return {
-      data,
-      err
-    };
-  }
-  __name(plainToClass, "plainToClass");
-  function classToValue(instance) {
-    const data = {};
-    const exposeVars = getExposeKey(instance);
-    for (const item of exposeVars)
-      data[item] = instance[item];
-    return data;
-  }
-  __name(classToValue, "classToValue");
-  function to(task, oldTasks) {
-    const tasks = oldTasks || [];
-    tasks.push(task);
-    return {
-      to: (task2) => to(task2, tasks),
-      value: tasks
-    };
-  }
-  __name(to, "to");
-  function snapShot(data) {
-    const snap = {};
-    for (const i in data)
-      snap[i] = data[i];
-    return {
-      data,
-      clear() {
-        for (const i in snap)
-          delete data[i];
-      },
-      apply() {
-        for (const i in snap)
-          data[i] = snap[i];
-      }
-    };
-  }
-  __name(snapShot, "snapShot");
-  function addDecoToClass(c, key, handler, type = "normal") {
-    handler(type === "normal" ? c.prototype : c, key);
-  }
-  __name(addDecoToClass, "addDecoToClass");
-
-  // src/namespace.ts
-  var activeInstance = {};
-  function injectProperty(key, value) {
-    activeInstance[key] = value;
-    return activeInstance;
-  }
-  __name(injectProperty, "injectProperty");
-  function getProperty(key) {
-    return activeInstance[key];
-  }
-  __name(getProperty, "getProperty");
-
-  // src/custom/decorator.ts
-  function Watcher(eventName, options) {
-    return (obj, key) => {
-      setModelVar(obj, key);
-      regisHandler(obj, key, {
-        init(instance) {
-          getProperty("watcher")?.({
-            eventName,
-            instance,
-            key,
-            options
-          });
-        }
-      });
-    };
-  }
-  __name(Watcher, "Watcher");
-  function Effect(eventName, options) {
-    return (obj, key) => {
-      setModelVar(obj, key);
-      regisHandler(obj, key, {
-        init(instance) {
-          instance[`$_${key}`] = instance[key];
-          Object.defineProperty(instance, key, {
-            get() {
-              return instance[`$_${key}`];
-            },
-            set(v) {
-              instance[`$_${key}`] = v;
-              getProperty(`effect-${eventName}`)?.({
-                instance,
-                key,
-                value: v,
-                options
-              });
-              return true;
-            }
-          });
-        }
-      });
-    };
-  }
-  __name(Effect, "Effect");
-  function Storage(storeKey) {
-    return (target, key) => {
-      let tag;
-      if (key) {
-        init(target);
-        tag = storeKey || target.__TAG__;
-        const uniTag = Symbol(tag);
-        setModelVar(target, uniTag);
-        regisHandler(target, uniTag, {
-          init: (instance) => {
-            getProperty("storage")?.({
-              instance,
-              key,
-              tag
-            });
-          }
-        });
-      } else {
-        init(target.prototype);
-        tag = storeKey || `${target.prototype.__TAG__}_${key}`;
-        const uniTag = Symbol(tag);
-        setModelVar(target.prototype, uniTag);
-        regisHandler(target.prototype, uniTag, {
-          init: (instance) => {
-            getProperty("storage")?.({
-              instance,
-              key: "",
-              tag
-            });
-          }
-        });
-      }
-    };
-  }
-  __name(Storage, "Storage");
-
-  // src/preset/rule.ts
-  function isOption() {
-    return Rule((param) => param === void 0 ? "ok" : true, "");
-  }
-  __name(isOption, "isOption");
-  function isArray(info) {
-    return Rule((param) => Array.isArray(param), info || ((k) => `'${k}' should be an array`));
-  }
-  __name(isArray, "isArray");
-  function isBoolean(info) {
-    return Rule((param) => [
-      true,
-      false
-    ].includes(param), info || ((k) => `'${k}' should be boolean`));
-  }
-  __name(isBoolean, "isBoolean");
-  function isNumber(info) {
-    return Rule((param) => typeof param === "number", info || ((k) => `'${k}' should be number`));
-  }
-  __name(isNumber, "isNumber");
-  function isString(info) {
-    return Rule((param) => typeof param === "string", info || ((k) => `'${k}' should be a string`));
-  }
-  __name(isString, "isString");
-  function isObject(info) {
-    return Rule((param) => {
-      return Object.prototype.toString.call(param) === "[object Object]";
-    }, info || ((k) => `'${k}' should be an object`));
-  }
-  __name(isObject, "isObject");
-  function isMobile(info) {
-    return Rule(/^((\+|00)86)?1((3[\d])|(4[5,6,7,9])|(5[0-3,5-9])|(6[5-7])|(7[0-8])|(8[\d])|(9[1,8,9]))\d{8}$/, info || ((k) => `'${k}' should be a mobile phone number`));
-  }
-  __name(isMobile, "isMobile");
-  function isLandline(info) {
-    return Rule(/\d{3}-\d{8}|\d{4}-\d{7}/, info || ((k) => `'${k}' should be a landline`));
-  }
-  __name(isLandline, "isLandline");
-  function isMailBox(info) {
-    return Rule(/^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/, info || ((k) => `'${k}' should be a mailbox`));
-  }
-  __name(isMailBox, "isMailBox");
-  function isIdCard(info) {
-    return Rule(/(^\d{8}(0\d|10|11|12)([0-2]\d|30|31)\d{3}$)|(^\d{6}(18|19|20)\d{2}(0\d|10|11|12)([0-2]\d|30|31)\d{3}(\d|X|x)$)/, info || ((k) => `'${k}' should be an identity card number`));
-  }
-  __name(isIdCard, "isIdCard");
-  function isCnName(info) {
-    return Rule(/^([\u4E00-\u9FA5·]{2,16})$/, info || ((k) => `'${k}' \u9700\u8981\u662F\u4E00\u4E2A\u5408\u7406\u7684\u4E2D\u6587\u540D\u5B57`));
-  }
-  __name(isCnName, "isCnName");
-  function isEnName(info) {
-    return Rule(/(^[a-zA-Z]{1}[a-zA-Z\s]{0,20}[a-zA-Z]{1}$)/, info || ((k) => `'${k}' should be a valid en-name`));
-  }
-  __name(isEnName, "isEnName");
-  function isDate(info) {
-    return Rule(/^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$/, info || ((k) => `'${k}' should be a valid date`));
-  }
-  __name(isDate, "isDate");
-  function isWechat(info) {
-    return Rule(/^[a-zA-Z]([-_a-zA-Z0-9]{5,19})+$/, info || ((k) => `'${k}' should be a valid wechat`));
-  }
-  __name(isWechat, "isWechat");
-  function isHexColor(info) {
-    return Rule(/^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/, info || ((k) => `'${k}' should be a valid hex-color`));
-  }
-  __name(isHexColor, "isHexColor");
-  function isPostalCode(info) {
-    return Rule(/^(0[1-7]|1[0-356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[0-5]|8[013-6])\d{4}$/, info || ((k) => `'${k}' should be a valid postal code`));
-  }
-  __name(isPostalCode, "isPostalCode");
-
-  // src/preset/pipe.ts
-  function toNumber() {
-    return Pipe(to((param) => Number(param)));
-  }
-  __name(toNumber, "toNumber");
-  function toString() {
-    return Pipe(to((param) => String(param)));
-  }
-  __name(toString, "toString");
-  return __toCommonJS(src_exports);
-})();

package/dist/pipe-5d060247.d.ts

@@ -1,21 +0,0 @@
-declare function isOption(): (obj: any, key: PropertyKey) => void;
-declare function isArray(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isBoolean(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isNumber(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isString(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isObject(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isMobile(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isLandline(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isMailBox(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isIdCard(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isCnName(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isEnName(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isDate(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isWechat(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isHexColor(info?: string): (obj: any, key: PropertyKey) => void;
-declare function isPostalCode(info?: string): (obj: any, key: PropertyKey) => void;
-
-declare function toNumber(): (obj: any, key: PropertyKey) => void;
-declare function toString(): (obj: any, key: PropertyKey) => void;
-
-export { isArray as a, isBoolean as b, isNumber as c, isString as d, isObject as e, isMobile as f, isLandline as g, isMailBox as h, isOption as i, isIdCard as j, isCnName as k, isEnName as l, isDate as m, isWechat as n, isHexColor as o, isPostalCode as p, toString as q, toNumber as t };

package/dist/preset/index.d.ts

@@ -1 +0,0 @@
-export { a as isArray, b as isBoolean, k as isCnName, m as isDate, l as isEnName, o as isHexColor, j as isIdCard, g as isLandline, h as isMailBox, f as isMobile, c as isNumber, e as isObject, i as isOption, p as isPostalCode, d as isString, n as isWechat, t as toNumber, q as toString } from '../pipe-5d060247.js';