@tinta-lang/syntax 0.0.0-stage → 0.1.16

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

@@ -0,0 +1,213 @@
+/**
+ * @import {Info, Join, Options, SafeConfig, State} from 'mdast-util-to-markdown'
+ * @import {Nodes} from 'mdast'
+ * @import {Enter, FlowParents, PhrasingParents, TrackFields} from './types.js'
+ */
+
+import {phrasing} from 'mdast-util-phrasing'
+import {zwitch} from 'zwitch'
+import {configure} from './configure.js'
+import {handle as handlers} from './handle/index.js'
+import {join} from './join.js'
+import {unsafe} from './unsafe.js'
+import {association} from './util/association.js'
+import {compilePattern} from './util/compile-pattern.js'
+import {containerPhrasing} from './util/container-phrasing.js'
+import {containerFlow} from './util/container-flow.js'
+import {indentLines} from './util/indent-lines.js'
+import {safe} from './util/safe.js'
+import {track} from './util/track.js'
+
+/**
+ * Turn an mdast syntax tree into markdown.
+ *
+ * @param {Nodes} tree
+ *   Tree to serialize.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {string}
+ *   Serialized markdown representing `tree`.
+ */
+export function toMarkdown(tree, options) {
+  const settings = options || {}
+  /** @type {State} */
+  const state = {
+    associationId: association,
+    bulletCurrent: undefined,
+    bulletLastUsed: undefined,
+    containerPhrasing: containerPhrasingBound,
+    containerFlow: containerFlowBound,
+    createTracker: track,
+    compilePattern,
+    enter,
+    // @ts-expect-error: GFM / frontmatter are typed in `mdast` but not defined
+    // here.
+    handlers: {...handlers},
+    // @ts-expect-error: add `handle` in a second.
+    handle: undefined,
+    indentLines,
+    indexStack: [],
+    join: [...join],
+    options: {},
+    safe: safeBound,
+    stack: [],
+    unsafe: [...unsafe]
+  }
+
+  configure(state, settings)
+
+  if (state.options.tightDefinitions) {
+    state.join.push(joinDefinition)
+  }
+
+  state.handle = zwitch('type', {
+    invalid,
+    unknown,
+    handlers: state.handlers
+  })
+
+  let result = state.handle(
+    phrasing(tree) ? {type: 'root', children: [tree]} : tree,
+    undefined,
+    state,
+    {before: '\n', after: '\n', now: {line: 1, column: 1}, lineShift: 0}
+  )
+
+  if (
+    result &&
+    result.charCodeAt(result.length - 1) !== 10 &&
+    result.charCodeAt(result.length - 1) !== 13
+  ) {
+    result += '\n'
+  }
+
+  return result
+
+  /**
+   * Enter a construct.
+   *
+   * @type {Enter}
+   */
+  function enter(name) {
+    state.stack.push(name)
+    return exit
+
+    /**
+     * Exit a construct.
+     *
+     * @returns {undefined}
+     *   Nothing.
+     */
+    function exit() {
+      state.stack.pop()
+    }
+  }
+}
+
+/**
+ * Handle an invalid value that cannot be processed.
+ *
+ * @param {unknown} value
+ *   Value.
+ * @returns {never}
+ *   Never.
+ * @throws {Error}
+ *   Always.
+ */
+function invalid(value) {
+  throw new Error('Cannot handle value `' + value + '`, expected node')
+}
+
+/**
+ * Handle an unknown node.
+ *
+ * @param {unknown} value
+ *   Value.
+ * @returns {never}
+ *   Never.
+ * @throws {Error}
+ *   Always.
+ */
+function unknown(value) {
+  // Always a node.
+  const node = /** @type {Nodes} */ (value)
+  throw new Error('Cannot handle unknown node `' + node.type + '`')
+}
+
+/**
+ * Join function for `tightDefinitions` option.
+ *
+ * @type {Join}
+ */
+function joinDefinition(left, right) {
+  // No blank line between adjacent definitions.
+  if (left.type === 'definition' && left.type === right.type) {
+    return 0
+  }
+}
+
+/**
+ * Serialize the children of a parent that contains phrasing children.
+ *
+ * These children will be joined flush together.
+ *
+ * @this {State}
+ *   Info passed around about the current state.
+ * @param {PhrasingParents} parent
+ *   Parent of flow nodes.
+ * @param {Info} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined together.
+ */
+function containerPhrasingBound(parent, info) {
+  return containerPhrasing(parent, this, info)
+}
+
+/**
+ * Serialize the children of a parent that contains flow children.
+ *
+ * These children will typically be joined by blank lines.
+ * What they are joined by exactly is defined by `Join` functions.
+ *
+ * @this {State}
+ *   Info passed around about the current state.
+ * @param {FlowParents} parent
+ *   Parent of flow nodes.
+ * @param {TrackFields} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined by (blank) lines.
+ */
+function containerFlowBound(parent, info) {
+  return containerFlow(parent, this, info)
+}
+
+/**
+ * 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.
+ *
+ * @this {State}
+ *   Info passed around about the current state.
+ * @param {string | null | undefined} value
+ *   Raw value to make safe.
+ * @param {SafeConfig} config
+ *   Configuration.
+ * @returns {string}
+ *   Serialized markdown safe for embedding.
+ */
+function safeBound(value, config) {
+  return safe(this, value, config)
+}

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

