@tinta-lang/syntax 0.0.0-stage → 0.1.16

package/vendor/mdast-util-to-markdown/lib/util/encode-info.js

@@ -0,0 +1,82 @@
+/**
+ * @import {EncodeSides} from '../types.js'
+ */
+
+import {classifyCharacter} from 'micromark-util-classify-character'
+
+/**
+ * Check whether to encode (as a character reference) the characters
+ * surrounding an attention run.
+ *
+ * Which characters are around an attention run influence whether it works or
+ * not.
+ *
+ * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.
+ * See this markdown in a particular renderer to see what works:
+ *
+ * ```markdown
+ * |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |
+ * | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |
+ * | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |
+ * | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |
+ * | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |
+ * | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |
+ * ```
+ *
+ * @param {number} outside
+ *   Code point on the outer side of the run.
+ * @param {number} inside
+ *   Code point on the inner side of the run.
+ * @param {string} marker
+ *   Marker of the run.
+ *   Underscores are handled more strictly (they form less often) than
+ *   asterisks.
+ * @returns {EncodeSides}
+ *   Whether to encode characters.
+ */
+// Important: punctuation must never be encoded.
+// Punctuation is solely used by markdown constructs.
+// And by encoding itself.
+// Encoding them will break constructs or double encode things.
+export function encodeInfo(outside, inside, marker) {
+  const outsideKind = classifyCharacter(outside)
+  const insideKind = classifyCharacter(inside)
+
+  // Letter outside:
+  if (outsideKind === undefined) {
+    return insideKind === undefined
+      ? // Letter inside:
+        // we have to encode *both* letters for `_` as it is looser.
+        // it already forms for `*` (and GFMs `~`).
+        marker === '_'
+        ? {inside: true, outside: true}
+        : {inside: false, outside: false}
+      : insideKind === 1
+        ? // Whitespace inside: encode both (letter, whitespace).
+          {inside: true, outside: true}
+        : // Punctuation inside: encode outer (letter)
+          {inside: false, outside: true}
+  }
+
+  // Whitespace outside:
+  if (outsideKind === 1) {
+    return insideKind === undefined
+      ? // Letter inside: already forms.
+        {inside: false, outside: false}
+      : insideKind === 1
+        ? // Whitespace inside: encode both (whitespace).
+          {inside: true, outside: true}
+        : // Punctuation inside: already forms.
+          {inside: false, outside: false}
+  }
+
+  // Punctuation outside:
+  return insideKind === undefined
+    ? // Letter inside: already forms.
+      {inside: false, outside: false}
+    : insideKind === 1
+      ? // Whitespace inside: encode inner (whitespace).
+        {inside: true, outside: false}
+      : // Punctuation inside: already forms.
+        {inside: false, outside: false}
+}

package/vendor/mdast-util-to-markdown/lib/util/format-code-as-indented.js

@@ -0,0 +1,27 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Code} from 'mdast'
+ */
+
+/**
+ * Checks if a code block can be formatted as an indented code block.
+ *
+ * @param {Code} node
+ *   Node to check.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {boolean}
+ *   Whether the code can be formatted as an indented code block.
+ */
+export function formatCodeAsIndented(node, state) {
+  return Boolean(
+    state.options.fences === false &&
+    node.value &&
+    // If there’s no info…
+    !node.lang &&
+    // And there’s a non-whitespace character…
+    /[^\n\r ]/.test(node.value) &&
+    // And the value doesn’t start or end in a blank…
+    !/^[\t ]*(?:[\n\r]|$)|(?:^|[\n\r])[\t ]*$/.test(node.value)
+  )
+}

package/vendor/mdast-util-to-markdown/lib/util/format-heading-as-setext.js

