opfs-worker 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -1,2 +1,1066 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const A=require("comlink");class s extends Error{constructor(e,t,n){super(e),this.code=t,this.path=n,this.name="OPFSError"}}class S extends s{constructor(){super("OPFS is not supported in this browser","OPFS_NOT_SUPPORTED")}}class y extends s{constructor(){super("OPFS is not mounted","OPFS_NOT_MOUNTED")}}class g extends s{constructor(e,t){super(e,"INVALID_PATH",t)}}class m extends s{constructor(e){super(`File not found: ${e}`,"FILE_NOT_FOUND",e)}}function D(r,e="utf-8"){switch(e){case"utf8":case"utf-8":return new TextEncoder().encode(r);case"utf16le":case"ucs2":case"ucs-2":return I(r);case"ascii":return H(r);case"latin1":return O(r);case"binary":return Uint8Array.from(r,t=>t.charCodeAt(0));case"base64":return Uint8Array.from(atob(r),t=>t.charCodeAt(0));case"hex":if(!/^[\da-f]+$/i.test(r)||r.length%2!==0)throw new s("Invalid hex string","INVALID_HEX_FORMAT");return Uint8Array.from(r.match(/.{1,2}/g).map(t=>parseInt(t,16)));default:return console.warn("Encoding not supported, falling back to UTF-8"),new TextEncoder().encode(r)}}function T(r,e="utf-8"){switch(e){case"utf8":case"utf-8":return new TextDecoder().decode(r);case"utf16le":case"ucs2":case"ucs-2":return N(r);case"latin1":return String.fromCharCode(...r);case"binary":return String.fromCharCode(...r);case"ascii":return String.fromCharCode(...r.map(t=>t&127));case"base64":return btoa(String.fromCharCode(...r));case"hex":return Array.from(r).map(t=>t.toString(16).padStart(2,"0")).join("");default:return console.warn("Unsupported encoding, falling back to UTF-8"),new TextDecoder().decode(r)}}function I(r){const e=new Uint8Array(r.length*2);for(let t=0;t<r.length;t++){const n=r.charCodeAt(t);e[t*2]=n&255,e[t*2+1]=n>>8}return e}function N(r){r.length%2!==0&&(console.warn("Invalid UTF-16LE buffer length, truncating last byte"),r=r.slice(0,r.length-1));const e=new Uint16Array(r.buffer,r.byteOffset,r.byteLength/2);return String.fromCharCode(...e)}function O(r){const e=new Uint8Array(r.length);for(let t=0;t<r.length;t++)e[t]=r.charCodeAt(t)&255;return e}function H(r){const e=new Uint8Array(r.length);for(let t=0;t<r.length;t++)e[t]=r.charCodeAt(t)&127;return e}function $(){if(!("storage"in navigator)||!("getDirectory"in navigator.storage))throw new S}function u(r){return Array.isArray(r)?r:r.split("/").filter(Boolean)}function F(r){return typeof r=="string"?r??"/":`/${r.join("/")}`}function v(r,e="utf-8"){return typeof r=="string"?D(r,e):r instanceof Uint8Array?r:new Uint8Array(r)}async function x(r){const e=await r.createSyncAccessHandle();try{const t=e.getSize(),n=new Uint8Array(t);return e.read(n,{at:0}),n}finally{e.close()}}async function E(r,e,t,n={}){let o=null;try{o=await r.createSyncAccessHandle();const i=v(e,t),a=n.append?o.getSize():0;o.write(i,{at:a}),n.truncate&&!n.append&&o.truncate(i.byteLength),o.flush()}catch(i){console.error(i);const a=n.append?"append":"write";throw new s(`Failed to ${a} file`,`${a.toUpperCase()}_FAILED`)}finally{if(o)try{o.close()}catch{}}}async function U(r,e="SHA-1"){try{const t=new Uint8Array(r),n=await crypto.subtle.digest(e,t);return Array.from(new Uint8Array(n)).map(i=>i.toString(16).padStart(2,"0")).join("")}catch(t){throw console.warn(`Failed to calculate ${e} hash:`,t),t}}class p{root=null;constructor(){$()}async mount(e="/"){try{const t=await navigator.storage.getDirectory();return this.root=await this.getDirectoryHandle(e,!0,t),!0}catch(t){throw console.error(t),new s("Failed to initialize OPFS","INIT_FAILED")}}async getDirectoryHandle(e,t=!1,n=this.root){if(!n)throw new y;const o=Array.isArray(e)?e:u(e);let i=n;for(const a of o)i=await i.getDirectoryHandle(a,{create:t});return i}async getFileHandle(e,t=!1,n=this.root){if(!n)throw new y;const o=u(e);if(o.length===0)throw new g("Path must not be empty",Array.isArray(e)?e.join("/"):e);const i=o.pop();return(await this.getDirectoryHandle(o,t,n)).getFileHandle(i,{create:t})}async index(e){const t=new Map,n=async o=>{const i=await this.readdir(o,{withFileTypes:!0});for(const a of i){const l=`${o==="/"?"":o}/${a.name}`;try{const c=await this.stat(l,e);t.set(l,c),c.isDirectory&&await n(l)}catch(c){console.warn(`Skipping broken entry: ${l}`,c)}}};return t.set("/",{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}),await n("/"),t}async readFile(e,t="utf-8"){try{const n=await this.getFileHandle(e,!1),o=await x(n);return t==="binary"?o:T(o,t)}catch(n){throw console.error(n),new m(e)}}async writeFile(e,t,n){const o=await this.getFileHandle(e,!0);await E(o,t,n,{truncate:!0})}async appendFile(e,t,n){const o=await this.getFileHandle(e,!0);await E(o,t,n,{append:!0})}async mkdir(e,t){if(!this.root)throw new y;const n=t?.recursive??!1,o=u(e);let i=this.root;for(let a=0;a<o.length;a++){const l=o[a];try{i=await i.getDirectoryHandle(l,{create:n||a===o.length-1})}catch(c){throw c.name==="NotFoundError"?new s(`Parent directory does not exist: ${F(o.slice(0,a+1))}`,"ENOENT"):c.name==="TypeMismatchError"?new s(`Path segment is not a directory: ${l}`,"ENOTDIR"):new s("Failed to create directory","MKDIR_FAILED")}}}async stat(e,t){const n=u(e),o=n.pop(),i=await this.getDirectoryHandle(n,!1),a=t?.includeHash??!1,l=t?.hashAlgorithm??"SHA-1";try{const f=await(await i.getFileHandle(o,{create:!1})).getFile(),h={kind:"file",size:f.size,mtime:new Date(f.lastModified).toISOString(),ctime:new Date(f.lastModified).toISOString(),isFile:!0,isDirectory:!1};if(a)try{const w=new Uint8Array(await f.arrayBuffer()),d=await U(w,l);h.hash=d}catch(w){console.warn(`Failed to calculate hash for ${e}:`,w)}return h}catch(c){if(c.name!=="TypeMismatchError"&&c.name!=="NotFoundError")throw new s("Failed to stat (file)","STAT_FAILED")}try{return await i.getDirectoryHandle(o,{create:!1}),{kind:"directory",size:0,mtime:new Date(0).toISOString(),ctime:new Date(0).toISOString(),isFile:!1,isDirectory:!0}}catch(c){throw c.name==="NotFoundError"?new s(`No such file or directory: ${e}`,"ENOENT"):new s("Failed to stat (directory)","STAT_FAILED")}}async readdir(e,t){const n=t?.withFileTypes??!1,o=await this.getDirectoryHandle(e,!1);if(n){const i=[];for await(const[a,l]of o.entries()){const c=l.kind==="file";i.push({name:a,kind:l.kind,isFile:c,isDirectory:!c})}return i}else{const i=[];for await(const[a]of o.entries())i.push(a);return i}}async exists(e){const t=u(e),n=t.pop();let o=null;try{o=await this.getDirectoryHandle(t,!1)}catch(i){throw(i.name==="NotFoundError"||i.name==="TypeMismatchError")&&(o=null),i}if(!o||!n)return!1;try{return await o.getFileHandle(n,{create:!1}),!0}catch(i){if(i.name!=="NotFoundError"&&i.name!=="TypeMismatchError")throw i}try{return await o.getDirectoryHandle(n,{create:!1}),!0}catch(i){if(i.name!=="NotFoundError"&&i.name!=="TypeMismatchError")throw i}return!1}async clear(e="/"){try{const t=await this.readdir(e,{withFileTypes:!0});for(const n of t){const o=`${e==="/"?"":e}/${n.name}`;await this.remove(o,{recursive:!0})}}catch(t){throw t instanceof s?t:new s(`Failed to clear directory: ${e}`,"CLEAR_FAILED")}}async remove(e,t){const n=t?.recursive??!1,o=t?.force??!1,i=u(e),a=i.pop();if(!a)throw new g("Invalid path",e);const l=await this.getDirectoryHandle(i,!1);try{await l.removeEntry(a,{recursive:n})}catch(c){if(c.name==="NotFoundError"){if(!o)throw new s(`No such file or directory: ${e}`,"ENOENT")}else throw c.name==="InvalidModificationError"?new s(`Directory not empty: ${e}. Use recursive option to force removal.`,"ENOTEMPTY"):c.name==="TypeMismatchError"&&!n?new s(`Cannot remove directory without recursive option: ${e}`,"EISDIR"):new s(`Failed to remove path: ${e}`,"RM_FAILED")}}async realpath(e){try{const t=u(e),n=[];for(const a of t)if(!(a==="."||a===""))if(a===".."){if(n.length===0)throw new s("Path escapes root","EINVAL");n.length>0&&n.pop()}else n.push(a);const o=F(n);if(!await this.exists(o))throw new m(o);return o}catch(t){throw t instanceof s?t:new s(`Failed to resolve path: ${e}`,"REALPATH_FAILED")}}async rename(e,t){try{if(!await this.exists(e))throw new m(e);await this.copy(e,t,{recursive:!0}),await this.remove(e,{recursive:!0})}catch(n){throw n instanceof s?n:new s(`Failed to rename from ${e} to ${t}`,"RENAME_FAILED")}}async copy(e,t,n){try{const o=n?.recursive??!1,i=n?.force??!0;if(!await this.exists(e))throw new s(`Source does not exist: ${e}`,"ENOENT");if(await this.exists(t)&&!i)throw new s(`Destination already exists: ${t}`,"EEXIST");if((await this.stat(e)).isFile){const f=await this.readFile(e,"binary");await this.writeFile(t,f)}else{if(!o)throw new s(`Cannot copy directory without recursive option: ${e}`,"EISDIR");await this.mkdir(t,{recursive:!0});const f=await this.readdir(e,{withFileTypes:!0});for(const h of f){const w=`${e}/${h.name}`,d=`${t}/${h.name}`;await this.copy(w,d,{recursive:!0,force:i})}}}catch(o){throw o instanceof s?o:new s(`Failed to copy from ${e} to ${t}`,"CP_FAILED")}}async sync(e,t){try{(t?.cleanBefore??!1)&&await this.clear("/");for(const[o,i]of e){const a=o.startsWith("/")?o:`/${o}`;let l;if(i instanceof Blob){const c=await i.arrayBuffer();l=new Uint8Array(c)}else l=i;await this.writeFile(a,l)}}catch(n){throw n instanceof s?n:new s("Failed to sync file system","SYNC_FAILED")}}}A.expose(new p);exports.OPFSWorker=p;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("comlink"),a=`/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const k = Symbol("Comlink.proxy"), U = Symbol("Comlink.endpoint"), z = Symbol("Comlink.releaseProxy"), T = Symbol("Comlink.finalizer"), E = Symbol("Comlink.thrown"), C = (e) => typeof e == "object" && e !== null || typeof e == "function", _ = {
+  canHandle: (e) => C(e) && e[k],
+  serialize(e) {
+    const { port1: t, port2: r } = new MessageChannel();
+    return x(e, t), [r, [r]];
+  },
+  deserialize(e) {
+    return e.start(), j(e);
+  }
+}, R = {
+  canHandle: (e) => C(e) && E in e,
+  serialize({ value: e }) {
+    let t;
+    return e instanceof Error ? t = {
+      isError: !0,
+      value: {
+        message: e.message,
+        name: e.name,
+        stack: e.stack
+      }
+    } : t = { isError: !1, value: e }, [t, []];
+  },
+  deserialize(e) {
+    throw e.isError ? Object.assign(new Error(e.value.message), e.value) : e.value;
+  }
+}, M = /* @__PURE__ */ new Map([
+  ["proxy", _],
+  ["throw", R]
+]);
+function W(e, t) {
+  for (const r of e)
+    if (t === r || r === "*" || r instanceof RegExp && r.test(t))
+      return !0;
+  return !1;
+}
+function x(e, t = globalThis, r = ["*"]) {
+  t.addEventListener("message", function a(n) {
+    if (!n || !n.data)
+      return;
+    if (!W(r, n.origin)) {
+      console.warn(\`Invalid origin '\${n.origin}' for comlink proxy\`);
+      return;
+    }
+    const { id: s, type: i, path: o } = Object.assign({ path: [] }, n.data), c = (n.data.argumentList || []).map(d);
+    let f;
+    try {
+      const u = o.slice(0, -1).reduce((h, g) => h[g], e), w = o.reduce((h, g) => h[g], e);
+      switch (i) {
+        case "GET":
+          f = w;
+          break;
+        case "SET":
+          u[o.slice(-1)[0]] = d(n.data.value), f = !0;
+          break;
+        case "APPLY":
+          f = w.apply(u, c);
+          break;
+        case "CONSTRUCT":
+          {
+            const h = new w(...c);
+            f = q(h);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: h, port2: g } = new MessageChannel();
+            x(e, g), f = X(h, [h]);
+          }
+          break;
+        case "RELEASE":
+          f = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (u) {
+      f = { value: u, [E]: 0 };
+    }
+    Promise.resolve(f).catch((u) => ({ value: u, [E]: 0 })).then((u) => {
+      const [w, h] = A(u);
+      t.postMessage(Object.assign(Object.assign({}, w), { id: s }), h), i === "RELEASE" && (t.removeEventListener("message", a), v(t), T in e && typeof e[T] == "function" && e[T]());
+    }).catch((u) => {
+      const [w, h] = A({
+        value: new TypeError("Unserializable return value"),
+        [E]: 0
+      });
+      t.postMessage(Object.assign(Object.assign({}, w), { id: s }), h);
+    });
+  }), t.start && t.start();
+}
+function B(e) {
+  return e.constructor.name === "MessagePort";
+}
+function v(e) {
+  B(e) && e.close();
+}
+function j(e, t) {
+  const r = /* @__PURE__ */ new Map();
+  return e.addEventListener("message", function(n) {
+    const { data: s } = n;
+    if (!s || !s.id)
+      return;
+    const i = r.get(s.id);
+    if (i)
+      try {
+        i(s);
+      } finally {
+        r.delete(s.id);
+      }
+  }), I(e, r, [], t);
+}
+function p(e) {
+  if (e)
+    throw new Error("Proxy has been released and is not useable");
+}
+function $(e) {
+  return m(e, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    v(e);
+  });
+}
+const F = /* @__PURE__ */ new WeakMap(), S = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
+  const t = (F.get(e) || 0) - 1;
+  F.set(e, t), t === 0 && $(e);
+});
+function V(e, t) {
+  const r = (F.get(t) || 0) + 1;
+  F.set(t, r), S && S.register(e, t, e);
+}
+function G(e) {
+  S && S.unregister(e);
+}
+function I(e, t, r = [], a = function() {
+}) {
+  let n = !1;
+  const s = new Proxy(a, {
+    get(i, o) {
+      if (p(n), o === z)
+        return () => {
+          G(s), $(e), t.clear(), n = !0;
+        };
+      if (o === "then") {
+        if (r.length === 0)
+          return { then: () => s };
+        const c = m(e, t, {
+          type: "GET",
+          path: r.map((f) => f.toString())
+        }).then(d);
+        return c.then.bind(c);
+      }
+      return I(e, t, [...r, o]);
+    },
+    set(i, o, c) {
+      p(n);
+      const [f, u] = A(c);
+      return m(e, t, {
+        type: "SET",
+        path: [...r, o].map((w) => w.toString()),
+        value: f
+      }, u).then(d);
+    },
+    apply(i, o, c) {
+      p(n);
+      const f = r[r.length - 1];
+      if (f === U)
+        return m(e, t, {
+          type: "ENDPOINT"
+        }).then(d);
+      if (f === "bind")
+        return I(e, t, r.slice(0, -1));
+      const [u, w] = O(c);
+      return m(e, t, {
+        type: "APPLY",
+        path: r.map((h) => h.toString()),
+        argumentList: u
+      }, w).then(d);
+    },
+    construct(i, o) {
+      p(n);
+      const [c, f] = O(o);
+      return m(e, t, {
+        type: "CONSTRUCT",
+        path: r.map((u) => u.toString()),
+        argumentList: c
+      }, f).then(d);
+    }
+  });
+  return V(s, e), s;
+}
+function Y(e) {
+  return Array.prototype.concat.apply([], e);
+}
+function O(e) {
+  const t = e.map(A);
+  return [t.map((r) => r[0]), Y(t.map((r) => r[1]))];
+}
+const L = /* @__PURE__ */ new WeakMap();
+function X(e, t) {
+  return L.set(e, t), e;
+}
+function q(e) {
+  return Object.assign(e, { [k]: !0 });
+}
+function A(e) {
+  for (const [t, r] of M)
+    if (r.canHandle(e)) {
+      const [a, n] = r.serialize(e);
+      return [
+        {
+          type: "HANDLER",
+          name: t,
+          value: a
+        },
+        n
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: e
+    },
+    L.get(e) || []
+  ];
+}
+function d(e) {
+  switch (e.type) {
+    case "HANDLER":
+      return M.get(e.name).deserialize(e.value);
+    case "RAW":
+      return e.value;
+  }
+}
+function m(e, t, r, a) {
+  return new Promise((n) => {
+    const s = K();
+    t.set(s, n), e.start && e.start(), e.postMessage(Object.assign({ id: s }, r), a);
+  });
+}
+function K() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+class l extends Error {
+  constructor(t, r, a) {
+    super(t), this.code = r, this.path = a, this.name = "OPFSError";
+  }
+}
+class J extends l {
+  constructor() {
+    super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
+  }
+}
+class D extends l {
+  constructor() {
+    super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
+  }
+}
+class P extends l {
+  constructor(t, r) {
+    super(t, "INVALID_PATH", r);
+  }
+}
+class b extends l {
+  constructor(t) {
+    super(\`File not found: \${t}\`, "FILE_NOT_FOUND", t);
+  }
+}
+function Q(e, t = "utf-8") {
+  switch (t) {
+    case "utf8":
+    case "utf-8":
+      return new TextEncoder().encode(e);
+    case "utf16le":
+    case "ucs2":
+    case "ucs-2":
+      return ee(e);
+    case "ascii":
+      return ne(e);
+    case "latin1":
+      return re(e);
+    case "binary":
+      return Uint8Array.from(e, (r) => r.charCodeAt(0));
+    case "base64":
+      return Uint8Array.from(atob(e), (r) => r.charCodeAt(0));
+    case "hex":
+      if (!/^[\\da-f]+$/i.test(e) || e.length % 2 !== 0)
+        throw new l("Invalid hex string", "INVALID_HEX_FORMAT");
+      return Uint8Array.from(e.match(/.{1,2}/g).map((r) => parseInt(r, 16)));
+    default:
+      return console.warn("Encoding not supported, falling back to UTF-8"), new TextEncoder().encode(e);
+  }
+}
+function Z(e, t = "utf-8") {
+  switch (t) {
+    case "utf8":
+    case "utf-8":
+      return new TextDecoder().decode(e);
+    case "utf16le":
+    case "ucs2":
+    case "ucs-2":
+      return te(e);
+    case "latin1":
+      return String.fromCharCode(...e);
+    case "binary":
+      return String.fromCharCode(...e);
+    case "ascii":
+      return String.fromCharCode(...e.map((r) => r & 127));
+    case "base64":
+      return btoa(String.fromCharCode(...e));
+    case "hex":
+      return Array.from(e).map((r) => r.toString(16).padStart(2, "0")).join("");
+    default:
+      return console.warn("Unsupported encoding, falling back to UTF-8"), new TextDecoder().decode(e);
+  }
+}
+function ee(e) {
+  const t = new Uint8Array(e.length * 2);
+  for (let r = 0; r < e.length; r++) {
+    const a = e.charCodeAt(r);
+    t[r * 2] = a & 255, t[r * 2 + 1] = a >> 8;
+  }
+  return t;
+}
+function te(e) {
+  e.length % 2 !== 0 && (console.warn("Invalid UTF-16LE buffer length, truncating last byte"), e = e.slice(0, e.length - 1));
+  const t = new Uint16Array(e.buffer, e.byteOffset, e.byteLength / 2);
+  return String.fromCharCode(...t);
+}
+function re(e) {
+  const t = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    t[r] = e.charCodeAt(r) & 255;
+  return t;
+}
+function ne(e) {
+  const t = new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r++)
+    t[r] = e.charCodeAt(r) & 127;
+  return t;
+}
+function ae() {
+  if (!("storage" in navigator) || !("getDirectory" in navigator.storage))
+    throw new J();
+}
+function y(e) {
+  return Array.isArray(e) ? e : e.split("/").filter(Boolean);
+}
+function N(e) {
+  return typeof e == "string" ? e ?? "/" : \`/\${e.join("/")}\`;
+}
+function se(e, t = "utf-8") {
+  return typeof e == "string" ? Q(e, t) : e instanceof Uint8Array ? e : new Uint8Array(e);
+}
+async function ie(e) {
+  const t = await e.createSyncAccessHandle();
+  try {
+    const r = t.getSize(), a = new Uint8Array(r);
+    return t.read(a, { at: 0 }), a;
+  } finally {
+    t.close();
+  }
+}
+async function H(e, t, r, a = {}) {
+  let n = null;
+  try {
+    n = await e.createSyncAccessHandle();
+    const s = se(t, r), i = a.append ? n.getSize() : 0;
+    n.write(s, { at: i }), a.truncate && !a.append && n.truncate(s.byteLength), n.flush();
+  } catch (s) {
+    console.error(s);
+    const i = a.append ? "append" : "write";
+    throw new l(\`Failed to \${i} file\`, \`\${i.toUpperCase()}_FAILED\`);
+  } finally {
+    if (n)
+      try {
+        n.close();
+      } catch {
+      }
+  }
+}
+async function oe(e, t = "SHA-1") {
+  try {
+    const r = new Uint8Array(e), a = await crypto.subtle.digest(t, r);
+    return Array.from(new Uint8Array(a)).map((s) => s.toString(16).padStart(2, "0")).join("");
+  } catch (r) {
+    throw console.warn(\`Failed to calculate \${t} hash:\`, r), r;
+  }
+}
+class ce {
+  /** Root directory handle for the file system */
+  root = null;
+  /** Watch event callback */
+  watchCallback = null;
+  /** Map of watched paths to their last known state */
+  watchers = /* @__PURE__ */ new Map();
+  /** Interval handle for polling watched paths */
+  watchTimer = null;
+  /** Polling interval in milliseconds */
+  watchInterval = 1e3;
+  /** Flag to avoid concurrent scans */
+  scanning = !1;
+  /**
+   * Creates a new OPFSFileSystem instance
+   * 
+   * @throws {OPFSError} If OPFS is not supported in the current browser
+   */
+  constructor() {
+    ae();
+  }
+  /**
+   * Initialize the file system within a given directory
+   * 
+   * This method sets up the root directory for all subsequent operations.
+   * It must be called before any other file system operations.
+   * 
+   * @param root - The root path for the file system (default: '/')
+   * @returns Promise that resolves to true if initialization was successful
+   * @throws {OPFSError} If initialization fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * const fs = new OPFSFileSystem();
+   * const success = await fs.init('/my-app');
+   * \`\`\`
+   */
+  async mount(t = "/", r, a) {
+    try {
+      const n = await navigator.storage.getDirectory();
+      return this.root = await this.getDirectoryHandle(t, !0, n), r && (this.watchCallback = r, a?.watchInterval && (this.watchInterval = a.watchInterval)), !0;
+    } catch (n) {
+      throw console.error(n), new l("Failed to initialize OPFS", "INIT_FAILED");
+    }
+  }
+  /**
+   * Get a directory handle from a path
+   * 
+   * Navigates through the directory structure to find or create a directory
+   * at the specified path.
+   * 
+   * @param path - The path to the directory (string or array of segments)
+   * @param create - Whether to create the directory if it doesn't exist (default: false)
+   * @param from - The directory to start from (default: root directory)
+   * @returns Promise that resolves to the directory handle
+   * @throws {OPFSError} If the directory cannot be accessed or created
+   * 
+   * @example
+   * \`\`\`typescript
+   * const docsDir = await fs.getDirectoryHandle('/users/john/documents', true);
+   * const docsDir2 = await fs.getDirectoryHandle(['users', 'john', 'documents'], true);
+   * \`\`\`
+   */
+  async getDirectoryHandle(t, r = !1, a = this.root) {
+    if (!a)
+      throw new D();
+    const n = Array.isArray(t) ? t : y(t);
+    let s = a;
+    for (const i of n)
+      s = await s.getDirectoryHandle(i, { create: r });
+    return s;
+  }
+  /**
+   * Get a file handle from a path
+   * 
+   * Navigates to the parent directory and retrieves or creates a file handle
+   * for the specified file path.
+   * 
+   * @param path - The path to the file (string or array of segments)
+   * @param create - Whether to create the file if it doesn't exist (default: false)
+   * @param from - The directory to start from (default: root directory)
+   * @returns Promise that resolves to the file handle
+   * @throws {PathError} If the path is empty
+   * @throws {OPFSError} If the file cannot be accessed or created
+   * 
+   * @example
+   * \`\`\`typescript
+   * const fileHandle = await fs.getFileHandle('/config/settings.json', true);
+   * const fileHandle2 = await fs.getFileHandle(['config', 'settings.json'], true);
+   * \`\`\`
+   */
+  async getFileHandle(t, r = !1, a = this.root) {
+    if (!a)
+      throw new D();
+    const n = y(t);
+    if (n.length === 0)
+      throw new P("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+    const s = n.pop();
+    return (await this.getDirectoryHandle(n, r, a)).getFileHandle(s, { create: r });
+  }
+  /**
+   * Recursively list all files and directories with their stats
+   * 
+   * Traverses the entire file system starting from the root and returns
+   * a Map containing all paths and their corresponding file statistics.
+   * 
+   * @param options - Options for indexing
+   * @param options.includeHash - Whether to calculate file hash (default: false)
+   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
+   * @returns Promise that resolves to a Map of path => FileStat
+   * @throws {OPFSError} If the indexing operation fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Basic index without hash
+   * const index = await fs.index();
+   * 
+   * // Index with file hash
+   * const indexWithHash = await fs.index({ 
+   *   includeHash: true,
+   *   hashAlgorithm: 'SHA-1'
+   * });
+   * 
+   * // Iterate through all files and directories
+   * for (const [path, stat] of index) {
+   *   console.log(\`\${path}: \${stat.isFile ? 'file' : 'directory'} (\${stat.size} bytes)\`);
+   *   if (stat.hash) console.log(\`  Hash: \${stat.hash}\`);
+   * }
+   * 
+   * // Get specific file stats
+   * const fileStats = index.get('/data/config.json');
+   * if (fileStats) {
+   *   console.log(\`File size: \${fileStats.size} bytes\`);
+   *   if (fileStats.hash) console.log(\`Hash: \${fileStats.hash}\`);
+   * }
+   * \`\`\`
+   */
+  async index(t) {
+    const r = /* @__PURE__ */ new Map(), a = async (n) => {
+      const s = await this.readdir(n, { withFileTypes: !0 });
+      for (const i of s) {
+        const o = \`\${n === "/" ? "" : n}/\${i.name}\`;
+        try {
+          const c = await this.stat(o, t);
+          r.set(o, c), c.isDirectory && await a(o);
+        } catch (c) {
+          console.warn(\`Skipping broken entry: \${o}\`, c);
+        }
+      }
+    };
+    return r.set("/", {
+      kind: "directory",
+      size: 0,
+      mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
+      isFile: !1,
+      isDirectory: !0
+    }), await a("/"), r;
+  }
+  async readFile(t, r = "utf-8") {
+    try {
+      const a = await this.getFileHandle(t, !1), n = await ie(a);
+      return r === "binary" ? n : Z(n, r);
+    } catch (a) {
+      throw console.error(a), new b(t);
+    }
+  }
+  /**
+   * Write data to a file
+   * 
+   * Creates or overwrites a file with the specified data. If the file already
+   * exists, it will be truncated before writing.
+   * 
+   * @param path - The path to the file to write
+   * @param data - The data to write to the file (string, Uint8Array, or ArrayBuffer)
+   * @param encoding - The encoding to use when writing string data (default: 'utf-8')
+   * @returns Promise that resolves when the write operation is complete
+   * @throws {OPFSError} If writing the file fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Write text data
+   * await fs.writeFile('/config/settings.json', JSON.stringify({ theme: 'dark' }));
+   * 
+   * // Write binary data
+   * const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
+   * await fs.writeFile('/data/binary.dat', binaryData);
+   * 
+   * // Write with specific encoding
+   * await fs.writeFile('/data/utf16.txt', 'Hello World', 'utf-16le');
+   * \`\`\`
+   */
+  async writeFile(t, r, a) {
+    const n = await this.getFileHandle(t, !0);
+    await H(n, r, a, { truncate: !0 });
+  }
+  /**
+   * Append data to a file
+   * 
+   * Adds data to the end of an existing file. If the file doesn't exist,
+   * it will be created.
+   * 
+   * @param path - The path to the file to append to
+   * @param data - The data to append to the file (string, Uint8Array, or ArrayBuffer)
+   * @param encoding - The encoding to use when appending string data (default: 'utf-8')
+   * @returns Promise that resolves when the append operation is complete
+   * @throws {OPFSError} If appending to the file fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Append text to a log file
+   * await fs.appendFile('/logs/app.log', \`[\${new Date().toISOString()}] User logged in\\n\`);
+   * 
+   * // Append binary data
+   * const additionalData = new Uint8Array([6, 7, 8]);
+   * await fs.appendFile('/data/binary.dat', additionalData);
+   * \`\`\`
+   */
+  async appendFile(t, r, a) {
+    const n = await this.getFileHandle(t, !0);
+    await H(n, r, a, { append: !0 });
+  }
+  /**
+   * Create a directory
+   * 
+   * Creates a new directory at the specified path. If the recursive option
+   * is enabled, parent directories will be created as needed.
+   * 
+   * @param path - The path where the directory should be created
+   * @param options - Options for directory creation
+   * @param options.recursive - Whether to create parent directories if they don't exist (default: false)
+   * @returns Promise that resolves when the directory is created
+   * @throws {OPFSError} If the directory cannot be created
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Create a single directory
+   * await fs.mkdir('/users/john');
+   * 
+   * // Create nested directories
+   * await fs.mkdir('/users/john/documents/projects', { recursive: true });
+   * \`\`\`
+   */
+  async mkdir(t, r) {
+    if (!this.root)
+      throw new D();
+    const a = r?.recursive ?? !1, n = y(t);
+    let s = this.root;
+    for (let i = 0; i < n.length; i++) {
+      const o = n[i];
+      try {
+        s = await s.getDirectoryHandle(o, { create: a || i === n.length - 1 });
+      } catch (c) {
+        throw c.name === "NotFoundError" ? new l(
+          \`Parent directory does not exist: \${N(n.slice(0, i + 1))}\`,
+          "ENOENT"
+        ) : c.name === "TypeMismatchError" ? new l(\`Path segment is not a directory: \${o}\`, "ENOTDIR") : new l("Failed to create directory", "MKDIR_FAILED");
+      }
+    }
+  }
+  /**
+   * Get file or directory stats
+   * 
+   * Retrieves metadata about a file or directory, including size, modification time,
+   * type information, and optionally file hashes.
+   * 
+   * @param path - The path to the file or directory
+   * @param options - Options for stat operation
+   * @param options.includeHash - Whether to calculate file hash (default: false, only for files)
+   * @param options.hashAlgorithm - Hash algorithm to use (default: 'SHA-1', fastest)
+   * @returns Promise that resolves to file/directory statistics
+   * @throws {OPFSError} If the file or directory does not exist or cannot be accessed
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Basic stats
+   * const stats = await fs.stat('/config/settings.json');
+   * console.log(\`File size: \${stats.size} bytes\`);
+   * console.log(\`Is file: \${stats.isFile}\`);
+   * console.log(\`Modified: \${stats.mtime}\`);
+   * 
+   * // Stats with hash (SHA-1 is fastest)
+   * const statsWithHash = await fs.stat('/config/settings.json', { 
+   *   includeHash: true,
+   *   hashAlgorithm: 'SHA-1'
+   * });
+   * console.log(\`Hash: \${statsWithHash.hash}\`);
+   * \`\`\`
+   */
+  async stat(t, r) {
+    const a = y(t), n = a.pop(), s = await this.getDirectoryHandle(a, !1), i = r?.includeHash ?? !1, o = r?.hashAlgorithm ?? "SHA-1";
+    try {
+      const f = await (await s.getFileHandle(n, { create: !1 })).getFile(), u = {
+        kind: "file",
+        size: f.size,
+        mtime: new Date(f.lastModified).toISOString(),
+        ctime: new Date(f.lastModified).toISOString(),
+        isFile: !0,
+        isDirectory: !1
+      };
+      if (i)
+        try {
+          const w = new Uint8Array(await f.arrayBuffer()), h = await oe(w, o);
+          u.hash = h;
+        } catch (w) {
+          console.warn(\`Failed to calculate hash for \${t}:\`, w);
+        }
+      return u;
+    } catch (c) {
+      if (c.name !== "TypeMismatchError" && c.name !== "NotFoundError")
+        throw new l("Failed to stat (file)", "STAT_FAILED");
+    }
+    try {
+      return await s.getDirectoryHandle(n, { create: !1 }), {
+        kind: "directory",
+        size: 0,
+        mtime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        ctime: (/* @__PURE__ */ new Date(0)).toISOString(),
+        isFile: !1,
+        isDirectory: !0
+        // Directories don't have hashes
+      };
+    } catch (c) {
+      throw c.name === "NotFoundError" ? new l(\`No such file or directory: \${t}\`, "ENOENT") : new l("Failed to stat (directory)", "STAT_FAILED");
+    }
+  }
+  async readdir(t, r) {
+    const a = r?.withFileTypes ?? !1, n = await this.getDirectoryHandle(t, !1);
+    if (a) {
+      const s = [];
+      for await (const [i, o] of n.entries()) {
+        const c = o.kind === "file";
+        s.push({
+          name: i,
+          kind: o.kind,
+          isFile: c,
+          isDirectory: !c
+        });
+      }
+      return s;
+    } else {
+      const s = [];
+      for await (const [i] of n.entries())
+        s.push(i);
+      return s;
+    }
+  }
+  /**
+   * Check if a file or directory exists
+   * 
+   * Verifies if a file or directory exists at the specified path.
+   * 
+   * @param path - The path to check
+   * @returns Promise that resolves to true if the file or directory exists, false otherwise  
+   * 
+   * @example
+   * \`\`\`typescript
+   * const exists = await fs.exists('/config/settings.json');
+   * console.log(\`File exists: \${exists}\`);
+   * \`\`\`
+   */
+  async exists(t) {
+    const r = y(t), a = r.pop();
+    let n = null;
+    try {
+      n = await this.getDirectoryHandle(r, !1);
+    } catch (s) {
+      throw (s.name === "NotFoundError" || s.name === "TypeMismatchError") && (n = null), s;
+    }
+    if (!n || !a)
+      return !1;
+    try {
+      return await n.getFileHandle(a, { create: !1 }), !0;
+    } catch (s) {
+      if (s.name !== "NotFoundError" && s.name !== "TypeMismatchError")
+        throw s;
+    }
+    try {
+      return await n.getDirectoryHandle(a, { create: !1 }), !0;
+    } catch (s) {
+      if (s.name !== "NotFoundError" && s.name !== "TypeMismatchError")
+        throw s;
+    }
+    return !1;
+  }
+  /**
+   * Clear all contents of a directory without removing the directory itself
+   * 
+   * Removes all files and subdirectories within the specified directory,
+   * but keeps the directory itself.
+   * 
+   * @param path - The path to the directory to clear (default: '/')
+   * @returns Promise that resolves when all contents are removed
+   * @throws {OPFSError} If the operation fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Clear root directory contents
+   * await fs.clear('/');
+   * 
+   * // Clear specific directory contents
+   * await fs.clear('/data');
+   * \`\`\`
+   */
+  async clear(t = "/") {
+    try {
+      const r = await this.readdir(t, { withFileTypes: !0 });
+      for (const a of r) {
+        const n = \`\${t === "/" ? "" : t}/\${a.name}\`;
+        await this.remove(n, { recursive: !0 });
+      }
+    } catch (r) {
+      throw r instanceof l ? r : new l(\`Failed to clear directory: \${t}\`, "CLEAR_FAILED");
+    }
+  }
+  /**
+   * Remove files and directories
+   * 
+   * Removes files and directories. Similar to Node.js fs.rm().
+   * 
+   * @param path - The path to remove
+   * @param options - Options for removal
+   * @param options.recursive - Whether to remove directories and their contents recursively (default: false)
+   * @param options.force - Whether to ignore errors if the path doesn't exist (default: false)
+   * @returns Promise that resolves when the removal is complete
+   * @throws {OPFSError} If the removal fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Remove a file
+   * await fs.rm('/path/to/file.txt');
+   * 
+   * // Remove a directory and all its contents
+   * await fs.rm('/path/to/directory', { recursive: true });
+   * 
+   * // Remove with force (ignore if doesn't exist)
+   * await fs.rm('/maybe/exists', { force: true });
+   * \`\`\`
+   */
+  async remove(t, r) {
+    const a = r?.recursive ?? !1, n = r?.force ?? !1, s = y(t), i = s.pop();
+    if (!i)
+      throw new P("Invalid path", t);
+    const o = await this.getDirectoryHandle(s, !1);
+    try {
+      await o.removeEntry(i, { recursive: a });
+    } catch (c) {
+      if (c.name === "NotFoundError") {
+        if (!n)
+          throw new l(\`No such file or directory: \${t}\`, "ENOENT");
+      } else throw c.name === "InvalidModificationError" ? new l(\`Directory not empty: \${t}. Use recursive option to force removal.\`, "ENOTEMPTY") : c.name === "TypeMismatchError" && !a ? new l(\`Cannot remove directory without recursive option: \${t}\`, "EISDIR") : new l(\`Failed to remove path: \${t}\`, "RM_FAILED");
+    }
+  }
+  /**
+   * Resolve a path to an absolute path
+   * 
+   * Resolves relative paths and normalizes path segments (like '..' and '.').
+   * Similar to Node.js fs.realpath() but without symlink resolution since OPFS doesn't support symlinks.
+   * 
+   * @param path - The path to resolve
+   * @returns Promise that resolves to the absolute normalized path
+   * @throws {FileNotFoundError} If the path does not exist
+   * @throws {OPFSError} If path resolution fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Resolve relative path
+   * const absolute = await fs.realpath('./config/../data/file.txt');
+   * console.log(absolute); // '/data/file.txt'
+   * \`\`\`
+   */
+  async realpath(t) {
+    try {
+      const r = y(t), a = [];
+      for (const i of r)
+        if (!(i === "." || i === ""))
+          if (i === "..") {
+            if (a.length === 0)
+              throw new l("Path escapes root", "EINVAL");
+            a.length > 0 && a.pop();
+          } else
+            a.push(i);
+      const n = N(a);
+      if (!await this.exists(n))
+        throw new b(n);
+      return n;
+    } catch (r) {
+      throw r instanceof l ? r : new l(\`Failed to resolve path: \${t}\`, "REALPATH_FAILED");
+    }
+  }
+  /**
+   * Rename a file or directory
+   * 
+   * Changes the name of a file or directory. If the target path already exists,
+   * it will be replaced.
+   * 
+   * @param oldPath - The current path of the file or directory
+   * @param newPath - The new path for the file or directory
+   * @returns Promise that resolves when the rename operation is complete
+   * @throws {OPFSError} If the rename operation fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * await fs.rename('/old/path/file.txt', '/new/path/renamed.txt');
+   * \`\`\`
+   */
+  async rename(t, r) {
+    try {
+      if (!await this.exists(t))
+        throw new b(t);
+      await this.copy(t, r, { recursive: !0 }), await this.remove(t, { recursive: !0 });
+    } catch (a) {
+      throw a instanceof l ? a : new l(\`Failed to rename from \${t} to \${r}\`, "RENAME_FAILED");
+    }
+  }
+  /**
+   * Copy files and directories
+   * 
+   * Copies files and directories. Similar to Node.js fs.cp().
+   * 
+   * @param source - The source path to copy from
+   * @param destination - The destination path to copy to
+   * @param options - Options for copying
+   * @param options.recursive - Whether to copy directories recursively (default: false)
+   * @param options.force - Whether to overwrite existing files (default: true)
+   * @returns Promise that resolves when the copy operation is complete
+   * @throws {OPFSError} If the copy operation fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Copy a file
+   * await fs.cp('/source/file.txt', '/dest/file.txt');
+   * 
+   * // Copy a directory and all its contents
+   * await fs.cp('/source/dir', '/dest/dir', { recursive: true });
+   * 
+   * // Copy without overwriting existing files
+   * await fs.cp('/source', '/dest', { recursive: true, force: false });
+   * \`\`\`
+   */
+  async copy(t, r, a) {
+    try {
+      const n = a?.recursive ?? !1, s = a?.force ?? !0;
+      if (!await this.exists(t))
+        throw new l(\`Source does not exist: \${t}\`, "ENOENT");
+      if (await this.exists(r) && !s)
+        throw new l(\`Destination already exists: \${r}\`, "EEXIST");
+      if ((await this.stat(t)).isFile) {
+        const f = await this.readFile(t, "binary");
+        await this.writeFile(r, f);
+      } else {
+        if (!n)
+          throw new l(\`Cannot copy directory without recursive option: \${t}\`, "EISDIR");
+        await this.mkdir(r, { recursive: !0 });
+        const f = await this.readdir(t, { withFileTypes: !0 });
+        for (const u of f) {
+          const w = \`\${t}/\${u.name}\`, h = \`\${r}/\${u.name}\`;
+          await this.copy(w, h, { recursive: !0, force: s });
+        }
+      }
+    } catch (n) {
+      throw n instanceof l ? n : new l(\`Failed to copy from \${t} to \${r}\`, "CP_FAILED");
+    }
+  }
+  /**
+   * Start watching a file or directory for changes
+   */
+  async watch(t) {
+    const r = t.startsWith("/") ? t : \`/\${t}\`, a = await this.buildSnapshot(r);
+    this.watchers.set(r, a), this.watchTimer || (this.watchTimer = setInterval(() => {
+      this.scanWatches();
+    }, this.watchInterval));
+  }
+  /**
+   * Stop watching a previously watched path
+   */
+  unwatch(t) {
+    const r = t.startsWith("/") ? t : \`/\${t}\`;
+    this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
+  }
+  async buildSnapshot(t) {
+    const r = /* @__PURE__ */ new Map(), a = async (n) => {
+      const s = await this.stat(n);
+      if (r.set(n, s), s.isDirectory) {
+        const i = await this.readdir(n, { withFileTypes: !0 });
+        for (const o of i) {
+          const c = \`\${n === "/" ? "" : n}/\${o.name}\`;
+          await a(c);
+        }
+      }
+    };
+    return await a(t), r;
+  }
+  async scanWatches() {
+    if (!this.scanning) {
+      this.scanning = !0;
+      try {
+        await Promise.all(
+          [...this.watchers.entries()].map(async ([t, r]) => {
+            let a;
+            try {
+              a = await this.buildSnapshot(t);
+            } catch {
+              a = /* @__PURE__ */ new Map();
+            }
+            const n = [];
+            for (const [s, i] of a) {
+              const o = r.get(s);
+              o ? (o.mtime !== i.mtime || o.size !== i.size) && n.push({ path: s, type: "change" }) : n.push({ path: s, type: "create" });
+            }
+            for (const s of r.keys())
+              a.has(s) || n.push({ path: s, type: "delete" });
+            if (n.length && this.watchCallback)
+              for (const s of n)
+                this.watchCallback(s);
+            this.watchers.set(t, a);
+          })
+        );
+      } finally {
+        this.scanning = !1;
+      }
+    }
+  }
+  /**
+   * Synchronize the file system with external data
+   * 
+   * Syncs the file system with an array of entries containing paths and data.
+   * This is useful for importing data from external sources or syncing with remote data.
+   * 
+   * @param entries - Array of [path, data] tuples to sync
+   * @param options - Options for synchronization
+   * @param options.cleanBefore - Whether to clear the file system before syncing (default: false)
+   * @returns Promise that resolves when synchronization is complete
+   * @throws {OPFSError} If the synchronization fails
+   * 
+   * @example
+   * \`\`\`typescript
+   * // Sync with external data
+   * const entries: [string, string | Uint8Array | Blob][] = [
+   *   ['/config.json', JSON.stringify({ theme: 'dark' })],
+   *   ['/data/binary.dat', new Uint8Array([1, 2, 3, 4])],
+   *   ['/upload.txt', new Blob(['file content'], { type: 'text/plain' })]
+   * ];
+   * 
+   * // Sync without clearing existing files
+   * await fs.sync(entries);
+   * 
+   * // Clean file system and then sync
+   * await fs.sync(entries, { cleanBefore: true });
+   * \`\`\`
+   */
+  async sync(t, r) {
+    try {
+      (r?.cleanBefore ?? !1) && await this.clear("/");
+      for (const [n, s] of t) {
+        const i = n.startsWith("/") ? n : \`/\${n}\`;
+        let o;
+        if (s instanceof Blob) {
+          const c = await s.arrayBuffer();
+          o = new Uint8Array(c);
+        } else
+          o = s;
+        await this.writeFile(i, o);
+      }
+    } catch (a) {
+      throw a instanceof l ? a : new l("Failed to sync file system", "SYNC_FAILED");
+    }
+  }
+}
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && x(new ce());
+//# sourceMappingURL=worker-D5GbafFH.js.map
+`,r=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",a],{type:"text/javascript;charset=utf-8"});function s(t){let n;try{if(n=r&&(self.URL||self.webkitURL).createObjectURL(r),!n)throw"";const e=new Worker(n,{type:"module",name:t?.name});return e.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(n)}),e}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(a),{type:"module",name:t?.name})}}function o(){return i.wrap(new s)}exports.createWorker=o;
 //# sourceMappingURL=index.cjs.map