@rse/ase 0.0.30 → 0.0.32

package/plugin/node_modules/markdown-it/lib/renderer.mjs

@@ -0,0 +1,322 @@
+/**
+ * class Renderer
+ *
+ * Generates HTML from parsed token stream. Each instance has independent
+ * copy of rules. Those can be rewritten with ease. Also, you can add new
+ * rules if you create plugin and adds new token types.
+ **/
+
+import { assign, unescapeAll, escapeHtml } from './common/utils.mjs'
+
+const default_rules = {}
+
+default_rules.code_inline = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx]
+
+  return  '<code' + slf.renderAttrs(token) + '>' +
+          escapeHtml(token.content) +
+          '</code>'
+}
+
+default_rules.code_block = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx]
+
+  return  '<pre' + slf.renderAttrs(token) + '><code>' +
+          escapeHtml(tokens[idx].content) +
+          '</code></pre>\n'
+}
+
+default_rules.fence = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx]
+  const info = token.info ? unescapeAll(token.info).trim() : ''
+  let langName = ''
+  let langAttrs = ''
+
+  if (info) {
+    const arr = info.split(/(\s+)/g)
+    langName = arr[0]
+    langAttrs = arr.slice(2).join('')
+  }
+
+  let highlighted
+  if (options.highlight) {
+    highlighted = options.highlight(token.content, langName, langAttrs) || escapeHtml(token.content)
+  } else {
+    highlighted = escapeHtml(token.content)
+  }
+
+  if (highlighted.indexOf('<pre') === 0) {
+    return highlighted + '\n'
+  }
+
+  // If language exists, inject class gently, without modifying original token.
+  // May be, one day we will add .deepClone() for token and simplify this part, but
+  // now we prefer to keep things local.
+  if (info) {
+    const i = token.attrIndex('class')
+    const tmpAttrs = token.attrs ? token.attrs.slice() : []
+
+    if (i < 0) {
+      tmpAttrs.push(['class', options.langPrefix + langName])
+    } else {
+      tmpAttrs[i] = tmpAttrs[i].slice()
+      tmpAttrs[i][1] += ' ' + options.langPrefix + langName
+    }
+
+    // Fake token just to render attributes
+    const tmpToken = {
+      attrs: tmpAttrs
+    }
+
+    return `<pre><code${slf.renderAttrs(tmpToken)}>${highlighted}</code></pre>\n`
+  }
+
+  return `<pre><code${slf.renderAttrs(token)}>${highlighted}</code></pre>\n`
+}
+
+default_rules.image = function (tokens, idx, options, env, slf) {
+  const token = tokens[idx]
+
+  // "alt" attr MUST be set, even if empty. Because it's mandatory and
+  // should be placed on proper position for tests.
+  //
+  // Replace content with actual value
+
+  token.attrs[token.attrIndex('alt')][1] =
+    slf.renderInlineAsText(token.children, options, env)
+
+  return slf.renderToken(tokens, idx, options)
+}
+
+default_rules.hardbreak = function (tokens, idx, options /*, env */) {
+  return options.xhtmlOut ? '<br />\n' : '<br>\n'
+}
+default_rules.softbreak = function (tokens, idx, options /*, env */) {
+  return options.breaks ? (options.xhtmlOut ? '<br />\n' : '<br>\n') : '\n'
+}
+
+default_rules.text = function (tokens, idx /*, options, env */) {
+  return escapeHtml(tokens[idx].content)
+}
+
+default_rules.html_block = function (tokens, idx /*, options, env */) {
+  return tokens[idx].content
+}
+default_rules.html_inline = function (tokens, idx /*, options, env */) {
+  return tokens[idx].content
+}
+
+/**
+ * new Renderer()
+ *
+ * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
+ **/
+function Renderer () {
+  /**
+   * Renderer#rules -> Object
+   *
+   * Contains render rules for tokens. Can be updated and extended.
+   *
+   * ##### Example
+   *
+   * ```javascript
+   * var md = require('markdown-it')();
+   *
+   * md.renderer.rules.strong_open  = function () { return '<b>'; };
+   * md.renderer.rules.strong_close = function () { return '</b>'; };
+   *
+   * var result = md.renderInline(...);
+   * ```
+   *
+   * Each rule is called as independent static function with fixed signature:
+   *
+   * ```javascript
+   * function my_token_render(tokens, idx, options, env, renderer) {
+   *   // ...
+   *   return renderedHTML;
+   * }
+   * ```
+   *
+   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs)
+   * for more details and examples.
+   **/
+  this.rules = assign({}, default_rules)
+}
+
+/**
+ * Renderer.renderAttrs(token) -> String
+ *
+ * Render token attributes to string.
+ **/
+Renderer.prototype.renderAttrs = function renderAttrs (token) {
+  let i, l, result
+
+  if (!token.attrs) { return '' }
+
+  result = ''
+
+  for (i = 0, l = token.attrs.length; i < l; i++) {
+    result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"'
+  }
+
+  return result
+}
+
+/**
+ * Renderer.renderToken(tokens, idx, options) -> String
+ * - tokens (Array): list of tokens
+ * - idx (Numbed): token index to render
+ * - options (Object): params of parser instance
+ *
+ * Default token renderer. Can be overriden by custom function
+ * in [[Renderer#rules]].
+ **/
+Renderer.prototype.renderToken = function renderToken (tokens, idx, options) {
+  const token = tokens[idx]
+  let result = ''
+
+  // Tight list paragraphs
+  if (token.hidden) {
+    return ''
+  }
+
+  // Insert a newline between hidden paragraph and subsequent opening
+  // block-level tag.
+  //
+  // For example, here we should insert a newline before blockquote:
+  //  - a
+  //    >
+  //
+  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
+    result += '\n'
+  }
+
+  // Add token name, e.g. `<img`
+  result += (token.nesting === -1 ? '</' : '<') + token.tag
+
+  // Encode attributes, e.g. `<img src="foo"`
+  result += this.renderAttrs(token)
+
+  // Add a slash for self-closing tags, e.g. `<img src="foo" /`
+  if (token.nesting === 0 && options.xhtmlOut) {
+    result += ' /'
+  }
+
+  // Check if we need to add a newline after this tag
+  let needLf = false
+  if (token.block) {
+    needLf = true
+
+    if (token.nesting === 1) {
+      if (idx + 1 < tokens.length) {
+        const nextToken = tokens[idx + 1]
+
+        if (nextToken.type === 'inline' || nextToken.hidden) {
+          // Block-level tag containing an inline tag.
+          //
+          needLf = false
+        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
+          // Opening tag + closing tag of the same type. E.g. `<li></li>`.
+          //
+          needLf = false
+        }
+      }
+    }
+  }
+
+  result += needLf ? '>\n' : '>'
+
+  return result
+}
+
+/**
+ * Renderer.renderInline(tokens, options, env) -> String
+ * - tokens (Array): list on block tokens to render
+ * - options (Object): params of parser instance
+ * - env (Object): additional data from parsed input (references, for example)
+ *
+ * The same as [[Renderer.render]], but for single token of `inline` type.
+ **/
+Renderer.prototype.renderInline = function (tokens, options, env) {
+  let result = ''
+  const rules = this.rules
+
+  for (let i = 0, len = tokens.length; i < len; i++) {
+    const type = tokens[i].type
+
+    if (typeof rules[type] !== 'undefined') {
+      result += rules[type](tokens, i, options, env, this)
+    } else {
+      result += this.renderToken(tokens, i, options)
+    }
+  }
+
+  return result
+}
+
+/** internal
+ * Renderer.renderInlineAsText(tokens, options, env) -> String
+ * - tokens (Array): list on block tokens to render
+ * - options (Object): params of parser instance
+ * - env (Object): additional data from parsed input (references, for example)
+ *
+ * Special kludge for image `alt` attributes to conform CommonMark spec.
+ * Don't try to use it! Spec requires to show `alt` content with stripped markup,
+ * instead of simple escaping.
+ **/
+Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
+  let result = ''
+
+  for (let i = 0, len = tokens.length; i < len; i++) {
+    switch (tokens[i].type) {
+      case 'text':
+        result += tokens[i].content
+        break
+      case 'image':
+        result += this.renderInlineAsText(tokens[i].children, options, env)
+        break
+      case 'html_inline':
+      case 'html_block':
+        result += tokens[i].content
+        break
+      case 'softbreak':
+      case 'hardbreak':
+        result += '\n'
+        break
+      default:
+        // all other tokens are skipped
+    }
+  }
+
+  return result
+}
+
+/**
+ * Renderer.render(tokens, options, env) -> String
+ * - tokens (Array): list on block tokens to render
+ * - options (Object): params of parser instance
+ * - env (Object): additional data from parsed input (references, for example)
+ *
+ * Takes token stream and generates HTML. Probably, you will never need to call
+ * this method directly.
+ **/
+Renderer.prototype.render = function (tokens, options, env) {
+  let result = ''
+  const rules = this.rules
+
+  for (let i = 0, len = tokens.length; i < len; i++) {
+    const type = tokens[i].type
+
+    if (type === 'inline') {
+      result += this.renderInline(tokens[i].children, options, env)
+    } else if (typeof rules[type] !== 'undefined') {
+      result += rules[type](tokens, i, options, env, this)
+    } else {
+      result += this.renderToken(tokens, i, options, env)
+    }
+  }
+
+  return result
+}
+
+export default Renderer

