persagy-vant 0.0.21

package/lib/utils/deep-assign.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  deepAssign: () => deepAssign
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_validate = require("./validate");
+const { hasOwnProperty } = Object.prototype;
+function assignKey(to, from, key) {
+  const val = from[key];
+  if (!(0, import_validate.isDef)(val)) {
+    return;
+  }
+  if (!hasOwnProperty.call(to, key) || !(0, import_validate.isObject)(val)) {
+    to[key] = val;
+  } else {
+    to[key] = deepAssign(Object(to[key]), val);
+  }
+}
+function deepAssign(to, from) {
+  Object.keys(from).forEach((key) => {
+    assignKey(to, from, key);
+  });
+  return to;
+}

package/lib/utils/deep-clone.d.ts

@@ -0,0 +1 @@
+export declare function deepClone<T extends Record<string, any> | null | undefined>(obj: T): T;

package/lib/utils/deep-clone.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  deepClone: () => deepClone
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_validate = require("./validate");
+function deepClone(obj) {
+  if (!(0, import_validate.isDef)(obj)) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if ((0, import_validate.isObject)(obj)) {
+    const to = {};
+    Object.keys(obj).forEach((key) => {
+      to[key] = deepClone(obj[key]);
+    });
+    return to;
+  }
+  return obj;
+}

package/lib/utils/dom.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+export declare type ScrollElement = Element | Window;
+export declare function getScrollTop(el: ScrollElement): number;
+export declare function setScrollTop(el: ScrollElement, value: number): void;
+export declare function getRootScrollTop(): number;
+export declare function setRootScrollTop(value: number): void;
+export declare function getElementTop(el: ScrollElement, scroller?: ScrollElement): number;
+export declare function resetScroll(): void;
+export declare const stopPropagation: (event: Event) => void;
+export declare function preventDefault(event: Event, isStopPropagation?: boolean): void;
+export declare function isHidden(elementRef: HTMLElement | Ref<HTMLElement | undefined>): boolean;
+export declare const windowWidth: Ref<number>, windowHeight: Ref<number>;

package/lib/utils/dom.js

@@ -0,0 +1,86 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  getElementTop: () => getElementTop,
+  getRootScrollTop: () => getRootScrollTop,
+  getScrollTop: () => getScrollTop,
+  isHidden: () => isHidden,
+  preventDefault: () => preventDefault,
+  resetScroll: () => resetScroll,
+  setRootScrollTop: () => setRootScrollTop,
+  setScrollTop: () => setScrollTop,
+  stopPropagation: () => stopPropagation,
+  windowHeight: () => windowHeight,
+  windowWidth: () => windowWidth
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_use = require("@vant/use");
+var import_vue = require("vue");
+var import_validate = require("./validate");
+function getScrollTop(el) {
+  const top = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
+  return Math.max(top, 0);
+}
+function setScrollTop(el, value) {
+  if ("scrollTop" in el) {
+    el.scrollTop = value;
+  } else {
+    el.scrollTo(el.scrollX, value);
+  }
+}
+function getRootScrollTop() {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+}
+function setRootScrollTop(value) {
+  setScrollTop(window, value);
+  setScrollTop(document.body, value);
+}
+function getElementTop(el, scroller) {
+  if (el === window) {
+    return 0;
+  }
+  const scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+  return (0, import_use.useRect)(el).top + scrollTop;
+}
+const isIOS = (0, import_validate.isIOS)();
+function resetScroll() {
+  if (isIOS) {
+    setRootScrollTop(getRootScrollTop());
+  }
+}
+const stopPropagation = (event) => event.stopPropagation();
+function preventDefault(event, isStopPropagation) {
+  if (typeof event.cancelable !== "boolean" || event.cancelable) {
+    event.preventDefault();
+  }
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+}
+function isHidden(elementRef) {
+  const el = (0, import_vue.unref)(elementRef);
+  if (!el) {
+    return false;
+  }
+  const style = window.getComputedStyle(el);
+  const hidden = style.display === "none";
+  const parentHidden = el.offsetParent === null && style.position !== "fixed";
+  return hidden || parentHidden;
+}
+const { width: windowWidth, height: windowHeight } = (0, import_use.useWindowSize)();

