links-notation 0.16.1 → 0.18.0

package/README.md

@@ -223,6 +223,35 @@ parent
     grandchild2
 ```
 
+### Multi-line Groups
+
+A parenthesized group opens a _nested context_: its body starts fresh at
+indentation level zero and follows the same rules as the root document, so a
+line break inside parentheses is structure rather than decoration.
+
+```lino
+value (
+  id "1"
+  label "one"
+)
+```
+
+The document above parses to `(value ((id 1) (label one)))` - two children, each
+a link of its own - rather than to one flat list in which the boundary between
+`id` and `label` would be lost. A body that stays on a single line still
+collapses to a single link, so `(a b c)` is unchanged.
+
+```javascript
+import { Parser, formatLinks } from 'links-notation';
+
+const links = new Parser().parse(`value (
+  id "1"
+  label "one"
+)`);
+
+console.log(formatLinks(links)); // (value ((id 1) (label one)))
+```
+
 ## API Reference
 
 ### Classes
@@ -250,11 +279,44 @@ Container for grouping related links.
 - `constructor(links)` - Create a new group
 - `format()` - Format the group as a string
 
+#### `ParseError`
+
+Thrown by `parse(input)` when the document does not parse. The message says
+where the document stopped making sense and quotes the offending line:
+
+```js
+import { Parser, ParseError } from 'links-notation';
+
+try {
+  new Parser().parse('# ok line\n# break: two\nci_gate x\n');
+} catch (error) {
+  console.error(error.message);
+  if (error instanceof ParseError) {
+    console.error(`${error.line}:${error.column} (offset ${error.offset})`);
+  }
+}
+```
+
+```text
+Syntax error at line 2, column 8: Expected "(", [ \t], [\r\n], or [^ \t\n\r(:)] but ":" found.
+2 | # break: two
+  |        ^
+```
+
+- `offset` - Offset of the offending position from the start of the document
+- `line`, `column` - Where the document stopped parsing, counted from 1
+- `found` - The character found instead, or `null` at the end of the document
+- `lineText` - The offending line, as written
+- `snippet` - The offending line with a caret under the offending column
+- `location` - The position as the generated parser reports it
+- `cause` - The error the generated parser threw
+
 ## Project Structure
 
 - `src/grammar.pegjs` - Peggy.js grammar definition
 - `src/Link.js` - Link data structure
 - `src/LinksGroup.js` - Links group container
+- `src/ParseError.js` - Parse error with the position of the defect
 - `src/Parser.js` - Parser wrapper
 - `src/index.js` - Main entry point
 - `tests/` - Test files
@@ -315,5 +377,4 @@ fail the format check.
 ## Package Information
 
 - Package: `links-notation`
-- Version: 0.1.0
-- License: MIT
+- License: Unlicense (see [LICENSE](../LICENSE))

package/README.ru.md

@@ -142,6 +142,35 @@ console.log(group.format());
     внук2
 ```
 
+### Многострочные группы
+
+Скобочная группа открывает _вложенный контекст_: её тело начинается заново с
+нулевого уровня отступа и подчиняется тем же правилам, что и корень документа,
+поэтому перенос строки внутри скобок — это структура, а не оформление.
+
+```lino
+value (
+  id "1"
+  label "one"
+)
+```
+
+Документ выше разбирается в `(value ((id 1) (label one)))` — два потомка,
+каждый из которых сам является связью, — а не в один плоский список, в котором
+граница между `id` и `label` была бы потеряна. Тело, умещающееся в одну строку,
+по-прежнему сворачивается в одну связь, так что `(a b c)` не меняется.
+
+```javascript
+import { Parser, formatLinks } from 'links-notation';
+
+const links = new Parser().parse(`value (
+  id "1"
+  label "one"
+)`);
+
+console.log(formatLinks(links)); // (value ((id 1) (label one)))
+```
+
 ## Справочник API
 
 ### Классы
@@ -169,11 +198,44 @@ console.log(group.format());
 - `constructor(links)` - Создание новой группы
 - `format()` - Форматирование группы в строку
 
