@blade-hq/agent-react 2612.0.0-beta.2 → 2612.0.0-beta.21

package/node_modules/markdown-it/lib/rules_block/list.mjs

@@ -0,0 +1,331 @@
+// Lists
+
+import { isSpace } from '../common/utils.mjs'
+
+// Search `[-+*][\n ]`, returns next pos after marker on success
+// or -1 on fail.
+function skipBulletListMarker (state, startLine) {
+  const max = state.eMarks[startLine]
+  let pos = state.bMarks[startLine] + state.tShift[startLine]
+
+  const marker = state.src.charCodeAt(pos++)
+  // Check bullet
+  if (marker !== 0x2A/* * */ &&
+      marker !== 0x2D/* - */ &&
+      marker !== 0x2B/* + */) {
+    return -1
+  }
+
+  if (pos < max) {
+    const ch = state.src.charCodeAt(pos)
+
+    if (!isSpace(ch)) {
+      // " -test " - is not a list item
+      return -1
+    }
+  }
+
+  return pos
+}
+
+// Search `\d+[.)][\n ]`, returns next pos after marker on success
+// or -1 on fail.
+function skipOrderedListMarker (state, startLine) {
+  const start = state.bMarks[startLine] + state.tShift[startLine]
+  const max = state.eMarks[startLine]
+  let pos = start
+
+  // List marker should have at least 2 chars (digit + dot)
+  if (pos + 1 >= max) { return -1 }
+
+  let ch = state.src.charCodeAt(pos++)
+
+  if (ch < 0x30/* 0 */ || ch > 0x39/* 9 */) { return -1 }
+
+  for (;;) {
+    // EOL -> fail
+    if (pos >= max) { return -1 }
+
+    ch = state.src.charCodeAt(pos++)
+
+    if (ch >= 0x30/* 0 */ && ch <= 0x39/* 9 */) {
+      // List marker should have no more than 9 digits
+      // (prevents integer overflow in browsers)
+      if (pos - start >= 10) { return -1 }
+
+      continue
+    }
+
+    // found valid marker
+    if (ch === 0x29/* ) */ || ch === 0x2e/* . */) {
+      break
+    }
+
+    return -1
+  }
+
+  if (pos < max) {
+    ch = state.src.charCodeAt(pos)
+
+    if (!isSpace(ch)) {
+      // " 1.test " - is not a list item
+      return -1
+    }
+  }
+  return pos
+}
+
+function markTightParagraphs (state, idx) {
+  const level = state.level + 2
+
+  for (let i = idx + 2, l = state.tokens.length - 2; i < l; i++) {
+    if (state.tokens[i].level === level && state.tokens[i].type === 'paragraph_open') {
+      state.tokens[i + 2].hidden = true
+      state.tokens[i].hidden = true
+      i += 2
+    }
+  }
+}
+
+export default function list (state, startLine, endLine, silent) {
+  let max, pos, start, token
+  let nextLine = startLine
+  let tight = true
+
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[nextLine] - state.blkIndent >= 4) { return false }
+
+  // Special case:
+  //  - item 1
+  //   - item 2
+  //    - item 3
+  //     - item 4
+  //      - this one is a paragraph continuation
+  if (state.listIndent >= 0 &&
+      state.sCount[nextLine] - state.listIndent >= 4 &&
+      state.sCount[nextLine] < state.blkIndent) {
+    return false
+  }
+
+  let isTerminatingParagraph = false
+
+  // limit conditions when list can interrupt
+  // a paragraph (validation mode only)
+  if (silent && state.parentType === 'paragraph') {
+    // Next list item should still terminate previous list item;
+    //
+    // This code can fail if plugins use blkIndent as well as lists,
+    // but I hope the spec gets fixed long before that happens.
+    //
+    if (state.sCount[nextLine] >= state.blkIndent) {
+      isTerminatingParagraph = true
+    }
+  }
+
+  // Detect list type and position after marker
+  let isOrdered
+  let markerValue
+  let posAfterMarker
+  if ((posAfterMarker = skipOrderedListMarker(state, nextLine)) >= 0) {
+    isOrdered = true
+    start = state.bMarks[nextLine] + state.tShift[nextLine]
+    markerValue = Number(state.src.slice(start, posAfterMarker - 1))
+
+    // If we're starting a new ordered list right after
+    // a paragraph, it should start with 1.
+    if (isTerminatingParagraph && markerValue !== 1) return false
+  } else if ((posAfterMarker = skipBulletListMarker(state, nextLine)) >= 0) {
+    isOrdered = false
+  } else {
+    return false
+  }
+
+  // If we're starting a new unordered list right after
+  // a paragraph, first line should not be empty.
+  if (isTerminatingParagraph) {
+    if (state.skipSpaces(posAfterMarker) >= state.eMarks[nextLine]) return false
+  }
+
+  // For validation mode we can terminate immediately
+  if (silent) { return true }
+
+  // We should terminate list on style change. Remember first one to compare.
+  const markerCharCode = state.src.charCodeAt(posAfterMarker - 1)
+
+  // Start list
+  const listTokIdx = state.tokens.length
+
+  if (isOrdered) {
+    token       = state.push('ordered_list_open', 'ol', 1)
+    if (markerValue !== 1) {
+      token.attrs = [['start', markerValue]]
+    }
+  } else {
+    token       = state.push('bullet_list_open', 'ul', 1)
+  }
+
+  const listLines = [nextLine, 0]
+  token.map    = listLines
+  token.markup = String.fromCharCode(markerCharCode)
+
+  //
+  // Iterate list items
+  //
+
+  let prevEmptyEnd = false
+  const terminatorRules = state.md.block.ruler.getRules('list')
+
+  const oldParentType = state.parentType
+  state.parentType = 'list'
+
+  while (nextLine < endLine) {
+    pos = posAfterMarker
+    max = state.eMarks[nextLine]
+
+    const initial = state.sCount[nextLine] + posAfterMarker - (state.bMarks[nextLine] + state.tShift[nextLine])
+    let offset = initial
+
+    while (pos < max) {
+      const ch = state.src.charCodeAt(pos)
+
+      if (ch === 0x09) {
+        offset += 4 - (offset + state.bsCount[nextLine]) % 4
+      } else if (ch === 0x20) {
+        offset++
+      } else {
+        break
+      }
+
+      pos++
+    }
+
+    const contentStart = pos
+    let indentAfterMarker
+
+    if (contentStart >= max) {
+      // trimming space in "-    \n  3" case, indent is 1 here
+      indentAfterMarker = 1
+    } else {
+      indentAfterMarker = offset - initial
+    }
+
+    // If we have more than 4 spaces, the indent is 1
+    // (the rest is just indented code block)
+    if (indentAfterMarker > 4) { indentAfterMarker = 1 }
+
+    // "  -  test"
+    //  ^^^^^ - calculating total length of this thing
+    const indent = initial + indentAfterMarker
+
+    // Run subparser & write tokens
+    token        = state.push('list_item_open', 'li', 1)
+    token.markup = String.fromCharCode(markerCharCode)
+    const itemLines = [nextLine, 0]
+    token.map    = itemLines
+    if (isOrdered) {
+      token.info = state.src.slice(start, posAfterMarker - 1)
+    }
+
+    // change current state, then restore it after parser subcall
+    const oldTight = state.tight
+    const oldTShift = state.tShift[nextLine]
+    const oldSCount = state.sCount[nextLine]
+
+    //  - example list
+    // ^ listIndent position will be here
+    //   ^ blkIndent position will be here
+    //
+    const oldListIndent = state.listIndent
+    state.listIndent = state.blkIndent
+    state.blkIndent = indent
+
+    state.tight = true
+    state.tShift[nextLine] = contentStart - state.bMarks[nextLine]
+    state.sCount[nextLine] = offset
+
+    if (contentStart >= max && state.isEmpty(nextLine + 1)) {
+      // workaround for this case
+      // (list item is empty, list terminates before "foo"):
+      // ~~~~~~~~
+      //   -
+      //
+      //     foo
+      // ~~~~~~~~
+      state.line = Math.min(state.line + 2, endLine)
+    } else {
+      state.md.block.tokenize(state, nextLine, endLine, true)
+    }
+
+    // If any of list item is tight, mark list as tight
+    if (!state.tight || prevEmptyEnd) {
+      tight = false
+    }
+    // Item become loose if finish with empty line,
+    // but we should filter last element, because it means list finish
+    prevEmptyEnd = (state.line - nextLine) > 1 && state.isEmpty(state.line - 1)
+
+    state.blkIndent = state.listIndent
+    state.listIndent = oldListIndent
+    state.tShift[nextLine] = oldTShift
+    state.sCount[nextLine] = oldSCount
+    state.tight = oldTight
+
+    token        = state.push('list_item_close', 'li', -1)
+    token.markup = String.fromCharCode(markerCharCode)
+
+    nextLine = state.line
+    itemLines[1] = nextLine
+
+    if (nextLine >= endLine) { break }
+
+    //
+    // Try to check if list is terminated or continued.
+    //
+    if (state.sCount[nextLine] < state.blkIndent) { break }
+
+    // if it's indented more than 3 spaces, it should be a code block
+    if (state.sCount[nextLine] - state.blkIndent >= 4) { break }
+
+    // fail if terminating block found
+    let terminate = false
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true
+        break
+      }
+    }
+    if (terminate) { break }
+
+    // fail if list has another type
+    if (isOrdered) {
+      posAfterMarker = skipOrderedListMarker(state, nextLine)
+      if (posAfterMarker < 0) { break }
+      start = state.bMarks[nextLine] + state.tShift[nextLine]
+    } else {
+      posAfterMarker = skipBulletListMarker(state, nextLine)
+      if (posAfterMarker < 0) { break }
+    }
+
+    if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) { break }
+  }
+
+  // Finalize list
+  if (isOrdered) {
+    token = state.push('ordered_list_close', 'ol', -1)
+  } else {
+    token = state.push('bullet_list_close', 'ul', -1)
+  }
+  token.markup = String.fromCharCode(markerCharCode)
+
+  listLines[1] = nextLine
+  state.line = nextLine
+
+  state.parentType = oldParentType
+
+  // mark paragraphs tight if needed
+  if (tight) {
+    markTightParagraphs(state, listTokIdx)
+  }
+
+  return true
+}

