vant 3.6.12 → 3.6.13

package/es/uploader/index.d.ts

@@ -1,11 +1,11 @@
 import { UploaderProps } from './Uploader';
-export declare const Uploader: import("../utils").WithInstall<import("vue").DefineComponent<{
+export declare const Uploader: import("../utils").WithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     name: {
         type: (NumberConstructor | StringConstructor)[];
         default: string;
     };
     accept: {
-        type: import("vue").PropType<string>;
+        type: import("vue").PropType<T>;
         default: string;
     };
     capture: StringConstructor;
@@ -18,15 +18,15 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
         default: number;
     };
     imageFit: {
-        type: import("vue").PropType<import("..").ImageFit>;
-        default: import("..").ImageFit;
+        type: import("vue").PropType<T>;
+        default: import("csstype").Property.ObjectFit | undefined;
     };
     resultType: {
-        type: import("vue").PropType<import("./types").UploaderResultType>;
+        type: import("vue").PropType<T>;
         default: import("./types").UploaderResultType;
     };
     uploadIcon: {
-        type: import("vue").PropType<string>;
+        type: import("vue").PropType<T>;
         default: string;
     };
     uploadText: StringConstructor;
@@ -34,13 +34,14 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
         type: BooleanConstructor;
         default: true;
     };
+    reupload: BooleanConstructor;
     afterRead: import("vue").PropType<import("./types").UploaderAfterRead>;
     showUpload: {
         type: BooleanConstructor;
         default: true;
     };
     modelValue: {
-        type: import("vue").PropType<import("./types").UploaderFileListItem[]>;
+        type: import("vue").PropType<T_1[]>;
         default: () => never[];
     };
     beforeRead: import("vue").PropType<import("./types").UploaderBeforeRead>;
@@ -59,13 +60,13 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
         type: import("vue").PropType<import("./types").UploaderMaxSize>;
         default: number;
     };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "delete" | "oversize" | "click-upload" | "close-preview" | "click-preview")[], "update:modelValue" | "delete" | "oversize" | "click-upload" | "close-preview" | "click-preview", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("delete" | "update:modelValue" | "oversize" | "clickUpload" | "closePreview" | "clickPreview" | "clickReupload")[], "delete" | "update:modelValue" | "oversize" | "clickUpload" | "closePreview" | "clickPreview" | "clickReupload", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     name: {
         type: (NumberConstructor | StringConstructor)[];
         default: string;
     };
     accept: {
-        type: import("vue").PropType<string>;
+        type: import("vue").PropType<T>;
         default: string;
     };
     capture: StringConstructor;
@@ -78,15 +79,15 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
         default: number;
     };
     imageFit: {
-        type: import("vue").PropType<import("..").ImageFit>;
-        default: import("..").ImageFit;
+        type: import("vue").PropType<T>;
+        default: import("csstype").Property.ObjectFit | undefined;
     };
     resultType: {
-        type: import("vue").PropType<import("./types").UploaderResultType>;
+        type: import("vue").PropType<T>;
         default: import("./types").UploaderResultType;
     };
     uploadIcon: {
-        type: import("vue").PropType<string>;
+        type: import("vue").PropType<T>;
         default: string;
     };
     uploadText: StringConstructor;
@@ -94,13 +95,14 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
         type: BooleanConstructor;
         default: true;
     };
+    reupload: BooleanConstructor;
     afterRead: import("vue").PropType<import("./types").UploaderAfterRead>;
     showUpload: {
         type: BooleanConstructor;
         default: true;
     };
     modelValue: {
-        type: import("vue").PropType<import("./types").UploaderFileListItem[]>;
+        type: import("vue").PropType<T_1[]>;
         default: () => never[];
     };
     beforeRead: import("vue").PropType<import("./types").UploaderBeforeRead>;
@@ -119,34 +121,37 @@ export declare const Uploader: import("../utils").WithInstall<import("vue").Defi
         type: import("vue").PropType<import("./types").UploaderMaxSize>;
         default: number;
     };
-}>> & {
+}>> & Readonly<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onDelete?: ((...args: any[]) => any) | undefined;
     onOversize?: ((...args: any[]) => any) | undefined;
