interop-test

ESM-CJS interop test

This project is maintained by JSerFeng

Results by test case

For readablility some shortcuts are applied:

default-export

default-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { default }
import { named as x }

import * as x; x.named		 undefined + errors
import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G] { default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
await import() === require()

import * as x; x === await import()		 false

default-export-esModule

default-export-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], default }
import { named as x }

import * as x; x.named		 undefined + errors
import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G] { [__esModule], default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

default-export-esModule-esm-reexport

default-export-esModule-esm-reexport rspack webpack
import x

import { default as x }

import * as x; x.default

import { named as x }

import * as x; x.named		 undefined + errors undefined + errors
import * as x; ident(x).default

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 undefined undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], [Module] } { [__esModule], [Module] }
import() { __esModule } { [__esModule], [Module] }
import * as x; x === await import() false true

default-export-esm

default-export-esm rspack webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default		 'default' 'default'
import { named as x }

import * as x; x.named		 undefined + errors undefined + errors
import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 undefined undefined
import { __esModule as x }

import * as x; x.__esModule		 true + errors true + errors
import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], default: [G], [Module] } { [__esModule], default: [G], [Module] }
import() { default } { [__esModule], default: [G], [Module] }
import * as x; x === await import() false true

default-export-runtime

default-export-runtime rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G] { default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
await import() === require()

import * as x; x === await import()		 false

named-and-default-export

named-and-default-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-babel-getter

named-and-default-export-babel-getter rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named: [G], default: [G] }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named: [G], default: [G] }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

named-and-default-export-duplicate

named-and-default-export-duplicate rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-esModule

named-and-default-export-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

named-and-default-export-esModule-duplicate

named-and-default-export-esModule-duplicate rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

named-and-default-export-esModule-esm-reexport

named-and-default-export-esModule-esm-reexport rspack webpack
import x

import { default as x }

import * as x; x.default		 undefined + errors undefined + errors
import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default		 undefined undefined
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named' 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], named: [G], [Module] } { [__esModule], named: [G], [Module] }
import() { __esModule, named } { [__esModule], named: [G], [Module] }
import * as x; x === await import() false true

named-and-default-export-esModule-reexport

named-and-default-export-esModule-reexport rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

named-and-default-export-esm

named-and-default-export-esm rspack webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default		 'default' 'default'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named' 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors true + errors
import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], default: [G], named: [G], [Module] } { [__esModule], default: [G], named: [G], [Module] }
import() { default, named } { [__esModule], default: [G], named: [G], [Module] }
import * as x; x === await import() false true

named-and-default-export-esm-esm-reexport

named-and-default-export-esm-esm-reexport rspack webpack
import x

import { default as x }

import * as x; x.default		 undefined + errors undefined + errors
import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default		 undefined undefined
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named' 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors true + errors
import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], named: [G], [Module] } { [__esModule], named: [G], [Module] }
import() { named } { [__esModule], named: [G], [Module] }
import * as x; x === await import() false true

named-and-default-export-esm-reexport

named-and-default-export-esm-reexport rspack webpack
import x

import { default as x }

import * as x; x.default		 undefined + errors undefined + errors
import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default		 undefined undefined
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named' 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors true + errors
import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], named: [G], [Module] } { [__esModule], named: [G], [Module] }
import() { named } { [__esModule], named: [G], [Module] }
import * as x; x === await import() false true

named-and-default-export-getter

named-and-default-export-getter rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [named]: [G], [default]: [G] }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [named]: [G], [default]: [G] }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-getter-esModule

named-and-default-export-getter-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule]: [G: true], [named]: [G], [default]: [G] }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule]: [G: true], [named]: [G], [default]: [G] }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

named-and-default-export-inherited

named-and-default-export-inherited rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-live

named-and-default-export-live rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ named } = require() 'named-outdated'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-non-enumerable

named-and-default-export-non-enumerable rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [named], [default] }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [named], [default] }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-non-enumerable-inherited

named-and-default-export-non-enumerable-inherited rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [named], [default] }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [named], [default] }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-reexport

named-and-default-export-reexport rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-runtime

named-and-default-export-runtime rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-default-export-runtime-esModule

named-and-default-export-runtime-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
import * as x; x === await import() false

named-and-null-default-export

named-and-null-default-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default: null }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default: null }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 null
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-null-default-export-esModule

named-and-null-default-export-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named, default: null }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named, default: null }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 null
import * as x; x === await import() false

named-and-null-default-export-non-enumerable

named-and-null-default-export-non-enumerable rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [named], [default]: null }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [named], [default]: null }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 null
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-null-default-export-runtime

named-and-null-default-export-runtime rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default: null }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default: null }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 null
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-and-null-default-export-runtime-esModule

named-and-null-default-export-runtime-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named, default: null }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named, default: null }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 null
import * as x; x === await import() false

named-export

named-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named }, [Module] }
x = require(); x.default

x = require(); ident(x).default

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-export-esModule

named-export-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 undefined
import * as x; x === await import() false

