edgexpress 3.0.1 → 3.0.2

package/src/processor.js

@@ -0,0 +1,86 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Processor = void 0;
+/**
+ * Exposes the API to register a set of handlers to process the
+ * templates output at different stages
+ */
+class Processor {
+    #handlers = new Map();
+    /**
+     * Execute tag handler
+     */
+    executeTag(data) {
+        const handlers = this.#handlers.get('tag');
+        if (!handlers) {
+            return;
+        }
+        handlers.forEach((handler) => {
+            handler(data);
+        });
+    }
+    /**
+     * Execute raw handlers
+     */
+    executeRaw(data) {
+        const handlers = this.#handlers.get('raw');
+        if (!handlers) {
+            return data.raw;
+        }
+        handlers.forEach((handler) => {
+            const output = handler(data);
+            if (output !== undefined) {
+                data.raw = output;
+            }
+        });
+        return data.raw;
+    }
+    /**
+     * Execute compiled handlers
+     */
+    executeCompiled(data) {
+        const handlers = this.#handlers.get('compiled');
+        if (!handlers) {
+            return data.compiled;
+        }
+        handlers.forEach((handler) => {
+            const output = handler(data);
+            if (output !== undefined) {
+                data.compiled = output;
+            }
+        });
+        return data.compiled;
+    }
+    /**
+     * Execute output handlers
+     */
+    executeOutput(data) {
+        const handlers = this.#handlers.get('output');
+        if (!handlers) {
+            return data.output;
+        }
+        handlers.forEach((handler) => {
+            const output = handler(data);
+            if (output !== undefined) {
+                data.output = output;
+            }
+        });
+        return data.output;
+    }
+    process(event, handler) {
+        if (!this.#handlers.has(event)) {
+            this.#handlers.set(event, new Set());
+        }
+        this.#handlers.get(event).add(handler);
+        return this;
+    }
+}
+exports.Processor = Processor;

package/src/tags/assign.d.ts

@@ -0,0 +1,5 @@
+import { type TagContract } from '../types.js'
+/**
+ * The assign tag is used to re-assign value to an existing variable
+ */
+export declare const assignTag: TagContract

