bare-module 2.5.1 → 2.5.3

package/binding.c

@@ -596,66 +596,27 @@ err:
 
 static js_value_t *
 init (js_env_t *env, js_value_t *exports) {
-  {
-    js_value_t *fn;
-    js_create_function(env, "init", -1, bare_module_init, NULL, &fn);
-    js_set_named_property(env, exports, "init", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "destroy", -1, bare_module_destroy, NULL, &fn);
-    js_set_named_property(env, exports, "destroy", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "createFunction", -1, bare_module_create_function, NULL, &fn);
-    js_set_named_property(env, exports, "createFunction", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "createModule", -1, bare_module_create_module, NULL, &fn);
-    js_set_named_property(env, exports, "createModule", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "createSyntheticModule", -1, bare_module_create_synthetic_module, NULL, &fn);
-    js_set_named_property(env, exports, "createSyntheticModule", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "deleteModule", -1, bare_module_delete_module, NULL, &fn);
-    js_set_named_property(env, exports, "deleteModule", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "setExport", -1, bare_module_set_export, NULL, &fn);
-    js_set_named_property(env, exports, "setExport", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "runModule", -1, bare_module_run_module, NULL, &fn);
-    js_set_named_property(env, exports, "runModule", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "getNamespace", -1, bare_module_get_namespace, NULL, &fn);
-    js_set_named_property(env, exports, "getNamespace", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "exists", -1, bare_module_exists, NULL, &fn);
-    js_set_named_property(env, exports, "exists", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "realpath", -1, bare_module_realpath, NULL, &fn);
-    js_set_named_property(env, exports, "realpath", fn);
-  }
-  {
-    js_value_t *fn;
-    js_create_function(env, "read", -1, bare_module_read, NULL, &fn);
-    js_set_named_property(env, exports, "read", fn);
+#define V(name, fn) \
+  { \
+    js_value_t *val; \
+    js_create_function(env, name, -1, fn, NULL, &val); \
+    js_set_named_property(env, exports, name, val); \
   }
+  V("init", bare_module_init)
+  V("destroy", bare_module_destroy)
+
+  V("createFunction", bare_module_create_function)
+  V("createModule", bare_module_create_module)
+  V("createSyntheticModule", bare_module_create_synthetic_module)
+  V("deleteModule", bare_module_delete_module)
+  V("setExport", bare_module_set_export)
+  V("runModule", bare_module_run_module)
+  V("getNamespace", bare_module_get_namespace)
+
+  V("exists", bare_module_exists)
+  V("realpath", bare_module_realpath)
+  V("read", bare_module_read)
+#undef V
 
   return exports;
 }

package/index.js

@@ -17,21 +17,13 @@ const Module = module.exports = exports = class Module {
     this._exports = null
     this._imports = null
     this._builtins = null
-    this._info = null
+    this._conditions = null
     this._protocol = null
     this._handle = null
 
     Module._modules.add(this)
   }
 
-  get type () {
-    return this._type
-  }
-
-  get defaultType () {
-    return this._defaultType
-  }
-
   get filename () {
     return this._filename
   }
@@ -40,6 +32,14 @@ const Module = module.exports = exports = class Module {
     return path.dirname(this._filename)
   }
 
+  get type () {
+    return this._type
+  }
+
+  get defaultType () {
+    return this._defaultType
+  }
+
   get main () {
     return this._main
   }
@@ -52,6 +52,18 @@ const Module = module.exports = exports = class Module {
     this._exports = value
   }
 
+  get imports () {
+    return this._imports
+  }
+
+  get builtins () {
+    return this._builtins
+  }
+
+  get conditions () {
+    return Array.from(this._conditions)
+  }
+
   get protocol () {
     return this._protocol
   }
@@ -81,12 +93,15 @@ const Module = module.exports = exports = class Module {
     return {
       __proto__: { constructor: Module },
 
-      type: this.type,
-      defaultType: this.defaultType,
       filename: this.filename,
       dirname: this.dirname,
+      type: this.type,
+      defaultType: this.defaultType,
       main: this.main,
-      exports: this.exports
+      exports: this.exports,
+      imports: this.imports,
+      builtins: this.builtins,
+      conditions: this.conditions
     }
   }
 
@@ -95,24 +110,19 @@ const Module = module.exports = exports = class Module {
   static _cache = Object.create(null)
   static _bundles = Object.create(null)
   static _modules = new Set()
+  static _conditions = ['import', 'require', 'bare', 'node']
 
   static _handle = binding.init(this, this._onimport, this._onevaluate, this._onmeta)
 
   static _onimport (specifier, assertions, referrerFilename, dynamic) {
     const referrer = this._cache[referrerFilename]
 
-    let protocol
+    const protocol = this._protocolFor(specifier, referrer._protocol)
 
-    if (referrer) {
-      protocol = this._protocolFor(specifier, referrer._protocol)
-
-      specifier = this.resolve(specifier, path.dirname(referrer._filename), {
-        protocol,
-        referrer
-      })
-    } else {
-      specifier = this.resolve(specifier)
-    }
+    specifier = this.resolve(specifier, path.dirname(referrer._filename), {
+      protocol,
+      referrer
+    })
 
     let type
 
@@ -146,29 +156,31 @@ const Module = module.exports = exports = class Module {
   }
 
   static _onmeta (specifier, meta) {
+    const self = Module
+
     const module = this._cache[specifier]
 
     const referrer = module
     const dirname = path.dirname(module._filename)
 
-    const resolve = (specifier) => {
-      return this.resolve(specifier, dirname, {
-        protocol: this._protocolFor(specifier, module._protocol),
+    meta.url = module._filename
+    meta.main = module._main === module
+    meta.resolve = resolve
+    meta.addon = addon
+
+    function resolve (specifier) {
+      return self.resolve(specifier, dirname, {
+        protocol: self._protocolFor(specifier, module._protocol),
         imports: module._imports,
         referrer
       })
     }
 
-    const addon = (specifier = '.') => {
+    function addon (specifier = '.') {
       return Bare.Addon.load(Bare.Addon.resolve(specifier, dirname, {
         referrer
       }))
     }
-
-    meta.url = module._filename
-    meta.main = module._main === module
-    meta.resolve = resolve
-    meta.addon = addon
   }
 
   static Protocol = Protocol
@@ -179,57 +191,77 @@ const Module = module.exports = exports = class Module {
     return this._cache
   }
 
+  // For Node.js compatibility
+  static get builtinModules () {
+    return []
+  }
+
+  // For Node.js compatibility
+  static isBuiltin () {
+    return false
+  }
+
   static createRequire (filename, opts = {}) {
-    const {
-      imports = null,
-      builtins = null,
-      protocol = this._protocolFor(filename, this._protocols['file:']),
-      type = constants.types.SCRIPT,
-      defaultType = constants.types.SCRIPT
+    const self = Module
+
+    let {
+      referrer = null,
+      protocol = self._protocolFor(filename, referrer ? referrer._protocol : self._protocols['file:']),
+      imports = referrer ? referrer._imports : null,
+      builtins = referrer ? referrer._builtins : null,
+      conditions = referrer ? referrer._conditions : self._conditions,
+      main = referrer ? referrer._main : null,
+      defaultType = referrer ? referrer._defaultType : constants.types.SCRIPT,
+      type = constants.types.SCRIPT
     } = opts
 
     const module = new Module(filename)
 
+    module._main = main || module
     module._type = type
     module._defaultType = defaultType
+    module._protocol = protocol
     module._imports = imports
     module._builtins = builtins
-    module._protocol = protocol
+    module._conditions = conditions
+
+    referrer = module
 
-    const referrer = module
     const dirname = path.dirname(module._filename)
 
-    const resolve = (specifier) => {
-      return this.resolve(specifier, dirname, {
-        protocol: this._protocolFor(specifier, protocol),
+    require.main = module._main
+    require.cache = self._cache
+    require.resolve = resolve
+    require.addon = addon
+
+    return require
+
+    function require (specifier) {
+      const module = self.load(resolve(specifier), {
+        protocol: self._protocolFor(specifier, protocol),
         referrer
       })
+
+      return module._exports
     }
 
-    const require = (specifier) => {
-      const module = this.load(resolve(specifier), {
-        protocol: this._protocolFor(specifier, protocol),
+    function resolve (specifier) {
+      return self.resolve(specifier, dirname, {
+        protocol: self._protocolFor(specifier, protocol),
         referrer
       })
-
-      return module._exports
     }
 
-    const addon = (specifier = '.') => {
+    function addon (specifier = '.') {
       return Bare.Addon.load(Bare.Addon.resolve(specifier, dirname, {
         referrer
       }))
     }
-
-    require.main = module._main
-    require.cache = this._cache
-    require.resolve = resolve
-    require.addon = addon
-
-    return require
   }
 
   static load (specifier, source = null, opts = {}) {
+    const self = Module
+
     if (!ArrayBuffer.isView(source) && typeof source !== 'string' && source !== null) {
       opts = source
       source = null
@@ -238,23 +270,24 @@ const Module = module.exports = exports = class Module {
     let {
       dynamic = false,
       referrer = null,
-      protocol = this._protocolFor(specifier, referrer ? referrer._protocol : this._protocols['file:']),
+      protocol = self._protocolFor(specifier, referrer ? referrer._protocol : self._protocols['file:']),
       imports = referrer ? referrer._imports : null,
       builtins = referrer ? referrer._builtins : null,
+      conditions = referrer ? referrer._conditions : self._conditions,
       main = referrer ? referrer._main : null,
       defaultType = referrer ? referrer._defaultType : 0,
       type = 0
     } = opts
 
-    if (this._cache[specifier]) return this._transform(this._cache[specifier], referrer, dynamic)
+    if (self._cache[specifier]) return self._transform(self._cache[specifier], referrer, dynamic)
 
-    const bundle = this._bundleFor(path.dirname(specifier), protocol)
+    const bundle = self._bundleFor(path.dirname(specifier), protocol)
 
     if (bundle) {
       protocol = new Protocol({
         imports: bundle.imports,
 
-        preresolve: this._protocols['file:'].preresolve,
+        preresolve: self._protocols['file:'].preresolve,
 
         exists (filename) {
           return bundle.exists(filename)
@@ -266,7 +299,7 @@ const Module = module.exports = exports = class Module {
       })
     }
 
-    const module = this._cache[specifier] = new this(specifier)
+    const module = self._cache[specifier] = new Module(specifier)
 
     if (builtins && specifier in builtins) {
       module._exports = builtins[specifier]
@@ -276,12 +309,12 @@ const Module = module.exports = exports = class Module {
       module._protocol = protocol
       module._imports = imports
       module._builtins = builtins
-      module._info = this._loadPackageManifest(path.dirname(module._filename), protocol)
+      module._conditions = conditions
 
-      let extension = this._extensionFor(type) || path.extname(specifier)
+      let extension = self._extensionFor(type) || path.extname(specifier)
 
-      if (extension in this._extensions === false) {
-        if (defaultType) extension = this._extensionFor(defaultType) || '.js'
+      if (extension in self._extensions === false) {
+        if (defaultType) extension = self._extensionFor(defaultType) || '.js'
         else extension = '.js'
       }
 
@@ -289,36 +322,15 @@ const Module = module.exports = exports = class Module {
         throw errors.INVALID_BUNDLE_EXTENSION(`Invalid extension for bundle '${specifier}'`)
       }
 
-      this._extensions[extension].call(this, module, source, referrer)
+      self._extensions[extension](module, source, referrer)
     }
 
-    return this._transform(module, referrer, dynamic)
-  }
-
-  static _loadPackageManifest (dirname, protocol, opts = {}) {
-    const {
-      traverse = true
-    } = opts
-
-    do {
-      const specifier = path.join(dirname, 'package.json')
-
-      if (this._cache[specifier]) return this._cache[specifier]._exports
-
-      if (protocol.exists(specifier)) {
-        try {
-          return this.load(specifier, { protocol })._exports
-        } catch {}
-      }
-
-      if (traverse) dirname = path.dirname(dirname)
-      else break
-    } while (dirname !== path.sep && dirname !== '.')
-
-    return {}
+    return self._transform(module, referrer, dynamic)
   }
 
   static resolve (specifier, dirname = os.cwd(), opts = {}) {
+    const self = Module
+
     if (typeof dirname !== 'string') {
       opts = dirname
       dirname = os.cwd()
@@ -326,19 +338,19 @@ const Module = module.exports = exports = class Module {
 
     let {
       referrer = null,
-      protocol = referrer ? referrer._protocol : this._protocols['file:'],
+      protocol = referrer ? referrer._protocol : self._protocols['file:'],
       imports = referrer ? referrer._imports : null,
       builtins = referrer ? referrer._builtins : null,
-      conditions = ['import', 'require', 'bare', 'node']
+      conditions = referrer ? referrer._conditions : self._conditions
     } = opts
 
-    const bundle = this._bundleFor(path.dirname(specifier), protocol)
+    const bundle = self._bundleFor(path.dirname(specifier), protocol)
 
     if (bundle) {
       protocol = new Protocol({
         imports: bundle.imports,
 
-        preresolve: this._protocols['file:'].preresolve,
+        preresolve: self._protocols['file:'].preresolve,
 
         exists (filename) {
           return bundle.exists(filename)
@@ -350,7 +362,7 @@ const Module = module.exports = exports = class Module {
       })
     }
 
-    const [resolved = null] = this._resolve(specifier, dirname, protocol, imports, builtins, conditions)
+    const [resolved = null] = self._resolve(specifier, dirname, protocol, imports, builtins, conditions)
 
     if (resolved === null) {
       let msg = `Cannot find module '${specifier}'`
@@ -363,29 +375,64 @@ const Module = module.exports = exports = class Module {
     return protocol.postresolve(resolved, dirname)
   }
 
+  static _loadPackageManifest (dirname, protocol, opts = {}) {
+    const {
+      traverse = true
+    } = opts
+
+    do {
+      const specifier = path.join(dirname, 'package.json')
+
+      if (this._cache[specifier]) return this._cache[specifier]
+
+      if (protocol.exists(specifier)) {
+        try {
+          return this.load(specifier, { protocol })
+        } catch {}
+      }
+
+      if (traverse) dirname = path.dirname(dirname)
+      else break
+    } while (dirname !== path.sep && dirname !== '.')
+
+    return null
+  }
+
   static * _resolve (specifier, dirname, protocol, imports, builtins, conditions) {
-    const info = this._loadPackageManifest(dirname, protocol)
+    const pkg = this._loadPackageManifest(dirname, protocol)
 
-    specifier = this._mapConditionalSpecifier(
-      specifier,
-      conditions,
-      [imports, protocol.imports, info.imports]
-    )
+    const info = (pkg && pkg._exports) || {}
 
-    protocol = this._protocolFor(specifier, protocol)
+    let resolved = specifier
 
-    specifier = protocol.preresolve(specifier, dirname)
+    if (info.imports) {
+      resolved = this._mapConditionalSpecifier(resolved, conditions, info.imports)
 
-    yield * protocol.resolve(specifier, dirname, imports)
+      if (resolved) dirname = path.dirname(pkg._filename)
+    }
 
-    if (builtins && specifier in builtins) yield specifier
+    if (protocol.imports) {
+      resolved = this._mapConditionalSpecifier(resolved, conditions, protocol.imports) || resolved
+    }
 
-    if (path.isAbsolute(specifier)) {
-      yield * this._resolveFile(specifier, protocol)
-      yield * this._resolveDirectory(specifier, protocol, conditions)
+    if (imports) {
+      resolved = this._mapConditionalSpecifier(resolved, conditions, imports) || resolved
     }
 
-    yield * this._resolveNodeModules(specifier, dirname, protocol, conditions)
+    protocol = this._protocolFor(resolved, protocol)
+
+    resolved = protocol.preresolve(resolved, dirname)
+
+    yield * protocol.resolve(resolved, dirname, imports)
+
+    if (builtins && resolved in builtins) yield resolved
+
+    if (path.isAbsolute(resolved)) {
+      yield * this._resolveFile(resolved, protocol)
+      yield * this._resolveDirectory(resolved, protocol, conditions)
+    }
+
+    yield * this._resolveNodeModules(resolved, dirname, protocol, conditions)
   }
 
   static * _resolveFile (filename, protocol) {
@@ -408,27 +455,24 @@ const Module = module.exports = exports = class Module {
   }
 
   static * _resolveDirectory (dirname, protocol, conditions) {
-    const info = this._loadPackageManifest(dirname, protocol, { traverse: false })
+    const pkg = this._loadPackageManifest(dirname, protocol, { traverse: false })
 
-    let specifier = null
+    const info = (pkg && pkg._exports) || {}
+
+    let resolved = null
 
     if (info.exports) {
-      specifier = this._mapConditionalSpecifier(
-        '.',
-        conditions,
-        [info.exports],
-        null // Disable fallback
-      )
-
-      if (specifier) specifier = path.join(dirname, specifier)
+      resolved = this._mapConditionalSpecifier('.', conditions, info.exports)
+
+      if (resolved) resolved = path.join(dirname, resolved)
       else return // Unexported
     } else if (info.main) {
-      specifier = path.join(dirname, info.main)
+      resolved = path.join(dirname, info.main)
     }
 
-    if (specifier) {
-      yield * this._resolveFile(specifier, protocol)
-      yield * this._resolveIndex(specifier, protocol)
+    if (resolved) {
+      yield * this._resolveFile(resolved, protocol)
+      yield * this._resolveIndex(resolved, protocol)
     }
 
     yield * this._resolveIndex(dirname, protocol)
@@ -441,15 +485,12 @@ const Module = module.exports = exports = class Module {
       let resolved = specifier
 
       if (name) {
-        const info = this._loadPackageManifest(path.join(nodeModules, name), protocol, { traverse: false })
+        const pkg = this._loadPackageManifest(path.join(nodeModules, name), protocol, { traverse: false })
+
+        const info = (pkg && pkg._exports) || {}
 
         if (info.exports) {
-          resolved = this._mapConditionalSpecifier(
-            expansion,
-            conditions,
-            [info.exports],
-            null // Disable fallback
-          )
+          resolved = this._mapConditionalSpecifier(expansion, conditions, info.exports)
 
           if (resolved) resolved = path.join(name, resolved)
           else return // Unexported
@@ -475,16 +516,16 @@ const Module = module.exports = exports = class Module {
     }
   }
 
-  static _mapConditionalSpecifier (specifier, conditions, specifierMaps, fallback = specifier) {
-    const specifiers = this._flattenSpecifierMaps(specifierMaps)
+  static _mapConditionalSpecifier (specifier, conditions, specifierMap) {
+    if (typeof specifierMap === 'string') specifierMap = { '.': specifierMap }
 
-    if (specifier in specifiers) {
-      specifier = search(specifiers[specifier])
+    if (specifier in specifierMap) {
+      specifier = search(specifierMap[specifier])
     } else {
-      specifier = search(specifiers)
+      specifier = search(specifierMap)
     }
 
-    return specifier || fallback
+    return specifier
 
     function search (specifiers) {
       while (true) {
@@ -506,24 +547,6 @@ const Module = module.exports = exports = class Module {
     }
   }
 
-  static _flattenSpecifierMaps (specifierMaps) {
-    const specifiers = Object.create(null)
-
-    for (let map of specifierMaps) {
-      if (typeof map === 'string') map = { '.': map }
-      if (map === null || typeof map !== 'object') continue
-
-      this._mergeSpecifierMaps(specifiers, map)
-    }
-
-    return specifiers
-  }
-
-  static _mergeSpecifierMaps (destination, source) {
-    // TODO Do a deep merge
-    Object.assign(destination, source)
-  }
-
   static _extensionFor (type) {
     switch (type) {
       case constants.types.SCRIPT:
@@ -602,11 +625,11 @@ const Module = module.exports = exports = class Module {
 
   static _transform (module, referrer = null, dynamic = false) {
     if (dynamic) {
-      if (module._type !== constants.types.MODULE) this._synthesize(module)
+      this._synthesize(module)
       this._evaluate(module)
     } else if (referrer) {
       if (referrer._type === constants.types.MODULE) {
-        if (module._type !== constants.types.MODULE) this._synthesize(module)
+        this._synthesize(module)
       } else if (module._type === constants.types.MODULE) {
         this._evaluate(module)
       }
@@ -632,36 +655,46 @@ const Module = module.exports = exports = class Module {
   static _synthesize (module) {
     if ((module._state & constants.states.SYNTHESIZED) !== 0) return
 
-    const names = ['default']
+    if (module._type !== constants.types.MODULE) {
+      const names = ['default']
 
-    for (const key of Object.keys(module._exports)) {
-      if (key !== 'default') names.push(key)
-    }
+      for (const key of Object.keys(module._exports)) {
+        if (key !== 'default') names.push(key)
+      }
 
-    module._handle = binding.createSyntheticModule(module._filename, names, this._handle)
+      module._handle = binding.createSyntheticModule(module._filename, names, this._handle)
+    }
 
     module._state |= constants.states.SYNTHESIZED
   }
 }
 
 Module._extensions['.js'] = function (module, source, referrer) {
+  const self = Module
+
+  const protocol = module._protocol
+
+  const pkg = self._loadPackageManifest(path.dirname(module._filename), protocol)
+
+  const info = (pkg && pkg._exports) || {}
+
   const isESM = (
     // The default type is ES modules.
-    (module._defaultType === constants.types.MODULE) ||
+    (constants.types.MODULE === module._defaultType) ||
 
     // The package is explicitly declared as an ES module.
-    (module._info && module._info.type === 'module') ||
+    (info && info.type === 'module') ||
 
     // The source is a data: URI and the referrer is itself an ES module.
-    (module._protocol === this._protocols['data:'] && referrer && referrer._type === constants.types.MODULE)
+    (protocol === self._protocols['data:'] && referrer && referrer._type === constants.types.MODULE)
   )
 
-  const loader = this._extensions[isESM ? '.mjs' : '.cjs']
-
-  return loader.call(this, module, source, referrer)
+  return self._extensions[isESM ? '.mjs' : '.cjs'](module, source, referrer)
 }
 
 Module._extensions['.cjs'] = function (module, source, referrer) {
+  const self = Module
+
   const protocol = module._protocol
 
   module._type = constants.types.SCRIPT
@@ -677,30 +710,8 @@ Module._extensions['.cjs'] = function (module, source, referrer) {
 
     const dirname = path.dirname(module._filename)
 
-    const resolve = (specifier) => {
-      return this.resolve(specifier, dirname, {
-        protocol: this._protocolFor(specifier, protocol),
-        referrer
-      })
-    }
-
-    const require = (specifier) => {
-      const module = this.load(resolve(specifier), {
-        protocol: this._protocolFor(specifier, protocol),
-        referrer
-      })
-
-      return module._exports
-    }
-
-    const addon = (specifier = '.') => {
-      return Bare.Addon.load(Bare.Addon.resolve(specifier, dirname, {
-        referrer
-      }))
-    }
-
     require.main = module._main
-    require.cache = this._cache
+    require.cache = self._cache
     require.resolve = resolve
     require.addon = addon
 
@@ -713,10 +724,34 @@ Module._extensions['.cjs'] = function (module, source, referrer) {
       module._filename,
       path.dirname(module._filename)
     )
+
+    function require (specifier) {
+      const module = self.load(resolve(specifier), {
+        protocol: self._protocolFor(specifier, protocol),
+        referrer
+      })
+
+      return module._exports
+    }
+
+    function resolve (specifier) {
+      return self.resolve(specifier, dirname, {
+        protocol: self._protocolFor(specifier, protocol),
+        referrer
+      })
+    }
+
+    function addon (specifier = '.') {
+      return Bare.Addon.load(Bare.Addon.resolve(specifier, dirname, {
+        referrer
+      }))
+    }
   }
 }
 
 Module._extensions['.mjs'] = function (module, source, referrer) {
+  const self = Module
+
   const protocol = module._protocol
 
   module._type = constants.types.MODULE
@@ -728,7 +763,7 @@ Module._extensions['.mjs'] = function (module, source, referrer) {
 
     if (typeof source !== 'string') source = Buffer.coerce(source).toString()
 
-    module._handle = binding.createModule(module._filename, source, 0, this._handle)
+    module._handle = binding.createModule(module._filename, source, 0, self._handle)
   }
 }
 
@@ -761,6 +796,8 @@ Module._extensions['.node'] = function (module, source, referrer) {
 }
 
 Module._extensions['.bundle'] = function (module, source, referrer) {
+  const self = Module
+
   const protocol = module._protocol
 
   module._type = constants.types.BUNDLE
@@ -769,16 +806,16 @@ Module._extensions['.bundle'] = function (module, source, referrer) {
 
   if (typeof source === 'string') source = Buffer.from(source)
 
-  const bundle = this._bundleFor(module._filename, protocol, source)
+  const bundle = self._bundleFor(module._filename, protocol, source)
 
-  module._exports = this.load(bundle.main, bundle.read(bundle.main), { protocol, referrer })._exports
+  module._exports = self.load(bundle.main, bundle.read(bundle.main), { protocol, referrer })._exports
 }
 
 Module._protocols['file:'] = new Protocol({
   preresolve (specifier, dirname) {
     specifier = specifier.replace(/^file:/, '')
 
-    if (specifier[0] === '.') specifier = path.join(dirname, specifier)
+    if (/^\.(\/|\\)/.test(specifier)) specifier = path.join(dirname, specifier)
     else if (path.isAbsolute(specifier)) specifier = path.normalize(specifier)
 
     return specifier

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-module",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Module support for JavaScript",
   "main": "index.js",
   "files": [