@tinta-lang/syntax 0.0.0-stage → 0.1.0-dev.0

package/vendor/mdast-util-to-markdown/lib/handle/link-reference.js

@@ -0,0 +1,78 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {LinkReference, Parents} from 'mdast'
+ */
+
+linkReference.peek = linkReferencePeek
+
+/**
+ * Serialize a link reference node.
+ *
+ * @param {LinkReference} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function linkReference(node, _, state, info) {
+  const type = node.referenceType
+  const exit = state.enter('linkReference')
+  let subexit = state.enter('label')
+  const tracker = state.createTracker(info)
+  let value = tracker.move('[')
+  const text = state.containerPhrasing(node, {
+    before: value,
+    after: ']',
+    ...tracker.current()
+  })
+  value += tracker.move(text + '][')
+
+  subexit()
+  // Hide that we’re in phrasing as things like attention or code cannot form
+  // in references.
+  // Character escapes and references *do* work.
+  // It is important to know about other constructs, such as table cells.
+  const stack = state.stack
+  state.stack = stack.filter(function (d) {
+    return d !== 'phrasing'
+  })
+  subexit = state.enter('reference')
+  // Note: for proper tracking, we should reset the output positions when we end
+  // up making a `shortcut` reference, because then there is no brace output.
+  // Practically, in that case, there is no content, so it doesn’t matter that
+  // we’ve tracked one too many characters.
+  const reference = state.safe(state.associationId(node), {
+    before: value,
+    after: ']',
+    ...tracker.current()
+  })
+  subexit()
+  state.stack = stack
+  exit()
+
+  if (type === 'full' || !text || text !== reference) {
+    value += tracker.move(reference + ']')
+  } else if (type === 'shortcut') {
+    // Remove the unwanted `[`.
+    value = value.slice(0, -1)
+  } else {
+    value += tracker.move(']')
+  }
+
+  return value
+}
+
+/**
+ * Peek at this node.
+ *
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function linkReferencePeek() {
+  return '['
+}

package/vendor/mdast-util-to-markdown/lib/handle/link.js

@@ -0,0 +1,129 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Link, Parents} from 'mdast'
+ * @import {Exit} from '../types.js'
+ */
+
+import {checkQuote} from '../util/check-quote.js'
+import {formatLinkAsAutolink} from '../util/format-link-as-autolink.js'
+
+link.peek = linkPeek
+
+/**
+ * Serialize a link node.
+ *
+ * @param {Link} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function link(node, _, state, info) {
+  const quote = checkQuote(state)
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe'
+  const tracker = state.createTracker(info)
+
+  if (formatLinkAsAutolink(node, state)) {
+    // Hide that we’re in phrasing as things like attention or code cannot form
+    // in autolinks.
+    // Character escapes also don’t work (nor character references),
+    // but that is a different matter, which `safe.js` handles for `autolink`.
+    // It is important to know about other constructs, such as table cells.
+    const stack = state.stack
+    state.stack = stack.filter(function (d) {
+      return d !== 'phrasing'
+    })
+    const exit = state.enter('autolink')
+    let value = tracker.move('<')
+    value += tracker.move(
+      state.containerPhrasing(node, {
+        before: value,
+        after: '>',
+        ...tracker.current()
+      })
+    )
+    value += tracker.move('>')
+    exit()
+    state.stack = stack
+    return value
+  }
+
+  const exit = state.enter('link')
+  let subexit = state.enter('label')
+  let value = tracker.move('[')
+  value += tracker.move(
+    state.containerPhrasing(node, {
+      before: value,
+      after: '](',
+      ...tracker.current()
+    })
+  )
+  value += tracker.move('](')
+  subexit()
+
+  if (
+    // If there’s no url but there is a title…
+    (!node.url && node.title) ||
+    // If there are control characters or whitespace.
+    /[\0- \u007F]/.test(node.url)
+  ) {
+    subexit = state.enter('destinationLiteral')
+    value += tracker.move('<')
+    value += tracker.move(
+      state.safe(node.url, {before: value, after: '>', ...tracker.current()})
+    )
+    value += tracker.move('>')
+  } else {
+    // No whitespace, raw is prettier.
+    subexit = state.enter('destinationRaw')
+    value += tracker.move(
+      state.safe(node.url, {
+        before: value,
+        after: node.title ? ' ' : ')',
+        ...tracker.current()
+      })
+    )
+  }
+
+  subexit()
+
+  if (node.title) {
+    subexit = state.enter(`title${suffix}`)
+    value += tracker.move(' ' + quote)
+    value += tracker.move(
+      state.safe(node.title, {
+        before: value,
+        after: quote,
+        ...tracker.current()
+      })
+    )
+    value += tracker.move(quote)
+    subexit()
+  }
+
+  value += tracker.move(')')
+
+  exit()
+  return value
+}
+
+/**
+ * Peek at this node.
+ *
+ * @param {Link} node
+ *   Node to peek at.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function linkPeek(node, _, state) {
+  return formatLinkAsAutolink(node, state) ? '<' : '['
+}

package/vendor/mdast-util-to-markdown/lib/handle/list-item.js

@@ -0,0 +1,73 @@
+/**
+ * @import {Info, Map, State} from 'mdast-util-to-markdown'
+ * @import {ListItem, Parents} from 'mdast'
+ */
+
+import {checkBullet} from '../util/check-bullet.js'
+import {checkListItemIndent} from '../util/check-list-item-indent.js'
+
+/**
+ * Serialize a list item node.
+ *
+ * @param {ListItem} node
+ *   Node to serialize.
+ * @param {Parents | undefined} parent
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function listItem(node, parent, state, info) {
+  const listItemIndent = checkListItemIndent(state)
+  let bullet = state.bulletCurrent || checkBullet(state)
+
+  // Add the marker value for ordered lists.
+  if (parent && parent.type === 'list' && parent.ordered) {
+    bullet =
+      (typeof parent.start === 'number' && parent.start > -1
+        ? parent.start
+        : 1) +
+      (state.options.incrementListMarker === false
+        ? 0
+        : parent.children.indexOf(node)) +
+      bullet
+  }
+
+  let size = bullet.length + 1
+
+  if (
+    listItemIndent === 'tab' ||
+    (listItemIndent === 'mixed' &&
+      ((parent && parent.type === 'list' && parent.spread) || node.spread))
+  ) {
+    size = Math.ceil(size / 4) * 4
+  }
+
+  const tracker = state.createTracker(info)
+  tracker.move(bullet + ' '.repeat(size - bullet.length))
+  tracker.shift(size)
+  const exit = state.enter('listItem')
+  const value = state.indentLines(
+    state.containerFlow(node, tracker.current()),
+    map
+  )
+  exit()
+
+  return value
+
+  /**
+   * Indent lines of the list item.
+   *
+   * @type {Map}
+   */
+  function map(line, index, blank) {
+    if (index) {
+      return (blank ? '' : ' '.repeat(size)) + line
+    }
+
+    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line
+  }
+}

