@samuelbines/nunjucks 0.0.3 → 0.0.4

package/dist/tests/globals.test.js

@@ -1,579 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const globals_1 = require("../src/globals");
-(0, vitest_1.describe)('globals()', () => {
-    (0, vitest_1.it)('returns a fresh object each call (no shared state)', () => {
-        const g1 = (0, globals_1.globals)();
-        const g2 = (0, globals_1.globals)();
-        (0, vitest_1.expect)(g1).not.toBe(g2);
-        (0, vitest_1.expect)(g1.range).not.toBe(g2.range); // methods are new per object literal
-    });
-    (0, vitest_1.describe)('range()', () => {
-        (0, vitest_1.it)('creates a range from 0..stop-1 when called with one arg', () => {
-            const { range } = (0, globals_1.globals)();
-            // TS signature says stop is required, but runtime supports one-arg call
-            (0, vitest_1.expect)(range(5)).toEqual([0, 1, 2, 3, 4]);
-        });
-        (0, vitest_1.it)('creates a range from start..stop-1 with positive step', () => {
-            const { range } = (0, globals_1.globals)();
-            (0, vitest_1.expect)(range(2, 7, 2)).toEqual([2, 4, 6]);
-            (0, vitest_1.expect)(range(2, 3, 1)).toEqual([2]);
-            (0, vitest_1.expect)(range(2, 2, 1)).toEqual([]);
-        });
-        (0, vitest_1.it)('creates a descending range when step is negative', () => {
-            const { range } = (0, globals_1.globals)();
-            (0, vitest_1.expect)(range(5, 0, -2)).toEqual([5, 3, 1]);
-            (0, vitest_1.expect)(range(5, 5, -1)).toEqual([]);
-        });
-        (0, vitest_1.it)('defaults step to 1 if not provided (2-arg call)', () => {
-            const { range } = (0, globals_1.globals)();
-            (0, vitest_1.expect)(range(3, 6)).toEqual([3, 4, 5]);
-        });
-    });
-    (0, vitest_1.describe)('cycler()', () => {
-        (0, vitest_1.it)('cycles through items and updates current', () => {
-            const { cycler } = (0, globals_1.globals)();
-            const c = cycler('a', 'b', 'c');
-            (0, vitest_1.expect)(c.current).toBeNull();
-            (0, vitest_1.expect)(c.next()).toBe('a');
-            (0, vitest_1.expect)(c.current).toBe('a');
-            (0, vitest_1.expect)(c.next()).toBe('b');
-            (0, vitest_1.expect)(c.current).toBe('b');
-            (0, vitest_1.expect)(c.next()).toBe('c');
-            (0, vitest_1.expect)(c.current).toBe('c');
-            // wraps
-            (0, vitest_1.expect)(c.next()).toBe('a');
-            (0, vitest_1.expect)(c.current).toBe('a');
-        });
-        (0, vitest_1.it)('reset() clears state', () => {
-            const { cycler } = (0, globals_1.globals)();
-            const c = cycler(1, 2);
-            c.next();
-            (0, vitest_1.expect)(c.current).toBe(1);
-            c.reset();
-            (0, vitest_1.expect)(c.current).toBeNull();
-            (0, vitest_1.expect)(c.next()).toBe(1);
-            (0, vitest_1.expect)(c.current).toBe(1);
-        });
-        (0, vitest_1.it)('empty cycler always returns null and current stays null', () => {
-            const { cycler } = (0, globals_1.globals)();
-            const c = cycler();
-            (0, vitest_1.expect)(c.current).toBeNull();
-            (0, vitest_1.expect)(c.next()).toBeNull();
-            (0, vitest_1.expect)(c.next()).toBeNull();
-            (0, vitest_1.expect)(c.current).toBeNull();
-        });
-        (0, vitest_1.it)('each cycler instance has independent state', () => {
-            const { cycler } = (0, globals_1.globals)();
-            const a = cycler('x', 'y');
-            const b = cycler('x', 'y');
-            (0, vitest_1.expect)(a.next()).toBe('x');
-            (0, vitest_1.expect)(a.current).toBe('x');
-            (0, vitest_1.expect)(b.current).toBeNull();
-            (0, vitest_1.expect)(b.next()).toBe('x');
-            (0, vitest_1.expect)(b.current).toBe('x');
-            (0, vitest_1.expect)(a.next()).toBe('y');
-            (0, vitest_1.expect)(b.next()).toBe('y');
-        });
-    });
-    (0, vitest_1.describe)('joiner()', () => {
-        (0, vitest_1.it)("returns '' the first time, then the separator afterwards", () => {
-            const { joiner } = (0, globals_1.globals)();
-            const j = joiner(',');
-            (0, vitest_1.expect)(j()).toBe('');
-            (0, vitest_1.expect)(j()).toBe(',');
-            (0, vitest_1.expect)(j()).toBe(',');
-        });
-        (0, vitest_1.it)("defaults separator to ','", () => {
-            const { joiner } = (0, globals_1.globals)();
-            const j = joiner();
-            (0, vitest_1.expect)(j()).toBe('');
-            (0, vitest_1.expect)(j()).toBe(',');
-        });
-        (0, vitest_1.it)('each joiner has independent state', () => {
-            const { joiner } = (0, globals_1.globals)();
-            const a = joiner('-');
-            const b = joiner('-');
-            (0, vitest_1.expect)(a()).toBe('');
-            (0, vitest_1.expect)(a()).toBe('-');
-            (0, vitest_1.expect)(b()).toBe('');
-            (0, vitest_1.expect)(b()).toBe('-');
-        });
-    });
-});
-(0, vitest_1.describe)('precompileGlobal()', () => {
-    (0, vitest_1.it)('produces a string that registers templates on window.nunjucksPrecompiled', () => {
-        const out = (0, globals_1.precompileGlobal)([
-            { name: 'a.njk', template: 'return { root: function(){} }' },
-            { name: 'b.njk', template: 'return { root: function(){} }' },
-        ]);
-        (0, vitest_1.expect)(typeof out).toBe('string');
-        // basic structure checks
-        (0, vitest_1.expect)(out).toContain('window.nunjucksPrecompiled');
-        (0, vitest_1.expect)(out).toContain('["a.njk"]');
-        (0, vitest_1.expect)(out).toContain('["b.njk"]');
-        (0, vitest_1.expect)(out).toContain('(function()');
-        (0, vitest_1.expect)(out).toContain('})();');
-    });
-    (0, vitest_1.it)('embeds the template source and invokes it via an IIFE', () => {
-        const tpl = "return { root: function(){ return 'ok' } }";
-        const out = (0, globals_1.precompileGlobal)([{ name: 'x', template: tpl }]);
-        (0, vitest_1.expect)(out).toContain(tpl);
-        (0, vitest_1.expect)(out).toContain('] = (function() {');
-        (0, vitest_1.expect)(out).toContain('\n})();\n'); // template IIFE close
-    });
-    (0, vitest_1.it)('includes a render wrapper when opts.isFunction is true', () => {
-        const out = (0, globals_1.precompileGlobal)([{ name: 'x', template: 'return { root: function(){} }' }], { isFunction: true });
-        (0, vitest_1.expect)(out).toContain('return function(ctx, cb)');
-        (0, vitest_1.expect)(out).toContain('nunjucks.render(');
-        (0, vitest_1.expect)(out).toContain('"x"');
-    });
-    (0, vitest_1.it)('does not include the render wrapper when opts.isFunction is false/omitted', () => {
-        const out1 = (0, globals_1.precompileGlobal)([{ name: 'x', template: 'return {}' }]);
-        const out2 = (0, globals_1.precompileGlobal)([{ name: 'x', template: 'return {}' }], {
-            isFunction: false,
-        });
-        (0, vitest_1.expect)(out1).not.toContain('return function(ctx, cb)');
-        (0, vitest_1.expect)(out2).not.toContain('return function(ctx, cb)');
-    });
-    (0, vitest_1.it)('JSON stringifies template names (handles quotes safely)', () => {
-        const name = 'weird"name';
-        const out = (0, globals_1.precompileGlobal)([{ name, template: 'return {}' }]);
-        // JSON.stringify adds escaping
-        (0, vitest_1.expect)(out).toContain(JSON.stringify(name));
-    });
-});
-function makeThisEnv(overrides) {
-    const runtime = {
-        contextOrFrameLookup: vitest_1.vi.fn((_ctx, _frame, key) => {
-            // simulate "not found" by default
-            if (key === 'existing')
-                return 123;
-            return undefined;
-        }),
-        memberLookup: vitest_1.vi.fn((obj, val) => {
-            // default behavior: just property access (like a basic runtime)
-            return obj?.[val];
-        }),
-    };
-    const lib = {
-        isObject: (o) => o !== null && typeof o === 'object' && !Array.isArray(o),
-        keys: (o) => Object.keys(o),
-    };
-    // "slim" mode by default for tests unless explicitly enabled
-    const base = {
-        runtime,
-        lib,
-        compiler: { Compiler: undefined },
-        parser: { Parser: undefined },
-        nodes: undefined,
-        lexer: {
-            TOKEN_LEFT_BRACKET: 'left-bracket',
-            TOKEN_RIGHT_BRACKET: 'right-bracket',
-            TOKEN_COLON: 'colon',
-        },
-    };
-    return Object.assign(base, overrides ?? {});
-}
-(0, vitest_1.describe)('installCompat', () => {
-    const ORIGINAL_BUILD_TYPE = process.env.BUILD_TYPE;
-    (0, vitest_1.afterEach)(() => {
-        process.env.BUILD_TYPE = ORIGINAL_BUILD_TYPE;
-    });
-    (0, vitest_1.it)('patches runtime.contextOrFrameLookup to support True/False/None when original returns undefined', () => {
-        const env = makeThisEnv();
-        const uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup({}, {}, 'existing')).toBe(123);
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup({}, {}, 'True')).toBe(true);
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup({}, {}, 'False')).toBe(false);
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup({}, {}, 'None')).toBe(null);
-        // unknown stays undefined
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup({}, {}, 'whatever')).toBe(undefined);
-        uninstall();
-        // original restored
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup).toBe(env.runtime.contextOrFrameLookup);
-    });
-    (0, vitest_1.it)('returns an uninstall function that restores original runtime hooks', () => {
-        const env = makeThisEnv();
-        const origLookup = env.runtime.contextOrFrameLookup;
-        const origMember = env.runtime.memberLookup;
-        const uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup).not.toBe(origLookup);
-        (0, vitest_1.expect)(env.runtime.memberLookup).not.toBe(origMember);
-        uninstall();
-        (0, vitest_1.expect)(env.runtime.contextOrFrameLookup).toBe(origLookup);
-        (0, vitest_1.expect)(env.runtime.memberLookup).toBe(origMember);
-    });
-    (0, vitest_1.describe)('memberLookup: array python-ish members', () => {
-        let env;
-        let uninstall;
-        (0, vitest_1.beforeEach)(() => {
-            env = makeThisEnv();
-            uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-        });
-        (0, vitest_1.afterEach)(() => uninstall());
-        (0, vitest_1.it)('array.append pushes and returns new length', () => {
-            const arr = [1, 2];
-            const append = env.runtime.memberLookup(arr, 'append', false);
-            (0, vitest_1.expect)(typeof append).toBe('function');
-            const out = append(3);
-            (0, vitest_1.expect)(out).toBe(3);
-            (0, vitest_1.expect)(arr).toEqual([1, 2, 3]);
-        });
-        (0, vitest_1.it)('array.pop() without index pops last', () => {
-            const arr = [1, 2, 3];
-            const pop = env.runtime.memberLookup(arr, 'pop', false);
-            (0, vitest_1.expect)(pop()).toBe(3);
-            (0, vitest_1.expect)(arr).toEqual([1, 2]);
-        });
-        (0, vitest_1.it)('array.pop(index) removes element at index and returns removed array (splice)', () => {
-            const arr = [10, 20, 30];
-            const pop = env.runtime.memberLookup(arr, 'pop', false);
-            (0, vitest_1.expect)(pop(1)).toEqual([20]);
-            (0, vitest_1.expect)(arr).toEqual([10, 30]);
-        });
-        (0, vitest_1.it)('array.pop(index) throws KeyError when out of bounds', () => {
-            const arr = [1];
-            const pop = env.runtime.memberLookup(arr, 'pop', false);
-            (0, vitest_1.expect)(() => pop(99)).toThrow(/KeyError/);
-            (0, vitest_1.expect)(() => pop(-1)).toThrow(/KeyError/);
-        });
-        (0, vitest_1.it)('array.remove(element) removes first match else throws ValueError', () => {
-            const arr = [1, 2, 2, 3];
-            const remove = env.runtime.memberLookup(arr, 'remove', false);
-            (0, vitest_1.expect)(remove(2)).toEqual([2]);
-            (0, vitest_1.expect)(arr).toEqual([1, 2, 3]);
-            (0, vitest_1.expect)(() => remove(999)).toThrow(/ValueError/);
-        });
-        (0, vitest_1.it)('array.count(element) returns occurrences', () => {
-            const arr = [1, 2, 2, 3];
-            const count = env.runtime.memberLookup(arr, 'count', false);
-            (0, vitest_1.expect)(count(2)).toBe(2);
-            (0, vitest_1.expect)(count(9)).toBe(0);
-        });
-        (0, vitest_1.it)('array.index(element) returns first index else throws ValueError', () => {
-            const arr = ['a', 'b'];
-            const index = env.runtime.memberLookup(arr, 'index', false);
-            (0, vitest_1.expect)(index('b')).toBe(1);
-            (0, vitest_1.expect)(() => index('x')).toThrow(/ValueError/);
-        });
-        (0, vitest_1.it)('array.find(element) returns index or -1', () => {
-            const arr = ['a', 'b'];
-            const find = env.runtime.memberLookup(arr, 'find', false);
-            (0, vitest_1.expect)(find('b')).toBe(1);
-            (0, vitest_1.expect)(find('x')).toBe(-1);
-        });
-        (0, vitest_1.it)('array.insert(index, elem) splices and returns []', () => {
-            const arr = [1, 3];
-            const insert = env.runtime.memberLookup(arr, 'insert', false);
-            (0, vitest_1.expect)(insert(1, 2)).toEqual([]);
-            (0, vitest_1.expect)(arr).toEqual([1, 2, 3]);
-        });
-    });
-    (0, vitest_1.describe)('memberLookup: object python-ish members', () => {
-        let env;
-        let uninstall;
-        (0, vitest_1.beforeEach)(() => {
-            env = makeThisEnv();
-            uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-        });
-        (0, vitest_1.afterEach)(() => uninstall());
-        (0, vitest_1.it)('object.items/values/keys', () => {
-            const obj = { a: 1, b: 2 };
-            const items = env.runtime.memberLookup(obj, 'items', false);
-            const values = env.runtime.memberLookup(obj, 'values', false);
-            const keys = env.runtime.memberLookup(obj, 'keys', false);
-            (0, vitest_1.expect)(items()).toEqual([
-                ['a', 1],
-                ['b', 2],
-            ]);
-            (0, vitest_1.expect)(values()).toEqual([1, 2]);
-            (0, vitest_1.expect)(keys()).toEqual(['a', 'b']);
-        });
-        (0, vitest_1.it)('object iter* aliases (iteritems/itervalues/iterkeys)', () => {
-            const obj = { a: 1 };
-            (0, vitest_1.expect)(env.runtime.memberLookup(obj, 'iteritems', false)()).toEqual([
-                ['a', 1],
-            ]);
-            (0, vitest_1.expect)(env.runtime.memberLookup(obj, 'itervalues', false)()).toEqual([1]);
-            (0, vitest_1.expect)(env.runtime.memberLookup(obj, 'iterkeys', false)()).toEqual(['a']);
-        });
-        (0, vitest_1.it)('object.get(key, def) returns def when missing', () => {
-            const obj = { a: 1 };
-            const get = env.runtime.memberLookup(obj, 'get', false);
-            (0, vitest_1.expect)(get('a', 9)).toBe(1);
-            (0, vitest_1.expect)(get('missing', 9)).toBe(9);
-            (0, vitest_1.expect)(get('missing', undefined)).toBe(undefined);
-        });
-        (0, vitest_1.it)('object.has_key checks own props only', () => {
-            const obj = Object.create({ inherited: 1 });
-            obj.own = 2;
-            const hasKey = env.runtime.memberLookup(obj, 'has_key', false);
-            (0, vitest_1.expect)(hasKey('own')).toBe(true);
-            (0, vitest_1.expect)(hasKey('inherited')).toBe(false);
-        });
-        (0, vitest_1.it)('object.pop(key, def) deletes and returns or throws KeyError', () => {
-            const obj = { a: 1 };
-            const pop = env.runtime.memberLookup(obj, 'pop', false);
-            (0, vitest_1.expect)(pop('a')).toBe(1);
-            (0, vitest_1.expect)('a' in obj).toBe(false);
-            (0, vitest_1.expect)(pop('missing', 7)).toBe(7);
-            (0, vitest_1.expect)(() => pop('missing2')).toThrow(/KeyError/);
-        });
-        (0, vitest_1.it)('object.popitem removes and returns a [k,v] pair or throws KeyError when empty', () => {
-            const obj = { a: 1, b: 2 };
-            const popitem = env.runtime.memberLookup(obj, 'popitem', false);
-            const [k, v] = popitem();
-            (0, vitest_1.expect)(['a', 'b']).toContain(k);
-            (0, vitest_1.expect)(v).toBe(1 === v ? 1 : 2);
-            (0, vitest_1.expect)(obj[k]).toBeUndefined();
-            const empty = {};
-            const popitemEmpty = env.runtime.memberLookup(empty, 'popitem', false);
-            (0, vitest_1.expect)(() => popitemEmpty()).toThrow(/KeyError/);
-        });
-        (0, vitest_1.it)('object.setdefault sets when missing, returns existing when present', () => {
-            const obj = { a: 1 };
-            const setdefault = env.runtime.memberLookup(obj, 'setdefault', false);
-            (0, vitest_1.expect)(setdefault('a', 9)).toBe(1);
-            (0, vitest_1.expect)(obj.a).toBe(1);
-            (0, vitest_1.expect)(setdefault('b', 9)).toBe(9);
-            (0, vitest_1.expect)(obj.b).toBe(9);
-            // default default is null
-            (0, vitest_1.expect)(setdefault('c')).toBe(null);
-            (0, vitest_1.expect)(obj.c).toBe(null);
-        });
-        (0, vitest_1.it)('object.update assigns and returns null', () => {
-            const obj = { a: 1 };
-            const update = env.runtime.memberLookup(obj, 'update', false);
-            const out = update({ b: 2, a: 9 });
-            (0, vitest_1.expect)(out).toBe(null);
-            (0, vitest_1.expect)(obj).toEqual({ a: 9, b: 2 });
-        });
-    });
-    (0, vitest_1.describe)('memberLookup: sliceLookup (arguments.length === 4)', () => {
-        let env;
-        let uninstall;
-        (0, vitest_1.beforeEach)(() => {
-            env = makeThisEnv({
-                runtime: {
-                    // memberLookup will be overwritten by installCompat, but
-                    // sliceLookup uses runtime.memberLookup to access indexes.
-                    contextOrFrameLookup: vitest_1.vi.fn(() => undefined),
-                    memberLookup: vitest_1.vi.fn((obj, idx) => obj?.[idx]),
-                },
-            });
-            uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-        });
-        (0, vitest_1.afterEach)(() => uninstall());
-        (0, vitest_1.it)('positive step slice: start..stop', () => {
-            const arr = ['a', 'b', 'c', 'd', 'e'];
-            // call memberLookup with 4 args to trigger sliceLookup(obj,start,stop,step)
-            const res = env.runtime.memberLookup(arr, 1, 4, 1);
-            (0, vitest_1.expect)(res).toEqual(['b', 'c', 'd']);
-        });
-        (0, vitest_1.it)('negative indices and negative step', () => {
-            const arr = ['a', 'b', 'c', 'd', 'e'];
-            // start=null => last element; stop=null => -1; step=-1 => reverse full
-            const res = env.runtime.memberLookup(arr, null, null, -1);
-            (0, vitest_1.expect)(res).toEqual(['e', 'd', 'c', 'b', 'a']);
-        });
-        (0, vitest_1.it)('stop < 0 adjusts by length', () => {
-            const arr = [0, 1, 2, 3, 4, 5];
-            const res = env.runtime.memberLookup(arr, 0, -2, 1); // stop becomes len-2 => 4
-            (0, vitest_1.expect)(res).toEqual([0, 1, 2, 3]);
-        });
-        (0, vitest_1.it)('start < 0 adjusts by length', () => {
-            const arr = [0, 1, 2, 3, 4];
-            const res = env.runtime.memberLookup(arr, -3, null, 1); // start becomes 2
-            (0, vitest_1.expect)(res).toEqual([2, 3, 4]);
-        });
-    });
-    (0, vitest_1.describe)('non-slim (BUILD_TYPE !== SLIM) parser/compiler patching', () => {
-        // These tests focus on: assertType ignores Slice; parseAggregate fallback attempts slice parsing.
-        // We keep it minimal by stubbing the shapes installCompat uses.
-        const prev = process.env.BUILD_TYPE;
-        (0, vitest_1.beforeEach)(() => {
-            process.env.BUILD_TYPE = 'FULL';
-        });
-        (0, vitest_1.afterEach)(() => {
-            process.env.BUILD_TYPE = prev;
-        });
-        (0, vitest_1.it)('patches Compiler.prototype.assertType to ignore Slice instances', () => {
-            // minimal nodes system: Node.extend + Literal + Array
-            class Node {
-                static extend(_name, def) {
-                    const Parent = this;
-                    return class Slice extends Parent {
-                        static fields = def.fields;
-                        fields = def.fields;
-                        start;
-                        stop;
-                        step;
-                        parent(l, c, start, stop, step) {
-                            this.lineno = l;
-                            this.colno = c;
-                            this.start = start;
-                            this.stop = stop;
-                            this.step = step;
-                        }
-                        constructor(...args) {
-                            super();
-                            def.init.apply(this, args);
-                        }
-                    };
-                }
-            }
-            class Literal extends Node {
-                lineno;
-                colno;
-                value;
-                constructor(lineno, colno, value) {
-                    super();
-                    this.lineno = lineno;
-                    this.colno = colno;
-                    this.value = value;
-                }
-            }
-            class ArrayNode extends Node {
-                lineno;
-                colno;
-                children;
-                constructor(lineno, colno, children) {
-                    super();
-                    this.lineno = lineno;
-                    this.colno = colno;
-                    this.children = children;
-                }
-            }
-            class Compiler {
-                assertType(node) {
-                    // original throws for unknown types
-                    if (!node || node.__type !== 'ok')
-                        throw new Error('bad type');
-                }
-            }
-            const env = makeThisEnv({
-                nodes: { Node, Literal, Array: ArrayNode },
-                compiler: { Compiler },
-                parser: { Parser: class Parser {
-                    } },
-            });
-            const uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-            const c = new env.compiler.Compiler();
-            // @ts-expect-error - the Slice class is created inside installCompat
-            const Slice = env.nodes.Node.extend; // not directly accessible; so we validate behavior indirectly:
-            // We can still ensure patched assertType does NOT throw when node is instance of Slice by:
-            // - creating a Slice by invoking parseAggregate fallback? too heavy here.
-            // Instead, just verify that assertType was replaced (function identity changed),
-            // and that calling it with a "bad type" still throws, implying original is still used for others.
-            (0, vitest_1.expect)(c.assertType).toBeTypeOf('function');
-            (0, vitest_1.expect)(() => c.assertType({ __type: 'nope' })).toThrow(/bad type/);
-            uninstall();
-        });
-        (0, vitest_1.it)('Parser.parseAggregate fallback: returns nodes.Array([Slice]) when it detects a slice', () => {
-            // Minimal nodes
-            class Node {
-                static extend(_name, def) {
-                    const Parent = this;
-                    return class Slice extends Parent {
-                        static fields = def.fields;
-                        fields = def.fields;
-                        start;
-                        stop;
-                        step;
-                        parent(l, c, start, stop, step) {
-                            this.lineno = l;
-                            this.colno = c;
-                            this.start = start;
-                            this.stop = stop;
-                            this.step = step;
-                        }
-                        constructor(...args) {
-                            super();
-                            def.init.apply(this, args);
-                        }
-                    };
-                }
-            }
-            class Literal extends Node {
-                lineno;
-                colno;
-                value;
-                constructor(lineno, colno, value) {
-                    super();
-                    this.lineno = lineno;
-                    this.colno = colno;
-                    this.value = value;
-                }
-            }
-            class ArrayNode extends Node {
-                lineno;
-                colno;
-                children;
-                constructor(lineno, colno, children) {
-                    super();
-                    this.lineno = lineno;
-                    this.colno = colno;
-                    this.children = children;
-                }
-            }
-            // Token stream stub
-            const tokens = { index: 1, lineno: 0, colno: 1 };
-            // Parser stub: original parseAggregate always throws (to trigger fallback)
-            class Parser {
-                tokens = { ...tokens };
-                peeked = false;
-                parseAggregate() {
-                    throw new Error('orig parseAggregate fail');
-                }
-                peekToken() {
-                    // After reset, compat expects LEFT_BRACKET
-                    return { type: 'left-bracket', lineno: 0, colno: 0 };
-                }
-                nextToken() {
-                    return this.peekToken();
-                }
-                skip(type) {
-                    // simulate parsing: "[ : ]"
-                    // first iteration sees COLON then later RIGHT_BRACKET
-                    if (!this.__state)
-                        this.__state = 0;
-                    this.__state++;
-                    // state 1: after entering loop, first skip(COLON) true
-                    if (this.__state === 1 && type === 'colon')
-                        return true;
-                    // state 2: then skip(RIGHT_BRACKET) true to end
-                    if (this.__state === 2 && type === 'right-bracket')
-                        return true;
-                    return false;
-                }
-                parseExpression() {
-                    // should not be called for the ":"-only slice
-                    throw new Error('parseExpression should not run');
-                }
-                fail(msg) {
-                    throw new Error(msg);
-                }
-            }
-            class Compiler {
-            }
-            const env = makeThisEnv({
-                nodes: { Node, Literal, Array: ArrayNode },
-                compiler: { Compiler },
-                parser: { Parser },
-            });
-            const uninstall = globals_1.installCompat.call(env, { lib: env.lib });
-            const p = new env.parser.Parser();
-            const out = p.parseAggregate();
-            (0, vitest_1.expect)(out).toBeInstanceOf(env.nodes.Array);
-            (0, vitest_1.expect)(out.children).toHaveLength(1);
-            const sliceNode = out.children[0];
-            // sliceNode should have start/stop/step literals by default
-            (0, vitest_1.expect)(sliceNode.start.value).toBe(null);
-            (0, vitest_1.expect)(sliceNode.stop.value).toBe(null);
-            (0, vitest_1.expect)(sliceNode.step.value).toBe(1);
-            uninstall();
-        });
-    });
-});

package/dist/tests/interpreter.test.d.ts

@@ -1 +0,0 @@
-export {};