package/lib/utils/format.d.ts

@@ -0,0 +1,13 @@
+import type { CSSProperties } from 'vue';
+import { type Numeric } from './basic';
+export declare function addUnit(value?: Numeric): string | undefined;
+export declare function getSizeStyle(originSize?: Numeric | Numeric[]): CSSProperties | undefined;
+export declare function getZIndexStyle(zIndex?: Numeric): CSSProperties;
+export declare function unitToPx(value: Numeric): number;
+export declare const camelize: (str: string) => string;
+export declare const kebabCase: (str: string) => string;
+export declare function padZero(num: Numeric, targetLength?: number): string;
+/** clamps number within the inclusive lower and upper bounds */
+export declare const clamp: (num: number, min: number, max: number) => number;
+export declare function formatNumber(value: string, allowDot?: boolean, allowMinus?: boolean): string;
+export declare function addNumber(num1: number, num2: number): number;

package/lib/utils/format.js

@@ -0,0 +1,139 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  addNumber: () => addNumber,
+  addUnit: () => addUnit,
+  camelize: () => camelize,
+  clamp: () => clamp,
+  formatNumber: () => formatNumber,
+  getSizeStyle: () => getSizeStyle,
+  getZIndexStyle: () => getZIndexStyle,
+  kebabCase: () => kebabCase,
+  padZero: () => padZero,
+  unitToPx: () => unitToPx
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_basic = require("./basic");
+var import_dom = require("./dom");
+var import_validate = require("./validate");
+function addUnit(value) {
+  if ((0, import_validate.isDef)(value)) {
+    return (0, import_validate.isNumeric)(value) ? `${value}px` : String(value);
+  }
+  return void 0;
+}
+function getSizeStyle(originSize) {
+  if ((0, import_validate.isDef)(originSize)) {
+    if (Array.isArray(originSize)) {
+      return {
+        width: addUnit(originSize[0]),
+        height: addUnit(originSize[1])
+      };
+    }
+    const size = addUnit(originSize);
+    return {
+      width: size,
+      height: size
+    };
+  }
+}
+function getZIndexStyle(zIndex) {
+  const style = {};
+  if (zIndex !== void 0) {
+    style.zIndex = +zIndex;
+  }
+  return style;
+}
+let rootFontSize;
+function getRootFontSize() {
+  if (!rootFontSize) {
+    const doc = document.documentElement;
+    const fontSize = doc.style.fontSize || window.getComputedStyle(doc).fontSize;
+    rootFontSize = parseFloat(fontSize);
+  }
+  return rootFontSize;
+}
+function convertRem(value) {
+  value = value.replace(/rem/g, "");
+  return +value * getRootFontSize();
+}
+function convertVw(value) {
+  value = value.replace(/vw/g, "");
+  return +value * import_dom.windowWidth.value / 100;
+}
+function convertVh(value) {
+  value = value.replace(/vh/g, "");
+  return +value * import_dom.windowHeight.value / 100;
+}
+function unitToPx(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (import_basic.inBrowser) {
+    if (value.includes("rem")) {
+      return convertRem(value);
+    }
+    if (value.includes("vw")) {
+      return convertVw(value);
+    }
+    if (value.includes("vh")) {
+      return convertVh(value);
+    }
+  }
+  return parseFloat(value);
+}
+const camelizeRE = /-(\w)/g;
+const camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
+const kebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+function padZero(num, targetLength = 2) {
+  let str = num + "";
+  while (str.length < targetLength) {
+    str = "0" + str;
+  }
+  return str;
+}
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+function trimExtraChar(value, char, regExp) {
+  const index = value.indexOf(char);
+  if (index === -1) {
+    return value;
+  }
+  if (char === "-" && index !== 0) {
+    return value.slice(0, index);
+  }
+  return value.slice(0, index + 1) + value.slice(index).replace(regExp, "");
+}
+function formatNumber(value, allowDot = true, allowMinus = true) {
+  if (allowDot) {
+    value = trimExtraChar(value, ".", /\./g);
+  } else {
+    value = value.split(".")[0];
+  }
+  if (allowMinus) {
+    value = trimExtraChar(value, "-", /-/g);
+  } else {
+    value = value.replace(/-/, "");
+  }
+  const regExp = allowDot ? /[^-0-9.]/g : /[^-0-9]/g;
+  return value.replace(regExp, "");
+}
+function addNumber(num1, num2) {
+  const cardinal = 10 ** 10;
+  return Math.round((num1 + num2) * cardinal) / cardinal;
+}

