@malloydata/malloy-tag 0.0.335 → 0.0.336

package/dist/tags.spec.js

@@ -23,10 +23,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const tags_1 = require("./tags");
+const peggy_1 = require("./peggy");
 expect.extend({
     tagsAre(src, result) {
         if (typeof src === 'string') {
-            const { tag, log } = tags_1.Tag.fromTagLine(src, 0, undefined);
+            const { tag, log } = (0, peggy_1.parseTag)(src);
             const errs = log.map(e => e.message);
             if (log.length > 0) {
                 return {
@@ -36,7 +37,7 @@ expect.extend({
             }
             src = tag;
         }
-        const got = src.properties;
+        const got = src.properties ? (0, tags_1.interfaceFromDict)(src.properties) : undefined;
         if (this.equals(got, result)) {
             return {
                 pass: true,
@@ -97,26 +98,19 @@ describe('tagParse to Tag', () => {
         ['x={y} -x.y', { x: { properties: { y: { deleted: true } } } }],
         ['x={y z} -x.y', { x: { properties: { z: {}, y: { deleted: true } } } }],
         ['x={y z} x {-y}', { x: { properties: { z: {}, y: { deleted: true } } } }],
-        ['x=1 x {xx=11}', { x: { eq: '1', properties: { xx: { eq: '11' } } } }],
-        ['x.y=xx x=1 {...}', { x: { eq: '1', properties: { y: { eq: 'xx' } } } }],
-        ['a {b c} a=1', { a: { eq: '1' } }],
-        ['a=1 a=...{b}', { a: { eq: '1', properties: { b: {} } } }],
-        [
-            'a=red { shade=dark } color=$(a) shade=$(a.shade)',
-            {
-                a: { eq: 'red', properties: { shade: { eq: 'dark' } } },
-                color: { eq: 'red', properties: { shade: { eq: 'dark' } } },
-                shade: { eq: 'dark' },
-            },
-        ],
-        ['x=.01', { x: { eq: '.01' } }],
-        ['x=-7', { x: { eq: '-7' } }],
-        ['x=7', { x: { eq: '7' } }],
-        ['x=7.0', { x: { eq: '7.0' } }],
-        ['x=.7', { x: { eq: '.7' } }],
-        ['x=.7e2', { x: { eq: '.7e2' } }],
-        ['x=7E2', { x: { eq: '7E2' } }],
+        ['x=1 x {xx=11}', { x: { eq: 1, properties: { xx: { eq: 11 } } } }],
+        ['x.y=xx x=1 {...}', { x: { eq: 1, properties: { y: { eq: 'xx' } } } }],
+        ['a {b c} a=1', { a: { eq: 1 } }],
+        ['a=1 a=...{b}', { a: { eq: 1, properties: { b: {} } } }],
+        ['x=.01', { x: { eq: 0.01 } }],
+        ['x=-7', { x: { eq: -7 } }],
+        ['x=7', { x: { eq: 7 } }],
+        ['x=7.0', { x: { eq: 7.0 } }],
+        ['x=.7', { x: { eq: 0.7 } }],
+        ['x=.7e2', { x: { eq: 70 } }],
+        ['x=7E2', { x: { eq: 700 } }],
         ['`spacey name`=Zaphod', { 'spacey name': { eq: 'Zaphod' } }],
+        ["name='single quoted'", { name: { eq: 'single quoted' } }],
         [
             'image { alt=hello { field=department } }',
             {
@@ -138,6 +132,57 @@ describe('tagParse to Tag', () => {
             },
         ],
         ['can remove.properties -...', {}],
+        // Colon syntax REPLACES properties (deletes old props)
+        ['name: { prop }', { name: { properties: { prop: {} } } }],
+        ['name: { a=1 b=2 }', { name: { properties: { a: { eq: 1 }, b: { eq: 2 } } } }],
+        ['name { old } name: { new }', { name: { properties: { new: {} } } }],
+        // Space syntax MERGES properties (keeps old props)
+        ['name { old } name { new }', { name: { properties: { old: {}, new: {} } } }],
+        // Colon and space syntax with dotted paths
+        ['a.b: { c }', { a: { properties: { b: { properties: { c: {} } } } } }],
+        [
+            'a.b { c } a.b { d }',
+            { a: { properties: { b: { properties: { c: {}, d: {} } } } } },
+        ],
+        ['a.b { c } a.b: { d }', { a: { properties: { b: { properties: { d: {} } } } } }],
+        // Colon syntax deletes existing value
+        ['name=val name: { prop }', { name: { properties: { prop: {} } } }],
+        // Space syntax preserves existing value
+        ['name=val name { prop }', { name: { eq: 'val', properties: { prop: {} } } }],
+        // Multi-line input
+        [
+            'person {\n  name="ted"\n  age=42\n}',
+            { person: { properties: { name: { eq: 'ted' }, age: { eq: 42 } } } },
+        ],
+        // Triple-quoted strings (multi-line values)
+        ['desc="""hello"""', { desc: { eq: 'hello' } }],
+        ['desc="""line one\nline two"""', { desc: { eq: 'line one\nline two' } }],
+        ['desc="""has " quote"""', { desc: { eq: 'has " quote' } }],
+        ['desc="""has "" two quotes"""', { desc: { eq: 'has "" two quotes' } }],
+        // Boolean values
+        ['enabled=@true', { enabled: { eq: true } }],
+        ['disabled=@false', { disabled: { eq: false } }],
+        // Date values
+        ['created=@2024-01-15', { created: { eq: new Date('2024-01-15') } }],
+        [
+            'updated=@2024-01-15T10:30:00Z',
+            { updated: { eq: new Date('2024-01-15T10:30:00Z') } },
+        ],
+        // Mixed types
+        [
+            'config { enabled=@true count=42 name=test }',
+            {
+                config: {
+                    properties: {
+                        enabled: { eq: true },
+                        count: { eq: 42 },
+                        name: { eq: 'test' },
+                    },
+                },
+            },
+        ],
+        // Arrays with typed values
+        ['flags=[@true, @false]', { flags: { eq: [{ eq: true }, { eq: false }] } }],
     ];
     test.each(tagTests)('tag %s', (expression, expected) => {
         expect(expression).tagsAre(expected);
@@ -150,7 +195,7 @@ describe('tagParse to Tag', () => {
 describe('Tag access', () => {
     test('just text', () => {
         const strToParse = 'a=b';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -158,7 +203,7 @@ describe('Tag access', () => {
     });
     test('tag path', () => {
         const strToParse = 'a.b.c.d.e=f';
-        const tagParse = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const tagParse = (0, peggy_1.parseTag)(strToParse);
         expect(tagParse.log).toEqual([]);
         const abcde = tagParse.tag.tag('a', 'b', 'c', 'd', 'e');
         expect(abcde).toBeDefined();
@@ -166,7 +211,7 @@ describe('Tag access', () => {
     });
     test('just array', () => {
         const strToParse = 'a=[b]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         const aval = a === null || a === void 0 ? void 0 : a.array();
@@ -178,7 +223,7 @@ describe('Tag access', () => {
     });
     test('tag path into array', () => {
         const strToParse = 'a.b.c = [{d=e}]';
-        const tagParse = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const tagParse = (0, peggy_1.parseTag)(strToParse);
         expect(tagParse.log).toEqual([]);
         const abcde = tagParse.tag.tag('a', 'b', 'c', 0, 'd');
         expect(abcde).toBeDefined();
@@ -186,7 +231,7 @@ describe('Tag access', () => {
     });
     test('array as text', () => {
         const strToParse = 'a=[b]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -194,7 +239,7 @@ describe('Tag access', () => {
     });
     test('text as array', () => {
         const strToParse = 'a=b';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -202,7 +247,7 @@ describe('Tag access', () => {
     });
     test('just numeric', () => {
         const strToParse = 'a=7';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -212,7 +257,7 @@ describe('Tag access', () => {
     });
     test('text as numeric', () => {
         const strToParse = 'a=seven';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -221,7 +266,7 @@ describe('Tag access', () => {
     });
     test('array as numeric', () => {
         const strToParse = 'a=[seven]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -230,7 +275,7 @@ describe('Tag access', () => {
     });
     test('full text array', () => {
         const strToParse = 'a=[b,c]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -239,7 +284,7 @@ describe('Tag access', () => {
     });
     test('filtered text array', () => {
         const strToParse = 'a=[b,c,{d}]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -248,7 +293,7 @@ describe('Tag access', () => {
     });
     test('full numeric array', () => {
         const strToParse = 'a=[1,2]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse, undefined);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -257,7 +302,7 @@ describe('Tag access', () => {
     });
     test('filtered numeric array', () => {
         const strToParse = 'a=[1,2,three]';
-        const getTags = tags_1.Tag.fromTagLine(strToParse);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         const a = getTags.tag.tag('a');
         expect(a).toBeDefined();
@@ -266,15 +311,51 @@ describe('Tag access', () => {
     });
     test('has', () => {
         const strToParse = 'a b.d';
-        const getTags = tags_1.Tag.fromTagLine(strToParse);
+        const getTags = (0, peggy_1.parseTag)(strToParse);
         expect(getTags.log).toEqual([]);
         expect(getTags.tag.has('a')).toBeTruthy();
         expect(getTags.tag.has('b', 'd')).toBeTruthy();
         expect(getTags.tag.has('c')).toBeFalsy();
     });
+    test('boolean accessor', () => {
+        const { tag } = (0, peggy_1.parseTag)('enabled=@true disabled=@false');
+        expect(tag.boolean('enabled')).toBe(true);
+        expect(tag.boolean('disabled')).toBe(false);
+        expect(tag.boolean('missing')).toBeUndefined();
+    });
+    test('isTrue and isFalse', () => {
+        const { tag } = (0, peggy_1.parseTag)('enabled=@true disabled=@false name=test');
+        expect(tag.isTrue('enabled')).toBe(true);
+        expect(tag.isFalse('enabled')).toBe(false);
+        expect(tag.isTrue('disabled')).toBe(false);
+        expect(tag.isFalse('disabled')).toBe(true);
+        // Non-boolean values
+        expect(tag.isTrue('name')).toBe(false);
+        expect(tag.isFalse('name')).toBe(false);
+        // Missing values
+        expect(tag.isTrue('missing')).toBe(false);
+        expect(tag.isFalse('missing')).toBe(false);
+    });
+    test('date accessor', () => {
+        const { tag } = (0, peggy_1.parseTag)('created=@2024-01-15 updated=@2024-01-15T10:30:00Z');
+        const created = tag.date('created');
+        expect(created).toBeInstanceOf(Date);
+        expect(created === null || created === void 0 ? void 0 : created.toISOString()).toBe('2024-01-15T00:00:00.000Z');
+        const updated = tag.date('updated');
+        expect(updated).toBeInstanceOf(Date);
+        expect(updated === null || updated === void 0 ? void 0 : updated.toISOString()).toBe('2024-01-15T10:30:00.000Z');
+        expect(tag.date('missing')).toBeUndefined();
+    });
+    test('text returns string for all scalar types', () => {
+        const { tag } = (0, peggy_1.parseTag)('n=42 b=@true d=@2024-01-15 s=hello');
+        expect(tag.text('n')).toBe('42');
+        expect(tag.text('b')).toBe('true');
+        expect(tag.text('d')).toBe('2024-01-15T00:00:00.000Z');
+        expect(tag.text('s')).toBe('hello');
+    });
     test('property access on existing tag (which does not yet have properties)', () => {
-        const parsePlot = tags_1.Tag.fromTagLine('# plot');
-        const parsed = tags_1.Tag.fromTagLine('# plot.x=2', 0, parsePlot.tag);
+        const parsePlot = (0, peggy_1.parseTag)('# plot');
+        const parsed = (0, peggy_1.parseTag)('# plot.x=2', parsePlot.tag);
         const allTags = parsed.tag;
         const plotTag = allTags.tag('plot');
         const xTag = plotTag.tag('x');
@@ -287,7 +368,7 @@ describe('Tag access', () => {
         const base = tags_1.Tag.withPrefix('# ');
         const ext = base.set(['a', 'b', 0], 3).set(['a', 'b', 1], 4);
         expect(ext).tagsAre({
-            a: { properties: { b: { eq: [{ eq: '3' }, { eq: '4' }] } } },
+            a: { properties: { b: { eq: [{ eq: 3 }, { eq: 4 }] } } },
         });
         expect(ext.toString()).toBe('# a.b = [3, 4]\n');
     });
@@ -298,13 +379,13 @@ describe('Tag access', () => {
             .set(['c', 0], 'foo')
             .set(['c', 0, 'a'], 4);
         expect(ext).tagsAre({
-            a: { properties: { b: { eq: [{ properties: { a: { eq: '3' } } }] } } },
-            c: { eq: [{ eq: 'foo', properties: { a: { eq: '4' } } }] },
+            a: { properties: { b: { eq: [{ properties: { a: { eq: 3 } } }] } } },
+            c: { eq: [{ eq: 'foo', properties: { a: { eq: 4 } } }] },
         });
         expect(ext.toString()).toBe('# a.b = [{ a = 3 }] c = [foo { a = 4 }]\n');
     });
     test('soft remove', () => {
-        const base = tags_1.Tag.fromTagLine('# a.b.c = [{ d = 1 }]').tag;
+        const base = (0, peggy_1.parseTag)('# a.b.c = [{ d = 1 }]').tag;
         const ext = base.delete('a', 'b', 'c', 0, 'd').delete('a', 'b', 'c', 0);
         expect(ext).tagsAre({
             a: { properties: { b: { properties: { c: { eq: [] } } } } },
@@ -312,7 +393,7 @@ describe('Tag access', () => {
         expect(ext.toString()).toBe('# a.b.c = []\n');
     });
     test('hard remove', () => {
-        const base = tags_1.Tag.fromTagLine('# hello').tag;
+        const base = (0, peggy_1.parseTag)('# hello').tag;
         const ext = base.unset('goodbye').unset('a', 'dieu');
         expect(ext).tagsAre({
             hello: {},
@@ -367,7 +448,7 @@ describe('Tag access', () => {
             const base = tags_1.Tag.withPrefix('#(malloy) ');
             const ext = base.set(['value'], '\n');
             expect(ext.toString()).toBe('#(malloy) value = "\\n"\n');
-            expect(base.text('value')).toBe('\n');
+            expect(ext.text('value')).toBe('\n');
             idempotent(ext);
         });
         test('value has a double quote', () => {
@@ -376,7 +457,7 @@ describe('Tag access', () => {
             expect(ext.toString()).toBe('#(malloy) value = "\\""\n');
             idempotent(ext);
         });
-        test.skip('value is empty string', () => {
+        test('value is empty string', () => {
             const base = tags_1.Tag.withPrefix('#(malloy) ');
             const ext = base.set(['value'], '');
             expect(ext.toString()).toBe('#(malloy) value = ""\n');
@@ -395,11 +476,409 @@ describe('Tag access', () => {
             idempotent(ext);
         });
     });
+    describe('parsing escape sequences in strings', () => {
+        test('\\n becomes newline', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\nworld"');
+            expect(tag.text('x')).toBe('hello\nworld');
+        });
+        test('\\t becomes tab', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\tworld"');
+            expect(tag.text('x')).toBe('hello\tworld');
+        });
+        test('\\r becomes carriage return', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\rworld"');
+            expect(tag.text('x')).toBe('hello\rworld');
+        });
+        test('\\b becomes backspace', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\bworld"');
+            expect(tag.text('x')).toBe('hello\bworld');
+        });
+        test('\\f becomes form feed', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\fworld"');
+            expect(tag.text('x')).toBe('hello\fworld');
+        });
+        test('\\uXXXX becomes unicode character', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\u0026world"');
+            expect(tag.text('x')).toBe('hello&world');
+        });
+        test('\\uXXXX with uppercase hex', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="\\u003F"');
+            expect(tag.text('x')).toBe('?');
+        });
+        test('\\\\ becomes backslash', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\\\world"');
+            expect(tag.text('x')).toBe('hello\\world');
+        });
+        test('\\" becomes double quote', () => {
+            const { tag } = (0, peggy_1.parseTag)('x="hello\\"world"');
+            expect(tag.text('x')).toBe('hello"world');
+        });
+        test("\\' in single quoted string", () => {
+            const { tag } = (0, peggy_1.parseTag)("x='hello\\'world'");
+            expect(tag.text('x')).toBe("hello'world");
+        });
+        test('\\` in backtick identifier', () => {
+            const { tag } = (0, peggy_1.parseTag)('`hello\\`world`=value');
+            expect(tag.text('hello`world')).toBe('value');
+        });
+    });
+});
+describe('Tag prefix handling', () => {
+    test('# prefix skips to first space', () => {
+        const { tag, log } = (0, peggy_1.parseTag)('# name=value');
+        expect(log).toEqual([]);
+        expect(tag.text('name')).toEqual('value');
+    });
+    test('#(docs) prefix skips to first space', () => {
+        const { tag, log } = (0, peggy_1.parseTag)('#(docs) name=value');
+        expect(log).toEqual([]);
+        expect(tag.text('name')).toEqual('value');
+    });
+    test('# with no space returns empty tag', () => {
+        const { tag, log } = (0, peggy_1.parseTag)('#noSpace');
+        expect(log).toEqual([]);
+        expect(tag.properties).toBeUndefined();
+    });
+    test('everything after # on same line is ignored (comment behavior)', () => {
+        // When parsing a single tag line, # at start means "skip prefix"
+        // The rest of the line after the space is the tag content
+        const { tag, log } = (0, peggy_1.parseTag)('# name=value # this is not a comment');
+        expect(log).toEqual([]);
+        // The "# this is not a comment" is parsed as tag content, not ignored
+        // because single-line parsing doesn't have comment support
+        expect(tag.has('name')).toBe(true);
+    });
+});
+describe('Empty and whitespace input', () => {
+    test('empty string produces empty tag', () => {
+        const { tag, log } = (0, peggy_1.parseTag)('');
+        expect(log).toEqual([]);
+        expect(tag.properties).toBeUndefined();
+    });
+    test('whitespace only produces empty tag', () => {
+        const { tag, log } = (0, peggy_1.parseTag)('   ');
+        expect(log).toEqual([]);
+        expect(tag.properties).toBeUndefined();
+    });
+    test('whitespace with comment produces empty tag', () => {
+        const { tag, log } = (0, peggy_1.parseTag)('   # this is a comment');
+        expect(log).toEqual([]);
+        expect(tag.properties).toBeUndefined();
+    });
+});
+describe('Error handling', () => {
+    test('syntax error has 0-based line and offset', () => {
+        const { log } = (0, peggy_1.parseTag)('a = [');
+        expect(log.length).toBe(1);
+        expect(log[0].code).toBe('tag-parse-syntax-error');
+        expect(log[0].line).toBe(0);
+        // Error at position 5 (after "a = [")
+        expect(log[0].offset).toBeGreaterThan(0);
+    });
+    test('error offset accounts for input position', () => {
+        const { log } = (0, peggy_1.parseTag)('valid another_valid oops=');
+        expect(log.length).toBe(1);
+        expect(log[0].line).toBe(0);
+        // Error should be near end of line
+        expect(log[0].offset).toBeGreaterThan(20);
+    });
+    test('error offset after prefix stripping', () => {
+        // "# " is stripped, so input becomes " a = ["
+        const { log } = (0, peggy_1.parseTag)('# a = [');
+        expect(log.length).toBe(1);
+        expect(log[0].line).toBe(0);
+        // Offset is relative to stripped input (after "#")
+        expect(log[0].offset).toBeGreaterThan(0);
+    });
+    test('longer prefix is stripped correctly', () => {
+        // "#(docs) " is stripped
+        const { log } = (0, peggy_1.parseTag)('#(docs) a = [');
+        expect(log.length).toBe(1);
+        expect(log[0].line).toBe(0);
+        // Offset is relative to stripped input (after "#(docs)")
+        expect(log[0].offset).toBeGreaterThan(0);
+    });
+    test('error on second line reports correct line number', () => {
+        // Error is on line 1 (0-based), the unclosed bracket
+        const { log } = (0, peggy_1.parseTag)('valid=1\ninvalid=[');
+        expect(log.length).toBe(1);
+        expect(log[0].line).toBe(1);
+        expect(log[0].offset).toBeGreaterThan(0);
+    });
+    test('unclosed string with newline produces error', () => {
+        // Regular strings cannot contain raw newlines - must close on same line
+        const { log } = (0, peggy_1.parseTag)('desc="forgot to close\n');
+        expect(log.length).toBe(1);
+        expect(log[0].line).toBe(0);
+    });
 });
 function idempotent(tag) {
     const str = tag.toString();
-    const clone = tags_1.Tag.fromTagLine(str).tag;
+    const clone = (0, peggy_1.parseTag)(str).tag;
     clone.prefix = tag.prefix;
     expect(clone.toString()).toBe(str);
 }
+describe('toObject', () => {
+    test('bare tag becomes true', () => {
+        const { tag } = (0, peggy_1.parseTag)('hidden');
+        expect(tag.toObject()).toEqual({ hidden: true });
+    });
+    test('string value becomes string', () => {
+        const { tag } = (0, peggy_1.parseTag)('color=blue');
+        expect(tag.toObject()).toEqual({ color: 'blue' });
+    });
+    test('numeric value becomes number', () => {
+        const { tag } = (0, peggy_1.parseTag)('size=10');
+        expect(tag.toObject()).toEqual({ size: 10 });
+    });
+    test('float value becomes number', () => {
+        const { tag } = (0, peggy_1.parseTag)('ratio=3.14');
+        expect(tag.toObject()).toEqual({ ratio: 3.14 });
+    });
+    test('properties only becomes nested object', () => {
+        const { tag } = (0, peggy_1.parseTag)('box { width=100 height=200 }');
+        expect(tag.toObject()).toEqual({ box: { width: 100, height: 200 } });
+    });
+    test('value and properties uses = key', () => {
+        const { tag } = (0, peggy_1.parseTag)('link="http://example.com" { target=_blank }');
+        expect(tag.toObject()).toEqual({
+            link: { '=': 'http://example.com', 'target': '_blank' },
+        });
+    });
+    test('array of simple values', () => {
+        const { tag } = (0, peggy_1.parseTag)('items=[a, b, c]');
+        expect(tag.toObject()).toEqual({ items: ['a', 'b', 'c'] });
+    });
+    test('array of numeric values', () => {
+        const { tag } = (0, peggy_1.parseTag)('nums=[1, 2, 3]');
+        expect(tag.toObject()).toEqual({ nums: [1, 2, 3] });
+    });
+    test('array with properties on elements', () => {
+        const { tag } = (0, peggy_1.parseTag)('items=[a { x=1 }, b { y=2 }]');
+        expect(tag.toObject()).toEqual({
+            items: [
+                { '=': 'a', 'x': 1 },
+                { '=': 'b', 'y': 2 },
+            ],
+        });
+    });
+    test('complex nested structure', () => {
+        const { tag } = (0, peggy_1.parseTag)('# hidden color=blue size=10 box { width=100 }');
+        expect(tag.toObject()).toEqual({
+            hidden: true,
+            color: 'blue',
+            size: 10,
+            box: { width: 100 },
+        });
+    });
+    test('deleted properties are excluded', () => {
+        const { tag } = (0, peggy_1.parseTag)('a b -a');
+        expect(tag.toObject()).toEqual({ b: true });
+    });
+    test('empty tag returns empty object', () => {
+        const { tag } = (0, peggy_1.parseTag)('');
+        expect(tag.toObject()).toEqual({});
+    });
+    test('deeply nested properties', () => {
+        const { tag } = (0, peggy_1.parseTag)('a.b.c=1');
+        expect(tag.toObject()).toEqual({ a: { b: { c: 1 } } });
+    });
+    test('array of objects (dictionaries)', () => {
+        const { tag } = (0, peggy_1.parseTag)('items=[{name=alice age=30}, {name=bob age=25}]');
+        expect(tag.toObject()).toEqual({
+            items: [
+                { name: 'alice', age: 30 },
+                { name: 'bob', age: 25 },
+            ],
+        });
+    });
+});
+describe('Tag parent tracking', () => {
+    test('root tag has no parent', () => {
+        const { tag } = (0, peggy_1.parseTag)('a=1');
+        expect(tag.parent).toBeUndefined();
+        expect(tag.root).toBe(tag);
+    });
+    test('child tag has parent set', () => {
+        const { tag } = (0, peggy_1.parseTag)('a { b=1 }');
+        const a = tag.tag('a');
+        expect(a === null || a === void 0 ? void 0 : a.parent).toBe(tag);
+    });
+    test('nested child has correct parent chain', () => {
+        const { tag } = (0, peggy_1.parseTag)('a { b { c=1 } }');
+        const a = tag.tag('a');
+        const b = a === null || a === void 0 ? void 0 : a.tag('b');
+        const c = b === null || b === void 0 ? void 0 : b.tag('c');
+        expect(a === null || a === void 0 ? void 0 : a.parent).toBe(tag);
+        expect(b === null || b === void 0 ? void 0 : b.parent).toBe(a);
+        expect(c === null || c === void 0 ? void 0 : c.parent).toBe(b);
+    });
+    test('root traverses to top of tree', () => {
+        const { tag } = (0, peggy_1.parseTag)('a { b { c=1 } }');
+        const c = tag.tag('a', 'b', 'c');
+        expect(c === null || c === void 0 ? void 0 : c.root).toBe(tag);
+    });
+    test('array elements have parent set to containing tag', () => {
+        const { tag } = (0, peggy_1.parseTag)('items=[a, b, c]');
+        const items = tag.tag('items');
+        const arr = items === null || items === void 0 ? void 0 : items.array();
+        expect(arr === null || arr === void 0 ? void 0 : arr[0].parent).toBe(items);
+        expect(arr === null || arr === void 0 ? void 0 : arr[1].parent).toBe(items);
+        expect(arr === null || arr === void 0 ? void 0 : arr[2].parent).toBe(items);
+    });
+    test('nested array elements have correct parents', () => {
+        const { tag } = (0, peggy_1.parseTag)('items=[{name=alice}, {name=bob}]');
+        const items = tag.tag('items');
+        const arr = items === null || items === void 0 ? void 0 : items.array();
+        const alice = arr === null || arr === void 0 ? void 0 : arr[0];
+        const name = alice === null || alice === void 0 ? void 0 : alice.tag('name');
+        expect(alice === null || alice === void 0 ? void 0 : alice.parent).toBe(items);
+        expect(name === null || name === void 0 ? void 0 : name.parent).toBe(alice);
+    });
+    test('dict accessor returns tags with correct parent', () => {
+        const { tag } = (0, peggy_1.parseTag)('a=1 b=2 c=3');
+        const dict = tag.dict;
+        expect(dict['a'].parent).toBe(tag);
+        expect(dict['b'].parent).toBe(tag);
+        expect(dict['c'].parent).toBe(tag);
+    });
+    test('entries iterator returns tags with correct parent', () => {
+        const { tag } = (0, peggy_1.parseTag)('a=1 b=2');
+        for (const [, child] of tag.entries()) {
+            expect(child.parent).toBe(tag);
+        }
+    });
+});
+describe('References (RefTag)', () => {
+    test('absolute reference resolves to root property', () => {
+        const { tag } = (0, peggy_1.parseTag)('source=hello target=$source');
+        expect(tag.text('target')).toBe('hello');
+    });
+    test('absolute reference with path resolves correctly', () => {
+        const { tag } = (0, peggy_1.parseTag)('config { db { host=localhost } } target=$config.db.host');
+        expect(tag.text('target')).toBe('localhost');
+    });
+    test('relative reference up one level', () => {
+        const { tag } = (0, peggy_1.parseTag)('outer { value=42 inner { ref=$^value } }');
+        expect(tag.numeric('outer', 'inner', 'ref')).toBe(42);
+    });
+    test('relative reference up two levels', () => {
+        const { tag } = (0, peggy_1.parseTag)('root=hello outer { inner { ref=$^^root } }');
+        expect(tag.text('outer', 'inner', 'ref')).toBe('hello');
+    });
+    test('reference with array index', () => {
+        const { tag } = (0, peggy_1.parseTag)('items=[first, second, third] target=$items[1]');
+        expect(tag.text('target')).toBe('second');
+    });
+    test('reference in array', () => {
+        const { tag } = (0, peggy_1.parseTag)('source=value refs=[$source, $source]');
+        const arr = tag.textArray('refs');
+        expect(arr).toEqual(['value', 'value']);
+    });
+    test('unresolved reference returns undefined', () => {
+        const { tag } = (0, peggy_1.parseTag)('ref=$nonexistent');
+        expect(tag.text('ref')).toBeUndefined();
+    });
+    test('RefTag.toRefString() returns source representation', () => {
+        const { tag } = (0, peggy_1.parseTag)('ref=$path.to.thing');
+        const ref = tag.tag('ref');
+        expect(ref).toBeInstanceOf(tags_1.RefTag);
+        expect(ref.toRefString()).toBe('$path.to.thing');
+    });
+    test('RefTag.toRefString() with ups', () => {
+        const { tag } = (0, peggy_1.parseTag)('a { ref=$^^root.path }');
+        const ref = tag.tag('a', 'ref');
+        expect(ref).toBeInstanceOf(tags_1.RefTag);
+        expect(ref.toRefString()).toBe('$^^root.path');
+    });
+    test('RefTag.toRefString() with array index', () => {
+        const { tag } = (0, peggy_1.parseTag)('ref=$items[0].name');
+        const ref = tag.tag('ref');
+        expect(ref).toBeInstanceOf(tags_1.RefTag);
+        expect(ref.toRefString()).toBe('$items[0].name');
+    });
+    test('chained reference access', () => {
+        const { tag } = (0, peggy_1.parseTag)('data { name=alice age=30 } ref=$data');
+        expect(tag.text('ref', 'name')).toBe('alice');
+        expect(tag.numeric('ref', 'age')).toBe(30);
+    });
+    test('reference has correct parent', () => {
+        const { tag } = (0, peggy_1.parseTag)('outer { ref=$something }');
+        const outer = tag.tag('outer');
+        const ref = outer === null || outer === void 0 ? void 0 : outer.tag('ref');
+        expect(ref === null || ref === void 0 ? void 0 : ref.parent).toBe(outer);
+    });
+    describe('validateReferences', () => {
+        test('no errors for valid references', () => {
+            const { tag } = (0, peggy_1.parseTag)('source=hello target=$source');
+            expect(tag.validateReferences()).toEqual([]);
+        });
+        test('error for unresolved reference', () => {
+            const { tag } = (0, peggy_1.parseTag)('ref=$nonexistent');
+            const errors = tag.validateReferences();
+            expect(errors).toHaveLength(1);
+            expect(errors[0]).toContain('Unresolved reference');
+            expect(errors[0]).toContain('$nonexistent');
+        });
+        test('error for unresolved nested reference', () => {
+            const { tag } = (0, peggy_1.parseTag)('outer { inner { ref=$missing } }');
+            const errors = tag.validateReferences();
+            expect(errors).toHaveLength(1);
+            expect(errors[0]).toContain('outer.inner.ref');
+        });
+        test('error for reference that goes up too far', () => {
+            const { tag } = (0, peggy_1.parseTag)('ref=$^^^^^way.too.far');
+            const errors = tag.validateReferences();
+            expect(errors).toHaveLength(1);
+        });
+        test('multiple unresolved references', () => {
+            const { tag } = (0, peggy_1.parseTag)('a=$missing1 b=$missing2');
+            const errors = tag.validateReferences();
+            expect(errors).toHaveLength(2);
+        });
+    });
+    describe('toJSON for references', () => {
+        test('RefTag serializes to linkTo marker', () => {
+            const { tag } = (0, peggy_1.parseTag)('ref=$path.to.thing');
+            const ref = tag.tag('ref');
+            expect(ref === null || ref === void 0 ? void 0 : ref.toJSON()).toEqual({ linkTo: '$path.to.thing' });
+        });
+        test('RefTag with ups serializes correctly', () => {
+            const { tag } = (0, peggy_1.parseTag)('a { ref=$^^root }');
+            const ref = tag.tag('a', 'ref');
+            expect(ref === null || ref === void 0 ? void 0 : ref.toJSON()).toEqual({ linkTo: '$^^root' });
+        });
+    });
+    describe('toObject with references', () => {
+        test('reference resolves to actual value', () => {
+            const { tag } = (0, peggy_1.parseTag)('source=hello target=$source');
+            const obj = tag.toObject();
+            expect(obj['target']).toBe('hello');
+        });
+        test('reference to object resolves correctly', () => {
+            const { tag } = (0, peggy_1.parseTag)('data { name=alice } ref=$data');
+            const obj = tag.toObject();
+            expect(obj['ref']).toEqual({ name: 'alice' });
+        });
+        test('unresolved reference becomes undefined', () => {
+            const { tag } = (0, peggy_1.parseTag)('ref=$nonexistent');
+            const obj = tag.toObject();
+            expect(obj['ref']).toBeUndefined();
+        });
+    });
+    describe('cloning with references', () => {
+        test('reference survives when extending tag is cloned', () => {
+            // Parse two lines - first creates reference, second extends it
+            const { tag } = (0, peggy_1.parseTag)(['source=hello target=$source', 'extra=data']);
+            // The reference should still work after the second parse cloned the first result
+            expect(tag.text('target')).toBe('hello');
+        });
+        test('clone preserves RefTag', () => {
+            const { tag } = (0, peggy_1.parseTag)('source=hello target=$source');
+            const cloned = tag.clone();
+            // After cloning, the reference should still resolve
+            expect(cloned.text('target')).toBe('hello');
+        });
+    });
+});
 //# sourceMappingURL=tags.spec.js.map