@samuelbines/nunjucks 0.0.3

package/dist/src/precompile.d.ts

@@ -0,0 +1,15 @@
+import { Environment, Template } from './environment';
+type IPrecompileOpts = {
+    isString?: boolean;
+    isFunction?: boolean;
+    force?: boolean;
+    env?: Environment;
+    wrapper?: (templates: Template[], opts?: {
+        isFunction: boolean;
+    }) => string;
+    name?: string;
+    include?: string[];
+    exclude?: string[];
+};
+export declare function precompile(input: any, opts?: IPrecompileOpts): string;
+export {};

package/dist/src/precompile.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.precompile = precompile;
+// DONE: Sat Jan 3
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const lib_1 = require("./lib");
+const compiler_1 = require("./compiler");
+const environment_1 = require("./environment");
+const globals_1 = require("./globals");
+// Default
+const initPrecompileOpts = {
+    isString: true,
+    isFunction: false,
+    force: false,
+    wrapper: globals_1.precompileGlobal,
+    env: new environment_1.Environment(),
+    exclude: [],
+    include: [],
+};
+function match(filename, patterns) {
+    if (!Array.isArray(patterns)) {
+        return false;
+    }
+    return patterns.some((pattern) => filename.match(pattern));
+}
+function _precompile(src, name, env = new environment_1.Environment()) {
+    const asyncFilters = env.asyncFilters;
+    const extensions = env.extensionsList;
+    let template;
+    name = name.replace(/\\/g, '/');
+    try {
+        template = (0, compiler_1.compile)(src, asyncFilters, extensions, name, {
+            throwOnUndefined: env.throwOnUndefined,
+        });
+    }
+    catch (err) {
+        lib_1.p.err('_precompile :', err);
+        throw (0, lib_1._prettifyError)(name, false, (0, lib_1.TemplateError)(err));
+    }
+    return {
+        name: name,
+        template: template,
+    };
+}
+function precompileString(str, opts) {
+    const _out = {
+        ...initPrecompileOpts,
+        ...opts,
+    };
+    if (!_precompile.name) {
+        throw new Error('the "name" option is required when compiling a string');
+    }
+    // @ts-ignore TODO: fix this
+    return _out?.wrapper([_precompile(str, opts.name, opts.env)], opts);
+}
+function precompile(input, opts) {
+    const env = opts?.env || new environment_1.Environment();
+    const wrapper = opts?.wrapper || globals_1.precompileGlobal;
+    if (opts?.isString) {
+        return precompileString(input, opts);
+    }
+    const pathStats = fs_1.default.statSync(input);
+    const precompiled = [];
+    const templates = [];
+    function addTemplates(dir) {
+        fs_1.default.readdirSync(dir).forEach((file) => {
+            const filepath = path_1.default.join(dir, file);
+            let subpath = filepath.substr(path_1.default.join(input, '/')?.length);
+            const stat = fs_1.default.statSync(filepath);
+            if (stat && stat.isDirectory()) {
+                subpath += '/';
+                if (!match(subpath, opts?.exclude)) {
+                    addTemplates(filepath);
+                }
+            }
+            else if (match(subpath, opts?.include)) {
+                templates?.push(filepath);
+            }
+        });
+    }
+    if (pathStats.isFile()) {
+        precompiled?.push(_precompile(fs_1.default.readFileSync(input, 'utf-8'), opts.name || input, env));
+    }
+    else if (pathStats.isDirectory()) {
+        addTemplates(input);
+        for (let i = 0; i < templates?.length; i++) {
+            const name = templates[i].replace(path_1.default.join(input, '/'), '');
+            try {
+                precompiled?.push(_precompile(fs_1.default.readFileSync(templates[i], 'utf-8'), name, env));
+            }
+            catch (e) {
+                if (opts.force) {
+                    // Don't stop generating the output if we're
+                    // forcing compilation.
+                    console.error(e); // eslint-disable-line no-console
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    }
+    return wrapper(precompiled, opts);
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,33 @@
+import { Context } from './environment';
+import { EscapeChar } from './lib';
+import { Callback } from './types';
+export declare class Frame {
+    parent: Frame | null;
+    isolateWrites: boolean;
+    topLevel: boolean;
+    variables: Record<string, any>;
+    constructor(parent?: Frame | null, isolateWrites?: boolean);
+    set(name: string, val: any, resolveUp?: boolean): void;
+    get(name: string): any;
+    lookup(name: string): Frame;
+    resolve(name: string, forWrite: boolean): Frame | null | undefined;
+    push(isolateWrites?: boolean): Frame;
+    pop(): Frame;
+}
+export declare function makeMacro(argNames: string[], kwargNames: string[], func: Function): (this: any, ...macroArgs: any[]) => any;
+export declare function makeKeywordArgs(obj: any): any;
+export declare const isKeywordArgs: (obj: object) => any;
+export declare function getKeywordArgs(args: any[]): any;
+export declare function numArgs(args: any[]): number;
+export declare function copySafeness(dest: any, target: string): string;
+export declare function markSafe(val: any): any;
+export declare function suppressValue(val: EscapeChar, autoescape: boolean): string;
+export declare function ensureDefined(val: any, lineno?: number, colno?: number): any;
+export declare function memberLookup(obj: Record<string, any>, val: string, own?: boolean): any;
+export declare function callWrap(obj: any, name: string, context: Context, args: any[]): any;
+export declare function contextOrFrameLookup(context: Context, frame: Frame, name: string): any;
+export declare function handleError(error: any, lineno?: number, colno?: number): any;
+export declare function asyncEach(arr: any[], dimen: number, iter: Function, cb: Callback): void;
+export declare function asyncAll(this: any, arr: any[], dimen: number, func: Function, cb: Callback): void;
+export declare function fromIterator(arr: any[]): any[];
+export declare function inOperator(key: string, val: any): boolean;

package/dist/src/runtime.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKeywordArgs = exports.Frame = void 0;
+exports.makeMacro = makeMacro;
+exports.makeKeywordArgs = makeKeywordArgs;
+exports.getKeywordArgs = getKeywordArgs;
+exports.numArgs = numArgs;
+exports.copySafeness = copySafeness;
+exports.markSafe = markSafe;
+exports.suppressValue = suppressValue;
+exports.ensureDefined = ensureDefined;
+exports.memberLookup = memberLookup;
+exports.callWrap = callWrap;
+exports.contextOrFrameLookup = contextOrFrameLookup;
+exports.handleError = handleError;
+exports.asyncEach = asyncEach;
+exports.asyncAll = asyncAll;
+exports.fromIterator = fromIterator;
+exports.inOperator = inOperator;
+const lib_1 = require("./lib");
+const supportsIterators = typeof Symbol === 'function' &&
+    Symbol.iterator &&
+    typeof Array.from === 'function';
+// Frames keep track of scoping both at compile-time and run-time so
+// we know how to access variables. Block tags can introduce special
+// variables, for example.
+class Frame {
+    parent;
+    isolateWrites;
+    topLevel = true;
+    variables;
+    constructor(parent = null, isolateWrites = false) {
+        this.parent = parent;
+        this.isolateWrites = isolateWrites;
+        this.variables = Object.create(null);
+        this.parent = parent;
+        this.topLevel = parent === null;
+        // if this is true, writes (set) should never propagate upwards past
+        // this frame to its parent (though reads may).
+        this.isolateWrites = isolateWrites;
+    }
+    set(name, val, resolveUp = false) {
+        // Allow variables with dots by automatically creating the
+        // nested structure
+        let parts = name.split('.');
+        let obj = this.variables;
+        let frame = this;
+        if (resolveUp) {
+            if (frame == this.resolve(parts[0], true)) {
+                frame.set(name, val);
+                return;
+            }
+        }
+        for (let i = 0; i < parts?.length - 1; i++) {
+            const id = parts[i];
+            if (!obj[id]) {
+                obj[id] = {};
+            }
+            obj = obj[id];
+        }
+        obj[parts[parts?.length - 1]] = val;
+    }
+    get(name) {
+        let val = this.variables[name];
+        if (val !== undefined) {
+            return val;
+        }
+        return null;
+    }
+    lookup(name) {
+        let pt = this.parent;
+        let val = this.variables[name];
+        lib_1.p.debug(pt, val, name, this.variables);
+        if (val !== undefined) {
+            return val;
+        }
+        return pt && pt.lookup(name);
+    }
+    resolve(name, forWrite) {
+        const p = forWrite && this.isolateWrites ? undefined : this.parent;
+        const val = this.variables[name];
+        if (!val) {
+            return this;
+        }
+        return p && p.resolve(name, forWrite);
+    }
+    push(isolateWrites = false) {
+        return new Frame(this, isolateWrites);
+    }
+    pop() {
+        return this.parent;
+    }
+}
+exports.Frame = Frame;
+function makeMacro(argNames, kwargNames, func) {
+    return function macro(...macroArgs) {
+        var argCount = numArgs(macroArgs);
+        var args;
+        var kwargs = getKeywordArgs(macroArgs);
+        if (argCount > argNames?.length) {
+            args = macroArgs.slice(0, argNames?.length);
+            // Positional arguments that should be passed in as
+            // keyword arguments (essentially default values)
+            macroArgs.slice(args?.length, argCount).forEach((val, i) => {
+                if (i < kwargNames?.length) {
+                    kwargs[kwargNames[i]] = val;
+                }
+            });
+            args?.push(kwargs);
+        }
+        else if (argCount < argNames?.length) {
+            args = macroArgs.slice(0, argCount);
+            for (let i = argCount; i < argNames?.length; i++) {
+                const arg = argNames[i];
+                // Keyword arguments that should be passed as
+                // positional arguments, i.e. the caller explicitly
+                // used the name of a positional arg
+                args?.push(kwargs[arg]);
+                delete kwargs[arg];
+            }
+            args?.push(kwargs);
+        }
+        else {
+            args = macroArgs;
+        }
+        return func.apply(this, args);
+    };
+}
+function makeKeywordArgs(obj) {
+    obj.__keywords = true;
+    return obj;
+}
+const isKeywordArgs = (obj) => obj && Object.prototype.hasOwnProperty.call(obj, '__keywords');
+exports.isKeywordArgs = isKeywordArgs;
+function getKeywordArgs(args) {
+    let len = args?.length;
+    if (len) {
+        const lastArg = args[len - 1];
+        if ((0, exports.isKeywordArgs)(lastArg)) {
+            return lastArg;
+        }
+    }
+    return {};
+}
+function numArgs(args) {
+    const len = args?.length;
+    if (len === 0)
+        return 0;
+    const lastArg = args[len - 1];
+    if ((0, exports.isKeywordArgs)(lastArg)) {
+        return len - 1;
+    }
+    return len;
+}
+function copySafeness(dest, target) {
+    if ((0, lib_1.isString)(dest)) {
+        return target;
+    }
+    return target.toString();
+}
+function markSafe(val) {
+    const type = typeof val;
+    if (type === 'string') {
+        return val.toString();
+    }
+    else if (type !== 'function') {
+        return val;
+    }
+    else {
+        return function wrapSafe(args) {
+            var ret = val.apply(this, arguments);
+            if (typeof ret === 'string') {
+                return ret.toString();
+            }
+            return ret;
+        };
+    }
+}
+function suppressValue(val, autoescape) {
+    if (autoescape) {
+        return (0, lib_1.escape)(val);
+    }
+    return val;
+}
+function ensureDefined(val, lineno = 0, colno = 0) {
+    if (val === null || val === undefined) {
+        lib_1.p.err('attempted to output null or undefined value');
+        throw (0, lib_1.TemplateError)('attempted to output null or undefined value', lineno + 1, colno + 1);
+    }
+    return val;
+}
+function memberLookup(obj, val, own = false) {
+    if (!obj)
+        return undefined;
+    if (typeof obj[val] === 'function') {
+        return (...args) => obj[val].apply(obj, args);
+    }
+    return obj[val];
+}
+function callWrap(obj, name, context, args) {
+    if (!obj) {
+        throw new Error('Unable to call `' + name + '`, which is undefined or falsey');
+    }
+    else if (typeof obj !== 'function') {
+        throw new Error('Unable to call `' + name + '`, which is not a function');
+    }
+    return obj.apply(context, args);
+}
+function contextOrFrameLookup(context, frame, name) {
+    let val = frame.lookup(name);
+    return val ? val : context.lookup(name);
+}
+function handleError(error, lineno = 0, colno = 0) {
+    if (error?.lineno)
+        return error;
+    return (0, lib_1.TemplateError)(error, lineno, colno);
+}
+function asyncEach(arr, dimen, iter, cb) {
+    if (Array.isArray(arr)) {
+        const len = arr?.length;
+        // TODO: confirm types here
+        (0, lib_1.asyncIter)(arr, function iterCallback(item, i, next) {
+            switch (dimen) {
+                case 1:
+                    iter(item, i, len, next);
+                    break;
+                case 2:
+                    iter(item[0], item[1], i, len, next);
+                    break;
+                case 3:
+                    iter(item[0], item[1], item[2], i, len, next);
+                    break;
+                default:
+                    item?.push(i, len, next);
+                    iter.apply(this, item);
+            }
+        }, cb);
+    }
+    else {
+        (0, lib_1.asyncFor)(arr, function iterCallback(key, val, i, len, next) {
+            iter(key, val, i, len, next);
+        }, cb);
+    }
+}
+function asyncAll(arr, dimen, func, cb) {
+    let finished = 0;
+    let len = 0;
+    let outputArr = [];
+    function done(i, output) {
+        finished++;
+        outputArr[i] = output;
+        if (finished === len) {
+            cb(null, outputArr.join(''));
+        }
+    }
+    if (Array.isArray(arr)) {
+        len = arr?.length;
+        outputArr = new Array(len);
+        if (len === 0) {
+            cb(null, '');
+        }
+        else {
+            for (let i = 0; i < arr?.length; i++) {
+                const item = arr[i];
+                switch (dimen) {
+                    case 1:
+                        func(item, i, len, done);
+                        break;
+                    case 2:
+                        func(item[0], item[1], i, len, done);
+                        break;
+                    case 3:
+                        func(item[0], item[1], item[2], i, len, done);
+                        break;
+                    default:
+                        item?.push(i, len, done);
+                        func.apply(this, item);
+                }
+            }
+        }
+    }
+    else {
+        const keys = Object.keys(arr || {});
+        len = keys?.length;
+        outputArr = new Array(len);
+        if (len === 0) {
+            cb(null, '');
+        }
+        else {
+            for (let i = 0; i < keys?.length; i++) {
+                const k = keys[i];
+                func(k, arr[k], i, len, done);
+            }
+        }
+    }
+}
+function fromIterator(arr) {
+    if (typeof arr !== 'object' || arr === null || Array.isArray(arr)) {
+        return arr;
+    }
+    else if (supportsIterators && Symbol.iterator in arr) {
+        return Array.from(arr);
+    }
+    return arr;
+}
+function inOperator(key, val) {
+    if (Array.isArray(val) || (0, lib_1.isString)(val)) {
+        return val.indexOf(key) !== -1;
+    }
+    else if ((0, lib_1.isObject)(val)) {
+        return key in val;
+    }
+    throw new Error('Cannot use "in" operator to search for "' + key + '" in unexpected types.');
+}

package/dist/src/transformer.d.ts

@@ -0,0 +1,3 @@
+import { Node, Block } from './nodes';
+export declare function collectBlocks(root: Node): Block[];
+export declare function transform(ast: Node, asyncFilters?: readonly string[]): Node;

package/dist/src/transformer.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectBlocks = collectBlocks;
+exports.transform = transform;
+// DONE: Sun 4th Jan 2026
+const nodes_1 = require("./nodes");
+let sym = 0;
+const gensym = () => 'hole_' + sym++;
+function mapCOW(arr, func) {
+    let res = null;
+    for (let i = 0; i < arr?.length; i++) {
+        const item = func(arr[i]);
+        if (item !== arr[i]) {
+            if (!res) {
+                res = arr.slice();
+            }
+            res[i] = item;
+        }
+    }
+    return res || arr;
+}
+function walk(ast, func, depthFirst = false) {
+    if (!(ast instanceof nodes_1.Node))
+        return ast;
+    let node = ast;
+    if (!depthFirst) {
+        const nodeT = func(node);
+        if (nodeT && nodeT !== node) {
+            return nodeT;
+        }
+    }
+    if (node instanceof nodes_1.NodeList) {
+        const children = mapCOW(node.children, (child) => walk(child, func, depthFirst));
+        if (children !== node.children) {
+            node = new ((0, nodes_1.NodeCreator)(node?.typename))(node.lineno, node?.colno, children);
+        }
+    }
+    else if (node instanceof nodes_1.CallExtension) {
+        const args = walk(node.args, func, depthFirst);
+        const contentArgs = mapCOW(node.contentArgs, (node) => walk(node, func, depthFirst));
+        if (args !== node.args || contentArgs !== node.contentArgs) {
+            node = new ((0, nodes_1.NodeCreator)(node?.typename))(node.lineno, node?.colno, node.extname, node.prop, args, contentArgs);
+        }
+    }
+    else {
+        const props = node.fields.map((field) => node[field]);
+        const propsT = mapCOW(props, (prop) => walk(prop, func, depthFirst));
+        if (propsT !== props) {
+            node = new ((0, nodes_1.NodeCreator)(node?.typename))(node.lineno, node?.colno);
+            propsT.forEach((prop, i) => {
+                node[node.fields[i]] = prop;
+            });
+        }
+    }
+    return depthFirst ? func(node) || node : node;
+}
+function collectBlocks(root) {
+    const blocks = [];
+    walk(root, (n) => {
+        if (n instanceof nodes_1.Block)
+            blocks.push(n);
+    });
+    return blocks;
+}
+function liftFilters(ast, asyncFilters = []) {
+    function _liftFilters(node, asyncFilters, key) {
+        const children = [];
+        const walked = walk(key ? node[key] : node, (descNode) => {
+            let symbol;
+            if (descNode instanceof nodes_1.Block) {
+                return descNode;
+            }
+            const isAsyncFilter = descNode instanceof nodes_1.Filter &&
+                asyncFilters.indexOf(descNode.name.value) !== -1;
+            if (isAsyncFilter || descNode instanceof nodes_1.CallExtensionAsync) {
+                symbol = new nodes_1.Symbol(descNode.lineno, descNode?.colno, gensym());
+                children?.push(new nodes_1.FilterAsync(descNode.lineno, descNode?.colno, descNode.name, descNode.args, symbol));
+            }
+            return symbol;
+        }, true);
+        if (key) {
+            node[key] = walked;
+        }
+        else {
+            node = walked;
+        }
+        if (children?.length) {
+            children?.push(node);
+            return new nodes_1.NodeList(node.lineno, node?.colno, children);
+        }
+        return node;
+    }
+    return walk(ast, (node) => {
+        if (node instanceof nodes_1.Output) {
+            return _liftFilters(node, asyncFilters);
+        }
+        else if (node instanceof Set) {
+            return _liftFilters(node, asyncFilters, 'value');
+        }
+        else if (node instanceof nodes_1.For) {
+            return _liftFilters(node, asyncFilters, 'arr');
+        }
+        else if (node instanceof nodes_1.If) {
+            return _liftFilters(node, asyncFilters, 'cond');
+        }
+        else if (node instanceof nodes_1.CallExtension) {
+            return _liftFilters(node, asyncFilters, 'args');
+        }
+        return undefined;
+    }, true);
+}
+function liftSuper(ast) {
+    return walk(ast, (block) => {
+        if (!(block instanceof nodes_1.Block))
+            return;
+        let hasSuper = false;
+        const symbol = gensym();
+        block.body = walk(block.body, (node) => {
+            if (node instanceof nodes_1.FunCall && node.name?.typename === 'Super') {
+                hasSuper = true;
+                return new nodes_1.Symbol(node.lineno, node?.colno, symbol);
+            }
+        });
+        if (hasSuper) {
+            block.body.children.unshift(new nodes_1.Super(0, 0, block.name, new nodes_1.Symbol(0, 0, symbol)));
+        }
+    });
+    return ast;
+}
+function convertStatements(ast) {
+    return walk(ast, (node) => {
+        if (!(node instanceof nodes_1.If) && !(node instanceof nodes_1.For)) {
+            return undefined;
+        }
+        let isAsync = false;
+        walk(node, (child) => {
+            if (child instanceof nodes_1.FilterAsync ||
+                child instanceof nodes_1.IfAsync ||
+                child instanceof nodes_1.AsyncEach ||
+                child instanceof nodes_1.AsyncAll ||
+                child instanceof nodes_1.CallExtensionAsync) {
+                isAsync = true;
+                // Stop iterating by returning the node
+                return child;
+            }
+            return undefined;
+        });
+        if (isAsync) {
+            if (node instanceof nodes_1.If) {
+                return new nodes_1.IfAsync(node.lineno, node?.colno, node.cond, node.body, node.else_);
+            }
+            else if (node instanceof nodes_1.For && !(node instanceof nodes_1.AsyncAll)) {
+                return new nodes_1.AsyncEach(node.lineno, node?.colno, node.arr, node.name, node.body, node.else_);
+            }
+        }
+        return undefined;
+    }, true);
+}
+function transform(ast, asyncFilters = []) {
+    return convertStatements(liftSuper(liftFilters(ast, asyncFilters)));
+}

package/dist/src/types.d.ts

@@ -0,0 +1,27 @@
+export type Callback<E = unknown, R = unknown> = (err?: E | null, res?: R) => void;
+type TokenType = string;
+export interface Token {
+    type: TokenType;
+    value?: any;
+    lineno?: number;
+    colno?: number;
+}
+export interface TokenStream {
+    nextToken(): Token | null;
+    _extractRegex(re: RegExp): RegExpExecArray | null;
+    backN(n: number): void;
+    tags: {
+        VARIABLE_START: string;
+        VARIABLE_END: string;
+        BLOCK_START: string;
+        BLOCK_END: string;
+        COMMENT_START: string;
+        COMMENT_END: string;
+    };
+}
+export interface ParserExtension<P> {
+    tags?: string[];
+    parse(parser: P, nodes: typeof import('./nodes'), lexer: typeof import('./lexer')): Node;
+    preprocess?: (src: string) => string;
+}
+export {};

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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