+#### `ParseError`
+
+Выбрасывается методом `parse(input)`, когда документ не разбирается. Сообщение
+говорит, где документ перестал быть понятным, и цитирует сломанную строку:
+
+```js
+import { Parser, ParseError } from 'links-notation';
+
+try {
+  new Parser().parse('# ok line\n# break: two\nci_gate x\n');
+} catch (error) {
+  console.error(error.message);
+  if (error instanceof ParseError) {
+    console.error(`${error.line}:${error.column} (смещение ${error.offset})`);
+  }
+}
+```
+
+```text
+Syntax error at line 2, column 8: Expected "(", [ \t], [\r\n], or [^ \t\n\r(:)] but ":" found.
+2 | # break: two
+  |        ^
+```
+
+- `offset` - Смещение сломанной позиции от начала документа
+- `line`, `column` - Где документ перестал разбираться, счет с 1
+- `found` - Найденный символ или `null` в конце документа
+- `lineText` - Сломанная строка, как она написана
+- `snippet` - Сломанная строка с указателем под нужным столбцом
+- `location` - Позиция в том виде, в каком ее сообщает сгенерированный парсер
+- `cause` - Ошибка, которую выбросил сгенерированный парсер
+
 ## Структура проекта
 
 - `src/grammar.pegjs` - Определение грамматики Peggy.js
 - `src/Link.js` - Структура данных связи
 - `src/LinksGroup.js` - Контейнер групп связей
+- `src/ParseError.js` - Ошибка разбора с позицией дефекта
 - `src/Parser.js` - Обертка парсера
 - `src/index.js` - Главная точка входа
 - `tests/` - Файлы тестов
@@ -186,5 +248,4 @@ console.log(group.format());
 ## Информация о пакете
 
 - Пакет: `links-notation`
-- Версия: 0.1.0
-- Лицензия: MIT
+- Лицензия: Unlicense (см. [LICENSE](../LICENSE))

package/dist/index.js