-    "onClick-upload"?: ((...args: any[]) => any) | undefined;
-    "onClose-preview"?: ((...args: any[]) => any) | undefined;
-    "onClick-preview"?: ((...args: any[]) => any) | undefined;
-}, {
+    onClickUpload?: ((...args: any[]) => any) | undefined;
+    onClosePreview?: ((...args: any[]) => any) | undefined;
+    onClickPreview?: ((...args: any[]) => any) | undefined;
+    onClickReupload?: ((...args: any[]) => any) | undefined;
+}>, {
     name: string | number;
     accept: string;
     disabled: boolean;
+    multiple: boolean;
     modelValue: import("./types").UploaderFileListItem[];
     readonly: boolean;
-    multiple: boolean;
     lazyLoad: boolean;
     maxCount: string | number;
-    imageFit: import("..").ImageFit;
+    imageFit: import("csstype").Property.ObjectFit | undefined;
     resultType: import("./types").UploaderResultType;
     uploadIcon: string;
     deletable: boolean;
+    reupload: boolean;
     showUpload: boolean;
     previewImage: boolean;
     previewFullImage: boolean;
     maxSize: import("./types").UploaderMaxSize;
-}>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
 export default Uploader;
+export { uploaderProps } from './Uploader';
 export type { UploaderProps };