package/src/tags/assign.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignTag = void 0;
+const edge_parser_1 = require("edge-parser");
+const lodash_1 = __importDefault(require("@poppinss/utils/lodash"));
+const utils_js_1 = require("../utils.js");
+/**
+ * The assign tag is used to re-assign value to an existing variable
+ */
+exports.assignTag = {
+    block: false,
+    seekable: true,
+    tagName: 'assign',
+    noNewLine: true,
+    /**
+     * Compiles else block node to Javascript else statement
+     */
+    compile(parser, buffer, token) {
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        (0, utils_js_1.isSubsetOf)(parsed, [edge_parser_1.expressions.AssignmentExpression], () => {
+            throw (0, utils_js_1.unallowedExpression)(`Invalid expression for the @assign tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        buffer.writeExpression(parser.utils.stringify(parsed), token.filename, token.loc.start.line);
+    },
+    /**
+     * Add methods to the template for running the loop
+     */
+    boot(template) {
+        template.macro('setValue', lodash_1.default.set);
+    },
+};

package/src/tags/component.d.ts

@@ -0,0 +1,6 @@
+import type { TagContract } from '../types.js'
+/**
+ * The component tag implementation. It is one of the most complex tags and
+ * can be used as a reference for creating other tags.
+ */
+export declare const componentTag: TagContract

package/src/tags/component.js

@@ -0,0 +1,299 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentTag = void 0;
+const edge_error_1 = require("edge-error");
+const lexerUtils = __importStar(require("edge-lexer/utils"));
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * A list of allowed expressions for the component name
+ */
+const ALLOWED_EXPRESSION_FOR_COMPONENT_NAME = [
+    edge_parser_1.expressions.Identifier,
+    edge_parser_1.expressions.Literal,
+    edge_parser_1.expressions.LogicalExpression,
+    edge_parser_1.expressions.MemberExpression,
+    edge_parser_1.expressions.ConditionalExpression,
+    edge_parser_1.expressions.CallExpression,
+    edge_parser_1.expressions.TemplateLiteral,
+];
+/**
+ * Returns the component name and props by parsing the component jsArg expression
+ */
+function getComponentNameAndProps(expression, parser, filename) {
+    let name;
+    /**
+     * Use the first expression inside the sequence expression as the name
+     * of the component
+     */
+    if (expression.type === edge_parser_1.expressions.SequenceExpression) {
+        name = expression.expressions.shift();
+    }
+    else {
+        name = expression;
+    }
+    /**
+     * Ensure the component name is a literal value or an expression that
+     * outputs a literal value
+     */
+    (0, utils_js_1.isSubsetOf)(name, ALLOWED_EXPRESSION_FOR_COMPONENT_NAME, () => {
+        (0, utils_js_1.unallowedExpression)(`"${parser.utils.stringify(name)}" is not a valid argument for component name`, filename, parser.utils.getExpressionLoc(name));
+    });
+    /**
+     * Parse rest of sequence expressions as an objectified string.
+     */
+    if (expression.type === edge_parser_1.expressions.SequenceExpression) {
+        /**
+         * We only need to entertain the first expression of the sequence
+         * expression, as components allows a max of two arguments
+         */
+        const firstSequenceExpression = expression.expressions[0];
+        return [parser.utils.stringify(name), parser.utils.stringify(firstSequenceExpression)];
+    }
+    /**
+     * When top level expression is not a sequence expression, then we assume props
+     * as empty stringified object.
+     */
+    return [parser.utils.stringify(name), '{}'];
+}
+/**
+ * Parses the slot component to fetch it's name and props
+ */
+function getSlotNameAndProps(token, parser) {
+    /**
+     * We just generate the acorn AST only, since we don't want parser to transform
+     * ast to edge statements for a `@slot` tag.
+     */
+    const parsed = parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename).expression;
+    (0, utils_js_1.isSubsetOf)(parsed, [edge_parser_1.expressions.Literal, edge_parser_1.expressions.SequenceExpression], () => {
+        (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid argument type for the @slot tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+    });
+    /**
+     * Fetch the slot name
+     */
+    let name;
+    if (parsed.type === edge_parser_1.expressions.SequenceExpression) {
+        name = parsed.expressions[0];
+    }
+    else {
+        name = parsed;
+    }
+    /**
+     * Validating the slot name to be a literal value, since slot names cannot be dynamic
+     */
+    (0, utils_js_1.isSubsetOf)(name, [edge_parser_1.expressions.Literal], () => {
+        (0, utils_js_1.unallowedExpression)('slot name must be a valid string literal', token.filename, parser.utils.getExpressionLoc(name));
+    });
+    /**
+     * Return the slot name with empty props, when the expression is a literal
+     * value.
+     */
+    if (parsed.type === edge_parser_1.expressions.Literal) {
+        return [name.raw, null];
+    }
+    /**
+     * Make sure the sequence expression has only 2 arguments in it. Though it doesn't hurt
+     * the rendering of component, we must not run code with false expectations.
+     */
+    if (parsed.expressions.length > 2) {
+        throw new edge_error_1.EdgeError('maximum of 2 arguments are allowed for @slot tag', 'E_MAX_ARGUMENTS', {
+            line: parsed.loc.start.line,
+            col: parsed.loc.start.column,
+            filename: token.filename,
+        });
+    }
+    (0, utils_js_1.isSubsetOf)(parsed.expressions[1], [edge_parser_1.expressions.Identifier], () => {
+        (0, utils_js_1.unallowedExpression)(`"${parser.utils.stringify(parsed.expressions[1])}" is not valid prop identifier for @slot tag`, token.filename, parser.utils.getExpressionLoc(parsed.expressions[1]));
+    });
+    /**
+     * Returning the slot name and slot props name
+     */
+    return [name.raw, parsed.expressions[1].name];
+}
+/**
+ * The component tag implementation. It is one of the most complex tags and
+ * can be used as a reference for creating other tags.
+ */
+exports.componentTag = {
+    block: true,
+    seekable: true,
+    tagName: 'component',
+    compile(parser, buffer, token) {
+        const asyncKeyword = parser.asyncMode ? 'async ' : '';
+        const awaitKeyword = parser.asyncMode ? 'await ' : '';
+        const parsed = (0, utils_js_1.parseJsArg)(parser, token);
+        /**
+         * Check component jsProps for allowed expressions
+         */
+        (0, utils_js_1.isSubsetOf)(parsed, ALLOWED_EXPRESSION_FOR_COMPONENT_NAME.concat(edge_parser_1.expressions.SequenceExpression), () => {
+            (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not a valid argument type for the @component tag`, token.filename, parser.utils.getExpressionLoc(parsed));
+        });
+        /**
+         * Pulling the name and props for the component. The underlying method will
+         * ensure that the arguments passed to component tag are valid
+         */
+        const [name, props] = getComponentNameAndProps(parsed, parser, token.filename);
+        /**
+         * Loop over all the children and set them as part of slots. If no slot
+         * is defined, then the content will be part of the main slot
+         */
+        const slots = {};
+        /**
+         * Main slot collects everything that is out of the named slots
+         * inside a component
+         */
+        const mainSlot = {
+            outputVar: 'slot_main',
+            props: {},
+            buffer: buffer.create(token.filename, {
+                outputVar: 'slot_main',
+            }),
+            line: -1,
+            filename: token.filename,
+        };
+        let slotsCounter = 0;
+        /**
+         * Loop over all the component children
+         */
+        token.children.forEach((child) => {
+            /**
+             * If children is not a slot, then add it to the main slot
+             */
+            if (!lexerUtils.isTag(child, 'slot')) {
+                /**
+                 * Ignore first newline inside the unnamed main slot
+                 */
+                if (mainSlot.buffer.size === 0 && child.type === 'newline') {
+                    return;
+                }
+                parser.processToken(child, mainSlot.buffer);
+                return;
+            }
+            /**
+             * Fetch slot and props
+             */
+            const [slotName, slotProps] = getSlotNameAndProps(child, parser);
+            slotsCounter++;
+            /**
+             * Create a new slot with buffer to process the children
+             */
+            if (!slots[slotName]) {
+                /**
+                 * Slot buffer points to the component file name, since slots doesn't
+                 * have their own file names.
+                 */
+                slots[slotName] = {
+                    outputVar: `slot_${slotsCounter}`,
+                    buffer: buffer.create(token.filename, {
+                        outputVar: `slot_${slotsCounter}`,
+                    }),
+                    props: slotProps,
+                    line: -1,
+                    filename: token.filename,
+                };
+                /**
+                 * Only start the frame, when there are props in use for a given slot.
+                 */
+                if (slotProps) {
+                    parser.stack.defineScope();
+                    parser.stack.defineVariable(slotProps);
+                }
+            }
+            /**
+             * Self process the slot children.
+             */
+            child.children.forEach((grandChildren) => {
+                parser.processToken(grandChildren, slots[slotName].buffer);
+            });
+            /**
+             * Close the frame after process the slot children
+             */
+            if (slotProps) {
+                parser.stack.clearScope();
+            }
+        });
+        const obj = new utils_js_1.StringifiedObject();
+        /**
+         * Creating a shallow copy of context for the component slots and its children
+         */
+        obj.add('$context', 'Object.assign({}, $context)');
+        /**
+         * Add main slot to the stringified object, when main slot
+         * is not defined otherwise.
+         */
+        if (!slots['main']) {
+            if (mainSlot.buffer.size) {
+                mainSlot.buffer.wrap(`${asyncKeyword}function () { const $context = this.$context;`, '}');
+                obj.add('main', mainSlot.buffer.disableFileAndLineVariables().flush());
+            }
+            else {
+                obj.add('main', 'function () { return "" }');
+            }
+        }
+        /**
+         * We convert the slots to an objectified string, that is passed to `template.renderWithState`,
+         * which will pass it to the component as it's local state.
+         */
+        Object.keys(slots).forEach((slotName) => {
+            if (slots[slotName].buffer.size) {
+                const fnCall = slots[slotName].props
+                    ? `${asyncKeyword}function (${slots[slotName].props}) { const $context = this.$context;`
+                    : `${asyncKeyword}function () { const $context = this.$context;`;
+                slots[slotName].buffer.wrap(fnCall, '}');
+                obj.add(slotName, slots[slotName].buffer.disableFileAndLineVariables().flush());
+            }
+            else {
+                obj.add(slotName, 'function () { return "" }');
+            }
+        });
+        const caller = new utils_js_1.StringifiedObject();
+        caller.add('filename', '$filename');
+        caller.add('line', '$lineNumber');
+        caller.add('col', 0);
+        /**
+         * Write the line to render the component with it's own state
+         */
+        buffer.outputExpression(`${awaitKeyword}template.compileComponent(${name})(template, template.getComponentState(${props}, ${obj.flush()}, ${caller.flush()}), $context)`, token.filename, token.loc.start.line, false);
+    },
+};

