254 lines
5.4 KiB
Plaintext
254 lines
5.4 KiB
Plaintext
/**
|
||
* @typedef {import('micromark-util-types').Construct} Construct
|
||
* @typedef {import('micromark-util-types').Previous} Previous
|
||
* @typedef {import('micromark-util-types').Resolver} Resolver
|
||
* @typedef {import('micromark-util-types').State} State
|
||
* @typedef {import('micromark-util-types').Token} Token
|
||
* @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
|
||
* @typedef {import('micromark-util-types').Tokenizer} Tokenizer
|
||
*/
|
||
|
||
import {markdownLineEnding} from 'micromark-util-character'
|
||
import {codes, types} from 'micromark-util-symbol'
|
||
import {ok as assert} from 'devlop'
|
||
|
||
/** @type {Construct} */
|
||
export const codeText = {
|
||
name: 'codeText',
|
||
tokenize: tokenizeCodeText,
|
||
resolve: resolveCodeText,
|
||
previous
|
||
}
|
||
|
||
// To do: next major: don’t resolve, like `markdown-rs`.
|
||
/** @type {Resolver} */
|
||
function resolveCodeText(events) {
|
||
let tailExitIndex = events.length - 4
|
||
let headEnterIndex = 3
|
||
/** @type {number} */
|
||
let index
|
||
/** @type {number | undefined} */
|
||
let enter
|
||
|
||
// If we start and end with an EOL or a space.
|
||
if (
|
||
(events[headEnterIndex][1].type === types.lineEnding ||
|
||
events[headEnterIndex][1].type === 'space') &&
|
||
(events[tailExitIndex][1].type === types.lineEnding ||
|
||
events[tailExitIndex][1].type === 'space')
|
||
) {
|
||
index = headEnterIndex
|
||
|
||
// And we have data.
|
||
while (++index < tailExitIndex) {
|
||
if (events[index][1].type === types.codeTextData) {
|
||
// Then we have padding.
|
||
events[headEnterIndex][1].type = types.codeTextPadding
|
||
events[tailExitIndex][1].type = types.codeTextPadding
|
||
headEnterIndex += 2
|
||
tailExitIndex -= 2
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
// Merge adjacent spaces and data.
|
||
index = headEnterIndex - 1
|
||
tailExitIndex++
|
||
|
||
while (++index <= tailExitIndex) {
|
||
if (enter === undefined) {
|
||
if (
|
||
index !== tailExitIndex &&
|
||
events[index][1].type !== types.lineEnding
|
||
) {
|
||
enter = index
|
||
}
|
||
} else if (
|
||
index === tailExitIndex ||
|
||
events[index][1].type === types.lineEnding
|
||
) {
|
||
events[enter][1].type = types.codeTextData
|
||
|
||
if (index !== enter + 2) {
|
||
events[enter][1].end = events[index - 1][1].end
|
||
events.splice(enter + 2, index - enter - 2)
|
||
tailExitIndex -= index - enter - 2
|
||
index = enter + 2
|
||
}
|
||
|
||
enter = undefined
|
||
}
|
||
}
|
||
|
||
return events
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Previous}
|
||
*/
|
||
function previous(code) {
|
||
// If there is a previous code, there will always be a tail.
|
||
return (
|
||
code !== codes.graveAccent ||
|
||
this.events[this.events.length - 1][1].type === types.characterEscape
|
||
)
|
||
}
|
||
|
||
/**
|
||
* @this {TokenizeContext}
|
||
* @type {Tokenizer}
|
||
*/
|
||
function tokenizeCodeText(effects, ok, nok) {
|
||
const self = this
|
||
let sizeOpen = 0
|
||
/** @type {number} */
|
||
let size
|
||
/** @type {Token} */
|
||
let token
|
||
|
||
return start
|
||
|
||
/**
|
||
* Start of code (text).
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* > | \`a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function start(code) {
|
||
assert(code === codes.graveAccent, 'expected `` ` ``')
|
||
assert(previous.call(self, self.previous), 'expected correct previous')
|
||
effects.enter(types.codeText)
|
||
effects.enter(types.codeTextSequence)
|
||
return sequenceOpen(code)
|
||
}
|
||
|
||
/**
|
||
* In opening sequence.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceOpen(code) {
|
||
if (code === codes.graveAccent) {
|
||
effects.consume(code)
|
||
sizeOpen++
|
||
return sequenceOpen
|
||
}
|
||
|
||
effects.exit(types.codeTextSequence)
|
||
return between(code)
|
||
}
|
||
|
||
/**
|
||
* Between something and something else.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function between(code) {
|
||
// EOF.
|
||
if (code === codes.eof) {
|
||
return nok(code)
|
||
}
|
||
|
||
// To do: next major: don’t do spaces in resolve, but when compiling,
|
||
// like `markdown-rs`.
|
||
// Tabs don’t work, and virtual spaces don’t make sense.
|
||
if (code === codes.space) {
|
||
effects.enter('space')
|
||
effects.consume(code)
|
||
effects.exit('space')
|
||
return between
|
||
}
|
||
|
||
// Closing fence? Could also be data.
|
||
if (code === codes.graveAccent) {
|
||
token = effects.enter(types.codeTextSequence)
|
||
size = 0
|
||
return sequenceClose(code)
|
||
}
|
||
|
||
if (markdownLineEnding(code)) {
|
||
effects.enter(types.lineEnding)
|
||
effects.consume(code)
|
||
effects.exit(types.lineEnding)
|
||
return between
|
||
}
|
||
|
||
// Data.
|
||
effects.enter(types.codeTextData)
|
||
return data(code)
|
||
}
|
||
|
||
/**
|
||
* In data.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function data(code) {
|
||
if (
|
||
code === codes.eof ||
|
||
code === codes.space ||
|
||
code === codes.graveAccent ||
|
||
markdownLineEnding(code)
|
||
) {
|
||
effects.exit(types.codeTextData)
|
||
return between(code)
|
||
}
|
||
|
||
effects.consume(code)
|
||
return data
|
||
}
|
||
|
||
/**
|
||
* In closing sequence.
|
||
*
|
||
* ```markdown
|
||
* > | `a`
|
||
* ^
|
||
* ```
|
||
*
|
||
* @type {State}
|
||
*/
|
||
function sequenceClose(code) {
|
||
// More.
|
||
if (code === codes.graveAccent) {
|
||
effects.consume(code)
|
||
size++
|
||
return sequenceClose
|
||
}
|
||
|
||
// Done!
|
||
if (size === sizeOpen) {
|
||
effects.exit(types.codeTextSequence)
|
||
effects.exit(types.codeText)
|
||
return ok(code)
|
||
}
|
||
|
||
// More or less accents: mark as data.
|
||
token.type = types.codeTextData
|
||
return data(code)
|
||
}
|
||
}
|