package/lib/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './basic';
+export * from './props';
+export * from './dom';
+export * from './create';
+export * from './format';
+export * from './constant';
+export * from './validate';
+export * from './interceptor';
+export * from './with-install';

package/lib/utils/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);
+__reExport(stdin_exports, require("./basic"), module.exports);
+__reExport(stdin_exports, require("./props"), module.exports);
+__reExport(stdin_exports, require("./dom"), module.exports);
+__reExport(stdin_exports, require("./create"), module.exports);
+__reExport(stdin_exports, require("./format"), module.exports);
+__reExport(stdin_exports, require("./constant"), module.exports);
+__reExport(stdin_exports, require("./validate"), module.exports);
+__reExport(stdin_exports, require("./interceptor"), module.exports);
+__reExport(stdin_exports, require("./with-install"), module.exports);

package/lib/utils/interceptor.d.ts

@@ -0,0 +1,6 @@
+export declare type Interceptor = (...args: any[]) => Promise<boolean> | boolean | undefined | void;
+export declare function callInterceptor(interceptor: Interceptor | undefined, { args, done, canceled, }: {
+    args?: unknown[];
+    done: () => void;
+    canceled?: () => void;
+}): void;

package/lib/utils/interceptor.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  callInterceptor: () => callInterceptor
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_basic = require("./basic");
+var import_validate = require("./validate");
+function callInterceptor(interceptor, {
+  args = [],
+  done,
+  canceled
+}) {
+  if (interceptor) {
+    const returnVal = interceptor.apply(null, args);
+    if ((0, import_validate.isPromise)(returnVal)) {
+      returnVal.then((value) => {
+        if (value) {
+          done();
+        } else if (canceled) {
+          canceled();
+        }
+      }).catch(import_basic.noop);
+    } else if (returnVal) {
+      done();
+    } else if (canceled) {
+      canceled();
+    }
+  } else {
+    done();
+  }
+}

package/lib/utils/mount-component.d.ts

@@ -0,0 +1,14 @@
+import { Component } from 'vue';
+export declare function usePopupState(): {
+    open: (props: Record<string, any>) => void;
+    close: () => void;
+    state: {
+        [x: string]: any;
+        show: boolean;
+    };
+    toggle: (show: boolean) => void;
+};
+export declare function mountComponent(RootComponent: Component): {
+    instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+    unmount(): void;
+};

package/lib/utils/mount-component.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  mountComponent: () => mountComponent,
+  usePopupState: () => usePopupState
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_utils = require("../utils");
+var import_use_expose = require("../composables/use-expose");
+function usePopupState() {
+  const state = (0, import_vue.reactive)({
+    show: false
+  });
+  const toggle = (show) => {
+    state.show = show;
+  };
+  const open = (props) => {
+    (0, import_utils.extend)(state, props, { transitionAppear: true });
+    toggle(true);
+  };
+  const close = () => toggle(false);
+  (0, import_use_expose.useExpose)({ open, close, toggle });
+  return {
+    open,
+    close,
+    state,
+    toggle
+  };
+}
+function mountComponent(RootComponent) {
+  const app = (0, import_vue.createApp)(RootComponent);
+  const root = document.createElement("div");
+  document.body.appendChild(root);
+  return {
+    instance: app.mount(root),
+    unmount() {
+      app.unmount();
+      document.body.removeChild(root);
+    }
+  };
+}

package/lib/utils/props.d.ts

