►
From YouTube: Modules
Description
OpenJS Foundation Collaborator Summit, Berlin, 2019
A
A
B
A
Say
like
specified
in
a
weird
way,
because
parts
of
it
are
specified
in
parts
like
the
loader
itself,
fully
specified
complicated,
transparent
interoperability,
so
transparent
interoperability
is
a
word
that
we'd
ever
hit.
That
I
were
to
because
it's
confusing,
but
when
I
say
it
I'm,
specifically
referring
to
being
able
to
require
any
SM
module
or
important
comment
jams
bottle
and
not
have
to
know.
You
know
what
the
format
is
that
it
exposes.
C
A
A
A
A
Oh
then,
it's
great,
you
can
even
see
what
I'm
doing
for
those
of
you
are
wondering
what
that
has
been
a
corner
of
a
really
beautiful
water,
color
painting
of
Calvin
and
Hobbes.
So
you
need
to
get
the
exciting.
Where
is
alarm?
I
mean
I've
been
talking?
Isn't
it
seem
like
scream
so
to
just
I
guess,
set
the
tone.
Just
stop
me
if
I'm
not
making
sense.
A
A
A
Some
of
the
sticker
points,
for
example,
were
their
environment
at
the
dot
NJ
s
extension
for
PS
modules,
but
you
know
there.
There
are
a
number
of
different
parties
in
response
to
this,
and
this
is
actually
kind
of
a
cool
thing.
If
you're
not
familiar
with
it
in
general,
the
TSE
keeps
we
started
doing
this
thing
called
strategic
initiatives.
A
We
could
look
at
the
history
and
see
how
well
these
are.
This
is
something
that's
talked
about,
but
kind
of
was
picked
off
by
Mike
Dawson.
You
know
I'm
covert
of
2017
and
the
strategic
initiatives
and
things
that
we've
identified
they're
like
really
high
level
things
that
we
should
be
focused
on
during
the
videos
project.
He
was
a
bit
of
a
shift
that
we
made
them
around.
The
TST
being
much
more
forward
thinking
than
being
responsive,
so
a
lot
of
things
CSU
is
focused
on
beforehand.
It
was
like.
Oh
there's,
a
fire.
A
We've
got
a
footnote.
We
wanted
to
have
a
shift
to
be
much
more
for
thinking
and
thinking
of
the
future
and
kind
of
dealing
with
existential
threats
to
to
know
himself,
and
so
you
can
see
one
of
the
first
ones
on.
There
was
modules
and
I
was
the
champion
of
it.
You
should
actually
probably
up
those
things,
but
there's
this
originally.
Yes,
that's
from
2017.
A
This
kind
of
was
how
the
initial
implementation
was
like
spec
down
and
then
implement,
as
I
mentioned
was
not
extremely
well
received.
I
myself
was
glad
that
we
had
something
as
a
starting
point
that
people
couldn't
agree
on
this
stuff.
So
what
we
did
is
we
spun
up
this
modules
team
after
about
six
months
of
just
like
yelling
and
like
shedding,
we
came
up
with
the
plan
and
the
plan
was
this
idea
that
we
call
the
minimal,
oh,
so
no
2.5
is
where
I
landed
great.
So
the
idea
modules
came
did.
A
Is
we
kind
of
permutated
a
whole
bunch
of
use
cases
as
well
as
different
different
needs
that
we
had
from
the
module
loader?
So
if
you
actually
go
here
and
go
into
the
issues
here
and
look
at
one
of
the
213
closed
issues,
you
can
see
lots
of
different
issues
that
were
opened
up
for,
like
you
know,
well
early
ones
around
the
governance
later
ones
around
stuff,
like
you
know,
import
Maps
proposal
for
their
imports
upstream
changes
to
know.
A
If
you
go
into
the
modules
people
itself
liam
a
list
of
these
different
features
that
was
based
on
number
55,
which
was
the
collection
of
kind
of
tracking
all
of
those,
and
so
we
have
all
these
different
use
cases
that
we
identified
that
he
would
need.
Although
it
was
also
kind
of
identified
earlier
that
hey
some
of
these
use
cases,
don't
aren't
able
to
coexist.
So
we
can
want
everything,
but
we're
going
to
kind
of
have
to
figure
out
what
works
and
what
doesn't
so
we
came
up
with.
Was
this
plan
with
different
phases?
A
A
But
that
baseline
was
hey.
What
are
the
common
features
that
all
the
potential
future
iterations
that
we're
talking
about
and
all
of
the
use
cases
that
we
like
to
see
happen
are
possible
with?
So
what
are?
What
is
a
baseline
that
if
we
were
all
to
go
and
forth
known
right
now
and
try
to
make
our
perfect
implementation
of
modules,
we
can
all
work
from
the
exact
same
point
and
at
least
build
upon
the
same
shared
idea
and
then
phase.
Two
is
fleshing
up
that
implementation
with
enough
functionality.
That
could
actually
be
useful.
A
So
the
phase
one
minimal
cradle
was
like
absolutely
useless.
Let's
make
it
it
kind
of
useful,
and
then
we
shipped
phase
two
with
nodes
well
and
now
we're
in
phase
three,
which
is
extending
that
MVP
with
a
head
of
user
experience,
education
that
we've
found
and
that's
kind
of
where
we
are
right
now
and
through
throughout
the
entire
phase.
One
of
the
things
that
we
came
up
with
as
fruit
was
these
kind
of
like
goals,
guidelines
and
vision
that
everyone
agreed
to
we've
been
at.
We
couldn't
agree
about.
You
know
like
specify.
B
A
Resolution
or
transparent
Interop
we
could
agree
that
we
wanted
more
implementation
to
be
spec
compliant.
We
wanted
as
much
for
it
to
be
browser
equivalent.
So
we
wanted
the
loader
in
knows,
but
as
much
as
possible.
That's
either
the
browser
work,
the
direction
of
what
the
browser's
capabilities
may
be
in
the
near
future
and.
B
A
Also
wanted
to
docto
anything
the
brook
common
Janus,
so
any
of
the
changes
that
you
were
planning
to
do,
but
just
you
know,
go
under
the
hood
and
completely
Raver,
currently
existing
system,
so
with
v-0
starting
from
the
current
shipping.
No,
the
following
changes
were
made
to
strip
out
most
of
the
eight
point,
five
point:
zero
describing
two
modules,
so
the
first
thing
we
did
is
remove
support
and
the
import
statement
for
a
command
J
of
JSON
in
native
modules,
so
that
was
all
of
the
transparent
trough
that
existed.
A
A
So
there
was,
there
wasn't
really
a
support
for
very
important,
very
important
when
you
just
give
a
specifier
as
a
man
and
a
specifier
would
be
something
like
you
know,
Marlo,
that's
an
example
of
a
bear
specifier
and
in
the
package.json
you're
able
to
use
the
main
field
to
specify
like
what
that
resolves
to,
but
we
even
stripped
data
from
this
kind
of
thing.
Zero.
We
completely.
B
A
A
And
each
of
those
features
actually
wouldn't
eat.
Other
potential
features
that
people
are
thinking
about.
We
made
the
important
statements,
only
support
the
done
MJS
extension,
the
idea
being
here
that
we
were
planning
as
a
group
that
we
would
always
work
out
of
kids.
So,
even
if
we
found
a
way
to
have
not
faced
piles
as
ESM,
there
will
always
be
a
need
for
completely
unto
us.
A
So
we
kept
support
for
important
ESM
that
only
for
in
jazz
files,
we
included
important
meta
URL.
This
is
something
that
exists
in
the
browser
as
well.
It
just
gives
you
file
URL
to
the
file
that
you're
in
we
kept
dynamic
important.
That
was
another
feature
we
had
pretty
much
large
sets,
as
this
will
always,
and
we
did
still
allow
for
support
for
built-in
modules
with
named
exports.
So
that
would
be
something
like
what
it
would
be
like
import.
A
Refit
spell
so
stuff,
like
this
continue
to
learn.
We
all
agreed,
hey
we're,
never
gonna
change
that
implementation.
We're
always
gonna
want
to
be
able
to
work.
The
built-in
libraries
we're
always
gonna
want
named
exports,
built-in
libraries,
the
biblical
books
and
libraries
and
node,
even
though
they're
implemented.
How
much
is
it's
all
known
to
us
compile
time,
so
we
can
do
some
fancy
stuff
with
our
buildings
that
can't
be
done
with
your
system
modules,
but
we
bring
much
hype
consensus
that
than
any
implementation
moving
forward
will
have
that
featuring.
A
So
the
combination
of
all
of
those
make
the
minimal
kernel
if
you're
wondering
timeline
here,
this
is
probably
about
like
15
months
into
discussion.
We
managed
to
get
there,
but
it
would
end
up
being
really
amazing
was
like
by
the
time
we
came
to
this
decision.
I,
actually
just
tripping
things
away.
A
Instead
of
trying
to
add
things
and
having
that
that
shared
understanding
of
the
space,
it
just
unlocked
a
whole
bunch
of
stuff,
because
now
we
won,
we
at
least
had
a
fundamental
place
that
we
were
all
on
the
same
page
about
so
the
next
bit
was
Phase
two,
and
there
was
a
lot
of
debate
to
kind
of
pick.
The
features
that
weddings
are
phase
two
and
actually
a
lot
of
research
to
land
on
them,
but
would
eventually
land
it
into
phase
2
was
if
one
was
defining
that
semantics
for
importing
a
package
of
entry
point.
A
B
A
A
So
we
define
the
semantics
for
package
entry
points.
We
define
the
semantics
for
determining
when
to
load
resources
as
either
a
chance
with
us
models.
This
is
what
is
the
introduction
of
the
field
in
the
package?
Caissons,
you
can
our
do
tightened
module
if
you
do
type
module.
The
package.json
is
no
resolves
to
SM
instead
of
CJ
s
and
it
did
involve
the
creation
of
the
new
box,
CGS
extension,
which
I'm
pretty
excited
about
so
like
I.
Actually
now.
For
me,
we've
got
three
extensions
and
this
is
like
obviously
CJ
s.
A
A
So
I'm
not
saying
to
do
this
in
your
group
today
like
this,
is
actually
a
way
in
which
you
could
organize
your
code.
That
was
like
always
work,
pretty
much
all
environments,
but
that
was
a
big
part
of
it,
because
if
we
had
importing
of
doc,
Janice,
hello
and
Janice
is
always
ESM
well,
how
do
you
still
import
any
common
J's
files?
The
other
thing
is
like
these
semantics
are
all
down
to
the
patch.
B
A
If
you
make
a
folder
and
then
folder
hasn't
package.json,
that
will
define
the
semantics
from
that
folder
down
the
folder
hierarchy.
So
you
can
kind
of
have
jazz
files
throughout
their
project.
But
as
long
as
there's
a
package.json
irritable
use,
the
nares
match
just
not
to
resolve
what
type
of
file.
A
A
If
we
did
something
like
hey,
if
you
have
a
doctrine,
it
could
be
either
yes
F
or
CJ
s,
and
we
do
some
sort
of
like
three
parts
of
the
ast
and
then
determine
the
type
of
the
loaded
that
would
have
been
completely
dynamic
and
then
there
would
be
no
way
to
like
statically
determine
that
without
actually
parsing
all
of
the
files,
so
I
don't
know,
I
prefer
this
just
mean
we
defined
this
semantics
for
enabling
ESM
treating
the
source
code
for
a
vowel.
That
was
the
entry
types
proposal
it
was
originally.
A
A
We
disabled
file
extension
directory
searching
by
people
back
on
a
witness
flag,
but
what
that
means
is
that
you
can't
like
import
dot,
slash,
folder,
slash
thing:
you
need
to
include
the
file
extension
to
do
it
and
if
you
don't
include
the
file
extension,
you
better
not
have
a
file
extension
we're
not
going
to
mind
it
for
a
big
motivating
factor
for
this.
What
is
browser
equivalents?
A
C
A
A
Great
place
to
start
a
conversation,
so
the
first
is
a
learner's
solution
that
supports
all
the
items
in
the
features
list.
So
there's
a
like
custom,
loaders,
the
ability
to
say
hey
when
you
import
a
file
like
run
this
dynamic
toad
first
instead
of
just
floating
in
that
is
something
that
we
need
to
figure
out.
We
have
an
implementation
of
loaders
and
it
exists.
The
chain
is
not
super
happy
with
it.
We
have
the
beginning
of
a
new
implementation.
It
has
all
sorts
of
memory
links
it's
also.
A
Building
on
top
of
the
worker
print
implementation
then
still
needs
some
kind
of
tweaks
to
be
are
in
an
ergonomic
together.
So
if
you're
looking
for
somewhere
to
work-
and
you
have
some
really
great
C++
trucks-
that's
somewhere,
we
I'm
going
to
help
us
today.
We
need
to
map
the
path.
Was
the
in
modules
we're
finding
a
similar
functionality?
As
the
browser
supports
proposal
yarn
over
here?
You
raise
your
hand
really
quickly.
Johanna
has
come
up
with
a
lot
of
those
ideas.
Package
I
for
tonight,
I
think
is
really
really
cool.
A
C
A
A
A
That's
I
think
in
an
origin
trial
right
now,
but
I
could
be
mistaken,
but
import
maps
are
what
are
going
to
allow
this
kind
of
like
their
imports
to
exist
in
the
browser
until
I
turn
that
module
into
like
know
about
the
modules,
slash
modules
to
entry
point,
the
same
thing
that
we
have
a
package.json,
a
name
import
maps
are
going
to
be
like
a
static
file.
That's
at
the
top
level
of
your
application.
It's
loaded
I
believe
as
like.
A
Tag
or
something
I
have
to
relook
at
the
spec,
but
when
we
really
move
with
this,
exports
is
a
tool
it
statically
crawling,
while
installing
your
module
graph
like
actually
specify
all
of
those
deep
imports,
so
we're
talking
about
browser
equivalents,
if
you
are
being
explicit
about
this
tools,
would
then
be
able
to
stack.
We
generate
all
of
this
be
able
to
have
the
exact
same
import
interface
for
both
the
browser
engine.
B
A
A
There's
a
proposal
that's
still
being
debated
whether
or
not
we
want
to
do
it,
which
is
like
having
some
sort
of
reference
inside
of
the
package
to
reference
itself.
So
you
can
import
I
mean
here's
some
like
really
not
used
to
tax
I.
Don't
think
that
this
would
be
it,
but
if
we
have
it
in
spaces
and
known,
we
can
have
like.
A
Something
like
so
or
this
or
me
or
like
some
sort
of
specifier
there.
That
means
your
own
module
because
there's
a
lot
of
places
where
you've
made
work
from
your
own
modules,
then
you
have
like
feet,
paths
and
got
docks
and
whatnot,
and
it's
not
great.
It's
like
a
bit
of
a
refactoring
hazard.
Potentially
so
that's
one
thing
that
we're
exploring.
This
is
another
one
that
came
up
as
a
potential
inconsistency.
A
How
much
ASM
and
that's
a
debate
within
the
modules
group
as
well
like,
should
we
be
introducing
new
features
like
this
to
ESM
if
we're
not
able
to
have
the
same
capabilities
and
coverages
with
implementing
something
like
this
in
common?
Yes,
ringing,
I,
think
I,
don't
know
hundred
percent
as
we
explore
the
in
spaces
as
a
possible
thing
that
opens
up
the
design
space,
but
doing
it
right
now
without
in
spaces.
I,
don't
think,
would
be
possible
with
it
major
but
love
to
hear
anything
goes
bad
limited
module
type
declaration.
A
I'm
not
sure
that
what
is
that's,
oh,
that's,
the
utility
method
for
determining
the
type
of
a
module
there's
an
upstream
PR
for
this
right
now.
So
if
you
have
feelings
you
can
jump
into
this,
this
is
like
util
methods
that
you
can
run
on
source
text
and
it
can
tell
you
as
an
SES,
M
I.
Think
if
there's
yeah
it's
like
contain
module.
Syntax
is
correct.
Api.
It
kind
of
looks
like
this
I
think.
There's
some
debates
about
whether
or
not
this
is
the
best
API.
What
they
P
I
should
look
like.
B
A
Another
one
is
provide
a
way
to
make
SM
the
default
in
nodes
that
are
common
gasps.
So
how
do
we
move
into
that?
Just
like
using
the
dead
binary?
It's
XE
SM
instead
of
common
dual-mode
modules,
is
a
really
contentious
topic
right
now,
so
the
ability
of
a
module
that
you
can
import
that
could
be
either
colleges
or
TSM,
so
you
can
both
require
it
and
import
it
with
the
same
specifier
so
like
this
is
important
for
multiple
authors.
A
If
you
are
about
to
author
and
you
want
people
to
be
able
to
like
import
low
and
require
low
and
just
kind
of
have
that
work,
that's
what
we
would
call
dual
mode.
I
have
some
of
my
own
opinions.
I
don't
exist,
but
I
want
to
get
to
it.
I
don't
want
to
poison
you
with
my
guidance
too
early
in
this
discussion,
but
that's
something
that
we
are
actively
evading.
A
How
should
this
work?
Should
it
even
work?
The
current
implementation
that
we
have,
and
only
the
single
entry
point
name,
that
Sheriff
KSM
and
with
the
file
extension
turned
off.
It's
actually
possible
anymore.
I
think
that's
a
feature.
People
disagree.
So
that's
something
that
we're
debating
and
we
also
need
to
finalize
the
behavior
of
an
important
comment.
Yes,
so
we
want
to
be
in
work
on
anjaneyasana
and
have
named
exports,
but
right
now
we
can
only
do
it
default
export.
That
has
something
to
do
with
the
specification
and
client
you
can't
have.
A
This
is
not
possible.
We
can
dig
into
that
more
afterwards,
we're
trying
to
go
to
a
taste
Ethernet
a
couple
times
with
different
approaches
to
how
we
can
allow
for
dynamic
modules,
where
let
me
do
exports
the
names
of
things
and
resolves
those
later,
but
we've
been
unable
to
do
that
way,
back
ingame
census
of
the
committee,
so
there
was
debate
about
whether
or
not
we
usually
even
should
have
that
transparent
interoffice
it's
default
only
because
you
still
even
need
to
know
that
it's
a
common
GSM
module
anyways,
that's
a
debate.
A
One
of
the
things
that
done
is
done.
The
only
thing
that
we
actually
finished
right
now
is:
we
need
a
better
mechanism
for
a
wire
with
wire,
so
you
can
narrow.
Do
import
read,
require
from
module
and
then
create
require
import.
Meta.
Url
I
mean
that
literally
gives
you
a
require
inside
of
the
module
that
you
could
use
this
little
den
of
ritual
is
not
the
best
user
experience,
but
we
haven't
come
up
with
a
better
way
to
do
it.
B
A
We
do
here
this
is
it's
like
the
best
thing
ever.
If
you
haven't
had
it
installed
on
your
computer,
you
should
do
it.
There
are
open
source
versions
available
for
Linux
and
Windows
as
well.
That
is
just
an
offline
document
for
your
a
really
great
fuzzy
search.
So
this
is
the
experimental
motor
hooks
that
it
exists
right
now,
and
so
you
can
make
a
result
right
now.
Legit
changes,
let's
resolve
the
your
appointment,
doesn't
really
change
it.
A
Takes
like
a
specifier
and
turns
it
into
a
path.
So
that's
what
would
turn
like
lodash
into
the
modules.
It
would
be
like
a
file
like
in
the
whole
path
to
to
node
modules.
Fetches.
One
thing
then
take
a
path
and
turn
it
into
like
the
actual
source
text
and
it's
a
little
more
complicated.
This
is
all
happening
with
like
source
text
module
records
like
under
the
minute.
This
is
kind
of
the
high
level,
and
then
the
transform
is
looking.
A
Instead
of
in
half,
so
each
of
these
phases
are
kind
of
like
different
phases
that
you
may
want
to
look
into.
So
you
know
this
is
specifier
example,
with
just
a
hook
there,
you
can
implement
the
file
extension
resolution
operator
to
look
into
any
of
these
other
things
for
fetching
the
source
text.
That's
how,
as
an
APM
vendor,
for
example,
you
could
set
your
own
custom
implementation
of
the
FS
instead
of
our
implementation
of
that
mass
per
transform
source
text.
A
B
A
B
A
We've
got
that
one
core,
but
for
third-party
modules,
yes
p.m.
on
the
name,
banks.
Well,
it's
tricky
because
you
actually
need
to
inject
into
that
source
code
and
update
those
those
module
light
bindings
with
all
the
exports
like.
If
you
explore
today
for
export
function,
you
know
she
wants
to
be
updating
that
export
and
you
can
only
do
that
from
within
the
module
you
canto
from
outside
of
the
module,
so
that
I
will
get
a
PM.
A
A
Ago,
but
it
landed
it
and
I
started
playing
with
building
stuff
that
it
scripted
one
of
the
first
things
that
I
noticed
was
like
when
we
build
it
out
and
we
did
the
test
for
them.
We
didn't
actually
like
compile
episode
early
with
a
description
we
took
what's
known
as
W
avian.
What
is
it
there's
an
intermediate
representation
of
the
ast
so
West,
and
we
me
directly
compiled
last
tourism
so
that
it
was
like
a
pretty
pretty
clean
translation
and
all
of
our
tests
and
everything
that
we've
implemented
works
with
West
hasn't.
A
But
almost
no
one
is
like
writing
last
bike
and
those
people
are
taking
like
C
code
and
then
compiling
back
to
web
assembly.
If
you
use
in
scripting
and
scripting
is
embedding
its
own
system,
and
that
includes
like
a
whole
implementation
of
just
things
like
how
do
we
convert
printf
or
any
is
one
of
the
system
calls
that
exists
into
things
that
are
actually
in
scripting?
Does
that
right
now,
I,
actually
like
wrapping
all
the
code
and
with
thousands
of
lines
of
JavaScript
it's
expecting
to
execute
and
have
available?
A
And
then
it's
expecting
there
to
be
like
this
source
off
parent,
that's
available
that
just
has
specific
things
implemented
in
it.
There's
no
way
for
us
today
like
inject
on
a
per
module
scope,
like
things
to
say,
hey.
If
you
try
to
import
source
in
only
this
module,
it
will
resolve
to
this
thing
now.
This
is
actually
a
thing
that
the
import
maps
are
are
introducing.
A
So
that's
something
that
we
could
think
about
exploring,
but
one
of
the
things
that
may
help
with
a
PMS
but
I'm
not
100%
when
we
some
sort
of
support
for
a
kind
of
like
injecting
or
changing
the
scope.
What
happens
when
you
import
modules
from
the
con
step?
One
module,
so
we
try
to
from
inside
of
a
web
assembly
module
import,
something
called
source
and
it
doesn't
exist
anywhere
else.
Can
we
inject
like
a
particular
thing
for
that
in
space?
A
I,
don't
know
if
this
is
possible
and
I
don't
know
if
there's
a
way
for
us
to
do
that
with
spectrum
plants,
but
because
of
like
this
edge
case,
that
I've
seen
with
web
assembly
is
something
that
I'm
thinking
about,
and
that
would
be
kind
of
similar
I
guess
in
a
way
to
proxy
wire,
but
not
exactly.
It
would
be
a
bit
of
a
different.
A
A
I
believe
that
we
had
initially
wanted
that
to
be
kind
of
blocking
things
who
are
living
the
flag,
but
I
was
gonna,
get
closer
to
late
October
and,
as
the
rest
of
the
implementation
gets
more
stable,
we
are
actually
getting
closer
to
making
a
decision
to
just
keep
loaders
behind
an
additional
flag
and
potentially
even
flag,
without
these
capabilities
and
I
understand
where
that
would
be
really
detrimental
to
a
POS.
So
we
should
likely
sink
on
that
and
see
about
the
right
people.
A
Sort
of
question
to
repeat
for
the
people
on
the
stream
is:
how
are
we
gonna?
Do
things
to
make
urban
our
core
module
authors
to
support
multiple
versions
of
know
them,
so
that
is
like
kind
of
was
actively
being
debated
with
two
little
modules,
and
so
dual
mode
modules
would
be
something
like
if
we
had
like
what
I
was
just
a
really
nice
solution
with
me
having
a
module
field.
B
A
A
No
reference
to
it
gives
own
cash.
So
if
you're
in
a
modulo
graphic
that
started
as
ESM
and
you
imported
a
module,
you
would
instantiate
this
source
text.
You
can
create
that
record
inside
of
the
ESM
patch
and
then,
if
later
on
down
in
your
tree,
someone
required
the
exact
same
module
in
the
exact
same,
like
general
module
context.
So
obnoxiously
people
are
it's
a
different
thing.
It.
A
A
new
instance
inside
of
a
require
patch,
with
a
completely
different
singleton
and
in
many
cases
this
may
just
kind
of
work,
but
having
worked
on
things
that
are
expecting
behavior
in
that
single
dinner
strip
state
between
your
app.
That
just
creates
these,
like
really
really
weird,
he's
really
weird
hard
to
track
down
an
art
to
even
know.
What's
going
on
problems.
C
A
A
Of
look,
I
am
a
module
author
who
he's
who
wants
to
upgrade
my
module
to
BES
now
and
once
that
transition
happens,
so
I'll
show
you
an
example
of
one
that
I've
created
I'm
a
module.
This
module
called
no
Thomas
C,
no
Noah
C
is
a
library
for
doing
the
open,
sound
control
primarily
used
by
like
artists
and
musicians,
so
not
people
who
necessarily
have
a
really
deep
understanding
of
our
ecosystem
and
all
the
subtleties
that
evidence.
A
Here's
an
example
of
known
of
new
experimental,
ESM
implementation.
Where
and
all
I'm
known
as
I've
created
a
deep
entry
point.
I
am
gasps.
This
can
land
an
assembler
minor.
You
can
see
them
all
the
es
mas
is
doing
is
actually
just
importing
all
the
common
tests
things
and
then
exporting
them
as
an
equal,
but
also
exporting
them
as
named
exports.
So
this
creates
any
SM
like
interface
into
the
common
J's
that
will
work
will
have
named
exports.
A
B
A
S,
support
and
nodejs
left
CJ
s
and
an
assembler
minor
on
the
prior
semi
major.
You
could
still
introduce
that
slash,
CJ
s,
entry
point
as
the
same
as
the
main,
and
so
this
isn't
perfect.
It's
definitely
not
as
economic
as
just
having
a
shared
name,
but
I
actually
think
that
this
is
pretty
reasonable.
It
creates
like
explicit
entry
points
if
you're,
supporting
it.
/,
PJs
and
/
PSM
could
always
work
as
explicit
entry
points,
and
you
can
basically
flip
which
one
is
the
default
in
a
separator.
A
This
is.
We've
documented
this
recently
in
a
pull
request.
I
think
Jeff
over
in
the
chat
has
pointed
to
it
right
here,
and
this
is
like
our
current
recommendation
and
that
kind
of
documents,
the
pattern
that
I
was
just
talking
about
we're
open
to
other
patterns
and
other
user
journeys.
So
you
know
the
more
people
who
have
looked
right
power
on
this
problem
and
think
through
it
we're
going
to
kind
of
talk
through
it
and
try
to
figure
it
out.
A
I
recognize
that
this
is
one
of
the
biggest
problems
that
will
have
a
speaker
system
and
we
get
pretty
fired
up
in
our
meetings.
When
we
talk
to
people
they
should
be
because
we
know
that
it's
extremely
important
for
the
adoption
of
ESF,
but
also
be
you
really
haven't-
worked
for
module
authors.
We're
gonna
have
to
do
this
to
continue
to
support
all
of
the
different
people
who
are
they
use
the
box
I
think
joining
and
to
the
people
who
are
dialing
in
on
the
stream.
I'm,
no
bigger
comments
on
this
degree.
A
A
I
think
the
change
is
that
what
we
did
with
it
should
be
to
remove
the
flag
with
an
upgrade
of
later,
so
that's
definitely
an
option
that
we
haven't
really
discussed.
Another
thing
that
we
definitely
want
to
try
to
do
is
back
work
to
ten
possible,
but
we're
kind
of
we're
waiting
to
see
where
things
land
before
we
see
what
we
can
backward
to
ten.
A
A
A
B
A
We
go
so.
This
is
how
we're
actually
doing
the
file
extension
resolution
itself,
and
you
can
see
that
we
have
two
different
format
Maps.
So
we
have
come
the
extension,
what
about
now
in
a
legacy
extension
format,
and
so
basically,
when
you're
in
the
legacy
bill,
which
is
essentially
type
module
or
you
have
type
legacy
inside
of
your
package
JSON.
This
is
what
the
file
extensions
will
resolve
to
so
CJ
s
and
dr.
hasn't
resolved.
The
kanji
has
translator
and
that's
in
translators.
Gotcha
is
actually
the
implementation
all
of
those
different
loaders.
A
So
there's
one
letter,
there's
the
JSON
loader,
there's
a
built
in
loader.
This
is
the
comma
J
s
loader
and
that's
the
name
loader
loader,
actually,
surprisingly,
but
so
when
you're
in
the
legacy
mode.
These
are
what
the
extensions
back
to
and
you'll
see.
Dr.
Bester
coverage
is
when
you
do
mode,
when
you
do
type
module,
we
actually
don't
support
anything
out
of
the
box
right
now.
That
is
not
like
browser
equivalent.
So
we
don't
support
native
modules,
but
that's
only
within
the
boundary
of
your
own
package,
so
the
important
package-
that's
a
native
module.
A
B
A
One
of
the
things
that
we
do
have,
though,
is
Lou
a
some
stuff
I'm
confused
that
I'm
not
seeing
Doug
wiser
than
attention
memo
look
into
that
afterwards,
but
essentially
we
are
we're
actively
exploring
webassembly
and
specifically
lousy
and
I.
Think
there's
some
members
in
this
ability
that
works
on
what
assembly
in
the
room
we've
got
until
back
there.
A
But
you
know
these
are
still
in
the
air.
We
couldn't
choose
to
change
the
way
that
this
is
supported,
that
I
think
in
general,
like
you,
wouldn't
be
writing
a
TSM
module,
that's
using
the
legacy
in
a
bottle
system.
So
as
long
as
you
have
a
package.json
that
doesn't
have
module
in
it
in
your
module,
that's
a
NATO
module.
Anyone
can
import
it.
They
just
can't
do
a
named
export,
so
there's
support
there.
That
is,
liberties.