links-notation 0.12.0 → 0.15.0

package/tests/ApiTests.test.js

@@ -125,7 +125,7 @@ test('test_indented_id_syntax_roundtrip', () => {
 
   // Validate that we can format with indented syntax using FormatOptions
   const options = new FormatOptions();
-  options.maxInlineRefs = 1;  // Force indentation with more than 1 ref
+  options.maxInlineRefs = 1; // Force indentation with more than 1 ref
   options.preferInline = false;
   const output = formatLinks(parsed, options);
   expect(output).toBe(input);
@@ -164,7 +164,7 @@ id2:
 
   // Validate that we can format with indented syntax using FormatOptions
   const options = new FormatOptions();
-  options.maxInlineRefs = 1;  // Force indentation with more than 1 ref
+  options.maxInlineRefs = 1; // Force indentation with more than 1 ref
   options.preferInline = false;
   const output = formatLinks(parsed, options);
   expect(output).toBe(input);

package/tests/EdgeCaseParser.test.js

@@ -93,11 +93,11 @@ test('Empty links', () => {
   expect(result.length).toBe(1);
   expect(result[0].id).toBe(null);
   expect(result[0].values).toEqual([]);
-  
+
   // '(:)' is now forbidden
   input = '(:)';
   expect(() => parser.parse(input)).toThrow();
-  
+
   input = '(id:)';
   result = parser.parse(input);
   expect(result.length).toBe(1);
@@ -159,4 +159,4 @@ test('Invalid input', () => {
   const input = '(invalid';
   // Unclosed parentheses should throw an error
   expect(() => parser.parse(input)).toThrow();
-});
+});

package/tests/EmptyReference.test.js

@@ -0,0 +1,91 @@
+// Conformance tests for the empty reference (issue #288).
+//
+// A bare delimiter pair is the empty reference. The three delimiters `"`, `'`
+// and ` (backtick) behave identically, and every longer n-quote run keeps the
+// meaning it already had. The table below is shared with the Rust, Python, C#,
+// Go, Java and PHP suites, so a document written by one implementation reads
+// the same in all of them.
+
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
+
+const parser = new Parser();
+
+// Render a parsed node unambiguously: every reference is wrapped in angle
+// brackets so an empty one is visible as `<>`.
+function render(node) {
+  if (!node.values || node.values.length === 0) {
+    return `<${node.id ?? ''}>`;
+  }
+  const head =
+    node.id === null || node.id === undefined ? '' : `<${node.id}>: `;
+  return `(${head}${node.values.map(render).join(' ')})`;
+}
+
+function parsesAs(input) {
+  return parser.parse(input).map(render).join('\n');
+}
+
+test('TestBareDelimiterPairIsTheEmptyReference', () => {
+  expect(parsesAs('(a "" b)')).toBe('(<a> <> <b>)');
+});
+
+test('TestEveryDelimiterStyleYieldsTheSameEmptyReference', () => {
+  expect(parsesAs('(a "" b)')).toBe('(<a> <> <b>)');
+  expect(parsesAs("(a '' b)")).toBe('(<a> <> <b>)');
+  expect(parsesAs('(a `` b)')).toBe('(<a> <> <b>)');
+});
+
+test('TestAdjacentEmptyReferencesStaySeparate', () => {
+  expect(parsesAs('(a "" "" b)')).toBe('(<a> <> <> <b>)');
+  expect(parsesAs("(a '' '' b)")).toBe('(<a> <> <> <b>)');
+  expect(parsesAs('(a `` `` b)')).toBe('(<a> <> <> <b>)');
+  expect(parsesAs('(a ""  "" b)')).toBe('(<a> <> <> <b>)');
+});
+
+test('TestNestedEmptyReferencesParse', () => {
+  expect(parsesAs('("" ("" 1))')).toBe('(<> (<> <1>))');
+  expect(parsesAs('("" (\'\' 1))')).toBe('(<> (<> <1>))');
+  expect(parsesAs('("x" ("" 1))')).toBe('(<x> (<> <1>))');
+  expect(parsesAs('("" ("x" 1))')).toBe('(<> (<x> <1>))');
+  expect(parsesAs('("" x ("" 1))')).toBe('(<> <x> (<> <1>))');
+  expect(parsesAs('("" 1 ("" 1))')).toBe('(<> <1> (<> <1>))');
+});
+
+test('TestEmptyReferenceIsValidAsAnId', () => {
+  expect(parsesAs('("": 1)')).toBe('(<>: <1>)');
+  expect(parsesAs('(o: ("" (o: ("" 1))))')).toBe('(<o>: (<> (<o>: (<> <1>))))');
+});
+
+test('TestNQuoteDelimitedBodiesAreUnchanged', () => {
+  // A run that encloses a substantive body keeps its n-quote meaning.
+  expect(parsesAs('(a ""x"" b)')).toBe('(<a> <x> <b>)');
+  expect(parsesAs('(x "" " "")')).toBe('(<x> < " >)');
+  expect(parsesAs("(x ' \" ')")).toBe('(<x> < " >)');
+  // An n-quote-delimited empty is still empty.
+  expect(parsesAs('(a """" b)')).toBe('(<a> <> <b>)');
+});
+
+test('TestSingleSpaceStillReadsAsASpace', () => {
+  expect(parsesAs('(a " " b)')).toBe('(<a> < > <b>)');
+});
+
+test('TestEmptyReferenceSurvivesARoundTrip', () => {
+  const inputs = [
+    '(a "" b)',
+    '(a "" "" b)',
+    '("" ("" 1))',
+    '("": 1)',
+    '(o: ("" (o: ("" 1))))',
+  ];
+  for (const input of inputs) {
+    const links = parser.parse(input);
+    const formatted = formatLinks(links);
+    expect(parser.parse(formatted)).toEqual(links);
+  }
+});
+
+test('TestEmptyReferenceIsWrittenAsADelimiterPair', () => {
+  expect(formatLinks(parser.parse('(a "" b)'))).toBe('(a "" b)');
+});

package/tests/FormatConfig.test.js

@@ -13,8 +13,16 @@ test('Format config basic', () => {
 test('Format with line length limit', () => {
   // Create a link with many references that exceeds line length
   const link = new Link('sequence', [
-    new Link('1'), new Link('2'), new Link('3'), new Link('4'), new Link('5'),
-    new Link('6'), new Link('7'), new Link('8'), new Link('9'), new Link('10')
+    new Link('1'),
+    new Link('2'),
+    new Link('3'),
+    new Link('4'),
+    new Link('5'),
+    new Link('6'),
+    new Link('7'),
+    new Link('8'),
+    new Link('9'),
+    new Link('10'),
   ]);
 
   // Format with line length limit
@@ -22,7 +30,7 @@ test('Format with line length limit', () => {
   const config = new FormatConfig({
     indentLongLines: true,
     maxLineLength: 30,
-    preferInline: false
+    preferInline: false,
   });
 
   const output = link.format(config);
@@ -32,12 +40,17 @@ test('Format with line length limit', () => {
 
 test('Format with max inline refs', () => {
   // Create a link with 4 references
-  const link = new Link('id', [new Link('1'), new Link('2'), new Link('3'), new Link('4')]);
+  const link = new Link('id', [
+    new Link('1'),
+    new Link('2'),
+    new Link('3'),
+    new Link('4'),
+  ]);
 
   // Format with maxInlineRefs=3 (should trigger indentation)
   const config = new FormatConfig({
     maxInlineRefs: 3,
-    preferInline: false
+    preferInline: false,
   });
 
   const output = link.format(config);
@@ -49,7 +62,7 @@ test('Format with consecutive grouping', () => {
   const links = [
     new Link('SetA', [new Link('a')]),
     new Link('SetA', [new Link('b')]),
-    new Link('SetA', [new Link('c')])
+    new Link('SetA', [new Link('c')]),
   ];
 
   const config = new FormatConfig({ groupConsecutive: true });
@@ -75,12 +88,17 @@ test('Format config less parentheses', () => {
 });
 
 test('Format config custom indent', () => {
-  const link = new Link('id', [new Link('1'), new Link('2'), new Link('3'), new Link('4')]);
+  const link = new Link('id', [
+    new Link('1'),
+    new Link('2'),
+    new Link('3'),
+    new Link('4'),
+  ]);
 
   const config = new FormatConfig({
     maxInlineRefs: 3,
     preferInline: false,
-    indentString: '    ' // 4 spaces
+    indentString: '    ', // 4 spaces
   });
 
   const output = link.format(config);
@@ -90,12 +108,16 @@ test('Format config custom indent', () => {
 
 test('Roundtrip with line length formatting', () => {
   // Create a simple link
-  const originalLink = new Link('test', [new Link('a'), new Link('b'), new Link('c')]);
+  const originalLink = new Link('test', [
+    new Link('a'),
+    new Link('b'),
+    new Link('c'),
+  ]);
 
   // Format with indentation
   const config = new FormatConfig({
     maxInlineRefs: 2,
-    preferInline: false
+    preferInline: false,
   });
 
   const formatted = originalLink.format(config);

package/tests/IndentedIdSyntax.test.js

@@ -1,16 +1,16 @@
-import { test, expect } from "bun:test";
-import { Parser } from "../src/Parser.js";
-import { formatLinks } from "../src/Link.js";
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
 
 const parser = new Parser();
 
-test("Basic indented ID syntax", () => {
+test('Basic indented ID syntax', () => {
   const indentedSyntax = `3:
   papa
   loves
   mama`;
 
-  const inlineSyntax = "(3: papa loves mama)";
+  const inlineSyntax = '(3: papa loves mama)';
 
   const indentedResult = parser.parse(indentedSyntax);
   const inlineResult = parser.parse(inlineSyntax);
@@ -19,25 +19,25 @@ test("Basic indented ID syntax", () => {
   expect(indentedResult).toEqual(inlineResult);
 
   // Both should format to the same inline syntax
-  expect(formatLinks(indentedResult)).toBe("(3: papa loves mama)");
-  expect(formatLinks(inlineResult)).toBe("(3: papa loves mama)");
+  expect(formatLinks(indentedResult)).toBe('(3: papa loves mama)');
+  expect(formatLinks(inlineResult)).toBe('(3: papa loves mama)');
 });
 
-test("Indented ID syntax with single value", () => {
+test('Indented ID syntax with single value', () => {
   const input = `greeting:
   hello`;
 
   const result = parser.parse(input);
   const formatted = formatLinks(result);
 
-  expect(formatted).toBe("(greeting: hello)");
+  expect(formatted).toBe('(greeting: hello)');
   expect(result.length).toBe(1);
-  expect(result[0].id).toBe("greeting");
+  expect(result[0].id).toBe('greeting');
   expect(result[0].values.length).toBe(1);
-  expect(result[0].values[0].id).toBe("hello");
+  expect(result[0].values[0].id).toBe('hello');
 });
 
-test("Indented ID syntax with multiple values", () => {
+test('Indented ID syntax with multiple values', () => {
   const input = `action:
   run
   fast
@@ -46,13 +46,13 @@ test("Indented ID syntax with multiple values", () => {
   const result = parser.parse(input);
   const formatted = formatLinks(result);
 
-  expect(formatted).toBe("(action: run fast now)");
+  expect(formatted).toBe('(action: run fast now)');
   expect(result.length).toBe(1);
-  expect(result[0].id).toBe("action");
+  expect(result[0].id).toBe('action');
   expect(result[0].values.length).toBe(3);
 });
 
-test("Indented ID syntax with numeric ID", () => {
+test('Indented ID syntax with numeric ID', () => {
   const input = `42:
   answer
   to
@@ -61,10 +61,10 @@ test("Indented ID syntax with numeric ID", () => {
   const result = parser.parse(input);
   const formatted = formatLinks(result);
 
-  expect(formatted).toBe("(42: answer to everything)");
+  expect(formatted).toBe('(42: answer to everything)');
 });
 
-test("Indented ID syntax with quoted ID", () => {
+test('Indented ID syntax with quoted ID', () => {
   const input = `"complex id":
   value1
   value2`;
@@ -75,7 +75,7 @@ test("Indented ID syntax with quoted ID", () => {
   expect(formatted).toBe("('complex id': value1 value2)");
 });
 
-test("Multiple indented ID links", () => {
+test('Multiple indented ID links', () => {
   const input = `first:
   a
   b
@@ -87,10 +87,10 @@ second:
   const formatted = formatLinks(result);
 
   expect(result.length).toBe(2);
-  expect(formatted).toBe("(first: a b)\n(second: c d)");
+  expect(formatted).toBe('(first: a b)\n(second: c d)');
 });
 
-test("Mixed indented and regular syntax", () => {
+test('Mixed indented and regular syntax', () => {
   const input = `first:
   a
   b
@@ -101,12 +101,12 @@ third value`;
   expect(result.length).toBe(3);
 
   const formatted = formatLinks(result);
-  expect(formatted).toContain("(first: a b)");
-  expect(formatted).toContain("(second: c d)");
-  expect(formatted).toContain("third value");
+  expect(formatted).toContain('(first: a b)');
+  expect(formatted).toContain('(second: c d)');
+  expect(formatted).toContain('third value');
 });
 
-test("Unsupported colon-only syntax should fail", () => {
+test('Unsupported colon-only syntax should fail', () => {
   const input = `:
   papa
   loves
@@ -117,7 +117,7 @@ test("Unsupported colon-only syntax should fail", () => {
   }).toThrow();
 });
 
-test("Indented ID with deeper nesting", () => {
+test('Indented ID with deeper nesting', () => {
   const input = `root:
   child1
   child2
@@ -129,36 +129,36 @@ test("Indented ID with deeper nesting", () => {
 
   // The root should have child1 and child2 as values
   const rootLink = result[0];
-  expect(rootLink.id).toBe("root");
+  expect(rootLink.id).toBe('root');
   expect(rootLink.values.length).toBe(2);
 });
 
-test("Empty indented ID should work", () => {
-  const input = "empty:";
+test('Empty indented ID should work', () => {
+  const input = 'empty:';
 
   const result = parser.parse(input);
   expect(result.length).toBe(1);
-  expect(result[0].id).toBe("empty");
+  expect(result[0].id).toBe('empty');
   expect(result[0].values.length).toBe(0);
 
   const formatted = formatLinks(result);
-  expect(formatted).toBe("(empty)");
+  expect(formatted).toBe('(empty)');
 });
 
-test("Equivalence test comprehensive", () => {
+test('Equivalence test comprehensive', () => {
   const testCases = [
     {
-      indented: "test:\n  one",
-      inline: "(test: one)"
+      indented: 'test:\n  one',
+      inline: '(test: one)',
     },
     {
-      indented: "x:\n  a\n  b\n  c",
-      inline: "(x: a b c)"
+      indented: 'x:\n  a\n  b\n  c',
+      inline: '(x: a b c)',
     },
     {
-      indented: "\"quoted\":\n  value",
-      inline: "(\"quoted\": value)"
-    }
+      indented: '"quoted":\n  value',
+      inline: '("quoted": value)',
+    },
   ];
 
   for (const testCase of testCases) {
@@ -168,4 +168,4 @@ test("Equivalence test comprehensive", () => {
     expect(indentedResult).toEqual(inlineResult);
     expect(formatLinks(indentedResult)).toBe(formatLinks(inlineResult));
   }
-});
+});

package/tests/Link.test.js

@@ -38,8 +38,8 @@ test('Link escapeReference with special characters', () => {
   expect(Link.escapeReference('has:colon')).toBe("'has:colon'");
   expect(Link.escapeReference('has space')).toBe("'has space'");
   expect(Link.escapeReference('has(paren)')).toBe("'has(paren)'");
-  expect(Link.escapeReference('has"quote')).toBe(`'has"quote'`);
-  expect(Link.escapeReference("has'quote")).toBe(`"has'quote"`);
+  expect(Link.escapeReference('has"quote')).toBe("'has\"quote'");
+  expect(Link.escapeReference("has'quote")).toBe('"has\'quote"');
 });
 
 test('Link simplify', () => {
@@ -63,7 +63,7 @@ test('Link equals', () => {
   const link1 = new Link('test', [new Link('child')]);
   const link2 = new Link('test', [new Link('child')]);
   const link3 = new Link('different', [new Link('child')]);
-  
+
   expect(link1.equals(link2)).toBe(true);
   expect(link1.equals(link3)).toBe(false);
-});
+});

package/tests/LinksGroup.test.js

@@ -6,7 +6,7 @@ test('LinksGroup constructor', () => {
   const element = new Link('root');
   const children = [new Link('child1'), new Link('child2')];
   const group = new LinksGroup(element, children);
-  
+
   expect(group.element).toBe(element);
   expect(group.children).toBe(children);
 });
@@ -16,10 +16,10 @@ test('LinksGroup toList flattens structure', () => {
   const child1 = new Link('child1');
   const child2 = new Link('child2');
   const grandchild = new Link('grandchild');
-  
+
   const childGroup = new LinksGroup(child2, [grandchild]);
   const group = new LinksGroup(root, [child1, childGroup]);
-  
+
   const list = group.toList();
   expect(list.length).toBe(4);
   expect(list[0]).toBe(root);
@@ -45,7 +45,10 @@ test('LinksGroup constructor equivalent test', () => {
   const children = [new Link('child1'), new Link('child2')];
 
   // Create a group with an id
-  const group = new LinksGroup(new Link('group'), [new LinksGroup(root), ...children.map(c => new LinksGroup(c))]);
+  const group = new LinksGroup(new Link('group'), [
+    new LinksGroup(root),
+    ...children.map((c) => new LinksGroup(c)),
+  ]);
 
   expect(group.element.id).toBe('group');
   expect(group.children.length).toBe(3);
@@ -64,4 +67,4 @@ test('LinksGroup append to links list test', () => {
   expect(list[0]).toBe(element);
   expect(list[1]).toBe(children[0]);
   expect(list[2]).toBe(children[1]);
-});
+});

package/tests/MixedIndentationModes.test.js

@@ -1,10 +1,10 @@
-import { test, expect } from "bun:test";
-import { Parser } from "../src/Parser.js";
-import { formatLinks } from "../src/Link.js";
+import { test, expect } from 'bun:test';
+import { Parser } from '../src/Parser.js';
+import { formatLinks } from '../src/Link.js';
 
 const parser = new Parser();
 
-test("Hero example mixed modes", () => {
+test('Hero example mixed modes', () => {
   const input = `empInfo
   employees:
     (
@@ -24,14 +24,14 @@ test("Hero example mixed modes", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("empInfo");
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
-  expect(formatted).toContain("Wesley Crusher");
+  expect(formatted).toContain('empInfo');
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
+  expect(formatted).toContain('Wesley Crusher');
 });
 
-test("Hero example alternative format", () => {
+test('Hero example alternative format', () => {
   const input = `empInfo
   (
     employees:
@@ -53,14 +53,14 @@ test("Hero example alternative format", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("empInfo");
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
-  expect(formatted).toContain("Wesley Crusher");
+  expect(formatted).toContain('empInfo');
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
+  expect(formatted).toContain('Wesley Crusher');
 });
 
-test("Hero example equivalence", () => {
+test('Hero example equivalence', () => {
   const version1 = `empInfo
   employees:
     (
@@ -102,7 +102,7 @@ test("Hero example equivalence", () => {
   expect(formatted1).toBe(formatted2);
 });
 
-test("Set context without colon", () => {
+test('Set context without colon', () => {
   const input = `empInfo
   employees`;
 
@@ -110,11 +110,11 @@ test("Set context without colon", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("empInfo");
-  expect(formatted).toContain("employees");
+  expect(formatted).toContain('empInfo');
+  expect(formatted).toContain('employees');
 });
 
-test("Sequence context with colon", () => {
+test('Sequence context with colon', () => {
   const input = `employees:
   James Kirk
   Jean-Luc Picard
@@ -125,13 +125,13 @@ test("Sequence context with colon", () => {
   expect(result.length).toBeGreaterThan(0);
   expect(result.length).toBe(1);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
-  expect(formatted).toContain("Wesley Crusher");
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
+  expect(formatted).toContain('Wesley Crusher');
 });
 
-test("Sequence context with complex values", () => {
+test('Sequence context with complex values', () => {
   const input = `employees:
   (
     name (James Kirk)
@@ -147,12 +147,12 @@ test("Sequence context with complex values", () => {
   expect(result.length).toBeGreaterThan(0);
   expect(result.length).toBe(1);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("employees:");
-  expect(formatted).toContain("James Kirk");
-  expect(formatted).toContain("Jean-Luc Picard");
+  expect(formatted).toContain('employees:');
+  expect(formatted).toContain('James Kirk');
+  expect(formatted).toContain('Jean-Luc Picard');
 });
 
-test("Nested set and sequence contexts", () => {
+test('Nested set and sequence contexts', () => {
   const input = `company
   departments:
     engineering
@@ -165,12 +165,12 @@ test("Nested set and sequence contexts", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("company");
-  expect(formatted).toContain("departments:");
-  expect(formatted).toContain("employees:");
+  expect(formatted).toContain('company');
+  expect(formatted).toContain('departments:');
+  expect(formatted).toContain('employees:');
 });
 
-test("Deeply nested mixed modes", () => {
+test('Deeply nested mixed modes', () => {
   const input = `root
   level1
     level2:
@@ -183,6 +183,6 @@ test("Deeply nested mixed modes", () => {
 
   expect(result.length).toBeGreaterThan(0);
   const formatted = formatLinks(result);
-  expect(formatted).toContain("root");
-  expect(formatted).toContain("level2:");
+  expect(formatted).toContain('root');
+  expect(formatted).toContain('level2:');
 });