@@ -0,0 +1,39 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Heading} from 'mdast'
+ */
+
+import {EXIT, visit} from 'unist-util-visit'
+import {toString} from 'mdast-util-to-string'
+
+/**
+ * Checks if a heading can be formatted as a setext heading.
+ *
+ * @param {Heading} node
+ *   Node to check.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {boolean}
+ *   Whether the heading can be formatted as a setext heading.
+ */
+export function formatHeadingAsSetext(node, state) {
+  let literalWithBreak = false
+
+  // Look for literals with a line break.
+  // Note that this also
+  visit(node, function (node) {
+    if (
+      ('value' in node && /\r?\n|\r/.test(node.value)) ||
+      node.type === 'break'
+    ) {
+      literalWithBreak = true
+      return EXIT
+    }
+  })
+
+  return Boolean(
+    (!node.depth || node.depth < 3) &&
+    toString(node) &&
+    (state.options.setext || literalWithBreak)
+  )
+}

package/vendor/mdast-util-to-markdown/lib/util/format-link-as-autolink.js

@@ -0,0 +1,39 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Link} from 'mdast'
+ */
+
+import {toString} from 'mdast-util-to-string'
+
+/**
+ * Checks if a link can be formatted as an autolink.
+ *
+ * @param {Link} node
+ *   Node to check.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {boolean}
+ *   Whether the link can be formatted as an autolink.
+ */
+export function formatLinkAsAutolink(node, state) {
+  const raw = toString(node)
+
+  return Boolean(
+    !state.options.resourceLink &&
+    // If there’s a url…
+    node.url &&
+    // And there’s no title…
+    !node.title &&
+    // And the content of `node` is a single text node…
+    node.children &&
+    node.children.length === 1 &&
+    node.children[0].type === 'text' &&
+    // And if the url is the same as the content…
+    (raw === node.url || 'mailto:' + raw === node.url) &&
+    // And that starts w/ a protocol…
+    /^[a-z][+\-.a-z]+:/i.test(node.url) &&
+    // And that doesn’t contain ASCII control codes (character escapes and
+    // references don’t work), space, or angle brackets…
+    !/[\0- <>\u007F]/.test(node.url)
+  )
+}

package/vendor/mdast-util-to-markdown/lib/util/html-kind.js

