@wasmedia/wexiftool 0.0.0-stage → 0.1.0

package/dist/wexiftool-CL0NBE7L.js

@@ -0,0 +1,761 @@
+var H = Object.defineProperty;
+var L = (n, t, e) => t in n ? H(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var A = (n, t, e) => L(n, typeof t != "symbol" ? t + "" : t, e);
+class b extends Error {
+  constructor(t, e) {
+    super(t, e), this.name = new.target.name;
+  }
+}
+class it extends b {
+}
+class at extends b {
+  constructor(e, r) {
+    super(`${e} is locked by another sync access handle (another tab or worker may be using it)`, { cause: r });
+    A(this, "path");
+    this.path = e;
+  }
+}
+class R extends b {
+}
+class ct extends b {
+}
+class lt extends b {
+}
+class ut extends b {
+  constructor(e, r) {
+    super(`commit() failed after ${e.length} file(s): ${(r == null ? void 0 : r.message) ?? String(r)}`, { cause: r });
+    A(this, "committed");
+    this.committed = e;
+  }
+}
+const g = "/wexiftool", j = "/opt/perlwasm/bin/exiftool";
+function B(n) {
+  n.ENV && (n.ENV.LC_ALL = "C");
+}
+class C {
+  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: (i) => {
+        var s;
+        (s = this.stdoutSink) == null || s.call(this, i);
+      },
+      printErr: (i) => {
+        var s;
+        (s = this.stderrSink) == null || s.call(this, i);
+      },
+      preRun: [B]
+    }, e = this.wasmUrl ?? this.defaultWasmUrl(), r = await this.importModuleFactory(e);
+    this.createModule = r;
+    const o = e.substring(0, e.lastIndexOf("/") + 1);
+    if (this.onWasmProgress && typeof fetch < "u") {
+      const i = await this.fetchWithProgress(o + "perl.wasm");
+      return await r({
+        ...t,
+        locateFile: (s) => o + s,
+        wasmBinary: i
+      });
+    }
+    return await r({
+      ...t,
+      locateFile: (i) => o + i
+    });
+  }
+  async fetchWithProgress(t) {
+    const e = await fetch(t);
+    if (!e.ok)
+      throw new Error(`Failed to fetch ${t}: ${e.status} ${e.statusText}`);
+    const r = e.headers.get("content-length"), o = r ? parseInt(r, 10) : null, i = e.body.getReader(), s = [];
+    let c = 0;
+    for (; ; ) {
+      const { done: d, value: u } = await i.read();
+      if (d) break;
+      s.push(u), c += u.byteLength, this.onWasmProgress(c, o);
+    }
+    const a = new Uint8Array(c);
+    let l = 0;
+    for (const d of s)
+      a.set(d, l), l += d.byteLength;
+    return a;
+  }
+  async importModuleFactory(t) {
+    var i;
+    if (typeof process < "u" && ((i = process.versions) != null && i.node)) {
+      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 r = await e.text();
+    return new Function(
+      "exports",
+      "module",
+      "define",
+      `${r}
+return createPerlModule;`
+    )(void 0, void 0, void 0);
+  }
+  defaultWasmUrl() {
+    return typeof __dirname < "u" ? require("path").join(__dirname, "..", "wasm", "perl.js") : 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 r = [...e].map(([s, c]) => ({ name: s, source: c })), { committed: o, ...i } = await this.run(t, r);
+    return i;
+  }
+  /**
+   * 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, r = {}) {
+    return await this.init(), this.enqueue(
+      () => e.some((o) => !(o.source instanceof Uint8Array)) ? this.runMounted(t, e, r) : this.runStaged(t, e)
+    );
+  }
+  runStaged(t, e) {
+    const r = this.module.FS, o = e.map((s, c) => `${g}/${c}/${v(s)}`), i = /* @__PURE__ */ new Map();
+    try {
+      e.forEach((c, a) => {
+        r.mkdir(`${g}/${a}`), r.writeFile(o[a], c.source), r.chmod(o[a], 292), i.set(o[a], F(r, o[a]));
+      });
+      const s = this.callExiftool(t, e, o);
+      return e.forEach((c, a) => {
+        if (F(r, o[a]) !== i.get(o[a]))
+          try {
+            s.files.set(c.name, r.readFile(o[a]));
+          } catch {
+          }
+      }), { ...s, committed: /* @__PURE__ */ new Map() };
+    } finally {
+      e.forEach((s, c) => M(r, `${g}/${c}`));
+    }
+  }
+  async runMounted(t, e, r) {
+    var a;
+    const { mountFiles: o } = await import("./index-D8B3sucz.js").then((l) => l.a), i = this.module, s = e.map((l, d) => `${g}/${d}/${v(l)}`), c = [];
+    try {
+      for (const [u, h] of e.entries()) {
+        const w = ((a = h.commitTo) == null ? void 0 : a.dir) ?? (r.readOnly ? void 0 : r.privateDir);
+        if (w === void 0 && !r.readOnly)
+          throw new Error(`Input "${h.name}" is mounted, so the run needs a privateDir, a commitTo or readOnly`);
+        c.push(
+          await o(i, `${g}/${u}`, {
+            inputs: { [v(h)]: h.source },
+            outputDir: w,
+            // 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: w === void 0 ? 0 : r.scratch ?? 1,
+            onExhausted: "spill",
+            backend: r.backend
+          })
+        );
+      }
+      const l = this.callExiftool(t, e, s), d = /* @__PURE__ */ new Map();
+      for (const [u, h] of e.entries()) {
+        const w = await c[u].commit(), m = w.find((f) => f.path === v(h));
+        if (h.commitTo)
+          m && d.set(h.name, m);
+        else
+          for (const f of w)
+            f === m && l.files.set(h.name, await N(f)), await q(f, r.privateDir);
+      }
+      return { ...l, committed: d };
+    } finally {
+      for (const l of c) 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, r) {
+    const o = this.module, i = new Map(e.map((u, h) => [u.name, r[h]])), s = [j];
+    for (const u of t)
+      s.push(
+        u.toLowerCase() === "-overwrite_original_in_place" ? "-overwrite_original" : i.get(u) ?? u
+      );
+    const c = new Set(t);
+    for (const u of e)
+      c.has(u.name) || s.push(i.get(u.name));
+    let a = "", l = "";
+    this.stdoutSink = (u) => {
+      a += u + `
+`;
+    }, this.stderrSink = (u) => {
+      l += u + `
+`;
+    };
+    let d;
+    try {
+      d = o.callMain(s);
+    } catch (u) {
+      if (u.status !== void 0)
+        d = u.status;
+      else
+        throw u;
+    } finally {
+      this.stdoutSink = null, this.stderrSink = null;
+    }
+    for (const [u, h] of i)
+      a = a.replaceAll(h, u), l = l.replaceAll(h, u);
+    return e.forEach((u, h) => {
+      const w = new RegExp(`${g}/${h}(?![0-9])`, "g"), m = u.name.lastIndexOf("/"), f = m > 0 ? u.name.slice(0, m) : m === 0 ? "/" : ".";
+      a = a.replace(w, () => f), l = l.replace(w, () => f);
+    }), { stdout: a.trimEnd(), stderr: l.trimEnd(), exitCode: d, 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();
+  }
+}
+function v(n) {
+  var e;
+  const t = (((e = n.commitTo) == null ? void 0 : e.as) ?? n.name).split("/").pop();
+  return t && t !== "." && t !== ".." ? t : "input.bin";
+}
+function F(n, t) {
+  try {
+    const e = n.stat(t);
+    return `${e.ino}:${e.size}:${+e.mtime}`;
+  } catch {
+    return "missing";
+  }
+}
+function M(n, t) {
+  let e;
+  try {
+    e = n.readdir(t);
+  } catch {
+    return;
+  }
+  for (const r of e) {
+    if (r === "." || r === "..") continue;
+    const o = `${t}/${r}`;
+    try {
+      n.unlink(o);
+    } catch {
+      M(n, o);
+    }
+  }
+  try {
+    n.rmdir(t);
+  } catch {
+  }
+}
+async function N(n) {
+  if (n.handle) return new Uint8Array(await (await n.handle.getFile()).arrayBuffer());
+  if (n.hostPath) {
+    const { readFile: t } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    return new Uint8Array(await t(n.hostPath));
+  }
+  return n.bytes ?? new Uint8Array();
+}
+async function q(n, t) {
+  if (n.hostPath) {
+    const { rm: e } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    await e(n.hostPath, { force: !0 });
+    return;
+  }
+  if (typeof t != "string") {
+    const e = n.path.split("/"), r = e.pop();
+    let o = t;
+    for (const i of e) o = await o.getDirectoryHandle(i);
+    await o.removeEntry(r).catch(() => {
+    });
+  }
+}
+function p(n) {
+  return typeof n == "object" && n !== null && n.kind === "file" && typeof n.getFile == "function";
+}
+async function k(n) {
+  if (n instanceof Uint8Array)
+    return { name: "input.bin", data: n };
+  if (n instanceof ArrayBuffer)
+    return { name: "input.bin", data: new Uint8Array(n) };
+  if (p(n)) {
+    const t = await n.getFile();
+    return { name: n.name || "input.bin", data: new Uint8Array(await t.arrayBuffer()) };
+  }
+  if (typeof File < "u" && n instanceof File) {
+    const t = await n.arrayBuffer();
+    return { name: n.name || "input.bin", data: new Uint8Array(t) };
+  }
+  if (typeof Blob < "u" && n instanceof Blob) {
+    const t = await n.arrayBuffer();
+    return { name: "input.bin", data: new Uint8Array(t) };
+  }
+  throw new Error("Unsupported input type");
+}
+async function z(n, t) {
+  const e = G(t);
+  if (typeof n.createSyncAccessHandle == "function") {
+    const r = await n.createSyncAccessHandle();
+    try {
+      r.truncate(0);
+      let o = 0;
+      for (; o < e.byteLength; ) {
+        const i = o === 0 ? e : e.slice(o), s = r.write(i, { at: o });
+        if (s <= 0)
+          throw new Error(`Short write to ${n.name} at byte ${o} of ${e.byteLength}`);
+        o += s;
+      }
+      r.flush();
+    } finally {
+      r.close();
+    }
+    return;
+  }
+  if (typeof n.createWritable == "function") {
+    const r = await n.createWritable();
+    try {
+      await r.write(e), await r.close();
+    } catch (o) {
+      throw await r.abort(o).catch(() => {
+      }), o;
+    }
+    return;
+  }
+  throw new Error(
+    `Cannot write to file handle "${n.name}": it has neither createSyncAccessHandle() (dedicated workers only) nor createWritable().`
+  );
+}
+function G(n) {
+  const { buffer: t, byteOffset: e, byteLength: r } = n;
+  return t instanceof ArrayBuffer && e === 0 && r === t.byteLength ? t : n.slice().buffer;
+}
+const V = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  isFileHandle: p,
+  resolveInput: k,
+  writeToHandle: z
+}, Symbol.toStringTag, { value: "Module" })), T = ".wexiftool";
+function O() {
+  var i, s;
+  const n = globalThis, t = !!((s = (i = n.process) == null ? void 0 : i.versions) != null && s.node) && typeof n.window > "u", e = n.DedicatedWorkerGlobalScope, r = n.FileSystemFileHandle, o = !t && typeof e == "function" && globalThis instanceof e && !!(r && "createSyncAccessHandle" in r.prototype);
+  return { node: t, opfs: o };
+}
+async function P(n, t, e, r) {
+  if (typeof t == "string") {
+    if (!e.node) throw new Error(`"${t}": file paths are only supported under Node`);
+    const { resolve: i, dirname: s, basename: c } = await import(
+      /* @vite-ignore */
+      "node:path"
+    ), a = i(t);
+    if (r === void 0) return { input: { name: n, source: a } };
+    if (typeof r != "string") return { input: { name: n, source: a }, writeAfter: r };
+    const l = i(r);
+    return { input: { name: n, source: a, commitTo: { dir: s(l), as: c(l) } } };
+  }
+  if (p(t) && e.opfs && await U(t)) {
+    const i = t;
+    if (r === void 0) return { input: { name: n, source: i } };
+    const s = p(r) ? await Y(r) : null;
+    return s ? { input: { name: n, source: i, commitTo: { dir: s, as: r.name } } } : { input: { name: n, source: i }, writeAfter: r };
+  }
+  const { data: o } = await k(t);
+  return { input: { name: n, source: o }, writeAfter: r };
+}
+const S = /* @__PURE__ */ new WeakMap();
+async function J(n, t) {
+  try {
+    const e = await X(t);
+    e && await e.isSameEntry(n) && S.set(n, t);
+  } catch {
+  }
+}
+async function K(n) {
+  return (await navigator.storage.getDirectory()).resolve(n);
+}
+async function X(n) {
+  if (n.length === 0) return null;
+  let t = await navigator.storage.getDirectory();
+  for (const e of n.slice(0, -1)) t = await t.getDirectoryHandle(e);
+  return t.getFileHandle(n[n.length - 1]);
+}
+const Q = 5e3;
+async function U(n) {
+  const t = S.get(n);
+  if (t) return t;
+  const r = [[await navigator.storage.getDirectory(), []]];
+  let o = 0;
+  for (; r.length > 0; ) {
+    const [i, s] = r.shift();
+    for await (const [c, a] of i.entries()) {
+      if (++o > Q) return null;
+      if (a.kind === "file") {
+        if (c === n.name && await a.isSameEntry(n)) {
+          const l = [...s, c];
+          return S.set(n, l), l;
+        }
+      } else s.length === 0 && c === T || r.push([a, [...s, c]]);
+    }
+  }
+  return null;
+}
+async function Y(n) {
+  const t = await U(n);
+  if (!t) return null;
+  let e = await navigator.storage.getDirectory();
+  for (const r of t.slice(0, -1)) e = await e.getDirectoryHandle(r);
+  return e;
+}
+async function _(n, t) {
+  const e = globalThis.crypto.randomUUID().slice(0, 8);
+  if (n.node) {
+    const { mkdtemp: s, rm: c } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    ), { tmpdir: a } = await import(
+      /* @vite-ignore */
+      "node:os"
+    ), { join: l } = await import(
+      /* @vite-ignore */
+      "node:path"
+    ), d = await s(l(a(), `wexiftool-${e}-`));
+    try {
+      return await t(d);
+    } finally {
+      await c(d, { recursive: !0, force: !0 });
+    }
+  }
+  const o = await (await navigator.storage.getDirectory()).getDirectoryHandle(T, { create: !0 }), i = await o.getDirectoryHandle(e, { create: !0 });
+  try {
+    return await t(i);
+  } finally {
+    await o.removeEntry(e, { recursive: !0 }).catch(() => {
+    });
+  }
+}
+async function W(n, t) {
+  if (typeof n == "string") {
+    const { writeFile: r } = await import(
+      /* @vite-ignore */
+      "node:fs/promises"
+    );
+    await r(n, t);
+    return;
+  }
+  const { writeToHandle: e } = await Promise.resolve().then(() => V);
+  await e(n, t);
+}
+const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  detectEnvironment: O,
+  planInput: P,
+  registerHint: J,
+  resolveOnCallerSide: K,
+  withPrivateDir: _,
+  writeRef: W
+}, Symbol.toStringTag, { value: "Module" }));
+function tt(n) {
+  const t = n, 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(p);
+}
+class D {
+  constructor(t, e) {
+    this.port = t, this.onWasmProgress = e, this.nextId = 1, this.pending = /* @__PURE__ */ new Map(), this.destroyed = !1, t.addEventListener("message", (r) => this.receive(r.data)), t.addEventListener("error", (r) => this.failAll(rt(r, "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 r = new D(t, e == null ? void 0 : e.onWasmProgress);
+    return await r.call({
+      op: "init",
+      options: { wasmUrl: e == null ? void 0 : e.wasmUrl, progress: !!(e != null && e.onWasmProgress) }
+    }), r;
+  }
+  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, r) {
+    return this.call({ op: "write", input: t, tags: e, options: r });
+  }
+  exec(t, e, r) {
+    return this.call({ op: "exec", args: t, files: e, options: r });
+  }
+  /**
+   * 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++, r = await et(t);
+    if (this.destroyed && t.op !== "destroy") throw new Error("WExifToolWorker was destroyed");
+    return new Promise((o, i) => {
+      this.pending.set(e, { resolve: o, reject: i });
+      try {
+        this.port.postMessage({ ...t, id: e, hints: r });
+      } catch (s) {
+        this.pending.delete(e), i(s instanceof Error ? s : new Error(String(s)));
+      }
+    });
+  }
+  receive(t) {
+    var r;
+    if (t.kind === "progress") {
+      (r = this.onWasmProgress) == null || r.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 r of this.pending.values()) r.reject(e);
+    this.pending.clear();
+  }
+}
+async function et(n) {
+  var o, i;
+  const t = globalThis;
+  if (typeof t.window > "u" || typeof ((i = (o = t.navigator) == null ? void 0 : o.storage) == null ? void 0 : i.getDirectory) != "function") return;
+  const e = tt(n);
+  if (e.length === 0) return;
+  const { resolveOnCallerSide: r } = await Promise.resolve().then(() => Z);
+  return Promise.all(e.map((s) => r(s).catch(() => null)));
+}
+function rt(n, t) {
+  const e = n == null ? void 0 : n.message;
+  return typeof e == "string" && e ? `${t}: ${e}` : t;
+}
+class I {
+  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 C(t == null ? void 0 : t.wasmUrl, t == null ? void 0 : t.onWasmProgress);
+    return await e.init(), new I(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 = x(t), r = await this.runFiles(["-json", "-G", e], [[e, t]], { readOnly: !0 });
+    if (r.exitCode !== 0 && r.stderr)
+      throw new Error(`ExifTool error: ${r.stderr}`);
+    try {
+      const o = JSON.parse(r.stdout);
+      return Array.isArray(o) ? o[0] : o;
+    } catch {
+      throw new Error(`Failed to parse ExifTool output: ${r.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 = nt(t.map(x)), r = await this.runFiles(
+      ["-json", "-G", ...e],
+      t.map((i, s) => [e[s], i]),
+      { readOnly: !0 }
+    );
+    let o;
+    try {
+      o = JSON.parse(r.stdout);
+    } catch {
+      throw new Error(`ExifTool error: ${r.stderr || `unparseable output: ${r.stdout}`}`);
+    }
+    if (!Array.isArray(o) || o.length !== t.length)
+      throw new Error(`ExifTool error: ${r.stderr || `expected ${t.length} results`}`);
+    return o;
+  }
+  async write(t, e, r) {
+    const o = x(t), i = Object.entries(e).map(([l, d]) => `-${l}=${d}`), s = typeof t == "string" || p(t), c = s ? (r == null ? void 0 : r.output) ?? t : void 0, a = await this.runFiles(
+      ["-overwrite_original", ...i, o],
+      [[o, t]],
+      { targets: c === void 0 ? void 0 : /* @__PURE__ */ new Map([[o, c]]) }
+    );
+    if (a.exitCode !== 0 && a.stderr)
+      throw new Error(`ExifTool error: ${a.stderr}`);
+    return s ? (!a.written.includes(o) && c !== t && await W(c, (await k(t)).data), c) : a.files.get(o) ?? (await k(t)).data;
+  }
+  /**
+   * Run exiftool with arbitrary flags and return raw stdout.
+   */
+  async readRaw(t, e) {
+    const r = x(t), o = await this.runFiles([...e, r], [[r, 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, r) {
+    const o = [...e ?? []], i = r != null && r.writeBack ? new Map(
+      o.filter(([, s]) => typeof s == "string" || p(s))
+    ) : void 0;
+    return this.runFiles(t, o, { targets: i });
+  }
+  /**
+   * Plan every input (mount or copy), run, and write back results the
+   * mounts couldn't commit in place.
+   */
+  async runFiles(t, e, r) {
+    const o = O();
+    try {
+      return await this.runPlanned(t, e, r, o);
+    } catch (i) {
+      if (o.opfs && i instanceof R)
+        return this.runPlanned(t, e, r, { ...o, opfs: !1 });
+      throw i;
+    }
+  }
+  async runPlanned(t, e, { targets: r, scratch: o, readOnly: i }, s) {
+    var m;
+    const c = [], a = [];
+    for (const [f, y] of e) {
+      let E = await P(f, y, s, r == null ? void 0 : r.get(f));
+      const $ = E.input.source;
+      typeof $ == "object" && !($ instanceof Uint8Array) && (await ot($, a) ? E = await P(f, y, { ...s, opfs: !1 }, r == null ? void 0 : r.get(f)) : a.push($)), c.push(E);
+    }
+    const l = c.map((f) => f.input);
+    let d;
+    if (l.every((f) => f.source instanceof Uint8Array))
+      d = await this.glue.exec(t, new Map(l.map((f) => [f.name, f.source])));
+    else {
+      const f = s.node ? "node" : "opfs";
+      d = !i && l.some((y) => !y.commitTo) ? await _(s, (y) => this.glue.run(t, l, { privateDir: y, backend: f, scratch: o })) : await this.glue.run(t, l, { backend: f, scratch: o, readOnly: i });
+    }
+    const u = [...((m = d.committed) == null ? void 0 : m.keys()) ?? []];
+    for (const { input: f, writeAfter: y } of c) {
+      const E = d.files.get(f.name);
+      y && E && (await W(y, E), d.files.delete(f.name), u.push(f.name));
+    }
+    const { committed: h, ...w } = d;
+    return { ...w, written: u };
+  }
+  /**
+   * Free WASM module resources.
+   */
+  destroy() {
+    this.glue.destroy();
+  }
+}
+function x(n) {
+  return typeof n == "string" ? n : (p(n) || typeof File < "u" && n instanceof File) && n.name || "input.bin";
+}
+function nt(n) {
+  const t = new Set(n), e = /* @__PURE__ */ new Map();
+  return n.map((r) => {
+    const o = (e.get(r) ?? 0) + 1;
+    if (e.set(r, o), o === 1) return r;
+    const i = r.lastIndexOf("/"), s = r.lastIndexOf("."), c = s > i + 1 ? s : r.length;
+    let a = o, l = `${r.slice(0, c)} (${a})${r.slice(c)}`;
+    for (; t.has(l); ) l = `${r.slice(0, c)} (${++a})${r.slice(c)}`;
+    return t.add(l), l;
+  });
+}
+async function ot(n, t) {
+  for (const e of t)
+    if (e === n || await e.isSameEntry(n)) return !0;
+  return !1;
+}
+export {
+  I as W,
+  it as a,
+  lt as b,
+  ct as c,
+  ut as d,
+  R as e,
+  at as f,
+  b as g,
+  tt as h,
+  p as i,
+  D as j,
+  Z as m
+};