package/src/tags/debugger.d.ts

@@ -0,0 +1,5 @@
+import type { TagContract } from '../types.js'
+/**
+ * Add debugger break point to the compiled template
+ */
+export declare const debuggerTag: TagContract

package/src/tags/debugger.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debuggerTag = void 0;
+/**
+ * Add debugger break point to the compiled template
+ */
+exports.debuggerTag = {
+    block: false,
+    seekable: false,
+    tagName: 'debugger',
+    noNewLine: true,
+    /**
+     * Compiles `@debugger` tags
+     */
+    compile(_, buffer, token) {
+        buffer.writeExpression('debugger', token.filename, token.loc.start.line);
+    },
+};

package/src/tags/each.d.ts

@@ -0,0 +1,20 @@
+import type lodash from '@poppinss/utils/lodash'
+import { type TagContract } from '../types.js'
+import { type asyncEach, type each } from '../utils.js'
+declare module '../template.js' {
+  interface Template {
+    loopAsync: typeof asyncEach
+    loop: typeof each
+    size: (typeof lodash)['size']
+  }
+}
+/**
+ * Each tag is used to run a foreach loop on arrays and even objects.
+ *
+ * ```edge
+ * @each((user, index) in users)
+ *   {{ user }} {{ index }}
+ * @endeach
+ * ```
+ */
+export declare const eachTag: TagContract

