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

package/vendor/micromark/lib/initialize/text.js

@@ -0,0 +1,216 @@
+/**
+ * @import {
+ *   Code,
+ *   InitialConstruct,
+ *   Initializer,
+ *   Resolver,
+ *   State,
+ *   TokenizeContext
+ * } from 'micromark-util-types'
+ */
+
+import { EditMap } from 'micromark-util-edit-map';
+export const resolver = {
+  resolveAll: createResolver()
+};
+export const string = initializeFactory('string');
+export const text = initializeFactory('text');
+
+/**
+ * @param {'string' | 'text'} field
+ *   Field.
+ * @returns {InitialConstruct}
+ *   Construct.
+ */
+function initializeFactory(field) {
+  return {
+    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),
+    tokenize: initializeText
+  };
+
+  /**
+   * @this {TokenizeContext}
+   *   Context.
+   * @type {Initializer}
+   */
+  function initializeText(effects) {
+    const self = this;
+    const constructs = this.parser.constructs[field];
+    const text = effects.attempt(constructs, start, notText);
+    return start;
+
+    /** @type {State} */
+    function start(code) {
+      return atBreak(code) ? text(code) : notText(code);
+    }
+
+    /** @type {State} */
+    function notText(code) {
+      if (code === null) {
+        effects.consume(code);
+        return;
+      }
+      effects.enter("data");
+      effects.consume(code);
+      return data;
+    }
+
+    /** @type {State} */
+    function data(code) {
+      if (atBreak(code)) {
+        effects.exit("data");
+        return text(code);
+      }
+
+      // Data.
+      effects.consume(code);
+      return data;
+    }
+
+    /**
+     * @param {Code} code
+     *   Code.
+     * @returns {boolean}
+     *   Whether the code is a break.
+     */
+    function atBreak(code) {
+      if (code === null) {
+        return true;
+      }
+      const list = constructs[code];
+      let index = -1;
+      if (list) {
+        // Always populated by defaults.
+
+        while (++index < list.length) {
+          const item = list[index];
+          if (!item.previous || item.previous.call(self, self.previous)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+  }
+}
+
+/**
+ * @param {Resolver | undefined} [extraResolver]
+ *   Resolver.
+ * @returns {Resolver}
+ *   Resolver.
+ */
+function createResolver(extraResolver) {
+  return resolveAllText;
+
+  /** @type {Resolver} */
+  function resolveAllText(events, context) {
+    let index = -1;
+    /** @type {number | undefined} */
+    let enter;
+
+    // A rather boring computation (to merge adjacent `data` events) which
+    // improves mm performance by 29%.
+    while (++index <= events.length) {
+      if (enter === undefined) {
+        if (events[index] && events[index][1].type === "data") {
+          enter = index;
+          index++;
+        }
+      } else if (!events[index] || events[index][1].type !== "data") {
+        // Don’t do anything if there is one data token.
+        if (index !== enter + 2) {
+          events[enter][1].end = events[index - 1][1].end;
+          events.splice(enter + 2, index - enter - 2);
+          index = enter + 2;
+        }
+        enter = undefined;
+      }
+    }
+    return extraResolver ? extraResolver(events, context) : events;
+  }
+}
+
+/**
+ * A rather ugly set of instructions which again looks at chunks in the input
+ * stream.
+ * The reason to do this here is that it is *much* faster to parse in reverse.
+ * And that we can’t hook into `null` to split the line suffix before an EOF.
+ * To do: figure out if we can make this into a clean utility, or even in core.
+ * As it will be useful for GFMs literal autolink extension (and maybe even
+ * tables?)
+ *
+ * @type {Resolver}
+ */
+function resolveAllLineSuffixes(events, context) {
+  const editMap = new EditMap();
+  let eventIndex = 0; // Skip first.
+
+  while (++eventIndex <= events.length) {
+    if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
+      const data = events[eventIndex - 1][1];
+      const chunks = context.sliceStream(data);
+      let index = chunks.length;
+      let bufferIndex = -1;
+      let size = 0;
+      /** @type {boolean | undefined} */
+      let tabs;
+      while (index--) {
+        const chunk = chunks[index];
+        if (typeof chunk === 'string') {
+          bufferIndex = chunk.length;
+          while (chunk.charCodeAt(bufferIndex - 1) === 32) {
+            size++;
+            bufferIndex--;
+          }
+          if (bufferIndex) {
+            break;
+          }
+          bufferIndex = -1;
+        }
+        // Number
+        else if (chunk === -2) {
+          tabs = true;
+          size++;
+        } else if (chunk === -1) {
+          // Empty
+        } else {
+          // Replacement character, exit.
+          index++;
+          break;
+        }
+      }
+
+      // Allow final trailing whitespace.
+      if (context._contentTypeTextTrailing && eventIndex === events.length) {
+        size = 0;
+      }
+      if (size) {
+        const token = {
+          type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing",
+          start: {
+            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,
+            _index: data.start._index + index,
+            line: data.end.line,
+            column: data.end.column - size,
+            offset: data.end.offset - size
+          },
+          end: {
+            ...data.end
+          }
+        };
+        data.end = {
+          ...token.start
+        };
+        if (data.start.offset === data.end.offset) {
+          Object.assign(data, token);
+        } else {
+          editMap.add(eventIndex, 0, [['enter', token, context], ['exit', token, context]]);
+        }
+      }
+      eventIndex++;
+    }
+  }
+  editMap.consume(events);
+  return events;
+}

package/vendor/micromark/lib/parse.js

@@ -0,0 +1,56 @@
+/**
+ * @import {
+ *   Create,
+ *   FullNormalizedExtension,
+ *   InitialConstruct,
+ *   ParseContext,
+ *   ParseOptions
+ * } from 'micromark-util-types'
+ */
+
+import { combineExtensions } from 'micromark-util-combine-extensions';
+import { content } from './initialize/content.js';
+import { document } from './initialize/document.js';
+import { flow } from './initialize/flow.js';
+import { string, text } from './initialize/text.js';
+import * as defaultConstructs from './constructs.js';
+import { createTokenizer } from './create-tokenizer.js';
+
+/**
+ * @param {ParseOptions | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {ParseContext}
+ *   Parser.
+ */
+export function parse(options) {
+  const settings = options || {};
+  const constructs = /** @type {FullNormalizedExtension} */
+  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);
+
+  /** @type {ParseContext} */
+  const parser = {
+    constructs,
+    content: create(content),
+    defined: [],
+    document: create(document),
+    flow: create(flow),
+    lazy: {},
+    string: create(string),
+    text: create(text)
+  };
+  return parser;
+
+  /**
+   * @param {InitialConstruct} initial
+   *   Construct to start with.
+   * @returns {Create}
+   *   Create a tokenizer.
+   */
+  function create(initial) {
+    return creator;
+    /** @type {Create} */
+    function creator(from) {
+      return createTokenizer(parser, initial, from, settings.observeTokenizer);
+    }
+  }
+}

package/vendor/micromark/lib/postprocess.js

@@ -0,0 +1,18 @@
+/**
+ * @import {Event} from 'micromark-util-types'
+ */
+
+import { subtokenize } from 'micromark-util-subtokenize';
+
+/**
+ * @param {Array<Event>} events
+ *   Events.
+ * @returns {Array<Event>}
+ *   Events.
+ */
+export function postprocess(events) {
+  while (!subtokenize(events)) {
+    // Empty
+  }
+  return events;
+}

package/vendor/micromark/lib/preprocess.js

@@ -0,0 +1,112 @@
+/**
+ * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'
+ */
+
+/**
+ * @callback Preprocessor
+ *   Preprocess a value.
+ * @param {Value} value
+ *   Value.
+ * @param {Encoding | null | undefined} [encoding]
+ *   Encoding when `value` is a typed array (optional).
+ * @param {boolean | null | undefined} [end=false]
+ *   Whether this is the last chunk (default: `false`).
+ * @returns {Array<Chunk>}
+ *   Chunks.
+ */
+
+const search = /[\0\t\n\r]/g;
+
+/**
+ * @returns {Preprocessor}
+ *   Preprocess a value.
+ */
+export function preprocess() {
+  let column = 1;
+  let buffer = '';
+  /** @type {boolean | undefined} */
+  let start = true;
+  /** @type {boolean | undefined} */
+  let atCarriageReturn;
+  return preprocessor;
+
+  /** @type {Preprocessor} */
+  // eslint-disable-next-line complexity
+  function preprocessor(value, encoding, end) {
+    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));
+
+    /** @type {Array<Chunk>} */
+    const chunks = [];
+    let startPosition = 0;
+    buffer = '';
+    if (start) {
+      // To do: `markdown-rs` actually parses BOMs (byte order mark).
+      if (value.charCodeAt(0) === 65279) {
+        startPosition++;
+      }
+      start = undefined;
+    }
+    while (startPosition < value.length) {
+      search.lastIndex = startPosition;
+      const match = search.exec(value);
+      const endPosition = match && match.index !== undefined ? match.index : value.length;
+      const code = value.charCodeAt(endPosition);
+      if (!match) {
+        buffer = value.slice(startPosition);
+        break;
+      }
+      if (code === 10 && startPosition === endPosition && atCarriageReturn) {
+        chunks.push(-3);
+        atCarriageReturn = undefined;
+      } else {
+        if (atCarriageReturn) {
+          chunks.push(-5);
+          atCarriageReturn = undefined;
+        }
+        if (startPosition < endPosition) {
+          chunks.push(value.slice(startPosition, endPosition));
+          column += endPosition - startPosition;
+        }
+        switch (code) {
+          case 0:
+            {
+              chunks.push(65533);
+              column++;
+              break;
+            }
+          case 9:
+            {
+              const next = Math.ceil(column / 4) * 4;
+              chunks.push(-2);
+              while (column++ < next) {
+                chunks.push(-1);
+              }
+              break;
+            }
+          case 10:
+            {
+              chunks.push(-4);
+              column = 1;
+              break;
+            }
+          default:
+            {
+              atCarriageReturn = true;
+              column = 1;
+            }
+        }
+      }
+      startPosition = endPosition + 1;
+    }
+    if (end) {
+      if (atCarriageReturn) {
+        chunks.push(-5);
+      }
+      if (buffer) {
+        chunks.push(buffer);
+      }
+      chunks.push(null);
+    }
+    return chunks;
+  }
+}

