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

package/node_modules/markdown-it/lib/rules_inline/emphasis.mjs

@@ -0,0 +1,123 @@
+// Process *this* and _that_
+//
+
+// Insert each marker as a separate text token, and add it to delimiter list
+//
+function emphasis_tokenize (state, silent) {
+  const start = state.pos
+  const marker = state.src.charCodeAt(start)
+
+  if (silent) { return false }
+
+  if (marker !== 0x5F /* _ */ && marker !== 0x2A /* * */) { return false }
+
+  const scanned = state.scanDelims(state.pos, marker === 0x2A)
+
+  for (let i = 0; i < scanned.length; i++) {
+    const token = state.push('text', '', 0)
+    token.content = String.fromCharCode(marker)
+
+    state.delimiters.push({
+      // Char code of the starting marker (number).
+      //
+      marker,
+
+      // Total length of these series of delimiters.
+      //
+      length: scanned.length,
+
+      // A position of the token this delimiter corresponds to.
+      //
+      token: state.tokens.length - 1,
+
+      // If this delimiter is matched as a valid opener, `end` will be
+      // equal to its position, otherwise it's `-1`.
+      //
+      end: -1,
+
+      // Boolean flags that determine if this delimiter could open or close
+      // an emphasis.
+      //
+      open: scanned.can_open,
+      close: scanned.can_close
+    })
+  }
+
+  state.pos += scanned.length
+
+  return true
+}
+
+function postProcess (state, delimiters) {
+  const max = delimiters.length
+
+  for (let i = max - 1; i >= 0; i--) {
+    const startDelim = delimiters[i]
+
+    if (startDelim.marker !== 0x5F/* _ */ && startDelim.marker !== 0x2A/* * */) {
+      continue
+    }
+
+    // Process only opening markers
+    if (startDelim.end === -1) {
+      continue
+    }
+
+    const endDelim = delimiters[startDelim.end]
+
+    // If the previous delimiter has the same marker and is adjacent to this one,
+    // merge those into one strong delimiter.
+    //
+    // `<em><em>whatever</em></em>` -> `<strong>whatever</strong>`
+    //
+    const isStrong = i > 0 &&
+               delimiters[i - 1].end === startDelim.end + 1 &&
+               // check that first two markers match and adjacent
+               delimiters[i - 1].marker === startDelim.marker &&
+               delimiters[i - 1].token === startDelim.token - 1 &&
+               // check that last two markers are adjacent (we can safely assume they match)
+               delimiters[startDelim.end + 1].token === endDelim.token + 1
+
+    const ch = String.fromCharCode(startDelim.marker)
+
+    const token_o   = state.tokens[startDelim.token]
+    token_o.type    = isStrong ? 'strong_open' : 'em_open'
+    token_o.tag     = isStrong ? 'strong' : 'em'
+    token_o.nesting = 1
+    token_o.markup  = isStrong ? ch + ch : ch
+    token_o.content = ''
+
+    const token_c   = state.tokens[endDelim.token]
+    token_c.type    = isStrong ? 'strong_close' : 'em_close'
+    token_c.tag     = isStrong ? 'strong' : 'em'
+    token_c.nesting = -1
+    token_c.markup  = isStrong ? ch + ch : ch
+    token_c.content = ''
+
+    if (isStrong) {
+      state.tokens[delimiters[i - 1].token].content = ''
+      state.tokens[delimiters[startDelim.end + 1].token].content = ''
+      i--
+    }
+  }
+}
+
+// Walk through delimiter list and replace text tokens with tags
+//
+function emphasis_post_process (state) {
+  const tokens_meta = state.tokens_meta
+  const max = state.tokens_meta.length
+
+  postProcess(state, state.delimiters)
+
+  for (let curr = 0; curr < max; curr++) {
+    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
+      postProcess(state, tokens_meta[curr].delimiters)
+    }
+  }
+}
+
+export default {
+  tokenize: emphasis_tokenize,
+  postProcess: emphasis_post_process
+}

package/node_modules/markdown-it/lib/rules_inline/entity.mjs