@@ -0,0 +1,56 @@
+/**
+ * @import {Join} from 'mdast-util-to-markdown'
+ */
+
+import {formatCodeAsIndented} from './util/format-code-as-indented.js'
+import {formatHeadingAsSetext} from './util/format-heading-as-setext.js'
+import {htmlKind} from './util/html-kind.js'
+
+/** @type {Array<Join>} */
+export const join = [joinDefaults]
+
+/**
+ * Default join function.
+ *
+ * @type {Join}
+ */
+function joinDefaults(left, right, parent, state) {
+  // Indented code after list or another indented code.
+  if (
+    right.type === 'code' &&
+    formatCodeAsIndented(right, state) &&
+    (left.type === 'list' ||
+      (left.type === right.type && formatCodeAsIndented(left, state)))
+  ) {
+    return false
+  }
+
+  // Join children of a list or an item.
+  // In which case, `parent` has a `spread` field.
+  if ('spread' in parent && typeof parent.spread === 'boolean') {
+    if (
+      left.type === 'paragraph' &&
+      // Two paragraphs.
+      (left.type === right.type ||
+        right.type === 'definition' ||
+        // Paragraph followed by a setext heading.
+        (right.type === 'heading' && formatHeadingAsSetext(right, state)))
+    ) {
+      return
+    }
+
+    // HTML that only ends at a blank line followed by something.
+    if (left.type === 'html') {
+      const kind = htmlKind(left.value)
+      if (kind === undefined || kind === 6 || kind === 7) return 1
+    }
+
+    // HTML that cannot interrupt a paragraph (kind 7) after one.
+    if (left.type === 'paragraph' && right.type === 'html') {
+      const kind = htmlKind(right.value)
+      if (kind === undefined || kind === 7) return 1
+    }
+
+    return parent.spread ? 1 : 0
+  }
+}

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