package/vendor/micromark/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.

package/vendor/micromark/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "micromark",
+  "version": "4.0.3",
+  "description": "small commonmark compliant markdown parser with positional info and concrete tokens",
+  "license": "MIT",
+  "keywords": [
+    "commonmark",
+    "compiler",
+    "gfm",
+    "html",
+    "lexer",
+    "markdown",
+    "markup",
+    "md",
+    "unified",
+    "parse",
+    "parser",
+    "plugin",
+    "process",
+    "remark",
+    "render",
+    "renderer",
+    "token",
+    "tokenizer"
+  ],
+  "repository": "https://github.com/micromark/micromark/tree/main/packages/micromark",
+  "bugs": "https://github.com/micromark/micromark/issues",
+  "funding": [
+    {
+      "type": "GitHub Sponsors",
+      "url": "https://github.com/sponsors/unifiedjs"
+    },
+    {
+      "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.map",
+    "index.d.ts",
+    "index.js",
+    "stream.d.ts.map",
+    "stream.d.ts",
+    "stream.js"
+  ],
+  "exports": {
+    ".": {
+      "development": "./dev/index.js",
+      "default": "./index.js"
+    },
+    "./stream": {
+      "development": "./dev/stream.js",
+      "default": "./stream.js"
+    }
+  },
+  "dependencies": {
+    "@types/debug": "^4.0.0",
+    "debug": "^4.0.0",
+    "decode-named-character-reference": "^1.0.0",
+    "devlop": "^1.0.0",
+    "micromark-core-commonmark": "^2.0.0",
+    "micromark-factory-space": "^2.0.0",
+    "micromark-util-character": "^2.0.0",
+    "micromark-util-chunked": "^2.0.0",
+    "micromark-util-combine-extensions": "^2.0.0",
+    "micromark-util-decode-numeric-character-reference": "^2.0.0",
+    "micromark-util-edit-map": "^1.0.0",
+    "micromark-util-encode": "^2.0.0",
+    "micromark-util-normalize-identifier": "^2.0.0",
+    "micromark-util-resolve-all": "^2.0.0",
+    "micromark-util-sanitize-uri": "^2.0.0",
+    "micromark-util-subtokenize": "^2.0.0",
+    "micromark-util-symbol": "^2.0.0",
+    "micromark-util-types": "^2.0.0"
+  },
+  "scripts": {
+    "build": "micromark-build"
+  }
+}

package/vendor/micromark-core-commonmark/index.js

@@ -0,0 +1,22 @@
+export { attention } from './lib/attention.js';
+export { autolink } from './lib/autolink.js';
+export { blankLine } from './lib/blank-line.js';
+export { blockQuote } from './lib/block-quote.js';
+export { characterEscape } from './lib/character-escape.js';
+export { characterReference } from './lib/character-reference.js';
+export { codeFenced } from './lib/code-fenced.js';
+export { codeIndented } from './lib/code-indented.js';
+export { codeText } from './lib/code-text.js';
+export { content } from './lib/content.js';
+export { definition } from './lib/definition.js';
+export { hardBreakEscape } from './lib/hard-break-escape.js';
+export { headingAtx } from './lib/heading-atx.js';
+export { htmlFlow } from './lib/html-flow.js';
+export { htmlText } from './lib/html-text.js';
+export { labelEnd } from './lib/label-end.js';
+export { labelStartImage } from './lib/label-start-image.js';
+export { labelStartLink } from './lib/label-start-link.js';
+export { lineEnding } from './lib/line-ending.js';
+export { list } from './lib/list.js';
+export { setextUnderline } from './lib/setext-underline.js';
+export { thematicBreak } from './lib/thematic-break.js';