opfs-worker 0.3.3 → 0.5.0

package/dist/raw.js

@@ -1,21 +1,18 @@
-import { expose as p } from "comlink";
-import { d as S, O as n, b as l, s as w, P as g, i as v, o as I, F as f, w as D, j as C, e as d, f as y, k as M, r as T, n as u, l as b } from "./helpers-DxFcNkZe.js";
-class A {
+import { expose as E } from "comlink";
+import { m as l, d as v, n as y, O as o, s as d, P as p, l as S, x as C, F as w, o as u, j as b, e as g, f, p as A, u as x, r as I, g as H, t as O } from "./helpers-Bm2TWyPQ.js";
+class $ {
   /** Root directory handle for the file system */
   root = null;
-  /** Map of watched paths to their last known state */
+  /** Map of watched paths and options */
   watchers = /* @__PURE__ */ new Map();
-  /** Interval handle for polling watched paths */
-  watchTimer = null;
-  /** Flag to avoid concurrent scans */
-  scanning = !1;
   /** Promise to prevent concurrent mount operations */
   mountingPromise = null;
   /** BroadcastChannel instance for sending events */
   broadcastChannel = null;
   /** Configuration options */
   options = {
-    watchInterval: 1e3,
+    root: "/",
+    namespace: "",
     maxFileSize: 50 * 1024 * 1024,
     hashAlgorithm: null,
     broadcastChannel: "opfs-worker"
@@ -32,38 +29,40 @@ class A {
   async notifyChange(t) {
     if (!this.options.broadcastChannel)
       return;
-    let e;
-    if (this.options.hashAlgorithm && !t.isDirectory && t.type !== "removed")
+    const e = t.path;
+    if (![...this.watchers.values()].some((r) => l(e, r.pattern) && r.include.some((s) => s && l(e, s)) && !r.exclude.some((s) => s && l(e, s))))
+      return;
+    let a;
+    if (this.options.hashAlgorithm)
       try {
-        const i = await this.stat(t.path);
-        i.isFile && i.hash && (e = i.hash);
-      } catch (i) {
-        console.warn(`Failed to calculate hash for ${t.path}:`, i);
+        a = (await this.stat(e)).hash;
+      } catch {
       }
     try {
       this.broadcastChannel || (this.broadcastChannel = new BroadcastChannel(this.options.broadcastChannel));
-      const i = {
-        root: this.root.name,
+      const r = {
+        namespace: this.options.namespace,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         ...t,
-        ...e && { hash: e }
+        ...a && { hash: a }
       };
-      this.broadcastChannel.postMessage(i);
-    } catch (i) {
-      console.warn("Failed to send event via BroadcastChannel:", i);
+      this.broadcastChannel.postMessage(r);
+    } catch (r) {
+      console.warn("Failed to send event via BroadcastChannel:", r);
     }
   }
   /**
    * Creates a new OPFSFileSystem instance
    * 
    * @param options - Optional configuration options
+   * @param options.root - Root path for the file system (default: '/')
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @param options.maxFileSize - Maximum file size for hashing in bytes (default: 50MB)
    * @throws {OPFSError} If OPFS is not supported in the current browser
    */
   constructor(t) {
-    S(), t && this.setOptions(t), this.mount("/");
+    v(), t && this.setOptions(t);
   }
   /**
    * Initialize the file system within a given directory
@@ -86,14 +85,13 @@ class A {
    * await fs.mount('/my-app');
    * ```
    */
-  async mount(t = "/") {
-    return this.mountingPromise && await this.mountingPromise, this.mountingPromise = new Promise(async (e, i) => {
-      this.root = null;
+  async mount(t = this.options.root) {
+    return this.mountingPromise && await this.mountingPromise, t = y(t), this.mountingPromise = new Promise(async (e, i) => {
       try {
         const a = await navigator.storage.getDirectory();
         t === "/" ? this.root = a : this.root = await this.getDirectoryHandle(t, !0, a), e(!0);
-      } catch (a) {
-        console.error(a), i(new n("Failed to initialize OPFS", "INIT_FAILED"));
+      } catch {
+        i(new o("Failed to initialize OPFS", "INIT_FAILED"));
       } finally {
         this.mountingPromise = null;
       }
@@ -103,31 +101,14 @@ class A {
    * Update configuration options
    * 
    * @param options - Configuration options to update
+   * @param options.root - Root path for the file system
    * @param options.watchInterval - Polling interval in milliseconds for file watching
    * @param options.hashAlgorithm - Hash algorithm for file hashing
    * @param options.maxFileSize - Maximum file size for hashing in bytes
    * @param options.broadcastChannel - Custom name for the broadcast channel
    */
-  setOptions(t) {
-    t.watchInterval !== void 0 && (this.options.watchInterval = t.watchInterval), t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel);
-  }
-  /**
-   * Automatically mount the OPFS root if not already mounted
-   * 
-   * This method is called internally when file operations are performed
-   * without explicitly mounting first.
-   * 
-   * @returns Promise that resolves when auto-mount is complete
-   * @throws {OPFSError} If auto-mount fails
-   */
-  async ensureMounted() {
-    if (!this.root) {
-      if (this.mountingPromise) {
-        await this.mountingPromise;
-        return;
-      }
-      throw new n("OPFS not mounted", "NOT_MOUNTED");
-    }
+  async setOptions(t) {
+    t.hashAlgorithm !== void 0 && (this.options.hashAlgorithm = t.hashAlgorithm), t.maxFileSize !== void 0 && (this.options.maxFileSize = t.maxFileSize), t.broadcastChannel !== void 0 && (this.broadcastChannel && this.options.broadcastChannel !== t.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.options.broadcastChannel = t.broadcastChannel), t.namespace && (this.options.namespace = t.namespace), t.root !== void 0 && (this.options.root = t.root, this.options.namespace || (this.options.namespace = `opfs-worker:${this.options.root}`), await this.mount(this.options.root));
   }
   /**
    * Get a directory handle from a path
@@ -148,9 +129,7 @@ class A {
    * ```
    */
   async getDirectoryHandle(t, e = !1, i = this.root) {
-    if (!i)
-      throw new l();
-    const a = Array.isArray(t) ? t : w(t);
+    const a = Array.isArray(t) ? t : d(t);
     let r = i;
     for (const s of a)
       r = await r.getDirectoryHandle(s, { create: e });
@@ -176,11 +155,9 @@ class A {
    * ```
    */
   async getFileHandle(t, e = !1, i = this.root) {
-    if (!i)
-      throw new l();
-    const a = w(t);
+    const a = d(t);
     if (a.length === 0)
-      throw new g("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
+      throw new p("Path must not be empty", Array.isArray(t) ? t.join("/") : t);
     const r = a.pop();
     return (await this.getDirectoryHandle(a, e, i)).getFileHandle(r, { create: e });
   }
@@ -209,10 +186,10 @@ class A {
       for (const r of a) {
         const s = `${i === "/" ? "" : i}/${r.name}`;
         try {
-          const o = await this.stat(s);
-          t.set(s, o), o.isDirectory && await e(s);
-        } catch (o) {
-          console.warn(`Skipping broken entry: ${s}`, o);
+          const n = await this.stat(s);
+          t.set(s, n), n.isDirectory && await e(s);
+        } catch (n) {
+          console.warn(`Skipping broken entry: ${s}`, n);
         }
       }
     };
@@ -226,12 +203,12 @@ class A {
     }), await e("/"), t;
   }
   async readFile(t, e = "utf-8") {
-    await this.ensureMounted();
+    await this.mount();
     try {
-      const i = await this.getFileHandle(t, !1), a = await v(i);
-      return e === "binary" ? a : I(a, e);
+      const i = await this.getFileHandle(t, !1), a = await S(i, t);
+      return e === "binary" ? a : C(a, e);
     } catch (i) {
-      throw console.error(i), new f(t);
+      throw new w(t, i);
     }
   }
   /**
@@ -260,9 +237,9 @@ class A {
    * ```
    */
   async writeFile(t, e, i) {
-    await this.ensureMounted();
-    const a = await this.getFileHandle(t, !0);
-    await D(a, e, i, { truncate: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    await this.mount();
+    const a = await this.exists(t), r = await this.getFileHandle(t, !0);
+    await u(r, e, i, {}, t), a ? await this.notifyChange({ path: t, type: "changed", isDirectory: !1 }) : await this.notifyChange({ path: t, type: "added", isDirectory: !1 });
   }
   /**
    * Append data to a file
@@ -287,9 +264,9 @@ class A {
    * ```
    */
   async appendFile(t, e, i) {
-    await this.ensureMounted();
+    await this.mount();
     const a = await this.getFileHandle(t, !0);
-    await D(a, e, i, { append: !0 }), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
+    await u(a, e, i, { append: !0 }, t), await this.notifyChange({ path: t, type: "changed", isDirectory: !1 });
   }
   /**
    * Create a directory
@@ -313,19 +290,20 @@ class A {
    * ```
    */
   async mkdir(t, e) {
-    if (await this.ensureMounted(), !this.root)
-      throw new l();
-    const i = e?.recursive ?? !1, a = w(t);
+    await this.mount();
+    const i = e?.recursive ?? !1, a = d(t);
     let r = this.root;
     for (let s = 0; s < a.length; s++) {
-      const o = a[s];
+      const n = a[s];
       try {
-        r = await r.getDirectoryHandle(o, { create: i || s === a.length - 1 });
+        r = await r.getDirectoryHandle(n, { create: i || s === a.length - 1 });
       } catch (c) {
-        throw c.name === "NotFoundError" ? new n(
-          `Parent directory does not exist: ${C(a.slice(0, s + 1))}`,
-          "ENOENT"
-        ) : c.name === "TypeMismatchError" ? new n(`Path segment is not a directory: ${o}`, "ENOTDIR") : new n("Failed to create directory", "MKDIR_FAILED");
+        throw c.name === "NotFoundError" ? new o(
+          `Parent directory does not exist: ${b(a.slice(0, s + 1))}`,
+          "ENOENT",
+          void 0,
+          c
+        ) : c.name === "TypeMismatchError" ? new o(`Path segment is not a directory: ${n}`, "ENOTDIR", void 0, c) : new o("Failed to create directory", "MKDIR_FAILED", void 0, c);
       }
     }
     await this.notifyChange({ path: t, type: "added", isDirectory: !0 });
@@ -353,7 +331,7 @@ class A {
    * ```
    */
   async stat(t) {
-    if (await this.ensureMounted(), t === "/")
+    if (await this.mount(), t === "/")
       return {
         kind: "directory",
         size: 0,
@@ -362,9 +340,9 @@ class A {
         isFile: !1,
         isDirectory: !0
       };
-    const e = d(t), i = await this.getDirectoryHandle(y(t), !1), a = this.options.hashAlgorithm !== null;
+    const e = g(t), i = await this.getDirectoryHandle(f(t), !1), a = this.options.hashAlgorithm !== null;
     try {
-      const s = await (await i.getFileHandle(e, { create: !1 })).getFile(), o = {
+      const s = await (await i.getFileHandle(e, { create: !1 })).getFile(), n = {
         kind: "file",
         size: s.size,
         mtime: new Date(s.lastModified).toISOString(),
@@ -374,15 +352,15 @@ class A {
       };
       if (a && this.options.hashAlgorithm)
         try {
-          const c = await M(s, this.options.hashAlgorithm, this.options.maxFileSize);
-          o.hash = c;
+          const c = await A(s, this.options.hashAlgorithm, this.options.maxFileSize);
+          n.hash = c;
         } catch (c) {
           console.warn(`Failed to calculate hash for ${t}:`, c);
         }
-      return o;
+      return n;
     } catch (r) {
       if (r.name !== "TypeMismatchError" && r.name !== "NotFoundError")
-        throw new n("Failed to stat (file)", "STAT_FAILED");
+        throw new o("Failed to stat (file)", "STAT_FAILED", void 0, r);
     }
     try {
       return await i.getDirectoryHandle(e, { create: !1 }), {
@@ -394,7 +372,7 @@ class A {
         isDirectory: !0
       };
     } catch (r) {
-      throw r.name === "NotFoundError" ? new n(`No such file or directory: ${t}`, "ENOENT") : new n("Failed to stat (directory)", "STAT_FAILED");
+      throw r.name === "NotFoundError" ? new o(`No such file or directory: ${t}`, "ENOENT", void 0, r) : new o("Failed to stat (directory)", "STAT_FAILED", void 0, r);
     }
   }
   /**
@@ -416,7 +394,7 @@ class A {
    * ```
    */
   async readDir(t) {
-    await this.ensureMounted();
+    await this.mount();
     const e = await this.getDirectoryHandle(t, !1), i = [];
     for await (const [a, r] of e.entries()) {
       const s = r.kind === "file";
@@ -444,12 +422,12 @@ class A {
    * ```
    */
   async exists(t) {
-    if (await this.ensureMounted(), t === "/")
+    if (await this.mount(), t === "/")
       return !0;
-    const e = d(t);
+    const e = g(t);
     let i = null;
     try {
-      i = await this.getDirectoryHandle(y(t), !1);
+      i = await this.getDirectoryHandle(f(t), !1);
     } catch (a) {
       throw (a.name === "NotFoundError" || a.name === "TypeMismatchError") && (i = null), a;
     }
@@ -460,14 +438,14 @@ class A {
     } catch (a) {
       if (a.name !== "NotFoundError" && a.name !== "TypeMismatchError")
         throw a;
+      try {
+        return await i.getDirectoryHandle(e, { create: !1 }), !0;
+      } catch (r) {
+        if (r.name !== "NotFoundError" && r.name !== "TypeMismatchError")
+          throw r;
+        return !1;
+      }
     }
-    try {
-      return await i.getDirectoryHandle(e, { create: !1 }), !0;
-    } catch (a) {
-      if (a.name !== "NotFoundError" && a.name !== "TypeMismatchError")
-        throw a;
-    }
-    return !1;
   }
   /**
    * Clear all contents of a directory without removing the directory itself
@@ -489,7 +467,7 @@ class A {
    * ```
    */
   async clear(t = "/") {
-    await this.ensureMounted();
+    await this.mount();
     try {
       const e = await this.readDir(t);
       for (const i of e) {
@@ -498,7 +476,7 @@ class A {
       }
       await this.notifyChange({ path: t, type: "changed", isDirectory: !0 });
     } catch (e) {
-      throw e instanceof n ? e : new n(`Failed to clear directory: ${t}`, "CLEAR_FAILED");
+      throw e instanceof o ? e : new o(`Failed to clear directory: ${t}`, "CLEAR_FAILED", void 0, e);
     }
   }
   /**
@@ -526,23 +504,10 @@ class A {
    * ```
    */
   async remove(t, e) {
-    await this.ensureMounted();
-    const i = e?.recursive ?? !1, a = e?.force ?? !1;
-    if (t === "/")
-      throw new n("Cannot remove root directory", "EROOT");
-    const r = d(t);
-    if (!r)
-      throw new g("Invalid path", t);
-    const s = await this.getDirectoryHandle(y(t), !1);
-    try {
-      await s.removeEntry(r, { recursive: i });
-    } catch (o) {
-      if (o.name === "NotFoundError") {
-        if (!a)
-          throw new n(`No such file or directory: ${t}`, "ENOENT");
-      } else throw o.name === "InvalidModificationError" ? new n(`Directory not empty: ${t}. Use recursive option to force removal.`, "ENOTEMPTY") : o.name === "TypeMismatchError" && !i ? new n(`Cannot remove directory without recursive option: ${t}`, "EISDIR") : new n(`Failed to remove path: ${t}`, "RM_FAILED");
-    }
-    await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
+    if (await this.mount(), t === "/")
+      throw new o("Cannot remove root directory", "EROOT");
+    const i = await this.getDirectoryHandle(f(t), !1);
+    await x(i, t, e), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 });
   }
   /**
    * Resolve a path to an absolute path
@@ -563,14 +528,14 @@ class A {
    * ```
    */
   async realpath(t) {
-    await this.ensureMounted();
+    await this.mount();
     try {
-      const e = T(t);
+      const e = I(t);
       if (!await this.exists(e))
-        throw new f(e);
+        throw new w(e);
       return e;
     } catch (e) {
-      throw e instanceof n ? e : new n(`Failed to resolve path: ${t}`, "REALPATH_FAILED");
+      throw e instanceof o ? e : new o(`Failed to resolve path: ${t}`, "REALPATH_FAILED", void 0, e);
     }
   }
   /**
@@ -590,13 +555,13 @@ class A {
    * ```
    */
   async rename(t, e) {
-    await this.ensureMounted();
+    await this.mount();
     try {
       if (!await this.exists(t))
-        throw new f(t);
+        throw new w(t);
       await this.copy(t, e, { recursive: !0 }), await this.remove(t, { recursive: !0 }), await this.notifyChange({ path: t, type: "removed", isDirectory: !1 }), await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
     } catch (i) {
-      throw i instanceof n ? i : new n(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED");
+      throw i instanceof o ? i : new o(`Failed to rename from ${t} to ${e}`, "RENAME_FAILED", void 0, i);
     }
   }
   /**
@@ -625,47 +590,70 @@ class A {
    * ```
    */
   async copy(t, e, i) {
-    await this.ensureMounted();
+    await this.mount();
     try {
       const a = i?.recursive ?? !1, r = i?.force ?? !0;
       if (!await this.exists(t))
-        throw new n(`Source does not exist: ${t}`, "ENOENT");
+        throw new o(`Source does not exist: ${t}`, "ENOENT", void 0);
       if (await this.exists(e) && !r)
-        throw new n(`Destination already exists: ${e}`, "EEXIST");
+        throw new o(`Destination already exists: ${e}`, "EEXIST", void 0);
       if ((await this.stat(t)).isFile) {
         const h = await this.readFile(t, "binary");
         await this.writeFile(e, h);
       } else {
         if (!a)
-          throw new n(`Cannot copy directory without recursive option: ${t}`, "EISDIR");
+          throw new o(`Cannot copy directory without recursive option: ${t}`, "EISDIR", void 0);
         await this.mkdir(e, { recursive: !0 });
         const h = await this.readDir(t);
         for (const m of h) {
-          const F = `${t}/${m.name}`, E = `${e}/${m.name}`;
-          await this.copy(F, E, { recursive: !0, force: r });
+          const F = `${t}/${m.name}`, D = `${e}/${m.name}`;
+          await this.copy(F, D, { recursive: !0, force: r });
         }
       }
-      await this.notifyChange({ path: e, type: "added", isDirectory: !1 });
     } catch (a) {
-      throw a instanceof n ? a : new n(`Failed to copy from ${t} to ${e}`, "CP_FAILED");
+      throw a instanceof o ? a : new o(`Failed to copy from ${t} to ${e}`, "CP_FAILED", void 0, a);
     }
   }
   /**
    * Start watching a file or directory for changes
+   * 
+   * @param path - The path to watch (minimatch syntax allowed)
+   * @param options - Watch options
+   * @param options.recursive - Whether to watch recursively (default: true)
+   * @param options.exclude - Glob pattern(s) to exclude (minimatch).
+   * @returns Promise that resolves when watching starts
+   * 
+   * @example
+   * ```typescript
+   * // Watch entire directory tree recursively (default)
+   * await fs.watch('/data');
+   * 
+   * // Watch only immediate children (shallow)
+   * await fs.watch('/data', { recursive: false });
+   * 
+   * // Watch a single file
+   * await fs.watch('/config.json', { recursive: false });
+   * 
+   * // Watch all json files but not in dist directory
+   * await fs.watch('/**\/*.json', { recursive: false, exclude: ['dist/**'] });
+   *
+   * ```
    */
-  async watch(t) {
-    await this.ensureMounted();
-    const e = u(t), i = await this.buildSnapshot(e);
-    this.watchers.set(e, i), this.watchTimer || (this.watchTimer = setInterval(() => {
-      this.scanWatches();
-    }, this.options.watchInterval));
+  async watch(t, e) {
+    if (!this.options.broadcastChannel)
+      throw new o("This instance is not configured to send events. Please specify options.broadcastChannel to enable watching.", "ENOENT");
+    const i = {
+      pattern: H(t, e?.recursive ?? !0),
+      include: Array.isArray(e?.include) ? e.include : [e?.include ?? "**"],
+      exclude: Array.isArray(e?.exclude) ? e.exclude : [e?.exclude ?? ""]
+    };
+    this.watchers.set(t, i);
   }
   /**
    * Stop watching a previously watched path
    */
   unwatch(t) {
-    const e = u(t);
-    this.watchers.delete(e), this.watchers.size === 0 && this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null);
+    this.watchers.delete(t);
   }
   /**
    * Dispose of resources and clean up the file system instance
@@ -674,49 +662,7 @@ class A {
    * to properly clean up resources like the broadcast channel and watch timers.
    */
   dispose() {
-    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchTimer && (clearInterval(this.watchTimer), this.watchTimer = null), this.watchers.clear();
-  }
-  async buildSnapshot(t) {
-    const e = /* @__PURE__ */ new Map(), i = async (a) => {
-      const r = await this.stat(a);
-      if (e.set(a, r), r.isDirectory) {
-        const s = await this.readDir(a);
-        for (const o of s) {
-          const c = `${a === "/" ? "" : a}/${o.name}`;
-          await i(c);
-        }
-      }
-    };
-    return await i(t), e;
-  }
-  async scanWatches() {
-    if (!this.scanning) {
-      this.scanning = !0;
-      try {
-        await Promise.all(
-          [...this.watchers.entries()].map(async ([t, e]) => {
-            let i;
-            try {
-              i = await this.buildSnapshot(t);
-            } catch {
-              i = /* @__PURE__ */ new Map();
-            }
-            for (const [a, r] of i) {
-              const s = e.get(a);
-              s ? (s.mtime !== r.mtime || s.size !== r.size) && await this.notifyChange({ path: a, type: "changed", isDirectory: r.isDirectory }) : await this.notifyChange({ path: a, type: "added", isDirectory: r.isDirectory });
-            }
-            for (const a of e.keys())
-              if (!i.has(a)) {
-                const r = e.get(a);
-                await this.notifyChange({ path: a, type: "removed", isDirectory: r?.isDirectory ?? !1 });
-              }
-            this.watchers.set(t, i);
-          })
-        );
-      } finally {
-        this.scanning = !1;
-      }
-    }
+    this.broadcastChannel && (this.broadcastChannel.close(), this.broadcastChannel = null), this.watchers.clear();
   }
   /**
    * Synchronize the file system with external data
@@ -747,22 +693,21 @@ class A {
    * ```
    */
   async sync(t, e) {
-    await this.ensureMounted();
+    await this.mount();
     try {
       (e?.cleanBefore ?? !1) && await this.clear("/");
       for (const [a, r] of t) {
-        const s = u(a);
-        let o;
-        r instanceof Blob ? o = await b(r) : o = r, await this.writeFile(s, o);
+        const s = y(a);
+        let n;
+        r instanceof Blob ? n = await O(r) : n = r, await this.writeFile(s, n);
       }
-      await this.notifyChange({ path: "/", type: "changed", isDirectory: !0 });
     } catch (i) {
-      throw i instanceof n ? i : new n("Failed to sync file system", "SYNC_FAILED");
+      throw i instanceof o ? i : new o("Failed to sync file system", "SYNC_FAILED", void 0, i);
     }
   }
 }
-typeof self < "u" && self.constructor.name === "DedicatedWorkerGlobalScope" && p(new A());
+typeof globalThis < "u" && globalThis.constructor.name === "DedicatedWorkerGlobalScope" && E(new $());
 export {
-  A as OPFSWorker
+  $ as OPFSWorker
 };
 //# sourceMappingURL=raw.js.map