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

package/vendor/micromark-extension-gfm-strikethrough/lib/html.js

@@ -0,0 +1,26 @@
+/**
+ * @import {HtmlExtension} from 'micromark-util-types'
+ */
+
+/**
+ * Create an HTML extension for `micromark` to support GFM strikethrough when
+ * serializing to HTML.
+ *
+ * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions`, to
+ *   support GFM strikethrough when serializing to HTML.
+ */
+export function gfmStrikethroughHtml() {
+  return {
+    enter: {
+      strikethrough() {
+        this.tag('<del>');
+      }
+    },
+    exit: {
+      strikethrough() {
+        this.tag('</del>');
+      }
+    }
+  };
+}

package/vendor/micromark-extension-gfm-strikethrough/lib/syntax.js

@@ -0,0 +1,142 @@
+/**
+ * @import {Options} from 'micromark-extension-gfm-strikethrough'
+ * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+ */
+
+import { splice } from 'micromark-util-chunked';
+import { classifyCharacter } from 'micromark-util-classify-character';
+import { resolveAll } from 'micromark-util-resolve-all';
+/**
+ * Create an extension for `micromark` to enable GFM strikethrough syntax.
+ *
+ * @param {Options | null | undefined} [options={}]
+ *   Configuration.
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable GFM strikethrough syntax.
+ */
+export function gfmStrikethrough(options) {
+  const options_ = options || {};
+  let single = options_.singleTilde;
+  const tokenizer = {
+    name: 'strikethrough',
+    tokenize: tokenizeStrikethrough,
+    resolveAll: resolveAllStrikethrough
+  };
+  if (single === null || single === undefined) {
+    single = true;
+  }
+  return {
+    text: {
+      [126]: tokenizer
+    },
+    insideSpan: {
+      null: [tokenizer]
+    },
+    attentionMarkers: {
+      null: [126]
+    }
+  };
+
+  /**
+   * Take events and resolve strikethrough.
+   *
+   * @type {Resolver}
+   */
+  function resolveAllStrikethrough(events, context) {
+    let index = -1;
+
+    // Walk through all events.
+    while (++index < events.length) {
+      // Find a token that can close.
+      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {
+        let open = index;
+
+        // Now walk back to find an opener.
+        while (open--) {
+          // Find a token that can open the closer.
+          if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&
+          // If the sizes are the same:
+          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {
+            events[index][1].type = 'strikethroughSequence';
+            events[open][1].type = 'strikethroughSequence';
+
+            /** @type {Token} */
+            const strikethrough = {
+              type: 'strikethrough',
+              start: Object.assign({}, events[open][1].start),
+              end: Object.assign({}, events[index][1].end)
+            };
+
+            /** @type {Token} */
+            const text = {
+              type: 'strikethroughText',
+              start: Object.assign({}, events[open][1].end),
+              end: Object.assign({}, events[index][1].start)
+            };
+
+            // Opening.
+            /** @type {Array<Event>} */
+            const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];
+            const insideSpan = context.parser.constructs.insideSpan.null;
+            if (insideSpan) {
+              // Between.
+              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));
+            }
+
+            // Closing.
+            splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);
+            splice(events, open - 1, index - open + 3, nextEvents);
+            index = open + nextEvents.length - 2;
+            break;
+          }
+        }
+      }
+    }
+    index = -1;
+    while (++index < events.length) {
+      if (events[index][1].type === 'strikethroughSequenceTemporary') {
+        events[index][1].type = "data";
+      }
+    }
+    return events;
+  }
+
+  /**
+   * @this {TokenizeContext}
+   * @type {Tokenizer}
+   */
+  function tokenizeStrikethrough(effects, ok, nok) {
+    const previous = this.previous;
+    const events = this.events;
+    let size = 0;
+    return start;
+
+    /** @type {State} */
+    function start(code) {
+      if (previous === 126 && events[events.length - 1][1].type !== "characterEscape") {
+        return nok(code);
+      }
+      effects.enter('strikethroughSequenceTemporary');
+      return more(code);
+    }
+
+    /** @type {State} */
+    function more(code) {
+      const before = classifyCharacter(previous);
+      if (code === 126) {
+        // If this is the third marker, exit.
+        if (size > 1) return nok(code);
+        effects.consume(code);
+        size++;
+        return more;
+      }
+      if (size < 2 && !single) return nok(code);
+      const token = effects.exit('strikethroughSequenceTemporary');
+      const after = classifyCharacter(code);
+      token._open = !after || after === 2 && Boolean(before);
+      token._close = !before || before === 2 && Boolean(after);
+      return ok(code);
+    }
+  }
+}