@@ -0,0 +1,31 @@
+/**
+ * prop type helpers
+ * help us to write less code and reduce bundle size
+ */
+import type { PropType } from 'vue';
+export declare const unknownProp: PropType<unknown>;
+export declare const numericProp: (NumberConstructor | StringConstructor)[];
+export declare const truthProp: {
+    type: BooleanConstructor;
+    default: true;
+};
+export declare const makeRequiredProp: <T>(type: T) => {
+    type: T;
+    required: true;
+};
+export declare const makeArrayProp: <T>() => {
+    type: PropType<T[]>;
+    default: () => never[];
+};
+export declare const makeNumberProp: <T>(defaultVal: T) => {
+    type: NumberConstructor;
+    default: T;
+};
+export declare const makeNumericProp: <T>(defaultVal: T) => {
+    type: (NumberConstructor | StringConstructor)[];
+    default: T;
+};
+export declare const makeStringProp: <T>(defaultVal: T) => {
+    type: PropType<T>;
+    default: T;
+};

package/lib/utils/props.js

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  makeArrayProp: () => makeArrayProp,
+  makeNumberProp: () => makeNumberProp,
+  makeNumericProp: () => makeNumericProp,
+  makeRequiredProp: () => makeRequiredProp,
+  makeStringProp: () => makeStringProp,
+  numericProp: () => numericProp,
+  truthProp: () => truthProp,
+  unknownProp: () => unknownProp
+});
+module.exports = __toCommonJS(stdin_exports);
+const unknownProp = null;
+const numericProp = [Number, String];
+const truthProp = {
+  type: Boolean,
+  default: true
+};
+const makeRequiredProp = (type) => ({
+  type,
+  required: true
+});
+const makeArrayProp = () => ({
+  type: Array,
+  default: () => []
+});
+const makeNumberProp = (defaultVal) => ({
+  type: Number,
+  default: defaultVal
+});
+const makeNumericProp = (defaultVal) => ({
+  type: numericProp,
+  default: defaultVal
+});
+const makeStringProp = (defaultVal) => ({
+  type: String,
+  default: defaultVal
+});

package/lib/utils/validate.d.ts

@@ -0,0 +1,9 @@
+import { type Numeric } from './basic';
+export declare const isDef: <T>(val: T) => val is NonNullable<T>;
+export declare const isFunction: (val: unknown) => val is Function;
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isPromise: <T = any>(val: unknown) => val is Promise<T>;
+export declare const isDate: (val: unknown) => val is Date;
+export declare function isMobile(value: string): boolean;
+export declare const isNumeric: (val: Numeric) => val is string;
+export declare const isIOS: () => boolean;

package/lib/utils/validate.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  isDate: () => isDate,
+  isDef: () => isDef,
+  isFunction: () => isFunction,
+  isIOS: () => isIOS,
+  isMobile: () => isMobile,
+  isNumeric: () => isNumeric,
+  isObject: () => isObject,
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_basic = require("./basic");
+const isDef = (val) => val !== void 0 && val !== null;
+const isFunction = (val) => typeof val === "function";
+const isObject = (val) => val !== null && typeof val === "object";
+const isPromise = (val) => isObject(val) && isFunction(val.then) && isFunction(val.catch);
+const isDate = (val) => Object.prototype.toString.call(val) === "[object Date]" && !Number.isNaN(val.getTime());
+function isMobile(value) {
+  value = value.replace(/[^-|\d]/g, "");
+  return /^((\+86)|(86))?(1)\d{10}$/.test(value) || /^0[0-9-]{10,13}$/.test(value);
+}
+const isNumeric = (val) => typeof val === "number" || /^\d+(\.\d+)?$/.test(val);
+const isIOS = () => import_basic.inBrowser ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;

package/lib/utils/with-install.d.ts

@@ -0,0 +1,13 @@
+import type { App, Component } from 'vue';
+declare type EventShim = {
+    new (...args: any[]): {
+        $props: {
+            onClick?: (...args: any[]) => void;
+        };
+    };
+};
+export declare type WithInstall<T> = T & {
+    install(app: App): void;
+} & EventShim;
+export declare function withInstall<T extends Component>(options: T): WithInstall<T>;
+export {};