@rse/ase 0.0.31 → 0.0.32

package/plugin/node_modules/markdown-it/lib/rules_core/replacements.mjs

@@ -0,0 +1,101 @@
+// Simple typographic replacements
+//
+// (c) (C) → ©
+// (tm) (TM) → ™
+// (r) (R) → ®
+// +- → ±
+// ... → … (also ?.... → ?.., !.... → !..)
+// ???????? → ???, !!!!! → !!!, `,,` → `,`
+// -- → –, --- → —
+//
+
+// TODO:
+// - fractionals 1/2, 1/4, 3/4 -> ½, ¼, ¾
+// - multiplications 2 x 4 -> 2 × 4
+
+const RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/
+
+// Workaround for phantomjs - need regex without /g flag,
+// or root check will fail every second time
+const SCOPED_ABBR_TEST_RE = /\((c|tm|r)\)/i
+
+const SCOPED_ABBR_RE = /\((c|tm|r)\)/ig
+const SCOPED_ABBR = {
+  c: '©',
+  r: '®',
+  tm: '™'
+}
+
+function replaceFn (match, name) {
+  return SCOPED_ABBR[name.toLowerCase()]
+}
+
+function replace_scoped (inlineTokens) {
+  let inside_autolink = 0
+
+  for (let i = inlineTokens.length - 1; i >= 0; i--) {
+    const token = inlineTokens[i]
+
+    if (token.type === 'text' && !inside_autolink) {
+      token.content = token.content.replace(SCOPED_ABBR_RE, replaceFn)
+    }
+
+    if (token.type === 'link_open' && token.info === 'auto') {
+      inside_autolink--
+    }
+
+    if (token.type === 'link_close' && token.info === 'auto') {
+      inside_autolink++
+    }
+  }
+}
+
+function replace_rare (inlineTokens) {
+  let inside_autolink = 0
+
+  for (let i = inlineTokens.length - 1; i >= 0; i--) {
+    const token = inlineTokens[i]
+
+    if (token.type === 'text' && !inside_autolink) {
+      if (RARE_RE.test(token.content)) {
+        token.content = token.content
+          .replace(/\+-/g, '±')
+          // .., ..., ....... -> …
+          // but ?..... & !..... -> ?.. & !..
+          .replace(/\.{2,}/g, '…').replace(/([?!])…/g, '$1..')
+          .replace(/([?!]){4,}/g, '$1$1$1').replace(/,{2,}/g, ',')
+          // em-dash
+          .replace(/(^|[^-])---(?=[^-]|$)/mg, '$1\u2014')
+          // en-dash
+          .replace(/(^|\s)--(?=\s|$)/mg, '$1\u2013')
+          .replace(/(^|[^-\s])--(?=[^-\s]|$)/mg, '$1\u2013')
+      }
+    }
+
+    if (token.type === 'link_open' && token.info === 'auto') {
+      inside_autolink--
+    }
+
+    if (token.type === 'link_close' && token.info === 'auto') {
+      inside_autolink++
+    }
+  }
+}
+
+export default function replace (state) {
+  let blkIdx
+
+  if (!state.md.options.typographer) { return }
+
+  for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
+    if (state.tokens[blkIdx].type !== 'inline') { continue }
+
+    if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
+      replace_scoped(state.tokens[blkIdx].children)
+    }
+
+    if (RARE_RE.test(state.tokens[blkIdx].content)) {
+      replace_rare(state.tokens[blkIdx].children)
+    }
+  }
+}

package/plugin/node_modules/markdown-it/lib/rules_core/smartquotes.mjs