package/vendor/micromark-extension-gfm-strikethrough/license

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2020 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.

package/vendor/micromark-extension-gfm-strikethrough/package.json

@@ -0,0 +1,129 @@
+{
+  "name": "micromark-extension-gfm-strikethrough",
+  "version": "2.1.0",
+  "description": "micromark extension to support GFM strikethrough",
+  "license": "MIT",
+  "keywords": [
+    "micromark",
+    "micromark-extension",
+    "strikethrough",
+    "strike",
+    "through",
+    "del",
+    "delete",
+    "deletion",
+    "gfm",
+    "markdown",
+    "unified"
+  ],
+  "repository": "micromark/micromark-extension-gfm-strikethrough",
+  "bugs": "https://github.com/micromark/micromark-extension-gfm-strikethrough/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/unified"
+  },
+  "author": "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)",
+  "contributors": [
+    "Titus Wormer <tituswormer@gmail.com> (https://wooorm.com)"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "files": [
+    "dev/",
+    "lib/",
+    "index.d.ts",
+    "index.js"
+  ],
+  "exports": {
+    "development": "./dev/index.js",
+    "default": "./index.js"
+  },
+  "dependencies": {
+    "devlop": "^1.0.0",
+    "micromark-util-chunked": "^2.0.0",
+    "micromark-util-classify-character": "^2.0.0",
+    "micromark-util-resolve-all": "^2.0.0",
+    "micromark-util-symbol": "^2.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "c8": "^10.0.0",
+    "create-gfm-fixtures": "^1.0.0",
+    "micromark": "^4.0.0",
+    "micromark-build": "^2.0.0",
+    "prettier": "^3.0.0",
+    "remark-cli": "^12.0.0",
+    "remark-preset-wooorm": "^10.0.0",
+    "tape": "^5.0.0",
+    "type-coverage": "^2.0.0",
+    "typescript": "^5.0.0",
+    "xo": "^0.58.0"
+  },
+  "scripts": {
+    "prepack": "npm run build && npm run format",
+    "build": "tsc --build --clean && tsc --build && type-coverage && micromark-build",
+    "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix",
+    "test-api-prod": "node --conditions production test/index.js",
+    "test-api-dev": "node --conditions development test/index.js",
+    "test-api": "npm run test-api-dev && npm run test-api-prod",
+    "test-coverage": "c8 --100 --reporter lcov npm run test-api",
+    "test": "npm run build && npm run format && npm run test-coverage"
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "none",
+    "useTabs": false
+  },
+  "remarkConfig": {
+    "plugins": [
+      "remark-preset-wooorm"
+    ]
+  },
+  "typeCoverage": {
+    "atLeast": 100,
+    "detail": true,
+    "ignoreCatch": true,
+    "strict": true
+  },
+  "xo": {
+    "prettier": true,
+    "rules": {
+      "logical-assignment-operators": "off",
+      "max-depth": "off",
+      "unicorn/prefer-at": "off"
+    },
+    "overrides": [
+      {
+        "files": "**/*.ts",
+        "rules": {
+          "@typescript-eslint/array-type": [
+            "error",
+            {
+              "default": "generic"
+            }
+          ],
+          "@typescript-eslint/ban-types": [
+            "error",
+            {
+              "extendDefaults": true
+            }
+          ],
+          "@typescript-eslint/consistent-type-definitions": [
+            "error",
+            "interface"
+          ]
+        }
+      },
+      {
+        "files": "test/**/*.js",
+        "rules": {
+          "no-await-in-loop": 0
+        }
+      }
+    ]
+  }
+}

package/vendor/micromark-extension-gfm-table/index.js

@@ -0,0 +1,2 @@
+export { gfmTableHtml } from './lib/html.js';
+export { gfmTable } from './lib/syntax.js';

package/vendor/micromark-extension-gfm-table/lib/edit-map.js