@@ -0,0 +1,51 @@
+// Process html entity - {, ¯, ", ...
+
+import { decodeHTML } from 'entities'
+import { isValidEntityCode, fromCodePoint } from '../common/utils.mjs'
+
+const DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i
+const NAMED_RE   = /^&([a-z][a-z0-9]{1,31});/i
+
+export default function entity (state, silent) {
+  const pos = state.pos
+  const max = state.posMax
+
+  if (state.src.charCodeAt(pos) !== 0x26/* & */) return false
+
+  if (pos + 1 >= max) return false
+
+  const ch = state.src.charCodeAt(pos + 1)
+
+  if (ch === 0x23 /* # */) {
+    const match = state.src.slice(pos).match(DIGITAL_RE)
+    if (match) {
+      if (!silent) {
+        const code = match[1][0].toLowerCase() === 'x' ? parseInt(match[1].slice(1), 16) : parseInt(match[1], 10)
+
+        const token   = state.push('text_special', '', 0)
+        token.content = isValidEntityCode(code) ? fromCodePoint(code) : fromCodePoint(0xFFFD)
+        token.markup  = match[0]
+        token.info    = 'entity'
+      }
+      state.pos += match[0].length
+      return true
+    }
+  } else {
+    const match = state.src.slice(pos).match(NAMED_RE)
+    if (match) {
+      const decoded = decodeHTML(match[0])
+      if (decoded !== match[0]) {
+        if (!silent) {
+          const token   = state.push('text_special', '', 0)
+          token.content = decoded
+          token.markup  = match[0]
+          token.info    = 'entity'
+        }
+        state.pos += match[0].length
+        return true
+      }
+    }
+  }
+
+  return false
+}

package/node_modules/markdown-it/lib/rules_inline/escape.mjs

@@ -0,0 +1,69 @@
+// Process escaped chars and hardbreaks
+
+import { isSpace } from '../common/utils.mjs'
+
+const ESCAPED = []
+
+for (let i = 0; i < 256; i++) { ESCAPED.push(0) }
+
+'\\!"#$%&\'()*+,./:;<=>?@[]^_`{|}~-'
+  .split('').forEach(function (ch) { ESCAPED[ch.charCodeAt(0)] = 1 })
+
+export default function escape (state, silent) {
+  let pos = state.pos
+  const max = state.posMax
+
+  if (state.src.charCodeAt(pos) !== 0x5C/* \ */) return false
+  pos++
+
+  // '\' at the end of the inline block
+  if (pos >= max) return false
+
+  let ch1 = state.src.charCodeAt(pos)
+
+  if (ch1 === 0x0A) {
+    if (!silent) {
+      state.push('hardbreak', 'br', 0)
+    }
+
+    pos++
+    // skip leading whitespaces from next line
+    while (pos < max) {
+      ch1 = state.src.charCodeAt(pos)
+      if (!isSpace(ch1)) break
+      pos++
+    }
+
+    state.pos = pos
+    return true
+  }
+
+  let escapedStr = state.src[pos]
+
+  if (ch1 >= 0xD800 && ch1 <= 0xDBFF && pos + 1 < max) {
+    const ch2 = state.src.charCodeAt(pos + 1)
+
+    if (ch2 >= 0xDC00 && ch2 <= 0xDFFF) {
+      escapedStr += state.src[pos + 1]
+      pos++
+    }
+  }
+
+  const origStr = '\\' + escapedStr
+
+  if (!silent) {
+    const token = state.push('text_special', '', 0)
+
+    if (ch1 < 256 && ESCAPED[ch1] !== 0) {
+      token.content = escapedStr
+    } else {
+      token.content = origStr
+    }
+
+    token.markup = origStr
+    token.info   = 'escape'
+  }
+
+  state.pos = pos + 1
+  return true
+}

package/node_modules/markdown-it/lib/rules_inline/fragments_join.mjs

