opfs-worker 0.2.3 → 0.2.4

package/dist/index.cjs

@@ -3,11 +3,11 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), T = Symbol("Comlink.finalizer"), p = Symbol("Comlink.thrown"), $ = (t) => typeof t == "object" && t !== null || typeof t == "function", W = {
+const H = Symbol("Comlink.proxy"), R = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), I = Symbol("Comlink.finalizer"), p = Symbol("Comlink.thrown"), $ = (t) => typeof t == "object" && t !== null || typeof t == "function", W = {
   canHandle: (t) => $(t) && t[H],
   serialize(t) {
     const { port1: e, port2: r } = new MessageChannel();
-    return x(t, e), [r, [r]];
+    return O(t, e), [r, [r]];
   },
   deserialize(t) {
     return t.start(), Y(t);
@@ -38,7 +38,7 @@ function V(t, e) {
       return !0;
   return !1;
 }
-function x(t, e = globalThis, r = ["*"]) {
+function O(t, e = globalThis, r = ["*"]) {
   e.addEventListener("message", function a(n) {
     if (!n || !n.data)
       return;
@@ -46,7 +46,7 @@ function x(t, e = globalThis, r = ["*"]) {
       console.warn(\`Invalid origin '\${n.origin}' for comlink proxy\`);
       return;
     }
-    const { id: i, type: o, path: s } = Object.assign({ path: [] }, n.data), l = (n.data.argumentList || []).map(d);
+    const { id: i, type: o, path: s } = Object.assign({ path: [] }, n.data), l = (n.data.argumentList || []).map(y);
     let u;
     try {
       const f = s.slice(0, -1).reduce((h, g) => h[g], t), w = s.reduce((h, g) => h[g], t);
@@ -55,7 +55,7 @@ function x(t, e = globalThis, r = ["*"]) {
           u = w;
           break;
         case "SET":
-          f[s.slice(-1)[0]] = d(n.data.value), u = !0;
+          f[s.slice(-1)[0]] = y(n.data.value), u = !0;
           break;
         case "APPLY":
           u = w.apply(f, l);
@@ -69,7 +69,7 @@ function x(t, e = globalThis, r = ["*"]) {
         case "ENDPOINT":
           {
             const { port1: h, port2: g } = new MessageChannel();
-            x(t, g), u = J(h, [h]);
+            O(t, g), u = J(h, [h]);
           }
           break;
         case "RELEASE":
@@ -83,7 +83,7 @@ function x(t, e = globalThis, r = ["*"]) {
     }
     Promise.resolve(u).catch((f) => ({ value: f, [p]: 0 })).then((f) => {
       const [w, h] = A(f);
-      e.postMessage(Object.assign(Object.assign({}, w), { id: i }), h), o === "RELEASE" && (e.removeEventListener("message", a), L(e), T in t && typeof t[T] == "function" && t[T]());
+      e.postMessage(Object.assign(Object.assign({}, w), { id: i }), h), o === "RELEASE" && (e.removeEventListener("message", a), L(e), I in t && typeof t[I] == "function" && t[I]());
     }).catch((f) => {
       const [w, h] = A({
         value: new TypeError("Unserializable return value"),
@@ -112,14 +112,14 @@ function Y(t, e) {
       } finally {
         r.delete(i.id);
       }
-  }), O(t, r, [], e);
+  }), P(t, r, [], e);
 }
 function E(t) {
   if (t)
     throw new Error("Proxy has been released and is not useable");
 }
 function z(t) {
-  return y(t, /* @__PURE__ */ new Map(), {
+  return d(t, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
     L(t);
@@ -136,7 +136,7 @@ function X(t, e) {
 function q(t) {
   S && S.unregister(t);
 }
-function O(t, e, r = [], a = function() {
+function P(t, e, r = [], a = function() {
 }) {
   let n = !1;
   const i = new Proxy(a, {
@@ -148,47 +148,47 @@ function O(t, e, r = [], a = function() {
       if (s === "then") {
         if (r.length === 0)
           return { then: () => i };
-        const l = y(t, e, {
+        const l = d(t, e, {
           type: "GET",
           path: r.map((u) => u.toString())
-        }).then(d);
+        }).then(y);
         return l.then.bind(l);
       }
-      return O(t, e, [...r, s]);
+      return P(t, e, [...r, s]);
     },
     set(o, s, l) {
       E(n);
       const [u, f] = A(l);
-      return y(t, e, {
+      return d(t, e, {
         type: "SET",
         path: [...r, s].map((w) => w.toString()),
         value: u
-      }, f).then(d);
+      }, f).then(y);
     },
     apply(o, s, l) {
       E(n);
       const u = r[r.length - 1];
       if (u === R)
-        return y(t, e, {
+        return d(t, e, {
           type: "ENDPOINT"
-        }).then(d);
+        }).then(y);
       if (u === "bind")
-        return O(t, e, r.slice(0, -1));
-      const [f, w] = N(l);
-      return y(t, e, {
+        return P(t, e, r.slice(0, -1));
+      const [f, w] = k(l);
+      return d(t, e, {
         type: "APPLY",
         path: r.map((h) => h.toString()),
         argumentList: f
-      }, w).then(d);
+      }, w).then(y);
     },
     construct(o, s) {
       E(n);
-      const [l, u] = N(s);
-      return y(t, e, {
+      const [l, u] = k(s);
+      return d(t, e, {
         type: "CONSTRUCT",
         path: r.map((f) => f.toString()),
         argumentList: l
-      }, u).then(d);
+      }, u).then(y);
     }
   });
   return X(i, t), i;
@@ -196,7 +196,7 @@ function O(t, e, r = [], a = function() {
 function K(t) {
   return Array.prototype.concat.apply([], t);
 }
-function N(t) {
+function k(t) {
   const e = t.map(A);
   return [e.map((r) => r[0]), K(e.map((r) => r[1]))];
 }
@@ -228,7 +228,7 @@ function A(t) {
     _.get(t) || []
   ];
 }
-function d(t) {
+function y(t) {
   switch (t.type) {
     case "HANDLER":
       return U.get(t.name).deserialize(t.value);
@@ -236,7 +236,7 @@ function d(t) {
       return t.value;
   }
 }
-function y(t, e, r, a) {
+function d(t, e, r, a) {
   return new Promise((n) => {
     const i = Z();
     e.set(i, n), t.start && t.start(), t.postMessage(Object.assign({ id: i }, r), a);
@@ -255,17 +255,17 @@ class ee extends c {
     super("OPFS is not supported in this browser", "OPFS_NOT_SUPPORTED");
   }
 }
-class D extends c {
+class T extends c {
   constructor() {
     super("OPFS is not mounted", "OPFS_NOT_MOUNTED");
   }
 }
-class k extends c {
+class v extends c {
   constructor(e, r) {
     super(e, "INVALID_PATH", r);
   }
 }
-class b extends c {
+class D extends c {
   constructor(e) {
     super(\`File not found: \${e}\`, "FILE_NOT_FOUND", e);
   }
@@ -350,18 +350,18 @@ function oe() {
 function m(t) {
   return Array.isArray(t) ? t : t.split("/").filter(Boolean);
 }
-function v(t) {
+function x(t) {
   return typeof t == "string" ? t ?? "/" : \`/\${t.join("/")}\`;
 }
-function I(t) {
+function b(t) {
   const e = m(t);
   return e[e.length - 1] || "";
 }
-function P(t) {
+function M(t) {
   const e = m(t);
-  return e.pop(), v(e);
+  return e.pop(), x(e);
 }
-function M(t) {
+function C(t) {
   return !t || t === "/" ? "/" : t.startsWith("/") ? t : \`/\${t}\`;
 }
 function ce(t) {
@@ -374,7 +374,7 @@ function ce(t) {
         r.pop();
       } else
         r.push(a);
-  return v(r);
+  return x(r);
 }
 function le(t, e = "utf-8") {
   return typeof t == "string" ? te(t, e) : t instanceof Uint8Array ? t : new Uint8Array(t);
@@ -388,7 +388,7 @@ async function ue(t) {
     e.close();
   }
 }
-async function C(t, e, r, a = {}) {
+async function N(t, e, r, a = {}) {
   let n = null;
   try {
     n = await t.createSyncAccessHandle();
@@ -433,6 +433,21 @@ class we {
   scanning = !1;
   /** Promise to prevent concurrent mount operations */
   mountingPromise = null;
+  /**
+   * Notify about internal changes to the file system
+   * 
+   * This method is called by internal operations to notify clients about
+   * changes, even when no specific paths are being watched.
+   * 
+   * @param path - The path that was changed
+   * @param type - The type of change (create, change, delete)
+   */
+  notifyInternalChange(e, r) {
+    this.watchCallback && this.watchCallback({
+      path: e,
+      type: r
+    });
+  }
   /**
    * Creates a new OPFSFileSystem instance
    * 
@@ -524,7 +539,7 @@ class we {
    */
   async getDirectoryHandle(e, r = !1, a = this.root) {
     if (!a)
-      throw new D();
+      throw new T();
     const n = Array.isArray(e) ? e : m(e);
     let i = a;
     for (const o of n)
@@ -552,10 +567,10 @@ class we {
    */
   async getFileHandle(e, r = !1, a = this.root) {
     if (!a)
-      throw new D();
+      throw new T();
     const n = m(e);
     if (n.length === 0)
-      throw new k("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
+      throw new v("Path must not be empty", Array.isArray(e) ? e.join("/") : e);
     const i = n.pop();
     return (await this.getDirectoryHandle(n, r, a)).getFileHandle(i, { create: r });
   }
@@ -624,7 +639,7 @@ class we {
       const a = await this.getFileHandle(e, !1), n = await ue(a);
       return r === "binary" ? n : re(n, r);
     } catch (a) {
-      throw console.error(a), new b(e);
+      throw console.error(a), new D(e);
     }
   }
   /**
@@ -655,7 +670,7 @@ class we {
   async writeFile(e, r, a) {
     await this.ensureMounted();
     const n = await this.getFileHandle(e, !0);
-    await C(n, r, a, { truncate: !0 });
+    await N(n, r, a, { truncate: !0 }), this.notifyInternalChange(e, "change");
   }
   /**
    * Append data to a file
@@ -682,7 +697,7 @@ class we {
   async appendFile(e, r, a) {
     await this.ensureMounted();
     const n = await this.getFileHandle(e, !0);
-    await C(n, r, a, { append: !0 });
+    await N(n, r, a, { append: !0 }), this.notifyInternalChange(e, "change");
   }
   /**
    * Create a directory
@@ -707,7 +722,7 @@ class we {
    */
   async mkdir(e, r) {
     if (await this.ensureMounted(), !this.root)
-      throw new D();
+      throw new T();
     const a = r?.recursive ?? !1, n = m(e);
     let i = this.root;
     for (let o = 0; o < n.length; o++) {
@@ -716,11 +731,12 @@ class we {
         i = await i.getDirectoryHandle(s, { create: a || o === n.length - 1 });
       } catch (l) {
         throw l.name === "NotFoundError" ? new c(
-          \`Parent directory does not exist: \${v(n.slice(0, o + 1))}\`,
+          \`Parent directory does not exist: \${x(n.slice(0, o + 1))}\`,
           "ENOENT"
         ) : l.name === "TypeMismatchError" ? new c(\`Path segment is not a directory: \${s}\`, "ENOTDIR") : new c("Failed to create directory", "MKDIR_FAILED");
       }
     }
+    this.notifyInternalChange(e, "create");
   }
   /**
    * Get file or directory stats
@@ -761,7 +777,7 @@ class we {
         isFile: !1,
         isDirectory: !0
       };
-    const a = I(e), n = await this.getDirectoryHandle(P(e), !1), i = r?.includeHash ?? !1, o = r?.hashAlgorithm ?? "SHA-1";
+    const a = b(e), n = await this.getDirectoryHandle(M(e), !1), i = r?.includeHash ?? !1, o = r?.hashAlgorithm ?? "SHA-1";
     try {
       const l = await (await n.getFileHandle(a, { create: !1 })).getFile(), u = {
         kind: "file",
@@ -835,10 +851,10 @@ class we {
   async exists(e) {
     if (await this.ensureMounted(), e === "/")
       return !0;
-    const r = I(e);
+    const r = b(e);
     let a = null;
     try {
-      a = await this.getDirectoryHandle(P(e), !1);
+      a = await this.getDirectoryHandle(M(e), !1);
     } catch (n) {
       throw (n.name === "NotFoundError" || n.name === "TypeMismatchError") && (a = null), n;
     }
@@ -885,6 +901,7 @@ class we {
         const n = \`\${e === "/" ? "" : e}/\${a.name}\`;
         await this.remove(n, { recursive: !0 });
       }
+      this.notifyInternalChange(e, "change");
     } catch (r) {
       throw r instanceof c ? r : new c(\`Failed to clear directory: \${e}\`, "CLEAR_FAILED");
     }
@@ -918,10 +935,10 @@ class we {
     const a = r?.recursive ?? !1, n = r?.force ?? !1;
     if (e === "/")
       throw new c("Cannot remove root directory", "EROOT");
-    const i = I(e);
+    const i = b(e);
     if (!i)
-      throw new k("Invalid path", e);
-    const o = await this.getDirectoryHandle(P(e), !1);
+      throw new v("Invalid path", e);
+    const o = await this.getDirectoryHandle(M(e), !1);
     try {
       await o.removeEntry(i, { recursive: a });
     } catch (s) {
@@ -930,6 +947,7 @@ class we {
           throw new c(\`No such file or directory: \${e}\`, "ENOENT");
       } else throw s.name === "InvalidModificationError" ? new c(\`Directory not empty: \${e}. Use recursive option to force removal.\`, "ENOTEMPTY") : s.name === "TypeMismatchError" && !a ? new c(\`Cannot remove directory without recursive option: \${e}\`, "EISDIR") : new c(\`Failed to remove path: \${e}\`, "RM_FAILED");
     }
+    this.notifyInternalChange(e, "delete");
   }
   /**
    * Resolve a path to an absolute path
@@ -954,7 +972,7 @@ class we {
     try {
       const r = ce(e);
       if (!await this.exists(r))
-        throw new b(r);
+        throw new D(r);
       return r;
     } catch (r) {
       throw r instanceof c ? r : new c(\`Failed to resolve path: \${e}\`, "REALPATH_FAILED");
@@ -980,8 +998,8 @@ class we {
     await this.ensureMounted();
     try {
       if (!await this.exists(e))
-        throw new b(e);
-      await this.copy(e, r, { recursive: !0 }), await this.remove(e, { recursive: !0 });
+        throw new D(e);
+      await this.copy(e, r, { recursive: !0 }), await this.remove(e, { recursive: !0 }), this.notifyInternalChange(e, "delete"), this.notifyInternalChange(r, "create");
     } catch (a) {
       throw a instanceof c ? a : new c(\`Failed to rename from \${e} to \${r}\`, "RENAME_FAILED");
     }
@@ -1032,6 +1050,7 @@ class we {
           await this.copy(w, h, { recursive: !0, force: i });
         }
       }
+      this.notifyInternalChange(r, "create");
     } catch (n) {
       throw n instanceof c ? n : new c(\`Failed to copy from \${e} to \${r}\`, "CP_FAILED");
     }
@@ -1041,7 +1060,7 @@ class we {
    */
   async watch(e) {
     await this.ensureMounted();
-    const r = M(e), a = await this.buildSnapshot(r);
+    const r = C(e), a = await this.buildSnapshot(r);
     this.watchers.set(r, a), this.watchTimer || (this.watchTimer = setInterval(() => {
       this.scanWatches();
     }, this.watchInterval));
@@ -1050,7 +1069,7 @@ class we {
    * Stop watching a previously watched path
    */
   unwatch(e) {
-    const r = M(e);
+    const r = C(e);
     this.watchers.delete(r), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
   }
   async buildSnapshot(e) {
@@ -1129,16 +1148,17 @@ class we {
     try {
       (r?.cleanBefore ?? !1) && await this.clear("/");
       for (const [n, i] of e) {
-        const o = M(n);
+        const o = C(n);
         let s;
         i instanceof Blob ? s = await he(i) : s = i, await this.writeFile(o, s);
       }
+      this.notifyInternalChange("/", "change");
     } catch (a) {
       throw a instanceof c ? a : new c("Failed to sync file system", "SYNC_FAILED");
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && x(new we());
-//# sourceMappingURL=worker-CRHhlrlS.js.map
+typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && O(new we());
+//# sourceMappingURL=worker-DCm4BiWM.js.map
 `,i=typeof self<"u"&&self.Blob&&new Blob(["URL.revokeObjectURL(import.meta.url);",o],{type:"text/javascript;charset=utf-8"});function s(r){let e;try{if(e=i&&(self.URL||self.webkitURL).createObjectURL(i),!e)throw"";const t=new Worker(e,{type:"module",name:r?.name});return t.addEventListener("error",()=>{(self.URL||self.webkitURL).revokeObjectURL(e)}),t}catch{return new Worker("data:text/javascript;charset=utf-8,"+encodeURIComponent(o),{type:"module",name:r?.name})}}function c(r,e){const t=a.wrap(new s);return r&&t.setWatchCallback(a.proxy(r),e),t}exports.DirectoryNotFoundError=n.DirectoryNotFoundError;exports.FileNotFoundError=n.FileNotFoundError;exports.OPFSError=n.OPFSError;exports.OPFSNotMountedError=n.OPFSNotMountedError;exports.OPFSNotSupportedError=n.OPFSNotSupportedError;exports.PathError=n.PathError;exports.PermissionError=n.PermissionError;exports.StorageError=n.StorageError;exports.TimeoutError=n.TimeoutError;exports.basename=n.basename;exports.calculateFileHash=n.calculateFileHash;exports.checkOPFSSupport=n.checkOPFSSupport;exports.convertBlobToUint8Array=n.convertBlobToUint8Array;exports.createBuffer=n.createBuffer;exports.decodeBuffer=n.decodeBuffer;exports.dirname=n.dirname;exports.encodeString=n.encodeString;exports.extname=n.extname;exports.joinPath=n.joinPath;exports.normalizePath=n.normalizePath;exports.readFileData=n.readFileData;exports.resolvePath=n.resolvePath;exports.splitPath=n.splitPath;exports.writeFileData=n.writeFileData;exports.createWorker=c;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["import { wrap, proxy } from 'comlink';\n\nimport WorkerCtor from './worker?worker&inline';\n\nimport type { OPFSWorker, RemoteOPFSWorker, WatchEvent } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\n\n/**\n * Creates a new file system instance with inline worker\n * @param watchCallback - Optional callback for file change events\n * @param watchOptions - Optional configuration for watching\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    watchCallback?: (event: WatchEvent) => void,\n    watchOptions?: { watchInterval?: number }\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up watch callback if provided\n    if (watchCallback) {\n        wrapped.setWatchCallback(proxy(watchCallback), watchOptions);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","watchCallback","watchOptions","wrapped","wrap","WorkerCtor","proxy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAiBO,SAASA,EACZC,EACAC,EACgB,CAChB,MAAMC,EAAUC,EAAAA,KAAiB,IAAIC,CAAY,EAGjD,OAAIJ,GACAE,EAAQ,iBAAiBG,EAAAA,MAAML,CAAa,EAAGC,CAAY,EAGxDC,CACX"}
+{"version":3,"file":"index.cjs","sources":["../src/index.ts"],"sourcesContent":["import { wrap, proxy } from 'comlink';\n\nimport WorkerCtor from './worker?worker&inline';\n\nimport type { OPFSWorker, RemoteOPFSWorker, WatchEvent } from './types';\n\nexport * from './types';\nexport * from './utils/errors';\nexport * from './utils/helpers';\nexport * from './utils/encoder';\n\n/**\n * Creates a new file system instance with inline worker\n * @param watchCallback - Optional callback for file change events\n * @param watchOptions - Optional configuration for watching\n * @returns Promise resolving to the file system interface\n */\nexport function createWorker(\n    watchCallback?: (event: WatchEvent) => void,\n    watchOptions?: { watchInterval?: number }\n): RemoteOPFSWorker {\n    const wrapped = wrap<OPFSWorker>(new WorkerCtor());\n    \n    // Set up watch callback if provided\n    if (watchCallback) {\n        wrapped.setWatchCallback(proxy(watchCallback), watchOptions);\n    }\n    \n    return wrapped;\n}\n"],"names":["createWorker","watchCallback","watchOptions","wrapped","wrap","WorkerCtor","proxy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qdAiBO,SAASA,EACZC,EACAC,EACgB,CAChB,MAAMC,EAAUC,EAAAA,KAAiB,IAAIC,CAAY,EAGjD,OAAIJ,GACAE,EAAQ,iBAAiBG,EAAAA,MAAML,CAAa,EAAGC,CAAY,EAGxDC,CACX"}