{"version":3,"file":"static/js/micromark-vendor.1ac75dfd.js","mappings":"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","sources":["../node_modules/micromark/lib/initialize/content.js","../node_modules/micromark/lib/initialize/document.js","../node_modules/micromark/lib/initialize/flow.js","../node_modules/micromark/lib/initialize/text.js","../node_modules/micromark/lib/create-tokenizer.js","../node_modules/micromark/lib/constructs.js","../node_modules/micromark/lib/parse.js","../node_modules/micromark/lib/postprocess.js","../node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const content = {\n tokenize: initializeContent\n}\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n const contentStart = effects.attempt(\n this.parser.constructs.contentInitial,\n afterContentStartConstruct,\n paragraphInitial\n )\n /** @type {Token} */\n\n let previous\n return contentStart\n /** @type {State} */\n\n function afterContentStartConstruct(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('lineEnding')\n effects.consume(code)\n effects.exit('lineEnding')\n return factorySpace(effects, contentStart, 'linePrefix')\n }\n /** @type {State} */\n\n function paragraphInitial(code) {\n effects.enter('paragraph')\n return lineStart(code)\n }\n /** @type {State} */\n\n function lineStart(code) {\n const token = effects.enter('chunkText', {\n contentType: 'text',\n previous\n })\n\n if (previous) {\n previous.next = token\n }\n\n previous = token\n return data(code)\n }\n /** @type {State} */\n\n function data(code) {\n if (code === null) {\n effects.exit('chunkText')\n effects.exit('paragraph')\n effects.consume(code)\n return\n }\n\n if (markdownLineEnding(code)) {\n effects.consume(code)\n effects.exit('chunkText')\n return lineStart\n } // Data.\n\n effects.consume(code)\n return data\n }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\n\nexport const document = {\n tokenize: initializeDocument\n}\n/** @type {Construct} */\n\nconst containerConstruct = {\n tokenize: tokenizeContainer\n}\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n const self = this\n /** @type {StackItem[]} */\n\n const stack = []\n let continued = 0\n /** @type {TokenizeContext|undefined} */\n\n let childFlow\n /** @type {Token|undefined} */\n\n let childToken\n /** @type {number} */\n\n let lineStartOffset\n return start\n /** @type {State} */\n\n function start(code) {\n // First we iterate through the open blocks, starting with the root\n // document, and descending through last children down to the last open\n // block.\n // Each block imposes a condition that the line must satisfy if the block is\n // to remain open.\n // For example, a block quote requires a `>` character.\n // A paragraph requires a non-blank line.\n // In this phase we may match all or just some of the open blocks.\n // But we cannot close unmatched blocks yet, because we may have a lazy\n // continuation line.\n if (continued < stack.length) {\n const item = stack[continued]\n self.containerState = item[1]\n return effects.attempt(\n item[0].continuation,\n documentContinue,\n checkNewContainers\n )(code)\n } // Done.\n\n return checkNewContainers(code)\n }\n /** @type {State} */\n\n function documentContinue(code) {\n continued++ // Note: this field is called `_closeFlow` but it also closes containers.\n // Perhaps a good idea to rename it but it’s already used in the wild by\n // extensions.\n\n if (self.containerState._closeFlow) {\n self.containerState._closeFlow = undefined\n\n if (childFlow) {\n closeFlow()\n } // Note: this algorithm for moving events around is similar to the\n // algorithm when dealing with lazy lines in `writeToChild`.\n\n const indexBeforeExits = self.events.length\n let indexBeforeFlow = indexBeforeExits\n /** @type {Point|undefined} */\n\n let point // Find the flow chunk.\n\n while (indexBeforeFlow--) {\n if (\n self.events[indexBeforeFlow][0] === 'exit' &&\n self.events[indexBeforeFlow][1].type === 'chunkFlow'\n ) {\n point = self.events[indexBeforeFlow][1].end\n break\n }\n }\n\n exitContainers(continued) // Fix positions.\n\n let index = indexBeforeExits\n\n while (index < self.events.length) {\n self.events[index][1].end = Object.assign({}, point)\n index++\n } // Inject the exits earlier (they’re still also at the end).\n\n splice(\n self.events,\n indexBeforeFlow + 1,\n 0,\n self.events.slice(indexBeforeExits)\n ) // Discard the duplicate exits.\n\n self.events.length = index\n return checkNewContainers(code)\n }\n\n return start(code)\n }\n /** @type {State} */\n\n function checkNewContainers(code) {\n // Next, after consuming the continuation markers for existing blocks, we\n // look for new block starts (e.g. `>` for a block quote).\n // If we encounter a new block start, we close any blocks unmatched in\n // step 1 before creating the new block as a child of the last matched\n // block.\n if (continued === stack.length) {\n // No need to `check` whether there’s a container, of `exitContainers`\n // would be moot.\n // We can instead immediately `attempt` to parse one.\n if (!childFlow) {\n return documentContinued(code)\n } // If we have concrete content, such as block HTML or fenced code,\n // we can’t have containers “pierce” into them, so we can immediately\n // start.\n\n if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n return flowStart(code)\n } // If we do have flow, it could still be a blank line,\n // but we’d be interrupting it w/ a new container if there’s a current\n // construct.\n\n self.interrupt = Boolean(\n childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n )\n } // Check if there is a new container.\n\n self.containerState = {}\n return effects.check(\n containerConstruct,\n thereIsANewContainer,\n thereIsNoNewContainer\n )(code)\n }\n /** @type {State} */\n\n function thereIsANewContainer(code) {\n if (childFlow) closeFlow()\n exitContainers(continued)\n return documentContinued(code)\n }\n /** @type {State} */\n\n function thereIsNoNewContainer(code) {\n self.parser.lazy[self.now().line] = continued !== stack.length\n lineStartOffset = self.now().offset\n return flowStart(code)\n }\n /** @type {State} */\n\n function documentContinued(code) {\n // Try new containers.\n self.containerState = {}\n return effects.attempt(\n containerConstruct,\n containerContinue,\n flowStart\n )(code)\n }\n /** @type {State} */\n\n function containerContinue(code) {\n continued++\n stack.push([self.currentConstruct, self.containerState]) // Try another.\n\n return documentContinued(code)\n }\n /** @type {State} */\n\n function flowStart(code) {\n if (code === null) {\n if (childFlow) closeFlow()\n exitContainers(0)\n effects.consume(code)\n return\n }\n\n childFlow = childFlow || self.parser.flow(self.now())\n effects.enter('chunkFlow', {\n contentType: 'flow',\n previous: childToken,\n _tokenizer: childFlow\n })\n return flowContinue(code)\n }\n /** @type {State} */\n\n function flowContinue(code) {\n if (code === null) {\n writeToChild(effects.exit('chunkFlow'), true)\n exitContainers(0)\n effects.consume(code)\n return\n }\n\n if (markdownLineEnding(code)) {\n effects.consume(code)\n writeToChild(effects.exit('chunkFlow')) // Get ready for the next line.\n\n continued = 0\n self.interrupt = undefined\n return start\n }\n\n effects.consume(code)\n return flowContinue\n }\n /**\n * @param {Token} token\n * @param {boolean} [eof]\n * @returns {void}\n */\n\n function writeToChild(token, eof) {\n const stream = self.sliceStream(token)\n if (eof) stream.push(null)\n token.previous = childToken\n if (childToken) childToken.next = token\n childToken = token\n childFlow.defineSkip(token.start)\n childFlow.write(stream) // Alright, so we just added a lazy line:\n //\n // ```markdown\n // > a\n // b.\n //\n // Or:\n //\n // > ~~~c\n // d\n //\n // Or:\n //\n // > | e |\n // f\n // ```\n //\n // The construct in the second example (fenced code) does not accept lazy\n // lines, so it marked itself as done at the end of its first line, and\n // then the content construct parses `d`.\n // Most constructs in markdown match on the first line: if the first line\n // forms a construct, a non-lazy line can’t “unmake” it.\n //\n // The construct in the third example is potentially a GFM table, and\n // those are *weird*.\n // It *could* be a table, from the first line, if the following line\n // matches a condition.\n // In this case, that second line is lazy, which “unmakes” the first line\n // and turns the whole into one content block.\n //\n // We’ve now parsed the non-lazy and the lazy line, and can figure out\n // whether the lazy line started a new flow block.\n // If it did, we exit the current containers between the two flow blocks.\n\n if (self.parser.lazy[token.start.line]) {\n let index = childFlow.events.length\n\n while (index--) {\n if (\n // The token starts before the line ending…\n childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…\n (!childFlow.events[index][1].end || // …or ends after it.\n childFlow.events[index][1].end.offset > lineStartOffset)\n ) {\n // Exit: there’s still something open, which means it’s a lazy line\n // part of something.\n return\n }\n } // Note: this algorithm for moving events around is similar to the\n // algorithm when closing flow in `documentContinue`.\n\n const indexBeforeExits = self.events.length\n let indexBeforeFlow = indexBeforeExits\n /** @type {boolean|undefined} */\n\n let seen\n /** @type {Point|undefined} */\n\n let point // Find the previous chunk (the one before the lazy line).\n\n while (indexBeforeFlow--) {\n if (\n self.events[indexBeforeFlow][0] === 'exit' &&\n self.events[indexBeforeFlow][1].type === 'chunkFlow'\n ) {\n if (seen) {\n point = self.events[indexBeforeFlow][1].end\n break\n }\n\n seen = true\n }\n }\n\n exitContainers(continued) // Fix positions.\n\n index = indexBeforeExits\n\n while (index < self.events.length) {\n self.events[index][1].end = Object.assign({}, point)\n index++\n } // Inject the exits earlier (they’re still also at the end).\n\n splice(\n self.events,\n indexBeforeFlow + 1,\n 0,\n self.events.slice(indexBeforeExits)\n ) // Discard the duplicate exits.\n\n self.events.length = index\n }\n }\n /**\n * @param {number} size\n * @returns {void}\n */\n\n function exitContainers(size) {\n let index = stack.length // Exit open containers.\n\n while (index-- > size) {\n const entry = stack[index]\n self.containerState = entry[1]\n entry[0].exit.call(self, effects)\n }\n\n stack.length = size\n }\n\n function closeFlow() {\n childFlow.write([null])\n childToken = undefined\n childFlow = undefined\n self.containerState._closeFlow = undefined\n }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContainer(effects, ok, nok) {\n return factorySpace(\n effects,\n effects.attempt(this.parser.constructs.document, ok, nok),\n 'linePrefix',\n this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n )\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {InitialConstruct} */\nexport const flow = {\n tokenize: initializeFlow\n}\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n const self = this\n const initial = effects.attempt(\n // Try to parse a blank line.\n blankLine,\n atBlankEnding, // Try to parse initial flow (essentially, only code).\n effects.attempt(\n this.parser.constructs.flowInitial,\n afterConstruct,\n factorySpace(\n effects,\n effects.attempt(\n this.parser.constructs.flow,\n afterConstruct,\n effects.attempt(content, afterConstruct)\n ),\n 'linePrefix'\n )\n )\n )\n return initial\n /** @type {State} */\n\n function atBlankEnding(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('lineEndingBlank')\n effects.consume(code)\n effects.exit('lineEndingBlank')\n self.currentConstruct = undefined\n return initial\n }\n /** @type {State} */\n\n function afterConstruct(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('lineEnding')\n effects.consume(code)\n effects.exit('lineEnding')\n self.currentConstruct = undefined\n return initial\n }\n}\n","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n return {\n tokenize: initializeText,\n resolveAll: createResolver(\n field === 'text' ? resolveAllLineSuffixes : undefined\n )\n }\n /** @type {Initializer} */\n\n function initializeText(effects) {\n const self = this\n const constructs = this.parser.constructs[field]\n const text = effects.attempt(constructs, start, notText)\n return start\n /** @type {State} */\n\n function start(code) {\n return atBreak(code) ? text(code) : notText(code)\n }\n /** @type {State} */\n\n function notText(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n\n effects.enter('data')\n effects.consume(code)\n return data\n }\n /** @type {State} */\n\n function data(code) {\n if (atBreak(code)) {\n effects.exit('data')\n return text(code)\n } // Data.\n\n effects.consume(code)\n return data\n }\n /**\n * @param {Code} code\n * @returns {boolean}\n */\n\n function atBreak(code) {\n if (code === null) {\n return true\n }\n\n const list = constructs[code]\n let index = -1\n\n if (list) {\n while (++index < list.length) {\n const item = list[index]\n\n if (!item.previous || item.previous.call(self, self.previous)) {\n return true\n }\n }\n }\n\n return false\n }\n }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\nfunction createResolver(extraResolver) {\n return resolveAllText\n /** @type {Resolver} */\n\n function resolveAllText(events, context) {\n let index = -1\n /** @type {number|undefined} */\n\n let enter // A rather boring computation (to merge adjacent `data` events) which\n // improves mm performance by 29%.\n\n while (++index <= events.length) {\n if (enter === undefined) {\n if (events[index] && events[index][1].type === 'data') {\n enter = index\n index++\n }\n } else if (!events[index] || events[index][1].type !== 'data') {\n // Don’t do anything if there is one data token.\n if (index !== enter + 2) {\n events[enter][1].end = events[index - 1][1].end\n events.splice(enter + 2, index - enter - 2)\n index = enter + 2\n }\n\n enter = undefined\n }\n }\n\n return extraResolver ? extraResolver(events, context) : events\n }\n}\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\n\nfunction resolveAllLineSuffixes(events, context) {\n let eventIndex = 0 // Skip first.\n\n while (++eventIndex <= events.length) {\n if (\n (eventIndex === events.length ||\n events[eventIndex][1].type === 'lineEnding') &&\n events[eventIndex - 1][1].type === 'data'\n ) {\n const data = events[eventIndex - 1][1]\n const chunks = context.sliceStream(data)\n let index = chunks.length\n let bufferIndex = -1\n let size = 0\n /** @type {boolean|undefined} */\n\n let tabs\n\n while (index--) {\n const chunk = chunks[index]\n\n if (typeof chunk === 'string') {\n bufferIndex = chunk.length\n\n while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n size++\n bufferIndex--\n }\n\n if (bufferIndex) break\n bufferIndex = -1\n } // Number\n else if (chunk === -2) {\n tabs = true\n size++\n } else if (chunk === -1) {\n // Empty\n } else {\n // Replacement character, exit.\n index++\n break\n }\n }\n\n if (size) {\n const token = {\n type:\n eventIndex === events.length || tabs || size < 2\n ? 'lineSuffix'\n : 'hardBreakTrailing',\n start: {\n line: data.end.line,\n column: data.end.column - size,\n offset: data.end.offset - size,\n _index: data.start._index + index,\n _bufferIndex: index\n ? bufferIndex\n : data.start._bufferIndex + bufferIndex\n },\n end: Object.assign({}, data.end)\n }\n data.end = Object.assign({}, token.start)\n\n if (data.start.offset === data.end.offset) {\n Object.assign(data, token)\n } else {\n events.splice(\n eventIndex,\n 0,\n ['enter', token, context],\n ['exit', token, context]\n )\n eventIndex += 2\n }\n }\n\n eventIndex++\n }\n }\n\n return events\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n * Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n /** @type {Point} */\n let point = Object.assign(\n from\n ? Object.assign({}, from)\n : {\n line: 1,\n column: 1,\n offset: 0\n },\n {\n _index: 0,\n _bufferIndex: -1\n }\n )\n /** @type {Record} */\n\n const columnStart = {}\n /** @type {Construct[]} */\n\n const resolveAllConstructs = []\n /** @type {Chunk[]} */\n\n let chunks = []\n /** @type {Token[]} */\n\n let stack = []\n /** @type {boolean|undefined} */\n\n let consumed = true\n /**\n * Tools used for tokenizing.\n *\n * @type {Effects}\n */\n\n const effects = {\n consume,\n enter,\n exit,\n attempt: constructFactory(onsuccessfulconstruct),\n check: constructFactory(onsuccessfulcheck),\n interrupt: constructFactory(onsuccessfulcheck, {\n interrupt: true\n })\n }\n /**\n * State and tools for resolving and serializing.\n *\n * @type {TokenizeContext}\n */\n\n const context = {\n previous: null,\n code: null,\n containerState: {},\n events: [],\n parser,\n sliceStream,\n sliceSerialize,\n now,\n defineSkip,\n write\n }\n /**\n * The state function.\n *\n * @type {State|void}\n */\n\n let state = initialize.tokenize.call(context, effects)\n /**\n * Track which character we expect to be consumed, to catch bugs.\n *\n * @type {Code}\n */\n\n let expectedCode\n\n if (initialize.resolveAll) {\n resolveAllConstructs.push(initialize)\n }\n\n return context\n /** @type {TokenizeContext['write']} */\n\n function write(slice) {\n chunks = push(chunks, slice)\n main() // Exit if we’re not done, resolve might change stuff.\n\n if (chunks[chunks.length - 1] !== null) {\n return []\n }\n\n addResult(initialize, 0) // Otherwise, resolve, and exit.\n\n context.events = resolveAll(resolveAllConstructs, context.events, context)\n return context.events\n } //\n // Tools.\n //\n\n /** @type {TokenizeContext['sliceSerialize']} */\n\n function sliceSerialize(token, expandTabs) {\n return serializeChunks(sliceStream(token), expandTabs)\n }\n /** @type {TokenizeContext['sliceStream']} */\n\n function sliceStream(token) {\n return sliceChunks(chunks, token)\n }\n /** @type {TokenizeContext['now']} */\n\n function now() {\n return Object.assign({}, point)\n }\n /** @type {TokenizeContext['defineSkip']} */\n\n function defineSkip(value) {\n columnStart[value.line] = value.column\n accountForPotentialSkip()\n } //\n // State management.\n //\n\n /**\n * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n * `consume`).\n * Here is where we walk through the chunks, which either include strings of\n * several characters, or numerical character codes.\n * The reason to do this in a loop instead of a call is so the stack can\n * drain.\n *\n * @returns {void}\n */\n\n function main() {\n /** @type {number} */\n let chunkIndex\n\n while (point._index < chunks.length) {\n const chunk = chunks[point._index] // If we’re in a buffer chunk, loop through it.\n\n if (typeof chunk === 'string') {\n chunkIndex = point._index\n\n if (point._bufferIndex < 0) {\n point._bufferIndex = 0\n }\n\n while (\n point._index === chunkIndex &&\n point._bufferIndex < chunk.length\n ) {\n go(chunk.charCodeAt(point._bufferIndex))\n }\n } else {\n go(chunk)\n }\n }\n }\n /**\n * Deal with one code.\n *\n * @param {Code} code\n * @returns {void}\n */\n\n function go(code) {\n consumed = undefined\n expectedCode = code\n state = state(code)\n }\n /** @type {Effects['consume']} */\n\n function consume(code) {\n if (markdownLineEnding(code)) {\n point.line++\n point.column = 1\n point.offset += code === -3 ? 2 : 1\n accountForPotentialSkip()\n } else if (code !== -1) {\n point.column++\n point.offset++\n } // Not in a string chunk.\n\n if (point._bufferIndex < 0) {\n point._index++\n } else {\n point._bufferIndex++ // At end of string chunk.\n // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n // strings.\n\n if (point._bufferIndex === chunks[point._index].length) {\n point._bufferIndex = -1\n point._index++\n }\n } // Expose the previous character.\n\n context.previous = code // Mark as consumed.\n\n consumed = true\n }\n /** @type {Effects['enter']} */\n\n function enter(type, fields) {\n /** @type {Token} */\n // @ts-expect-error Patch instead of assign required fields to help GC.\n const token = fields || {}\n token.type = type\n token.start = now()\n context.events.push(['enter', token, context])\n stack.push(token)\n return token\n }\n /** @type {Effects['exit']} */\n\n function exit(type) {\n const token = stack.pop()\n token.end = now()\n context.events.push(['exit', token, context])\n return token\n }\n /**\n * Use results.\n *\n * @type {ReturnHandle}\n */\n\n function onsuccessfulconstruct(construct, info) {\n addResult(construct, info.from)\n }\n /**\n * Discard results.\n *\n * @type {ReturnHandle}\n */\n\n function onsuccessfulcheck(_, info) {\n info.restore()\n }\n /**\n * Factory to attempt/check/interrupt.\n *\n * @param {ReturnHandle} onreturn\n * @param {Record} [fields]\n */\n\n function constructFactory(onreturn, fields) {\n return hook\n /**\n * Handle either an object mapping codes to constructs, a list of\n * constructs, or a single construct.\n *\n * @param {Construct|Construct[]|ConstructRecord} constructs\n * @param {State} returnState\n * @param {State} [bogusState]\n * @returns {State}\n */\n\n function hook(constructs, returnState, bogusState) {\n /** @type {Construct[]} */\n let listOfConstructs\n /** @type {number} */\n\n let constructIndex\n /** @type {Construct} */\n\n let currentConstruct\n /** @type {Info} */\n\n let info\n return Array.isArray(constructs)\n ? /* c8 ignore next 1 */\n handleListOfConstructs(constructs)\n : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n ? handleListOfConstructs([constructs])\n : handleMapOfConstructs(constructs)\n /**\n * Handle a list of construct.\n *\n * @param {ConstructRecord} map\n * @returns {State}\n */\n\n function handleMapOfConstructs(map) {\n return start\n /** @type {State} */\n\n function start(code) {\n const def = code !== null && map[code]\n const all = code !== null && map.null\n const list = [\n // To do: add more extension tests.\n\n /* c8 ignore next 2 */\n ...(Array.isArray(def) ? def : def ? [def] : []),\n ...(Array.isArray(all) ? all : all ? [all] : [])\n ]\n return handleListOfConstructs(list)(code)\n }\n }\n /**\n * Handle a list of construct.\n *\n * @param {Construct[]} list\n * @returns {State}\n */\n\n function handleListOfConstructs(list) {\n listOfConstructs = list\n constructIndex = 0\n\n if (list.length === 0) {\n return bogusState\n }\n\n return handleConstruct(list[constructIndex])\n }\n /**\n * Handle a single construct.\n *\n * @param {Construct} construct\n * @returns {State}\n */\n\n function handleConstruct(construct) {\n return start\n /** @type {State} */\n\n function start(code) {\n // To do: not needed to store if there is no bogus state, probably?\n // Currently doesn’t work because `inspect` in document does a check\n // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n // by not storing.\n info = store()\n currentConstruct = construct\n\n if (!construct.partial) {\n context.currentConstruct = construct\n }\n\n if (\n construct.name &&\n context.parser.constructs.disable.null.includes(construct.name)\n ) {\n return nok(code)\n }\n\n return construct.tokenize.call(\n // If we do have fields, create an object w/ `context` as its\n // prototype.\n // This allows a “live binding”, which is needed for `interrupt`.\n fields ? Object.assign(Object.create(context), fields) : context,\n effects,\n ok,\n nok\n )(code)\n }\n }\n /** @type {State} */\n\n function ok(code) {\n consumed = true\n onreturn(currentConstruct, info)\n return returnState\n }\n /** @type {State} */\n\n function nok(code) {\n consumed = true\n info.restore()\n\n if (++constructIndex < listOfConstructs.length) {\n return handleConstruct(listOfConstructs[constructIndex])\n }\n\n return bogusState\n }\n }\n }\n /**\n * @param {Construct} construct\n * @param {number} from\n * @returns {void}\n */\n\n function addResult(construct, from) {\n if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n resolveAllConstructs.push(construct)\n }\n\n if (construct.resolve) {\n splice(\n context.events,\n from,\n context.events.length - from,\n construct.resolve(context.events.slice(from), context)\n )\n }\n\n if (construct.resolveTo) {\n context.events = construct.resolveTo(context.events, context)\n }\n }\n /**\n * Store state.\n *\n * @returns {Info}\n */\n\n function store() {\n const startPoint = now()\n const startPrevious = context.previous\n const startCurrentConstruct = context.currentConstruct\n const startEventsIndex = context.events.length\n const startStack = Array.from(stack)\n return {\n restore,\n from: startEventsIndex\n }\n /**\n * Restore state.\n *\n * @returns {void}\n */\n\n function restore() {\n point = startPoint\n context.previous = startPrevious\n context.currentConstruct = startCurrentConstruct\n context.events.length = startEventsIndex\n stack = startStack\n accountForPotentialSkip()\n }\n }\n /**\n * Move the current point a bit forward in the line when it’s on a column\n * skip.\n *\n * @returns {void}\n */\n\n function accountForPotentialSkip() {\n if (point.line in columnStart && point.column < 2) {\n point.column = columnStart[point.line]\n point.offset += columnStart[point.line] - 1\n }\n }\n}\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Chunk[]} chunks\n * @param {Pick} token\n * @returns {Chunk[]}\n */\n\nfunction sliceChunks(chunks, token) {\n const startIndex = token.start._index\n const startBufferIndex = token.start._bufferIndex\n const endIndex = token.end._index\n const endBufferIndex = token.end._bufferIndex\n /** @type {Chunk[]} */\n\n let view\n\n if (startIndex === endIndex) {\n // @ts-expect-error `_bufferIndex` is used on string chunks.\n view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n } else {\n view = chunks.slice(startIndex, endIndex)\n\n if (startBufferIndex > -1) {\n // @ts-expect-error `_bufferIndex` is used on string chunks.\n view[0] = view[0].slice(startBufferIndex)\n }\n\n if (endBufferIndex > 0) {\n // @ts-expect-error `_bufferIndex` is used on string chunks.\n view.push(chunks[endIndex].slice(0, endBufferIndex))\n }\n }\n\n return view\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Chunk[]} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\nfunction serializeChunks(chunks, expandTabs) {\n let index = -1\n /** @type {string[]} */\n\n const result = []\n /** @type {boolean|undefined} */\n\n let atTab\n\n while (++index < chunks.length) {\n const chunk = chunks[index]\n /** @type {string} */\n\n let value\n\n if (typeof chunk === 'string') {\n value = chunk\n } else\n switch (chunk) {\n case -5: {\n value = '\\r'\n break\n }\n\n case -4: {\n value = '\\n'\n break\n }\n\n case -3: {\n value = '\\r' + '\\n'\n break\n }\n\n case -2: {\n value = expandTabs ? ' ' : '\\t'\n break\n }\n\n case -1: {\n if (!expandTabs && atTab) continue\n value = ' '\n break\n }\n\n default: {\n // Currently only replacement character.\n value = String.fromCharCode(chunk)\n }\n }\n\n atTab = chunk === -2\n result.push(value)\n }\n\n return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport {\n attention,\n autolink,\n blockQuote,\n characterEscape,\n characterReference,\n codeFenced,\n codeIndented,\n codeText,\n definition,\n hardBreakEscape,\n headingAtx,\n htmlFlow,\n htmlText,\n labelEnd,\n labelStartImage,\n labelStartLink,\n lineEnding,\n list,\n setextUnderline,\n thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n/** @type {Extension['document']} */\n\nexport const document = {\n [42]: list,\n [43]: list,\n [45]: list,\n [48]: list,\n [49]: list,\n [50]: list,\n [51]: list,\n [52]: list,\n [53]: list,\n [54]: list,\n [55]: list,\n [56]: list,\n [57]: list,\n [62]: blockQuote\n}\n/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n [91]: definition\n}\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n [-2]: codeIndented,\n [-1]: codeIndented,\n [32]: codeIndented\n}\n/** @type {Extension['flow']} */\n\nexport const flow = {\n [35]: headingAtx,\n [42]: thematicBreak,\n [45]: [setextUnderline, thematicBreak],\n [60]: htmlFlow,\n [61]: setextUnderline,\n [95]: thematicBreak,\n [96]: codeFenced,\n [126]: codeFenced\n}\n/** @type {Extension['string']} */\n\nexport const string = {\n [38]: characterReference,\n [92]: characterEscape\n}\n/** @type {Extension['text']} */\n\nexport const text = {\n [-5]: lineEnding,\n [-4]: lineEnding,\n [-3]: lineEnding,\n [33]: labelStartImage,\n [38]: characterReference,\n [42]: attention,\n [60]: [autolink, htmlText],\n [91]: labelStartLink,\n [92]: [hardBreakEscape, characterEscape],\n [93]: labelEnd,\n [95]: attention,\n [96]: codeText\n}\n/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n null: [attention, resolveText]\n}\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n null: [42, 95]\n}\n/** @type {Extension['disable']} */\n\nexport const disable = {\n null: []\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\n */\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse(options = {}) {\n /** @type {FullNormalizedExtension} */\n // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n const constructs = combineExtensions(\n // @ts-expect-error Same as above.\n [defaultConstructs].concat(options.extensions || [])\n )\n /** @type {ParseContext} */\n\n const parser = {\n defined: [],\n lazy: {},\n constructs,\n content: create(content),\n document: create(document),\n flow: create(flow),\n string: create(string),\n text: create(text)\n }\n return parser\n /**\n * @param {InitialConstruct} initial\n */\n\n function create(initial) {\n return creator\n /** @type {Create} */\n\n function creator(from) {\n return createTokenizer(parser, initial, from)\n }\n }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * @param {Event[]} events\n * @returns {Event[]}\n */\n\nexport function postprocess(events) {\n while (!subtokenize(events)) {\n // Empty\n }\n\n return events\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Chunk[]}\n */\nconst search = /[\\0\\t\\n\\r]/g\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n let column = 1\n let buffer = ''\n /** @type {boolean|undefined} */\n\n let start = true\n /** @type {boolean|undefined} */\n\n let atCarriageReturn\n return preprocessor\n /** @type {Preprocessor} */\n\n function preprocessor(value, encoding, end) {\n /** @type {Chunk[]} */\n const chunks = []\n /** @type {RegExpMatchArray|null} */\n\n let match\n /** @type {number} */\n\n let next\n /** @type {number} */\n\n let startPosition\n /** @type {number} */\n\n let endPosition\n /** @type {Code} */\n\n let code // @ts-expect-error `Buffer` does allow an encoding.\n\n value = buffer + value.toString(encoding)\n startPosition = 0\n buffer = ''\n\n if (start) {\n if (value.charCodeAt(0) === 65279) {\n startPosition++\n }\n\n start = undefined\n }\n\n while (startPosition < value.length) {\n search.lastIndex = startPosition\n match = search.exec(value)\n endPosition =\n match && match.index !== undefined ? match.index : value.length\n code = value.charCodeAt(endPosition)\n\n if (!match) {\n buffer = value.slice(startPosition)\n break\n }\n\n if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n chunks.push(-3)\n atCarriageReturn = undefined\n } else {\n if (atCarriageReturn) {\n chunks.push(-5)\n atCarriageReturn = undefined\n }\n\n if (startPosition < endPosition) {\n chunks.push(value.slice(startPosition, endPosition))\n column += endPosition - startPosition\n }\n\n switch (code) {\n case 0: {\n chunks.push(65533)\n column++\n break\n }\n\n case 9: {\n next = Math.ceil(column / 4) * 4\n chunks.push(-2)\n\n while (column++ < next) chunks.push(-1)\n\n break\n }\n\n case 10: {\n chunks.push(-4)\n column = 1\n break\n }\n\n default: {\n atCarriageReturn = true\n column = 1\n }\n }\n }\n\n startPosition = endPosition + 1\n }\n\n if (end) {\n if (atCarriageReturn) chunks.push(-5)\n if (buffer) chunks.push(buffer)\n chunks.push(null)\n }\n\n return chunks\n }\n}\n"],"names":["content","tokenize","effects","previous","contentStart","attempt","this","parser","constructs","contentInitial","code","consume","enter","exit","factorySpace","lineStart","token","contentType","next","data","markdownLineEnding","document","childFlow","childToken","lineStartOffset","self","stack","continued","start","length","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","undefined","closeFlow","point","indexBeforeExits","events","indexBeforeFlow","type","end","exitContainers","index","Object","assign","splice","slice","documentContinued","currentConstruct","concrete","flowStart","interrupt","Boolean","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","line","offset","containerContinue","push","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","seen","size","entry","call","ok","nok","disable","null","includes","initial","blankLine","flowInitial","afterConstruct","resolver","resolveAll","createResolver","string","initializeFactory","text","field","notText","atBreak","list","resolveAllLineSuffixes","extraResolver","context","eventIndex","chunks","bufferIndex","tabs","chunk","charCodeAt","column","_index","_bufferIndex","createTokenizer","initialize","from","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","pop","constructFactory","construct","info","addResult","onsuccessfulcheck","sliceSerialize","expandTabs","atTab","result","value","String","fromCharCode","join","serializeChunks","main","state","view","startIndex","startBufferIndex","endIndex","endBufferIndex","sliceChunks","chunkIndex","go","_","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","Array","isArray","handleListOfConstructs","map","def","all","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","partial","name","create","resolve","resolveTo","blockQuote","definition","codeIndented","headingAtx","thematicBreak","setextUnderline","htmlFlow","codeFenced","characterReference","characterEscape","lineEnding","labelStartImage","attention","autolink","htmlText","labelStartLink","hardBreakEscape","labelEnd","codeText","insideSpan","resolveText","attentionMarkers","parse","options","combineExtensions","defaultConstructs","concat","extensions","defined","postprocess","subtokenize","search","preprocess","atCarriageReturn","buffer","encoding","match","startPosition","endPosition","toString","lastIndex","exec","Math","ceil"],"sourceRoot":""}