@@ -0,0 +1,38 @@
+// Clean up tokens after emphasis and strikethrough postprocessing:
+// merge adjacent text nodes into one and re-calculate all token levels
+//
+// This is necessary because initially emphasis delimiter markers (*, _, ~)
+// are treated as their own separate text tokens. Then emphasis rule either
+// leaves them as text (needed to merge with adjacent text) or turns them
+// into opening/closing tags (which messes up levels inside).
+//
+
+export default function fragments_join (state) {
+  let curr, last
+  let level = 0
+  const tokens = state.tokens
+  const max = state.tokens.length
+
+  for (curr = last = 0; curr < max; curr++) {
+    // re-calculate levels after emphasis/strikethrough turns some text nodes
+    // into opening/closing tags
+    if (tokens[curr].nesting < 0) level-- // closing tag
+    tokens[curr].level = level
+    if (tokens[curr].nesting > 0) level++ // opening tag
+
+    if (tokens[curr].type === 'text' &&
+        curr + 1 < max &&
+        tokens[curr + 1].type === 'text') {
+      // collapse two adjacent text nodes
+      tokens[curr + 1].content = tokens[curr].content + tokens[curr + 1].content
+    } else {
+      if (curr !== last) { tokens[last] = tokens[curr] }
+
+      last++
+    }
+  }
+
+  if (curr !== last) {
+    tokens.length = last
+  }
+}

package/node_modules/markdown-it/lib/rules_inline/html_inline.mjs

@@ -0,0 +1,50 @@
+// Process html tags
+
+import { HTML_TAG_RE } from '../common/html_re.mjs'
+
+function isLinkOpen (str) {
+  return /^<a[>\s]/i.test(str)
+}
+function isLinkClose (str) {
+  return /^<\/a\s*>/i.test(str)
+}
+
+function isLetter (ch) {
+  /* eslint no-bitwise:0 */
+  const lc = ch | 0x20 // to lower case
+  return (lc >= 0x61/* a */) && (lc <= 0x7a/* z */)
+}
+
+export default function html_inline (state, silent) {
+  if (!state.md.options.html) { return false }
+
+  // Check start
+  const max = state.posMax
+  const pos = state.pos
+  if (state.src.charCodeAt(pos) !== 0x3C/* < */ ||
+      pos + 2 >= max) {
+    return false
+  }
+
+  // Quick fail on second char
+  const ch = state.src.charCodeAt(pos + 1)
+  if (ch !== 0x21/* ! */ &&
+      ch !== 0x3F/* ? */ &&
+      ch !== 0x2F/* / */ &&
+      !isLetter(ch)) {
+    return false
+  }
+
+  const match = state.src.slice(pos).match(HTML_TAG_RE)
+  if (!match) { return false }
+
+  if (!silent) {
+    const token = state.push('html_inline', '', 0)
+    token.content = match[0]
+
+    if (isLinkOpen(token.content))  state.linkLevel++
+    if (isLinkClose(token.content)) state.linkLevel--
+  }
+  state.pos += match[0].length
+  return true
+}

package/node_modules/markdown-it/lib/rules_inline/image.mjs