package/vendor/mdast-util-to-markdown/lib/handle/list.js

@@ -0,0 +1,107 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {List, Parents} from 'mdast'
+ */
+
+import {checkBullet} from '../util/check-bullet.js'
+import {checkBulletOther} from '../util/check-bullet-other.js'
+import {checkBulletOrdered} from '../util/check-bullet-ordered.js'
+import {checkRule} from '../util/check-rule.js'
+
+/**
+ * Serialize a list node.
+ *
+ * @param {List} node
+ *   Node to serialize.
+ * @param {Parents | undefined} parent
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function list(node, parent, state, info) {
+  const exit = state.enter('list')
+  const bulletCurrent = state.bulletCurrent
+  /** @type {string} */
+  let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state)
+  /** @type {string} */
+  const bulletOther = node.ordered
+    ? bullet === '.'
+      ? ')'
+      : '.'
+    : checkBulletOther(state)
+  let useDifferentMarker =
+    parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false
+
+  if (!node.ordered) {
+    const firstListItem = node.children ? node.children[0] : undefined
+
+    // If there’s an empty first list item directly in two list items,
+    // we have to use a different bullet:
+    //
+    // ```markdown
+    // * - *
+    // ```
+    //
+    // …because otherwise it would become one big thematic break.
+    if (
+      // Bullet could be used as a thematic break marker:
+      (bullet === '*' || bullet === '-') &&
+      // Empty first list item:
+      firstListItem &&
+      (!firstListItem.children || !firstListItem.children[0]) &&
+      // Directly in two other list items:
+      state.stack[state.stack.length - 1] === 'list' &&
+      state.stack[state.stack.length - 2] === 'listItem' &&
+      state.stack[state.stack.length - 3] === 'list' &&
+      state.stack[state.stack.length - 4] === 'listItem' &&
+      // That are each the first child.
+      state.indexStack[state.indexStack.length - 1] === 0 &&
+      state.indexStack[state.indexStack.length - 2] === 0 &&
+      state.indexStack[state.indexStack.length - 3] === 0
+    ) {
+      useDifferentMarker = true
+    }
+
+    // If there’s a thematic break at the start of the first list item,
+    // we have to use a different bullet:
+    //
+    // ```markdown
+    // * ---
+    // ```
+    //
+    // …because otherwise it would become one big thematic break.
+    if (checkRule(state) === bullet && firstListItem) {
+      let index = -1
+
+      while (++index < node.children.length) {
+        const item = node.children[index]
+
+        if (
+          item &&
+          item.type === 'listItem' &&
+          item.children &&
+          item.children[0] &&
+          item.children[0].type === 'thematicBreak'
+        ) {
+          useDifferentMarker = true
+          break
+        }
+      }
+    }
+  }
+
+  if (useDifferentMarker) {
+    bullet = bulletOther
+  }
+
+  state.bulletCurrent = bullet
+  const value = state.containerFlow(node, info)
+  state.bulletLastUsed = bullet
+  state.bulletCurrent = bulletCurrent
+  exit()
+  return value
+}

