persagy-vant 0.0.51 → 0.0.52

package/es/qr-scanner/QrScanner.mjs

@@ -0,0 +1,615 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { defineComponent, nextTick, onActivated, onBeforeUnmount, onDeactivated, onMounted, ref, watch, createVNode as _createVNode, Fragment as _Fragment, createTextVNode as _createTextVNode } from "vue";
+import { createNamespace, extend, makeArrayProp, makeNumericProp, makeStringProp, numericProp, truthProp } from "../utils/index.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { useId } from "../composables/use-id.mjs";
+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");
+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..."),
+  formats: extend(makeArrayProp(), {
+    default: () => ["QRCode"]
+  }),
+  facingMode: makeStringProp("environment"),
+  showAlbum: truthProp,
+  showTorch: truthProp,
+  showSwitchCamera: truthProp,
+  closeAfterScan: truthProp,
+  scanInterval: makeNumericProp(150),
+  duplicateInterval: makeNumericProp(2e3),
+  maxImageSize: makeNumericProp(20 * 1024 * 1024),
+  paused: Boolean,
+  wasmUrl: String,
+  beforeConfirm: Function,
+  nativeScan: Function,
+  teleport: {
+    type: [String, Object],
+    default: "body"
+  },
+  zIndex: numericProp,
+  closeOnPopstate: truthProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: qrScannerProps,
+  emits: ["update:show", "scan", "error", "cancel", "close", "closed", "ready"],
+  setup(props, {
+    emit
+  }) {
+    const torchHintId = `${useId()}-torch-hint`;
+    const video = ref();
+    const frame = ref();
+    const fileInput = ref();
+    const phase = ref("idle");
+    const message = ref("");
+    const hasTorch = ref(false);
+    const torchOn = ref(false);
+    const torchChanging = ref(false);
+    const cameraCount = ref(0);
+    let cameras = [];
+    let deviceId;
+    let stream;
+    let canvas;
+    let timer;
+    let generation = 0;
+    let abortController;
+    let resumeWhenVisible = false;
+    const recentResults = /* @__PURE__ */ new Map();
+    const isCurrent = (id) => id === generation && props.show && !props.paused;
+    const release = () => {
+      generation += 1;
+      if (timer)
+        clearTimeout(timer);
+      timer = void 0;
+      abortController == null ? void 0 : abortController.abort();
+      abortController = void 0;
+      stream == null ? void 0 : stream.getTracks().forEach((track) => track.stop());
+      stream = void 0;
+      if (video.value)
+        video.value.srcObject = null;
+      hasTorch.value = false;
+      torchOn.value = false;
+      torchChanging.value = false;
+    };
+    const stop = () => {
+      release();
+      phase.value = "paused";
+    };
+    const close = (cancelled = false) => {
+      release();
+      phase.value = "idle";
+      if (cancelled)
+        emit("cancel");
+      emit("update:show", false);
+    };
+    const reportError = (code, text, cause) => {
+      release();
+      phase.value = "error";
+      message.value = text;
+      emit("error", {
+        code,
+        message: text,
+        cause
+      });
+    };
+    const cameraError = (error) => {
+      const errorName = error == null ? void 0 : error.name;
+      if (errorName === "NotAllowedError" || errorName === "PermissionDeniedError") {
+        reportError("CAMERA_PERMISSION_DENIED", "\u65E0\u6CD5\u4F7F\u7528\u6444\u50CF\u5934\uFF0C\u8BF7\u5141\u8BB8\u76F8\u673A\u6743\u9650\uFF1B\u4E5F\u53EF\u4EE5\u4ECE\u76F8\u518C\u8BC6\u522B", error);
+      } else if (errorName === "NotFoundError" || errorName === "DevicesNotFoundError") {
+        reportError("CAMERA_NOT_FOUND", "\u672A\u627E\u5230\u53EF\u7528\u6444\u50CF\u5934\uFF0C\u8BF7\u4ECE\u76F8\u518C\u8BC6\u522B", error);
+      } else {
+        reportError("CAMERA_UNAVAILABLE", "\u6444\u50CF\u5934\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u5173\u95ED\u5176\u4ED6\u5360\u7528\u76F8\u673A\u7684\u5E94\u7528\u540E\u91CD\u8BD5", error);
+      }
+    };
+    const schedule = (id, decoder) => {
+      if (!isCurrent(id) || phase.value !== "scanning")
+        return;
+      timer = setTimeout(
+        // The frame reader schedules the next iteration of this loop.
+        // eslint-disable-next-line no-use-before-define
+        () => scanFrame(id, decoder),
+        Math.max(100, Number(props.scanInterval) || 150)
+      );
+    };
+    const acceptResult = (result, id) => __async(this, null, function* () {
+      var _a;
+      if (!isCurrent(id))
+        return;
+      const now = Date.now();
+      if (result.source === "camera" && now - (recentResults.get(result.text) || 0) < Number(props.duplicateInterval))
+        return;
+      recentResults.set(result.text, now);
+      if (recentResults.size > 100) {
+        recentResults.delete(recentResults.keys().next().value);
+      }
+      phase.value = "processing";
+      message.value = "";
+      try {
+        const accepted = yield (_a = props.beforeConfirm) == null ? void 0 : _a.call(props, result);
+        if (!isCurrent(id))
+          return;
+        if (accepted === false) {
+          stop();
+          message.value = "\u672C\u6B21\u626B\u7801\u7ED3\u679C\u672A\u786E\u8BA4\uFF0C\u8BF7\u7EE7\u7EED\u626B\u63CF";
+          return;
+        }
+        emit("scan", result);
+        if (!isCurrent(id))
+          return;
+        if (props.closeAfterScan) {
+          close();
+        } else if (result.source === "camera") {
+          phase.value = "scanning";
+        } else {
+          timer = setTimeout(
+            // Non-camera sources restart through the same acquisition path.
+            // eslint-disable-next-line no-use-before-define
+            start,
+            Math.max(100, Number(props.scanInterval) || 150)
+          );
+        }
+      } catch (error) {
+        if (isCurrent(id)) {
+          reportError("CONFIRM_FAILED", (error == null ? void 0 : error.message) || "\u8BBE\u5907\u4FE1\u606F\u67E5\u8BE2\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5", error);
+        }
+      }
+    });
+    function scanFrame(id, decoder) {
+      return __async(this, null, function* () {
+        var _a;
+        if (!isCurrent(id) || phase.value !== "scanning" || !video.value)
+          return;
+        try {
+          canvas || (canvas = document.createElement("canvas"));
+          const viewport = video.value.getBoundingClientRect();
+          const target = (_a = frame.value) == null ? void 0 : _a.getBoundingClientRect();
+          if (!viewport.width || !viewport.height || !(target == null ? void 0 : target.width)) {
+            schedule(id, decoder);
+            return;
+          }
+          const scale = Math.max(viewport.width / video.value.videoWidth, viewport.height / video.value.videoHeight);
+          const offsetX = (video.value.videoWidth * scale - viewport.width) / 2;
+          const offsetY = (video.value.videoHeight * scale - viewport.height) / 2;
+          const image = decoder.captureImage(video.value, canvas, 1280, {
+            x: (target.left - viewport.left + offsetX) / scale,
+            y: (target.top - viewport.top + offsetY) / scale,
+            width: target.width / scale,
+            height: target.height / scale
+          });
+          if (image) {
+            const result = yield decoder.decode(image, props.formats, props.wasmUrl);
+            if (!isCurrent(id))
+              return;
+            if (result)
+              yield acceptResult({
+                text: result.text,
+                format: result.format,
+                source: "camera"
+              }, id);
+          }
+          schedule(id, decoder);
+        } catch (error) {
+          if (isCurrent(id))
+            reportError("DECODE_FAILED", "\u8BC6\u522B\u670D\u52A1\u5F02\u5E38\uFF0C\u8BF7\u91CD\u8BD5\u6216\u4ECE\u76F8\u518C\u8BC6\u522B", error);
+        }
+      });
+    }
+    function start() {
+      return __async(this, null, function* () {
+        var _a, _b, _c, _d;
+        release();
+        if (!props.show || props.paused || document.hidden) {
+          phase.value = "paused";
+          return;
+        }
+        const id = generation;
+        phase.value = "starting";
+        message.value = "";
+        if (props.nativeScan) {
+          abortController = new AbortController();
+          try {
+            const result = yield props.nativeScan({
+              formats: props.formats,
+              signal: abortController.signal
+            });
+            if (!isCurrent(id))
+              return;
+            if (!result)
+              close(true);
+            else if (typeof result.text !== "string" || !result.text.length) {
+              reportError("NATIVE_SCAN_FAILED", "\u672A\u83B7\u53D6\u5230\u4E8C\u7EF4\u7801\u5185\u5BB9\uFF0C\u8BF7\u91CD\u65B0\u626B\u63CF");
+            } else
+              yield acceptResult({
+                text: result.text,
+                format: result.format || "QRCode",
+                source: "native"
+              }, id);
+          } catch (error) {
+            if (isCurrent(id))
+              reportError("NATIVE_SCAN_FAILED", (error == null ? void 0 : error.message) || "\u5BBF\u4E3B\u626B\u7801\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5", error);
+          }
+          return;
+        }
+        if (window.isSecureContext === false) {
+          reportError("INSECURE_CONTEXT", "\u5B9E\u65F6\u626B\u7801\u9700\u8981 HTTPS \u5B89\u5168\u9875\u9762\uFF0C\u8BF7\u6539\u7528 HTTPS \u6216\u4ECE\u76F8\u518C\u8BC6\u522B");
+          return;
+        }
+        if (!((_a = navigator.mediaDevices) == null ? void 0 : _a.getUserMedia)) {
+          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;
+        }
+        try {
+          const acquiredStream = yield navigator.mediaDevices.getUserMedia({
+            audio: false,
+            video: extend(deviceId ? {
+              deviceId: {
+                exact: deviceId
+              }
+            } : {
+              facingMode: {
+                ideal: props.facingMode
+              }
+            }, {
+              width: {
+                ideal: 1280
+              },
+              height: {
+                ideal: 720
+              }
+            })
+          });
+          if (!isCurrent(id)) {
+            acquiredStream.getTracks().forEach((track2) => track2.stop());
+            return;
+          }
+          stream = acquiredStream;
+          yield nextTick();
+          if (!isCurrent(id))
+            return;
+          if (!video.value)
+            throw new Error("\u626B\u7801\u9884\u89C8\u5C1A\u672A\u5C31\u7EEA");
+          video.value.srcObject = stream;
+          yield video.value.play();
+        } catch (error) {
+          if (isCurrent(id))
+            cameraError(error);
+          return;
+        }
+        let decoder;
+        try {
+          decoder = yield import("./decoder");
+          yield decoder.prepareDecoder(props.wasmUrl);
+        } 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);
+          return;
+        }
+        if (!isCurrent(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;
+          hasTorch.value = Array.isArray(capability) ? capability.includes(true) : capability === true;
+        } catch (e) {
+          hasTorch.value = false;
+        }
+        track == null ? void 0 : track.addEventListener("ended", () => {
+          if (isCurrent(id))
+            reportError("CAMERA_UNAVAILABLE", "\u6444\u50CF\u5934\u5DF2\u4E2D\u65AD\uFF0C\u8BF7\u91CD\u65B0\u5C1D\u8BD5");
+        }, {
+          once: true
+        });
+        (_d = (_c = navigator.mediaDevices).enumerateDevices) == null ? void 0 : _d.call(_c).then((devices) => {
+          if (!isCurrent(id))
+            return;
+          cameras = devices.filter((device) => device.kind === "videoinput");
+          cameraCount.value = cameras.length;
+        }).catch(() => {
+        });
+        phase.value = "scanning";
+        emit("ready", {
+          torch: hasTorch.value
+        });
+        schedule(id, decoder);
+      });
+    }
+    const scanImage = (file) => __async(this, null, function* () {
+      if (!props.show || props.paused)
+        return;
+      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 = "";
+      let imageCanvas;
+      try {
+        const decoder = yield import("./decoder");
+        const image = yield decoder.loadImage(file);
+        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);
+        if (!isCurrent(id))
+          return;
+        if (!result) {
+          reportError("IMAGE_NOT_FOUND", "\u56FE\u7247\u4E2D\u672A\u8BC6\u522B\u5230\u4E8C\u7EF4\u7801\uFF0C\u8BF7\u9009\u62E9\u6E05\u6670\u7684\u8BBE\u5907\u4E8C\u7EF4\u7801\u56FE\u7247");
+          return;
+        }
+        yield acceptResult({
+          text: result.text,
+          format: result.format,
+          source: "image"
+        }, id);
+      } catch (error) {
+        if (isCurrent(id))
+          reportError("DECODE_FAILED", (error == null ? void 0 : error.message) || "\u56FE\u7247\u8BC6\u522B\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5", error);
+      } finally {
+        if (imageCanvas) {
+          imageCanvas.width = 0;
+          imageCanvas.height = 0;
+        }
+      }
+    });
+    const toggleTorch = () => __async(this, null, function* () {
+      const id = generation;
+      const track = stream == null ? void 0 : stream.getVideoTracks()[0];
+      if (!track || !hasTorch.value || torchChanging.value || phase.value === "starting" || phase.value === "processing")
+        return;
+      const enabled = !torchOn.value;
+      torchChanging.value = true;
+      try {
+        yield track.applyConstraints({
+          advanced: [{
+            torch: enabled
+          }]
+        });
+        if (isCurrent(id))
+          torchOn.value = enabled;
+      } catch (error) {
+        if (isCurrent(id)) {
+          hasTorch.value = false;
+          emit("error", {
+            code: "TORCH_UNAVAILABLE",
+            message: "\u5F53\u524D\u6444\u50CF\u5934\u65E0\u6CD5\u5F00\u542F\u624B\u7535\u7B52",
+            cause: error
+          });
+        }
+      } finally {
+        if (isCurrent(id))
+          torchChanging.value = false;
+      }
+    });
+    const switchCamera = () => {
+      var _a, _b;
+      const current = (_a = stream == null ? void 0 : stream.getVideoTracks()[0]) == null ? void 0 : _a.getSettings().deviceId;
+      const index = cameras.findIndex((camera) => camera.deviceId === current);
+      deviceId = (_b = cameras[(index + 1) % cameras.length]) == null ? void 0 : _b.deviceId;
+      start();
+    };
+    const onVisibilityChange = () => {
+      if (props.nativeScan)
+        return;
+      if (document.hidden) {
+        resumeWhenVisible = props.show && (phase.value === "scanning" || phase.value === "starting");
+        stop();
+      } else if (resumeWhenVisible) {
+        resumeWhenVisible = false;
+        start();
+      }
+    };
+    watch(() => props.show, (show) => __async(this, null, function* () {
+      release();
+      recentResults.clear();
+      if (show) {
+        deviceId = void 0;
+        yield nextTick();
+        if (props.show)
+          start();
+      } else {
+        phase.value = "idle";
+        resumeWhenVisible = false;
+      }
+    }), {
+      immediate: true
+    });
+    watch(() => props.paused, (paused) => {
+      if (paused)
+        stop();
+      else if (props.show)
+        start();
+    });
+    watch(() => props.facingMode, () => {
+      deviceId = void 0;
+      if (props.show)
+        start();
+    });
+    onMounted(() => document.addEventListener("visibilitychange", onVisibilityChange));
+    onBeforeUnmount(() => {
+      release();
+      if (canvas) {
+        canvas.width = 0;
+        canvas.height = 0;
+      }
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    });
+    onDeactivated(stop);
+    onActivated(() => {
+      if (props.show && phase.value === "paused")
+        start();
+    });
+    useExpose({
+      start,
+      stop,
+      close: () => close(true),
+      scanImage
+    });
+    return () => {
+      const busy = phase.value === "starting" || phase.value === "processing";
+      const needsRetry = phase.value === "error" || phase.value === "paused";
+      let torchHint = "";
+      if (!hasTorch.value) {
+        if (props.nativeScan)
+          torchHint = "\u8865\u5149\u8BF7\u5728\u539F\u751F\u626B\u7801\u9875\u9762\u64CD\u4F5C";
+        else if (phase.value === "starting")
+          torchHint = "\u76F8\u673A\u5C31\u7EEA\u540E\u53EF\u5F00\u542F\u624B\u7535\u7B52";
+        else if (phase.value === "scanning")
+          torchHint = "\u5F53\u524D\u6444\u50CF\u5934\u6216\u6D4F\u89C8\u5668\u65E0\u6CD5\u4F7F\u7528\u624B\u7535\u7B52";
+        else
+          torchHint = "\u6444\u50CF\u5934\u672A\u5C31\u7EEA\uFF0C\u624B\u7535\u7B52\u6682\u4E0D\u53EF\u7528";
+      }
+      return _createVNode(Popup, {
+        "show": props.show,
+        "class": bem(),
+        "teleport": props.teleport,
+        "zIndex": props.zIndex,
+        "position": "bottom",
+        "overlay": false,
+        "closeOnPopstate": props.closeOnPopstate,
+        "onUpdate:show": (show) => {
+          if (!show)
+            close(true);
+        },
+        "onClose": () => emit("close"),
+        "onClosed": () => emit("closed")
+      }, {
+        default: () => [_createVNode("video", {
+          "ref": video,
+          "class": bem("video"),
+          "muted": true,
+          "playsinline": true,
+          "autoplay": true
+        }, null), _createVNode("div", {
+          "class": bem("shade")
+        }, null), _createVNode("header", {
+          "class": bem("header")
+        }, [_createVNode("button", {
+          "type": "button",
+          "class": bem("close"),
+          "aria-label": "\u5173\u95ED\u626B\u7801",
+          "onClick": () => close(true)
+        }, [_createVNode(Icon, {
+          "name": "cross",
+          "size": "24"
+        }, null)]), _createVNode("span", {
+          "class": bem("title")
+        }, [props.title])]), _createVNode("div", {
+          "class": bem("viewfinder")
+        }, [_createVNode("div", {
+          "ref": frame,
+          "class": bem("frame", {
+            scanning: phase.value === "scanning"
+          }),
+          "aria-hidden": "true"
+        }, [_createVNode("i", null, null), _createVNode("i", null, null), _createVNode("i", null, null), _createVNode("i", null, null)]), _createVNode("p", {
+          "class": bem("tip")
+        }, [props.tip])]), _createVNode("div", {
+          "class": bem("status"),
+          "role": "status",
+          "aria-live": "polite"
+        }, [busy && _createVNode(Loading, {
+          "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]
+        }), needsRetry && _createVNode(_Fragment, null, [_createVNode("p", {
+          "class": bem("message")
+        }, [message.value || "\u626B\u63CF\u5DF2\u6682\u505C"]), _createVNode(Button, {
+          "type": "primary",
+          "size": "small",
+          "onClick": start
+        }, {
+          default: () => [phase.value === "paused" ? "\u7EE7\u7EED\u626B\u63CF" : "\u91CD\u65B0\u5C1D\u8BD5"]
+        })])]), _createVNode("div", {
+          "class": bem("actions")
+        }, [props.showTorch && _createVNode("button", {
+          "type": "button",
+          "class": bem("action", {
+            active: torchOn.value
+          }),
+          "disabled": !hasTorch.value || busy || torchChanging.value,
+          "aria-pressed": torchOn.value,
+          "aria-busy": torchChanging.value || void 0,
+          "aria-describedby": torchHint ? torchHintId : void 0,
+          "title": torchHint || void 0,
+          "onClick": toggleTorch
+        }, [_createVNode(Icon, {
+          "name": torchOn.value ? "flashlight" : "flashlight-off",
+          "size": "26"
+        }, null), _createVNode("span", null, [torchOn.value ? "\u5173\u95ED\u624B\u7535\u7B52" : "\u6253\u5F00\u624B\u7535\u7B52"])]), props.showAlbum && _createVNode("button", {
+          "type": "button",
+          "class": bem("action"),
+          "disabled": phase.value === "processing",
+          "onClick": () => {
+            var _a;
+            stop();
+            resumeWhenVisible = false;
+            (_a = fileInput.value) == null ? void 0 : _a.click();
+          }
+        }, [_createVNode(Icon, {
+          "name": "photo-o",
+          "size": "26"
+        }, null), _createVNode("span", null, [_createTextVNode("\u4ECE\u76F8\u518C\u8BC6\u522B")])]), props.showSwitchCamera && cameraCount.value > 1 && !props.nativeScan && _createVNode("button", {
+          "type": "button",
+          "class": bem("action"),
+          "disabled": busy,
+          "onClick": switchCamera
+        }, [_createVNode(Icon, {
+          "name": "exchange",
+          "size": "26"
+        }, null), _createVNode("span", null, [_createTextVNode("\u5207\u6362\u6444\u50CF\u5934")])]), props.showTorch && torchHint && _createVNode("p", {
+          "id": torchHintId,
+          "class": bem("torch-hint"),
+          "role": "status"
+        }, [torchHint])]), _createVNode("input", {
+          "ref": fileInput,
+          "class": bem("file-input"),
+          "type": "file",
+          "accept": "image/*",
+          "onChange": (event) => {
+            var _a;
+            const input = event.target;
+            const file = (_a = input.files) == null ? void 0 : _a[0];
+            input.value = "";
+            if (file)
+              scanImage(file);
+          }
+        }, null)]
+      });
+    };
+  }
+});
+export {
+  stdin_default as default
+};

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

@@ -0,0 +1,10 @@
+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 captureImage(source: HTMLVideoElement | HTMLImageElement, canvas: HTMLCanvasElement, maxSize?: number, region?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): ImageData | undefined;