@@ -0,0 +1,138 @@
+// Process ![image](<src> "title")
+
+import { normalizeReference, isSpace } from '../common/utils.mjs'
+
+export default function image (state, silent) {
+  let code, content, label, pos, ref, res, title, start
+  let href = ''
+  const oldPos = state.pos
+  const max = state.posMax
+
+  if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) { return false }
+  if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) { return false }
+
+  const labelStart = state.pos + 2
+  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false)
+
+  // parser failed to find ']', so it's not a valid link
+  if (labelEnd < 0) { return false }
+
+  pos = labelEnd + 1
+  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
+    //
+    // Inline link
+    //
+
+    // [link](  <href>  "title"  )
+    //        ^^ skipping these spaces
+    pos++
+    for (; pos < max; pos++) {
+      code = state.src.charCodeAt(pos)
+      if (!isSpace(code) && code !== 0x0A) { break }
+    }
+    if (pos >= max) { return false }
+
+    // [link](  <href>  "title"  )
+    //          ^^^^^^ parsing link destination
+    start = pos
+    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
+    if (res.ok) {
+      href = state.md.normalizeLink(res.str)
+      if (state.md.validateLink(href)) {
+        pos = res.pos
+      } else {
+        href = ''
+      }
+    }
+
+    // [link](  <href>  "title"  )
+    //                ^^ skipping these spaces
+    start = pos
+    for (; pos < max; pos++) {
+      code = state.src.charCodeAt(pos)
+      if (!isSpace(code) && code !== 0x0A) { break }
+    }
+
+    // [link](  <href>  "title"  )
+    //                  ^^^^^^^ parsing link title
+    res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
+    if (pos < max && start !== pos && res.ok) {
+      title = res.str
+      pos = res.pos
+
+      // [link](  <href>  "title"  )
+      //                         ^^ skipping these spaces
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos)
+        if (!isSpace(code) && code !== 0x0A) { break }
+      }
+    } else {
+      title = ''
+    }
+
+    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
+      state.pos = oldPos
+      return false
+    }
+    pos++
+  } else {
+    //
+    // Link reference
+    //
+    if (typeof state.env.references === 'undefined') { return false }
+
+    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
+      start = pos + 1
+      pos = state.md.helpers.parseLinkLabel(state, pos)
+      if (pos >= 0) {
+        label = state.src.slice(start, pos++)
+      } else {
+        pos = labelEnd + 1
+      }
+    } else {
+      pos = labelEnd + 1
+    }
+
+    // covers label === '' and label === undefined
+    // (collapsed reference link and shortcut reference link respectively)
+    if (!label) { label = state.src.slice(labelStart, labelEnd) }
+
+    ref = state.env.references[normalizeReference(label)]
+    if (!ref) {
+      state.pos = oldPos
+      return false
+    }
+    href = ref.href
+    title = ref.title
+  }
+
+  //
+  // We found the end of the link, and know for a fact it's a valid link;
+  // so all that's left to do is to call tokenizer.
+  //
+  if (!silent) {
+    content = state.src.slice(labelStart, labelEnd)
+
+    const tokens = []
+    state.md.inline.parse(
+      content,
+      state.md,
+      state.env,
+      tokens
+    )
+
+    const token = state.push('image', 'img', 0)
+    const attrs = [['src', href], ['alt', '']]
+    token.attrs = attrs
+    token.children = tokens
+    token.content = content
+
+    if (title) {
+      attrs.push(['title', title])
+    }
+  }
+
+  state.pos = pos
+  state.posMax = max
+  return true
+}

package/node_modules/markdown-it/lib/rules_inline/link.mjs

@@ -0,0 +1,139 @@
+// Process [link](<to> "stuff")
+
+import { normalizeReference, isSpace } from '../common/utils.mjs'
+
+export default function link (state, silent) {
+  let code, label, res, ref
+  let href = ''
+  let title = ''
+  let start = state.pos
+  let parseReference = true
+
+  if (state.src.charCodeAt(state.pos) !== 0x5B/* [ */) { return false }
+
+  const oldPos = state.pos
+  const max = state.posMax
+  const labelStart = state.pos + 1
+  const labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true)
+
+  // parser failed to find ']', so it's not a valid link
+  if (labelEnd < 0) { return false }
+
+  let pos = labelEnd + 1
+  if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
+    //
+    // Inline link
+    //
+
+    // might have found a valid shortcut link, disable reference parsing
+    parseReference = false
+
+    // [link](  <href>  "title"  )
+    //        ^^ skipping these spaces
+    pos++
+    for (; pos < max; pos++) {
+      code = state.src.charCodeAt(pos)
+      if (!isSpace(code) && code !== 0x0A) { break }
+    }
+    if (pos >= max) { return false }
+
+    // [link](  <href>  "title"  )
+    //          ^^^^^^ parsing link destination
+    start = pos
+    res = state.md.helpers.parseLinkDestination(state.src, pos, state.posMax)
+    if (res.ok) {
+      href = state.md.normalizeLink(res.str)
+      if (state.md.validateLink(href)) {
+        pos = res.pos
+      } else {
+        href = ''
+      }
+
+      // [link](  <href>  "title"  )
+      //                ^^ skipping these spaces
+      start = pos
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos)
+        if (!isSpace(code) && code !== 0x0A) { break }
+      }
+
+      // [link](  <href>  "title"  )
+      //                  ^^^^^^^ parsing link title
+      res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax)
+      if (pos < max && start !== pos && res.ok) {
+        title = res.str
+        pos = res.pos
+
+        // [link](  <href>  "title"  )
+        //                         ^^ skipping these spaces
+        for (; pos < max; pos++) {
+          code = state.src.charCodeAt(pos)
+          if (!isSpace(code) && code !== 0x0A) { break }
+        }
+      }
+    }
+
+    if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
+      // parsing a valid shortcut link failed, fallback to reference
+      parseReference = true
+    }
+    pos++
+  }
+
+  if (parseReference) {
+    //
+    // Link reference
+    //
+    if (typeof state.env.references === 'undefined') { return false }
+
+    if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
+      start = pos + 1
+      pos = state.md.helpers.parseLinkLabel(state, pos)
+      if (pos >= 0) {
+        label = state.src.slice(start, pos++)
+      } else {
+        pos = labelEnd + 1
+      }
+    } else {
+      pos = labelEnd + 1
+    }
+
+    // covers label === '' and label === undefined
+    // (collapsed reference link and shortcut reference link respectively)
+    if (!label) { label = state.src.slice(labelStart, labelEnd) }
+
+    ref = state.env.references[normalizeReference(label)]
+    if (!ref) {
+      state.pos = oldPos
+      return false
+    }
+    href = ref.href
+    title = ref.title
+  }
+
+  //
+  // We found the end of the link, and know for a fact it's a valid link;
+  // so all that's left to do is to call tokenizer.
+  //
+  if (!silent) {
+    state.pos = labelStart
+    state.posMax = labelEnd
+
+    const token_o = state.push('link_open', 'a', 1)
+    const attrs = [['href', href]]
+    token_o.attrs  = attrs
+    if (title) {
+      attrs.push(['title', title])
+    }
+
+    state.linkLevel++
+    state.md.inline.tokenize(state)
+    state.linkLevel--
+
+    state.push('link_close', 'a', -1)
+  }
+
+  state.pos = pos
+  state.posMax = max
+  return true
+}