@@ -0,0 +1,193 @@
+// Convert straight quotation marks to typographic ones
+//
+
+import { isWhiteSpace, isPunctChar, isMdAsciiPunct } from '../common/utils.mjs'
+
+const QUOTE_TEST_RE = /['"]/
+const QUOTE_RE = /['"]/g
+const APOSTROPHE = '\u2019' /* ’ */
+
+function replaceAt (str, index, ch) {
+  return str.slice(0, index) + ch + str.slice(index + 1)
+}
+
+function process_inlines (tokens, state) {
+  let j
+
+  const stack = []
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+
+    const thisLevel = tokens[i].level
+
+    for (j = stack.length - 1; j >= 0; j--) {
+      if (stack[j].level <= thisLevel) { break }
+    }
+    stack.length = j + 1
+
+    if (token.type !== 'text') { continue }
+
+    let text = token.content
+    let pos = 0
+    let max = text.length
+
+    /* eslint no-labels:0,block-scoped-var:0 */
+    OUTER:
+    while (pos < max) {
+      QUOTE_RE.lastIndex = pos
+      const t = QUOTE_RE.exec(text)
+      if (!t) { break }
+
+      let canOpen = true
+      let canClose = true
+      pos = t.index + 1
+      const isSingle = (t[0] === "'")
+
+      // Find previous character,
+      // default to space if it's the beginning of the line
+      //
+      let lastChar = 0x20
+
+      if (t.index - 1 >= 0) {
+        lastChar = text.charCodeAt(t.index - 1)
+      } else {
+        for (j = i - 1; j >= 0; j--) {
+          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // lastChar defaults to 0x20
+          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'
+
+          lastChar = tokens[j].content.charCodeAt(tokens[j].content.length - 1)
+          break
+        }
+      }
+
+      // Find next character,
+      // default to space if it's the end of the line
+      //
+      let nextChar = 0x20
+
+      if (pos < max) {
+        nextChar = text.charCodeAt(pos)
+      } else {
+        for (j = i + 1; j < tokens.length; j++) {
+          if (tokens[j].type === 'softbreak' || tokens[j].type === 'hardbreak') break // nextChar defaults to 0x20
+          if (!tokens[j].content) continue // should skip all tokens except 'text', 'html_inline' or 'code_inline'
+
+          nextChar = tokens[j].content.charCodeAt(0)
+          break
+        }
+      }
+
+      const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar))
+      const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar))
+
+      const isLastWhiteSpace = isWhiteSpace(lastChar)
+      const isNextWhiteSpace = isWhiteSpace(nextChar)
+
+      if (isNextWhiteSpace) {
+        canOpen = false
+      } else if (isNextPunctChar) {
+        if (!(isLastWhiteSpace || isLastPunctChar)) {
+          canOpen = false
+        }
+      }
+
+      if (isLastWhiteSpace) {
+        canClose = false
+      } else if (isLastPunctChar) {
+        if (!(isNextWhiteSpace || isNextPunctChar)) {
+          canClose = false
+        }
+      }
+
+      if (nextChar === 0x22 /* " */ && t[0] === '"') {
+        if (lastChar >= 0x30 /* 0 */ && lastChar <= 0x39 /* 9 */) {
+          // special case: 1"" - count first quote as an inch
+          canClose = canOpen = false
+        }
+      }
+
+      if (canOpen && canClose) {
+        // Replace quotes in the middle of punctuation sequence, but not
+        // in the middle of the words, i.e.:
+        //
+        // 1. foo " bar " baz - not replaced
+        // 2. foo-"-bar-"-baz - replaced
+        // 3. foo"bar"baz     - not replaced
+        //
+        canOpen = isLastPunctChar
+        canClose = isNextPunctChar
+      }
+
+      if (!canOpen && !canClose) {
+        // middle of word
+        if (isSingle) {
+          token.content = replaceAt(token.content, t.index, APOSTROPHE)
+        }
+        continue
+      }
+
+      if (canClose) {
+        // this could be a closing quote, rewind the stack to get a match
+        for (j = stack.length - 1; j >= 0; j--) {
+          let item = stack[j]
+          if (stack[j].level < thisLevel) { break }
+          if (item.single === isSingle && stack[j].level === thisLevel) {
+            item = stack[j]
+
+            let openQuote
+            let closeQuote
+            if (isSingle) {
+              openQuote = state.md.options.quotes[2]
+              closeQuote = state.md.options.quotes[3]
+            } else {
+              openQuote = state.md.options.quotes[0]
+              closeQuote = state.md.options.quotes[1]
+            }
+
+            // replace token.content *before* tokens[item.token].content,
+            // because, if they are pointing at the same token, replaceAt
+            // could mess up indices when quote length != 1
+            token.content = replaceAt(token.content, t.index, closeQuote)
+            tokens[item.token].content = replaceAt(
+              tokens[item.token].content, item.pos, openQuote)
+
+            pos += closeQuote.length - 1
+            if (item.token === i) { pos += openQuote.length - 1 }
+
+            text = token.content
+            max = text.length
+
+            stack.length = j
+            continue OUTER
+          }
+        }
+      }
+
+      if (canOpen) {
+        stack.push({
+          token: i,
+          pos: t.index,
+          single: isSingle,
+          level: thisLevel
+        })
+      } else if (canClose && isSingle) {
+        token.content = replaceAt(token.content, t.index, APOSTROPHE)
+      }
+    }
+  }
+}
+
+export default function smartquotes (state) {
+  /* eslint max-depth:0 */
+  if (!state.md.options.typographer) { return }
+
+  for (let blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
+    if (state.tokens[blkIdx].type !== 'inline' ||
+        !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)) {
+      continue
+    }
+
+    process_inlines(state.tokens[blkIdx].children, state)
+  }
+}

package/plugin/node_modules/markdown-it/lib/rules_core/state_core.mjs

