@tinta-lang/syntax 0.0.0-stage → 0.1.16

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

@@ -0,0 +1,41 @@
+/**
+ * @import {Break, Parents} from 'mdast'
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ */
+
+import {patternInScope} from '../util/pattern-in-scope.js'
+
+/**
+ * Serialize a break node.
+ *
+ * @param {Break} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function hardBreak(_, _1, state, info) {
+  let index = -1
+
+  while (++index < state.unsafe.length) {
+    const pattern = state.unsafe[index]
+
+    // If we can’t put unconditional eols in this construct (setext headings,
+    // tables), use a space instead.
+    if (
+      pattern.character === '\n' &&
+      !pattern.before &&
+      !pattern.after &&
+      patternInScope(state.stack, pattern)
+    ) {
+      return /[\t ]/.test(info.before) ? '' : ' '
+    }
+  }
+
+  return '\\\n'
+}

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

@@ -0,0 +1,86 @@
+/**
+ * @import {Info, Map, State} from 'mdast-util-to-markdown'
+ * @import {Code, Parents} from 'mdast'
+ */
+
+import {longestStreak} from 'longest-streak'
+import {formatCodeAsIndented} from '../util/format-code-as-indented.js'
+import {checkFence} from '../util/check-fence.js'
+
+/**
+ * Serialize a code node.
+ *
+ * @param {Code} 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 code(node, _, state, info) {
+  const marker = checkFence(state)
+  const raw = node.value || ''
+
+  if (formatCodeAsIndented(node, state)) {
+    const exit = state.enter('codeIndented')
+    const value = state.indentLines(raw, map)
+    exit()
+    return value
+  }
+
+  const tracker = state.createTracker(info)
+  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3))
+  const exit = state.enter('codeFenced')
+  const suffix = marker === '`' ? 'GraveAccent' : 'Tilde'
+  let value = tracker.move(sequence)
+
+  if (node.lang) {
+    const subexit = state.enter(`codeFencedLang${suffix}`)
+    value += tracker.move(
+      state.safe(node.lang, {
+        before: value,
+        after: ' ',
+        encode: ['`'],
+        ...tracker.current()
+      })
+    )
+    subexit()
+  }
+
+  if (node.lang && node.meta) {
+    const subexit = state.enter(`codeFencedMeta${suffix}`)
+    value += tracker.move(' ')
+    value += tracker.move(
+      state.safe(node.meta, {
+        before: value,
+        after: '\n',
+        encode: ['`'],
+        ...tracker.current()
+      })
+    )
+    subexit()
+  }
+
+  value += tracker.move('\n')
+
+  if (raw) {
+    value += tracker.move(raw + '\n')
+  }
+
+  value += tracker.move(sequence)
+  exit()
+  return value
+}
+
+/**
+ * Indent lines w/ code indent.
+ *
+ * @type {Map}
+ */
+function map(line, _, blank) {
+  return (blank ? '' : '    ') + line
+}

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

