persagy-vant 0.0.53 → 0.0.54

package/es/index.d.ts

@@ -118,4 +118,4 @@ declare namespace _default {
 }
 export default _default;
 export function install(app: any): void;
-export const version: "0.0.53";
+export const version: "0.0.54";

package/es/index.mjs

@@ -111,7 +111,7 @@ import { Uploader } from "./uploader/index.mjs";
 import { VideoPreview } from "./video-preview/index.mjs";
 import { WorkOrderCard } from "./work-order-card/index.mjs";
 import { WorkOrderFilter } from "./work-order-filter/index.mjs";
-const version = "0.0.53";
+const version = "0.0.54";
 function install(app) {
   const components = [
     ActionBar,

package/es/locale/lang/en-US.d.ts

@@ -69,5 +69,14 @@ declare const _default: {
         recordVideo: string;
         chooseFromAlbum: string;
     };
+    vanQrScanner: {
+        startupCamera: string;
+        startupPreview: string;
+        startupDecoder: string;
+        timeoutCamera: string;
+        timeoutPreview: string;
+        timeoutDecoder: string;
+        previewFailed: string;
+    };
 };
 export default _default;

package/es/locale/lang/en-US.mjs

@@ -68,6 +68,15 @@ var stdin_default = {
     takePhoto: "Take photo",
     recordVideo: "Record video",
     chooseFromAlbum: "Choose from album"
+  },
+  vanQrScanner: {
+    startupCamera: "Requesting camera access and opening the camera...",
+    startupPreview: "Starting the camera preview...",
+    startupDecoder: "Preparing code recognition...",
+    timeoutCamera: "Camera startup timed out. Check system and browser camera permissions, or choose an image.",
+    timeoutPreview: "Camera preview timed out. Retry or choose an image.",
+    timeoutDecoder: "Code recognition setup timed out. Check the network or scanner resource deployment and retry.",
+    previewFailed: "Camera preview failed. Retry or choose an image."
   }
 };
 export {

package/es/locale/lang/zh-CN.d.ts

@@ -69,5 +69,14 @@ declare const _default: {
         recordVideo: string;
         chooseFromAlbum: string;
     };
+    vanQrScanner: {
+        startupCamera: string;
+        startupPreview: string;
+        startupDecoder: string;
+        timeoutCamera: string;
+        timeoutPreview: string;
+        timeoutDecoder: string;
+        previewFailed: string;
+    };
 };
 export default _default;

package/es/locale/lang/zh-CN.mjs

