links-notation 0.27.1 → 0.28.0

package/src/parser-generated.js

@@ -224,7 +224,7 @@ function peg$parse(input, options) {
   }
   function peg$f10() {    unreadableLines.add(lineKey(offset())); return false;  }
   function peg$f11(l) {    return l;  }
-  function peg$f12(i) {    return { id: i };  }
+  function peg$f12(r) {    return { id: r.value, rawId: r.raw };  }
   function peg$f13(g, rest) {
     return rest === null ? g : { values: [g].concat(rest) };
   }
@@ -243,18 +243,22 @@ function peg$parse(input, options) {
   function peg$f23() {    return location();  }
   function peg$f24(value) {    return value;  }
   function peg$f25(list) {    return list;  }
-  function peg$f26(id, v) {    return { id: id, values: v };  }
+  function peg$f26(id, v) {    return { id: id.value, rawId: id.raw, values: v };  }
   function peg$f27(v) {    return { values: v };  }
-  function peg$f28(id) {    return { id: id, values: [] };  }
-  function peg$f29() {
+  function peg$f28(id) {    return { id: id.value, rawId: id.raw, values: [] };  }
+  function peg$f29(value) {
+    const { start, end } = range();
+    return { value: value, raw: source.slice(start, end) };
+  }
+  function peg$f30() {
     return hasReferenceLiteralPrefix(input, offset());
   }
-  function peg$f30(literal) {
+  function peg$f31(literal) {
     return decodeReferenceLiteral(literal);
   }
-  function peg$f31() {    return !hasReferenceLiteralPrefix(input, offset());  }
-  function peg$f32(chars) {    return chars.join('');  }
-  function peg$f33() {
+  function peg$f32() {    return !hasReferenceLiteralPrefix(input, offset());  }
+  function peg$f33(chars) {    return chars.join('');  }
+  function peg$f34() {
     const pos = offset();
     const result = parseQuotedStringAt(input, pos, '"');
     if (result) {
@@ -264,11 +268,11 @@ function peg$parse(input, options) {
     }
     return false;
   }
-  function peg$f34(chars) {    return parsedValue;  }
-  function peg$f35(c, cs) {    return [c].concat(cs).join('');  }
-  function peg$f36() {    return parsedLength > 1 && (parsedLength--, true);  }
-  function peg$f37(c) {    return c;  }
-  function peg$f38() {
+  function peg$f35(chars) {    return parsedValue;  }
+  function peg$f36(c, cs) {    return [c].concat(cs).join('');  }
+  function peg$f37() {    return parsedLength > 1 && (parsedLength--, true);  }
+  function peg$f38(c) {    return c;  }
+  function peg$f39() {
     const pos = offset();
     const result = parseQuotedStringAt(input, pos, "'");
     if (result) {
@@ -278,11 +282,11 @@ function peg$parse(input, options) {
     }
     return false;
   }
-  function peg$f39(chars) {    return parsedValue;  }
-  function peg$f40(c, cs) {    return [c].concat(cs).join('');  }
-  function peg$f41() {    return parsedLength > 1 && (parsedLength--, true);  }
-  function peg$f42(c) {    return c;  }
-  function peg$f43() {
+  function peg$f40(chars) {    return parsedValue;  }
+  function peg$f41(c, cs) {    return [c].concat(cs).join('');  }
+  function peg$f42() {    return parsedLength > 1 && (parsedLength--, true);  }
+  function peg$f43(c) {    return c;  }
+  function peg$f44() {
     const pos = offset();
     const result = parseQuotedStringAt(input, pos, '`');
     if (result) {
@@ -292,16 +296,16 @@ function peg$parse(input, options) {
     }
     return false;
   }
-  function peg$f44(chars) {    return parsedValue;  }
-  function peg$f45(c, cs) {    return [c].concat(cs).join('');  }
-  function peg$f46() {    return parsedLength > 1 && (parsedLength--, true);  }
-  function peg$f47(c) {    return c;  }
-  function peg$f48() {    return indentationStack.slice();  }
-  function peg$f49(spaces) {    setBaseIndentation(spaces);  }
-  function peg$f50(spaces) {    return normalizeIndentation(spaces) > getCurrentIndentation();  }
-  function peg$f51(spaces) {    pushIndentation(spaces);  }
-  function peg$f52(spaces) {    return checkIndentation(spaces);  }
-  function peg$f53() {    return isInsideNestedContext();  }
+  function peg$f45(chars) {    return parsedValue;  }
+  function peg$f46(c, cs) {    return [c].concat(cs).join('');  }
+  function peg$f47() {    return parsedLength > 1 && (parsedLength--, true);  }
+  function peg$f48(c) {    return c;  }
+  function peg$f49() {    return indentationStack.slice();  }
+  function peg$f50(spaces) {    setBaseIndentation(spaces);  }
+  function peg$f51(spaces) {    return normalizeIndentation(spaces) > getCurrentIndentation();  }
+  function peg$f52(spaces) {    pushIndentation(spaces);  }
+  function peg$f53(spaces) {    return checkIndentation(spaces);  }
+  function peg$f54() {    return isInsideNestedContext();  }
   let peg$currPos = options.peg$currPos | 0;
   let peg$savedPos = peg$currPos;
   const peg$posDetailsCache = [{ line: 1, column: 1 }];
@@ -1218,6 +1222,20 @@ function peg$parse(input, options) {
   }
 
   function peg$parsereference() {
+    let s0, s1;
+
+    s0 = peg$currPos;
+    s1 = peg$parsereferenceValue();
+    if (s1 !== peg$FAILED) {
+      peg$savedPos = s0;
+      s1 = peg$f29(s1);
+    }
+    s0 = s1;
+
+    return s0;
+  }
+
+  function peg$parsereferenceValue() {
     let s0;
 
     s0 = peg$parsereferenceLiteral();
@@ -1253,7 +1271,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f29();
+      s2 = peg$f30();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1352,7 +1370,7 @@ function peg$parse(input, options) {
         }
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f30(s3);
+          s0 = peg$f31(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1374,7 +1392,7 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f31();
+    s1 = peg$f32();
     if (s1) {
       s1 = undefined;
     } else {
@@ -1393,7 +1411,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f32(s2);
+        s0 = peg$f33(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1442,7 +1460,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f33();
+      s2 = peg$f34();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1452,7 +1470,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeDouble();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f34(s3);
+          s0 = peg$f35(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1488,7 +1506,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeDoubleMore();
       }
       peg$savedPos = s0;
-      s0 = peg$f35(s1, s2);
+      s0 = peg$f36(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1502,7 +1520,7 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f36();
+    s1 = peg$f37();
     if (s1) {
       s1 = undefined;
     } else {
@@ -1518,7 +1536,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f37(s2);
+        s0 = peg$f38(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1553,7 +1571,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f38();
+      s2 = peg$f39();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1563,7 +1581,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeSingle();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f39(s3);
+          s0 = peg$f40(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1599,7 +1617,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeSingleMore();
       }
       peg$savedPos = s0;
-      s0 = peg$f40(s1, s2);
+      s0 = peg$f41(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1613,7 +1631,7 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f41();
+    s1 = peg$f42();
     if (s1) {
       s1 = undefined;
     } else {
@@ -1629,7 +1647,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f42(s2);
+        s0 = peg$f43(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1664,7 +1682,7 @@ function peg$parse(input, options) {
     }
     if (s1 !== peg$FAILED) {
       peg$savedPos = peg$currPos;
-      s2 = peg$f43();
+      s2 = peg$f44();
       if (s2) {
         s2 = undefined;
       } else {
@@ -1674,7 +1692,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeBacktick();
         if (s3 !== peg$FAILED) {
           peg$savedPos = s0;
-          s0 = peg$f44(s3);
+          s0 = peg$f45(s3);
         } else {
           peg$currPos = s0;
           s0 = peg$FAILED;
@@ -1710,7 +1728,7 @@ function peg$parse(input, options) {
         s3 = peg$parseconsumeBacktickMore();
       }
       peg$savedPos = s0;
-      s0 = peg$f45(s1, s2);
+      s0 = peg$f46(s1, s2);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1724,7 +1742,7 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f46();
+    s1 = peg$f47();
     if (s1) {
       s1 = undefined;
     } else {
@@ -1740,7 +1758,7 @@ function peg$parse(input, options) {
       }
       if (s2 !== peg$FAILED) {
         peg$savedPos = s0;
-        s0 = peg$f47(s2);
+        s0 = peg$f48(s2);
       } else {
         peg$currPos = s0;
         s0 = peg$FAILED;
@@ -1759,7 +1777,7 @@ function peg$parse(input, options) {
     s0 = peg$currPos;
     s1 = '';
     peg$savedPos = s0;
-    s1 = peg$f48();
+    s1 = peg$f49();
     s0 = s1;
 
     return s0;
@@ -1788,7 +1806,7 @@ function peg$parse(input, options) {
       }
     }
     peg$savedPos = s0;
-    s1 = peg$f49(s1);
+    s1 = peg$f50(s1);
     s0 = s1;
 
     return s0;
@@ -1817,7 +1835,7 @@ function peg$parse(input, options) {
       }
     }
     peg$savedPos = peg$currPos;
-    s2 = peg$f50(s1);
+    s2 = peg$f51(s1);
     if (s2) {
       s2 = undefined;
     } else {
@@ -1825,7 +1843,7 @@ function peg$parse(input, options) {
     }
     if (s2 !== peg$FAILED) {
       peg$savedPos = s0;
-      s0 = peg$f51(s1);
+      s0 = peg$f52(s1);
     } else {
       peg$currPos = s0;
       s0 = peg$FAILED;
@@ -1857,7 +1875,7 @@ function peg$parse(input, options) {
       }
     }
     peg$savedPos = peg$currPos;
-    s2 = peg$f52(s1);
+    s2 = peg$f53(s1);
     if (s2) {
       s2 = undefined;
     } else {
@@ -2057,7 +2075,7 @@ function peg$parse(input, options) {
 
     s0 = peg$currPos;
     peg$savedPos = peg$currPos;
-    s1 = peg$f53();
+    s1 = peg$f54();
     if (s1) {
       s1 = undefined;
     } else {
@@ -2197,6 +2215,8 @@ function peg$parse(input, options) {
   // until the stack overflows.
   let contextDepth = 0;
   const maxDepth = options.maxDepth ?? Infinity;
+  // The document as the caller wrote it, comments included.
+  const source = options.source ?? input;
   // Lines already found unreadable, keyed by where they start and whether they
   // are inside a parenthesised group. Reading a line depends on nothing else: a
   // group starts a fresh indentation context, and indentation only decides

package/src/references.js

@@ -61,3 +61,21 @@ export function unescapeReference(reference) {
   }
   return reading.value;
 }
+
+/**
+ * The delimiter a reference was written between, read from the reference as it
+ * was written: `'`, `"` or `` ` `` for a quoted reference (however many of them
+ * open it), and null for a bare reference, a versioned literal, or no text.
+ * @param {string|null|undefined} raw - One reference exactly as written
+ * @returns {string|null} The delimiter character, or null
+ * @example
+ * referenceQuote("'1'"); // "'"
+ * referenceQuote('""a b""'); // '"'
+ * referenceQuote('1'); // null
+ * referenceQuote("'unclosed"); // null: a bare reference that starts with '
+ */
+export function referenceQuote(raw) {
+  if (typeof raw !== 'string' || !QUOTES.includes(raw[0])) return null;
+  const reading = readReference(raw, 0);
+  return reading !== null && reading.length === raw.length ? raw[0] : null;
+}

package/tests/Cst.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, test } from 'bun:test';
+import { CstKind, CstNode, Parser } from '../src/index.js';
+
+const roundTrip = (input, options) =>
+  new Parser(options).parseCst(input).toString();
+
+describe('concrete syntax tree (issue #364)', () => {
+  test('is the default lossless view of a document', () => {
+    const input = "(t 1 '1')";
+    const cst = new Parser().parseCst(input);
+    expect(cst).toBeInstanceOf(CstNode);
+    expect(cst.kind).toBe(CstKind.DOCUMENT);
+    expect(cst.toString()).toBe(input);
+    expect(cst.toSExpression()).toBe(
+      '(document (line (group open_paren:"(" (line reference:"t" whitespace:" " reference:"1" whitespace:" " reference:"\'1\'") close_paren:")")))'
+    );
+  });
+
+  test('reference tokens carry their value and delimiter', () => {
+    const references = new Parser()
+      .parseCst("(a \"b c\" ~1{64} ''e''''f'')")
+      .tokens()
+      .filter((token) => token.kind === CstKind.REFERENCE);
+    expect(
+      references.map((token) => [token.text, token.value, token.quote])
+    ).toEqual([
+      ['a', 'a', null],
+      ['"b c"', 'b c', '"'],
+      ['~1{64}', 'd', null],
+      ["''e''''f''", "e''f", "'"],
+    ]);
+  });
+
+  test.each([
+    ['empty', ''],
+    ['only whitespace', ' \t '],
+    ['blank lines', '\n\n'],
+    ['CRLF and CR', 'a\r\nb\rc\r\n'],
+    ['tabs and trailing spaces', 'a\t b  \n'],
+    ['comments everywhere', '# head\na: b # tail\n  # inner\n  c\n# end'],
+    ['multiline quotes', '(note: "one\n  two\r\nthree")'],
+    ['nested groups over lines', '(a (b\n  (c d)\n) e)\n'],
+    ['indentation', 'root:\n  child:\n    leaf\n  tail'],
+    ['literals', '(~1{} ~1{e6a0b9})'],
+    ['comment marks inside quotes', '(\'#a\' "b # c" `#`)'],
+    ['unicode', '(根: café 🙂)\n'],
+  ])('recovers %s exactly', (_, input) => {
+    expect(roundTrip(input)).toBe(input);
+  });
+
+  test('without comment support, # is part of references', () => {
+    const input = 'a #b';
+    const cst = new Parser({ comments: false }).parseCst(input);
+    expect(cst.toString()).toBe(input);
+    expect(cst.tokens().map((token) => token.kind)).toEqual([
+      'reference',
+      'whitespace',
+      'reference',
+    ]);
+  });
+
+  test('a group belongs to the line it opens on', () => {
+    const cst = new Parser().parseCst('a (b\nc)\nd');
+    expect(cst.children.map((line) => line.toString())).toEqual([
+      'a (b\nc)\n',
+      'd',
+    ]);
+    const group = cst.children[0].children[2];
+    expect(group.kind).toBe(CstKind.GROUP);
+    expect(group.children.map((child) => child.kind)).toEqual([
+      'open_paren',
+      'line',
+      'line',
+      'close_paren',
+    ]);
+  });
+
+  test('reads versioned literals in linear time', () => {
+    // CodeQL js/polynomial-redos flagged the regular expression that used to
+    // find where a literal ends; the scanner that replaced it is one pass.
+    const input = [
+      `~1{${'61'.repeat(50000)}}`,
+      `~${'1'.repeat(50000)}x`,
+      '~1{61} '.repeat(20000),
+    ].join('\n');
+    const started = Date.now();
+    const cst = new Parser().parseCst(input);
+    expect(Date.now() - started).toBeLessThan(5000);
+    expect(cst.toString()).toBe(input);
+    expect(
+      new Parser()
+        .parseCst('(~1{64} ~{} ~a{b} ~1x)')
+        .tokens()
+        .filter((token) => token.kind === CstKind.REFERENCE)
+        .map((token) => [token.text, token.value])
+    ).toEqual([
+      ['~1{64}', 'd'],
+      ['~{}', '~{}'],
+      ['~a{b}', '~a{b}'],
+      ['~1x', '~1x'],
+    ]);
+  });
+
+  test('rejects what parse() rejects', () => {
+    expect(() => new Parser().parseCst('(a')).toThrow();
+    expect(() => new Parser().parseCst('a)')).toThrow();
+    expect(() => new Parser({ maxDepth: 1 }).parseCst('((a))')).toThrow();
+  });
+});

package/tests/SharedSyntaxParity.test.js

@@ -0,0 +1,47 @@
+import { readFileSync } from 'node:fs';
+import { URL } from 'node:url';
+import { expect, test } from 'bun:test';
+import { Parser, StreamParser } from '../src/index.js';
+
+const read = (name) =>
+  JSON.parse(
+    readFileSync(new URL(`../../parity/${name}`, import.meta.url), 'utf8')
+  );
+const syntaxFixtures = read('syntax-fixtures.json');
+const textFixtures = read('text-fixtures.json');
+const tree = (links) =>
+  links.map((link) => ({
+    id: link.id,
+    raw: link.rawId,
+    quote: link.quote,
+    values: tree(link.values),
+  }));
+
+test('shared syntax parity: raw references and concrete syntax trees', () => {
+  for (const fixture of syntaxFixtures) {
+    const parser = new Parser();
+    expect(tree(parser.parse(fixture.input)), fixture.id).toEqual(
+      fixture.links
+    );
+    const cst = parser.parseCst(fixture.input);
+    expect(cst.toSExpression(), fixture.id).toBe(fixture.cst);
+    expect(cst.toString(), fixture.id).toBe(fixture.input);
+    const stream = new StreamParser();
+    for (const character of fixture.input) stream.write(character);
+    expect(tree(stream.end()), fixture.id).toEqual(fixture.links);
+  }
+});
+
+test('every shared input is recovered exactly from its concrete syntax tree', () => {
+  for (const { id, input } of [...textFixtures, ...syntaxFixtures]) {
+    const cst = new Parser().parseCst(input);
+    expect(cst.toString(), id).toBe(input);
+    expect(
+      cst
+        .tokens()
+        .map((token) => token.text)
+        .join(''),
+      id
+    ).toBe(input);
+  }
+});

package/tests/SyntaxMetadata.test.js

@@ -0,0 +1,102 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  Link,
+  Parser,
+  StreamParser,
+  formatLinks,
+  referenceQuote,
+} from '../src/index.js';
+
+describe('syntax metadata on parsed links (issue #364)', () => {
+  test("1 and '1' are the same reference but keep how they were written", () => {
+    const [link] = new Parser().parse("(t 1 '1')");
+    const [, bare, quoted] = link.values;
+    expect(bare.id).toBe('1');
+    expect(quoted.id).toBe('1');
+    expect(bare.rawId).toBe('1');
+    expect(quoted.rawId).toBe("'1'");
+    expect(bare.quote).toBeNull();
+    expect(quoted.quote).toBe("'");
+    // Equality and formatting ignore the metadata.
+    expect(bare.equals(quoted)).toBe(true);
+    expect(link.format()).toBe('(t 1 1)');
+  });
+
+  test('records every quote kind and run length', () => {
+    const [link] = new Parser().parse('("a": \'b\' `c` ""d"" ~1{65} f)');
+    expect(link.rawId).toBe('"a"');
+    expect(link.quote).toBe('"');
+    expect(link.values.map((value) => [value.rawId, value.quote])).toEqual([
+      ["'b'", "'"],
+      ['`c`', '`'],
+      ['""d""', '"'],
+      ['~1{65}', null],
+      ['f', null],
+    ]);
+  });
+
+  test('keeps raw text from the source, not from comment stripping', () => {
+    const [link] = new Parser().parse("(a 'b # c') # d");
+    expect(link.values[1].rawId).toBe("'b # c'");
+  });
+
+  test('leaves links without written IDs without raw text', () => {
+    const [link] = new Parser().parse('(a b)');
+    expect(link.rawId).toBeNull();
+    expect(link.quote).toBeNull();
+    expect(new Link('x').rawId).toBeNull();
+    expect(new Link('x').quote).toBeNull();
+  });
+
+  test('does not change equality, formatting or serialization', () => {
+    const quoted = new Parser().parse("('a': 'b')");
+    const bare = new Parser().parse('(a: b)');
+    expect(quoted[0].equals(bare[0])).toBe(true);
+    expect(formatLinks(quoted)).toBe(formatLinks(bare));
+    expect(quoted[0].toString()).toBe(bare[0].toString());
+    expect(JSON.stringify(quoted)).toBe(JSON.stringify(bare));
+    expect(quoted).toEqual(bare);
+  });
+
+  test('AST mode (syntax: false) drops the metadata', () => {
+    const [link] = new Parser({ syntax: false }).parse("('a': 'b')");
+    expect(link.rawId).toBeNull();
+    expect(link.values[0].rawId).toBeNull();
+    expect(link.values[0].quote).toBeNull();
+    expect(link.equals(new Parser().parse("('a': 'b')")[0])).toBe(true);
+  });
+
+  test('parseGroups and StreamParser keep the metadata', () => {
+    const groups = new Parser().parseGroups('\'root\':\n  "child"');
+    expect(groups[0].element.rawId).toBe("'root'");
+    expect(groups[0].children[0].element.values[0].rawId).toBe('"child"');
+    const stream = new StreamParser();
+    stream.write("(a '");
+    stream.write("b')");
+    const [link] = stream.end();
+    expect(link.values[1].rawId).toBe("'b'");
+    expect(link.values[1].quote).toBe("'");
+  });
+
+  test('rawId can be set on links built in code and must be text or null', () => {
+    const link = new Link('a');
+    link.rawId = '"a"';
+    expect(link.quote).toBe('"');
+    link.rawId = null;
+    expect(link.quote).toBeNull();
+    expect(() => {
+      link.rawId = 1;
+    }).toThrow(TypeError);
+  });
+
+  test('referenceQuote reads the delimiter of one complete reference', () => {
+    expect(referenceQuote("'1'")).toBe("'");
+    expect(referenceQuote('""a b""')).toBe('"');
+    expect(referenceQuote('`x`')).toBe('`');
+    expect(referenceQuote('1')).toBeNull();
+    expect(referenceQuote('~1{31}')).toBeNull();
+    expect(referenceQuote("'unclosed")).toBeNull();
+    expect(referenceQuote("'a' b")).toBeNull();
+    expect(referenceQuote(null)).toBeNull();
+  });
+});