@@ -0,0 +1,222 @@
+/**
+ * @import {Event} from 'micromark-util-types'
+ */
+
+// Port of `edit_map.rs` from `markdown-rs`.
+// This should move to `markdown-js` later.
+
+// Deal with several changes in events, batching them together.
+//
+// Preferably, changes should be kept to a minimum.
+// Sometimes, it’s needed to change the list of events, because parsing can be
+// messy, and it helps to expose a cleaner interface of events to the compiler
+// and other users.
+// It can also help to merge many adjacent similar events.
+// And, in other cases, it’s needed to parse subcontent: pass some events
+// through another tokenizer and inject the result.
+
+/**
+ * @typedef {[number, number, Array<Event>]} Change
+ * @typedef {[number, number, number]} Jump
+ */
+
+/**
+ * Tracks a bunch of edits.
+ */
+export class EditMap {
+  /**
+   * Create a new edit map.
+   */
+  constructor() {
+    /**
+     * Record of changes.
+     *
+     * @type {Array<Change>}
+     */
+    this.map = [];
+
+    /**
+     * Changes by index, so `add` does not scan `map` (quadratic on
+     * table-heavy documents).
+     *
+     * @type {Map<number, Change>}
+     */
+    this.index = new Map();
+  }
+
+  /**
+   * Create an edit: a remove and/or add at a certain place.
+   *
+   * @param {number} index
+   *   Index at which to apply the edit.
+   * @param {number} remove
+   *   Count of items to remove at the index.
+   * @param {Array<Event>} add
+   *   Items to add at the index.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  add(index, remove, add) {
+    addImplementation(this, index, remove, add);
+  }
+
+  // To do: add this when moving to `micromark`.
+  // /**
+  //  * Create an edit: but insert `add` before existing additions.
+  //  *
+  //  * @param {number} index
+  //  * @param {number} remove
+  //  * @param {Array<Event>} add
+  //  * @returns {undefined}
+  //  */
+  // addBefore(index, remove, add) {
+  //   addImplementation(this, index, remove, add, true)
+  // }
+
+  /**
+   * Done, change the events.
+   *
+   * @param {Array<Event>} events
+   *   List of events to apply the edits to.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  consume(events) {
+    this.map.sort(function (a, b) {
+      return a[0] - b[0];
+    });
+
+    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+    if (this.map.length === 0) {
+      return;
+    }
+
+    // To do: if links are added in events, like they are in `markdown-rs`,
+    // this is needed.
+    // // Calculate jumps: where items in the current list move to.
+    // /** @type {Array<Jump>} */
+    // const jumps = []
+    // let index = 0
+    // let addAcc = 0
+    // let removeAcc = 0
+    // while (index < this.map.length) {
+    //   const [at, remove, add] = this.map[index]
+    //   removeAcc += remove
+    //   addAcc += add.length
+    //   jumps.push([at, removeAcc, addAcc])
+    //   index += 1
+    // }
+    //
+    // . shiftLinks(events, jumps)
+
+    let index = this.map.length;
+    /** @type {Array<Array<Event>>} */
+    const vecs = [];
+    while (index > 0) {
+      index -= 1;
+      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);
+
+      // Truncate rest.
+      events.length = this.map[index][0];
+    }
+    vecs.push(events.slice());
+    events.length = 0;
+    let slice = vecs.pop();
+    while (slice) {
+      for (const element of slice) {
+        events.push(element);
+      }
+      slice = vecs.pop();
+    }
+
+    // Truncate everything.
+    this.map.length = 0;
+    this.index.clear();
+  }
+}
+
+/**
+ * Create an edit.
+ *
+ * @param {EditMap} editMap
+ *   Edit map to apply to.
+ * @param {number} at
+ *   Index at which to apply the edit.
+ * @param {number} remove
+ *   Count of items to remove at the index.
+ * @param {Array<Event>} add
+ *   Items to add at the index.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function addImplementation(editMap, at, remove, add) {
+  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */
+  if (remove === 0 && add.length === 0) {
+    return;
+  }
+  const existing = editMap.index.get(at);
+  if (existing) {
+    existing[1] += remove;
+
+    // To do: before not used by tables, use when moving to micromark.
+    // if (before) {
+    //   add.push(...existing[2])
+    //   existing[2] = add
+    // } else {
+    existing[2].push(...add);
+    // }
+
+    return;
+  }
+
+  /** @type {Change} */
+  const change = [at, remove, add];
+  editMap.map.push(change);
+  editMap.index.set(at, change);
+}
+
+// /**
+//  * Shift `previous` and `next` links according to `jumps`.
+//  *
+//  * This fixes links in case there are events removed or added between them.
+//  *
+//  * @param {Array<Event>} events
+//  * @param {Array<Jump>} jumps
+//  */
+// function shiftLinks(events, jumps) {
+//   let jumpIndex = 0
+//   let index = 0
+//   let add = 0
+//   let rm = 0
+
+//   while (index < events.length) {
+//     const rmCurr = rm
+
+//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {
+//       add = jumps[jumpIndex][2]
+//       rm = jumps[jumpIndex][1]
+//       jumpIndex += 1
+//     }
+
+//     // Ignore items that will be removed.
+//     if (rm > rmCurr) {
+//       index += rm - rmCurr
+//     } else {
+//       // ?
+//       // if let Some(link) = &events[index].link {
+//       //     if let Some(next) = link.next {
+//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);
+//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {
+//       //             add = jumps[jumpIndex].2;
+//       //             rm = jumps[jumpIndex].1;
+//       //             jumpIndex += 1;
+//       //         }
+//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);
+//       //         index = next;
+//       //         continue;
+//       //     }
+//       // }
+//       index += 1
+//     }
+//   }
+// }