package/vendor/mdast-util-to-markdown/lib/handle/paragraph.js

@@ -0,0 +1,27 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Paragraph, Parents} from 'mdast'
+ */
+
+/**
+ * Serialize a paragraph node.
+ *
+ * @param {Paragraph} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function paragraph(node, _, state, info) {
+  const exit = state.enter('paragraph')
+  const subexit = state.enter('phrasing')
+  const value = state.containerPhrasing(node, info)
+  subexit()
+  exit()
+  return value
+}

package/vendor/mdast-util-to-markdown/lib/handle/root.js

@@ -0,0 +1,34 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Root} from 'mdast'
+ */
+
+import {phrasing} from 'mdast-util-phrasing'
+
+/**
+ * Serialize a root node.
+ *
+ * @param {Root} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function root(node, _, state, info) {
+  // Note: `html` nodes are ambiguous.
+  const hasPhrasing = node.children.some(function (d) {
+    return phrasing(d)
+  })
+
+  if (!hasPhrasing) return state.containerFlow(node, info)
+
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing(node, info)
+  exit()
+  return value
+}

package/vendor/mdast-util-to-markdown/lib/handle/strong.js

@@ -0,0 +1,67 @@
+/**
+ * @import {AttentionInfo, Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Strong} from 'mdast'
+ */
+
+import {checkStrong} from '../util/check-strong.js'
+
+strong.attention = attention
+strong.peek = peek
+
+/**
+ * Serialize a strong node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
+ * @param {Strong} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function strong(node, _, state, info) {
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing({type: 'root', children: [node]}, info)
+  exit()
+  return value
+}
+
+/**
+ * Serialize a strong node as attention.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+function attention(_, state) {
+  const marker = checkStrong(state)
+  return {
+    construct: 'strong',
+    markers: marker === '*' ? ['*', '_'] : ['_', '*'],
+    sizes: [2]
+  }
+}
+
+/**
+ * Peek at this node.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function peek(_, _1, state) {
+  return state.options.strong || '*'
+}

package/vendor/mdast-util-to-markdown/lib/handle/text.js

@@ -0,0 +1,30 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Text} from 'mdast'
+ */
+
+/**
+ * Serialize a text node.
+ *
+ * @param {Text} node
+ *   Node to serialize.
+ * @param {Parents | undefined} parent
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function text(node, parent, state, info) {
+  /* c8 ignore next -- parent always passed */
+  const siblings = parent ? parent.children : []
+  const index = siblings.indexOf(node)
+
+  return state.safe(node.value, {
+    ...info,
+    afterNode: siblings[index + 1],
+    beforeNode: siblings[index - 1]
+  })
+}

package/vendor/mdast-util-to-markdown/lib/handle/thematic-break.js

@@ -0,0 +1,27 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Parents, ThematicBreak} from 'mdast'
+ */
+
+import {checkRuleRepetition} from '../util/check-rule-repetition.js'
+import {checkRule} from '../util/check-rule.js'
+
+/**
+ * Serialize a thematic break node.
+ *
+ * @param {ThematicBreak} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function thematicBreak(_, _1, state) {
+  const value = (
+    checkRule(state) + (state.options.ruleSpaces ? ' ' : '')
+  ).repeat(checkRuleRepetition(state))
+
+  return state.options.ruleSpaces ? value.slice(0, -1) : value
+}