{"version":3,"file":"static/js/2155_1d62ea6bdf68094c7373.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/initialize/content.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/initialize/document.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/initialize/flow.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/initialize/text.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/create-tokenizer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/constructs.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/parse.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/node_modules/micromark/lib/postprocess.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark@3.2.0/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').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const content = {\n tokenize: initializeContent\n}\n\n/**\n * @this {TokenizeContext}\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 let previous\n return contentStart\n\n /** @type {State} */\n function afterContentStartConstruct(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n effects.enter('lineEnding')\n effects.consume(code)\n effects.exit('lineEnding')\n return factorySpace(effects, contentStart, 'linePrefix')\n }\n\n /** @type {State} */\n function paragraphInitial(code) {\n effects.enter('paragraph')\n return lineStart(code)\n }\n\n /** @type {State} */\n function lineStart(code) {\n const token = effects.enter('chunkText', {\n contentType: 'text',\n previous\n })\n if (previous) {\n previous.next = token\n }\n previous = token\n return data(code)\n }\n\n /** @type {State} */\n function data(code) {\n if (code === null) {\n effects.exit('chunkText')\n effects.exit('paragraph')\n effects.consume(code)\n return\n }\n if (markdownLineEnding(code)) {\n effects.consume(code)\n effects.exit('chunkText')\n return lineStart\n }\n\n // Data.\n effects.consume(code)\n return data\n }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\nexport const document = {\n tokenize: initializeDocument\n}\n\n/** @type {Construct} */\nconst containerConstruct = {\n tokenize: tokenizeContainer\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeDocument(effects) {\n const self = this\n /** @type {Array} */\n const stack = []\n let continued = 0\n /** @type {TokenizeContext | undefined} */\n let childFlow\n /** @type {Token | undefined} */\n let childToken\n /** @type {number} */\n let lineStartOffset\n return start\n\n /** @type {State} */\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 }\n\n // Done.\n return checkNewContainers(code)\n }\n\n /** @type {State} */\n function documentContinue(code) {\n continued++\n\n // 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 if (self.containerState._closeFlow) {\n self.containerState._closeFlow = undefined\n if (childFlow) {\n closeFlow()\n }\n\n // Note: this algorithm for moving events around is similar to the\n // algorithm when dealing with lazy lines in `writeToChild`.\n const indexBeforeExits = self.events.length\n let indexBeforeFlow = indexBeforeExits\n /** @type {Point | undefined} */\n let point\n\n // Find the flow chunk.\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 exitContainers(continued)\n\n // Fix positions.\n let index = indexBeforeExits\n while (index < self.events.length) {\n self.events[index][1].end = Object.assign({}, point)\n index++\n }\n\n // Inject the exits earlier (they’re still also at the end).\n splice(\n self.events,\n indexBeforeFlow + 1,\n 0,\n self.events.slice(indexBeforeExits)\n )\n\n // Discard the duplicate exits.\n self.events.length = index\n return checkNewContainers(code)\n }\n return start(code)\n }\n\n /** @type {State} */\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 }\n\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 if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n return flowStart(code)\n }\n\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 // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n // needed in micromark-extension-gfm-table@1.0.6).\n self.interrupt = Boolean(\n childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n )\n }\n\n // Check if there is a new container.\n self.containerState = {}\n return effects.check(\n containerConstruct,\n thereIsANewContainer,\n thereIsNoNewContainer\n )(code)\n }\n\n /** @type {State} */\n function thereIsANewContainer(code) {\n if (childFlow) closeFlow()\n exitContainers(continued)\n return documentContinued(code)\n }\n\n /** @type {State} */\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\n /** @type {State} */\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\n /** @type {State} */\n function containerContinue(code) {\n continued++\n stack.push([self.currentConstruct, self.containerState])\n // Try another.\n return documentContinued(code)\n }\n\n /** @type {State} */\n function flowStart(code) {\n if (code === null) {\n if (childFlow) closeFlow()\n exitContainers(0)\n effects.consume(code)\n return\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\n /** @type {State} */\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 if (markdownLineEnding(code)) {\n effects.consume(code)\n writeToChild(effects.exit('chunkFlow'))\n // Get ready for the next line.\n continued = 0\n self.interrupt = undefined\n return start\n }\n effects.consume(code)\n return flowContinue\n }\n\n /**\n * @param {Token} token\n * @param {boolean | undefined} [eof]\n * @returns {void}\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)\n\n // 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 if (self.parser.lazy[token.start.line]) {\n let index = childFlow.events.length\n while (index--) {\n if (\n // The token starts before the line ending…\n childFlow.events[index][1].start.offset < lineStartOffset &&\n // …and either is not ended yet…\n (!childFlow.events[index][1].end ||\n // …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 }\n\n // Note: this algorithm for moving events around is similar to the\n // algorithm when closing flow in `documentContinue`.\n const indexBeforeExits = self.events.length\n let indexBeforeFlow = indexBeforeExits\n /** @type {boolean | undefined} */\n let seen\n /** @type {Point | undefined} */\n let point\n\n // Find the previous chunk (the one before the lazy line).\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 seen = true\n }\n }\n exitContainers(continued)\n\n // Fix positions.\n index = indexBeforeExits\n while (index < self.events.length) {\n self.events[index][1].end = Object.assign({}, point)\n index++\n }\n\n // Inject the exits earlier (they’re still also at the end).\n splice(\n self.events,\n indexBeforeFlow + 1,\n 0,\n self.events.slice(indexBeforeExits)\n )\n\n // Discard the duplicate exits.\n self.events.length = index\n }\n }\n\n /**\n * @param {number} size\n * @returns {void}\n */\n function exitContainers(size) {\n let index = stack.length\n\n // Exit open containers.\n while (index-- > size) {\n const entry = stack[index]\n self.containerState = entry[1]\n entry[0].exit.call(self, effects)\n }\n stack.length = size\n }\n function closeFlow() {\n childFlow.write([null])\n childToken = undefined\n childFlow = undefined\n self.containerState._closeFlow = undefined\n }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContainer(effects, ok, nok) {\n // Always populated by defaults.\n\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 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const flow = {\n tokenize: initializeFlow\n}\n\n/**\n * @this {TokenizeContext}\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,\n // 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\n /** @type {State} */\n function atBlankEnding(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n effects.enter('lineEndingBlank')\n effects.consume(code)\n effects.exit('lineEndingBlank')\n self.currentConstruct = undefined\n return initial\n }\n\n /** @type {State} */\n function afterConstruct(code) {\n if (code === null) {\n effects.consume(code)\n return\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').Code} Code\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nexport const resolver = {\n resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n\n/**\n * @param {'string' | 'text'} field\n * @returns {InitialConstruct}\n */\nfunction initializeFactory(field) {\n return {\n tokenize: initializeText,\n resolveAll: createResolver(\n field === 'text' ? resolveAllLineSuffixes : undefined\n )\n }\n\n /**\n * @this {TokenizeContext}\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\n /** @type {State} */\n function start(code) {\n return atBreak(code) ? text(code) : notText(code)\n }\n\n /** @type {State} */\n function notText(code) {\n if (code === null) {\n effects.consume(code)\n return\n }\n effects.enter('data')\n effects.consume(code)\n return data\n }\n\n /** @type {State} */\n function data(code) {\n if (atBreak(code)) {\n effects.exit('data')\n return text(code)\n }\n\n // Data.\n effects.consume(code)\n return data\n }\n\n /**\n * @param {Code} code\n * @returns {boolean}\n */\n function atBreak(code) {\n if (code === null) {\n return true\n }\n const list = constructs[code]\n let index = -1\n if (list) {\n // Always populated by defaults.\n\n while (++index < list.length) {\n const item = list[index]\n if (!item.previous || item.previous.call(self, self.previous)) {\n return true\n }\n }\n }\n return false\n }\n }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n * @returns {Resolver}\n */\nfunction createResolver(extraResolver) {\n return resolveAllText\n\n /** @type {Resolver} */\n function resolveAllText(events, context) {\n let index = -1\n /** @type {number | undefined} */\n let enter\n\n // A rather boring computation (to merge adjacent `data` events) which\n // improves mm performance by 29%.\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 enter = undefined\n }\n }\n return extraResolver ? extraResolver(events, context) : events\n }\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 */\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 let tabs\n while (index--) {\n const chunk = chunks[index]\n if (typeof chunk === 'string') {\n bufferIndex = chunk.length\n while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n size++\n bufferIndex--\n }\n if (bufferIndex) break\n bufferIndex = -1\n }\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 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 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 eventIndex++\n }\n }\n return events\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenType} TokenType\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * @callback Restore\n * @returns {void}\n *\n * @typedef Info\n * @property {Restore} 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 */\n\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\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 | undefined} [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 const columnStart = {}\n /** @type {Array} */\n const resolveAllConstructs = []\n /** @type {Array} */\n let chunks = []\n /** @type {Array} */\n let stack = []\n /** @type {boolean | undefined} */\n let consumed = true\n\n /**\n * Tools used for tokenizing.\n *\n * @type {Effects}\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 /**\n * State and tools for resolving and serializing.\n *\n * @type {TokenizeContext}\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 /**\n * The state function.\n *\n * @type {State | void}\n */\n let state = initialize.tokenize.call(context, effects)\n\n /**\n * Track which character we expect to be consumed, to catch bugs.\n *\n * @type {Code}\n */\n let expectedCode\n if (initialize.resolveAll) {\n resolveAllConstructs.push(initialize)\n }\n return context\n\n /** @type {TokenizeContext['write']} */\n function write(slice) {\n chunks = push(chunks, slice)\n main()\n\n // Exit if we’re not done, resolve might change stuff.\n if (chunks[chunks.length - 1] !== null) {\n return []\n }\n addResult(initialize, 0)\n\n // Otherwise, resolve, and exit.\n context.events = resolveAll(resolveAllConstructs, context.events, context)\n return context.events\n }\n\n //\n // Tools.\n //\n\n /** @type {TokenizeContext['sliceSerialize']} */\n function sliceSerialize(token, expandTabs) {\n return serializeChunks(sliceStream(token), expandTabs)\n }\n\n /** @type {TokenizeContext['sliceStream']} */\n function sliceStream(token) {\n return sliceChunks(chunks, token)\n }\n\n /** @type {TokenizeContext['now']} */\n function now() {\n // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n const {line, column, offset, _index, _bufferIndex} = point\n return {\n line,\n column,\n offset,\n _index,\n _bufferIndex\n }\n }\n\n /** @type {TokenizeContext['defineSkip']} */\n function defineSkip(value) {\n columnStart[value.line] = value.column\n accountForPotentialSkip()\n }\n\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 function main() {\n /** @type {number} */\n let chunkIndex\n while (point._index < chunks.length) {\n const chunk = chunks[point._index]\n\n // If we’re in a buffer chunk, loop through it.\n if (typeof chunk === 'string') {\n chunkIndex = point._index\n if (point._bufferIndex < 0) {\n point._bufferIndex = 0\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 /**\n * Deal with one code.\n *\n * @param {Code} code\n * @returns {void}\n */\n function go(code) {\n consumed = undefined\n expectedCode = code\n state = state(code)\n }\n\n /** @type {Effects['consume']} */\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 }\n\n // Not in a string chunk.\n if (point._bufferIndex < 0) {\n point._index++\n } else {\n point._bufferIndex++\n\n // At end of string chunk.\n // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n // strings.\n if (point._bufferIndex === chunks[point._index].length) {\n point._bufferIndex = -1\n point._index++\n }\n }\n\n // Expose the previous character.\n context.previous = code\n\n // Mark as consumed.\n consumed = true\n }\n\n /** @type {Effects['enter']} */\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\n /** @type {Effects['exit']} */\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 /**\n * Use results.\n *\n * @type {ReturnHandle}\n */\n function onsuccessfulconstruct(construct, info) {\n addResult(construct, info.from)\n }\n\n /**\n * Discard results.\n *\n * @type {ReturnHandle}\n */\n function onsuccessfulcheck(_, info) {\n info.restore()\n }\n\n /**\n * Factory to attempt/check/interrupt.\n *\n * @param {ReturnHandle} onreturn\n * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n */\n function constructFactory(onreturn, fields) {\n return hook\n\n /**\n * Handle either an object mapping codes to constructs, a list of\n * constructs, or a single construct.\n *\n * @param {Array | Construct | ConstructRecord} constructs\n * @param {State} returnState\n * @param {State | undefined} [bogusState]\n * @returns {State}\n */\n function hook(constructs, returnState, bogusState) {\n /** @type {Array} */\n let listOfConstructs\n /** @type {number} */\n let constructIndex\n /** @type {Construct} */\n let currentConstruct\n /** @type {Info} */\n let info\n return Array.isArray(constructs) /* c8 ignore next 1 */\n ? handleListOfConstructs(constructs)\n : 'tokenize' in constructs\n ? // @ts-expect-error Looks like a construct.\n handleListOfConstructs([constructs])\n : handleMapOfConstructs(constructs)\n\n /**\n * Handle a list of construct.\n *\n * @param {ConstructRecord} map\n * @returns {State}\n */\n function handleMapOfConstructs(map) {\n return start\n\n /** @type {State} */\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 /* 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 /**\n * Handle a list of construct.\n *\n * @param {Array} list\n * @returns {State}\n */\n function handleListOfConstructs(list) {\n listOfConstructs = list\n constructIndex = 0\n if (list.length === 0) {\n return bogusState\n }\n return handleConstruct(list[constructIndex])\n }\n\n /**\n * Handle a single construct.\n *\n * @param {Construct} construct\n * @returns {State}\n */\n function handleConstruct(construct) {\n return start\n\n /** @type {State} */\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 if (!construct.partial) {\n context.currentConstruct = construct\n }\n\n // Always populated by defaults.\n\n if (\n construct.name &&\n context.parser.constructs.disable.null.includes(construct.name)\n ) {\n return nok(code)\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\n /** @type {State} */\n function ok(code) {\n consumed = true\n onreturn(currentConstruct, info)\n return returnState\n }\n\n /** @type {State} */\n function nok(code) {\n consumed = true\n info.restore()\n if (++constructIndex < listOfConstructs.length) {\n return handleConstruct(listOfConstructs[constructIndex])\n }\n return bogusState\n }\n }\n }\n\n /**\n * @param {Construct} construct\n * @param {number} from\n * @returns {void}\n */\n function addResult(construct, from) {\n if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n resolveAllConstructs.push(construct)\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 if (construct.resolveTo) {\n context.events = construct.resolveTo(context.events, context)\n }\n }\n\n /**\n * Store state.\n *\n * @returns {Info}\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 /**\n * Restore state.\n *\n * @returns {void}\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 /**\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 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/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Array} chunks\n * @param {Pick} token\n * @returns {Array}\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 {Array} */\n let view\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 if (startBufferIndex > -1) {\n const head = view[0]\n if (typeof head === 'string') {\n view[0] = head.slice(startBufferIndex)\n } else {\n view.shift()\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 return view\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\n */\nfunction serializeChunks(chunks, expandTabs) {\n let index = -1\n /** @type {Array} */\n const result = []\n /** @type {boolean | undefined} */\n let atTab\n while (++index < chunks.length) {\n const chunk = chunks[index]\n /** @type {string} */\n let value\n if (typeof chunk === 'string') {\n value = chunk\n } else\n switch (chunk) {\n case -5: {\n value = '\\r'\n break\n }\n case -4: {\n value = '\\n'\n break\n }\n case -3: {\n value = '\\r' + '\\n'\n break\n }\n case -2: {\n value = expandTabs ? ' ' : '\\t'\n break\n }\n case -1: {\n if (!expandTabs && atTab) continue\n value = ' '\n break\n }\n default: {\n // Currently only replacement character.\n value = String.fromCharCode(chunk)\n }\n }\n atTab = chunk === -2\n result.push(value)\n }\n return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\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\n/** @satisfies {Extension['document']} */\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\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n [91]: definition\n}\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n [-2]: codeIndented,\n [-1]: codeIndented,\n [32]: codeIndented\n}\n\n/** @satisfies {Extension['flow']} */\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\n/** @satisfies {Extension['string']} */\nexport const string = {\n [38]: characterReference,\n [92]: characterEscape\n}\n\n/** @satisfies {Extension['text']} */\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\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n null: [attention, resolveText]\n}\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n null: [42, 95]\n}\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Create} Create\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n */\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/**\n * @param {ParseOptions | null | undefined} [options]\n * @returns {ParseContext}\n */\nexport function parse(options) {\n const settings = options || {}\n const constructs =\n /** @type {FullNormalizedExtension} */\n combineExtensions([defaultConstructs, ...(settings.extensions || [])])\n\n /** @type {ParseContext} */\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 /**\n * @param {InitialConstruct} initial\n */\n function create(initial) {\n return creator\n /** @type {Create} */\n function creator(from) {\n return createTokenizer(parser, initial, from)\n }\n }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * @param {Array} events\n * @returns {Array}\n */\nexport function postprocess(events) {\n while (!subtokenize(events)) {\n // Empty\n }\n return events\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {boolean | null | undefined} [end=false]\n * @returns {Array}\n */\n\nconst search = /[\\0\\t\\n\\r]/g\n\n/**\n * @returns {Preprocessor}\n */\nexport function preprocess() {\n let column = 1\n let buffer = ''\n /** @type {boolean | undefined} */\n let start = true\n /** @type {boolean | undefined} */\n let atCarriageReturn\n return preprocessor\n\n /** @type {Preprocessor} */\n function preprocessor(value, encoding, end) {\n /** @type {Array} */\n const chunks = []\n /** @type {RegExpMatchArray | null} */\n let match\n /** @type {number} */\n let next\n /** @type {number} */\n let startPosition\n /** @type {number} */\n let endPosition\n /** @type {Code} */\n let code\n\n // @ts-expect-error `Buffer` does allow an encoding.\n value = buffer + value.toString(encoding)\n startPosition = 0\n buffer = ''\n if (start) {\n // To do: `markdown-rs` actually parses BOMs (byte order mark).\n if (value.charCodeAt(0) === 65279) {\n startPosition++\n }\n start = undefined\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 if (!match) {\n buffer = value.slice(startPosition)\n break\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 if (startPosition < endPosition) {\n chunks.push(value.slice(startPosition, endPosition))\n column += endPosition - startPosition\n }\n switch (code) {\n case 0: {\n chunks.push(65533)\n column++\n break\n }\n case 9: {\n next = Math.ceil(column / 4) * 4\n chunks.push(-2)\n while (column++ < next) chunks.push(-1)\n break\n }\n case 10: {\n chunks.push(-4)\n column = 1\n break\n }\n default: {\n atCarriageReturn = true\n column = 1\n }\n }\n }\n startPosition = endPosition + 1\n }\n if (end) {\n if (atCarriageReturn) chunks.push(-5)\n if (buffer) chunks.push(buffer)\n chunks.push(null)\n }\n return chunks\n }\n}\n"],"names":["content","tokenize","effects","contentStart","attempt","this","parser","constructs","contentInitial","code","consume","enter","exit","f","lineStart","previous","token","contentType","next","data","self","stack","childFlow","childToken","lineStartOffset","continued","start","length","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","undefined","closeFlow","indexBeforeExits","events","point","indexBeforeFlow","type","end","exitContainers","index","Object","assign","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","document","disable","null","includes","initial","flowInitial","afterConstruct","resolver","resolveAll","createResolver","string","initializeFactory","field","text","notText","atBreak","list","resolveAllLineSuffixes","extraResolver","context","splice","eventIndex","chunks","tabs","bufferIndex","chunk","charCodeAt","column","_index","_bufferIndex","createTokenizer","initialize","from","columnStart","resolveAllConstructs","consumed","accountForPotentialSkip","fields","pop","constructFactory","construct","info","addResult","onsuccessfulcheck","sliceSerialize","expandTabs","result","atTab","value","String","fromCharCode","join","serializeChunks","main","expectedCode","state","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","shift","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","definition","attention","autolink","insideSpan","attentionMarkers","parse","options","settings","defined","extensions","postprocess","search","preprocess","atCarriageReturn","buffer","encoding","match","startPosition","endPosition","toString","lastIndex","exec","Math","ceil"],"sourceRoot":""}