package/src/tags/each.js

@@ -0,0 +1,185 @@
+"use strict";
+/*
+ * edge.js
+ *
+ * (c) EdgeJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eachTag = void 0;
+const lodash_1 = __importDefault(require("@poppinss/utils/lodash"));
+const lexerUtils = __importStar(require("edge-lexer/utils"));
+const edge_parser_1 = require("edge-parser");
+const utils_js_1 = require("../utils.js");
+/**
+ * Returns the list to loop over for the each binary expression
+ */
+function getLoopList(rhsExpression, parser, filename) {
+    return parser.utils.stringify(parser.utils.transformAst(rhsExpression, filename, parser));
+}
+/**
+ * Returns loop item and the index for the each binary expression
+ */
+function getLoopItemAndIndex(lhsExpression, parser, filename) {
+    /**
+     * Ensure the LHS content inside `@each()` curly braces is a `SequenceExpression` or
+     * `Identifier`. Anything else is not allowed.
+     *
+     * For example:
+     *
+     * - In `@each(user in users)`, `user` is an indentifier
+     * - In `@each((user, index) in users)`, `(user, index)` is a sequence expression
+     */
+    (0, utils_js_1.isSubsetOf)(lhsExpression, [edge_parser_1.expressions.SequenceExpression, edge_parser_1.expressions.Identifier], () => {
+        (0, utils_js_1.unallowedExpression)(`invalid left hand side "${lhsExpression.type}" expression for the @each tag`, filename, parser.utils.getExpressionLoc(lhsExpression));
+    });
+    /**
+     * Return list index from the sequence expression
+     */
+    if (lhsExpression.type === 'SequenceExpression') {
+        /**
+         * First item of the sequence expression must be an idenifier
+         */
+        (0, utils_js_1.isSubsetOf)(lhsExpression.expressions[0], [edge_parser_1.expressions.Identifier], () => {
+            (0, utils_js_1.unallowedExpression)(`"${lhsExpression.expressions[0]}.type" is not allowed as value identifier for @each tag`, filename, parser.utils.getExpressionLoc(lhsExpression.expressions[0]));
+        });
+        /**
+         * Second item of the sequence expression must be an idenifier
+         */
+        (0, utils_js_1.isSubsetOf)(lhsExpression.expressions[1], [edge_parser_1.expressions.Identifier], () => {
+            (0, utils_js_1.unallowedExpression)(`"${lhsExpression.expressions[1]}.type" is not allowed as key identifier for @each tag`, filename, parser.utils.getExpressionLoc(lhsExpression.expressions[1]));
+        });
+        return [lhsExpression.expressions[0].name, lhsExpression.expressions[1].name];
+    }
+    /**
+     * There is no key, just the value
+     */
+    return [lhsExpression.name];
+}
+/**
+ * Each tag is used to run a foreach loop on arrays and even objects.
+ *
+ * ```edge
+ * @each((user, index) in users)
+ *   {{ user }} {{ index }}
+ * @endeach
+ * ```
+ */
+exports.eachTag = {
+    block: true,
+    seekable: true,
+    tagName: 'each',
+    /**
+     * Compile the template
+     */
+    compile(parser, buffer, token) {
+        const awaitKeyword = parser.asyncMode ? 'await ' : '';
+        const loopFunctionName = parser.asyncMode ? 'loopAsync' : 'loop';
+        const asyncKeyword = parser.asyncMode ? 'async ' : '';
+        /**
+         * We just generate the AST and do not transform it, since the transform
+         * function attempts to resolve identifiers and we don't want that
+         */
+        const { expression } = parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename);
+        /**
+         * Each tag only accepts the binary expression or sequence expression. ie `user in users`
+         */
+        (0, utils_js_1.isSubsetOf)(expression, [edge_parser_1.expressions.BinaryExpression], () => {
+            (0, utils_js_1.unallowedExpression)(`"${token.properties.jsArg}" is not valid expression for the @each tag`, token.filename, parser.utils.getExpressionLoc(expression));
+        });
+        /**
+         * Finding if an else child exists inside the each tag
+         */
+        const elseIndex = token.children.findIndex((child) => lexerUtils.isTag(child, 'else'));
+        const elseChildren = elseIndex > -1 ? token.children.splice(elseIndex) : [];
+        /**
+         * Fetching the item,index and list for the each loop
+         */
+        const list = getLoopList(expression.right, parser, token.filename);
+        const [item, index] = getLoopItemAndIndex(expression.left, parser, token.filename);
+        /**
+         * If there is an else statement, then wrap the loop inside the `if` statement first
+         */
+        if (elseIndex > -1) {
+            buffer.writeStatement(`if(template.size(${list})) {`, token.filename, token.loc.start.line);
+        }
+        /**
+         * Write the loop statement to the template
+         */
+        const loopCallbackArgs = (index ? [item, index] : [item]).join(',');
+        buffer.writeStatement(`${awaitKeyword}template.${loopFunctionName}(${list}, ${asyncKeyword}function (${loopCallbackArgs}) {`, token.filename, token.loc.start.line);
+        /**
+         * Start a new parser scope. So that all variable resolutions for the `item`
+         * are pointing to the local variable and not the template `state`.
+         */
+        parser.stack.defineScope();
+        parser.stack.defineVariable(item);
+        index && parser.stack.defineVariable(index);
+        /**
+         * Process all children
+         */
+        token.children.forEach((child) => parser.processToken(child, buffer));
+        /**
+         * Clear scope
+         */
+        parser.stack.clearScope();
+        /**
+         * Close each loop
+         */
+        buffer.writeExpression('})', token.filename, -1);
+        /**
+         * If there is an else statement, then process
+         * else childs and close the if block
+         */
+        if (elseIndex > -1) {
+            elseChildren.forEach((elseChild) => parser.processToken(elseChild, buffer));
+            buffer.writeStatement('}', token.filename, -1);
+        }
+    },
+    /**
+     * Add methods to the template for running the loop
+     */
+    boot(template) {
+        template.macro('loopAsync', utils_js_1.asyncEach);
+        template.macro('loop', utils_js_1.each);
+        template.macro('size', lodash_1.default.size);
+    },
+};

package/src/tags/else.d.ts

@@ -0,0 +1,2 @@
+import { type TagContract } from '../types.js'
+export declare const elseTag: TagContract