@wasmedia/wexiftool 0.1.1 → 0.2.0

package/dist/wexiftool-CRI8zlju.js

@@ -0,0 +1,948 @@
+var J = Object.defineProperty;
+var q = (r, t, e) => t in r ? J(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var P = (r, t, e) => q(r, typeof t != "symbol" ? t + "" : t, e);
+class $ extends Error {
+  constructor(t, e) {
+    super(t, e), this.name = new.target.name;
+  }
+}
+class At extends $ {
+}
+class kt extends $ {
+  constructor(e, n) {
+    super(`${e} is locked by another sync access handle (another tab or worker may be using it)`, { cause: n });
+    P(this, "path");
+    this.path = e;
+  }
+}
+class z extends $ {
+}
+class xt extends $ {
+}
+class Pt extends $ {
+}
+class St extends $ {
+  constructor(e, n) {
+    super(`commit() failed after ${e.length} file(s): ${(n == null ? void 0 : n.message) ?? String(n)}`, { cause: n });
+    P(this, "committed");
+    this.committed = e;
+  }
+}
+function G(r, t, e, n = ",") {
+  const o = O(t), s = r === "json" ? V(o, e) : K(o, e, n);
+  return s === o ? t : L(s);
+}
+function V(r, t) {
+  return r.replace(/("SourceFile"\s*:\s*)("(?:[^"\\]|\\.)*")/g, (e, n, o) => {
+    let s;
+    try {
+      s = JSON.parse(j(o));
+    } catch {
+      return e;
+    }
+    const i = t(s);
+    return i === void 0 ? e : n + O(new TextEncoder().encode(JSON.stringify(i)));
+  });
+}
+function K(r, t, e) {
+  var c;
+  const n = X(r, e);
+  if (n.length === 0) return r;
+  const o = n[0].map((l) => I(r.slice(l.start, l.end)).replace(/^\xef\xbb\xbf/, ""));
+  let s = o.indexOf("SourceFile");
+  if (s < 0 && ((c = o[0]) == null ? void 0 : c.toLowerCase()) === "sourcefile" && (s = 0), s < 0) return r;
+  let i = "", a = 0;
+  for (const l of n.slice(1)) {
+    const u = l[s];
+    if (!u) continue;
+    const h = t(j(I(r.slice(u.start, u.end))));
+    h !== void 0 && (i += r.slice(a, u.start) + '"' + O(new TextEncoder().encode(h)).replaceAll('"', '""') + '"', a = u.end);
+  }
+  return i + r.slice(a);
+}
+function X(r, t) {
+  const e = [];
+  let n = [], o = 0;
+  for (; o < r.length; ) {
+    const s = o;
+    let i = o;
+    for (; r[i] === " "; ) i++;
+    if (r[i] === '"') {
+      for (i++; i < r.length; )
+        if (r[i] === '"')
+          if (r[i + 1] === '"') i += 2;
+          else break;
+        else
+          i++;
+      for (i++; i < r.length && !r.startsWith(t, i) && r[i] !== `
+` && r[i] !== "\r"; ) i++;
+    } else
+      for (; i < r.length && !r.startsWith(t, i) && r[i] !== `
+` && r[i] !== "\r"; ) i++;
+    if (n.push({ start: s, end: i }), r.startsWith(t, i)) {
+      o = i + t.length;
+      continue;
+    }
+    e.push(n), n = [], r[i] === "\r" && r[i + 1] === `
+` ? o = i + 2 : o = i + 1;
+  }
+  return n.length > 0 && e.push(n), e;
+}
+function I(r) {
+  const t = r.replace(/^ +/, "");
+  return t.startsWith('"') ? t.slice(1).replace(/"\s*$/, "").replaceAll('""', '"') : t.replace(/[ \n\r]+$/, "");
+}
+function O(r) {
+  let t = "";
+  for (let e = 0; e < r.length; e += 32768)
+    t += String.fromCharCode(...r.subarray(e, e + 32768));
+  return t;
+}
+function L(r) {
+  const t = new Uint8Array(r.length);
+  for (let e = 0; e < r.length; e++) t[e] = r.charCodeAt(e);
+  return t;
+}
+function j(r) {
+  return new TextDecoder().decode(L(r));
+}
+const g = "/wexiftool", Q = "/opt/perlwasm/bin/exiftool";
+function Y(r) {
+  r.ENV && (r.ENV.LC_ALL = "C");
+}
+class Z {
+  constructor(t, e) {
+    this.wasmUrl = t, this.onWasmProgress = e, this.module = null, this.modulePromise = null, this.tail = Promise.resolve(), this.createModule = null, this.stdoutSink = null, this.stderrSink = null;
+  }
+  /**
+   * Lazily initialize the WASM module on first use.
+   */
+  async init() {
+    if (!this.module) {
+      if (this.modulePromise) {
+        await this.modulePromise;
+        return;
+      }
+      this.modulePromise = this.loadModule(), this.module = await this.modulePromise;
+      try {
+        this.module.FS.mkdir(g);
+      } catch {
+      }
+    }
+  }
+  async loadModule() {
+    const t = {
+      noInitialRun: !0,
+      print: (s) => {
+        var i;
+        (i = this.stdoutSink) == null || i.call(this, s);
+      },
+      printErr: (s) => {
+        var i;
+        (i = this.stderrSink) == null || i.call(this, s);
+      },
+      preRun: [Y]
+    }, e = this.wasmUrl ?? this.defaultWasmUrl(), n = await this.importModuleFactory(e);
+    this.createModule = n;
+    const o = e.substring(0, e.lastIndexOf("/") + 1);
+    if (this.onWasmProgress && typeof fetch < "u" && !S()) {
+      const s = await this.fetchWithProgress(o + "perl.wasm");
+      return await n({
+        ...t,
+        locateFile: (i) => o + i,
+        wasmBinary: s
+      });
+    }
+    return await n({
+      ...t,
+      locateFile: (s) => o + s
+    });
+  }
+  async fetchWithProgress(t) {
+    const e = await fetch(t);
+    if (!e.ok)
+      throw new Error(`Failed to fetch ${t}: ${e.status} ${e.statusText}`);
+    const n = e.headers.get("content-length"), o = n ? parseInt(n, 10) : null, s = e.body.getReader(), i = [];
+    let a = 0;
+    for (; ; ) {
+      const { done: u, value: h } = await s.read();
+      if (u) break;
+      i.push(h), a += h.byteLength, this.onWasmProgress(a, o);
+    }
+    const c = new Uint8Array(a);
+    let l = 0;
+    for (const u of i)
+      c.set(u, l), l += u.byteLength;
+    return c;
+  }
+  async importModuleFactory(t) {
+    if (S()) {
+      const s = await import(
+        /* @vite-ignore */
+        t
+      );
+      return s.default ?? s;
+    }
+    const e = await fetch(t);
+    if (!e.ok)
+      throw new Error(`Failed to fetch ${t}: ${e.status} ${e.statusText}`);
+    const n = await e.text();
+    return new Function(
+      "exports",
+      "module",
+      "define",
+      `${n}
+return createPerlModule;`
+    )(void 0, void 0, void 0);
+  }
+  defaultWasmUrl() {
+    return new URL(
+      /* @vite-ignore */
+      "../wasm/perl.js",
+      import.meta.url
+    ).href;
+  }
+  /**
+   * Run exiftool over in-memory files. Only one run happens at a time (Perl is
+   * single-threaded). `result.files` holds the files the run changed.
+   */
+  async exec(t, e) {
+    const n = [...e].map(([i, a]) => ({ name: i, source: a })), { committed: o, ...s } = await this.run(t, n);
+    return s;
+  }
+  /**
+   * Run exiftool over any mix of in-memory files and file references.
+   *
+   * If every input is bytes, they are staged in MEMFS. Otherwise each input
+   * gets its own wopfs mount, so referenced files are read in place rather
+   * than copied in. Both use the same layout, `/wexiftool/<i>/<name>`, and
+   * both make inputs read-only, so exiftool sees identical files and produces
+   * identical output either way.
+   */
+  async run(t, e, n = {}) {
+    return await this.init(), e = await tt(t, e), this.enqueue(
+      () => {
+        var o;
+        return e.some((s) => !(s.source instanceof Uint8Array)) || (o = n.outputs) != null && o.length ? this.runMounted(t, e, n) : this.runStaged(t, e);
+      }
+    );
+  }
+  runStaged(t, e) {
+    const n = this.module.FS, o = e.map((i, a) => `${g}/${a}/${E(i)}`), s = /* @__PURE__ */ new Map();
+    try {
+      e.forEach((a, c) => {
+        n.mkdir(`${g}/${c}`), n.writeFile(o[c], a.source), n.chmod(o[c], 292), s.set(o[c], U(n, o[c]));
+      });
+      const i = this.callExiftool(t, e, o, /* @__PURE__ */ new Map());
+      return e.forEach((a, c) => {
+        if (U(n, o[c]) !== s.get(o[c]))
+          try {
+            i.files.set(a.name, n.readFile(o[c]));
+          } catch {
+          }
+      }), { ...i, committed: /* @__PURE__ */ new Map() };
+    } finally {
+      e.forEach((i, a) => C(n, `${g}/${a}`));
+    }
+  }
+  async runMounted(t, e, n) {
+    var c;
+    if (S() && !globalThis.crypto) {
+      const { webcrypto: l } = await import(
+        /* @vite-ignore */
+        "node:crypto"
+      );
+      Object.defineProperty(globalThis, "crypto", { value: l, configurable: !0, writable: !0 });
+    }
+    const { mountFiles: o } = await import("./index-C7MUqxoE.js").then((l) => l.a), s = this.module, i = e.map((l, u) => `${g}/${u}/${E(l)}`), a = [];
+    try {
+      for (const [m, d] of e.entries()) {
+        const y = ((c = d.commitTo) == null ? void 0 : c.dir) ?? (n.readOnly ? void 0 : n.privateDir);
+        if (y === void 0 && !n.readOnly)
+          throw new Error(`Input "${d.name}" is mounted, so the run needs a privateDir, a commitTo or readOnly`);
+        a.push(
+          await o(s, `${g}/${m}`, {
+            inputs: { [E(d)]: d.source },
+            outputDir: y,
+            // Read-only: no outputDir, so wopfs creates no scratch directory or
+            // pool, and anything exiftool tried to create would fail with
+            // EROFS. Otherwise exiftool creates one temp file per file it
+            // writes, and spill covers anything unexpected.
+            scratch: y === void 0 ? 0 : n.scratch ?? 1,
+            onExhausted: "spill",
+            backend: n.backend
+          })
+        );
+      }
+      const l = n.outputs ?? [], u = /* @__PURE__ */ new Map();
+      for (const [m, d] of l.entries()) {
+        const y = `${g}/o${m}`;
+        a.push(
+          await o(s, y, {
+            inputs: Object.fromEntries(d.existing.map((w) => [w, `${d.dir}/${w}`])),
+            outputDir: d.dir,
+            // A directory gets a file per input (-o DIR/).
+            scratch: n.scratch ?? (d.file === void 0 ? Math.max(1, e.length) : 1),
+            onExhausted: "spill",
+            backend: n.backend
+          })
+        ), u.set(d.name, d.file === void 0 ? `${y}/` : `${y}/${d.file}`);
+      }
+      const h = this.callExiftool(t, e, i, u), f = /* @__PURE__ */ new Map();
+      for (const [m, d] of e.entries()) {
+        const y = await a[m].commit(), w = y.find((p) => p.path === E(d));
+        if (d.commitTo)
+          w && f.set(d.name, w);
+        else
+          for (const p of y)
+            p === w && h.files.set(d.name, await it(p)), await st(p, n.privateDir);
+      }
+      for (const [m, d] of l.entries())
+        for (const y of await a[e.length + m].commit())
+          f.set(d.file === void 0 ? ot(d.name, y.path) : d.name, y);
+      return { ...h, committed: f };
+    } finally {
+      for (const l of a) await l.release();
+    }
+  }
+  /**
+   * Map names in `args` to their paths, run exiftool, and map paths in its
+   * output back to names. Synchronous: everything callMain touches must
+   * already be in place.
+   */
+  callExiftool(t, e, n, o) {
+    const s = this.module, i = new Map(e.map((f, m) => [f.name, n[m]])), a = [Q], c = /* @__PURE__ */ new Set();
+    for (const f of t) {
+      if (f.toLowerCase() === "-overwrite_original_in_place") {
+        a.push("-overwrite_original");
+        continue;
+      }
+      const m = i.get(f) ?? o.get(f);
+      if (m !== void 0) {
+        c.add(f), a.push(m);
+        continue;
+      }
+      const d = nt.exec(f), y = d ? i.get(d[2]) : void 0;
+      if (d && y !== void 0) {
+        c.add(d[2]), a.push(d[1] + y);
+        continue;
+      }
+      a.push(f);
+    }
+    for (const f of e)
+      c.has(f.name) || a.push(i.get(f.name));
+    let l = "", u = "";
+    this.stdoutSink = (f) => {
+      l += f + `
+`;
+    }, this.stderrSink = (f) => {
+      u += f + `
+`;
+    };
+    let h;
+    try {
+      h = s.callMain(a);
+    } catch (f) {
+      if (f.status !== void 0)
+        h = f.status;
+      else
+        throw f;
+    } finally {
+      this.stdoutSink = null, this.stderrSink = null;
+    }
+    for (const [f, m] of [...i, ...o])
+      l = l.replaceAll(m, f), u = u.replaceAll(m, f);
+    return e.forEach((f, m) => {
+      const d = new RegExp(`${g}/${m}(?![0-9])`, "g"), y = f.name.lastIndexOf("/"), w = y > 0 ? f.name.slice(0, y) : y === 0 ? "/" : ".";
+      l = l.replace(d, () => w), u = u.replace(d, () => w);
+    }), { stdout: l.trimEnd(), stderr: u.trimEnd(), exitCode: h, files: /* @__PURE__ */ new Map() };
+  }
+  /**
+   * Serialize runs. A run spans awaits (mounting, committing), so this is a
+   * promise chain rather than a flag: the next run starts only when the
+   * previous one has fully settled.
+   */
+  enqueue(t) {
+    const e = this.tail.then(t, t);
+    return this.tail = e.catch(() => {
+    }), e;
+  }
+  /**
+   * Release WASM module resources.
+   */
+  destroy() {
+    this.module = null, this.modulePromise = null, this.createModule = null, this.tail = Promise.resolve();
+  }
+}
+async function tt(r, t) {
+  var a;
+  const e = r.findIndex((c) => c.toLowerCase() === "-csvdelim"), n = e >= 0 ? (a = r[e + 1]) == null ? void 0 : a.replaceAll("\\t", "	") : void 0, o = (c, l) => `${g}/${l}/${E(c)}`, s = (c) => {
+    const l = c.toLowerCase(), u = t.findIndex(
+      (h) => h.name === c || h.name.toLowerCase() === l || typeof h.source == "string" && (h.source === c || h.source.toLowerCase() === l)
+    );
+    return u < 0 ? void 0 : o(t[u], u);
+  }, i = [...t];
+  for (const c of r) {
+    const l = rt.exec(c), u = l ? t.findIndex((m) => m.name === l[2]) : -1;
+    if (!l || u < 0) continue;
+    const h = l[1].toLowerCase() === "csv" ? "csv" : "json", f = G(h, await et(t[u].source), s, n);
+    i[u] = { name: t[u].name, source: f };
+  }
+  return i;
+}
+async function et(r) {
+  if (r instanceof Uint8Array) return r;
+  if (typeof r == "string") {
+    const { readFile: t } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    return new Uint8Array(await t(r));
+  }
+  return new Uint8Array(await (await r.getFile()).arrayBuffer());
+}
+const rt = /^-(csv|j|json)\+?=(.+)$/i, nt = /^(-(?:csv|j|json)\+?=|-geotag=)(.+)$/i;
+function ot(r, t) {
+  return r.endsWith("/") ? r + t : `${r}/${t}`;
+}
+function S() {
+  var r;
+  return typeof process < "u" && !!((r = process.versions) != null && r.node);
+}
+function E(r) {
+  var e;
+  const t = (((e = r.commitTo) == null ? void 0 : e.as) ?? r.name).split("/").pop();
+  return t && t !== "." && t !== ".." ? t : "input.bin";
+}
+function U(r, t) {
+  try {
+    const e = r.stat(t);
+    return `${e.ino}:${e.size}:${+e.mtime}`;
+  } catch {
+    return "missing";
+  }
+}
+function C(r, t) {
+  let e;
+  try {
+    e = r.readdir(t);
+  } catch {
+    return;
+  }
+  for (const n of e) {
+    if (n === "." || n === "..") continue;
+    const o = `${t}/${n}`;
+    try {
+      r.unlink(o);
+    } catch {
+      C(r, o);
+    }
+  }
+  try {
+    r.rmdir(t);
+  } catch {
+  }
+}
+async function it(r) {
+  if (r.handle) return new Uint8Array(await (await r.handle.getFile()).arrayBuffer());
+  if (r.hostPath) {
+    const { readFile: t } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    return new Uint8Array(await t(r.hostPath));
+  }
+  return r.bytes ?? new Uint8Array();
+}
+async function st(r, t) {
+  if (r.hostPath) {
+    const { rm: e } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    await e(r.hostPath, { force: !0 });
+    return;
+  }
+  if (typeof t != "string") {
+    const e = r.path.split("/"), n = e.pop();
+    let o = t;
+    for (const s of e) o = await o.getDirectoryHandle(s);
+    await o.removeEntry(n).catch(() => {
+    });
+  }
+}
+function b(r) {
+  return typeof r == "object" && r !== null && r.kind === "file" && typeof r.getFile == "function";
+}
+async function x(r) {
+  if (r instanceof Uint8Array)
+    return { name: "input.bin", data: r };
+  if (r instanceof ArrayBuffer)
+    return { name: "input.bin", data: new Uint8Array(r) };
+  if (b(r)) {
+    const t = await r.getFile();
+    return { name: r.name || "input.bin", data: new Uint8Array(await t.arrayBuffer()) };
+  }
+  if (typeof File < "u" && r instanceof File) {
+    const t = await r.arrayBuffer();
+    return { name: r.name || "input.bin", data: new Uint8Array(t) };
+  }
+  if (typeof Blob < "u" && r instanceof Blob) {
+    const t = await r.arrayBuffer();
+    return { name: "input.bin", data: new Uint8Array(t) };
+  }
+  throw new Error("Unsupported input type");
+}
+async function at(r, t) {
+  const e = ct(t);
+  if (typeof r.createSyncAccessHandle == "function") {
+    let n;
+    try {
+      n = await r.createSyncAccessHandle();
+    } catch (o) {
+      if (typeof r.createWritable != "function") throw o;
+      return D(r, e);
+    }
+    try {
+      n.truncate(0);
+      let o = 0;
+      for (; o < e.byteLength; ) {
+        const s = o === 0 ? e : e.slice(o), i = n.write(s, { at: o });
+        if (i <= 0)
+          throw new Error(`Short write to ${r.name} at byte ${o} of ${e.byteLength}`);
+        o += i;
+      }
+      n.flush();
+    } finally {
+      n.close();
+    }
+    return;
+  }
+  if (typeof r.createWritable == "function")
+    return D(r, e);
+  throw new Error(
+    `Cannot write to file handle "${r.name}": it has neither createSyncAccessHandle() (dedicated workers only) nor createWritable().`
+  );
+}
+async function D(r, t) {
+  const e = await r.createWritable();
+  try {
+    await e.write(t), await e.close();
+  } catch (n) {
+    throw await e.abort(n).catch(() => {
+    }), n;
+  }
+}
+function ct(r) {
+  const { buffer: t, byteOffset: e, byteLength: n } = r;
+  return t instanceof ArrayBuffer && e === 0 && n === t.byteLength ? t : r.slice().buffer;
+}
+const lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  isFileHandle: b,
+  resolveInput: x,
+  writeToHandle: at
+}, Symbol.toStringTag, { value: "Module" })), B = ".wexiftool";
+function M() {
+  var s, i;
+  const r = globalThis, t = !!((i = (s = r.process) == null ? void 0 : s.versions) != null && i.node) && typeof r.window > "u", e = r.DedicatedWorkerGlobalScope, n = r.FileSystemFileHandle, o = !t && typeof e == "function" && globalThis instanceof e && !!(n && "createSyncAccessHandle" in n.prototype);
+  return { node: t, opfs: o };
+}
+async function W(r, t, e, n) {
+  if (typeof t == "string") {
+    if (!e.node) throw new Error(`"${t}": file paths are only supported under Node`);
+    const { resolve: s, dirname: i, basename: a } = await import(
+      /* @vite-ignore */
+      "node:path"
+    ), c = s(t);
+    if (n === void 0) return { input: { name: r, source: c } };
+    if (typeof n != "string") return { input: { name: r, source: c }, writeAfter: n };
+    const l = s(n);
+    return a(l) !== a(c) ? { input: { name: r, source: c }, writeAfter: l } : { input: { name: r, source: c, commitTo: { dir: i(l), as: a(l) } } };
+  }
+  if (b(t) && e.opfs && await _(t)) {
+    const s = t;
+    if (n === void 0) return { input: { name: r, source: s } };
+    const i = b(n) && n.name === t.name ? await wt(n) : null;
+    return i ? { input: { name: r, source: s, commitTo: { dir: i, as: n.name } } } : { input: { name: r, source: s }, writeAfter: n };
+  }
+  const { data: o } = await x(t);
+  return { input: { name: r, source: o }, writeAfter: n };
+}
+const F = /* @__PURE__ */ new WeakMap();
+async function ut(r, t) {
+  try {
+    const e = await dt(t);
+    e && await e.isSameEntry(r) && F.set(r, t);
+  } catch {
+  }
+}
+async function ft(r) {
+  return (await navigator.storage.getDirectory()).resolve(r);
+}
+async function dt(r) {
+  if (r.length === 0) return null;
+  let t = await navigator.storage.getDirectory();
+  for (const e of r.slice(0, -1)) t = await t.getDirectoryHandle(e);
+  return t.getFileHandle(r[r.length - 1]);
+}
+const ht = 5e3;
+async function _(r) {
+  const t = F.get(r);
+  if (t) return t;
+  const n = [[await navigator.storage.getDirectory(), []]];
+  let o = 0;
+  for (; n.length > 0; ) {
+    const [s, i] = n.shift();
+    for await (const [a, c] of s.entries()) {
+      if (++o > ht) return null;
+      if (c.kind === "file") {
+        if (a === r.name && await c.isSameEntry(r)) {
+          const l = [...i, a];
+          return F.set(r, l), l;
+        }
+      } else i.length === 0 && a === B || n.push([c, [...i, a]]);
+    }
+  }
+  return null;
+}
+async function wt(r) {
+  const t = await _(r);
+  if (!t) return null;
+  let e = await navigator.storage.getDirectory();
+  for (const n of t.slice(0, -1)) e = await e.getDirectoryHandle(n);
+  return e;
+}
+async function H(r, t) {
+  if (r.node) {
+    const { mkdtemp: i, rm: a } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    ), { tmpdir: c } = await import(
+      /* @vite-ignore */
+      "node:os"
+    ), { join: l } = await import(
+      /* @vite-ignore */
+      "node:path"
+    ), u = await i(l(c(), "wexiftool-"));
+    try {
+      return await t(u);
+    } finally {
+      await a(u, { recursive: !0, force: !0 });
+    }
+  }
+  const e = globalThis.crypto.randomUUID().slice(0, 8), o = await (await navigator.storage.getDirectory()).getDirectoryHandle(B, { create: !0 }), s = await o.getDirectoryHandle(e, { create: !0 });
+  try {
+    return await t(s);
+  } finally {
+    await o.removeEntry(e, { recursive: !0 }).catch(() => {
+    });
+  }
+}
+async function T(r, t) {
+  if (typeof r == "string") {
+    const { writeFile: n } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    await n(r, t);
+    return;
+  }
+  const { writeToHandle: e } = await Promise.resolve().then(() => lt);
+  await e(r, t);
+}
+const mt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  detectEnvironment: M,
+  planInput: W,
+  registerHint: ut,
+  resolveOnCallerSide: ft,
+  withPrivateDir: H,
+  writeRef: T
+}, Symbol.toStringTag, { value: "Module" }));
+function yt(r) {
+  const t = r, e = [];
+  return "input" in t && e.push(t.input), t.inputs && e.push(...t.inputs), t.files && e.push(...t.files.values()), t.options && "output" in t.options && e.push(t.options.output), e.filter(b);
+}
+class R {
+  constructor(t, e) {
+    this.port = t, this.onWasmProgress = e, this.nextId = 1, this.pending = /* @__PURE__ */ new Map(), this.destroyed = !1, t.addEventListener("message", (n) => this.receive(n.data)), t.addEventListener("error", (n) => this.failAll(gt(n, "Worker error"))), t.addEventListener(
+      "messageerror",
+      () => this.failAll("Worker sent a message that could not be deserialized")
+    );
+  }
+  /**
+   * Load the WASM module inside `worker` and resolve once it's ready.
+   */
+  static async create(t, e) {
+    const n = new R(t, e == null ? void 0 : e.onWasmProgress);
+    return await n.call({
+      op: "init",
+      options: { wasmUrl: e == null ? void 0 : e.wasmUrl, progress: !!(e != null && e.onWasmProgress) }
+    }), n;
+  }
+  read(t) {
+    return this.call({ op: "read", input: t });
+  }
+  readMany(t) {
+    return this.call({ op: "readMany", inputs: t });
+  }
+  readRaw(t, e) {
+    return this.call({ op: "readRaw", input: t, args: e });
+  }
+  write(t, e, n) {
+    return this.call({ op: "write", input: t, tags: e, options: n });
+  }
+  exec(t, e, n) {
+    return this.call({ op: "exec", args: t, files: e, options: n });
+  }
+  /**
+   * Free the module. Terminates the worker when given a real `Worker`, which
+   * releases its memory outright; otherwise asks it to drop the module.
+   */
+  async destroy() {
+    if (this.destroyed = !0, typeof this.port.terminate == "function") {
+      this.port.terminate(), this.failAll("WExifToolWorker was destroyed");
+      return;
+    }
+    await this.call({ op: "destroy" });
+  }
+  async call(t) {
+    const e = this.nextId++, n = await pt(t);
+    if (this.destroyed && t.op !== "destroy") throw new Error("WExifToolWorker was destroyed");
+    return new Promise((o, s) => {
+      this.pending.set(e, { resolve: o, reject: s });
+      try {
+        this.port.postMessage({ ...t, id: e, hints: n });
+      } catch (i) {
+        this.pending.delete(e), s(i instanceof Error ? i : new Error(String(i)));
+      }
+    });
+  }
+  receive(t) {
+    var n;
+    if (t.kind === "progress") {
+      (n = this.onWasmProgress) == null || n.call(this, t.loaded, t.total);
+      return;
+    }
+    const e = this.pending.get(t.id);
+    e && (this.pending.delete(t.id), t.ok ? e.resolve(t.value) : e.reject(new Error(t.error)));
+  }
+  failAll(t) {
+    const e = new Error(t);
+    for (const n of this.pending.values()) n.reject(e);
+    this.pending.clear();
+  }
+}
+async function pt(r) {
+  var o, s;
+  const t = globalThis;
+  if (typeof t.window > "u" || typeof ((s = (o = t.navigator) == null ? void 0 : o.storage) == null ? void 0 : s.getDirectory) != "function") return;
+  const e = yt(r);
+  if (e.length === 0) return;
+  const { resolveOnCallerSide: n } = await Promise.resolve().then(() => mt);
+  return Promise.all(e.map((i) => n(i).catch(() => null)));
+}
+function gt(r, t) {
+  const e = r == null ? void 0 : r.message;
+  return typeof e == "string" && e ? `${t}: ${e}` : t;
+}
+class N {
+  constructor(t) {
+    this.glue = t;
+  }
+  /**
+   * Create and initialize a WExifTool instance.
+   * The WASM module is lazy-loaded on first use.
+   */
+  static async create(t) {
+    const e = new Z(t == null ? void 0 : t.wasmUrl, t == null ? void 0 : t.onWasmProgress);
+    return await e.init(), new N(e);
+  }
+  /**
+   * Read all metadata from a file.
+   * Returns a record of tag names to values.
+   *
+   * A host path (Node) or an OPFS file handle (in a dedicated worker) is read
+   * in place, without copying the file into memory.
+   */
+  async read(t) {
+    const e = k(t), n = await this.runFiles(["-json", "-G", e], [[e, t]], { readOnly: !0 });
+    if (n.exitCode !== 0 && n.stderr)
+      throw new Error(`ExifTool error: ${n.stderr}`);
+    try {
+      const o = JSON.parse(n.stdout);
+      return Array.isArray(o) ? o[0] : o;
+    } catch {
+      throw new Error(`Failed to parse ExifTool output: ${n.stdout}`);
+    }
+  }
+  /**
+   * Read metadata from several files in one exiftool run, which saves
+   * starting Perl once per file. Results are in input order.
+   *
+   * A file exiftool can't read gets an entry with an `Error` tag rather than
+   * failing the batch, as with native `exiftool -json`.
+   */
+  async readMany(t) {
+    if (t.length === 0) return [];
+    const e = bt(t.map(k)), n = await this.runFiles(
+      ["-json", "-G", ...e],
+      t.map((s, i) => [e[i], s]),
+      { readOnly: !0 }
+    );
+    let o;
+    try {
+      o = JSON.parse(n.stdout);
+    } catch {
+      throw new Error(`ExifTool error: ${n.stderr || `unparseable output: ${n.stdout}`}`);
+    }
+    if (!Array.isArray(o) || o.length !== t.length)
+      throw new Error(`ExifTool error: ${n.stderr || `expected ${t.length} results`}`);
+    return o;
+  }
+  async write(t, e, n) {
+    const o = k(t), s = Object.entries(e).map(([l, u]) => `-${l}=${u}`), i = typeof t == "string" || b(t), a = i ? (n == null ? void 0 : n.output) ?? t : void 0, c = await this.runFiles(
+      ["-overwrite_original", ...s, o],
+      [[o, t]],
+      { targets: a === void 0 ? void 0 : /* @__PURE__ */ new Map([[o, a]]) }
+    );
+    if (c.exitCode !== 0 && c.stderr)
+      throw new Error(`ExifTool error: ${c.stderr}`);
+    return i ? (!c.written.includes(o) && a !== t && await T(a, (await x(t)).data), a) : c.files.get(o) ?? (await x(t)).data;
+  }
+  /**
+   * Run exiftool with arbitrary flags and return raw stdout.
+   */
+  async readRaw(t, e) {
+    const n = k(t), o = await this.runFiles([...e, n], [[n, t]], { scratch: 0 });
+    if (o.exitCode !== 0 && o.stderr)
+      throw new Error(`ExifTool error: ${o.stderr}`);
+    return o.stdout;
+  }
+  /**
+   * Low-level: run exiftool with arbitrary args and a map of files.
+   * This is the most flexible API — CLI and other methods build on it.
+   *
+   * Values may be bytes, file handles or (under Node) host paths. Files the
+   * run changed come back as bytes in `result.files`.
+   *
+   * With `writeBack: true`, a changed file that came from a handle or host
+   * path is written back to it instead, and its name is listed in
+   * `result.written` rather than returned as bytes. Byte inputs always come
+   * back in `result.files`.
+   */
+  async exec(t, e, n) {
+    var c;
+    const o = [...e ?? []], s = n == null ? void 0 : n.writeBack, i = s ? new Map(
+      o.filter(
+        ([l, u]) => (typeof u == "string" || b(u)) && (s === !0 || s.includes(l))
+      )
+    ) : void 0, a = (c = n == null ? void 0 : n.outputs) != null && c.length ? await $t(n.outputs, o) : void 0;
+    return this.runFiles(t, o, { targets: i, outputs: a });
+  }
+  /**
+   * Plan every input (mount or copy), run, and write back results the
+   * mounts couldn't commit in place.
+   */
+  async runFiles(t, e, n) {
+    const o = M();
+    try {
+      return await this.runPlanned(t, e, n, o);
+    } catch (s) {
+      if (o.opfs && s instanceof z)
+        return this.runPlanned(t, e, n, { ...o, opfs: !1 });
+      throw s;
+    }
+  }
+  async runPlanned(t, e, { targets: n, scratch: o, readOnly: s, outputs: i }, a) {
+    var y;
+    const c = [], l = [];
+    for (const [w, p] of e) {
+      let v = await W(w, p, a, n == null ? void 0 : n.get(w));
+      const A = v.input.source;
+      typeof A == "object" && !(A instanceof Uint8Array) && (await vt(A, l) ? v = await W(w, p, { ...a, opfs: !1 }, n == null ? void 0 : n.get(w)) : l.push(A)), c.push(v);
+    }
+    const u = c.map((w) => w.input);
+    let h;
+    if (!i && u.every((w) => w.source instanceof Uint8Array))
+      h = await this.glue.exec(t, new Map(u.map((w) => [w.name, w.source])));
+    else {
+      const w = a.node ? "node" : "opfs";
+      h = !s && u.some((p) => !p.commitTo) ? await H(
+        a,
+        (p) => this.glue.run(t, u, { privateDir: p, backend: w, scratch: o, outputs: i })
+      ) : await this.glue.run(t, u, { backend: w, scratch: o, readOnly: s, outputs: i });
+    }
+    const f = [...((y = h.committed) == null ? void 0 : y.keys()) ?? []];
+    for (const { input: w, writeAfter: p } of c) {
+      const v = h.files.get(w.name);
+      p && v && (await T(p, v), h.files.delete(w.name), f.push(w.name));
+    }
+    const { committed: m, ...d } = h;
+    return { ...d, written: f };
+  }
+  /**
+   * Free WASM module resources.
+   */
+  destroy() {
+    this.glue.destroy();
+  }
+}
+function k(r) {
+  return typeof r == "string" ? r : (b(r) || typeof File < "u" && r instanceof File) && r.name || "input.bin";
+}
+function bt(r) {
+  const t = new Set(r), e = /* @__PURE__ */ new Map();
+  return r.map((n) => {
+    const o = (e.get(n) ?? 0) + 1;
+    if (e.set(n, o), o === 1) return n;
+    const s = n.lastIndexOf("/"), i = n.lastIndexOf("."), a = i > s + 1 ? i : n.length;
+    let c = o, l = `${n.slice(0, a)} (${c})${n.slice(a)}`;
+    for (; t.has(l); ) l = `${n.slice(0, a)} (${++c})${n.slice(a)}`;
+    return t.add(l), l;
+  });
+}
+async function vt(r, t) {
+  for (const e of t)
+    if (e === r || await e.isSameEntry(r)) return !0;
+  return !1;
+}
+async function $t(r, t) {
+  var u;
+  if (!M().node) throw new Error("exec() outputs are only supported under Node");
+  const { mkdir: e, stat: n } = await import(
+    /* @vite-ignore */
+    "node:fs/promises"
+  ), { resolve: o, dirname: s, basename: i, join: a } = await import(
+    /* @vite-ignore */
+    "node:path"
+  ), c = (h) => n(h).then((f) => f, () => null), l = [];
+  for (const h of r) {
+    const f = o(h), m = await c(f);
+    if (h.endsWith("/") || m != null && m.isDirectory()) {
+      const d = [];
+      for (const [y] of t) {
+        const w = i(y);
+        (u = await c(a(f, w))) != null && u.isFile() && d.push(w);
+      }
+      await e(f, { recursive: !0 }), l.push({ name: h, dir: f, existing: d });
+    } else
+      await e(s(f), { recursive: !0 }), l.push({ name: h, dir: s(f), file: i(f), existing: m ? [i(f)] : [] });
+  }
+  return l;
+}
+export {
+  N as W,
+  At as a,
+  Pt as b,
+  xt as c,
+  St as d,
+  z as e,
+  kt as f,
+  $ as g,
+  yt as h,
+  b as i,
+  R as j,
+  mt as m
+};