@@ -0,0 +1,160 @@
+/**
+ * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * List of constructs that occur in phrasing (paragraphs, headings), but cannot
+ * contain things like attention (emphasis, strong), images, or links.
+ * So they sort of cancel each other out.
+ * Note: could use a better name.
+ *
+ * @type {Array<ConstructName>}
+ */
+const fullPhrasingSpans = [
+  'autolink',
+  'destinationLiteral',
+  'destinationRaw',
+  'reference',
+  'titleQuote',
+  'titleApostrophe'
+]
+
+/** @type {Array<Unsafe>} */
+export const unsafe = [
+  {character: '\t', after: '[\\r\\n]', inConstruct: 'phrasing'},
+  {character: '\t', before: '[\\r\\n]', inConstruct: 'phrasing'},
+  {
+    character: '\t',
+    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']
+  },
+  {
+    character: '\r',
+    inConstruct: [
+      'codeFencedLangGraveAccent',
+      'codeFencedLangTilde',
+      'codeFencedMetaGraveAccent',
+      'codeFencedMetaTilde',
+      'destinationLiteral',
+      'headingAtx'
+    ]
+  },
+  {
+    character: '\n',
+    inConstruct: [
+      'codeFencedLangGraveAccent',
+      'codeFencedLangTilde',
+      'codeFencedMetaGraveAccent',
+      'codeFencedMetaTilde',
+      'destinationLiteral',
+      'headingAtx'
+    ]
+  },
+  {character: '\r', before: '[\\r\\n]', inConstruct: 'phrasing'},
+  {character: '\r', after: '\\r', inConstruct: 'phrasing'},
+  {character: '\n', before: '\\n', inConstruct: 'phrasing'},
+  {character: '\n', after: '[\\r\\n]', inConstruct: 'phrasing'},
+  {character: ' ', after: '[\\r\\n]', inConstruct: 'phrasing'},
+  {character: ' ', before: '[\\r\\n]', inConstruct: 'phrasing'},
+  {
+    character: ' ',
+    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedLangTilde']
+  },
+  // An exclamation mark can start an image, if it is followed by a link or
+  // a link reference.
+  {
+    character: '!',
+    after: '\\[',
+    inConstruct: 'phrasing',
+    notInConstruct: fullPhrasingSpans
+  },
+  // A quote can break out of a title.
+  {character: '"', inConstruct: 'titleQuote'},
+  // A number sign could start an ATX heading if it starts a line.
+  {atBreak: true, character: '#'},
+  {character: '#', inConstruct: 'headingAtx', after: '(?:[\r\n]|$)'},
+  // Dollar sign and percentage are not used in markdown.
+  // An ampersand could start a character reference.
+  {character: '&', after: '[#A-Za-z]', inConstruct: 'phrasing'},
+  // An apostrophe can break out of a title.
+  {character: "'", inConstruct: 'titleApostrophe'},
+  // A left paren could break out of a destination raw.
+  {character: '(', inConstruct: 'destinationRaw'},
+  // A left paren followed by `]` could make something into a link or image.
+  {
+    before: '\\]',
+    character: '(',
+    inConstruct: 'phrasing',
+    notInConstruct: fullPhrasingSpans
+  },
+  // A right paren could start a list item or break out of a destination
+  // raw.
+  {atBreak: true, before: '\\d+', character: ')'},
+  {character: ')', inConstruct: 'destinationRaw'},
+  // An asterisk can start thematic breaks, list items, emphasis, strong.
+  {atBreak: true, character: '*', after: '(?:[ \t\r\n*])'},
+  {character: '*', inConstruct: 'phrasing', notInConstruct: fullPhrasingSpans},
+  // A plus sign could start a list item.
+  {atBreak: true, character: '+', after: '(?:[ \t\r\n])'},
+  // A dash can start thematic breaks, list items, and setext heading
+  // underlines.
+  {atBreak: true, character: '-', after: '(?:[ \t\r\n-])'},
+  // A dot could start a list item.
+  {atBreak: true, before: '\\d+', character: '.', after: '(?:[ \t\r\n]|$)'},
+  // Slash, colon, and semicolon are not used in markdown for constructs.
+  // A less than can start html (flow or text) or an autolink.
+  // HTML could start with an exclamation mark (declaration, cdata, comment),
+  // slash (closing tag), question mark (instruction), or a letter (tag).
+  // An autolink also starts with a letter.
+  // Finally, it could break out of a destination literal.
+  {atBreak: true, character: '<', after: '[!/?A-Za-z]'},
+  {
+    character: '<',
+    after: '[!/?A-Za-z]',
+    inConstruct: 'phrasing',
+    notInConstruct: fullPhrasingSpans
+  },
+  {character: '<', inConstruct: 'destinationLiteral'},
+  // An equals to can start setext heading underlines.
+  {atBreak: true, character: '='},
+  // A greater than can start block quotes and it can break out of a
+  // destination literal.
+  {atBreak: true, character: '>'},
+  {character: '>', inConstruct: 'destinationLiteral'},
+  // Question mark and at sign are not used in markdown for constructs.
+  // A left bracket can start definitions, references, labels,
+  {atBreak: true, character: '['},
+  {character: '[', inConstruct: 'phrasing', notInConstruct: fullPhrasingSpans},
+  {character: '[', inConstruct: ['label', 'reference']},
+  // A backslash can start an escape (when followed by punctuation) or a
+  // hard break (when followed by an eol).
+  // Note: typical escapes are handled in `safe`!
+  {character: '\\', after: '[\\r\\n]', inConstruct: 'phrasing'},
+  // A right bracket can exit labels.
+  {character: ']', inConstruct: ['label', 'reference']},
+  // Caret is not used in markdown for constructs.
+  // An underscore can start emphasis, strong, or a thematic break.
+  {atBreak: true, character: '_'},
+  {character: '_', inConstruct: 'phrasing', notInConstruct: fullPhrasingSpans},
+  // A grave accent can start code (fenced or text), or it can break out of
+  // a grave accent code fence.
+  {atBreak: true, character: '`'},
+  {
+    character: '`',
+    inConstruct: ['codeFencedLangGraveAccent', 'codeFencedMetaGraveAccent']
+  },
+  {character: '`', inConstruct: 'phrasing', notInConstruct: fullPhrasingSpans},
+  // Left brace, vertical bar, right brace are not used in markdown for
+  // constructs.
+  // A tilde can start code (fenced).
+  {atBreak: true, character: '~'},
+  {character: '<', inConstruct: 'autolink'},
+  {character: '>', inConstruct: 'autolink'},
+  {character: '\u007F', inConstruct: 'autolink'}
+]
+
+// Also the low ASCII control characters including space.
+let code = -1
+
+while (++code < 33) {
+  unsafe.push({character: String.fromCharCode(code), inConstruct: 'autolink'})
+}

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

