►
From YouTube: Preserve unchanged Markdown technical exploration
Description
On this call, the Editor team explores the problem of preserving unchanged Markdown in the Content Editor and a potential solution for it.
A
Hello,
everyone,
so
I'm
africa
from
the
ather
team
and
today
we're
gonna,
be
exploring
the
preserve
and
change
markdown
problem
that
we
are
solving
in
the
continuator.
So
the
idea
is
that
we
are
going
to
spend
some
time
in
this
meeting,
understanding
the
problem
and
talking
about
a
solution
that
I
propose
and
pretty
much
like
working
with
the
with
the
team
to
evolve
this
proposal
and
collaborate
on
requirements.
A
This
is
the
first
call
of
a
series
of
weekly
calls
where
we
are
gonna
be
work
where
we
are
gonna
be
working
on
this
program.
So
this
one
is
pretty
much
like
a
high
level
overview
of
the
problem
and
probably
in
next
week
we
are
gonna,
be
doing
some
curing
sessions
or
we
can
just
like
continue
talking
about
this
and
I'm
providing
updates.
A
A
The
second
important
piece
of
of
background
knowledge
is
that
is
a
way
that
the
content
editor
saves
changes
when
a
user
is
editing
markdown,
the
web
browser
doesn't
support
markdown
directly.
It
supports
html
right.
So
when
the
contentor
loads
a
markdown
document
into
a
con
loads,
a
marketing
document,
it
has
to
convert
this
markdown
into
another
format
to
display
in
the
web
browser.
In
the
case
of
the
continator.
It's
a
pros
mirror
document.
A
There
is
an
intermediate
format
between
them
and
the
content.
The
idea
is
that
the
transmitter
document
is
a
more
efficient
data
structure
to
interact
with
in
this
programming
of
doing,
we
see
we
caters,
so
the
continator
is
not
transforming
up
like
only
a
part
of
the
document
is
creating
is
converting
the
entire
markdown
file
into
this
format
and
when
the
user
saves
changes,
it's
transforming
this
object
back
to
the
back
to
markdown
and
it's
creating
the
markdown
from
scratch.
We
are.
A
A
A
This,
where
the
list
marker
you
just
like
repeat
one
one,
one
one
and
then
the
markdown
printer
will
create
the
right
numbers
when
when
is
generating
html,
but
then
the
continuator
doesn't
know
that
it
doesn't
remember
that
and
it
has
its
own
formatting
preferences.
So
it
is
not
following
this:
it's
not
using
this
format
of
list
of
order
disks.
A
What
is
doing
is
just
like
inserting
the
sequential
numbers,
so
that's
a
problem,
because
the
container,
then
is
removing
a
lot
of
formatting
preferences
that
the
user
has
and
at
the
same
time,
when,
in
a
common
situation
at
gitlab,
where
you
are
modifying
a
file,
you
want,
you
create
a
merch
request
or
you
create.
You
create
just
like
some
sort
of
file
of
change
that
should
be
published
and
reviewed.
A
D
A
D
A
D
Okay,
so,
okay,
fair
enough,
you
say
that
the
the
main
problem
is
that
content
editor
sort
of
has
so
to
speak,
has
its
own
opinion
on
the
preferences
of
how
to
format
the
document
and
that's
where
the
the
main
problem
lies
is
it
is
it?
Is
it
technically
possible
to
somehow
synchronize
the
settings
in
the
in
the
content,
editor
and
user
settings
slash
source
editor?
If
we're
talking
about
switching
from
stores
to
content.
A
Yes,
it
is
possible
and
we
could
just
like
configure
the
markdown
serializer
to
understand
those
preferences,
but
there
is
a.
There
is
a
problem
that
I
was
talking,
as
is
a
user
has
intentional
formatting
preferences,
but
that's
not
usually
the
case.
The
case
is
that
there
are,
there
could
be
a
markdown
file
where
there
are
five
users
working
on
it
and
there
is
a
user
that
has
a
formatting
preference
for
headings.
A
Another
one
is
input,
is
writing
headings
in
another
way,
so
that
would
be
helpful
if,
if
every
markdown
file
is
only
implemented
by
it's
only
edited
by
a
single
person,
that's
not
usually
the
case,
and
even
when
it
is
a
single
person
like
even
I
I
should
say
like.
I
am
that
kind
of
person
that
doesn't
have
like
maybe
one
day,
I'm
writing,
at
least
in
one
way
and
then
another
day,
I'm
switching
a
formatting
preference,
a
formatting
preferences.
B
B
A
That
that's
one
of
the
examples
in
this
screenshot
right
this.
This
is
a
single
paragraph
according
to
markdown,
because
they
they
live
in
there.
There
isn't
a
blank
line
between
these
two
pieces
of
text.
The
container
is
just
like
doing
the
right
thing.
That
is
like
compressing
it
and
putting
it
one
sentence
after
the
other,
and
we
don't
want
that.
We
want
to
preserve
why
the
user,
like
decided
to
put
it
in
that
in
that
way,.
E
E
C
C
A
Got
it?
Hopefully,
I
think
that
in
the
case
of
if,
if
we
like,
when
we
talk
about
the
solution,
we
are
adopting
a
client
side,
martial
parser,
and
in
that
case
it
wouldn't
be
like
browsers
that
ignore
comments,
it
could
be
more
like.
Oh
did,
he
have
an
html
note
and
we
can
preserve
it
if
we
want
yeah,
let's
go
to
the
to
the
solution.
A
A
If
the
user
is
working
on
a
part
of
the
document,
we
want
to
focus
on
that
and
everything
else
we
are.
We
are
recovering
that
content
from
the
original
markdown
file.
Don't
change
one!
What
does
that?
Look
like
well,
the
process
of
preserving
change.
Markdown
has
two
phases.
We
have
to
detect
changes,
detect
changes
and
then
we
need
to
to
use
source
maps
to
to
retrieve
the
unchanged
market.
A
So
what
is
change
detection?
The
idea
is
like
with
change
detection.
We
want
to
say:
hey
the
user,
only
modified
this
paragraph,
so,
let's
find
within
the
pros,
mirror
document
the
paragraph
that
was
changed
and
let's
generate
markdown
for
that.
For
all
of
the
other
notes
within
the
document,
we
want
to
identify
them
and
use
the
source
mapping
to
retrieve
the
original
file.
So
why?
And
how
can
we
do
that?
A
A
A
A
Provide,
builds,
build
built-in
support
for
it,
so
we
just
passed
that
html
transmitter
has
a
dom
parser
that
converts
it
that
converts
that
html
into
a
prosperous
document,
and
we
populate
the
continent
with
that
prosperous
document.
What
this
solution
proposes
is
that
we
remove
the
backend
api
completely
and
we
remove
the
html
completely
as
well.
A
Well,
tip
top
is
a
hug
wrapper
around
crossmaker
and
tiptop
consumes
and
generates
prosperous
documents.
So,
when
we
create
like
a
prosperous
document,
has
a
schema
that
defines
the
structure
of
the
document
and
what
is
allowed
in
what
is
and
what
is
denied
by
the
way
should
probably
be
paying
attention
to
the
race
hunt
picture
right.
It's
like
my
first
time.
Oh.
A
A
B
B
A
A
Those,
let's
see,
let's
reverse
the
problem
that
that
I
showed
in
there
that
I
show
up
showed
in
the
in
the
previous
in
the
screenshot
that
I
put
in
the
document
that
it
was
like.
Oh,
this
probably
is
a
a
single
paragraph,
so
this
shouldn't
be
like
the
touchscreen.
Sorry
pros,
mirror
shouldn't
be
doing
that
this,
like
transforming
it
into
something
like
this,
but
the
one
is
like
when
we
restore
this
document.
If
I
didn't
change
this
paragraph
this
paragraph,
I
want
to
keep
this
a
line
break
here.
A
D
A
D
That
would
be,
but
still
it
would
would
mean
that
people
get
commits
with
the
changes
that
they
didn't
intend
to
make
right.
So
in
this
particular
case,
I'm
not
sure
whether
we
will
be
satisfied
with
95
or
even
98
of
the
result,
but
that's
that's
something
that
we
have
to
give
it
give
a
go.
I
I
still
believe
or
like
not
believe
I
don't
have
enough
experience
with
ast
to
to
to
believe
in
it,
but
I
still
think
that
ast
will
produce
accurate
enough
model
for
us
to
to
to
work
with.
A
B
A
A
Can
be
100
confident
that
in
the
notes,
the
block
notes
and
what
what
I
mean
by
block
node
is
paragraph
list
item
block
quote
like
all
of
that
headings
as
well
will
be
completely
restored
because
it's
a
like
we
are.
If,
if
there
are
inline
elements,
that's
a
bit
more
difficult,
but
when
it
is
a
block
element,
we
just
like
completely
retrieve
it
from
the
original
source.
A
A
A
A
We
need
to
implement
new
tokens
in
the
parser
and
yeah,
like
there
is
augmentation
available
for
this
remark
uses
an
underlying
engine
that
is
called
micromark,
which
is
very
small
and
fast,
but
usually
implementing
tokens
is
a
it's
sort
of
a
a
messy
problem.
There
are
many
exceptions
in
the
syntax.
A
We
don't
have
and
expect
a
proper
respect
of
these
features.
We
only
have
six
samples
we
and
we
have
the
documentation,
so
that
makes
it
more
difficult,
because
if
we
had
unexpected,
we
would
have
under
that
respect
all
of
the
edge
cases,
and
it
would
be
just
like
implementing
this,
but
we
don't
have
that
that
kind
of
resource
right
now.
B
So
one
of
the
things
that
I'm
planning
to
do-
and
I've
already
talked
with
david
and
eric
about
this-
is
the
the
current
golden
master
respect
that
we
have
to
do.
What
brett
walker
asked
us
to
do
and
try
to
make
it
everything
that
is
in
common
mark
or
in
github
flavored
markdown
make
it
match
exactly
the
names
of
the
marks.
B
The
structure,
every
example
that
they
have
will
be
represented
one
to
one
in
our
golden
master,
and
then
we
can
be
sure
that
at
least
that's
ensuring
we,
we
never
deviate
from
common
mark
or
github
flavored
markdown
and
then
just
add
only
the
superset
of
what
is
in
get
lab.
Flavor
markdown
that
you
list
here.
So
it's
it's.
Will
that
help
with
the
problem
you
just
said
of,
like
possibly
regressing
of
breaking
other
marks.
If
we
extend
the
ast
for
a
new
one,
you
know
inadvertently.
A
B
A
C
B
A
That's
another
way
of
putting
it
yeah
like
we
could
do
that
that,
like
we
could
say,
hey,
let's
pass
the
mark
down
to
the
mark.
The
markdown
example
to
the
marathon
parser,
the
markdown
parser
generates
approach,
mirror
document,
and
then
we
can
generate
the
html
with
the
prosimular
and
ensure
that
it's
the
same
as
a
golden
master.
A
D
I'm
wondering
how
this
will
work
in
the
in
case
of
of
the
code
snippets
in
the
in
the
document
so
code.
Snippets,
mermaid,
charts
well,
though,
survive
this
transformation,
because
those
those
are
technically
like
I
from
what
I
understand.
Those
are
gitlab,
specific
sugars
as
well,
so
probably
those
those
have
to
be
treated
somehow
special
as
well.
No.
A
A
A
E
E
A
A
B
D
The
point
of
the
point
paul
made
was
that
like,
if
you,
if
the,
if
the
tax
part
that
you
cut,
contains
all
those
like
extra
spaces
and
things
like
this,
those
won't
be
preserved
when
you
place
them
to
the
new
place.
So
that's
that's
the
main
issue.
I'm
I'm
not
sure
whether
it's
an
issue
or
not,
but
that's
that's
just
something
that
that
will
happen.
We
will
lose
the
formatting
in
this
case.
B
E
E
Are
we
starting
at
the
root
and
like
parsing
through,
like
the
whole
tree
or
is,
are
we
keeping
track
of
changes
like
I
like?
I
know
just
this
little
bit
was
changed
and
so
does
that
question
make
sense.
I'm
I'm
trying
to
understand
the
detecting
changes
bit
and
especially
with
the
fact
that
nodes
can
contain
nodes.
E
A
B
D
A
D
E
B
A
Exactly
like
we,
we
start
with
document
d1.
That
is
the
one
that
generated
the
the
parsing
process
and
the
loading
the
document
process,
and
then
we
end
up
with
this
document.
There
is
no
b2,
it's
probably
b
100
or
v1,
and
we,
the
algorithm,
the
one
that
we
implemented
in
in
in
a
an
attempt
that
we
had
at
solving
this
problem
last
year,
was
that
we
we
were
comparing
both
traces
and
detecting,
which
of
the
nodes,
change.
Well,
you've
reviewed
that
that
nurse
request.
E
E
A
new
child
treated
as
it's
changed
like
I
don't
know.
Maybe
we
don't-
maybe
maybe
I
am
over
complicating
it,
so
I'm
coming
from
keeping
track
of
changes
in
file
systems
and
so
file
systems
is
a
tree
as
well
and
those
changes
propagate
up
where
like.
If
I
make
a
change
on
a
nested
file,
it
treats
it
as
that
folder
has
changed
and
that
parent
folder
has
changed,
and
so
I
see
that
as
from
files,
this
is
a
really
great
way
to
track,
not
track
changes
but
quickly
calculate
changes.
E
E
Right
it
bubbles
up
right,
and
so
I
see
this
is
a
tree
structure
too.
How
is
this
I'm
really
curious
like
how
is
this
algorithm,
maybe
similar
or
not
similar
and
like
and
maybe-
and
I
think
I
need
to-
I
need
to
hear
more
about
what
you're
thinking
and
I
know
we're
at
times,
so
I'm
just
throwing
these
out
there
for
my
own
learning
of
what
you're,
anticipating
from
this
this
process,
because.
E
E
I
don't
know
if
it's
a
good
idea
or
not,
but
like
a
lot
of
the
the
git
algorithm
is
very
related
to
this,
which
is
I
find
just
interesting,
and
I
don't
know
if
it's
going
to
be
helpful
or
not,
but
that's
just
interesting
yeah
doing
some
unit
tests
to
for
some
of
those
edge
cases.
That
would
be
amazing.
A
B
A
E
A
E
A
A
So
there
is
a
gitlab
flavor
markdown
allows
like
you,
can
use
custom
characters
to
reference
issues
and
merge
requests
and
milestones
and
in
the
backend
the
way
that
they,
the
vacuum
parser
resolve.
Those
references
is
by
creating
the
database,
and
if
the
user
has
permissions
to
see
those
objects,
then
it
will
transform
those
characters
into
links,
but
obviously
we
cannot
do
that
in
the
in
the
client.
A
We
can
just
defer
reference
resolution
to
another
stage.
For
example,
let's
say
that
we
display
all
of
those
references
in
the
continator
and
then
when
the
user
tries
to
interact
with
one
of
those
references,
we
can
query
the
backend
through
an
api
and
to
see
if
they
I
know
to
resolve
the
reference,
and
if
the
user
doesn't
have
permissions,
it
stays
like
that.
Otherwise
we
display
something
about
the
reference.
A
Another
option
is
just
like
from
the
beginning.
After
the
document
is
parsed.
We
can
send
a
graphical
graphical
query
and
that's
something
that
you
an
idea
that
you
share
with
me
before
and
is
that
well
rough
here
we
can
build
complex
queries
that
are
querying
like
completely
different
resources
in
a
single
call.
B
B
A
B
A
B
A
So
yeah,
that
is
the
second
challenge.
Well,
if
you
don't
have
any
other
questions,
the
last
section
is
about
norms,
and
this
is
about
performance.
We
probably
need
to
measure
performance
for
rendering
large
markdown
files.
This
is
something
that
can
take
even
a
minute
in
the
back
end,
probably
because
of
all
of
the
reference
and
resolutions
all
of
the
reference
resolution
that
is
happening
in
the
back
end
in
the
client.
It
could
take
a
lot
of
time
as
well.
A
A
B
Yeah
always
never
solve
a
problem
performance
problem
unless
you
have
completely
put
metrics
around
it
and
you
have
a
goal
of
what
metric
you're
trying
to
improve
but
yeah.
If
it
is
the
references
and
if
we
take
the
second
approach,
where
it's
just
a
refql
query
yeah
that
can
be
done
as
synchronously
and
can
hydrate
in
the
document
later.
B
And
then
you
know
all
of
the
links
are
normal
and
they're,
not
hydrated.
Yet
we
do
the
background
process.
The
graphql
query:
that's
gonna
go
get
the
reference
data,
but
then
they
go
and
change.
One
of
those
references
before
that
promise
resolves
from
the
background
is:
it
is
gonna,
break
everything
or.