@@ -0,0 +1,83 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Definition, Parents} from 'mdast'
+ */
+
+import {checkQuote} from '../util/check-quote.js'
+
+/**
+ * Serialize a definition node.
+ *
+ * @param {Definition} 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 definition(node, _, state, info) {
+  const quote = checkQuote(state)
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe'
+  const exit = state.enter('definition')
+  let subexit = state.enter('label')
+  const tracker = state.createTracker(info)
+  let value = tracker.move('[')
+  value += tracker.move(
+    state.safe(state.associationId(node), {
+      before: value,
+      after: ']',
+      ...tracker.current()
+    })
+  )
+  value += tracker.move(']: ')
+
+  subexit()
+
+  if (
+    // If there’s no url, or…
+    !node.url ||
+    // 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 ? ' ' : '\n',
+        ...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()
+  }
+
+  exit()
+
+  return value
+}

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

@@ -0,0 +1,67 @@
+/**
+ * @import {AttentionInfo, Info, State} from 'mdast-util-to-markdown'
+ * @import {Emphasis, Parents} from 'mdast'
+ */
+
+import {checkEmphasis} from '../util/check-emphasis.js'
+
+emphasis.attention = attention
+emphasis.peek = peek
+
+/**
+ * Serialize an emphasis node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
+ * @param {Emphasis} 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 emphasis(node, _, state, info) {
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing({type: 'root', children: [node]}, info)
+  exit()
+  return value
+}
+
+/**
+ * Serialize an emphasis node as attention.
+ *
+ * @param {Emphasis} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+function attention(_, state) {
+  const marker = checkEmphasis(state)
+  return {
+    construct: 'emphasis',
+    markers: marker === '*' ? ['*', '_'] : ['_', '*'],
+    sizes: [1]
+  }
+}
+
+/**
+ * Peek at this node.
+ *
+ * @param {Emphasis} _
+ *   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.emphasis || '*'
+}

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

@@ -0,0 +1,84 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Heading, Parents} from 'mdast'
+ */
+
+import {encodeCharacterReference} from '../util/encode-character-reference.js'
+import {formatHeadingAsSetext} from '../util/format-heading-as-setext.js'
+
+/**
+ * Serialize a heading node.
+ *
+ * @param {Heading} 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 heading(node, _, state, info) {
+  const rank = Math.max(Math.min(6, node.depth || 1), 1)
+  const tracker = state.createTracker(info)
+
+  if (formatHeadingAsSetext(node, state)) {
+    const exit = state.enter('headingSetext')
+    const subexit = state.enter('phrasing')
+    const value = state.containerPhrasing(node, {
+      ...tracker.current(),
+      before: '\n',
+      after: '\n'
+    })
+    subexit()
+    exit()
+
+    return (
+      value +
+      '\n' +
+      (rank === 1 ? '=' : '-').repeat(
+        // The whole size…
+        value.length -
+          // Minus the position of the character after the last EOL (or
+          // 0 if there is none)…
+          (Math.max(value.lastIndexOf('\r'), value.lastIndexOf('\n')) + 1)
+      )
+    )
+  }
+
+  const sequence = '#'.repeat(rank)
+  const exit = state.enter('headingAtx')
+  const subexit = state.enter('phrasing')
+
+  // Note: for proper tracking, we should reset the output positions when there
+  // is no content returned, because then the space is not output.
+  // Practically, in that case, there is no content, so it doesn’t matter that
+  // we’ve tracked one too many characters.
+  tracker.move(sequence + ' ')
+
+  let value = state.containerPhrasing(node, {
+    before: '# ',
+    after: '\n',
+    ...tracker.current()
+  })
+
+  const head = value.charCodeAt(0)
+
+  if (head === 9 /* `\t` */ || head === 32 /* ` ` */) {
+    // To do: what effect has the character reference on tracking?
+    value = encodeCharacterReference(head) + value.slice(1)
+  }
+
+  value = value ? sequence + ' ' + value : sequence
+
+  if (state.options.closeAtx) {
+    value += ' ' + sequence
+  }
+
+  subexit()
+  exit()
+
+  return value
+}

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

