►
From YouTube: SES-mtg: Update on Jessica, Jessie modules
Description
Content begins at 5:45
Before that is mostly figuring out how to use Zoom
A
B
A
B
B
A
A
good
that's,
a
good
idea,
see
if
anybody
showed
up
in
the
old
place.
Let
them
know
about
the
new
voice,
yeah
and
as
soon
as
we
get
past,
all
hi
Daria.
As
soon
as
we
get
past
all
of
these
issues,
these
new
zoom
experience
issues
Michael.
Today's
your
day,
you
get
to
tell
us
about
Jessica
and
met
interpreting
Jesse.
C
C
B
Those
too
I
often
have
them
open.
You
know
chat,
you
can
do
chat
to
everyone
or
individually,
so
make
sure
the
to
field
is
not
like
privately
at
someone.
If
you're
trying
to
tell
everyone
something
it
tends
to
be
sometimes
the
case,
and
then
you
can
emot--.
You
know
to
encourage
the
speaking
person
to
fifty
years
or
to
disapprove
approve
all
these
things
are
in
the
toolbar
and
manage
participants
for
some
reason
you
can
even
go
get
coffee,
I,
guess.
A
A
D
D
D
So
for
a
given
grammar
here
we
have
underscore
tokens
that
are
just
by
convention
tokens
that
get
skipped
by
the
semantic
actions.
So
when
I
say,
grammar
is
underscore
spacing
definition
plus
end
of
file.
I
can
just
pass
that
directly
to
meta
compiler,
which
takes
the
definitions
as
arguments.
Okay,.
A
C
A
C
A
A
D
D
A
D
C
D
D
B
C
D
D
D
To
avoid
infinite
regress
VST
that
we
supply
to
the
bootstrap
is
just
handwritten
or
generated
by
the
parser
earlier,
so
the
peg
tag
basically
takes
these
productions
that
describe
parsing
expression,
grammars
and
it's
it's
a
it's
a
similar
thing
to
be
enough,
except
it
has
prioritized
twice
so
when
you
express
multiple
choices
like
in
this
prefix
roll,
the
slashes
indicate
try
the
first
one.
First,
then,
the
second
one,
then
third,
one
in
the
fourth
of
they
all
fail.
D
So
for
this
rule
or
for
this
sequence
and
hole,
we
get
this
function
called
when
it
parses
correctly
and
has
committed.
So
the
first
argument
is
the
token
for:
are
they
the
semantic
action
for
and-
and
the
second
argument
is
the
semantic
action
for
the
hole
and
then
we're
generating
a
parse
tree
out
of
that.
So
we
say
it's
a
predicate,
followed
by
the
whole
number,
which
is
what
we
got
from
the
whole
Toby.
D
D
D
D
C
C
D
So
as
an
example,
definition
of
array
is
left
bracket
or
right
bracket.
All
my
tokens
have
implicit
fairly
white
space
or,
as
kind
of
explicit,
trailing
whitespace
that
we
define
the
left
bracket
with
trailing
whitespace
and
so
on.
So
the
ws
token
is
the
token
we
use
for
all
of
these
grammars
based
on
Jason.
A
So
let
me
let
me
just
mention
some
things
that
I'm
seeing
that
are
familiar
fill
in
some
of
the
context
is
the
Jason
grammar
is
written
the
way
it
is
in
order
to
be
a
super
grammar,
a
grammar
to
be
inherited
from
in
order
for
sub
grammars,
to
extend
this
grammar
into
successively
larger
subsets
of
JavaScript.
So
that's
what
the
comment
to
be
extended
when
primary
expression
is
and
why
it's
called
primary
expression
is
that
this
is
the
subset
of
what
becomes
primary
expression
as
we
grow
from
Jason
into
larger
subsets
of
JavaScript.
D
A
A
question
about
lines,
31
and
32
sure
so
in
line
32
you're
using
the
star
star
and
not
the
plus
plus
to
just
fill
in
for
for
everybody
else,
one
of
the
the
things
that
Dean
came
up
with
Dean
by
the
way
he
just
joined
us.
But
one
of
the
things
that
Dean
came
up
with
in
some
much
earlier
extended
BNF
exercise
was.
A
Normal,
our
reg
X
and
extended
BNF
have
a
suffix
star,
+
+,
+
question
mark
Dean
came
up
with
the
in
fix
star,
star,
+,
+
+,
meaning,
let's
say
in
this
case
element
star,
star,
comma
means
0
or
more
elements
set
created
by
commas.
Okay
and
then
the
the
semantic
value
of
the
star
star
is
the
list
of
left
of
semantic
values
of
the
left-hand.
Operand
I
use
a
list
of
semantic
values
of
the
successive
element
productions.
In
this
case
the
question
I
have
about
31
verses.
A
D
D
D
C
B
So
also
the
clarification
here,
the
inset
that
you
have
the
white
space
inset
versus
the
you
have
a
I
guess
this
is
a
backslash
or
a
forward,
slash
four
slash
yeah,
so
so
so
aligning
them.
Is
it
aesthetic
only
or
is
it
related
to
the
syntax
of
you
know
the
definition
that
your?
So
if
you
remove
the
spaces
online,
40,
the
you
know,
prefix
spaces
or
the
space
or
whether
we
affect
how
how
like
the
meaning
I,
know.
D
A
So
just
yeah,
one
of
the
other
thing
to
fill
in
for
people
who
are
used
to
nan
peg
parser
generators
is.
This
is
a
the
reason
why
this
thing
explicitly
has
things
like
underbar
white
space
on
the
tokens
is
that
this
is
a
one-level
grammar
in
that
it's
not
doesn't
have
a
separate
lecture
versus
parser.
You
know
for
for
sort
of
normal
practice
outside
of
pegs
that
you
have
a
like
with
yak.
You
have
a
two-level
grammar
where
you've
got
a
lexer.
A
That
gives
you
a
stream
of
tokens
where
the
lexer
defines
the
white
set
white
space
and
sensitivity
and
tosses.
You
know,
and
and
does
not
produce
any
whitespace
information
up
to
the
parser,
and
then
the
parser
just
sees
a
sequence
of
tokens
with
the
peg.
Here
the
peg
is
really
just
seeing
a
sequence
of
characters
and
it's
one
grammar
that's
trying
to
get
all
the
way
up
from
the
characters
to
the
ast,
so
the
whitespace
rules
are
part
of
the
one
level
grammar
so.
D
Here's
some
interesting
stuff
down
here
at
the
bottom.
We
have
the
definition
of
utf-8,
that's
accepted
by
Jason,
so
this
is
a
utf-8
character
with
continuations.
So
essentially
it
defines
the
the
extending
to
utf-8
characters,
but
there
has
a
two
three
or
four
characters
in
that
character.
Sorry,
bytes
I
will
say
yeah.
A
A
B
A
C
D
B
A
D
A
D
A
D
A
The
the
fella,
what
Michael
said
was
he
doesn't
know
if
it
should
be
in
Justin.
We
haven't
talked
about
Justin
yet
so
the
the
the
hierarchies
of
extensions
is
Jason
is
the
base
grammar
the
the
super
yogi,
the
smallest
grammar
in
terms
of
the
success
of
subsets
and
yeah.
It
should
it
should
not
have
backslash
X,
because
it's
not
part
of
Jason
Justin
is
a.
A
Superset
of
Jason
and
subset
of
Jesse,
which
is
essentially
the
JavaScript
expression
grammar
that
does
not
contain
functions,
does
not
contain
declarations.
Just
contains
JavaScript
expressions,
so
we
can.
So
it
is
an
open
question
as
to
what
we
should
and
should
not
include
in
Justin.
That's
part
of
the
JavaScript
expression
grammar
that
we
want
Justin
to
include
that's
a
that's
a
policy
decision
we
can
revisit
when
we
take
it
when
we
come
back
to
looking
at
that
back,
slash
X
should
not
be
part
of
Jason.
Can.
B
B
A
So
we
are,
we
actually
don't
so
that
the
the
the
successive
subsets
are
Jason
is
the
smallest
than
Justin,
then
Jessie,
and
that's
all
that
I
was
trying
to
do
accurately
using
the
quasi
the
quasi
parser
generator.
So
I'm
going
to
assume
that's
all
you're
trying
to
do
accurately
as
well,
and
then
SES
is
really
based
on
the
full
grammar
of
JavaScript,
which
I
was
not
trying
to
represent
with
these
techniques.
And
the
reason
is
that
JavaScript
is
bizarrely
hard
to
parse
and
to
parse
JavaScript
accurately
and
to
Lex.
A
When
you
see
a
a
/,
the
/
could
be
the
beginning
of
a
reg
X
or
it
could
be
a
beginning
of
a
/
/
or
a
slash
star
comment,
or
it
could
be
a
divided
and
in
the
presence
of
semicolon
insertion,
it
becomes
bizarrely
hard
to
know
how
to
interpret
the
slash
so
by
omitting
by
choosing
a
bunch
of
things
to
omit
from
Jessie.
I
was
able
to
have
Jessie,
be
a
proper
subset
of
JavaScript
and
still
not
have
to
worry
about
parameterize
productions.
A
B
There
is
a
point
I'll
just
add
here
and
I'm
gonna.
Try
to
plug
something
I
worked
on
I
will
find
a
regular
expression
that,
if
matched
in
the
right
sequence,
when
you're
matching
the
different
tokens,
it
actually
matches
a
regular
expression.
So
as
long
as
you're,
not
in
a
string
and
as
long
as
you
match
the
regular
expression
I
believe
before
or
after
commas,
it
matches
so
far.
Every
single
regular
expression,
but.
B
D
Okay,
so
this
is
the
Justin
grammar
that
mark
alluded
to
earlier,
so
in
the
each
of
these
cases,
the
endowments
that
we
passed
in
to
make
Justin
wear
the
peg
tag
that
we
generated
and
the
the
previous
JSON
peg.
So
this
is
what
uses
the
peg
extend
syntax,
which
generates
a
new
quasi
quasi
literal
in
tag
that
is
the
peg
grammar
extended
by
the
existing
grammar
in
the
JSON
tag,
if
that
makes
sense,
so
we're
saying
that
all
the
rules
from
jason
peg
are
added
and
we
can
override
them
or
inherit
them
like.
D
Absolutely
that
does
happen,
and
it's
all
based
on
what
priorities
you
need.
So,
if
you
have
to
do
something,
that's
ambiguous
in
the
previous
guy
grammar,
you
have
to
prioritize
your
insertions
about
the
ones
that
are
this
so
here.
This
also
demonstrates
one
other
extension
for
me
in
which
is
the
less
than
and
greater
than
this
brackets
a
number
of
tokens
or
expressions,
and
basically
the
entire
consume
string
by
those
tokens
or
expressions
are,
let's
return
to
the
semantic
action.
I.
D
So
I
to
decompress
this
statement,
so
I'm
looking
for
a
single
quote
and
then
I'm
looking
for
anything
that
is
not
a
single
quote
followed
by
and
if
it
is
not
a
single
quote
than
the
matches
of
the
character
rule,
which
includes
the
escaped
characters
and
back
slashes
and
so
on.
Okay
and
I
want
zero.
More
of
those
then
followed
by
another
single
quote.
The
the
lesson
and
greater-than
are
basically
like
YY
texts
where
you
say
this
is
for
my
semantic
action:
I'm
not
interested
in
the
individual
list
of
characters.
D
A
C
A
D
A
D
D
A
D
A
D
So
we're
assuming,
if
we
get
something
like
that,
because
it's
a
token
we
have
another
rule
that
matches
it,
but
when
we're
specifically
looking
for
new,
no
new
line,
see
between
a
sink
and
a
wage
or
a
sinking
generator
or
a
sinking
function.
For
example,
we
only
care
that
it's
only
whitespace,
but
what
this
doesn't
cover
yet-
and
this
is
imperfect
still
is-
you
should
be
able
to
insert
comments
and
stuff
in
that
in
that
situation.
So.
D
A
A
D
D
A
A
C
D
And
to
make
that
clear
to
the
convention
is
that
for
all
the
white
space
it's
introduced
into
the
tokens
as
trailing
whitespace
all
the
time.
So
for
a
given
token,
we
can
always
assume
we're
not
in
whitespace,
and
we
can
just
match
a
fixed
string.
But
then,
when
we
define
all
our
other
tokens,
we
need
to
insert
whitespace
explicitly.
So
this
rule
on
116
illustrates
that
where
we
want
return
and
then
the
explicit
whitespace
or
none
I
fall
semicolon.
Okay,.
A
D
D
A
A
A
D
This
is
just
a
brief
overview
of
the
grammar.
Alex
I
encourage
anybody
to
look
at
the
source
code
for
which
I
haven't
posted
a
link
lately,
but
so
to
get
a
bit
more
background.
The
whole
point
of
jessica
is
to
provide
a
jessica
environment
and
to
implement
the
majority
of
that
environment
in
jesse
itself.
So
all
of
these
modules
are
written
as
jesse
modules
I'll
just
pop
over
to
the
next
thing.
B
B
D
C
D
B
C
C
D
A
D
D
D
D
Okay,
so
next
thing
I
want
to
say
okay,
so
just
to
give
you
a
sense
of
what
the
typescript
typing's
give
me
in
vs
code
and
in
any
language
that
supports
typescript
language
server,
okay,
I
can
do
Co.
Oh,
this
is
interesting.
Why
is
this
working?
Oh
I?
Didn't!
Do
it
right?
Let
me
try
this
again
I'm,
not
in
the
typescript
file.
If
I
was
in
the
typescript
file,
then
I
could
do
CEO
and
I
do
not
get
console.
I
do
not
get
anything
else.
D
D
A
D
D
I,
don't
and
I
probably
never
will
the
options
that
I've
picked
for
typescript
are
very
simple,
they're,
basically
saying
we're
emitting
yes,
2017
and
all
the
other
things
like
the
in
Turks
are
the
imports.
This
is
the
typescript
file,
or
this
is
the
typescript
file
here
and
the
the
mgs
file
that
contains
the
identical
imports.
So
this
is
interesting.
Very
interesting.
Actually,
I
have
to
look
at
the
up
with
some
work,
but
a
lot
of
these
a
lot
of
these
emitted
code
are
somewhat
useless.
So
using.
A
D
A
D
B
Could
I
ask
you
two
questions
here
sure
so
you're
running
TSC
from
the
command-line
right?
That's
correct:
you're,
not
having
vias
quote
auto
whatever
they
call
it
in
vs
code.
Whenever
you
save
a
nmj
sots
there,
that's
one
option,
the
other.
There
are
two
more
options:
I
wonder.
If
you
explored
or
want
to
explore,
you
could
write
up
a
plugins
trial,
a
compiler
which
is
like
DSC,
but
it
just
it
allows
you
to
pass
a
a
custom
compiler
plug-in.
B
D
Just
to
explain
what
what's
all
I
was
talking
about
is
when
you
use
the
typescript
compiler
API
from
another
JavaScript
program,
you
can
control
a
lot
more
about
what
the
compiler
outputs
and
what
it
parses
as
success.
So
I
do
intend
to
eventually
make
a
type
Jesse
limited
type
of
script.
Compiler.
That
would
be
a
friend
end
for
the
typescript
API.
D
B
The
second
alternative
to
that
which
I
found
very
very
useful,
are
one
of
two
paths:
either
you
use
roll-up
and
compile
separate
modules
or
independent
modules
as
one
of
the
options
of
typescript
that
allows
you
to
save
to
dot
MJS
without
the
Jas
extension
habit
of
renaming
everything
or
you
could
use
sucrase
I
think.
But
that
requires
a
lot
of
tempering,
because
you
know
so
as
to
craze
is
basically
a
how.
B
Like
it's
like
sucrose
but
sucres
like
so
yeah
yeah
yeah,
they
keep,
you
know,
spinning
off
names,
and
so
so
it
basically
is
a
compiler
that
compiles
using
other
compilers,
so
it
uses
babel.
It
uses
typescript.
It
uses
any
of
the
popular
ones
and
it
really
just
limits
to
a
very,
very
limited
subset
of
transformations
to
minimize
the
you
know,
wasteful
rewrite
of
code
that
that
you
know
is
completely
outdated.
I
guess.
A
D
A
D
A
A
A
D
D
A
D
Okay,
so
this
is
the
evaluator
I'll,
be
changing
this
now
that
I
know
that
a
new
experience
or
something
weird
I'll
just
use
some
contents
constants,
but
essentially
what
I
have
is
a
binding
that
defines
a
getter
and
a
setter
for
a
name-
and
this
is
very
scheme
like
we
just
have
a
parent
of
the
binding,
which
is
another
binding
or
undefined,
and
we
can
create
bindings
and
there's
a
when
we
actually
evaluate
a
variable.
We
just
walk
up
the
current
context,
bindings
in
its
environment
pointer,
so
this
is
kind
of
how
it
looks.
D
I,
I
think
the
most
interesting
part
is
down
here
or
where
we
have
different
kinds
of
actions
for
the
context.
We're
basically
saying
this
is
the
context,
the
evaluation
context
that
the
current
context
is
in,
and
we
say
the
actions
are
about
they're
viable
in
that
context.
So
when
we
ask
to
do
about
something
that
is
the
module
actions
and
the
only
thing
I
can
evaluate
is
in
module
and
that
comes
directly
from
what
is
parsed
right
now.
This
interpreter
is
just
ad
hoc.
It's
whatever
I
feel
like
doing
right
now.
D
A
So
this
it
so
so
what
we're
seeing
is
a
start
on
a
meta
interpreter
of
Jesse
in
Jesse,
or
you
know
technically
in
the
typescript
that
should
expand
to
Jesse,
but
where
the
representation
of
the
program
being
interpreted
is
the
ast
representation
that
the
grammar
we
were
looking
at
produces
precisely
yeah.
Okay,.
A
D
A
D
D
So
I'll
go
back
to
the
test
suite
which
is
written
in
typescript,
and
it
doesn't
need
to
be
compiled
because
I
use
a
version
of
just
that
supports
touch
script
directly,
so
I,
don't
know
where
that
same
dot,
disabled.
Let's
try
this
oh
right.
This
is
disabled.
So
this
is
why
I'm
currently
working
on
is
the.
D
D
D
B
D
That's
what
the
the
tag
string
does:
yeah
yeah,
so
the
the
parser
tags
otherwise
can
identify
holes
in
their
parse.
Do
they
get
either
characters
or
they
have
some
semantics,
some
predicates
that
allow
them
to
detect
a
whole
order
to
detect
basically
any
kind
of
any
kind
of
action
you
want
to
do
on
the
par
stream.
You
can
well.
A
D
A
A
D
A
C
D
D
D
A
D
D
D
So
in
all
this
box,
folding
one
of
the
things
we
do
is
we
combine
the
template
with
the
semantic
actions
and
put
that
all
together
before
we
compile
them
up.
So
when
you
first
run
the
grammar,
all
you
get
is
yest.
He
was
specified
the
holes
as
numbers,
but
you
also
get
an
array
of
the
actual
expressions
corresponding
to
those
holes
which
are
the
the
rest
arguments
right
right.
C
A
A
D
D
D
So
one
of
the
things
that
I
could
do
here
is
I,
have
a
reference
types
and
I
import,
a
global
environment
and
stuff
for
these
tests,
so
I
have
access
to
the
the
Jessie
subset
as
well
as
all
the
stuff
that
I
would
get
from
just
plain
node.
Now
one
open
question
that
I
have
not
solved
yet
is
how
do
I
get
to
use
SES
as
the
host
in
the
node.js
environment?
And
this
is
difficult
without
an
implementation
of
import
right.
B
D
Now
I'm,
just
relying
on
the
typescript
typings
to
help
keep
me
in
the
right
subset
and
when
I
have
to
compiler
actually
written,
then
it
will
reveal
all
the
ways
in
which
I
cheated
and
then
from
there.
Hopefully
we
get
to
the
SES
environment.
Before
that
point,
I
said:
we've
been
really
nice
to
have
it
now.
A
Since
all
of
this
is
written
in
Jessie,
Jessie
does
not
have
resource
model
crap
and
therefore
doesn't
need
the
mechanisms
like
the
manifests,
like
you
know,
like
various
other,
that
you
like
the
like
the
support
for
separate
compartments
and
linking
between
different
loaders,
all
of
which
are
motivated
to
support
resource
modules.
All
of
these
things
should
be
pure
modules.
A
A
D
B
Yeah
I
think
he
dropped
off.
I
I
have
a
a
work
in
progress,
module
system
polyfill,
which
works
in
all
the
browsers
and
note
a
common
Jas
and
ESM
and
I'm
looking
for
a
good
cause
or
a
good.
You
know
driving
cause
to
actually
work
on
it
further,
but
would
that
be
a
good,
so
it
doesn't
implement
all
the
hard.
You
know
rough
corners
out
of
esm,
but
it
does
implement
bindings
based.
B
B
D
B
Yeah
that's
easy
like:
if
I
can
you
know
strip
out
just
the
export
default
behavior
and
your
importing
default
I'm
pretty
sure
it?
You
know
it's
a
good
enough
reason
for
me
to
to
go
into
the
code
and
you
know
try
to
make.
It
makes
make
more
sense
like
right
now,
I
made
it
work
to
test
a
lot
of
different
scenarios
like
named
bindings
for
the
you're,
just
focusing
on
defaults.
I'm,
pretty
sure
we
can.
We
can
refine
that
into
a
very,
very
limited
subset
for.
A
A
Since
Jesse
modules
must
all
be,
must
all
obey
those
rules
and
we
had
and
then
at
some
point
part
of
the
meta
interpretive
implementation
of
Jessie
would
be
the
subset
of
those
purity
tracking
rules
that
are
applicable
to
Jesse
I'm,
not
sure
how
much
of
a
simplification
that
is,
but
jesse
is
a
small
subset
of
SES.
So,
potentially
there
is,
you
know,
there's
some
simplification.
A
If
we
just
try
to
imp
the
purity
checking
rules
for
Jesse
and
in
any
case,
the
issue
of
soundness
should
be
an
easier
one
to
examine
in
the
context
of
Jesse
than
it
is
in
the
context
of
full
cest.
That's
what
your
rechecking
rules
under
the
assumptions
actually
result
in
the
pure
The
Cure
value
guarantees
of
the
exports
for
modules
that
we
hope
that
they
result
in.
D
Yeah,
yes,
I
think
it's
getting
close
to
the
point
where
contributions
from
other
people
would
be
greatly
appreciated,
and
this
to
emphasize
this
is
only
one
implementation
of
Jesse,
so
I
don't
want
to
do
anything
that
gives
a
more
advantageous
environment
to
me,
but
maybe
compromises
the
other
people
who
are
trying
to
write
jesse
interpreters.
So
it
would
be
really
great
if
we
could
separate
these
things
out
into
different
modules
that
could
be
used
by
other
people
too.
D
D
C
C
C
C
A
C
A
That
certainly
would
help
the
debugging
experience
so
I
think
as
a
development
tool.
At
least
it's
probably
worth
providing
I
think
as
something
for
the
platforms
to
support
and
I.
Think
it
probably
my
guess,
is
it
probably
isn't,
but
I'll
reserve
judgment
until
I
see
what
it
looks
like
as
a
shim,
but
obviously,
if
it
doesn't
need
to
go
into
the
it
also
does
not
need
to
become
a
proposal,
can
just
be
a
library
right.
C
Well,
I
can
write
it
up
again,
I'd
written
up
a
sample
of
it
based
on
what
Mozilla
had
done,
and
it
turns
out
that
what
they
had
done,
including
their
error
messages,
was
based
not
just
on
the
spec
but
the
Armistice.
Where
identical
to
what
Tom
then
cuts
in
his
implementation.
I'm.
Sorry,
it's
box,
he
had
implementation.
C
D
I
had
one
quick
question
in
regards
to
libraries
who
want
to
provide
to
Jessie
what
are
you
intending
for?
Crypto
I
did
notice
that
I
was
talking
with
ty
from
the
tank
project
and
he's
made
available
some
JavaScript
code
that
they're
using
internally
and
will
become
part
of
tank
1.4
once
they
get
the
build
system
to
work.
What
does
tink
tink
is
continuation
of
Khizar,
which
is
basically
crypto
API.
Is
that
are
hard
to
misuse.
A
A
D
B
A
So
once
we
get
into
despair,
ammeter
izing
membranes
with
distortions
on
I'm,
pretty
sure
you're
correct,
with
respect
to
the
basic
core
membrane
for
Jesse.
What
I'm
thinking?
Let
me
let
me
so
let
me
state
the
hypothesis
and
you
can
tell
me
where
I
might
be
going
wrong.
Is
that
because
Jesse
objects
are
their
properties
are
not
mutable
and
the
objects
are
not
extensible.
A
A
A
A
A
C
A
In
Jessie
does
not
contain
Jessie
itself
does
not
have
reflect
on
the
whitelist
so
and-
and
it
also
does
not
have
get
own
property
descriptor
or
get
on
property
descriptors
or
define
property
on
the
whitelist.
So
you
actually
in
a
standalone
Jessie
implementation.
You
can't
reflectively
sense
whether
a
property
is
an
accessor
property
or
a
data.
Property
I
think
that's
the
hypothesis.
This
is
still
let.
C
A
C
A
C
A
C
A
C
A
C
A
So
the
idea
would
be
that
the
target
has
a
fixed
set
of
named
properties.
Jessie
also
does
not
have
symbols.
Standalone
Jessie
does
not
have
symbols,
so
you
have
a
fixed
set
of
named
own
properties
that
the
proxy
can
just
be
an
object
that
has
the
corresponding
set
of
named
accessor
properties
with
getters
and
no
setters,
where
the
oh,
oh,
actually,
no
with.
A
Well,
let
me
come
back
to
the
setters.
Maybe
it
does
need
setters,
because
the
underlying
heart
doesn't
need
setters,
because
the
underlying
target
can
have
access
or
properties
with
with
getters
and
setters
so
and
therefore
the
proxy
would
have
a
get
trap.
A
set
trap
into
has
trap
and
the
proxies
accessors
would
just
directly
reflect
into
the
handler.