@@ -68,6 +68,15 @@ var stdin_default = {
     takePhoto: "\u62CD\u7167",
     recordVideo: "\u62CD\u89C6\u9891",
     chooseFromAlbum: "\u4ECE\u76F8\u518C\u9009\u62E9"
+  },
+  vanQrScanner: {
+    startupCamera: "\u6B63\u5728\u8BF7\u6C42\u76F8\u673A\u6743\u9650\u5E76\u6253\u5F00\u6444\u50CF\u5934...",
+    startupPreview: "\u6B63\u5728\u542F\u52A8\u76F8\u673A\u753B\u9762...",
+    startupDecoder: "\u6B63\u5728\u51C6\u5907\u626B\u7801\u8BC6\u522B...",
+    timeoutCamera: "\u6444\u50CF\u5934\u542F\u52A8\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u7CFB\u7EDF\u548C\u6D4F\u89C8\u5668\u76F8\u673A\u6388\u6743\uFF0C\u4E5F\u53EF\u4EE5\u4ECE\u76F8\u518C\u8BC6\u522B",
+    timeoutPreview: "\u76F8\u673A\u753B\u9762\u542F\u52A8\u8D85\u65F6\uFF0C\u8BF7\u91CD\u8BD5\u6216\u4ECE\u76F8\u518C\u8BC6\u522B",
+    timeoutDecoder: "\u626B\u7801\u8BC6\u522B\u51C6\u5907\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u626B\u7801\u8D44\u6E90\u90E8\u7F72\u540E\u91CD\u8BD5",
+    previewFailed: "\u76F8\u673A\u753B\u9762\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u6216\u4ECE\u76F8\u518C\u8BC6\u522B"
   }
 };
 export {

package/es/locale/lang/zh-TW.d.ts

@@ -60,5 +60,14 @@ declare const _default: {
     vanAddressList: {
         add: string;
     };
+    vanQrScanner: {
+        startupCamera: string;
+        startupPreview: string;
+        startupDecoder: string;
+        timeoutCamera: string;
+        timeoutPreview: string;
+        timeoutDecoder: string;
+        previewFailed: string;
+    };
 };
 export default _default;

package/es/locale/lang/zh-TW.mjs

@@ -59,6 +59,15 @@ var stdin_default = {
   },
   vanAddressList: {
     add: "\u65B0\u589E\u5730\u5740"
+  },
+  vanQrScanner: {
+    startupCamera: "\u6B63\u5728\u8ACB\u6C42\u76F8\u6A5F\u6B0A\u9650\u4E26\u958B\u555F\u651D\u5F71\u6A5F...",
+    startupPreview: "\u6B63\u5728\u555F\u52D5\u76F8\u6A5F\u756B\u9762...",
+    startupDecoder: "\u6B63\u5728\u6E96\u5099\u6383\u78BC\u8B58\u5225...",
+    timeoutCamera: "\u651D\u5F71\u6A5F\u555F\u52D5\u903E\u6642\uFF0C\u8ACB\u6AA2\u67E5\u7CFB\u7D71\u548C\u700F\u89BD\u5668\u76F8\u6A5F\u6388\u6B0A\uFF0C\u4E5F\u53EF\u4EE5\u5F9E\u76F8\u7C3F\u8B58\u5225",
+    timeoutPreview: "\u76F8\u6A5F\u756B\u9762\u555F\u52D5\u903E\u6642\uFF0C\u8ACB\u91CD\u8A66\u6216\u5F9E\u76F8\u7C3F\u8B58\u5225",
+    timeoutDecoder: "\u6383\u78BC\u8B58\u5225\u6E96\u5099\u903E\u6642\uFF0C\u8ACB\u6AA2\u67E5\u7DB2\u8DEF\u6216\u6383\u78BC\u8CC7\u6E90\u90E8\u7F72\u5F8C\u91CD\u8A66",
+    previewFailed: "\u76F8\u6A5F\u756B\u9762\u555F\u52D5\u5931\u6557\uFF0C\u8ACB\u91CD\u8A66\u6216\u5F9E\u76F8\u7C3F\u8B58\u5225"
   }
 };
 export {

package/es/qr-scanner/QrScanner.d.ts

@@ -14,6 +14,11 @@ declare const qrScannerProps: {
         type: PropType<string>;
         default: string;
     };
+    startupTimeout: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startupTexts: PropType<Partial<Record<"camera" | "preview" | "decoder", string>>>;
     formats: {
         type: PropType<QrScannerFormat[]>;
         default: () => never[];
@@ -81,6 +86,11 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<string>;
         default: string;
     };
+    startupTimeout: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startupTexts: PropType<Partial<Record<"camera" | "preview" | "decoder", string>>>;
     formats: {
         type: PropType<QrScannerFormat[]>;
         default: () => never[];
@@ -132,7 +142,7 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: true;
     };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "error" | "closed" | "update:show" | "cancel" | "scan" | "ready")[], "close" | "error" | "closed" | "update:show" | "cancel" | "scan" | "ready", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("close" | "error" | "closed" | "update:show" | "cancel" | "scan" | "ready" | "stageChange")[], "close" | "error" | "closed" | "update:show" | "cancel" | "scan" | "ready" | "stageChange", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<ExtractPropTypes<{
     show: BooleanConstructor;
     title: {
         type: PropType<string>;
@@ -146,6 +156,11 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<string>;
         default: string;
     };
+    startupTimeout: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    startupTexts: PropType<Partial<Record<"camera" | "preview" | "decoder", string>>>;
     formats: {
         type: PropType<QrScannerFormat[]>;
         default: () => never[];
@@ -205,6 +220,7 @@ declare const _default: import("vue").DefineComponent<{
     onCancel?: ((...args: any[]) => any) | undefined;
     onScan?: ((...args: any[]) => any) | undefined;
     onReady?: ((...args: any[]) => any) | undefined;
+    onStageChange?: ((...args: any[]) => any) | undefined;
 }, {
     title: string;
     show: boolean;
@@ -213,6 +229,7 @@ declare const _default: import("vue").DefineComponent<{
     closeOnPopstate: boolean;
     tip: string;
     processingText: string;
+    startupTimeout: string | number;
     formats: QrScannerFormat[];
     facingMode: "environment" | "user";
     showAlbum: boolean;

package/es/qr-scanner/QrScanner.mjs

@@ -26,12 +26,16 @@ import { Button } from "../button/index.mjs";
 import { Icon } from "../icon/index.mjs";
 import { Loading } from "../loading/index.mjs";
 import { Popup } from "../popup/index.mjs";
-const [name, bem] = createNamespace("qr-scanner");
+import zhCN from "../locale/lang/zh-CN.mjs";
+import { DEFAULT_STARTUP_TIMEOUT, waitForAbort } from "./startup.mjs";
+const [name, bem, t] = createNamespace("qr-scanner");
 const qrScannerProps = {
   show: Boolean,
   title: makeStringProp("\u626B\u63CF\u8BBE\u5907\u4E8C\u7EF4\u7801"),
   tip: makeStringProp("\u5C06\u8BBE\u5907\u4E8C\u7EF4\u7801\u7F6E\u4E8E\u53D6\u666F\u6846\u5185\uFF0C\u5373\u53EF\u81EA\u52A8\u8BC6\u522B"),
   processingText: makeStringProp("\u6B63\u5728\u5904\u7406\u626B\u7801\u7ED3\u679C..."),
+  startupTimeout: makeNumericProp(DEFAULT_STARTUP_TIMEOUT),
+  startupTexts: Object,
   formats: extend(makeArrayProp(), {
     default: () => ["QRCode"]
   }),
@@ -57,7 +61,7 @@ const qrScannerProps = {
 var stdin_default = defineComponent({
   name,
   props: qrScannerProps,
-  emits: ["update:show", "scan", "error", "cancel", "close", "closed", "ready"],
+  emits: ["update:show", "scan", "error", "cancel", "close", "closed", "ready", "stageChange"],
   setup(props, {
     emit
   }) {
@@ -66,6 +70,7 @@ var stdin_default = defineComponent({
     const frame = ref();
     const fileInput = ref();
     const phase = ref("idle");
+    const startupStage = ref("camera");
     const message = ref("");
     const hasTorch = ref(false);
     const torchOn = ref(false);
@@ -76,13 +81,25 @@ var stdin_default = defineComponent({
     let stream;
     let canvas;
     let timer;
+    let startupTimer;
+    let startupStartedAt = 0;
+    let startupDeadline = 0;
     let generation = 0;
     let abortController;
     let resumeWhenVisible = false;
+    let pickingAlbum = false;
     const recentResults = /* @__PURE__ */ new Map();
     const isCurrent = (id) => id === generation && props.show && !props.paused;
+    const startupText = (key) => t(key) || zhCN.vanQrScanner[key];
+    const clearStartupTimer = () => {
+      if (startupTimer !== void 0)
+        clearTimeout(startupTimer);
+      startupTimer = void 0;
+      startupDeadline = 0;
+    };
     const release = () => {
       generation += 1;
+      clearStartupTimer();
       if (timer)
         clearTimeout(timer);
       timer = void 0;
@@ -101,6 +118,7 @@ var stdin_default = defineComponent({
       phase.value = "paused";
     };
     const close = (cancelled = false) => {
+      pickingAlbum = false;
       release();
       phase.value = "idle";
       if (cancelled)
@@ -108,14 +126,46 @@ var stdin_default = defineComponent({
       emit("update:show", false);
     };
     const reportError = (code, text, cause) => {
+      const startupInfo = phase.value === "starting" && abortController && !props.nativeScan ? {
+        stage: startupStage.value,
+        elapsedMs: Math.max(0, Date.now() - startupStartedAt)
+      } : {};
       release();
       phase.value = "error";
       message.value = text;
-      emit("error", {
+      emit("error", extend({
         code,
         message: text,
         cause
+      }, startupInfo));
+    };
+    const reportStartupTimeout = () => {
+      const timeoutMessages = {
+        camera: startupText("timeoutCamera"),
+        preview: startupText("timeoutPreview"),
+        decoder: startupText("timeoutDecoder"),
+        ready: ""
+      };
+      reportError("STARTUP_TIMEOUT", timeoutMessages[startupStage.value]);
+    };
+    const canContinueStartup = (id) => {
+      if (!isCurrent(id))
+        return false;
+      if (startupDeadline && Date.now() >= startupDeadline) {
+        reportStartupTimeout();
+        return false;
+      }
+      return true;
+    };
+    const setStartupStage = (stage, id) => {
+      if (!canContinueStartup(id))
+        return false;
+      startupStage.value = stage;
+      emit("stageChange", {
+        stage,
+        elapsedMs: Math.max(0, Date.now() - startupStartedAt)
       });
+      return isCurrent(id);
     };
     const cameraError = (error) => {
       const errorName = error == null ? void 0 : error.name;
@@ -203,7 +253,7 @@ var stdin_default = defineComponent({
             height: target.height / scale
           });
           if (image) {
-            const result = yield decoder.decode(image, props.formats, props.wasmUrl);
+            const result = yield decoder.decode(image, props.formats, props.wasmUrl, abortController == null ? void 0 : abortController.signal);
             if (!isCurrent(id))
               return;
             if (result)
@@ -229,6 +279,7 @@ var stdin_default = defineComponent({
           return;
         }
         const id = generation;
+        pickingAlbum = false;
         phase.value = "starting";
         message.value = "";
         if (props.nativeScan) {
@@ -264,8 +315,25 @@ var stdin_default = defineComponent({
           reportError("CAMERA_UNSUPPORTED", "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301\u5B9E\u65F6\u626B\u7801\uFF0C\u8BF7\u4ECE\u76F8\u518C\u8BC6\u522B\u6216\u5728\u7CFB\u7EDF\u6D4F\u89C8\u5668\u6253\u5F00");
           return;
         }
+        abortController = new AbortController();
+        const {
+          signal
+        } = abortController;
+        startupStartedAt = Date.now();
+        const configuredTimeout = Number(props.startupTimeout);
+        const timeout = Number.isFinite(configuredTimeout) ? Math.max(0, configuredTimeout) : DEFAULT_STARTUP_TIMEOUT;
+        if (timeout > 0) {
+          startupDeadline = startupStartedAt + timeout;
+          startupTimer = setTimeout(() => {
+            if (!isCurrent(id) || phase.value !== "starting")
+              return;
+            reportStartupTimeout();
+          }, timeout);
+        }
+        if (!setStartupStage("camera", id))
+          return;
         try {
-          const acquiredStream = yield navigator.mediaDevices.getUserMedia({
+          const acquiredStream = yield waitForAbort(navigator.mediaDevices.getUserMedia({
             audio: false,
             video: extend(deviceId ? {
               deviceId: {
@@ -283,28 +351,44 @@ var stdin_default = defineComponent({
                 ideal: 720
               }
             })
-          });
+          }).then((acquired) => {
+            if (!isCurrent(id))
+              acquired.getTracks().forEach((track2) => track2.stop());
+            return acquired;
+          }), signal);
           if (!isCurrent(id)) {
             acquiredStream.getTracks().forEach((track2) => track2.stop());
             return;
           }
           stream = acquiredStream;
+        } catch (error) {
+          if (isCurrent(id))
+            cameraError(error);
+          return;
+        }
+        if (!setStartupStage("preview", id))
+          return;
+        try {
           yield nextTick();
-          if (!isCurrent(id))
+          if (!canContinueStartup(id))
             return;
           if (!video.value)
             throw new Error("\u626B\u7801\u9884\u89C8\u5C1A\u672A\u5C31\u7EEA");
           video.value.srcObject = stream;
-          yield video.value.play();
+          yield waitForAbort(video.value.play(), signal);
         } catch (error) {
           if (isCurrent(id))
-            cameraError(error);
+            reportError("PREVIEW_FAILED", startupText("previewFailed"), error);
           return;
         }
+        if (!setStartupStage("decoder", id))
+          return;
         let decoder;
         try {
-          decoder = yield import("./decoder");
-          yield decoder.prepareDecoder(props.wasmUrl);
+          decoder = yield waitForAbort(import("./decoder"), signal);
+          if (!canContinueStartup(id))
+            return;
+          yield waitForAbort(decoder.prepareDecoder(props.wasmUrl, signal), signal);
         } catch (error) {
           if (isCurrent(id))
             reportError("DECODER_LOAD_FAILED", "\u626B\u7801\u8D44\u6E90\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u8D44\u6E90\u90E8\u7F72\u540E\u91CD\u8BD5", error);
@@ -312,6 +396,8 @@ var stdin_default = defineComponent({
         }
         if (!isCurrent(id))
           return;
+        if (!canContinueStartup(id))
+          return;
         const track = stream == null ? void 0 : stream.getVideoTracks()[0];
         try {
           const capability = (_b = track == null ? void 0 : track.getCapabilities) == null ? void 0 : _b.call(track).torch;
@@ -333,6 +419,9 @@ var stdin_default = defineComponent({
         }).catch(() => {
         });
         phase.value = "scanning";
+        clearStartupTimer();
+        if (!setStartupStage("ready", id))
+          return;
         emit("ready", {
           torch: hasTorch.value
         });
@@ -342,25 +431,32 @@ var stdin_default = defineComponent({
     const scanImage = (file) => __async(this, null, function* () {
       if (!props.show || props.paused)
         return;
+      pickingAlbum = false;
+      release();
+      phase.value = "processing";
+      message.value = "";
       if (file.size > Number(props.maxImageSize)) {
         reportError("IMAGE_TOO_LARGE", "\u56FE\u7247\u8FC7\u5927\uFF0C\u8BF7\u9009\u62E9\u8F83\u5C0F\u7684\u56FE\u7247");
         return;
       }
-      release();
       const id = generation;
-      phase.value = "processing";
-      message.value = "";
+      abortController = new AbortController();
+      const {
+        signal
+      } = abortController;
       let imageCanvas;
       try {
-        const decoder = yield import("./decoder");
-        const image = yield decoder.loadImage(file);
+        const decoder = yield waitForAbort(import("./decoder"), signal);
+        if (!isCurrent(id))
+          return;
+        const image = yield waitForAbort(decoder.loadImage(file, signal), signal);
         if (!isCurrent(id))
           return;
         imageCanvas = document.createElement("canvas");
         const data = decoder.captureImage(image, imageCanvas, 1920);
         if (!data)
           throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u56FE\u7247");
-        const result = yield decoder.decode(data, props.formats, props.wasmUrl);
+        const result = yield waitForAbort(decoder.decode(data, props.formats, props.wasmUrl, signal), signal);
         if (!isCurrent(id))
           return;
         if (!result) {
@@ -429,6 +525,15 @@ var stdin_default = defineComponent({
         start();
       }
     };
+    const onAlbumCancel = () => {
+      if (pickingAlbum && phase.value === "paused")
+        start();
+      pickingAlbum = false;
+    };
+    watch(fileInput, (input, previous) => {
+      previous == null ? void 0 : previous.removeEventListener("cancel", onAlbumCancel);
+      input == null ? void 0 : input.addEventListener("cancel", onAlbumCancel);
+    });
     watch(() => props.show, (show) => __async(this, null, function* () {
       release();
       recentResults.clear();
@@ -455,9 +560,15 @@ var stdin_default = defineComponent({
       if (props.show)
         start();
     });
+    watch(() => props.wasmUrl, () => {
+      if (props.show && !props.nativeScan && (phase.value === "starting" || phase.value === "scanning"))
+        start();
+    });
     onMounted(() => document.addEventListener("visibilitychange", onVisibilityChange));
     onBeforeUnmount(() => {
+      var _a;
       release();
+      (_a = fileInput.value) == null ? void 0 : _a.removeEventListener("cancel", onAlbumCancel);
       if (canvas) {
         canvas.width = 0;
         canvas.height = 0;
@@ -542,7 +653,15 @@ var stdin_default = defineComponent({
           "color": "white",
           "vertical": true
         }, {
-          default: () => [phase.value === "starting" ? props.nativeScan ? "\u6B63\u5728\u6253\u5F00\u626B\u7801..." : "\u6B63\u5728\u542F\u52A8\u6444\u50CF\u5934..." : props.processingText]
+          default: () => {
+            var _a, _b, _c, _d, _e, _f;
+            return [phase.value === "starting" ? props.nativeScan ? "\u6B63\u5728\u6253\u5F00\u626B\u7801..." : {
+              camera: (_b = (_a = props.startupTexts) == null ? void 0 : _a.camera) != null ? _b : startupText("startupCamera"),
+              preview: (_d = (_c = props.startupTexts) == null ? void 0 : _c.preview) != null ? _d : startupText("startupPreview"),
+              decoder: (_f = (_e = props.startupTexts) == null ? void 0 : _e.decoder) != null ? _f : startupText("startupDecoder"),
+              ready: ""
+            }[startupStage.value] : props.processingText];
+          }
         }), needsRetry && _createVNode(_Fragment, null, [_createVNode("p", {
           "class": bem("message")
         }, [message.value || "\u626B\u63CF\u5DF2\u6682\u505C"]), _createVNode(Button, {
@@ -575,6 +694,7 @@ var stdin_default = defineComponent({
             var _a;
             stop();
             resumeWhenVisible = false;
+            pickingAlbum = true;
             (_a = fileInput.value) == null ? void 0 : _a.click();
           }
         }, [_createVNode(Icon, {
@@ -604,6 +724,9 @@ var stdin_default = defineComponent({
             input.value = "";
             if (file)
               scanImage(file);
+            else if (pickingAlbum && phase.value === "paused")
+              start();
+            pickingAlbum = false;
           }
         }, null)]
       });

package/es/qr-scanner/decoder.d.ts

@@ -1,7 +1,7 @@
 import type { QrScannerFormat } from './types';
-export declare function prepareDecoder(wasmUrl?: string): Promise<void>;
-export declare function decode(image: ImageData, formats: QrScannerFormat[], wasmUrl?: string): Promise<import("zxing-wasm/reader").ReadResult | undefined>;
-export declare function loadImage(file: File): Promise<HTMLImageElement>;
+export declare function prepareDecoder(wasmUrl?: string, signal?: AbortSignal): Promise<void>;
+export declare function decode(image: ImageData, formats: QrScannerFormat[], wasmUrl?: string, signal?: AbortSignal): Promise<import("zxing-wasm/reader").ReadResult | undefined>;
+export declare function loadImage(file: File, signal?: AbortSignal): Promise<HTMLImageElement>;
 export declare function captureImage(source: HTMLVideoElement | HTMLImageElement, canvas: HTMLCanvasElement, maxSize?: number, region?: {
     x: number;
     y: number;

package/es/qr-scanner/decoder.mjs

@@ -18,48 +18,120 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-import { prepareZXingModule, readBarcodes } from "zxing-wasm/reader";
-let ready;
-let activeWasmUrl;
-function prepareDecoder(wasmUrl) {
-  return __async(this, null, function* () {
+import {
+  prepareZXingModule,
+  purgeZXingModule,
+  readBarcodes
+} from "zxing-wasm/reader";
+import { abortError, waitForAbort } from "./startup.mjs";
+let preparation;
+function invalidate(entry) {
+  if (preparation === entry) {
+    preparation = void 0;
+    purgeZXingModule();
+  }
+}
+function createPreparation(wasmUrl) {
+  const controller = new AbortController();
+  const entry = {
+    wasmUrl,
+    pending: true,
+    controller,
+    consumers: /* @__PURE__ */ new Set(),
+    promise: void 0
+  };
+  const initialize = () => __async(this, null, function* () {
     const url = wasmUrl || (yield import("zxing-wasm/reader/zxing_reader.wasm?url")).default;
-    if (!ready || url !== activeWasmUrl) {
-      activeWasmUrl = url;
-      ready = Promise.resolve(
-        prepareZXingModule({
-          overrides: { locateFile: () => url },
-          fireImmediately: true
-        })
-      ).catch((error) => {
-        ready = void 0;
-        throw error;
-      });
+    if (controller.signal.aborted || preparation !== entry)
+      throw abortError();
+    yield prepareZXingModule({
+      overrides: { locateFile: () => url },
+      fireImmediately: true
+    });
+  });
+  entry.promise = waitForAbort(
+    Promise.resolve().then(initialize),
+    controller.signal
+  ).then(
+    () => {
+      entry.pending = false;
+    },
+    (error) => {
+      entry.pending = false;
+      invalidate(entry);
+      throw error;
+    }
+  );
+  return entry;
+}
+function prepareDecoder(wasmUrl, signal) {
+  return __async(this, null, function* () {
+    if (signal == null ? void 0 : signal.aborted)
+      throw abortError();
+    if (!preparation || preparation.wasmUrl !== wasmUrl) {
+      preparation = createPreparation(wasmUrl);
+    }
+    const entry = preparation;
+    const consumer = Symbol("decoder-consumer");
+    entry.consumers.add(consumer);
+    const releaseConsumer = () => {
+      entry.consumers.delete(consumer);
+      if (entry.pending && !entry.consumers.size) {
+        invalidate(entry);
+        entry.controller.abort();
+      }
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", releaseConsumer, { once: true });
+    try {
+      yield waitForAbort(entry.promise, signal);
+    } finally {
+      signal == null ? void 0 : signal.removeEventListener("abort", releaseConsumer);
+      releaseConsumer();
     }
-    yield ready;
   });
 }
-function decode(image, formats, wasmUrl) {
+function decode(image, formats, wasmUrl, signal) {
   return __async(this, null, function* () {
-    yield prepareDecoder(wasmUrl);
-    const results = yield readBarcodes(image, {
-      formats: formats.length ? formats : ["QRCode"],
-      tryHarder: true,
-      maxNumberOfSymbols: 1
-    });
+    yield prepareDecoder(wasmUrl, signal);
+    if (signal == null ? void 0 : signal.aborted)
+      throw abortError();
+    const results = yield waitForAbort(
+      readBarcodes(image, {
+        formats: formats.length ? formats : ["QRCode"],
+        tryHarder: true,
+        maxNumberOfSymbols: 1
+      }),
+      signal
+    );
     return results.find((result) => result.isValid && result.text.length > 0);
   });
 }
-function loadImage(file) {
+function loadImage(file, signal) {
   return new Promise((resolve, reject) => {
+    if (signal == null ? void 0 : signal.aborted) {
+      reject(abortError());
+      return;
+    }
     const url = URL.createObjectURL(file);
     const image = new Image();
-    image.onload = () => {
+    const cleanup = () => {
       URL.revokeObjectURL(url);
+      signal == null ? void 0 : signal.removeEventListener("abort", onAbort);
+      image.onload = null;
+      image.onerror = null;
+    };
+    const onAbort = () => {
+      cleanup();
+      image.src = "";
+      reject(abortError());
+    };
+    signal == null ? void 0 : signal.addEventListener("abort", onAbort, { once: true });
+    image.onload = () => {
+      cleanup();
       resolve(image);
     };
     image.onerror = () => {
-      URL.revokeObjectURL(url);
+      cleanup();
       reject(new Error("\u65E0\u6CD5\u8BFB\u53D6\u56FE\u7247\uFF0C\u8BF7\u9009\u62E9 JPG\u3001PNG \u7B49\u6D4F\u89C8\u5668\u652F\u6301\u7684\u56FE\u7247"));
     };
     image.src = url;