package/vendor/micromark-extension-gfm-table/lib/html.js

@@ -0,0 +1,135 @@
+/**
+ * @import {HtmlExtension} from 'micromark-util-types'
+ */
+
+const alignment = {
+  none: '',
+  left: ' align="left"',
+  right: ' align="right"',
+  center: ' align="center"'
+};
+
+// To do: micromark@5: use `infer` here, when all events are exposed.
+
+/**
+ * Create an HTML extension for `micromark` to support GitHub tables when
+ * serializing to HTML.
+ *
+ * @returns {HtmlExtension}
+ *   Extension for `micromark` that can be passed in `htmlExtensions` to
+ *   support GitHub tables when serializing to HTML.
+ */
+export function gfmTableHtml() {
+  return {
+    enter: {
+      table(token) {
+        const tableAlign = token._align;
+        this.lineEndingIfNeeded();
+        this.tag('<table>');
+        this.setData('tableAlign', tableAlign);
+      },
+      tableBody() {
+        this.tag('<tbody>');
+      },
+      tableData() {
+        const tableAlign = this.getData('tableAlign');
+        const tableColumn = this.getData('tableColumn');
+        const align = alignment[tableAlign[tableColumn]];
+        if (align === undefined) {
+          // Capture results to ignore them.
+          this.buffer();
+        } else {
+          this.lineEndingIfNeeded();
+          this.tag('<td' + align + '>');
+        }
+      },
+      tableHead() {
+        this.lineEndingIfNeeded();
+        this.tag('<thead>');
+      },
+      tableHeader() {
+        const tableAlign = this.getData('tableAlign');
+        const tableColumn = this.getData('tableColumn');
+        const align = alignment[tableAlign[tableColumn]];
+        this.lineEndingIfNeeded();
+        this.tag('<th' + align + '>');
+      },
+      tableRow() {
+        this.setData('tableColumn', 0);
+        this.lineEndingIfNeeded();
+        this.tag('<tr>');
+      }
+    },
+    exit: {
+      // Overwrite the default code text data handler to unescape escaped pipes when
+      // they are in tables.
+      codeTextData(token) {
+        let value = this.sliceSerialize(token);
+        if (this.getData('tableAlign')) {
+          value = value.replace(/\\([\\|])/g, replace);
+        }
+        this.raw(this.encode(value));
+      },
+      table() {
+        this.setData('tableAlign');
+        // Note: we don’t set `slurpAllLineEndings` anymore, in delimiter rows,
+        // but we do need to reset it to match a funky newline GH generates for
+        // list items combined with tables.
+        this.setData('slurpAllLineEndings');
+        this.lineEndingIfNeeded();
+        this.tag('</table>');
+      },
+      tableBody() {
+        this.lineEndingIfNeeded();
+        this.tag('</tbody>');
+      },
+      tableData() {
+        const tableAlign = this.getData('tableAlign');
+        const tableColumn = this.getData('tableColumn');
+        if (tableColumn in tableAlign) {
+          this.tag('</td>');
+          this.setData('tableColumn', tableColumn + 1);
+        } else {
+          // Stop capturing.
+          this.resume();
+        }
+      },
+      tableHead() {
+        this.lineEndingIfNeeded();
+        this.tag('</thead>');
+      },
+      tableHeader() {
+        const tableColumn = this.getData('tableColumn');
+        this.tag('</th>');
+        this.setData('tableColumn', tableColumn + 1);
+      },
+      tableRow() {
+        const tableAlign = this.getData('tableAlign');
+        let tableColumn = this.getData('tableColumn');
+        while (tableColumn < tableAlign.length) {
+          this.lineEndingIfNeeded();
+          this.tag('<td' + alignment[tableAlign[tableColumn]] + '></td>');
+          tableColumn++;
+        }
+        this.setData('tableColumn', tableColumn);
+        this.lineEndingIfNeeded();
+        this.tag('</tr>');
+      }
+    }
+  };
+}
+
+/**
+ * Replace escaped characters in table cells.
+ *
+ * @param {string} $0
+ *   Whole.
+ * @param {string} $1
+ *   Escaped character (either a backslash or a pipe).
+ * @returns {string}
+ *   Replacement for the escaped character.
+ */
+function replace($0, $1) {
+  // Pipes work, backslashes don’t (but can’t escape pipes).
+  return $1 === '|' ? $1 : $0;
+}