named-export-esm

named-export-esm rspack webpack
import x

import { default as x }

import * as x; x.default		 undefined + errors undefined + errors
import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default		 undefined undefined
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named' 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors true + errors
import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], named: [G], [Module] } { [__esModule], named: [G], [Module] }
import() { named } { [__esModule], named: [G], [Module] }
import * as x; x === await import() false true

named-export-non-enumerable

named-export-non-enumerable rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [named] }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [named] }, [Module] }
x = require(); x.default

x = require(); ident(x).default

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-export-runtime

named-export-runtime rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named }, [Module] }
x = require(); x.default

x = require(); ident(x).default

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

named-export-runtime-esModule

named-export-runtime-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { [__esModule], named }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 undefined
import * as x; x === await import() false

order

order rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { b, a, c }
import { named as x }

import * as x; x.named		 undefined + errors
import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], b: [G: 'b'], a: [G: 'a'], c: [G: 'c'], default: [G] { b, a, c }, [Module] }
await import() === require()

import * as x; x === await import()		 false

order-esModule

order-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { [__esModule], b, a, c }
import { named as x }

import * as x; x.named		 undefined + errors
import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true
import * as x

import()		 [Module: null prototype] { [__esModule], b: [G: 'b'], a: [G: 'a'], c: [G: 'c'], default: [G] { [__esModule], b, a, c }, [Module] }
import * as x; x === await import() false

order-esm

order-esm rspack webpack
import x

import { default as x }

import * as x; x.default

import { named as x }

import * as x; x.named		 undefined + errors undefined + errors
import * as x; ident(x).default

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 undefined undefined
import { __esModule as x }

import * as x; x.__esModule		 true + errors true + errors
import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()		 true true
import * as x

x = require()		 { [__esModule], a: [G: 'a'], b: [G: 'b'], c: [G: 'c'], [Module] } { [__esModule], a: [G: 'a'], b: [G: 'b'], c: [G: 'c'], [Module] }
import() { a, b, c } { [__esModule], a: [G: 'a'], b: [G: 'b'], c: [G: 'c'], [Module] }
import * as x; x === await import() false true

require-circular

require-circular rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { default, named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G] { default, named }, named: [G], [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

require-circular-self

require-circular-self rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { default, named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G] { default, named }, named: [G], [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

require-conditional-execution

require-conditional-execution rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { default, named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G] { default, named }, named: [G], [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

single-class-export

single-class-export rspack webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 <ref *1> { [class TheClass] [length]: 0, [name]: 'TheClass', [prototype]: { [constructor]: [Circular *1] } } <ref *1> { [class TheClass] [length]: 0, [name]: 'TheClass', [prototype]: { [constructor]: [Circular *1] } }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: <Inspection threw>], [Module] } [Module: null prototype] { [__esModule], length: [G: 0], name: [G: 'TheClass'], prototype: [G] <ref *1> { [constructor]: { [class TheClass] [length]: 0, [name]: 'TheClass', [prototype]: [Circular *1] } }, default: [G: <Inspection threw>], [Module] }
await import() === require()

import * as x; x === await import()		 false false

single-empty-string-export

single-empty-string-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 ''
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: ''], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-function-export

single-function-export rspack webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 <ref *1> { [Function: theFunction] [length]: 0, [name]: 'theFunction', [arguments]: null, [caller]: null, [prototype]: { [constructor]: [Circular *1] } } <ref *1> { [Function: theFunction] [length]: 0, [name]: 'theFunction', [arguments]: null, [caller]: null, [prototype]: { [constructor]: [Circular *1] } }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: <Inspection threw>], [Module] } [Module: null prototype] { [__esModule], length: [G: 0], name: [G: 'theFunction'], arguments: [G: null], caller: [G: null], prototype: [G] <ref *1> { [constructor]: { [Function: theFunction] [length]: 0, [name]: 'theFunction', [arguments]: null, [caller]: null, [prototype]: [Circular *1] } }, default: [G: <Inspection threw>], [Module] }
await import() === require()

import * as x; x === await import()		 false false

single-null-export

single-null-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 null
import { named as x }

import * as x; x.named

x = require(); x.default

{ named } = require()

x = require(); x.named

{ __esModule } = require()

x = require(); x.__esModule		 type error
import * as x; ident(x).named

x = require(); ident(x).default

x = require(); ident(x).named

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: null], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-object-export

single-object-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named }, [Module] }
x = require(); x.default

x = require(); ident(x).default

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

single-object-with-default-export

single-object-with-default-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

single-object-with-default-export-duplicate

single-object-with-default-export-duplicate rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 'default'
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

single-object-with-null-default-export

single-object-with-null-default-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 { named, default: null }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], named: [G], default: [G] { named, default: null }, [Module] }
x = require(); x.default