@@ -0,0 +1,27 @@
+/**
+ * @import {Html} from 'mdast'
+ */
+
+html.peek = htmlPeek
+
+/**
+ * Serialize an HTML node.
+ *
+ * @param {Html} node
+ *   Node to serialize.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function html(node) {
+  return node.value || ''
+}
+
+/**
+ * Peek at this node.
+ *
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function htmlPeek() {
+  return '<'
+}

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

@@ -0,0 +1,78 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {ImageReference, Parents} from 'mdast'
+ */
+
+imageReference.peek = imageReferencePeek
+
+/**
+ * Serialize an image reference node.
+ *
+ * @param {ImageReference} 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 imageReference(node, _, state, info) {
+  const type = node.referenceType
+  const exit = state.enter('imageReference')
+  let subexit = state.enter('label')
+  const tracker = state.createTracker(info)
+  let value = tracker.move('![')
+  const alt = state.safe(node.alt, {
+    before: value,
+    after: ']',
+    ...tracker.current()
+  })
+  value += tracker.move(alt + '][')
+
+  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' || !alt || alt !== 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 imageReferencePeek() {
+  return '!'
+}

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

@@ -0,0 +1,92 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Image, Parents} from 'mdast'
+ */
+
+import {checkQuote} from '../util/check-quote.js'
+
+image.peek = imagePeek
+
+/**
+ * Serialize an image node.
+ *
+ * @param {Image} 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 image(node, _, state, info) {
+  const quote = checkQuote(state)
+  const suffix = quote === '"' ? 'Quote' : 'Apostrophe'
+  const exit = state.enter('image')
+  let subexit = state.enter('label')
+  const tracker = state.createTracker(info)
+  let value = tracker.move('![')
+  value += tracker.move(
+    state.safe(node.alt, {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.
+ *
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function imagePeek() {
+  return '!'
+}

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

@@ -0,0 +1,45 @@
+import {blockquote} from './blockquote.js'
+import {hardBreak} from './break.js'
+import {code} from './code.js'
+import {definition} from './definition.js'
+import {emphasis} from './emphasis.js'
+import {heading} from './heading.js'
+import {html} from './html.js'
+import {image} from './image.js'
+import {imageReference} from './image-reference.js'
+import {inlineCode} from './inline-code.js'
+import {link} from './link.js'
+import {linkReference} from './link-reference.js'
+import {list} from './list.js'
+import {listItem} from './list-item.js'
+import {paragraph} from './paragraph.js'
+import {root} from './root.js'
+import {strong} from './strong.js'
+import {text} from './text.js'
+import {thematicBreak} from './thematic-break.js'
+
+/**
+ * Default (CommonMark) handlers.
+ */
+export const handle = {
+  blockquote,
+  break: hardBreak,
+  code,
+  definition,
+  emphasis,
+  hardBreak,
+  heading,
+  html,
+  image,
+  imageReference,
+  inlineCode,
+  link,
+  linkReference,
+  list,
+  listItem,
+  paragraph,
+  root,
+  strong,
+  text,
+  thematicBreak
+}

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

@@ -0,0 +1,86 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {InlineCode, Parents} from 'mdast'
+ */
+
+inlineCode.peek = inlineCodePeek
+
+/**
+ * Serialize an inline code node.
+ *
+ * @param {InlineCode} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function inlineCode(node, _, state) {
+  let value = node.value || ''
+  let sequence = '`'
+  let index = -1
+
+  // If there is a single grave accent on its own in the code, use a fence of
+  // two.
+  // If there are two in a row, use one.
+  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {
+    sequence += '`'
+  }
+
+  // If this is not just spaces or eols (tabs don’t count), and either the
+  // first or last character are a space, eol, or tick, then pad with spaces.
+  if (
+    /[^\n\r ]/.test(value) &&
+    ((/^[\n\r ]/.test(value) && /[\n\r ]$/.test(value)) || /^`|`$/.test(value))
+  ) {
+    value = ' ' + value + ' '
+  }
+
+  // We have a potential problem: certain characters after eols could result in
+  // blocks being seen.
+  // For example, if someone injected the string `'\n# b'`, then that would
+  // result in an ATX heading.
+  // We can’t escape characters in `inlineCode`, but because eols are
+  // transformed to spaces when going from markdown to HTML anyway, we can swap
+  // them out.
+  while (++index < state.unsafe.length) {
+    const pattern = state.unsafe[index]
+    const expression = state.compilePattern(pattern)
+
+    // Only look for `atBreak`s.
+    // Btw: note that `atBreak` patterns will always start the regex at LF or
+    // CR.
+    if (!pattern.atBreak) continue
+
+    /** @type {RegExpExecArray | null} */
+    let match
+
+    while ((match = expression.exec(value))) {
+      let position = match.index
+
+      // Support CRLF (patterns only look for one of the characters).
+      if (
+        value.charCodeAt(position) === 10 /* `\n` */ &&
+        value.charCodeAt(position - 1) === 13 /* `\r` */
+      ) {
+        position--
+      }
+
+      value = value.slice(0, position) + ' ' + value.slice(match.index + 1)
+    }
+  }
+
+  return sequence + value + sequence
+}
+
+/**
+ * Peek at this node.
+ *
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function inlineCodePeek() {
+  return '`'
+}