package/node_modules/markdown-it/lib/rules_block/paragraph.mjs

@@ -0,0 +1,46 @@
+// Paragraph
+
+export default function paragraph (state, startLine, endLine) {
+  const terminatorRules = state.md.block.ruler.getRules('paragraph')
+  const oldParentType = state.parentType
+  let nextLine = startLine + 1
+  state.parentType = 'paragraph'
+
+  // jump line-by-line until empty one or EOF
+  for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) { continue }
+
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) { continue }
+
+    // Some tags can terminate paragraph without empty line.
+    let terminate = false
+    for (let i = 0, l = terminatorRules.length; i < l; i++) {
+      if (terminatorRules[i](state, nextLine, endLine, true)) {
+        terminate = true
+        break
+      }
+    }
+    if (terminate) { break }
+  }
+
+  const content = state.getLines(startLine, nextLine, state.blkIndent, false).trim()
+
+  state.line = nextLine
+
+  const token_o    = state.push('paragraph_open', 'p', 1)
+  token_o.map      = [startLine, state.line]
+
+  const token_i    = state.push('inline', '', 0)
+  token_i.content  = content
+  token_i.map      = [startLine, state.line]
+  token_i.children = []
+
+  state.push('paragraph_close', 'p', -1)
+
+  state.parentType = oldParentType
+
+  return true
+}