@@ -0,0 +1,33 @@
+/**
+ * @import {AssociationId} from '../types.js'
+ */
+
+import {decodeString} from 'micromark-util-decode-string'
+
+/**
+ * Get an identifier from an association to match it to others.
+ *
+ * Associations are nodes that match to something else through an ID:
+ * <https://github.com/syntax-tree/mdast#association>.
+ *
+ * The `label` of an association is the string value: character escapes and
+ * references work, and casing is intact.
+ * The `identifier` is used to match one association to another:
+ * controversially, character escapes and references don’t work in this
+ * matching: `&copy;` does not match `©`, and `\+` does not match `+`.
+ *
+ * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\nb`
+ * matches `a b`.
+ * So, we do prefer the label when figuring out how we’re going to serialize:
+ * it has whitespace, casing, and we can ignore most useless character
+ * escapes and all character references.
+ *
+ * @type {AssociationId}
+ */
+export function association(node) {
+  if (node.label || !node.identifier) {
+    return node.label || ''
+  }
+
+  return decodeString(node.identifier)
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Get the first character of a value.
+ *
+ * Is aware of astral characters (such as emoji).
+ *
+ * @param {string} value
+ *   Value.
+ * @returns {string}
+ *   First character; empty if `value` is empty.
+ */
+export function firstCharacter(value) {
+  const code = value.codePointAt(0)
+  return code === undefined ? '' : String.fromCodePoint(code)
+}
+
+/**
+ * Get the last character of a value.
+ *
+ * Is aware of astral characters (such as emoji).
+ *
+ * @param {string} value
+ *   Value.
+ * @returns {string}
+ *   Last character; empty if `value` is empty.
+ */
+export function lastCharacter(value) {
+  // Only a surrogate pair gives a code point above the BMP.
+  const code = value.codePointAt(value.length - 2)
+  return code !== undefined && code > 0xff_ff
+    ? value.slice(-2)
+    : value.slice(-1)
+}

package/vendor/mdast-util-to-markdown/lib/util/check-bullet-ordered.js

@@ -0,0 +1,25 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Checks the preferred ordered list bullet option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['bulletOrdered'], null | undefined>}
+ *   Preferred ordered list bullet.
+ */
+export function checkBulletOrdered(state) {
+  const marker = state.options.bulletOrdered || '.'
+
+  if (marker !== '.' && marker !== ')') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        marker +
+        '` for `options.bulletOrdered`, expected `.` or `)`'
+    )
+  }
+
+  return marker
+}