x = require(); ident(x).default		 null
{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
await import() === require()

import * as x; x === await import()		 false

single-promise-object-export

single-promise-object-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 Promise { { named } }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x [Module: null prototype] { [__esModule], constructor: [G: <Inspection threw>], then: [G: <Inspection threw>], catch: [G: <Inspection threw>], finally: [G: <Inspection threw>], default: [G] Promise { { named } }, [Module] }
import() { named }
await import() === require()

import * as x; x === await import()		 false

single-promise-object-with-default-export

single-promise-object-with-default-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 Promise { { named, default } }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x [Module: null prototype] { [__esModule], constructor: [G: <Inspection threw>], then: [G: <Inspection threw>], catch: [G: <Inspection threw>], finally: [G: <Inspection threw>], default: [G] Promise { { named, default } }, [Module] }
import() { named, default }
await import() === require()

import * as x; x === await import()		 false

single-promise-string-export

single-promise-string-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 Promise { 'single' }
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x [Module: null prototype] { [__esModule], constructor: [G: <Inspection threw>], then: [G: <Inspection threw>], catch: [G: <Inspection threw>], finally: [G: <Inspection threw>], default: [G] Promise { 'single' }, [Module] }
import() 'single'
await import() === require()

import * as x; x === await import()		 false

single-string-export

single-string-export rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 'single'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: 'single'], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-string-export-defined

single-string-export-defined rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 'single'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: 'single'], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-string-export-duplicate

single-string-export-duplicate rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 'single'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: 'single'], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-string-export-esm-reexport

single-string-export-esm-reexport rspack webpack
import x

import { default as x }

import * as x; x.default		 undefined + errors undefined + errors
import * as x; ident(x).default

import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named		 undefined undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

await import() === require()

import * as x; x === await import()		 true true
import * as x { '0': [G: 's'], '1': [G: 'i'], '2': [G: 'n'], '3': [G: 'g'], '4': [G: 'l'], '5': [G: 'e'], [__esModule], [Module] } { [__esModule], [Module] }
import()

x = require()		 { '0': [G: 's'], '1': [G: 'i'], '2': [G: 'n'], '3': [G: 'g'], '4': [G: 'l'], '5': [G: 'e'], [__esModule], [Module] } { '0': [G: 's'], '1': [G: 'i'], '2': [G: 'n'], '3': [G: 'g'], '4': [G: 'l'], '5': [G: 'e'], [__esModule], [Module] }

single-string-export-getter

single-string-export-getter rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 'single'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: 'single'], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-string-export-live

single-string-export-live rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 'single-outdated'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: 'single-outdated'], [Module] }
await import() === require()

import * as x; x === await import()		 false

single-string-export-reexport

single-string-export-reexport rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

x = require()		 'single'
import { named as x }

import * as x; x.named

import * as x; ident(x).named

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule		 true
import * as x

import()		 [Module: null prototype] { [__esModule], default: [G: 'single'], [Module] }
await import() === require()

import * as x; x === await import()		 false

tla-esModule

tla-esModule rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

import { named as x }

import * as x; x.named

import * as x; ident(x).named

import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

import * as x

import()

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

x = require()

await import() === require()

import * as x; x === await import()		 compilation error

tla-esModule-esm-reexport

tla-esModule-esm-reexport rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default

import { named as x }

import * as x; x.named

import * as x; ident(x).named

import { __esModule as x }

import * as x; x.__esModule

import * as x; ident(x).__esModule

import * as x

import()

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule

x = require()

await import() === require()

import * as x; x === await import()		 compilation error

tla-esm

tla-esm rspack

webpack
import x

import { default as x }

import * as x; x.default

import * as x; ident(x).default		 'default'
import { named as x }

import * as x; x.named

import * as x; ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule

import * as x; x === await import()		 true
import * as x

import()		 { [__esModule], default: [G], named: [G], [Module] }
x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
x = require() Promise { { [__esModule], default: [G], named: [G], [Module] }, [Symbol(webpack exports)]: { [__esModule], default: [G], named: [G], [Module] }, [Symbol(webpack queues)]: { [Function (anonymous)] [length]: 1, [name]: '' } }
await import() === require() false

tla-esm-esm-reexport

tla-esm-esm-reexport rspack

webpack
import x

import { default as x }

import * as x; x.default		 undefined + errors
import * as x; ident(x).default

x = require(); x.default

x = require(); ident(x).default

{ named } = require()

x = require(); x.named

x = require(); ident(x).named

{ __esModule } = require()

x = require(); x.__esModule

x = require(); ident(x).__esModule		 undefined
import { named as x }

import * as x; x.named

import * as x; ident(x).named		 'named'
import { __esModule as x }

import * as x; x.__esModule		 true + errors
import * as x; ident(x).__esModule

import * as x; x === await import()		 true
import * as x

import()		 { [__esModule], named: [G], [Module] }
x = require() Promise { { [__esModule], named: [G], [Module] }, [Symbol(webpack exports)]: { [__esModule], named: [G], [Module] }, [Symbol(webpack queues)]: { [Function (anonymous)] [length]: 1, [name]: '' } }
await import() === require() false