package/node_modules/markdown-it/lib/rules_inline/linkify.mjs

@@ -0,0 +1,63 @@
+// Process links like https://example.org/
+
+// RFC3986: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+const SCHEME_RE = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i
+
+export default function linkify (state, silent) {
+  if (!state.md.options.linkify) return false
+  if (state.linkLevel > 0) return false
+
+  const pos = state.pos
+  const max = state.posMax
+
+  if (pos + 3 > max) return false
+  if (state.src.charCodeAt(pos) !== 0x3A/* : */) return false
+  if (state.src.charCodeAt(pos + 1) !== 0x2F/* / */) return false
+  if (state.src.charCodeAt(pos + 2) !== 0x2F/* / */) return false
+
+  const match = state.pending.match(SCHEME_RE)
+  if (!match) return false
+
+  const proto = match[1]
+
+  const link = state.md.linkify.matchAtStart(state.src.slice(pos - proto.length))
+  if (!link) return false
+
+  let url = link.url
+
+  // invalid link, but still detected by linkify somehow;
+  // need to check to prevent infinite loop below
+  if (url.length <= proto.length) return false
+
+  // disallow '*' at the end of the link (conflicts with emphasis)
+  // do manual backsearch to avoid perf issues with regex /\*+$/ on "****...****a".
+  let urlEnd = url.length
+  while (urlEnd > 0 && url.charCodeAt(urlEnd - 1) === 0x2A/* * */) {
+    urlEnd--
+  }
+  if (urlEnd !== url.length) {
+    url = url.slice(0, urlEnd)
+  }
+
+  const fullUrl = state.md.normalizeLink(url)
+  if (!state.md.validateLink(fullUrl)) return false
+
+  if (!silent) {
+    state.pending = state.pending.slice(0, -proto.length)
+
+    const token_o = state.push('link_open', 'a', 1)
+    token_o.attrs = [['href', fullUrl]]
+    token_o.markup = 'linkify'
+    token_o.info = 'auto'
+
+    const token_t = state.push('text', '', 0)
+    token_t.content = state.md.normalizeLinkText(url)
+
+    const token_c = state.push('link_close', 'a', -1)
+    token_c.markup = 'linkify'
+    token_c.info = 'auto'
+  }
+
+  state.pos += url.length - proto.length
+  return true
+}