package/vendor/mdast-util-to-markdown/lib/util/check-bullet-other.js

@@ -0,0 +1,42 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+import {checkBullet} from './check-bullet.js'
+
+/**
+ * Checks the preferred alternate list bullet option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['bullet'], null | undefined>}
+ *   Preferred alternate list bullet.
+ */
+export function checkBulletOther(state) {
+  const bullet = checkBullet(state)
+  const bulletOther = state.options.bulletOther
+
+  if (!bulletOther) {
+    return bullet === '*' ? '-' : '*'
+  }
+
+  if (bulletOther !== '*' && bulletOther !== '+' && bulletOther !== '-') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        bulletOther +
+        '` for `options.bulletOther`, expected `*`, `+`, or `-`'
+    )
+  }
+
+  if (bulletOther === bullet) {
+    throw new Error(
+      'Expected `bullet` (`' +
+        bullet +
+        '`) and `bulletOther` (`' +
+        bulletOther +
+        '`) to be different'
+    )
+  }
+
+  return bulletOther
+}

package/vendor/mdast-util-to-markdown/lib/util/check-bullet.js

@@ -0,0 +1,25 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Checks the preferred list bullet option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['bullet'], null | undefined>}
+ *   Preferred list bullet.
+ */
+export function checkBullet(state) {
+  const marker = state.options.bullet || '*'
+
+  if (marker !== '*' && marker !== '+' && marker !== '-') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        marker +
+        '` for `options.bullet`, expected `*`, `+`, or `-`'
+    )
+  }
+
+  return marker
+}

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

@@ -0,0 +1,25 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Checks the preferred emphasis option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['emphasis'], null | undefined>}
+ *   Preferred emphasis marker.
+ */
+export function checkEmphasis(state) {
+  const marker = state.options.emphasis || '*'
+
+  if (marker !== '*' && marker !== '_') {
+    throw new Error(
+      'Cannot serialize emphasis with `' +
+        marker +
+        '` for `options.emphasis`, expected `*`, or `_`'
+    )
+  }
+
+  return marker
+}

package/vendor/mdast-util-to-markdown/lib/util/check-fence.js

@@ -0,0 +1,25 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Checks the preferred fence option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['fence'], null | undefined>}
+ *   Preferred fence marker.
+ */
+export function checkFence(state) {
+  const marker = state.options.fence || '`'
+
+  if (marker !== '`' && marker !== '~') {
+    throw new Error(
+      'Cannot serialize code with `' +
+        marker +
+        '` for `options.fence`, expected `` ` `` or `~`'
+    )
+  }
+
+  return marker
+}

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

@@ -0,0 +1,25 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Checks the preferred list item indent option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['listItemIndent'], null | undefined>}
+ *   Preferred list item indent.
+ */
+export function checkListItemIndent(state) {
+  const style = state.options.listItemIndent || 'one'
+
+  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {
+    throw new Error(
+      'Cannot serialize items with `' +
+        style +
+        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'
+    )
+  }
+
+  return style
+}

package/vendor/mdast-util-to-markdown/lib/util/check-quote.js

@@ -0,0 +1,25 @@
+/**
+ * @import {Options, State} from 'mdast-util-to-markdown'
+ */
+
+/**
+ * Checks the preferred quote option.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Exclude<Options['quote'], null | undefined>}
+ *   Preferred quote.
+ */
+export function checkQuote(state) {
+  const marker = state.options.quote || '"'
+
+  if (marker !== '"' && marker !== "'") {
+    throw new Error(
+      'Cannot serialize title with `' +
+        marker +
+        '` for `options.quote`, expected `"`, or `\'`'
+    )
+  }
+
+  return marker
+}