@wasmedia/wexiftool 0.0.0-stage → 0.1.1

package/dist/index-BUUKaFua.js

@@ -0,0 +1,681 @@
+var V = Object.defineProperty;
+var Y = (e, t, n) => t in e ? V(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var O = (e, t, n) => Y(e, typeof t != "symbol" ? t + "" : t, n);
+import { a as b, b as $, c as z, d as H, e as D, f as I, g as L } from "./wexiftool-CUKoJisL.js";
+function q(e) {
+  if (!e.startsWith("/") || e === "/" || e.endsWith("/"))
+    throw new b(`mountpoint must be an absolute path other than "/", without a trailing slash: ${e}`);
+}
+function K(e) {
+  if (e.split("/").some((n) => n === "" || n === "." || n === ".."))
+    throw new b(`input path must be relative and normalized: ${JSON.stringify(e)}`);
+}
+function T(e, t) {
+  const n = e.analyzePath(t);
+  if (n.exists) {
+    if (!n.object || !e.isDir(n.object.mode))
+      throw new b(`${t} exists and is not a directory`);
+    return [];
+  }
+  const s = t.split("/").slice(1), a = s.map((l, f) => "/" + s.slice(0, f + 1).join("/")).filter((l) => !e.analyzePath(l).exists);
+  return e.mkdirTree(t), a;
+}
+function M(e, t) {
+  for (const n of [...t].reverse())
+    e.rmdir(n);
+}
+function A(e, t) {
+  for (const n of e.streams)
+    if (n && n.node.mount === t)
+      try {
+        e.close(n);
+      } catch {
+      }
+}
+function U(e, t) {
+  return (t == null ? void 0 : t.name) === "ErrnoError" ? new b(`cannot mount at ${e} (errno ${t.errno}); is it already a mount point?`, { cause: t }) : t;
+}
+function _(e, t, n, s) {
+  A(e, n);
+  const a = s[0] ?? t, l = e.cwd();
+  (l === a || l.startsWith(`${a}/`)) && e.chdir(a.slice(0, a.lastIndexOf("/")) || "/");
+  try {
+    e.unmount(t);
+  } catch (f) {
+    const h = f == null ? void 0 : f.errno;
+    throw new $(`cannot unmount ${t} (errno ${h}); release() can be retried`, { cause: f });
+  }
+  M(e, s);
+}
+function x() {
+  var s, a;
+  const e = globalThis;
+  if ((a = (s = e.process) == null ? void 0 : s.versions) != null && a.node && typeof e.window > "u")
+    return "node";
+  const t = e.DedicatedWorkerGlobalScope, n = e.FileSystemFileHandle;
+  return typeof t == "function" && globalThis instanceof t && n && "createSyncAccessHandle" in n.prototype ? "opfs" : "memfs";
+}
+const Q = [
+  "ErrnoError",
+  "createNode",
+  "hashRemoveNode",
+  "isDir",
+  "isFile",
+  "mount",
+  "unmount",
+  "lookupPath",
+  "analyzePath",
+  "mkdirTree",
+  "rmdir",
+  "readdir",
+  "writeFile",
+  "readFile",
+  "chmod",
+  "close",
+  "cwd",
+  "chdir"
+];
+function G(e) {
+  var s;
+  const t = e == null ? void 0 : e.FS;
+  if (!t)
+    throw new z("module has no FS export; build it with -sEXPORTED_RUNTIME_METHODS=FS");
+  const n = Q.filter((a) => typeof t[a] != "function");
+  if (Array.isArray(t.streams) || n.push("streams"), (s = t.filesystems) != null && s.MEMFS || n.push("filesystems.MEMFS"), n.length)
+    throw new z(`module.FS is missing ${n.join(", ")}: this Emscripten's FS internals differ from the ones wopfs supports (emsdk 5.0.5, 5.0.6)`);
+}
+const E = {
+  EACCES: 2,
+  EINVAL: 28,
+  EIO: 29,
+  ENODEV: 43,
+  ENOENT: 44,
+  ENOSPC: 51,
+  ENOTEMPTY: 55,
+  EPERM: 63,
+  EROFS: 69
+}, X = 0, Z = 1, tt = 2, et = 61440, R = 16384, nt = 32768, C = R | 511, st = nt | 292, g = (e) => (e.mode & et) === R;
+function rt(e) {
+  const t = e._malloc;
+  return typeof t != "function" || !e.HEAPU8 ? () => null : (n) => {
+    const s = t(n);
+    return s ? { ptr: s, heap: e.HEAPU8, free: () => {
+      var a;
+      return (a = e._free) == null ? void 0 : a.call(e, s);
+    } } : null;
+  };
+}
+function ot(e, t) {
+  const n = (r) => new e.ErrnoError(r);
+  function s(r) {
+    try {
+      return r();
+    } catch (o) {
+      const { name: i, code: c } = o ?? {};
+      throw i === "ErrnoError" ? o : n(i === "QuotaExceededError" || c === "ENOSPC" || c === "EDQUOT" ? E.ENOSPC : E.EIO);
+    }
+  }
+  const a = (r) => r.wopfs;
+  function l(r, o, i, c) {
+    const u = e.createNode(r, o, i, 0);
+    return u.node_ops = y, u.stream_ops = d, u.atime = u.mtime = u.ctime = Date.now(), g(u) ? u.contents = /* @__PURE__ */ Object.create(null) : u.wopfs = c, r && (r.contents[o] = u, r.mtime = r.ctime = u.mtime), u;
+  }
+  function f(r) {
+    const o = r.wopfs;
+    !o || o.input || (o.unlinked = !0, o.openCount === 0 && t.discardFile(o.file));
+  }
+  function h(r) {
+    const o = a(r);
+    if (o.input)
+      throw n(E.EACCES);
+    return o;
+  }
+  const w = (r) => {
+    r.mtime = r.ctime = Date.now();
+  }, y = {
+    getattr(r) {
+      const o = g(r) ? 4096 : a(r).size;
+      return {
+        dev: 1,
+        ino: r.id,
+        mode: r.mode,
+        nlink: 1,
+        uid: 0,
+        gid: 0,
+        rdev: 0,
+        size: o,
+        atime: new Date(r.atime),
+        mtime: new Date(r.mtime),
+        ctime: new Date(r.ctime),
+        blksize: 4096,
+        blocks: Math.ceil(o / 4096)
+      };
+    },
+    setattr(r, o) {
+      for (const i of ["mode", "atime", "mtime", "ctime"])
+        o[i] != null && (r[i] = o[i]);
+      if (o.size !== void 0) {
+        const i = h(r), c = o.size;
+        s(() => i.file.truncate(c)), i.size = c, w(r);
+      }
+    },
+    lookup(r, o) {
+      const i = r.contents[o];
+      if (i)
+        return i;
+      throw n(E.ENOENT);
+    },
+    mknod(r, o, i) {
+      if (t.readOnly)
+        throw n(E.EROFS);
+      if (e.isDir(i))
+        return l(r, o, i);
+      if (!e.isFile(i))
+        throw n(E.EPERM);
+      const c = s(() => t.createFile());
+      if (!c)
+        throw n(E.ENOSPC);
+      return l(r, o, i, { file: c, size: 0, input: !1, openCount: 0, unlinked: !1 });
+    },
+    rename(r, o, i) {
+      const c = o.contents[i];
+      if (c) {
+        if (g(c) && Object.keys(c.contents).length)
+          throw n(E.ENOTEMPTY);
+        e.hashRemoveNode(c), f(c);
+      }
+      delete r.parent.contents[r.name], o.contents[i] = r, r.name = i, w(o), w(r.parent);
+    },
+    unlink(r, o) {
+      const i = r.contents[o];
+      delete r.contents[o], w(r), f(i);
+    },
+    rmdir(r, o) {
+      const i = r.contents[o];
+      if (Object.keys(i.contents).length)
+        throw n(E.ENOTEMPTY);
+      delete r.contents[o], w(r);
+    },
+    readdir(r) {
+      return [".", "..", ...Object.keys(r.contents)];
+    },
+    symlink() {
+      throw n(E.EPERM);
+    }
+  }, d = {
+    open(r) {
+      if (g(r.node))
+        return;
+      const o = (r.flags & 3) === X ? a(r.node) : h(r.node);
+      o.openCount++;
+    },
+    dup(r) {
+      g(r.node) || a(r.node).openCount++;
+    },
+    close(r) {
+      if (g(r.node))
+        return;
+      const o = a(r.node);
+      o.openCount--, o.unlinked ? o.openCount === 0 && t.discardFile(o.file) : o.input || s(() => o.file.flush());
+    },
+    read(r, o, i, c, u) {
+      const p = a(r.node);
+      if (u >= p.size)
+        return 0;
+      const m = Math.min(c, p.size - u);
+      return s(() => p.file.read(new Uint8Array(o.buffer, o.byteOffset + i, m), u));
+    },
+    write(r, o, i, c, u) {
+      if (!c)
+        return 0;
+      const p = h(r.node), m = s(() => p.file.write(new Uint8Array(o.buffer, o.byteOffset + i, c), u));
+      return p.size = Math.max(p.size, u + m), w(r.node), m;
+    },
+    llseek(r, o, i) {
+      let c = o;
+      if (i === Z ? c += r.position : i === tt && !g(r.node) && (c += a(r.node).size), c < 0)
+        throw n(E.EINVAL);
+      return c;
+    },
+    /** Served by copying into the heap: a memory cost, documented in the README. */
+    mmap(r, o, i) {
+      if (g(r.node))
+        throw n(E.ENODEV);
+      const c = t.mmapAlloc(o);
+      if (!c)
+        throw n(E.ENODEV);
+      const u = c.heap.subarray(c.ptr, c.ptr + o), p = a(r.node), m = i < p.size ? Math.min(o, p.size - i) : 0;
+      if (m)
+        try {
+          s(() => p.file.read(u.subarray(0, m), i));
+        } catch (k) {
+          throw c.free(), k;
+        }
+      return u.fill(0, m), { ptr: c.ptr, allocated: !0 };
+    },
+    msync(r, o, i, c) {
+      return d.write(r, o, 0, c, i), 0;
+    },
+    fsync(r) {
+      return g(r.node) || s(() => a(r.node).file.flush()), 0;
+    }
+  };
+  return {
+    mount(r) {
+      const o = l(null, "/", C);
+      o.mount = r;
+      for (const { path: i, file: c } of r.opts.inputs ?? []) {
+        const u = i.split("/");
+        let p = o;
+        for (const m of u.slice(0, -1))
+          p = p.contents[m] ?? l(p, m, C);
+        l(p, u[u.length - 1], st, {
+          file: c,
+          size: c.getSize(),
+          input: !0,
+          openCount: 0,
+          unlinked: !1
+        });
+      }
+      return o;
+    },
+    node_ops: y,
+    stream_ops: d
+  };
+}
+function it(e) {
+  const t = [], n = (s, a) => {
+    for (const [l, f] of Object.entries(s.contents)) {
+      const h = a ? `${a}/${l}` : l;
+      g(f) ? n(f, h) : f.wopfs && !f.wopfs.input && t.push({ path: h, backing: f.wopfs });
+    }
+  };
+  return n(e, ""), t.sort((s, a) => s.path < a.path ? -1 : s.path > a.path ? 1 : 0);
+}
+class j {
+  constructor(t) {
+    O(this, "data");
+    O(this, "size");
+    this.data = t ?? new Uint8Array(0), this.size = this.data.length;
+  }
+  read(t, n) {
+    const s = Math.max(0, Math.min(t.length, this.size - n));
+    return t.set(this.data.subarray(n, n + s)), s;
+  }
+  write(t, n) {
+    const s = n + t.length;
+    return this.reserve(s), n > this.size && this.data.fill(0, this.size, n), this.data.set(t, n), this.size = Math.max(this.size, s), t.length;
+  }
+  truncate(t) {
+    t > this.size && (this.reserve(t), this.data.fill(0, this.size, t)), this.size = t;
+  }
+  getSize() {
+    return this.size;
+  }
+  flush() {
+  }
+  close() {
+  }
+  bytes() {
+    return this.data.subarray(0, this.size);
+  }
+  reserve(t) {
+    if (t <= this.data.length)
+      return;
+    const n = new Uint8Array(Math.max(t, this.data.length * 2, 4096));
+    n.set(this.data.subarray(0, this.size)), this.data = n;
+  }
+}
+function at(e) {
+  let t = !1;
+  return {
+    read: (n, s) => e.read(n, { at: s }),
+    write: (n, s) => e.write(n, { at: s }),
+    truncate: (n) => e.truncate(n),
+    getSize: () => e.getSize(),
+    flush: () => e.flush(),
+    close: () => {
+      t || (t = !0, e.close());
+    }
+  };
+}
+const ct = 1 << 20;
+function lt(e, t, n) {
+  const s = new Uint8Array(Math.min(ct, Math.max(n, 1)));
+  t.truncate(0);
+  for (let a = 0; a < n; ) {
+    const l = e.read(s.subarray(0, Math.min(s.length, n - a)), a);
+    if (l <= 0)
+      break;
+    t.write(s.subarray(0, l), a), a += l;
+  }
+}
+class W {
+  constructor(t) {
+    O(this, "options");
+    O(this, "slots");
+    O(this, "free");
+    O(this, "byFile", /* @__PURE__ */ new Map());
+    O(this, "warned", !1);
+    this.options = t, this.slots = [...t.preopened ?? []], this.free = [...this.slots].reverse();
+    for (const n of this.slots)
+      this.byFile.set(n.file, n);
+  }
+  acquire() {
+    let t = this.free.pop();
+    return !t && this.options.open && this.slots.length < this.options.capacity && (t = this.options.open(this.slots.length), this.slots.push(t), this.byFile.set(t.file, t)), t ? t.file : this.options.onExhausted === "strict" ? null : (this.warned || (this.warned = !0, this.options.warn(`wopfs: scratch pool of ${this.options.capacity} exhausted; holding further new files in memory until commit()`)), new j());
+  }
+  /** The file is unreachable and closed. A spilled file is simply dropped. */
+  discard(t) {
+    const n = this.byFile.get(t);
+    if (n) {
+      try {
+        t.truncate(0);
+      } catch {
+        return;
+      }
+      this.free.push(n);
+    }
+  }
+  slotOf(t) {
+    return this.byFile.get(t);
+  }
+}
+function ft(e, t, n) {
+  const s = e.FS, a = T(s, t), l = ot(s, {
+    createFile: () => n.pool.acquire(),
+    discardFile: (w) => n.pool.discard(w),
+    mmapAlloc: rt(e),
+    readOnly: n.readOnly
+  });
+  let f;
+  try {
+    f = s.mount(l, { inputs: n.inputs }, t);
+  } catch (w) {
+    throw M(s, a), U(t, w);
+  }
+  let h = "mounted";
+  return {
+    backend: n.kind,
+    mountpoint: t,
+    async commit() {
+      if (h !== "mounted")
+        throw new $(`commit() on a mount that is ${h}`);
+      h = "committing", A(s, f.mount);
+      for (const { file: y } of n.inputs)
+        y.close();
+      const w = [];
+      try {
+        for (const { path: y, backing: d } of it(f))
+          w.push(await n.commitFile(y, d.file, d.size));
+      } catch (y) {
+        throw new H(w, y);
+      }
+      return h = "committed", w;
+    },
+    async release() {
+      if (h !== "released") {
+        h = "releasing";
+        try {
+          _(s, t, f.mount, a);
+        } finally {
+          await n.release();
+        }
+        h = "released";
+      }
+    }
+  };
+}
+function ut(e, t, n) {
+  return {
+    kind: e,
+    inputs: t,
+    readOnly: !0,
+    pool: new W({ capacity: 0, onExhausted: "strict", warn: () => {
+    } }),
+    async commitFile(s) {
+      throw new $(`an input-only mount (no outputDir) cannot commit ${s}`);
+    },
+    release: n
+  };
+}
+function B(e) {
+  return typeof e == "object" && e !== null && e.kind === "file" && typeof e.getFile == "function";
+}
+function ht(e) {
+  return typeof e == "object" && e !== null && e.kind === "directory" && typeof e.getFileHandle == "function";
+}
+const dt = {
+  opfs: "a FileSystemFileHandle, Uint8Array or Blob",
+  node: "a host path string, Uint8Array or Blob",
+  memfs: "a Uint8Array, Blob or FileSystemFileHandle"
+};
+async function J(e, t, n) {
+  if (e instanceof Uint8Array)
+    return e;
+  if (typeof Blob < "u" && e instanceof Blob)
+    return new Uint8Array(await e.arrayBuffer());
+  if (n === "memfs" && B(e))
+    return new Uint8Array(await (await e.getFile()).arrayBuffer());
+  throw new b(`input ${t}: the ${n} backend takes ${dt[n]}`);
+}
+function pt() {
+  return globalThis.crypto.randomUUID().slice(0, 8);
+}
+async function N(e, t) {
+  let n;
+  try {
+    n = await e.createSyncAccessHandle();
+  } catch (s) {
+    const a = s == null ? void 0 : s.name;
+    throw a === "NoModificationAllowedError" || a === "InvalidStateError" ? new I(t, s) : s;
+  }
+  if (typeof n.getSize() != "number")
+    throw await n.close(), new D("this browser's FileSystemSyncAccessHandle methods are asynchronous; wopfs needs the synchronous ones");
+  return at(n);
+}
+async function wt(e, t, n) {
+  try {
+    await e.move(t, n);
+  } catch (s) {
+    if ((s == null ? void 0 : s.name) !== "InvalidModificationError")
+      throw s;
+    await t.removeEntry(n), await e.move(t, n);
+  }
+}
+async function mt(e, t, n, s, a) {
+  const l = await N(t, n);
+  try {
+    lt(e, l, s), l.flush();
+  } catch (f) {
+    throw l.close(), await a().catch(() => {
+    }), f;
+  }
+  l.close();
+}
+async function yt(e) {
+  const t = e.outputDir;
+  if (t !== void 0 && !ht(t))
+    throw new b("the opfs backend needs outputDir to be a FileSystemDirectoryHandle");
+  if (t === void 0 && e.scratch > 0)
+    throw new b(`scratch (${e.scratch}) needs outputDir: without it the mount is input-only`);
+  const n = [], s = `.wopfs-scratch-${pt()}`;
+  let a, l = 0;
+  const f = async () => {
+    for (const h of n)
+      try {
+        h.close();
+      } catch {
+      }
+    a && await t.removeEntry(s, { recursive: !0 }).catch(() => {
+    });
+  };
+  try {
+    const h = [], w = [];
+    for (const [o, i] of e.inputs)
+      if (B(i)) {
+        for (const [u, p] of w)
+          if (await p.isSameEntry(i))
+            throw new b(`inputs ${JSON.stringify(u)} and ${JSON.stringify(o)} are the same file`);
+        w.push([o, i]);
+        const c = await N(i, o);
+        n.push(c), h.push({ path: o, file: c });
+      } else
+        h.push({ path: o, file: new j(await J(i, o, "opfs")) });
+    if (t === void 0)
+      return ut("opfs", h, f);
+    if (a = await t.getDirectoryHandle(s, { create: !0 }), typeof (await a.getFileHandle("probe", { create: !0 })).move != "function")
+      throw new D("this browser's FileSystemFileHandle has no move(); wopfs needs it to commit outputs safely");
+    const d = [];
+    for (let o = 0; o < e.scratch; o++) {
+      const i = `s${o}`, c = await a.getFileHandle(i, { create: !0 }), u = await N(c, `${s}/${i}`);
+      n.push(u), d.push({ name: i, file: u, handle: c });
+    }
+    const r = new W({ capacity: e.scratch, onExhausted: e.onExhausted, preopened: d, warn: e.warn });
+    return {
+      kind: "opfs",
+      inputs: h,
+      pool: r,
+      async commitFile(o, i, c) {
+        const u = o.split("/"), p = u.pop();
+        let m = t;
+        for (const F of u)
+          m = await m.getDirectoryHandle(F, { create: !0 });
+        const k = r.slotOf(i);
+        let S;
+        if (k)
+          i.flush(), i.close(), S = k.handle;
+        else {
+          const F = `spill${l++}`;
+          S = await a.getFileHandle(F, { create: !0 }), await mt(i, S, `${s}/${F}`, c, () => a.removeEntry(F)), i.close();
+        }
+        return await wt(S, m, p), { path: o, size: c, handle: S };
+      },
+      release: f
+    };
+  } catch (h) {
+    throw await f(), h;
+  }
+}
+async function P(e, t, n) {
+  const s = e.FS, a = [];
+  for (const [d, r] of n.inputs)
+    a.push([d, await J(r, d, "memfs")]);
+  const l = T(s, t);
+  let f;
+  try {
+    f = s.mount(s.filesystems.MEMFS, {}, t);
+  } catch (d) {
+    throw M(s, l), U(t, d);
+  }
+  const h = /* @__PURE__ */ new Set();
+  try {
+    for (const [d, r] of a) {
+      const o = `${t}/${d}`;
+      s.mkdirTree(o.slice(0, o.lastIndexOf("/"))), s.writeFile(o, r), s.chmod(o, 292), h.add(s.lookupPath(o).node);
+    }
+  } catch (d) {
+    throw s.unmount(t), M(s, l), d;
+  }
+  const w = (d, r, o) => {
+    for (const i of s.readdir(d)) {
+      if (i === "." || i === "..")
+        continue;
+      const c = `${d}/${i}`, u = r ? `${r}/${i}` : i, p = s.lookupPath(c).node;
+      if (s.isDir(p.mode))
+        w(c, u, o);
+      else if (s.isFile(p.mode) && !h.has(p)) {
+        const m = s.readFile(c);
+        o.push({ path: u, size: m.length, bytes: m });
+      }
+    }
+  };
+  let y = "mounted";
+  return {
+    backend: "memfs",
+    mountpoint: t,
+    async commit() {
+      if (y !== "mounted")
+        throw new $(`commit() on a mount that is ${y}`);
+      A(s, f.mount);
+      const d = [];
+      return w(t, "", d), y = "committed", d.sort((r, o) => r.path < o.path ? -1 : r.path > o.path ? 1 : 0);
+    },
+    async release() {
+      y !== "released" && (y = "releasing", _(s, t, f.mount, l), y = "released");
+    }
+  };
+}
+function Et(e) {
+  const t = Object.entries(e.inputs ?? {});
+  for (const [l] of t)
+    K(l);
+  const n = new Set(t.map(([l]) => l));
+  for (const [l] of t) {
+    const f = l.split("/");
+    for (let h = 1; h < f.length; h++) {
+      const w = f.slice(0, h).join("/");
+      if (n.has(w))
+        throw new b(`input ${JSON.stringify(w)} is a file, but ${JSON.stringify(l)} needs it to be a directory`);
+    }
+  }
+  const s = e.scratch ?? (e.outputDir === void 0 ? 0 : 16);
+  if (!Number.isInteger(s) || s < 0)
+    throw new b(`scratch must be a non-negative integer: ${s}`);
+  const a = e.onExhausted ?? "spill";
+  if (a !== "spill" && a !== "strict")
+    throw new b(`onExhausted must be "spill" or "strict": ${a}`);
+  return {
+    inputs: t,
+    outputDir: e.outputDir,
+    scratch: s,
+    onExhausted: a,
+    warn: e.onWarning ?? ((l) => console.warn(l))
+  };
+}
+async function v(e, t, n) {
+  try {
+    return ft(e, t, n);
+  } catch (s) {
+    throw await n.release(), s;
+  }
+}
+async function bt(e, t, n = {}) {
+  G(e), q(t);
+  const s = Et(n), a = n.backend ?? "auto", l = a === "auto" ? x() : a;
+  if (l === "memfs")
+    return P(e, t, s);
+  if (l === "node") {
+    const { openNodeBackend: f } = await import("./node-WHSUCdKF.js");
+    return v(e, t, await f(s));
+  }
+  if (l !== "opfs")
+    throw new b(`unknown backend: ${String(l)}`);
+  try {
+    return await v(e, t, await yt(s));
+  } catch (f) {
+    if (a === "auto" && f instanceof D)
+      return s.warn(`wopfs: ${f.message}; falling back to memfs`), P(e, t, s);
+    throw f;
+  }
+}
+const St = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WopfsCommitError: H,
+  WopfsError: L,
+  WopfsInputError: b,
+  WopfsLockedError: I,
+  WopfsRuntimeError: z,
+  WopfsStateError: $,
+  WopfsUnsupportedError: D,
+  detectBackend: x,
+  mountFiles: bt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  j as M,
+  W as S,
+  St as a,
+  J as b,
+  ut as i,
+  pt as r
+};