Use more maps.

Author: jdalton

esm.js

@@ -161,12 +161,13 @@ shared = loadESM()
 if (cachePath !== "") {
   const { dir } = shared.package
 
-  if (! has(dir, cachePath)) {
-    dir[cachePath] = {
+  let cache = dir.get(cachePath)
+
+  if (cache === void 0) {
+    cache = {
       buffer: cachedData,
-      compile: {
-        __proto__: null,
-        esm: {
+      compile: new Map([
+        ["esm", {
           circular: 0,
           code: null,
           codeWithTDZ: null,
@@ -177,16 +178,24 @@ if (cachePath !== "") {
           sourceType: 1,
           transforms: 0,
           yieldIndex: -1
-        }
-      },
-      map: { __proto__: null }
+        }]
+      ]),
+      meta: new Map
     }
+
+    dir.set(cachePath, cache)
   }
 
-  shared.pendingScripts[cachePath] = {
-    __proto__: null,
-    esm: script
+  const { pendingScripts } = shared
+
+  let scripts = pendingScripts.get(cachePath)
+
+  if (scripts === void 0) {
+    scripts = new Map
+    pendingScripts.set(cachePath, scripts)
   }
+
+  scripts.set("esm", script)
 }
 
 // The legacy symbol used for `esm` export detection.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "esm",
-  "version": "3.2.5",
+  "version": "3.2.6-pre",
   "description": "Tomorrow's ECMAScript modules today!",
   "keywords": "commonjs, ecmascript, export, import, modules, node, require",
   "repository": "standard-things/esm",

package.json

@@ -49,10 +49,10 @@ function init() {
       return compile(code, options)
     },
     from(entry) {
-      const { cache, cachePath } = entry.package
+      const pkg = entry.package
+      const { cache } = pkg
       const { cacheName } = entry
-      const { map } = cache
-      const meta = map[cacheName]
+      const meta = cache.meta.get(cacheName)
 
       if (meta === void 0) {
         return null
@@ -88,7 +88,7 @@ function init() {
         let filename = meta[6]
 
         if (filename) {
-          filename = resolve(cachePath, filename)
+          filename = resolve(pkg.cachePath, filename)
         }
 
         result.filename = filename
@@ -113,7 +113,7 @@ function init() {
       }
 
       entry.compileData = result
-      cache.compile[cacheName] = result
+      cache.compile.set(cacheName, result)
 
       return result
     }
@@ -143,11 +143,15 @@ function init() {
 
     const { pendingWrites } = shared
 
-    if (! Reflect.has(pendingWrites, cachePath)) {
-      pendingWrites[cachePath] = { __proto__: null }
+    let compileDatas = pendingWrites.get(cachePath)
+
+    if (compileDatas === void 0) {
+      compileDatas = new Map
+      pendingWrites.set(cachePath, compileDatas)
     }
 
-    pendingWrites[cachePath][cacheName] = result
+    compileDatas.set(cacheName, result)
+
     return result
   }
 
@@ -157,12 +161,11 @@ function init() {
     const { pendingScripts, pendingWrites } = shared
     const { dir } = shared.package
 
-    for (const cachePath in dir) {
+    dir.forEach((cache, cachePath) => {
       if (cachePath === "") {
-        continue
+        return
       }
 
-      const cache = dir[cachePath]
       const noCacheDir = ! mkdirp(cachePath)
 
       let { dirty } = cache
@@ -179,39 +182,37 @@ function init() {
 
       if (dirty ||
           noCacheDir) {
-        Reflect.deleteProperty(dir, cachePath)
-        Reflect.deleteProperty(pendingScripts, cachePath)
-        Reflect.deleteProperty(pendingWrites, cachePath)
+        dir.delete(cachePath)
+        pendingScripts.delete(cachePath)
+        pendingWrites.delete(cachePath)
       }
 
       if (noCacheDir) {
-        continue
+        return
       }
 
       if (dirty) {
         writeMarker(cachePath + sep + ".dirty")
         removeFile(cachePath + sep + ".data.blob")
         removeFile(cachePath + sep + ".data.json")
 
-        for (const cacheName in cache.compile) {
+        cache.compile.forEach((compileData, cacheName) => {
           removeFile(cachePath + sep + cacheName)
-        }
+        })
       }
-    }
+    })
 
-    const pendingScriptDatas = { __proto__: null }
+    const pendingScriptDatas = new Map
     const useCreateCachedData = shared.support.createCachedData
 
-    for (const cachePath in pendingScripts) {
-      const cache = dir[cachePath]
+    pendingScripts.forEach((scripts, cachePath) => {
+      const cache = dir.get(cachePath)
       const compileDatas = cache.compile
-      const { map } = cache
-      const scripts = pendingScripts[cachePath]
+      const metas = cache.meta
 
-      for (const cacheName in scripts) {
-        const compileData = compileDatas[cacheName]
-        const cachedData = compileData ? compileData.scriptData : null
-        const script = scripts[cacheName]
+      scripts.forEach((script, cacheName) => {
+        const compileData = compileDatas.get(cacheName)
+        const cachedData = compileData != null ? compileData.scriptData : null
 
         let scriptData
         let changed = false
@@ -234,7 +235,7 @@ function init() {
                      script.cachedDataRejected) {
             changed = true
 
-            const meta = map[cacheName]
+            const meta = metas.get(cacheName)
 
             if (meta !== void 0) {
               meta[0] = -1
@@ -248,33 +249,35 @@ function init() {
 
         if (changed &&
             cacheName !== "") {
-          if (! Reflect.has(pendingScriptDatas, cachePath)) {
-            pendingScriptDatas[cachePath] = { __proto__: null }
+          let scriptDatas = pendingScriptDatas.get(cachePath)
+
+          if (scriptDatas === void 0) {
+            scriptDatas = new Map
+            pendingScriptDatas.set(cachePath, scriptDatas)
           }
 
-          pendingScriptDatas[cachePath][cacheName] = scriptData
+          scriptDatas.set(cacheName, scriptData)
         }
-      }
-    }
+      })
+    })
 
-    for (const cachePath in pendingScriptDatas) {
-      const cache = dir[cachePath]
-      const { buffer, map } = cache
+    pendingScriptDatas.forEach((scriptDatas, cachePath) => {
+      const cache = dir.get(cachePath)
       const compileDatas = cache.compile
-      const scriptDatas = pendingScriptDatas[cachePath]
+      const metas = cache.meta
 
-      for (const cacheName in scriptDatas) {
-        let meta = map[cacheName]
+      scriptDatas.forEach((scriptData, cacheName) => {
+        let meta = metas.get(cacheName)
 
         if (meta !== void 0) {
-          continue
+          return
         }
 
         meta = [-1, -1]
 
-        const compileData = compileDatas[cacheName]
+        const compileData = compileDatas.get(cacheName)
 
-        if (compileData) {
+        if (compileData != null) {
           const {
             filename,
             firstAwaitOutsideFunction,
@@ -315,27 +318,23 @@ function init() {
           }
         }
 
-        map[cacheName] = meta
-      }
+        metas.set(cacheName, meta)
+      })
 
+      const { buffer } = cache
       const buffers = []
+      const jsonMeta = {}
 
       let offset = 0
 
-      for (const cacheName in map) {
-        const meta = map[cacheName]
-
-        if (meta === void 0) {
-          continue
-        }
-
-        const compileData = compileDatas[cacheName]
-        const [offsetStart, offsetEnd] = meta
-
-        let scriptData = scriptDatas[cacheName]
+      metas.forEach((meta, cacheName) => {
+        let scriptData = scriptDatas.get(cacheName)
 
         if (scriptData === void 0) {
-          if (compileData) {
+          const compileData = compileDatas.get(cacheName)
+          const [offsetStart, offsetEnd] = meta
+
+          if (compileData != null) {
             scriptData = compileData.scriptData
           } else if (offsetStart !== -1 &&
                      offsetEnd !== -1) {
@@ -348,40 +347,40 @@ function init() {
           meta[1] = offset += scriptData.length
           buffers.push(scriptData)
         }
-      }
+
+        jsonMeta[cacheName] = meta
+      })
 
       writeFile(cachePath + sep + ".data.blob", GenericBuffer.concat(buffers))
       writeFile(cachePath + sep + ".data.json", JSON.stringify({
-        map,
+        meta: jsonMeta,
         version: PACKAGE_VERSION
       }))
-    }
-
-    for (const cachePath in pendingWrites) {
-      const contents = pendingWrites[cachePath]
-
-      for (const cacheName in contents) {
-        const { code } = contents[cacheName]
+    })
 
+    pendingWrites.forEach((compileDatas, cachePath) => {
+      compileDatas.forEach(({ code }, cacheName) => {
         if (writeFile(cachePath + sep + cacheName, code)) {
           removeExpired(cachePath, cacheName)
         }
-      }
-    }
+      })
+    })
   }
 
   function removeExpired(cachePath, cacheName) {
-    const cache = shared.package.dir[cachePath]
+    const cache = shared.package.dir.get(cachePath)
+    const compileDatas = cache.compile
+    const metas = cache.meta
     const pathHash = getCachePathHash(cacheName)
 
-    for (const otherCacheName in cache) {
+    compileDatas.forEach((compileData, otherCacheName) => {
       if (otherCacheName !== cacheName &&
           otherCacheName.startsWith(pathHash)) {
-        Reflect.deleteProperty(cache.compile, otherCacheName)
-        Reflect.deleteProperty(cache.map, otherCacheName)
+        compileDatas.delete(otherCacheName)
+        metas.delete(otherCacheName)
         removeFile(cachePath + sep + otherCacheName)
       }
-    }
+    })
   }
 
   function toCompileOptions(options = {}) {

src/caching-compiler.js

@@ -71,9 +71,11 @@ function hook(vm) {
     const compileDatas = entry.package.cache.compile
     const { runtimeName } = entry
 
-    let compileData = Reflect.has(compileDatas, cacheName)
-      ? compileDatas[cacheName]
-      : null
+    let compileData = compileDatas.get(cacheName)
+
+    if (compileData === void 0) {
+      compileData = null
+    }
 
     if (compileData === null) {
       const compilerOptions = {
@@ -86,7 +88,7 @@ function hook(vm) {
       }
 
       compileData = tryWrapper(CachingCompiler.compile, [content, compilerOptions], content)
-      compileDatas[cacheName] = compileData
+      compileDatas.set(cacheName, compileData)
     } else if (compileData.scriptData !== null &&
                scriptOptions.produceCachedData &&
                ! Reflect.has(scriptOptions, "cachedData")) {

src/hook/vm.js

@@ -113,7 +113,7 @@ function compile(caller, entry, content, filename, fallback) {
       compileData.scriptData = scriptData
 
       entry.compileData = compileData
-      pkg.cache.compile[cacheName] = compileData
+      pkg.cache.compile.set(cacheName, compileData)
 
       if (compileData.sourceType === SOURCE_TYPE_MODULE) {
         entry.type = TYPE_ESM

src/module/internal/compile.js

@@ -127,14 +127,16 @@ const compile = maskFunction(function (content, filename) {
   const script = new realVM.Script(Module.wrap(preparedContent), scriptOptions)
 
   if (cachePath !== "") {
-    const { cacheName } = entry
     const { pendingScripts } = shared
 
-    if (! Reflect.has(pendingScripts, cachePath)) {
-      pendingScripts[cachePath] = { __proto__: null }
+    let scripts = pendingScripts.get(cachePath)
+
+    if (scripts === void 0) {
+      scripts = new Map
+      pendingScripts.set(cachePath, scripts)
     }
 
-    pendingScripts[cachePath][cacheName] = script
+    scripts.set(entry.cacheName, script)
   }
 
   if (useRunInContext === void 0) {