►
From YouTube: Node.js Tooling Group Meeting 2021-02-05
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
Yeah
all
right
cool
looks
like
we're,
live,
welcome
everybody
to
another
episode
of
the
node.js
tooling
group,
whatever
they
are
cadre,
I
don't
know
who
wants
to
drive
today.
Anyone.
B
I
can
run
through
the
agenda.
Okay,.
B
Yeah
and
I'll
help
notes.
B
Okay,
let's
see
first
up,
we
have
the
recursive
copy
issue,
don't
actually
remember
where
we
left
this
one.
Last
time
we
were,
people
were
going
to
review
the
rfc.
I
think
we
decided
that
it
was
probably
good
enough.
B
B
We
all
does
anyone
know
of
a
good
way
to
reach
those
people
like
one
of
the
various
slacks
or
twitter
or
something
else.
C
I'd
be
tempted
to
flag
them
on
the
issue
and
tooling
and
just
see
if
you
get
feedback
they
can
be
found.
There's
two
folks.
They
were
active
in
the
thread
where
we
were
removing
the
experimental
flag
from
rimder
recursive,
so
should
be
able
to
find
the
folks
from
from
those
threads.
B
Okay,
I
will
do
that
right
after
this
meeting.
Yeah,
that's
a
good
idea.
I
guess
get
them
get
them,
maybe
commenting
on
the
the
tooling
issue
before
we
open
the
larger
issue:
cool
okay,
I
don't
think
we
really
have
anything
else
to
talk
about
on
that.
One
then,
unless,
unless
someone
has
something
they
want
to
bring
up,
nope
makes
sense:
okay,
perfect
yeah,
hopefully,
hopefully,
by
next
time
we
can
get
a
little
bit
of
feedback
there.
C
So
I
followed
up
on
this
last
week
and
we
got
kind
of
a
bit
of
a
conversation
going
with
the
folks
who
rate
what's
it
called
keep
forgetting
the
name
quibble
yes,
so
there
is
a
user
land
tool
and
there
was
some
interesting
conversation
that
came
out
of
it
as
well.
That
I
think
yet.
I
think
dino
facilitates
this
in
in
their
platform,
so
so
dino
has
been
thinking
about
how
to
do
it.
Someone
linked
how
dino
does
it
in
the
conversation,
so
I.
C
B
Just
looking
quickly
at
the
conversation
here,
where
did
that
go
someone
says
you
can
use
the
same
method
as
dino,
adding
like
hash
number?
That
indicates
that
this
is
a
new
iteration
of
the
module.
B
Right
yeah,
so
this
is
kind
of
like
I
mean
how
you
would
do
like
invalidation
browser
right,
yeah
put
a
hash
at
the
end
of
the
thing.
I
guess
I
guess
the
issue
with
that
would
be
you're,
not
you're.
Never
unloading,
the
old
modules
right,
you're,
just
gonna,
keep
loading
a
new
one
which,
for
something
like
a
watching
like
test
mode,
could
be
an
issue,
but
maybe
not
I
don't
know.
C
All
right
so
maybe
keep
on
the
agenda
in
case
we
could
make
it
a
little
easier
might
be
worth
talking.
I
don't
know
if
there's
any
immediate
action
items
are
there.
B
C
C
B
I
think
maybe
yeah.
Maybe
we
can
remove
it
from
the
agenda,
but
maybe
we'll
leave
the
issue
open,
so
we
can
revisit
it
at
some
point.
If
that
does
happen,.
B
Okay,
okay,
I
just
removed
it
from
the
agenda.
Does
anyone
have
anything
else
they
want
to
add
on
that
before
we
move
on.
B
No
okay,
the
next
two
on
here
I
think,
actually
I
meant
to
take
these
off.
This
was
the
support
for
booking
spawn,
spawn
sync
and
a
better
way
to
detect
the
process
is
exiting.
Oh,
actually,
the
process
exiting
you
were
gonna
work
on
right
then,.
C
Yeah,
I
I'd
be
curious
to
look
into
that
a
little
more
okay,
yeah,
like
that's
the
like,
really
really
excellent
one
like.
I
would
like
to
look
at
that,
because
I've
run
into
that
a
few
times
and
think
it's
a
little
crappy,
so
I
kind
of
want
to
look
at
it.
I
just
removed
the
label
from
the
other
one,
because
I
think
it's
been
kind
of
uns
we've
been
saying
we're
going
to
remove
it
for
a
few
weeks
and
just
not
removing
it
so.
B
Yeah
I
cleaned
up
a
couple
after
the
last
meeting
and
I
must
have
missed
that
one.
So,
okay,
so
we'll
skip
over
that
one
and
remove
it
from
the
agenda
for
the
future.
Is
there
in
terms
of
the
detecting
processes
exiting?
Is
there
anything
you
want
to
you
want
to
mention
there
then,
or
have
you
not
had
a
chance
to
look
at
it?
I.
B
Okay,
all
right
we're
really
flying
through
this
meeting.
A
B
Actually,
I
have
a
couple,
or
at
least
one
new
thing
I
wanted
to
add
as
well.
So
next
up
sports,
math
v3
any
updates
there.
C
I
have
I
keep
threatening
to
make
a
pr
I'm
going
to
re-threaten
to
make
the
pr
hopefully
this
weekend,
maybe
because
really
I
just
need
to
delete
some
code,
and
I
do
want
to
get
it
out
the
door
sooner
rather
than
later.
So
I
will.
C
I
think
I'm
threatening
myself
that
I'm
going
to
open
a
pr
but
yeah,
basically
literally
all
I
have
to
do-
is
delete
some
code,
that's
being
overly
clever
and
just
make
it
so
it
remaps
the
source
maps.
But
if
you
tell
it
to
and
doesn't
invent
a
new
stack
trace
format,
which
I
think
hindsight
2020
was
a
bad
idea,
so
I'll
actually
open
that
pr
and
maybe
this
weekend,
let
me
get
it
going.
B
Okay,
that
sounds
good,
okay,
so
yeah
I
mean
the
last
thing
on
the
on
the
agenda
is
argument
parsing.
I
maybe
have
something
quick
to
bring
up
before
that.
If
you
guys
want
to
spend
some
more
time
at
the
end
of
meeting
at
argument,
yeah
yeah
sounds
good
yeah.
So
just
something
we
talked
about.
B
I
think
in
the
last
couple
meetings
is
we
have
the
recursive
rm
function
in
node
now
we've
deprecated
the
recursive
rimdir
option,
and
I
was
saying
I
was
going
to
open
a
pr
to
actually
remove
the
deprecated
code
turns
out.
Someone
else
did
that
earlier
this
week,
so
there
is
a
pr
for
that.
Let
me
let
me
link
it
here.
C
If
I
think
I
read
that
pr,
they
were
actually
that
thread
turned
into
such
a
long
thread
about
the
renaming
and
deprecation
and
everything
it's
it
seemed
like
like.
Were
they
just
making
it
so
the
render
with
recursive
is
no
longer
permissive
like
it
doesn't
it,
it
throws
errors
in
more
cases,
or
did
they
completely
remove
the
option.
B
I'm
not
sure
if
we're
talking
about
the
same
thing,
because
so
far
the
only
discussion
on
this.
This
pr
is
one
comment
for
me,
but
their
their
initial
approach.
They,
I
think
they
did
kind
of
what
you
were
talking
about.
There
were
they
they
made
it.
Oh
sorry,.
A
I
added
a
link
to
what
the
pr
links
to
and
there's
right
comments
here.
Maybe
that's
what
ben's
talking
about
yeah,
maybe.
C
Yeah
sorry,
I
meant
that
I
meant
the
like
the
conversation
around
the
deprecation.
The
conversation
around
calling
rimder
recursive
stable
was
a
really
long
conversation
and
I
think,
where
I
lost
thread
was
whether
we
were
going
to
leave
the
recursive
option
on
rimder,
but
make
it
behave
less
permissively,
which
is,
I
think,
is
what
this
pr
is,
because
this
pr
is,
I
think,
throwing
errors.
If
you
try
to
remember
a
file,
I
think
or
if
you
try
to
render
so
just
something.
B
B
So
that's
what
it
was
initially,
but
then
I
suggested,
maybe
we
just
remove
it
entirely,
which
I
think
they
changed
the
pr
to
do,
which
maybe
was
not
the
right
call.
C
C
B
C
B
C
No,
no,
I
I
think
I
think
we
should
just
revisit
the
like.
Let's
revisit
the
decision
we
made
with
the
tsc
and
just
make
sure
we
match
it,
and
I
think
that
the
I'm
blanking
on
whether
the
decision
was
to
completely
remove
or
to
just
leave
the
permissive
behavior
and
and
render.
Oh
sorry,
I'm
using
the
wrong
two
leave
it
in
rimder,
but
make
it
stricter.
B
Yeah
I
had,
I
had
thought
we
wanted
to
remove
it
entirely,
but
now
that
you
mentioned
that
I'm
not
100
on
that.
So
I
agree
with
you.
We
should
yeah
do
some
some
reading
up
on
that
and.
C
C
B
Yeah,
that's
not
a
bad
idea.
I
know
we
did
try
to
summarize
the
plan
in
this
issue,
but
you're
right.
This
did
kind
of
turn
into
a
long
discussion
so
yeah.
I
guess
in
terms
of
next
steps,
just
yeah
revisiting
that
discussion
and
the
decision
we
made
and
then
do
that
thing
in
the
pr
I
was
maybe
a
bit
hasty
in
suggesting
they
changed
the
pr
to
remove
the
functionality
entirely.
C
B
Yeah,
okay,
so
just
yeah.
Maybe
I
see
some
notes
here
that
yeah
we'll
just
revisit
that
conversation.
I'll
make
a
note
for
myself
to
do
that
as.
B
B
Okay,
so
I
guess
that's
that's
kind
of
the
next
step
there
does
anyone
have
any
other
quick
new
stuff
or
should
we
should
we
get
into
the
argument
parsing
discussion,
let's
get
into
it
all
right.
Let's
do
it.
D
So
I
feel
like
we're
going
to
be
retreading
some
some
history
here
and
I
apologize
that
you
know
last
year,
when
I
know
ben
and
and
chris
and
roy
had
been
discussing
this,
I
didn't
get
more
involved
at
that
time.
Oh
ben
just
noted.
D
What
is
this
this
is
from
the
prior
conversation
ignore
me.
I.
D
D
Yeah
cool
yeah,
so
yeah,
so
I
apologize.
I
want
to
start
off
by
apologizing,
but
not
being
more
involved
at
that
time.
D
I
know
chris
put
a
lot
of
effort
into
sort
of
the
proposal
and
then
the
actual
implementation
back
in
I
think
august
september
time
frame
as
well,
so
I
sat
down
with
joe
async
last
friday
to
sort
of
go
over
so
so
I
did
a
lot
of
reading
in
terms
of
the
the
thread
and
the
pr
there
and
then
also
like
looking
at
the
implementation
that
chris
put
together
for
parsergs,
which
I
thought
was
great
like
I
think
there's
a
lot
of
goods
like
like.
D
I
think
the
implementation
is
really
good.
The
sort
of
changes
or
ideas
that
I
had
and
and
sort
of
spoke
with
joe
about
essentially
tried
to
thread
the
needle
of
of
the
feedback
that
seemed
to
be
blocking.
D
You
know
moving
moving
forward,
so
I
put
together
a
couple
docs
that
I
can
share
here
and
you
know
sort
of
maybe
walk,
walk.
You
folks,
through
and
again
like
feel
free
to
to
give
feedback,
as
we
kind
of
walk
through
this.
But
I
started
essentially
with
looking
at
the
three.
D
D
Cool,
so,
let's
start
with,
actually
that's
the
current
states,
let's
go
to
sort
of
like,
I
guess
the
like
problem
statement.
I
sort
of
came
out
of
this
or,
like
the
three
main
things
that
I
saw
in
the
feedback,
which
were
people
seem
to
have
a
big
problem
with
sort
of
the
coercion
and
like
the
options
being,
there
seems
to
be
a
difference
between
the
the
definition
of
and
the
declaration
of
options
being
passed
to
to
your
program.
D
Also,
it
seemed
to
be
that
the
options
nomenclature
are
naming
of
of
things
within
the
docs
themselves
and
also
within
the
options
for
the
api
kind
of
got
a
bit
overloaded.
So
it
was
a
bit
terse
to
like
read
the
docs
and
figure
out
what
exactly
was
going
on,
and
then
it
seemed
also
that
you
know
folks
wanted
a
bit
stricter
api
in
terms
of
whether
or
not
a
string
or
array
could
be
returned
from
from
parsearcs.
D
So
these
seem
to
be
like
the
three
things
that
you
know.
As
far
as
I
could
tell
like,
from
from
gawking
sort
of
the
the
feedback,
were
the
big
things
folks
can
correct
me
if
they
they
thought
there
were.
You
know,
other
other
items
that
people
really
yeah
essentially.
B
The
only
other
one
that
I
remember
was
around
whether
or
not
we
should
throw
if
the
if
the
the
args
pass
didn't
meet
whatever
criteria
or
definition
or
like
if
a
required
arg
was
missing.
B
But
maybe
that
wasn't
as
big
of
a
deal
as
I
remember
it.
Being.
C
E
D
So
I
so
correct
me,
then
there
it
was
defining
the
arguments
that
would
essentially
allow
it
to
throw
like
a
throw
an
error
like
this.
B
Oh,
I
was
just
gonna
say
I.
If
I'm
remembering
correctly,
it
was
like,
let's
say:
you've
you've
passed
like
an
in
that
like
an
argument
that
it's
supposed
to
be
a
string
and
you
passed
a
number
or
there's
a
required
argument
and
you
didn't
pass
it
or
something
like
that.
It
was
really.
E
B
Any
error
should
the
parser
throw
an
exception,
or
should
it
maybe
you
return
like
a
an
object
of
like
with
a
list
of
errors
that
you
could
handle.
I
think
that
was
kind
of
the
debate.
If
I'm
remembering
correctly.
D
So
I
think
the
reason
why
this
last
point-
and
I
do
remember
this
now-
didn't
really
come
up
for
me
as
I
was
ideating
on
on
how
to
like
address
a
lot
of
the
feedback,
was
that
I
started
out
with
the
first
bullet
point
and
tried
to
like
parse
like
parse,
for
forgive
my
bad
pun,
but
try
to
essentially
figure
out
how
we
could
make
everybody
happy
and
and
and
try
to
really
also
figure
out.
D
What's
what
the
problem
with
like
the
current
solution
was,
so
let
me
just
throw
open
up
here
the
final
sort
of
like
docs
as
it
was,
as
it
was
essentially
created
by
chris
for
essentially
parse
args.
D
So
if
we
look
at
this,
I
don't
see
anything
specifically
about
throwing.
So
potentially
that
was
the
feedback
that
you
know
like
what?
What
what
do
we
do
in
these
cases?
So
you
know
the
idea
that
I've
had
is
that
you
know
parse
args
should
actually
be
less
less
try
to
do
less
coercion,
in
fact
like
no
coercion
at
all.
Another
big
thing
I
saw
with
this
implementation
was
the
handling
of
like
falsie
values,
so
there
were
certain
cases
where
I
think
they
were
coercing
like
false,
specifically
to
like
boolean.
D
So
the
idea
would
be
actually
just
to
not
just
provide
a
singular
options,
return
value,
but
to
actually
split
those
out
into
two
separate
things,
which
is
the
declared
parsed
arguments
that
were
passed
and
then
a
separate
object.
That
would
essentially
be
the
the
string
values
that
were
so.
We
don't
do
anything
with
booleans.
You
don't
do
anything
with
casting
you,
don't
do
any
coercion
at
all.
You
don't
do
any
validation,
so
you
kind
of
get
away
from
the
except
like
having
to
handle
the
exceptions.
D
So
you
pass
in
an
array
of
strings
you're
going
to
get
back
strings
still
as
the
values,
and
then
you
it's
up
to
you
as
the
consumer
of
that
of
this
api
to
then
do
any
kind
of
validation
or
coercion
on
those
values
if
you'd
like
to
right.
So
that's
kind
of
like
how
I
think
this
is
the
reason
why
I
I
think
that
in
the
problem
statement
here,
I've
sort
of
gotten
away
from
it
and
you
can
see
some
initial
further
down
into
this
dock.
D
I
actually
get
into
a
whole
bunch
of
examples,
but
the
idea
the
change
here
would
be
that
you
know
we
split
these
two
things
out.
There's
args
and
there's
values
and
args
essentially,
would
be
the
representation
that
something
was
declared
like
an
argument
or
option
was
passed
and
that
will
always
be
boolean
always
be
true.
D
So
or
sorry,
it
won't
always
be
true,
but
it
will
always
be
a
boolean,
so
this
will
basically
give
you
what
you
would
like,
probably
in
the
99
percentile
of
of
times,
for
sort
of
those
quick
clis
that
you're
you're
trying
to
create
this
quick.
You
know,
you
know,
programs
that
you
want
to
pass
like
a
flag
to
and
you
want
to
quickly
see
whether
or
not
it
was
declared.
D
This
is
the
perfect
thing
for
you
right.
So
if
we
go
down,
I
I
actually
will
show
you
the
proposal,
so
this
would
essentially
be
the
change
made.
So
not
just
do
we
split
out,
you
know
args
and
values,
but
we'd
actually
also
change,
just
the
name
a
little
bit
of
the
two
options.
So
again
we're
not
completely
changing.
You
know
the
api
that
much
we
would
go
from
options
with
value
to
just
with
value
options
again
trying
to
reduce
the
overloaded
options
nomenclature.
D
We
will
also
be
prescriptive
here
before
you
could
provide,
I
believe,
a
string
and
array
and
or
array.
So
if
there
was
only
a
singular
flag,
you
could
provide
a
string,
but
here
we
would
actually
be
prescriptive
where
we
would
say
it
has
to
always
be
an
array.
This
was
another
sort
of
like
piece
of
feedback
that
both
of
these
options
essentially
are
always
arrays
arrays
of
strings.
So
again,
like
being
a
little
bit
more
prescriptive
there.
D
I
think
we'll
would
actually
like
get
more
people
on
board
and
be
make
more
people
happy
and
then,
in
terms
of
like
the
return
value,
this
is
sort
of
the
also
a
bit
more
prescriptive
on
what
parsers
would
take.
So
essentially
it's
you're
not
going
to
be
able
to
take
like
an
object
like
it's
it's.
I
think
that
this
default
value
is
kind
of
weird
like
you'll.
It
will
have
a
default,
but
it
I
think
it's
weird
that
if
there's
an
object
provided
like
I
feel
like
that's,
that's
a
weird.
D
I
don't
know,
I
don't
know
any
other
method.
That
sort
of
like
falls
back
to
that
like
we.
It
should
either
error
out
and
I
haven't
specified
that,
but
there
should
be
there's
something
should
throw
if
you're
providing
a
non
array
like
a
string
value
or
something
to
parse
args.
D
So
the
return
values,
I
imagine
again
would
be
would
change
into
essentially
an
object
that
has
the
properties
corresponding
boolean
values
of
the
declared
options
that
were
passed
to
the
program,
whereas
the
values
object
that
gets
returned
would
actually
be
those
same
properties
with
string
values,
and
so,
in
this
case,
in
this
first
example,
you
can
start
to
see.
You
know
how
you
could
essentially
use
this
positionals
doesn't
change
like
the
the
concept
of
the
positionals
and
how
they
get
parsed
won't
change
at
all
same
with
the
multiples
api.
I
think.
D
That's
all
great,
I
don't
think
there's
anything
really
required
there.
D
C
I'm
curious
like
what
happens
if
I
do
like,
so
if
so,
you
have
the
argument
dash
dash,
enable
http,
and
I
I've
passed
it
no
arguments.
So
it's
going
to
be
in
this
scheme.
It's
going
to
be
true
right.
C
Yeah
I
passed
the
string
false
what
what
set
in
what
set
in
the
two
arrays
at
that
point.
Okay,.
C
E
C
D
Okay,
that
makes
sense-
and
I
think,
and
what
this
gets
away
from
is
it
does
give
you
the
foundation
like
to
build.
D
The
key
is
getting
away
from
like
the
validation
aspect
of
this,
but,
like
I
created
an
example
of
essentially
how
you
could
do
something
a
little
bit
more
for
both
and
essentially
start
to
validate
or
even
like
recreate.
You
know
like
yards
essentially,
but
I
think.
C
Other
question
I
have
is
why
we
would
like,
if
we
could,
you
go
up
to
where
def,
where
you
write
the
docs
for
it
a
little
bit
like
you
were
at
a
little
earlier
yeah,
so
I'm
not
quite
seeing
the
difference
between
like
if
with
value
is
always
an
array
like
do
we
need
both
multiples
end
with
value
like
like
is.
If
you
only
provide
one
value
to
an
argument,
is
it
just
an
array
with
one
value
in
it.
D
Yeah
so
this
I
was
originally
thinking
that
this
could
be.
D
Yeah
like
an
object
right,
but
I
want
to
try
to
map
this
as
closely
to
what
yeah.
C
Because
I
kind
of
think
like
the
two
cases
I
think
we
were
trying
to
cover
that
are
maybe
could
use
a
different
configuration
name,
are
there's
kind
of
two
scenarios.
There's
I'm
going
to
accept
10
copies
of
foo
versus.
I
want
to
only
use
the
last
value.
I
was
provided
of
foo,
if
you,
if
you
just
always
like,
I
think,
with
your
simplified
approach,
you
wouldn't
even
need
both
of
those
configuration
settings.
To
be
honest,
like
I
think.
C
I'm
just
thinking
the
only
annoying
thing
is
like:
if
the
value
was
always
an
array
of
strings,
then
you
could
implement
both
approaches,
because
if
you,
if
you
only
want
to
use
the
last
value,
you
just
take
the
very
last
thing
the
list
and
that's
what
you've
set
the
argument
to
and
if
you
want
to
accept
an
array
of
values,
you
just
use
the
whole
array.
C
D
Yeah
and
I'm
imagining
the
99
case
is
truly
this
like
where
you're
gonna
use.
You
know
these
two
lines:
you're
gonna
essentially
do
parse,
args
and
and
use
the
args
whether
or
not
the
flag
or
option
that
you've
provided.
Is
there
not
not
necessarily
the
value?
And
that's
that's
where
I've
tried
to
like
really
delineate
like
the
the
problem
space,
so
that,
like
we,
don't
have
to
try
to
play
in
the
coercion
or
or
inference
of
like
the
values
and
if
we
don't
touch
those
and
leave
them
as
strings.
C
C
A
Yeah
yeah,
I
agree
with
ben
now
that
he
has
articulated
that.
That
makes
sense
to
me.
B
Yeah,
I
also
agree-
and
I
was
gonna
say
I
do
kind
of
like
the
idea
of
splitting
out,
like
the
presence
of
an
argument
versus
the
value,
because
I
think
that's
where
some
of
that
coercion
came
in
like
okay,
this
value
is
undefined.
Does
that
mean
they
passed
undefined?
Does
that
mean
they
didn't
pass
it
at
all
like?
So
I
do
like
the
being
more
explicit
about
that
yep.
C
No,
I
really
like
this
because
I
think,
if
you're
like
building
a
really
simple
cli
that
takes
arguments
like
that
are
values,
then
you
just
use
the
values.
So
it's
just
all
these
values
foo,
if
you
just
do
care
about
booleans
you're,
usually
only
using
args
foo
right
and
I
don't
think
we
lose
any
information.
Do.
D
Information
loss
at
all.
It's
just
that
by
breaking
those
two
things
out.
I
think
you
really
have
you
know
we
we
don't
have
to
play
again.
I
started
to
show
how
you
could
essentially
start
to
create,
like
validation
and
like
essentially
walk
over
these
objects.
You
can
even
essentially
like
do
a
spread,
operation
and
and
and
collapse
these
back
two
together.
If
you
wanted
that
right,
like
yeah.
C
Oh
did
you
know,
I
do
have
one
idea
why
with
values
might
still
be
useful,
but-
and
so
the
one
issue
you
have
is
with
positional
arguments,
because
if,
if
we
don't
know
a
value
as
a
boolean,
here's
the
problem
like
differentiating
between
dash
dash
foo
with
the
positional
after
it
versus
dash
dash
foo
with
the
value
of
that
positional
being
assigned
to
it
like,
like.
C
That's
that's
where
you
start
to
get
the
ambiguity
and
the
problem
is
that
if
you
hand
a
user,
your
cli
they're
not
going
to
know
to
put
the
equal
sign
between
values.
That's
too
con.
That's
true!
Constrictive
from
my
point
of
view
is
people
like
to
this
is
a
user-facing
thing
someone's
going
to
grab
your
little
command
line,
application,
you've,
built
and
they're
going
to
try
putting
in
dash
dash
food
without
an
equal
sign,
dash
dash
foo
with
a
space
they're
going
to
just
play
around
with
it.
C
I'm
just
thinking
like
like,
maybe
maybe
I'm
saying
we
don't-
need
the
positionals
functionality,
though,
because
because
maybe
you
would
maybe
then,
as
someone
running
the
parser,
you
would
have
to
know
oh
foo
actually
yeah.
I
think
that
this
works
so
imagine
that
imagine
you're
building
a
program
I'm
looking
at
foo
equals
true
on
the
right
hand,
side
there
imagine
you're,
building
a
program
where.
C
C
If
you
use
the
approach
you're
advocating,
I
think
we
can.
We
can
still
support
it
because
the
parser
can
say
the
value
of
foo
is
banana,
but
I
know
I
want
food
to
be
boolean
bananas,
not
true
or
false,
so
I'm
actually
going
to
treat
banana
as
a
positional.
So
so
I
think
I
don't.
I
think
I
have
enough
information
in
values
and
args
to
if
I
was
writing
a
more
complicated
command
line.
Parser
do
a
little
bit
of
validation
and
then
push
the
appropriate
things
into
a
positionals
array.
C
D
No,
it's
okay
like
again,
like
kind
of
like
making
it
easier
for
you
to
be
like
identifying
flags
versus
like
you
know,
I
I
imagine
positionals
would
be
useful
for,
like
you
know,
for
npm,
it's
like
sub
commands
right
like.
C
A
A
Let's
do
what
you
were
talking
about,
yeah
like
file
and
then
two
files.
You
know
imagining
you're
you're
passing
two
files
to
some.
D
Tooling,
so
let's
do
I
don't
know
why
that
became
json,
so
you're,
saying
file
name.
D
So
in
this
case
and
what
what
are
you
passing
to,
are
you
passing
anything
to
parsegs
or
no?
Oh,
you
tell
me
okay.
So
how
would
you
like
this
to
be
returned?
Because,
right
now,
let's
say
that
you
get
back
args
values
and
positionals
right
yeah?
What
would
be
returned
essentially
in
args
would
be.
D
Args
it'd
be
files
file
is
true
and
then
with
values.
It
would
be.
D
Positionals
sorry,
this
would
actually
not
be
empty,
it'd
be
undefined
and
then
positionals
would
be
a
and
b.
A
C
I
think
it
would
be
hard
to
go
back
to
where
you
were,
but
what
I
will
say,
though
joe
is
in
yarg's,
and
I
think
it's
the
right
approach.
If
the
the
way
I
advocate
a
raise,
whether
you'd
be
you'd
actually
have
foo
multiple
times
so
you'd
have
like
dash
dash
foo
a
dash
dash
foo
b
c,
and
I
think
we
could
probably
make
that
work
with
with
values.
I
think.
D
D
This
c
right,
and
then
we
did
with
value
foo.
What
would
happen
today
is
that
a
foo
would
be,
let's
see.
D
So
let's
do
the
exact
same
example,
but
now
you
say
multiples
and
then
foo
and
now
you
essentially
have
values,
is
now
an
array
of
a
b
and
c
and
c,
and
then
you
get
rid
of
the
sorry.
Positionals
are
no
longer
in
both
these
cases.
There's
no
positionals.
C
C
D
D
Yeah,
sorry,
I
I
mixed
that
up
yeah
again
this
the
reason
why
I
want
to
do
essentially
this
design
work
and
bring
this
first
as
a
design
and
update
the
is
just
again
so
we
can
ideate
come
to
the
consensus,
and
then
this
is
again
like
kind
of
the
approach
that
I
talked
with
joe
about
like
like
that,
we
like.
I
think
this
is
the
right
way
to
like
present
it
before
we
go
and
do
any
work
again
right
so
yeah.
How
do
you
think
about
this
ben,
like
in
terms
of
that.
C
A
C
As
long
as
they
keep
their
ordering,
then
I
think
the
person
could
get
the
behavior
of
with
value
without
multiples
with
one
less
setting
right,
because
you
just
if
you
only
care
about
the
last
value,
just
take
the
last
value,
otherwise
turn
it
into
an
array.
If
we
provided
it
multiple
times
and
just
proves
one
configuration
setting,
which
is
maybe
nice.
C
And
then
you
get
one
if
you're
with
values
is
yeah
exactly,
and
it
might
be
more
if
you've
provided
foo
three
times
the
the
like
a
b
case,
where,
like
you,
would
want
food
to
get
a
and
b.
I
think
that's
that's
just
riddled
with
parsing
edge
cases
like
I
I
I
don't
even
have
that
turned
on
by
default
in
yards,
because
I
think
it
creates,
I
think,
creates
a
pain
in
the
neck.
A
C
B
I
think
I
I
like
this
in
general.
I
think
it
would
be
great
to
to
share
this
doc
and
then
maybe
we
can
like
I'd,
be
curious
to
look
at
some
of
the
clies
that
I've
written
and
you
know
see
if
this
handles
all
the
cases,
but
in
general
I
like
it
a
lot.
I
like
the
I
like
that
it's
been
simplified.
B
I
like
that.
I
mean
basically
there's
no
way
for
this
to
throw
an
error
or
an
exception,
now
right,
you're,
going
to
end
up
with
whatever
parsed
arguments,
and
then
it's
kind
of
up
to
you
to
if
you
want
to
validate
those
in
some
way
to
do
that
right.
B
Yeah,
I
was
not,
I
was
in
the
original
discussion.
I
was
kind
of
against
the
idea
of
it
ever
throwing,
and
so
I
think,
just
removing
that
concern
is
great.
B
I
one
thing
I
will
say
so
yeah
I
mean
it
sounds
like
we're
all
on
board
with
this,
and
we
all
we
all
like
this.
I
think
this
is
different
enough
from
the
original
proposal
that
we're
going
to
probably
get
a
new
set
of
concerns
and
comments.
D
So
I
mean
again
kind
of
looking
at
the
changes
here
between
the
two
docs
like
I
do.
I
do
definitely
want
to
like
round
this
out.
Maybe
put
this
into
a
dock
that,
like
we,
can
collaborate
on
or
like
just
give
the
hackmd
reference
in
an
issue
in
the
node
tooling
working
group.
D
First,
let's
like
really
hammer
this
and
and
and
provide
a
whole
bunch
of
examples
and
then
and
then
really
flush
this
out
and
then
my
hope
is
that
actually
like,
we
would
provide
that
or
get
some
reviews
done
and
almost
get
like
approval
before
we
do
the
work.
It's
almost
like
it's
the
rfc
process
that
you
know
we'll
get
the
approval
of
from
the
folks,
especially
the
folks
that
had
sort
of
contentious
like
feedback
before.
D
B
Yeah,
I'm
definitely
not
saying
that
it
being
different
is
a
reason
we
we
shouldn't
do
it.
I
think
this
is
an
improvement
I
am
just
you
know.
I
think
I
think
we
are
going
to
get
kind
of
like
another
round
of
of
yeah.
That's.
B
A
C
And
I
think
it
I
think
it
definitely
covers
the
80
case,
which
is
great.
B
Yeah
definitely
please
share
that
that
heck,
md
doc
and
then
yeah,
I'm
curious
to,
like
I
said,
look
at
some
of
the
the
cli
that
I've
built
and
just
you
know,
make
sure
it's
kind
of
doing
what
what
I
would
expect
it
to
do.
Yeah.
D
D
C
Yeah
well
I'd
love,
for
I
could
imagine
us
exposing
some
more
little
helpers
right
out
of
node,
so
he
could
like
because
python
you
can
run
an
http
server
with,
I
think,
like
python
server
or
something
like
it
would
be
neat
to
be
able
to
do
like
node,
fs
rm
and
get
rid
of
a
folder,
because
that's
something
you
have
to
do
in
your
mpm
scripts.
All
the
darn
time,
like
I,
I
think,
just
having.
No,
I
think,
having
a
command
line.
I
think,
having
a
command
line
parser
in
node.
D
A
Once
once,
if
you
want
to
go
over
the
design
dock
again,
darcy
just
to
make
sure
what
we
talked
about
is
is
clear
and
examples
look
good
and
we
can
share
it.
I'm
happy
to
start
looking
into
implementation
and
we
can
go
from
there.
Yeah.
D
Yeah,
I
don't
have
that
much
time
day
to
day,
so
if
we
can,
I
can
help,
like
you
know,
manifest
this
in
some
way
and
then
and
yeah
that'd
be
great.
B
A
D
How's
your
week
been
multiple
multiple,
multiple
days
with
multiple
pots
of
coffee.
No,
no!
It's
it's!
It's
been
to
keep
up
with
all
the
great
news
and
then
folks,
giving
you
know.
It's
been
a
good
response
so
far
and
yeah
we're
staying
top
on
top
of
feedback,
and
we
want
people
to
roll
forward
with
us.
So
yeah,
it's
great
like
big
performance
improvements
and
and
like
a
lot
of
yeah,
just
a
lot,
a
lot
of
wins.
So
that's
great!
Congratulations.
D
A
Cool,
so
you
know
maybe
ping
us
when
you
can
share
the
doc
and
we
can.
We
can
iterate
and
go
forward
on
that.
I
look
forward
to
it
sounds
good.
All
right
take
care.
Everyone,
yeah
have
a
good
weekend.