@@ -0,0 +1,63 @@
+import {asciiAlpha, asciiAlphanumeric} from 'micromark-util-character'
+import {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'
+
+/**
+ * @typedef {1 | 2 | 3 | 4 | 5 | 6 | 7} Kind
+ *   Kind of HTML (flow) element.
+ */
+
+/**
+ * Infer the kind of HTML that `value` is.
+ *
+ * This works on valid trees as produced by `micromark`.
+ * Kinds:
+ *
+ * 1. raw
+ * 2. comment
+ * 3. instruction
+ * 4. declaration
+ * 5. cdata
+ * 6. block
+ * 7. other
+ *
+ * See: <https://spec.commonmark.org/0.31.2/#html-blocks>.
+ *
+ * @param {string} value
+ *   HTML.
+ * @returns {Kind | undefined}
+ *   Kind; `undefined` if unknown.
+ */
+export function htmlKind(value) {
+  if (value.charCodeAt(0) !== 60 /* `<` */) return
+
+  const next = value.charCodeAt(1)
+
+  if (next === 33 /* `!` */) {
+    const code = value.charCodeAt(2)
+    if (code === 45 /* `-` */) return 2
+    if (code === 91 /* `[` */) return 5
+    if (asciiAlpha(code)) return 4
+    return
+  }
+
+  if (next === 63 /* `?` */) return 3
+
+  const closing = next === 47 /* `/` */
+  const start = closing ? 2 : 1
+  let end = start
+  let code = value.charCodeAt(end)
+
+  if (!asciiAlpha(code)) return
+
+  while (code === 45 /* `-` */ || asciiAlphanumeric(code)) {
+    code = value.charCodeAt(++end)
+  }
+
+  const name = value.slice(start, end).toLowerCase()
+
+  if (!closing && code !== 47 /* `/` */ && htmlRawNames.includes(name)) {
+    return 1
+  }
+
+  return htmlBlockNames.includes(name) ? 6 : 7
+}

package/vendor/mdast-util-to-markdown/lib/util/indent-lines.js

@@ -0,0 +1,40 @@
+/**
+ * @import {IndentLines} from '../types.js'
+ */
+
+const eol = /\r?\n|\r/g
+
+/**
+ * Indents each line.
+ *
+ * @type {IndentLines}
+ */
+export function indentLines(value, map) {
+  /** @type {Array<string>} */
+  const result = []
+  let start = 0
+  let line = 0
+  /** @type {RegExpExecArray | null} */
+  let match
+
+  while ((match = eol.exec(value))) {
+    one(value.slice(start, match.index))
+    result.push(match[0])
+    start = match.index + match[0].length
+    line++
+  }
+
+  one(value.slice(start))
+
+  return result.join('')
+
+  /**
+   * Indents a single line.
+   *
+   * @param {string} value
+   *   Line.
+   */
+  function one(value) {
+    result.push(map(value, line, !value))
+  }
+}

package/vendor/mdast-util-to-markdown/lib/util/pattern-in-scope.js

@@ -0,0 +1,52 @@
+/**
+ * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Check if a pattern is in scope based on the current stack of constructs.
+ *
+ * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
+ * @param {Unsafe} pattern
+ *   Pattern to check.
+ * @returns {boolean}
+ *   Whether the pattern is in scope.
+ */
+export function patternInScope(stack, pattern) {
+  return (
+    listInScope(stack, pattern.inConstruct, true) &&
+    !listInScope(stack, pattern.notInConstruct, false)
+  )
+}
+
+/**
+ * Check if any of the constructs in the list are present in the stack.
+ *
+ * @param {Array<ConstructName>} stack
+ *   Current stack of constructs.
+ * @param {Unsafe['inConstruct']} list
+ *   List of constructs to check for in the stack.
+ * @param {boolean} none
+ *   Value to return if the list is empty or not provided.
+ * @returns {boolean}
+ *   Whether any of the constructs in the list are present in the stack.
+ */
+function listInScope(stack, list, none) {
+  if (typeof list === 'string') {
+    list = [list]
+  }
+
+  if (!list || list.length === 0) {
+    return none
+  }
+
+  let index = -1
+
+  while (++index < list.length) {
+    if (stack.includes(list[index])) {
+      return true
+    }
+  }
+
+  return false
+}

package/vendor/mdast-util-to-markdown/lib/util/safe.js

@@ -0,0 +1,263 @@
+/**
+ * @import {Nodes} from 'mdast'
+ * @import {SafeConfig, State, Unsafe} from 'mdast-util-to-markdown'
+ */
+
+import {classifyCharacter} from 'micromark-util-classify-character'
+import {encodeCharacterReference} from './encode-character-reference.js'
+import {patternInScope} from './pattern-in-scope.js'
+
+const own = {}.hasOwnProperty
+
+/**
+ * Make a string safe for embedding in markdown constructs.
+ *
+ * In markdown, almost all punctuation characters can, in certain cases,
+ * result in something.
+ * Whether they do is highly subjective to where they happen and in what
+ * they happen.
+ *
+ * To solve this, `mdast-util-to-markdown` tracks:
+ *
+ * * characters before and after something;
+ * * what “constructs” we are in.
+ *
+ * This information is then used by this function to escape or encode
+ * special characters.
+ *
+ * @param {State} state
+ *   Info passed around about the current state.
+ * @param {string | null | undefined} input
+ *   Raw value to make safe.
+ * @param {SafeConfig} config
+ *   Configuration.
+ * @returns {string}
+ *   Serialized markdown safe for embedding.
+ */
+export function safe(state, input, config) {
+  const value = (config.before || '') + (input || '') + (config.after || '')
+  /** @type {Array<number>} */
+  const positions = []
+  /** @type {Array<string>} */
+  const result = []
+  /** @type {Record<number, {before: boolean, after: boolean}>} */
+  const infos = {}
+  // Character escapes and references do not work in autolinks, so
+  // percent-encoding is used instead.
+  const percentEncode = state.stack.includes('autolink')
+  const offset = config.before ? config.before.length : 0
+  const end = value.length - (config.after ? config.after.length : 0)
+  let index = -1
+
+  while (++index < state.unsafe.length) {
+    const pattern = state.unsafe[index]
+
+    if (
+      !patternInScope(state.stack, pattern) ||
+      !nodeInScope(pattern.beforeNode, config.beforeNode) ||
+      !nodeInScope(pattern.afterNode, config.afterNode)
+    ) {
+      continue
+    }
+
+    const expression = state.compilePattern(pattern)
+    const from = pattern.beforeNode ? offset : 0
+    const subject = value.slice(from, pattern.afterNode ? end : undefined)
+    /** @type {RegExpExecArray | null} */
+    let match
+
+    while ((match = expression.exec(subject))) {
+      const before = 'before' in pattern || Boolean(pattern.atBreak)
+      const after = 'after' in pattern
+      const position = from + match.index + (before ? match[1].length : 0)
+
+      if (own.call(infos, position)) {
+        if (infos[position].before && !before) {
+          infos[position].before = false
+        }
+
+        if (infos[position].after && !after) {
+          infos[position].after = false
+        }
+      } else {
+        positions.push(position)
+        infos[position] = {before, after}
+      }
+    }
+  }
+
+  positions.sort(numerical)
+
+  let start = offset
+  index = -1
+
+  while (++index < positions.length) {
+    const position = positions[index]
+
+    // Character before or after matched:
+    if (position < start || position >= end) {
+      continue
+    }
+
+    // Special handling for “intraword” underscores (`a_b`, `a__b`).
+    // Those are different from asterisks in forming attention.
+    // Note that `a _ b` also cannot form but not escaping it is very complex,
+    // so that’s not handled.
+    if (
+      value.charAt(position) === '_' &&
+      // Preceded by an unescaped character that is not punctuation or whitespace:
+      position > 0 &&
+      classifyCharacter(value.charCodeAt(position - 1)) === undefined &&
+      !own.call(infos, position - 1) &&
+      // Characters next to attention markers can become character references
+      // later, turning `a` into `&#x61;`, so those do not count.
+      !(position - 1 === offset && /[*_]/.test(value.charAt(offset - 1)))
+    ) {
+      let sequenceEnd = position + 1
+
+      // Look for the whole run.
+      while (sequenceEnd < end && value.charAt(sequenceEnd) === '_') {
+        sequenceEnd++
+      }
+
+      const skip = sequenceEnd - position - 1
+
+      if (
+        // All underscores in the run are unsafe positions, so they can be
+        // skipped.
+        positions[index + skip] === sequenceEnd - 1 &&
+        // Rest as above.
+        sequenceEnd < value.length &&
+        classifyCharacter(value.charCodeAt(sequenceEnd)) === undefined &&
+        !own.call(infos, sequenceEnd) &&
+        !(sequenceEnd === end - 1 && /[*_]/.test(value.charAt(end)))
+      ) {
+        index += skip
+        continue
+      }
+    }
+
+    // If this character is supposed to be escaped because it has a condition on
+    // the next character, and the next character is definitly being escaped,
+    // then skip this escape.
+    if (
+      (position + 1 < end &&
+        positions[index + 1] === position + 1 &&
+        infos[position].after &&
+        !infos[position + 1].before &&
+        !infos[position + 1].after) ||
+      (positions[index - 1] === position - 1 &&
+        infos[position].before &&
+        !infos[position - 1].before &&
+        !infos[position - 1].after)
+    ) {
+      continue
+    }
+
+    if (start !== position) {
+      const slice = value.slice(start, position)
+      // If we have to use a character reference, an ampersand would be more
+      // correct, but as backslashes only care about punctuation, either will
+      // do the trick
+      result.push(percentEncode ? slice : escapeBackslashes(slice, '\\'))
+    }
+
+    start = position
+
+    // Percent-encoding such as `%20`.
+    if (percentEncode) {
+      result.push(
+        '%' +
+          value.charCodeAt(position).toString(16).toUpperCase().padStart(2, '0')
+      )
+      start++
+    } else if (
+      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
+      (!config.encode || !config.encode.includes(value.charAt(position)))
+    ) {
+      // Character escape.
+      result.push('\\')
+    } else {
+      // Character reference.
+      result.push(encodeCharacterReference(value.charCodeAt(position)))
+      start++
+    }
+  }
+
+  const rest = value.slice(start, end)
+  result.push(percentEncode ? rest : escapeBackslashes(rest, config.after))
+
+  return result.join('')
+}
+
+/**
+ * Check if a node matches the node types of a pattern.
+ *
+ * @param {Array<Nodes['type']> | Nodes['type'] | null | undefined} types
+ *   Node types.
+ * @param {Nodes | undefined} node
+ *   Node.
+ * @returns {boolean}
+ *   Whether `node` matches `types`.
+ */
+function nodeInScope(types, node) {
+  if (!types) return true
+  if (!node) return false
+  return typeof types === 'string'
+    ? types === node.type
+    : types.includes(node.type)
+}
+
+/**
+ * Compare two numbers.
+ *
+ * @param {number} a
+ *   Number.
+ * @param {number} b
+ *   Other number.
+ * @returns {number}
+ *   Result.
+ */
+function numerical(a, b) {
+  return a - b
+}
+
+/**
+ * Escape backslashes in a string, considering characters that follow.
+ *
+ * @param {string} value
+ *   Value.
+ * @param {string} after
+ *   Characters that follow the value.
+ * @returns {string}
+ *   Escaped string.
+ */
+function escapeBackslashes(value, after) {
+  const expression = /\\(?=[!-/:-@[-`{-~])/g
+  /** @type {Array<number>} */
+  const positions = []
+  /** @type {Array<string>} */
+  const results = []
+  const whole = value + after
+  let index = -1
+  let start = 0
+  /** @type {RegExpExecArray | null} */
+  let match
+
+  while ((match = expression.exec(whole))) {
+    positions.push(match.index)
+  }
+
+  while (++index < positions.length) {
+    if (start !== positions[index]) {
+      results.push(value.slice(start, positions[index]))
+    }
+
+    results.push('\\')
+    start = positions[index]
+  }
+
+  results.push(value.slice(start))
+
+  return results.join('')
+}

package/vendor/mdast-util-to-markdown/lib/util/track.js

@@ -0,0 +1,55 @@
+/**
+ * @import {CreateTracker, TrackCurrent, TrackMove, TrackShift} from '../types.js'
+ */
+
+/**
+ * Track positional info in the output.
+ *
+ * @type {CreateTracker}
+ */
+export function track(config) {
+  // Defaults are used to prevent crashes when older utilities somehow activate
+  // this code.
+  /* c8 ignore next 5 */
+  const options = config || {}
+  const now = options.now || {}
+  let lineShift = options.lineShift || 0
+  let line = now.line || 1
+  let column = now.column || 1
+
+  return {move, current, shift}
+
+  /**
+   * Get the current tracked info.
+   *
+   * @type {TrackCurrent}
+   */
+  function current() {
+    return {now: {line, column}, lineShift}
+  }
+
+  /**
+   * Define an increased line shift (the typical indent for lines).
+   *
+   * @type {TrackShift}
+   */
+  function shift(value) {
+    lineShift += value
+  }
+
+  /**
+   * Move past some generated markdown.
+   *
+   * @type {TrackMove}
+   */
+  function move(input) {
+    // eslint-disable-next-line unicorn/prefer-default-parameters
+    const value = input || ''
+    const chunks = value.split(/\r?\n|\r/g)
+    const tail = chunks[chunks.length - 1]
+    line += chunks.length - 1
+    column =
+      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift
+    return value
+  }
+}

package/vendor/mdast-util-to-markdown/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) Titus Wormer <tituswormer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.