@@ -0,0 +1,17 @@
+// Core state object
+//
+
+import Token from '../token.mjs'
+
+function StateCore (src, md, env) {
+  this.src = src
+  this.env = env
+  this.tokens = []
+  this.inlineMode = false
+  this.md = md // link to parser instance
+}
+
+// re-export Token class to use in core rules
+StateCore.prototype.Token = Token
+
+export default StateCore

package/plugin/node_modules/markdown-it/lib/rules_core/text_join.mjs

@@ -0,0 +1,43 @@
+// Join raw text tokens with the rest of the text
+//
+// This is set as a separate rule to provide an opportunity for plugins
+// to run text replacements after text join, but before escape join.
+//
+// For example, `\:)` shouldn't be replaced with an emoji.
+//
+
+export default function text_join (state) {
+  let curr, last
+  const blockTokens = state.tokens
+  const l = blockTokens.length
+
+  for (let j = 0; j < l; j++) {
+    if (blockTokens[j].type !== 'inline') continue
+
+    const tokens = blockTokens[j].children
+    const max = tokens.length
+
+    for (curr = 0; curr < max; curr++) {
+      if (tokens[curr].type === 'text_special') {
+        tokens[curr].type = 'text'
+      }
+    }
+
+    for (curr = last = 0; curr < max; curr++) {
+      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/plugin/node_modules/markdown-it/lib/rules_inline/autolink.mjs

@@ -0,0 +1,72 @@
+// Process autolinks '<protocol:...>'
+
+/* eslint max-len:0 */
+const EMAIL_RE    = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/
+/* eslint-disable-next-line no-control-regex */
+const AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/
+
+export default function autolink (state, silent) {
+  let pos = state.pos
+
+  if (state.src.charCodeAt(pos) !== 0x3C/* < */) { return false }
+
+  const start = state.pos
+  const max = state.posMax
+
+  for (;;) {
+    if (++pos >= max) return false
+
+    const ch = state.src.charCodeAt(pos)
+
+    if (ch === 0x3C /* < */) return false
+    if (ch === 0x3E /* > */) break
+  }
+
+  const url = state.src.slice(start + 1, pos)
+
+  if (AUTOLINK_RE.test(url)) {
+    const fullUrl = state.md.normalizeLink(url)
+    if (!state.md.validateLink(fullUrl)) { return false }
+
+    if (!silent) {
+      const token_o   = state.push('link_open', 'a', 1)
+      token_o.attrs   = [['href', fullUrl]]
+      token_o.markup  = 'autolink'
+      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  = 'autolink'
+      token_c.info    = 'auto'
+    }
+
+    state.pos += url.length + 2
+    return true
+  }
+
+  if (EMAIL_RE.test(url)) {
+    const fullUrl = state.md.normalizeLink('mailto:' + url)
+    if (!state.md.validateLink(fullUrl)) { return false }
+
+    if (!silent) {
+      const token_o   = state.push('link_open', 'a', 1)
+      token_o.attrs   = [['href', fullUrl]]
+      token_o.markup  = 'autolink'
+      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  = 'autolink'
+      token_c.info    = 'auto'
+    }
+
+    state.pos += url.length + 2
+    return true
+  }
+
+  return false
+}

package/plugin/node_modules/markdown-it/lib/rules_inline/backticks.mjs

@@ -0,0 +1,60 @@
+// Parse backticks
+
+export default function backtick (state, silent) {
+  let pos = state.pos
+  const ch = state.src.charCodeAt(pos)
+
+  if (ch !== 0x60/* ` */) { return false }
+
+  const start = pos
+  pos++
+  const max = state.posMax
+
+  // scan marker length
+  while (pos < max && state.src.charCodeAt(pos) === 0x60/* ` */) { pos++ }
+
+  const marker = state.src.slice(start, pos)
+  const openerLength = marker.length
+
+  if (state.backticksScanned && (state.backticks[openerLength] || 0) <= start) {
+    if (!silent) state.pending += marker
+    state.pos += openerLength
+    return true
+  }
+
+  let matchEnd = pos
+  let matchStart
+
+  // Nothing found in the cache, scan until the end of the line (or until marker is found)
+  while ((matchStart = state.src.indexOf('`', matchEnd)) !== -1) {
+    matchEnd = matchStart + 1
+
+    // scan marker length
+    while (matchEnd < max && state.src.charCodeAt(matchEnd) === 0x60/* ` */) { matchEnd++ }
+
+    const closerLength = matchEnd - matchStart
+
+    if (closerLength === openerLength) {
+      // Found matching closer length.
+      if (!silent) {
+        const token = state.push('code_inline', 'code', 0)
+        token.markup = marker
+        token.content = state.src.slice(pos, matchStart)
+          .replace(/\n/g, ' ')
+          .replace(/^ (.+) $/, '$1')
+      }
+      state.pos = matchEnd
+      return true
+    }
+
+    // Some different length found, put it in cache as upper limit of where closer can be found
+    state.backticks[closerLength] = matchStart
+  }
+
+  // Scanned through the end, didn't find anything
+  state.backticksScanned = true
+
+  if (!silent) state.pending += marker
+  state.pos += openerLength
+  return true
+}

package/plugin/node_modules/markdown-it/lib/rules_inline/balance_pairs.mjs

@@ -0,0 +1,124 @@
+// For each opening emphasis-like marker find a matching closing one
+//
+
+function processDelimiters (delimiters) {
+  const openersBottom = {}
+  const max = delimiters.length
+
+  if (!max) return
+
+  // headerIdx is the first delimiter of the current (where closer is) delimiter run
+  let headerIdx = 0
+  let lastTokenIdx = -2 // needs any value lower than -1
+  const jumps = []
+
+  for (let closerIdx = 0; closerIdx < max; closerIdx++) {
+    const closer = delimiters[closerIdx]
+
+    jumps.push(0)
+
+    // markers belong to same delimiter run if:
+    //  - they have adjacent tokens
+    //  - AND markers are the same
+    //
+    if (delimiters[headerIdx].marker !== closer.marker || lastTokenIdx !== closer.token - 1) {
+      headerIdx = closerIdx
+    }
+
+    lastTokenIdx = closer.token
+
+    // Length is only used for emphasis-specific "rule of 3",
+    // if it's not defined (in strikethrough or 3rd party plugins),
+    // we can default it to 0 to disable those checks.
+    //
+    closer.length = closer.length || 0
+
+    if (!closer.close) continue
+
+    // Previously calculated lower bounds (previous fails)
+    // for each marker, each delimiter length modulo 3,
+    // and for whether this closer can be an opener;
+    // https://github.com/commonmark/cmark/commit/34250e12ccebdc6372b8b49c44fab57c72443460
+    /* eslint-disable-next-line no-prototype-builtins */
+    if (!openersBottom.hasOwnProperty(closer.marker)) {
+      openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1]
+    }
+
+    const minOpenerIdx = openersBottom[closer.marker][(closer.open ? 3 : 0) + (closer.length % 3)]
+
+    let openerIdx = headerIdx - jumps[headerIdx] - 1
+
+    let newMinOpenerIdx = openerIdx
+
+    for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
+      const opener = delimiters[openerIdx]
+
+      if (opener.marker !== closer.marker) continue
+
+      if (opener.open && opener.end < 0) {
+        let isOddMatch = false
+
+        // from spec:
+        //
+        // If one of the delimiters can both open and close emphasis, then the
+        // sum of the lengths of the delimiter runs containing the opening and
+        // closing delimiters must not be a multiple of 3 unless both lengths
+        // are multiples of 3.
+        //
+        if (opener.close || closer.open) {
+          if ((opener.length + closer.length) % 3 === 0) {
+            if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
+              isOddMatch = true
+            }
+          }
+        }
+
+        if (!isOddMatch) {
+          // If previous delimiter cannot be an opener, we can safely skip
+          // the entire sequence in future checks. This is required to make
+          // sure algorithm has linear complexity (see *_*_*_*_*_... case).
+          //
+          const lastJump = openerIdx > 0 && !delimiters[openerIdx - 1].open
+            ? jumps[openerIdx - 1] + 1
+            : 0
+
+          jumps[closerIdx] = closerIdx - openerIdx + lastJump
+          jumps[openerIdx] = lastJump
+
+          closer.open  = false
+          opener.end   = closerIdx
+          opener.close = false
+          newMinOpenerIdx = -1
+          // treat next token as start of run,
+          // it optimizes skips in **<...>**a**<...>** pathological case
+          lastTokenIdx = -2
+          break
+        }
+      }
+    }
+
+    if (newMinOpenerIdx !== -1) {
+      // If match for this delimiter run failed, we want to set lower bound for
+      // future lookups. This is required to make sure algorithm has linear
+      // complexity.
+      //
+      // See details here:
+      // https://github.com/commonmark/cmark/issues/178#issuecomment-270417442
+      //
+      openersBottom[closer.marker][(closer.open ? 3 : 0) + ((closer.length || 0) % 3)] = newMinOpenerIdx
+    }
+  }
+}
+
+export default function link_pairs (state) {
+  const tokens_meta = state.tokens_meta
+  const max = state.tokens_meta.length
+
+  processDelimiters(state.delimiters)
+
+  for (let curr = 0; curr < max; curr++) {
+    if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
+      processDelimiters(tokens_meta[curr].delimiters)
+    }
+  }
+}