admin08077/Githubgemini

1{"version":3,"file":"micromark-CTBPIv-_.js","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/preprocess.js","../../node_modules/micromark/lib/postprocess.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<StackItem>} */\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<Point, '_bufferIndex' | '_index'> | 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<string, number>} */\n  const columnStart = {}\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n  let chunks = []\n  /** @type {Array<Token>} */\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> | 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<Construct>} */\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<Construct>} 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<Chunk>} chunks\n * @param {Pick<Token, 'end' | 'start'>} token\n * @returns {Array<Chunk>}\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<Chunk>} */\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<Chunk>} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\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').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<Chunk>}\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<Chunk>} */\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","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events\n}\n"],"names":["content","initializeContent","effects","contentStart","afterContentStartConstruct","paragraphInitial","previous","code","factorySpace","lineStart","token","data","markdownLineEnding","document","initializeDocument","containerConstruct","tokenizeContainer","self","stack","continued","childFlow","childToken","lineStartOffset","start","item","documentContinue","checkNewContainers","closeFlow","indexBeforeExits","indexBeforeFlow","point","exitContainers","index","splice","documentContinued","flowStart","thereIsANewContainer","thereIsNoNewContainer","containerContinue","flowContinue","writeToChild","eof","stream","seen","size","entry","ok","nok","flow","initializeFlow","initial","blankLine","atBlankEnding","afterConstruct","resolver","createResolver","string","initializeFactory","text","field","initializeText","resolveAllLineSuffixes","constructs","notText","atBreak","list","extraResolver","resolveAllText","events","context","enter","eventIndex","chunks","bufferIndex","tabs","chunk","createTokenizer","parser","initialize","from","columnStart","resolveAllConstructs","consume","exit","constructFactory","onsuccessfulconstruct","onsuccessfulcheck","sliceStream","sliceSerialize","now","defineSkip","write","state","slice","push","main","addResult","resolveAll","expandTabs","serializeChunks","sliceChunks","line","column","offset","_index","_bufferIndex","value","accountForPotentialSkip","chunkIndex","go","type","fields","construct","info","_","onreturn","hook","returnState","bogusState","listOfConstructs","constructIndex","currentConstruct","handleListOfConstructs","handleMapOfConstructs","map","def","all","handleConstruct","store","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","restore","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","result","atTab","blockQuote","contentInitial","definition","flowInitial","codeIndented","headingAtx","thematicBreak","setextUnderline","htmlFlow","codeFenced","characterReference","characterEscape","lineEnding","labelStartImage","attention","autolink","htmlText","labelStartLink","hardBreakEscape","labelEnd","codeText","insideSpan","resolveText","attentionMarkers","disable","parse","options","combineExtensions","defaultConstructs","create","creator","search","preprocess","buffer","atCarriageReturn","preprocessor","encoding","end","match","next","startPosition","endPosition","postprocess","subtokenize"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8]}