package/node_modules/markdown-it/lib/rules_block/reference.mjs

@@ -0,0 +1,212 @@
+import { isSpace, normalizeReference } from '../common/utils.mjs'
+
+export default function reference (state, startLine, _endLine, silent) {
+  let pos = state.bMarks[startLine] + state.tShift[startLine]
+  let max = state.eMarks[startLine]
+  let nextLine = startLine + 1
+
+  // if it's indented more than 3 spaces, it should be a code block
+  if (state.sCount[startLine] - state.blkIndent >= 4) { return false }
+
+  if (state.src.charCodeAt(pos) !== 0x5B/* [ */) { return false }
+
+  function getNextLine (nextLine) {
+    const endLine = state.lineMax
+
+    if (nextLine >= endLine || state.isEmpty(nextLine)) {
+      // empty line or end of input
+      return null
+    }
+
+    let isContinuation = false
+
+    // this would be a code block normally, but after paragraph
+    // it's considered a lazy continuation regardless of what's there
+    if (state.sCount[nextLine] - state.blkIndent > 3) { isContinuation = true }
+
+    // quirk for blockquotes, this line should already be checked by that rule
+    if (state.sCount[nextLine] < 0) { isContinuation = true }
+
+    if (!isContinuation) {
+      const terminatorRules = state.md.block.ruler.getRules('reference')
+      const oldParentType = state.parentType
+      state.parentType = 'reference'
+
+      // Some tags can terminate paragraph without empty line.
+      let terminate = false
+      for (let i = 0, l = terminatorRules.length; i < l; i++) {
+        if (terminatorRules[i](state, nextLine, endLine, true)) {
+          terminate = true
+          break
+        }
+      }
+
+      state.parentType = oldParentType
+      if (terminate) {
+        // terminated by another block
+        return null
+      }
+    }
+
+    const pos = state.bMarks[nextLine] + state.tShift[nextLine]
+    const max = state.eMarks[nextLine]
+
+    // max + 1 explicitly includes the newline
+    return state.src.slice(pos, max + 1)
+  }
+
+  let str = state.src.slice(pos, max + 1)
+
+  max = str.length
+  let labelEnd = -1
+
+  for (pos = 1; pos < max; pos++) {
+    const ch = str.charCodeAt(pos)
+    if (ch === 0x5B /* [ */) {
+      return false
+    } else if (ch === 0x5D /* ] */) {
+      labelEnd = pos
+      break
+    } else if (ch === 0x0A /* \n */) {
+      const lineContent = getNextLine(nextLine)
+      if (lineContent !== null) {
+        str += lineContent
+        max = str.length
+        nextLine++
+      }
+    } else if (ch === 0x5C /* \ */) {
+      pos++
+      if (pos < max && str.charCodeAt(pos) === 0x0A) {
+        const lineContent = getNextLine(nextLine)
+        if (lineContent !== null) {
+          str += lineContent
+          max = str.length
+          nextLine++
+        }
+      }
+    }
+  }
+
+  if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 0x3A/* : */) { return false }
+
+  // [label]:   destination   'title'
+  //         ^^^ skip optional whitespace here
+  for (pos = labelEnd + 2; pos < max; pos++) {
+    const ch = str.charCodeAt(pos)
+    if (ch === 0x0A) {
+      const lineContent = getNextLine(nextLine)
+      if (lineContent !== null) {
+        str += lineContent
+        max = str.length
+        nextLine++
+      }
+    } else if (isSpace(ch)) {
+      /* eslint no-empty:0 */
+    } else {
+      break
+    }
+  }
+
+  // [label]:   destination   'title'
+  //            ^^^^^^^^^^^ parse this
+  const destRes = state.md.helpers.parseLinkDestination(str, pos, max)
+  if (!destRes.ok) { return false }
+
+  const href = state.md.normalizeLink(destRes.str)
+  if (!state.md.validateLink(href)) { return false }
+
+  pos = destRes.pos
+
+  // save cursor state, we could require to rollback later
+  const destEndPos = pos
+  const destEndLineNo = nextLine
+
+  // [label]:   destination   'title'
+  //                       ^^^ skipping those spaces
+  const start = pos
+  for (; pos < max; pos++) {
+    const ch = str.charCodeAt(pos)
+    if (ch === 0x0A) {
+      const lineContent = getNextLine(nextLine)
+      if (lineContent !== null) {
+        str += lineContent
+        max = str.length
+        nextLine++
+      }
+    } else if (isSpace(ch)) {
+      /* eslint no-empty:0 */
+    } else {
+      break
+    }
+  }
+
+  // [label]:   destination   'title'
+  //                          ^^^^^^^ parse this
+  let titleRes = state.md.helpers.parseLinkTitle(str, pos, max)
+  while (titleRes.can_continue) {
+    const lineContent = getNextLine(nextLine)
+    if (lineContent === null) break
+    str += lineContent
+    pos = max
+    max = str.length
+    nextLine++
+    titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes)
+  }
+  let title
+
+  if (pos < max && start !== pos && titleRes.ok) {
+    title = titleRes.str
+    pos = titleRes.pos
+  } else {
+    title = ''
+    pos = destEndPos
+    nextLine = destEndLineNo
+  }
+
+  // skip trailing spaces until the rest of the line
+  while (pos < max) {
+    const ch = str.charCodeAt(pos)
+    if (!isSpace(ch)) { break }
+    pos++
+  }
+
+  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
+    if (title) {
+      // garbage at the end of the line after title,
+      // but it could still be a valid reference if we roll back
+      title = ''
+      pos = destEndPos
+      nextLine = destEndLineNo
+      while (pos < max) {
+        const ch = str.charCodeAt(pos)
+        if (!isSpace(ch)) { break }
+        pos++
+      }
+    }
+  }
+
+  if (pos < max && str.charCodeAt(pos) !== 0x0A) {
+    // garbage at the end of the line
+    return false
+  }
+
+  const label = normalizeReference(str.slice(1, labelEnd))
+  if (!label) {
+    // CommonMark 0.20 disallows empty labels
+    return false
+  }
+
+  // Reference can not terminate anything. This check is for safety only.
+  /* istanbul ignore if */
+  if (silent) { return true }
+
+  if (typeof state.env.references === 'undefined') {
+    state.env.references = {}
+  }
+  if (typeof state.env.references[label] === 'undefined') {
+    state.env.references[label] = { title, href }
+  }
+
+  state.line = nextLine
+  return true
+}