package/plugin/node_modules/markdown-it/lib/ruler.mjs

@@ -0,0 +1,340 @@
+/**
+ * class Ruler
+ *
+ * Helper class, used by [[MarkdownIt#core]], [[MarkdownIt#block]] and
+ * [[MarkdownIt#inline]] to manage sequences of functions (rules):
+ *
+ * - keep rules in defined order
+ * - assign the name to each rule
+ * - enable/disable rules
+ * - add/replace rules
+ * - allow assign rules to additional named chains (in the same)
+ * - cacheing lists of active rules
+ *
+ * You will not need use this class directly until write plugins. For simple
+ * rules control use [[MarkdownIt.disable]], [[MarkdownIt.enable]] and
+ * [[MarkdownIt.use]].
+ **/
+
+/**
+ * new Ruler()
+ **/
+function Ruler () {
+  // List of added rules. Each element is:
+  //
+  // {
+  //   name: XXX,
+  //   enabled: Boolean,
+  //   fn: Function(),
+  //   alt: [ name2, name3 ]
+  // }
+  //
+  this.__rules__ = []
+
+  // Cached rule chains.
+  //
+  // First level - chain name, '' for default.
+  // Second level - diginal anchor for fast filtering by charcodes.
+  //
+  this.__cache__ = null
+}
+
+// Helper methods, should not be used directly
+
+// Find rule index by name
+//
+Ruler.prototype.__find__ = function (name) {
+  for (let i = 0; i < this.__rules__.length; i++) {
+    if (this.__rules__[i].name === name) {
+      return i
+    }
+  }
+  return -1
+}
+
+// Build rules lookup cache
+//
+Ruler.prototype.__compile__ = function () {
+  const self = this
+  const chains = ['']
+
+  // collect unique names
+  self.__rules__.forEach(function (rule) {
+    if (!rule.enabled) { return }
+
+    rule.alt.forEach(function (altName) {
+      if (chains.indexOf(altName) < 0) {
+        chains.push(altName)
+      }
+    })
+  })
+
+  self.__cache__ = {}
+
+  chains.forEach(function (chain) {
+    self.__cache__[chain] = []
+    self.__rules__.forEach(function (rule) {
+      if (!rule.enabled) { return }
+
+      if (chain && rule.alt.indexOf(chain) < 0) { return }
+
+      self.__cache__[chain].push(rule.fn)
+    })
+  })
+}
+
+/**
+ * Ruler.at(name, fn [, options])
+ * - name (String): rule name to replace.
+ * - fn (Function): new rule function.
+ * - options (Object): new rule options (not mandatory).
+ *
+ * Replace rule by name with new function & options. Throws error if name not
+ * found.
+ *
+ * ##### Options:
+ *
+ * - __alt__ - array with names of "alternate" chains.
+ *
+ * ##### Example
+ *
+ * Replace existing typographer replacement rule with new one:
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ *
+ * md.core.ruler.at('replacements', function replace(state) {
+ *   //...
+ * });
+ * ```
+ **/
+Ruler.prototype.at = function (name, fn, options) {
+  const index = this.__find__(name)
+  const opt = options || {}
+
+  if (index === -1) { throw new Error('Parser rule not found: ' + name) }
+
+  this.__rules__[index].fn = fn
+  this.__rules__[index].alt = opt.alt || []
+  this.__cache__ = null
+}
+
+/**
+ * Ruler.before(beforeName, ruleName, fn [, options])
+ * - beforeName (String): new rule will be added before this one.
+ * - ruleName (String): name of added rule.
+ * - fn (Function): rule function.
+ * - options (Object): rule options (not mandatory).
+ *
+ * Add new rule to chain before one with given name. See also
+ * [[Ruler.after]], [[Ruler.push]].
+ *
+ * ##### Options:
+ *
+ * - __alt__ - array with names of "alternate" chains.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ *
+ * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+ *   //...
+ * });
+ * ```
+ **/
+Ruler.prototype.before = function (beforeName, ruleName, fn, options) {
+  const index = this.__find__(beforeName)
+  const opt = options || {}
+
+  if (index === -1) { throw new Error('Parser rule not found: ' + beforeName) }
+
+  this.__rules__.splice(index, 0, {
+    name: ruleName,
+    enabled: true,
+    fn,
+    alt: opt.alt || []
+  })
+
+  this.__cache__ = null
+}
+
+/**
+ * Ruler.after(afterName, ruleName, fn [, options])
+ * - afterName (String): new rule will be added after this one.
+ * - ruleName (String): name of added rule.
+ * - fn (Function): rule function.
+ * - options (Object): rule options (not mandatory).
+ *
+ * Add new rule to chain after one with given name. See also
+ * [[Ruler.before]], [[Ruler.push]].
+ *
+ * ##### Options:
+ *
+ * - __alt__ - array with names of "alternate" chains.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ *
+ * md.inline.ruler.after('text', 'my_rule', function replace(state) {
+ *   //...
+ * });
+ * ```
+ **/
+Ruler.prototype.after = function (afterName, ruleName, fn, options) {
+  const index = this.__find__(afterName)
+  const opt = options || {}
+
+  if (index === -1) { throw new Error('Parser rule not found: ' + afterName) }
+
+  this.__rules__.splice(index + 1, 0, {
+    name: ruleName,
+    enabled: true,
+    fn,
+    alt: opt.alt || []
+  })
+
+  this.__cache__ = null
+}
+
+/**
+ * Ruler.push(ruleName, fn [, options])
+ * - ruleName (String): name of added rule.
+ * - fn (Function): rule function.
+ * - options (Object): rule options (not mandatory).
+ *
+ * Push new rule to the end of chain. See also
+ * [[Ruler.before]], [[Ruler.after]].
+ *
+ * ##### Options:
+ *
+ * - __alt__ - array with names of "alternate" chains.
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ *
+ * md.core.ruler.push('my_rule', function replace(state) {
+ *   //...
+ * });
+ * ```
+ **/
+Ruler.prototype.push = function (ruleName, fn, options) {
+  const opt = options || {}
+
+  this.__rules__.push({
+    name: ruleName,
+    enabled: true,
+    fn,
+    alt: opt.alt || []
+  })
+
+  this.__cache__ = null
+}
+
+/**
+ * Ruler.enable(list [, ignoreInvalid]) -> Array
+ * - list (String|Array): list of rule names to enable.
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+ *
+ * Enable rules with given names. If any rule name not found - throw Error.
+ * Errors can be disabled by second param.
+ *
+ * Returns list of found rule names (if no exception happened).
+ *
+ * See also [[Ruler.disable]], [[Ruler.enableOnly]].
+ **/
+Ruler.prototype.enable = function (list, ignoreInvalid) {
+  if (!Array.isArray(list)) { list = [list] }
+
+  const result = []
+
+  // Search by name and enable
+  list.forEach(function (name) {
+    const idx = this.__find__(name)
+
+    if (idx < 0) {
+      if (ignoreInvalid) { return }
+      throw new Error('Rules manager: invalid rule name ' + name)
+    }
+    this.__rules__[idx].enabled = true
+    result.push(name)
+  }, this)
+
+  this.__cache__ = null
+  return result
+}
+
+/**
+ * Ruler.enableOnly(list [, ignoreInvalid])
+ * - list (String|Array): list of rule names to enable (whitelist).
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+ *
+ * Enable rules with given names, and disable everything else. If any rule name
+ * not found - throw Error. Errors can be disabled by second param.
+ *
+ * See also [[Ruler.disable]], [[Ruler.enable]].
+ **/
+Ruler.prototype.enableOnly = function (list, ignoreInvalid) {
+  if (!Array.isArray(list)) { list = [list] }
+
+  this.__rules__.forEach(function (rule) { rule.enabled = false })
+
+  this.enable(list, ignoreInvalid)
+}
+
+/**
+ * Ruler.disable(list [, ignoreInvalid]) -> Array
+ * - list (String|Array): list of rule names to disable.
+ * - ignoreInvalid (Boolean): set `true` to ignore errors when rule not found.
+ *
+ * Disable rules with given names. If any rule name not found - throw Error.
+ * Errors can be disabled by second param.
+ *
+ * Returns list of found rule names (if no exception happened).
+ *
+ * See also [[Ruler.enable]], [[Ruler.enableOnly]].
+ **/
+Ruler.prototype.disable = function (list, ignoreInvalid) {
+  if (!Array.isArray(list)) { list = [list] }
+
+  const result = []
+
+  // Search by name and disable
+  list.forEach(function (name) {
+    const idx = this.__find__(name)
+
+    if (idx < 0) {
+      if (ignoreInvalid) { return }
+      throw new Error('Rules manager: invalid rule name ' + name)
+    }
+    this.__rules__[idx].enabled = false
+    result.push(name)
+  }, this)
+
+  this.__cache__ = null
+  return result
+}
+
+/**
+ * Ruler.getRules(chainName) -> Array
+ *
+ * Return array of active functions (rules) for given chain name. It analyzes
+ * rules configuration, compiles caches if not exists and returns result.
+ *
+ * Default chain name is `''` (empty string). It can't be skipped. That's
+ * done intentionally, to keep signature monomorphic for high speed.
+ **/
+Ruler.prototype.getRules = function (chainName) {
+  if (this.__cache__ === null) {
+    this.__compile__()
+  }
+
+  // Chain can be empty, if rules disabled. But we still have to return Array.
+  return this.__cache__[chainName] || []
+}
+
+export default Ruler