-export type { UploaderInstance, UploaderResultType, UploaderFileListItem, } from './types';
+export type { UploaderInstance, UploaderThemeVars, UploaderResultType, UploaderFileListItem, UploaderBeforeRead, UploaderAfterRead, } from './types';
 declare module 'vue' {
     interface GlobalComponents {
         VanUploader: typeof Uploader;

package/es/uploader/index.mjs

@@ -2,7 +2,9 @@ import { withInstall } from "../utils/index.mjs";
 import _Uploader from "./Uploader.mjs";
 const Uploader = withInstall(_Uploader);
 var stdin_default = Uploader;
+import { uploaderProps } from "./Uploader.mjs";
 export {
   Uploader,
-  stdin_default as default
+  stdin_default as default,
+  uploaderProps
 };

package/es/uploader/types.d.ts

@@ -2,8 +2,8 @@ import type { ComponentPublicInstance } from 'vue';
 import type { ImageFit } from '../image';
 import type { Numeric, Interceptor } from '../utils';
 import type { UploaderProps } from './Uploader';
-export declare type UploaderResultType = 'dataUrl' | 'text' | 'file';
-export declare type UploaderFileListItem = {
+export type UploaderResultType = 'dataUrl' | 'text' | 'file';
+export type UploaderFileListItem = {
     url?: string;
     file?: File;
     objectUrl?: string;
@@ -13,20 +13,49 @@ export declare type UploaderFileListItem = {
     message?: string;
     imageFit?: ImageFit;
     deletable?: boolean;
+    reupload?: boolean;
     previewSize?: Numeric;
     beforeDelete?: Interceptor;
 };
-export declare type UploaderMaxSize = Numeric | ((file: File) => boolean);
-export declare type UploaderBeforeRead = (file: File | File[], detail: {
+export type UploaderMaxSize = Numeric | ((file: File) => boolean);
+export type UploaderBeforeRead = (file: File | File[], detail: {
     name: Numeric;
     index: number;
 }) => boolean | undefined | Promise<File | File[] | undefined>;
-export declare type UploaderAfterRead = (items: UploaderFileListItem | UploaderFileListItem[], detail: {
+export type UploaderAfterRead = (items: UploaderFileListItem | UploaderFileListItem[], detail: {
     name: Numeric;
     index: number;
 }) => void;
-export declare type UploaderExpose = {
+export type UploaderExpose = {
     chooseFile: () => void;
     closeImagePreview: () => void;
+    reuploadFile: (index: number) => void;
+};
+export type UploaderInstance = ComponentPublicInstance<UploaderProps, UploaderExpose>;
+export type UploaderThemeVars = {
+    uploaderSize?: string;
+    uploaderIconSize?: string;
+    uploaderIconColor?: string;
+    uploaderTextColor?: string;
+    uploaderTextFontSize?: string;
+    uploaderUploadBackground?: string;
+    uploaderUploadActiveColor?: string;
+    uploaderDeleteColor?: string;
+    uploaderDeleteIconSize?: string;
+    uploaderDeleteBackground?: string;
+    uploaderFileBackground?: string;
+    uploaderFileIconSize?: string;
+    uploaderFileIconColor?: string;
+    uploaderFileNamePadding?: string;
+    uploaderFileNameMarginTop?: string;
+    uploaderFileNameFontSize?: string;
+    uploaderFileNameTextColor?: string;
+    uploaderMaskTextColor?: string;
+    uploaderMaskBackground?: string;
+    uploaderMaskIconSize?: string;
+    uploaderMaskMessageFontSize?: string;
+    uploaderMaskMessageLineHeight?: number | string;
+    uploaderLoadingIconSize?: string;
+    uploaderLoadingIconColor?: string;
+    uploaderDisabledOpacity?: number | string;
 };
-export declare type UploaderInstance = ComponentPublicInstance<UploaderProps, UploaderExpose>;

package/es/uploader/utils.d.ts

@@ -1,5 +1,5 @@
 import type { UploaderMaxSize, UploaderResultType, UploaderFileListItem } from './types';
-declare const name: string, bem: (el?: import("../utils").Mods | undefined, mods?: import("../utils").Mods | undefined) => import("../utils").Mods, t: (path: string, ...args: unknown[]) => any;
+declare const name: string, bem: (el?: import("../utils").Mods, mods?: import("../utils").Mods) => import("../utils").Mods, t: (path: string, ...args: unknown[]) => any;
 export { name, bem, t };
 export declare function readFileContent(file: File, resultType: UploaderResultType): Promise<string | void>;
 export declare function isOversize(items: UploaderFileListItem | UploaderFileListItem[], maxSize: UploaderMaxSize): boolean;

package/es/uploader/utils.mjs

@@ -23,7 +23,7 @@ function isOversize(items, maxSize) {
       if (isFunction(maxSize)) {
         return maxSize(item.file);
       }
-      return item.file.size > maxSize;
+      return item.file.size > +maxSize;
     }
     return false;
   });

package/es/utils/basic.d.ts

@@ -2,16 +2,29 @@ import type { ComponentPublicInstance } from 'vue';
 export declare function noop(): void;
 export declare const extend: {
     <T extends {}, U>(target: T, source: U): T & U;
-    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
-    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
     (target: object, ...sources: any[]): any;
 };
 export declare const inBrowser: boolean;
-export declare type Numeric = number | string;
-export declare type ComponentInstance = ComponentPublicInstance<{}, any>;
+export type Numeric = number | string;
+export type ComponentInstance = ComponentPublicInstance<{}, any>;
+export declare const isObject: (val: unknown) => val is Record<any, any>;
+export declare const isDef: <T>(val: T) => val is NonNullable<T>;
+export declare const isFunction: (val: unknown) => val is Function;
+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;
 export declare function get(object: any, path: string): any;
-export declare type Writeable<T> = {
+export type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+export type RequiredParams<T> = T extends (...args: infer P) => infer R ? (...args: {
+    [K in keyof P]-?: NonNullable<P[K]>;
+}) => R : never;
 export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>, ignoreUndefined?: boolean): Writeable<Pick<T, U>>;
+export declare const isSameValue: (newValue: unknown, oldValue: unknown) => boolean;
 export declare const toArray: <T>(item: T | T[]) => T[];
+export declare const flat: <T>(arr: Array<T | T[]>) => T[];

package/es/utils/basic.mjs

@@ -1,8 +1,18 @@
-import { isObject } from "./validate.mjs";
 function noop() {
 }
 const extend = Object.assign;
 const inBrowser = typeof window !== "undefined";
+const isObject = (val) => val !== null && typeof val === "object";
+const isDef = (val) => val !== void 0 && val !== null;
+const isFunction = (val) => typeof val === "function";
+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 = () => inBrowser ? /ios|iphone|ipad|ipod/.test(navigator.userAgent.toLowerCase()) : false;
 function get(object, path) {
   const keys = path.split(".");
   let result = object;
@@ -13,18 +23,33 @@ function get(object, path) {
   return result;
 }
 function pick(obj, keys, ignoreUndefined) {
-  return keys.reduce((ret, key) => {
-    if (!ignoreUndefined || obj[key] !== void 0) {
-      ret[key] = obj[key];
-    }
-    return ret;
-  }, {});
+  return keys.reduce(
+    (ret, key) => {
+      if (!ignoreUndefined || obj[key] !== void 0) {
+        ret[key] = obj[key];
+      }
+      return ret;
+    },
+    {}
+  );
 }
+const isSameValue = (newValue, oldValue) => JSON.stringify(newValue) === JSON.stringify(oldValue);
 const toArray = (item) => Array.isArray(item) ? item : [item];
+const flat = (arr) => arr.reduce((acc, val) => acc.concat(val), []);
 export {
   extend,
+  flat,
   get,
   inBrowser,
+  isDate,
+  isDef,
+  isFunction,
+  isIOS,
+  isMobile,
+  isNumeric,
+  isObject,
+  isPromise,
+  isSameValue,
   noop,
   pick,
   toArray

package/es/utils/closest.d.ts

@@ -0,0 +1 @@
+export declare function closest(arr: number[], target: number): number;

package/es/utils/closest.mjs

@@ -0,0 +1,8 @@
+function closest(arr, target) {
+  return arr.reduce(
+    (pre, cur) => Math.abs(pre - target) < Math.abs(cur - target) ? pre : cur
+  );
+}
+export {
+  closest
+};

package/es/utils/constant.d.ts

@@ -1,11 +1,14 @@
 import type { InjectionKey } from 'vue';
 import type { FormProvide } from '../form/types';
 export declare const BORDER = "van-hairline";
-export declare const BORDER_TOP: string;
-export declare const BORDER_LEFT: string;
-export declare const BORDER_BOTTOM: string;
-export declare const BORDER_SURROUND: string;
-export declare const BORDER_TOP_BOTTOM: string;
-export declare const BORDER_UNSET_TOP_BOTTOM: string;
+export declare const BORDER_TOP = "van-hairline--top";
+export declare const BORDER_LEFT = "van-hairline--left";
+export declare const BORDER_RIGHT = "van-hairline--right";
+export declare const BORDER_BOTTOM = "van-hairline--bottom";
+export declare const BORDER_SURROUND = "van-hairline--surround";
+export declare const BORDER_TOP_BOTTOM = "van-hairline--top-bottom";
+export declare const BORDER_UNSET_TOP_BOTTOM = "van-hairline-unset--top-bottom";
 export declare const HAPTICS_FEEDBACK = "van-haptics-feedback";
 export declare const FORM_KEY: InjectionKey<FormProvide>;
+export declare const LONG_PRESS_START_TIME = 500;
+export declare const TAP_OFFSET = 5;

package/es/utils/constant.mjs

@@ -1,20 +1,26 @@
 const BORDER = "van-hairline";
 const BORDER_TOP = `${BORDER}--top`;
 const BORDER_LEFT = `${BORDER}--left`;
+const BORDER_RIGHT = `${BORDER}--right`;
 const BORDER_BOTTOM = `${BORDER}--bottom`;
 const BORDER_SURROUND = `${BORDER}--surround`;
 const BORDER_TOP_BOTTOM = `${BORDER}--top-bottom`;
 const BORDER_UNSET_TOP_BOTTOM = `${BORDER}-unset--top-bottom`;
 const HAPTICS_FEEDBACK = "van-haptics-feedback";
 const FORM_KEY = Symbol("van-form");
+const LONG_PRESS_START_TIME = 500;
+const TAP_OFFSET = 5;
 export {
   BORDER,
   BORDER_BOTTOM,
   BORDER_LEFT,
+  BORDER_RIGHT,
   BORDER_SURROUND,
   BORDER_TOP,
   BORDER_TOP_BOTTOM,
   BORDER_UNSET_TOP_BOTTOM,
   FORM_KEY,
-  HAPTICS_FEEDBACK
+  HAPTICS_FEEDBACK,
+  LONG_PRESS_START_TIME,
+  TAP_OFFSET
 };

package/es/utils/create.d.ts

@@ -1,9 +1,9 @@
 export declare function createTranslate(name: string): (path: string, ...args: unknown[]) => any;
-export declare type Translate = ReturnType<typeof createTranslate>;
-export declare type Mod = string | {
+export type Translate = ReturnType<typeof createTranslate>;
+export type Mod = string | {
     [key: string]: any;
 };
-export declare type Mods = Mod | Mod[];
+export type Mods = Mod | Mod[];
 /**
  * bem helper
  * b() // 'button'
@@ -13,5 +13,5 @@ export declare type Mods = Mod | Mod[];
  * b(['disabled', 'primary']) // 'button button--disabled button--primary'
  */
 export declare function createBEM(name: string): (el?: Mods, mods?: Mods) => Mods;
-export declare type BEM = ReturnType<typeof createBEM>;
-export declare function createNamespace(name: string): readonly [string, (el?: Mods | undefined, mods?: Mods | undefined) => Mods, (path: string, ...args: unknown[]) => any];
+export type BEM = ReturnType<typeof createBEM>;
+export declare function createNamespace(name: string): readonly [string, (el?: Mods, mods?: Mods) => Mods, (path: string, ...args: unknown[]) => any];

package/es/utils/create.mjs

@@ -1,6 +1,5 @@
-import { get } from "./basic.mjs";
+import { get, isFunction } from "./basic.mjs";
 import { camelize } from "./format.mjs";
-import { isFunction } from "./validate.mjs";
 import locale from "../locale/index.mjs";
 function createTranslate(name) {
   const prefix = camelize(name) + ".";

package/es/utils/deep-assign.d.ts

@@ -1,3 +1,3 @@
-declare type ObjectIndex = Record<string, unknown>;
+type ObjectIndex = Record<string, unknown>;
 export declare function deepAssign(to: ObjectIndex, from: ObjectIndex): ObjectIndex;
 export {};

package/es/utils/deep-assign.mjs

@@ -1,4 +1,4 @@
-import { isDef, isObject } from "./validate.mjs";
+import { isDef, isObject } from "./basic.mjs";
 const { hasOwnProperty } = Object.prototype;
 function assignKey(to, from, key) {
   const val = from[key];

package/es/utils/deep-clone.mjs

@@ -1,4 +1,4 @@
-import { isDef, isObject } from "./validate.mjs";
+import { isDef, isObject } from "./basic.mjs";
 function deepClone(obj) {
   if (!isDef(obj)) {
     return obj;

package/es/utils/dom.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-export declare type ScrollElement = Element | Window;
+export 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;
@@ -9,4 +9,5 @@ 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>;
+export declare const windowWidth: Ref<number, number>, windowHeight: Ref<number, number>;
+export declare function getContainingBlock(el: Element): HTMLElement | null;

package/es/utils/dom.mjs

@@ -1,6 +1,6 @@
 import { useRect, useWindowSize } from "@vant/use";
 import { unref } from "vue";
-import { isIOS as checkIsIOS } from "./validate.mjs";
+import { isIOS as checkIsIOS } from "./basic.mjs";
 function getScrollTop(el) {
   const top = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
   return Math.max(top, 0);
@@ -52,7 +52,24 @@ function isHidden(elementRef) {
   return hidden || parentHidden;
 }
 const { width: windowWidth, height: windowHeight } = useWindowSize();
+function isContainingBlock(el) {
+  const css = window.getComputedStyle(el);
+  return css.transform !== "none" || css.perspective !== "none" || ["transform", "perspective", "filter"].some(
+    (value) => (css.willChange || "").includes(value)
+  );
+}
+function getContainingBlock(el) {
+  let node = el.parentElement;
+  while (node) {
+    if (node && node.tagName !== "HTML" && node.tagName !== "BODY" && isContainingBlock(node)) {
+      return node;
+    }
+    node = node.parentElement;
+  }
+  return null;
+}
 export {
+  getContainingBlock,
   getElementTop,
   getRootScrollTop,
   getScrollTop,

package/es/utils/format.mjs

@@ -1,6 +1,6 @@
 import { inBrowser } from "./basic.mjs";
 import { windowWidth, windowHeight } from "./dom.mjs";
-import { isDef, isNumeric } from "./validate.mjs";
+import { isDef, isNumeric } from "./basic.mjs";
 function addUnit(value) {
   if (isDef(value)) {
     return isNumeric(value) ? `${value}px` : String(value);

package/es/utils/index.d.ts

@@ -4,6 +4,6 @@ export * from './dom';
 export * from './create';
 export * from './format';
 export * from './constant';
-export * from './validate';
 export * from './interceptor';
 export * from './with-install';
+export * from './closest';

package/es/utils/index.mjs

@@ -4,6 +4,6 @@ export * from "./dom.mjs";
 export * from "./create.mjs";
 export * from "./format.mjs";
 export * from "./constant.mjs";
-export * from "./validate.mjs";
 export * from "./interceptor.mjs";
 export * from "./with-install.mjs";
+export * from "./closest.mjs";

package/es/utils/interceptor.d.ts

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

package/es/utils/interceptor.mjs

@@ -1,9 +1,9 @@
-import { noop } from "./basic.mjs";
-import { isPromise } from "./validate.mjs";
+import { noop, isPromise } from "./basic.mjs";
 function callInterceptor(interceptor, {
   args = [],
   done,
-  canceled
+  canceled,
+  error
 }) {
   if (interceptor) {
     const returnVal = interceptor.apply(null, args);
@@ -14,7 +14,7 @@ function callInterceptor(interceptor, {
         } else if (canceled) {
           canceled();
         }
-      }).catch(noop);
+      }).catch(error || noop);
     } else if (returnVal) {
       done();
     } else if (canceled) {

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

@@ -9,6 +9,6 @@ export declare function usePopupState(): {
     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, {}>>;
+    instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>, {}, {}, "", {}, any>;
     unmount(): void;
 };

package/es/utils/mount-component.mjs

@@ -1,5 +1,5 @@
 import { createApp, reactive } from "vue";
-import { extend } from "../utils/index.mjs";
+import { extend } from "./basic.mjs";
 import { useExpose } from "../composables/use-expose.mjs";
 function usePopupState() {
   const state = reactive({

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

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

package/es/vue-tsx-shim.d.ts

@@ -19,5 +19,6 @@ declare module 'vue' {
   interface HTMLAttributes {
     onTouchmovePassive?: EventHandler;
     onTouchstartPassive?: EventHandler;
+    onClickCapture?: EventHandler;
   }
 }