@@ -149,13 +149,13 @@ class Link {
     if (options.shouldIndentByRefCount(this.values.length)) {
       shouldIndent = true;
     } else {
-      const valuesStr2 = this.values.map((v) => this.formatValue(v)).join(" ");
+      const valuesStr = this.values.map((v) => this.formatValue(v)).join(" ");
       let testLine;
       if (this.id !== null) {
-        const idStr2 = Link.escapeReference(this.id);
-        testLine = options.lessParentheses ? `${idStr2}: ${valuesStr2}` : `(${idStr2}: ${valuesStr2})`;
+        const idStr = Link.escapeReference(this.id);
+        testLine = options.lessParentheses ? `${idStr}: ${valuesStr}` : `(${idStr}: ${valuesStr})`;
       } else {
-        testLine = options.lessParentheses ? valuesStr2 : `(${valuesStr2})`;
+        testLine = options.lessParentheses ? valuesStr : `(${valuesStr})`;
       }
       if (options.shouldIndentByLength(testLine)) {
         shouldIndent = true;
@@ -181,8 +181,8 @@ class Link {
   }
   _formatIndented(options) {
     if (this.id === null) {
-      const lines2 = this.values.map((v) => options.indentString + this.formatValue(v));
-      return lines2.join(`
+      const lines = this.values.map((v) => options.indentString + this.formatValue(v));
+      return lines.join(`
 `);
     }
     const idStr = Link.escapeReference(this.id);
@@ -269,6 +269,57 @@ class LinksGroup {
     return list.map((item) => `(${item.id || item})`).join(" ");
   }
 }
+// src/ParseError.js
+var QUOTED_LINE_WIDTH = 80;
+var ELLIPSIS = "...";
+
+class ParseError extends Error {
+  constructor(input, error) {
+    const start = error?.location?.start ?? { offset: 0, line: 1, column: 1 };
+    const lineText = lineAt(input, start.offset);
+    const summary = `line ${start.line}, column ${start.column}: ${error.message}`;
+    const snippet = quote(start.line, lineText, start.column);
+    super(`Syntax error at ${summary}
+${snippet}`);
+    this.name = "ParseError";
+    this.cause = error;
+    this.location = error.location;
+    this.offset = start.offset;
+    this.line = start.line;
+    this.column = start.column;
+    this.found = error.found ?? null;
+    this.lineText = lineText;
+    this.snippet = snippet;
+  }
+}
+function lineAt(input, offset) {
+  const at = Math.max(0, Math.min(offset, input.length));
+  const start = input.lastIndexOf(`
+`, at - 1) + 1;
+  const end = input.indexOf(`
+`, start);
+  const line = input.slice(start, end === -1 ? input.length : end);
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+function quote(number, lineText, column) {
+  const [quoted, at] = windowAround(lineText, column);
+  const gutter = " ".repeat(String(number).length);
+  return `${number} | ${quoted}
+${gutter} | ${" ".repeat(at - 1)}^`;
+}
+function windowAround(lineText, column) {
+  if (lineText.length <= QUOTED_LINE_WIDTH) {
+    return [lineText, column];
+  }
+  const target = column - 1;
+  const lastStart = lineText.length - QUOTED_LINE_WIDTH;
+  const start = Math.min(Math.max(target - Math.floor(QUOTED_LINE_WIDTH / 2), 0), lastStart);
+  const end = start + QUOTED_LINE_WIDTH;
+  const quoted = (start > 0 ? ELLIPSIS : "") + lineText.slice(start, end) + (end < lineText.length ? ELLIPSIS : "");
+  const shift = start > 0 ? ELLIPSIS.length : 0;
+  return [quoted, target - start + shift + 1];
+}
+
 // src/parser-generated.js
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
@@ -282,7 +333,7 @@ class peg$SyntaxError extends SyntaxError {
     let str = "Error: " + this.message;
     if (this.location) {
       let src = null;
-      const st = sources.find((s2) => s2.source === this.location.source);
+      const st = sources.find((s) => s.source === this.location.source);
       if (st) {
         src = st.text.split(/\r\n|\n|\r/g);
       }
@@ -345,8 +396,8 @@ class peg$SyntaxError extends SyntaxError {
     function describeExpectation(expectation) {
       return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
     }
-    function describeExpected(expected2) {
-      const descriptions = expected2.map(describeExpectation);
+    function describeExpected(expected) {
+      const descriptions = expected.map(describeExpectation);
       descriptions.sort();
       if (descriptions.length > 0) {
         let j = 1;
@@ -367,8 +418,8 @@ class peg$SyntaxError extends SyntaxError {
           return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
       }
     }
-    function describeFound(found2) {
-      return found2 ? '"' + literalEscape(found2) + '"' : "end of input";
+    function describeFound(found) {
+      return found ? '"' + literalEscape(found) + '"' : "end of input";
     }
     return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
   }
@@ -597,13 +648,13 @@ function peg$parse(input, options) {
   function location() {
     return peg$computeLocation(peg$savedPos, peg$currPos);
   }
-  function expected(description, location2) {
-    location2 = location2 !== undefined ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
-    throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location2);
+  function expected(description, location) {
+    location = location !== undefined ? location : peg$computeLocation(peg$savedPos, peg$currPos);
+    throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location);
   }
-  function error(message, location2) {
-    location2 = location2 !== undefined ? location2 : peg$computeLocation(peg$savedPos, peg$currPos);
-    throw peg$buildSimpleError(message, location2);
+  function error(message, location) {
+    location = location !== undefined ? location : peg$computeLocation(peg$savedPos, peg$currPos);
+    throw peg$buildSimpleError(message, location);
   }
   function peg$getUnicode(pos = peg$currPos) {
     const cp = input.codePointAt(pos);
@@ -612,8 +663,8 @@ function peg$parse(input, options) {
     }
     return String.fromCodePoint(cp);
   }
-  function peg$literalExpectation(text2, ignoreCase) {
-    return { type: "literal", text: text2, ignoreCase };
+  function peg$literalExpectation(text, ignoreCase) {
+    return { type: "literal", text, ignoreCase };
   }
   function peg$classExpectation(parts, inverted, ignoreCase, unicode) {
     return { type: "class", parts, inverted, ignoreCase, unicode };
@@ -657,7 +708,7 @@ function peg$parse(input, options) {
       return details;
     }
   }
-  function peg$computeLocation(startPos, endPos, offset2) {
+  function peg$computeLocation(startPos, endPos, offset) {
     const startPosDetails = peg$computePosDetails(startPos);
     const endPosDetails = peg$computePosDetails(endPos);
     const res = {
@@ -673,13 +724,13 @@ function peg$parse(input, options) {
         column: endPosDetails.column
       }
     };
-    if (offset2 && peg$source && typeof peg$source.offset === "function") {
+    if (offset && peg$source && typeof peg$source.offset === "function") {
       res.start = peg$source.offset(res.start);
       res.end = peg$source.offset(res.end);
     }
     return res;
   }
-  function peg$fail(expected2) {
+  function peg$fail(expected) {
     if (peg$currPos < peg$maxFailPos) {
       return;
     }
@@ -687,13 +738,13 @@ function peg$parse(input, options) {
       peg$maxFailPos = peg$currPos;
       peg$maxFailExpected = [];
     }
-    peg$maxFailExpected.push(expected2);
+    peg$maxFailExpected.push(expected);
   }
-  function peg$buildSimpleError(message, location2) {
-    return new peg$SyntaxError(message, null, null, location2);
+  function peg$buildSimpleError(message, location) {
+    return new peg$SyntaxError(message, null, null, location);
   }
-  function peg$buildStructuredError(expected2, found, location2) {
-    return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected2, found), expected2, found, location2);
+  function peg$buildStructuredError(expected, found, location) {
+    return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
   }
   function peg$parsedocument() {
     let s0, s1, s2, s3, s4, s5;
@@ -2024,9 +2075,11 @@ class Parser {
       const rawResult = peg$parse(input);
       return this.transformResult(rawResult);
     } catch (error) {
+      if (error && error.location) {
+        throw new ParseError(input, error);
+      }
       const parseError = new Error(`Parse error: ${error.message}`);
       parseError.cause = error;
-      parseError.location = error.location;
       throw parseError;
     }
   }
@@ -2086,9 +2139,9 @@ class Parser {
     if (pathElements.length === 0)
       return current;
     if (pathElements.length === 1) {
-      const combined2 = new Link(null, [pathElements[0], current]);
-      combined2._isFromPathCombination = true;
-      return combined2;
+      const combined = new Link(null, [pathElements[0], current]);
+      combined._isFromPathCombination = true;
+      return combined;
     }
     const parentPath = pathElements.slice(0, -1);
     const lastElement = pathElements[pathElements.length - 1];
@@ -2163,6 +2216,7 @@ export {
   FormatOptions,
   Link,
   LinksGroup,
+  ParseError,
   Parser,
   formatLinks
 };

package/index.d.ts

@@ -144,11 +144,62 @@ export class Parser {
    * Parse Lino notation text into Link objects
    * @param input - The Lino notation text to parse
    * @returns Array of parsed Link objects
-   * @throws {Error} If parsing fails
+   * @throws {ParseError} If the text does not parse
    */
   parse(input: string): Link[];
 }
 
+/**
+ * The position a parse stopped at, as the generated parser reports it
+ */
+export interface ParseErrorLocation {
+  start: { offset: number; line: number; column: number };
+  end: { offset: number; line: number; column: number };
+}
+
+/**
+ * The error thrown when a document does not parse
+ *
+ * The message says where the document stopped making sense and quotes the
+ * offending line with a caret under it.
+ */
+export class ParseError extends Error {
+  /**
+   * Offset of the offending position from the start of the document
+   */
+  offset: number;
+
+  /**
+   * Line the offending position is on, counted from 1
+   */
+  line: number;
+
+  /**
+   * Column the offending position is at, counted from 1
+   */
+  column: number;
+
+  /**
+   * The character found instead, or null at the end of the document
+   */
+  found: string | null;
+
+  /**
+   * The offending line, as written, without its line ending
+   */
+  lineText: string;
+
+  /**
+   * The offending line with a caret under the offending column
+   */
+  snippet: string;
+
+  /**
+   * The position the generated parser reported
+   */
+  location: ParseErrorLocation;
+}
+
 /**
  * Options for formatting links
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "links-notation",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Links Notation parser for JavaScript",
   "main": "dist/index.js",
   "types": "index.d.ts",

package/src/ParseError.js

@@ -0,0 +1,104 @@
+/** The number of characters a quoted line is cut down to. */
+const QUOTED_LINE_WIDTH = 80;
+
+/** What a message writes in place of the part of a long line it left out. */
+const ELLIPSIS = '...';
+
+/**
+ * The error thrown when a document does not parse, carrying the position the
+ * parser stopped at.
+ *
+ * The generated parser reports that position, but only on the error object; the
+ * message it writes says what it expected without saying where. This error puts
+ * the line and the column in the message as well, and quotes the offending line
+ * with a caret under it, the way the Rust and C# ports do.
+ */
+export class ParseError extends Error {
+  /**
+   * @param {string} input - The document that failed to parse
+   * @param {Error} error - The error the generated parser threw
+   */
+  constructor(input, error) {
+    const start = error?.location?.start ?? { offset: 0, line: 1, column: 1 };
+    const lineText = lineAt(input, start.offset);
+    const summary = `line ${start.line}, column ${start.column}: ${error.message}`;
+    const snippet = quote(start.line, lineText, start.column);
+    super(`Syntax error at ${summary}\n${snippet}`);
+
+    this.name = 'ParseError';
+    /** @type {Error} The error the generated parser threw */
+    this.cause = error;
+    /** @type {{start: {offset: number, line: number, column: number}}} */
+    this.location = error.location;
+    /** @type {number} Offset of the offending position from the start of the document */
+    this.offset = start.offset;
+    /** @type {number} Line the offending position is on, counted from 1 */
+    this.line = start.line;
+    /** @type {number} Column the offending position is at, counted from 1 */
+    this.column = start.column;
+    /** @type {string|null} The character found instead, or null at the end of the document */
+    this.found = error.found ?? null;
+    /** @type {string} The offending line, as written, without its line ending */
+    this.lineText = lineText;
+    /** @type {string} The offending line with a caret under the offending column */
+    this.snippet = snippet;
+  }
+}
+
+/**
+ * The line the given offset falls on, without its line ending.
+ * @param {string} input - The document being parsed
+ * @param {number} offset - Offset of the offending position
+ * @returns {string} The offending line
+ */
+function lineAt(input, offset) {
+  const at = Math.max(0, Math.min(offset, input.length));
+  const start = input.lastIndexOf('\n', at - 1) + 1;
+  const end = input.indexOf('\n', start);
+  const line = input.slice(start, end === -1 ? input.length : end);
+  return line.endsWith('\r') ? line.slice(0, -1) : line;
+}
+
+/**
+ * The offending line with a caret under the offending column, quoted the way a
+ * compiler quotes source. A long line is shown as a window around the caret, so
+ * the message stays the same size whether the document has ten lines or fifteen
+ * hundred.
+ * @param {number} number - The line number, counted from 1
+ * @param {string} lineText - The offending line
+ * @param {number} column - The offending column, counted from 1
+ * @returns {string} The quoted line and the caret under it
+ */
+function quote(number, lineText, column) {
+  const [quoted, at] = windowAround(lineText, column);
+  const gutter = ' '.repeat(String(number).length);
+  return `${number} | ${quoted}\n${gutter} | ${' '.repeat(at - 1)}^`;
+}
+
+/**
+ * Cuts a line down to a window around the given column, and says which column
+ * the offending character sits at in that window. Both columns count from 1.
+ * @param {string} lineText - The offending line
+ * @param {number} column - The offending column, counted from 1
+ * @returns {[string, number]} The window and the column within it
+ */
+function windowAround(lineText, column) {
+  if (lineText.length <= QUOTED_LINE_WIDTH) {
+    return [lineText, column];
+  }
+
+  const target = column - 1;
+  const lastStart = lineText.length - QUOTED_LINE_WIDTH;
+  const start = Math.min(
+    Math.max(target - Math.floor(QUOTED_LINE_WIDTH / 2), 0),
+    lastStart
+  );
+  const end = start + QUOTED_LINE_WIDTH;
+
+  const quoted =
+    (start > 0 ? ELLIPSIS : '') +
+    lineText.slice(start, end) +
+    (end < lineText.length ? ELLIPSIS : '');
+  const shift = start > 0 ? ELLIPSIS.length : 0;
+  return [quoted, target - start + shift + 1];
+}

package/src/Parser.js

@@ -1,4 +1,5 @@
 import { Link } from './Link.js';
+import { ParseError } from './ParseError.js';
 import * as parserModule from './parser-generated.js';
 
 export class Parser {
@@ -35,10 +36,13 @@ export class Parser {
       const rawResult = parserModule.parse(input);
       return this.transformResult(rawResult);
     } catch (error) {
-      // Preserve original error information
+      // A syntax error knows where it stopped; anything else is passed on with
+      // the original error kept as the cause.
+      if (error && error.location) {
+        throw new ParseError(input, error);
+      }
       const parseError = new Error(`Parse error: ${error.message}`);
       parseError.cause = error;
-      parseError.location = error.location;
       throw parseError;
     }
   }

package/src/index.js

@@ -1,5 +1,6 @@
 export { Link, formatLinks } from './Link.js';
 export { LinksGroup } from './LinksGroup.js';
 export { Parser } from './Parser.js';
+export { ParseError } from './ParseError.js';
 export { FormatConfig } from './FormatConfig.js';
 export { FormatOptions } from './FormatOptions.js';

package/tests/ParseErrorPosition.test.js

@@ -0,0 +1,109 @@
+// A parse error has to say where the document stopped making sense.
+//
+// The positions asserted here are the ones the Rust and C# ports report for the
+// same input, so the implementations can be held to the same contract
+// (https://github.com/link-foundation/links-notation/issues/302).
+
+import { test, expect } from 'bun:test';
+import { Parser, ParseError } from '../src/index.js';
+
+const parser = new Parser();
+
+function syntaxError(document) {
+  try {
+    const links = parser.parse(document);
+    throw new Error(
+      `expected ${JSON.stringify(document)} not to parse, got ${links.length} links`
+    );
+  } catch (error) {
+    expect(error).toBeInstanceOf(ParseError);
+    return error;
+  }
+}
+
+test('reports the line and column of the defect', () => {
+  // The example from the issue: the defect is the colon on line 2, and the
+  // two lines after it are fine.
+  const error = syntaxError('# ok line\n# break: two\nci_gate x\n  stage rust');
+
+  expect(error.line).toBe(2);
+  expect(error.column).toBe(8);
+  expect(error.found).toBe(':');
+});
+
+test('offset agrees with the other implementations', () => {
+  // Rust and C# report offset 17, line 2, column 8 for this document.
+  const error = syntaxError('# ok line\n# break: two\n');
+
+  expect(error.offset).toBe(17);
+  expect(error.line).toBe(2);
+  expect(error.column).toBe(8);
+});
+
+test('reports the line a late defect is on', () => {
+  const error = syntaxError('a\nb\nc\nd\ne: f: g\nh\n');
+
+  expect(error.line).toBe(5);
+  expect(error.column).toBe(5);
+  expect(error.lineText).toBe('e: f: g');
+});
+
+test('reports the end of the document when a group is never closed', () => {
+  const error = syntaxError('a (b\n');
+
+  expect(error.offset).toBe(5);
+  expect(error.line).toBe(2);
+  expect(error.column).toBe(1);
+  expect(error.found).toBeNull();
+  expect(error.message).toContain('end of input');
+});
+
+test('reports an unmatched closing parenthesis', () => {
+  const error = syntaxError('a b)\n');
+
+  expect(error.offset).toBe(3);
+  expect(error.line).toBe(1);
+  expect(error.column).toBe(4);
+  expect(error.found).toBe(')');
+});
+
+test('message says where the document broke', () => {
+  const error = syntaxError('# ok line\n# break: two\n');
+
+  expect(error.message.startsWith('Syntax error at line 2, column 8:')).toBe(
+    true
+  );
+  expect(error.snippet).toBe('2 | # break: two\n  |        ^');
+});
+
+test('message quotes one line rather than the rest of the document', () => {
+  const document = `# ok line\n# break: two\n${'trailing line\n'.repeat(500)}`;
+
+  const error = syntaxError(document);
+
+  expect(error.message).toContain('line 2, column 8');
+  expect(error.message).not.toContain('trailing line');
+  expect(error.message.length).toBeLessThan(200);
+});
+
+test('message of a long line stays a message', () => {
+  const document = `${'a'.repeat(400)}: ${'b'.repeat(400)}: c`;
+
+  const error = syntaxError(document);
+
+  expect(error.line).toBe(1);
+  expect(error.column).toBe(803);
+  expect(error.message).toContain('...');
+  expect(error.message.length).toBeLessThan(300);
+});
+
+test('the location the parser used to report is still there', () => {
+  const error = syntaxError('a: b: c');
+
+  expect(error.location.start).toEqual({ offset: 4, line: 1, column: 5 });
+  expect(error.cause).toBeDefined();
+});
+
+test('a document that parses reports nothing', () => {
+  expect(parser.parse('a: b\n  c: d\n').length).toBe(2);
+});