ember-legacy-class-transform/.node_modules.ember-try/@glimmer/runtime/dist/modules/es5/lib/syntax/functions.js

The default blueprint for ember-cli addons.

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

import { map } from '@glimmer/reference';
import { assert, dict, EMPTY_ARRAY } from '@glimmer/util';
import * as WireFormat from '@glimmer/wire-format';
import OpcodeBuilder from '../compiled/opcodes/builder';
import { Register } from '../opcodes';
import * as ClientSide from '../syntax/client-side';
import RawInlineBlock from './raw-block';
var Ops = WireFormat.Ops;
export var ATTRS_BLOCK = '&attrs';

var Compilers = function () {
    function Compilers() {
        var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;

        _classCallCheck(this, Compilers);

        this.offset = offset;
        this.names = dict();
        this.funcs = [];
    }

    Compilers.prototype.add = function add(name, func) {
        this.funcs.push(func);
        this.names[name] = this.funcs.length - 1;
    };

    Compilers.prototype.compile = function compile(sexp, builder) {
        var name = sexp[this.offset];
        var index = this.names[name];
        var func = this.funcs[index];
        assert(!!func, 'expected an implementation for ' + (this.offset === 0 ? Ops[sexp[0]] : ClientSide.Ops[sexp[1]]));
        func(sexp, builder);
    };

    return Compilers;
}();

var STATEMENTS = new Compilers();
var CLIENT_SIDE = new Compilers(1);
STATEMENTS.add(Ops.Text, function (sexp, builder) {
    builder.text(sexp[1]);
});
STATEMENTS.add(Ops.Comment, function (sexp, builder) {
    builder.comment(sexp[1]);
});
STATEMENTS.add(Ops.CloseElement, function (_sexp, builder) {
    builder.closeElement();
});
STATEMENTS.add(Ops.FlushElement, function (_sexp, builder) {
    builder.flushElement();
});
STATEMENTS.add(Ops.Modifier, function (sexp, builder) {
    var env = builder.env,
        meta = builder.meta;
    var name = sexp[1],
        params = sexp[2],
        hash = sexp[3];

    if (env.hasModifier(name, meta.templateMeta)) {
        builder.compileArgs(params, hash, true);
        builder.modifier(env.lookupModifier(name, meta.templateMeta));
    } else {
        throw new Error('Compile Error ' + name + ' is not a modifier: Helpers may not be used in the element form.');
    }
});
STATEMENTS.add(Ops.StaticAttr, function (sexp, builder) {
    var name = sexp[1],
        value = sexp[2],
        namespace = sexp[3];

    builder.staticAttr(name, namespace, value);
});
STATEMENTS.add(Ops.DynamicAttr, function (sexp, builder) {
    dynamicAttr(sexp, false, builder);
});
STATEMENTS.add(Ops.TrustingAttr, function (sexp, builder) {
    dynamicAttr(sexp, true, builder);
});
function dynamicAttr(sexp, trusting, builder) {
    var name = sexp[1],
        value = sexp[2],
        namespace = sexp[3];

    expr(value, builder);
    if (namespace) {
        builder.dynamicAttrNS(name, namespace, trusting);
    } else {
        builder.dynamicAttr(name, trusting);
    }
}
STATEMENTS.add(Ops.OpenElement, function (sexp, builder) {
    builder.openPrimitiveElement(sexp[1]);
});
CLIENT_SIDE.add(ClientSide.Ops.OpenComponentElement, function (sexp, builder) {
    builder.pushComponentOperations();
    builder.openElementWithOperations(sexp[2]);
});
CLIENT_SIDE.add(ClientSide.Ops.DidCreateElement, function (_sexp, builder) {
    builder.didCreateElement(Register.s0);
});
CLIENT_SIDE.add(ClientSide.Ops.DidRenderLayout, function (_sexp, builder) {
    builder.didRenderLayout(Register.s0);
});
STATEMENTS.add(Ops.Append, function (sexp, builder) {
    var value = sexp[1],
        trusting = sexp[2];

    var _builder$env$macros = builder.env.macros(),
        inlines = _builder$env$macros.inlines;

    var returned = inlines.compile(sexp, builder) || value;
    if (returned === true) return;
    var isGet = E.isGet(value);
    var isMaybeLocal = E.isMaybeLocal(value);
    if (trusting) {
        builder.guardedAppend(value, true);
    } else {
        if (isGet || isMaybeLocal) {
            builder.guardedAppend(value, false);
        } else {
            expr(value, builder);
            builder.cautiousAppend();
        }
    }
});
STATEMENTS.add(Ops.Block, function (sexp, builder) {
    var name = sexp[1],
        params = sexp[2],
        hash = sexp[3],
        _template = sexp[4],
        _inverse = sexp[5];

    var template = builder.template(_template);
    var inverse = builder.template(_inverse);
    var templateBlock = template && template.scan();
    var inverseBlock = inverse && inverse.scan();

    var _builder$env$macros2 = builder.env.macros(),
        blocks = _builder$env$macros2.blocks;

    blocks.compile(name, params, hash, templateBlock, inverseBlock, builder);
});
export var InvokeDynamicLayout = function () {
    function InvokeDynamicLayout(attrs) {
        _classCallCheck(this, InvokeDynamicLayout);

        this.attrs = attrs;
    }

    InvokeDynamicLayout.prototype.invoke = function invoke(vm, layout) {
        var _layout$symbolTable = layout.symbolTable,
            symbols = _layout$symbolTable.symbols,
            hasEval = _layout$symbolTable.hasEval;

        var stack = vm.stack;
        var scope = vm.pushRootScope(symbols.length + 1, true);
        scope.bindSelf(stack.pop());
        scope.bindBlock(symbols.indexOf(ATTRS_BLOCK) + 1, this.attrs);
        var lookup = null;
        var $eval = -1;
        if (hasEval) {
            $eval = symbols.indexOf('$eval') + 1;
            lookup = dict();
        }
        var callerNames = stack.pop();
        for (var i = callerNames.length - 1; i >= 0; i--) {
            var symbol = symbols.indexOf(callerNames[i]);
            var value = stack.pop();
            if (symbol !== -1) scope.bindSymbol(symbol + 1, value);
            if (hasEval) lookup[callerNames[i]] = value;
        }
        var numPositionalArgs = stack.pop();
        assert(typeof numPositionalArgs === 'number', '[BUG] Incorrect value of positional argument count found during invoke-dynamic-layout.');
        // Currently we don't support accessing positional args in templates, so just throw them away
        stack.pop(numPositionalArgs);
        var inverseSymbol = symbols.indexOf('&inverse');
        var inverse = stack.pop();
        if (inverseSymbol !== -1) {
            scope.bindBlock(inverseSymbol + 1, inverse);
        }
        if (lookup) lookup['&inverse'] = inverse;
        var defaultSymbol = symbols.indexOf('&default');
        var defaultBlock = stack.pop();
        if (defaultSymbol !== -1) {
            scope.bindBlock(defaultSymbol + 1, defaultBlock);
        }
        if (lookup) lookup['&default'] = defaultBlock;
        if (lookup) scope.bindEvalScope(lookup);
        vm.pushFrame();
        vm.call(layout.handle);
    };

    InvokeDynamicLayout.prototype.toJSON = function toJSON() {
        return { GlimmerDebug: '<invoke-dynamic-layout>' };
    };

    return InvokeDynamicLayout;
}();
STATEMENTS.add(Ops.Component, function (sexp, builder) {
    var tag = sexp[1],
        attrs = sexp[2],
        args = sexp[3],
        block = sexp[4];

    if (builder.env.hasComponentDefinition(tag, builder.meta.templateMeta)) {
        var child = builder.template(block);
        var attrsBlock = new RawInlineBlock(builder.meta, attrs, EMPTY_ARRAY);
        var definition = builder.env.getComponentDefinition(tag, builder.meta.templateMeta);
        builder.pushComponentManager(definition);
        builder.invokeComponent(attrsBlock, null, args, child && child.scan());
    } else if (block && block.parameters.length) {
        throw new Error('Compile Error: Cannot find component ' + tag);
    } else {
        builder.openPrimitiveElement(tag);
        for (var i = 0; i < attrs.length; i++) {
            STATEMENTS.compile(attrs[i], builder);
        }
        builder.flushElement();
        if (block) {
            var stmts = block.statements;
            for (var _i = 0; _i < stmts.length; _i++) {
                STATEMENTS.compile(stmts[_i], builder);
            }
        }
        builder.closeElement();
    }
});
export var PartialInvoker = function () {
    function PartialInvoker(outerSymbols, evalInfo) {
        _classCallCheck(this, PartialInvoker);

        this.outerSymbols = outerSymbols;
        this.evalInfo = evalInfo;
    }

    PartialInvoker.prototype.invoke = function invoke(vm, _partial) {
        var partial = _partial;
        var partialSymbols = partial.symbolTable.symbols;
        var outerScope = vm.scope();
        var partialScope = vm.pushRootScope(partialSymbols.length, false);
        partialScope.bindCallerScope(outerScope.getCallerScope());
        partialScope.bindEvalScope(outerScope.getEvalScope());
        partialScope.bindSelf(outerScope.getSelf());
        var evalInfo = this.evalInfo,
            outerSymbols = this.outerSymbols;

        var locals = dict();
        for (var i = 0; i < evalInfo.length; i++) {
            var slot = evalInfo[i];
            var name = outerSymbols[slot - 1];
            var ref = outerScope.getSymbol(slot);
            locals[name] = ref;
        }
        var evalScope = outerScope.getEvalScope();
        for (var _i2 = 0; _i2 < partialSymbols.length; _i2++) {
            var _name = partialSymbols[_i2];
            var symbol = _i2 + 1;
            var value = evalScope[_name];
            if (value !== undefined) partialScope.bind(symbol, value);
        }
        partialScope.bindPartialMap(locals);
        vm.pushFrame();
        vm.call(partial.handle);
    };

    return PartialInvoker;
}();
STATEMENTS.add(Ops.Partial, function (sexp, builder) {
    var name = sexp[1],
        evalInfo = sexp[2];
    var _builder$meta = builder.meta,
        templateMeta = _builder$meta.templateMeta,
        symbols = _builder$meta.symbols;

    function helper(vm, args) {
        var env = vm.env;

        var nameRef = args.positional.at(0);
        return map(nameRef, function (n) {
            if (typeof n === 'string' && n) {
                if (!env.hasPartial(n, templateMeta)) {
                    throw new Error('Could not find a partial named "' + n + '"');
                }
                return env.lookupPartial(n, templateMeta);
            } else if (n) {
                throw new Error('Could not find a partial named "' + String(n) + '"');
            } else {
                return null;
            }
        });
    }
    builder.startLabels();
    builder.pushFrame();
    builder.returnTo('END');
    expr(name, builder);
    builder.pushImmediate(1);
    builder.pushImmediate(EMPTY_ARRAY);
    builder.pushArgs(true);
    builder.helper(helper);
    builder.dup();
    builder.test('simple');
    builder.enter(2);
    builder.jumpUnless('ELSE');
    builder.getPartialTemplate();
    builder.compileDynamicBlock();
    builder.invokeDynamic(new PartialInvoker(symbols, evalInfo));
    builder.popScope();
    builder.popFrame();
    builder.label('ELSE');
    builder.exit();
    builder.return();
    builder.label('END');
    builder.popFrame();
    builder.stopLabels();
});

var InvokeDynamicYield = function () {
    function InvokeDynamicYield(callerCount) {
        _classCallCheck(this, InvokeDynamicYield);

        this.callerCount = callerCount;
    }

    InvokeDynamicYield.prototype.invoke = function invoke(vm, block) {
        var callerCount = this.callerCount;

        var stack = vm.stack;
        if (!block) {
            // To balance the pop{Frame,Scope}
            vm.pushFrame();
            vm.pushCallerScope();
            return;
        }
        var table = block.symbolTable;
        var locals = table.parameters; // always present in inline blocks
        var calleeCount = locals ? locals.length : 0;
        var count = Math.min(callerCount, calleeCount);
        vm.pushFrame();
        vm.pushCallerScope(calleeCount > 0);
        var scope = vm.scope();
        for (var i = 0; i < count; i++) {
            scope.bindSymbol(locals[i], stack.fromBase(callerCount - i));
        }
        vm.call(block.handle);
    };

    InvokeDynamicYield.prototype.toJSON = function toJSON() {
        return { GlimmerDebug: '<invoke-dynamic-yield caller-count=' + this.callerCount + '>' };
    };

    return InvokeDynamicYield;
}();

STATEMENTS.add(Ops.Yield, function (sexp, builder) {
    var to = sexp[1],
        params = sexp[2];

    var count = compileList(params, builder);
    builder.getBlock(to);
    builder.compileDynamicBlock();
    builder.invokeDynamic(new InvokeDynamicYield(count));
    builder.popScope();
    builder.popFrame();
    if (count) {
        builder.pop(count);
    }
});
STATEMENTS.add(Ops.Debugger, function (sexp, builder) {
    var evalInfo = sexp[1];

    builder.debugger(builder.meta.symbols, evalInfo);
});
STATEMENTS.add(Ops.ClientSideStatement, function (sexp, builder) {
    CLIENT_SIDE.compile(sexp, builder);
});
var EXPRESSIONS = new Compilers();
var CLIENT_SIDE_EXPRS = new Compilers(1);
var E = WireFormat.Expressions;
export function expr(expression, builder) {
    if (Array.isArray(expression)) {
        EXPRESSIONS.compile(expression, builder);
    } else {
        builder.primitive(expression);
    }
}
EXPRESSIONS.add(Ops.Unknown, function (sexp, builder) {
    var name = sexp[1];
    if (builder.env.hasHelper(name, builder.meta.templateMeta)) {
        EXPRESSIONS.compile([Ops.Helper, name, EMPTY_ARRAY, null], builder);
    } else if (builder.meta.asPartial) {
        builder.resolveMaybeLocal(name);
    } else {
        builder.getVariable(0);
        builder.getProperty(name);
    }
});
EXPRESSIONS.add(Ops.Concat, function (sexp, builder) {
    var parts = sexp[1];
    for (var i = 0; i < parts.length; i++) {
        expr(parts[i], builder);
    }
    builder.concat(parts.length);
});
CLIENT_SIDE_EXPRS.add(ClientSide.Ops.FunctionExpression, function (sexp, builder) {
    builder.function(sexp[2]);
});
EXPRESSIONS.add(Ops.Helper, function (sexp, builder) {
    var env = builder.env,
        meta = builder.meta;
    var name = sexp[1],
        params = sexp[2],
        hash = sexp[3];

    if (env.hasHelper(name, meta.templateMeta)) {
        builder.compileArgs(params, hash, true);
        builder.helper(env.lookupHelper(name, meta.templateMeta));
    } else {
        throw new Error('Compile Error: ' + name + ' is not a helper');
    }
});
EXPRESSIONS.add(Ops.Get, function (sexp, builder) {
    var head = sexp[1],
        path = sexp[2];

    builder.getVariable(head);
    for (var i = 0; i < path.length; i++) {
        builder.getProperty(path[i]);
    }
});
EXPRESSIONS.add(Ops.MaybeLocal, function (sexp, builder) {
    var path = sexp[1];

    if (builder.meta.asPartial) {
        var head = path[0];
        path = path.slice(1);
        builder.resolveMaybeLocal(head);
    } else {
        builder.getVariable(0);
    }
    for (var i = 0; i < path.length; i++) {
        builder.getProperty(path[i]);
    }
});
EXPRESSIONS.add(Ops.Undefined, function (_sexp, builder) {
    return builder.primitive(undefined);
});
EXPRESSIONS.add(Ops.HasBlock, function (sexp, builder) {
    builder.hasBlock(sexp[1]);
});
EXPRESSIONS.add(Ops.HasBlockParams, function (sexp, builder) {
    builder.hasBlockParams(sexp[1]);
});
EXPRESSIONS.add(Ops.ClientSideExpression, function (sexp, builder) {
    CLIENT_SIDE_EXPRS.compile(sexp, builder);
});
export function compileList(params, builder) {
    if (!params) return 0;
    for (var i = 0; i < params.length; i++) {
        expr(params[i], builder);
    }
    return params.length;
}
export var Blocks = function () {
    function Blocks() {
        _classCallCheck(this, Blocks);

        this.names = dict();
        this.funcs = [];
    }

    Blocks.prototype.add = function add(name, func) {
        this.funcs.push(func);
        this.names[name] = this.funcs.length - 1;
    };

    Blocks.prototype.addMissing = function addMissing(func) {
        this.missing = func;
    };

    Blocks.prototype.compile = function compile(name, params, hash, template, inverse, builder) {
        var index = this.names[name];
        if (index === undefined) {
            assert(!!this.missing, name + ' not found, and no catch-all block handler was registered');
            var func = this.missing;
            var handled = func(name, params, hash, template, inverse, builder);
            assert(!!handled, name + ' not found, and the catch-all block handler didn\'t handle it');
        } else {
            var _func = this.funcs[index];
            _func(params, hash, template, inverse, builder);
        }
    };

    return Blocks;
}();
export var BLOCKS = new Blocks();
export var Inlines = function () {
    function Inlines() {
        _classCallCheck(this, Inlines);

        this.names = dict();
        this.funcs = [];
    }

    Inlines.prototype.add = function add(name, func) {
        this.funcs.push(func);
        this.names[name] = this.funcs.length - 1;
    };

    Inlines.prototype.addMissing = function addMissing(func) {
        this.missing = func;
    };

    Inlines.prototype.compile = function compile(sexp, builder) {
        var value = sexp[1];
        // TODO: Fix this so that expression macros can return
        // things like components, so that {{component foo}}
        // is the same as {{(component foo)}}
        if (!Array.isArray(value)) return ['expr', value];
        var name = void 0;
        var params = void 0;
        var hash = void 0;
        if (value[0] === Ops.Helper) {
            name = value[1];
            params = value[2];
            hash = value[3];
        } else if (value[0] === Ops.Unknown) {
            name = value[1];
            params = hash = null;
        } else {
            return ['expr', value];
        }
        var index = this.names[name];
        if (index === undefined && this.missing) {
            var func = this.missing;
            var returned = func(name, params, hash, builder);
            return returned === false ? ['expr', value] : returned;
        } else if (index !== undefined) {
            var _func2 = this.funcs[index];
            var _returned = _func2(name, params, hash, builder);
            return _returned === false ? ['expr', value] : _returned;
        } else {
            return ['expr', value];
        }
    };

    return Inlines;
}();
export var INLINES = new Inlines();
populateBuiltins(BLOCKS, INLINES);
export function populateBuiltins() {
    var blocks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Blocks();
    var inlines = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Inlines();

    blocks.add('if', function (params, _hash, template, inverse, builder) {
        //        PutArgs
        //        Test(Environment)
        //        Enter(BEGIN, END)
        // BEGIN: Noop
        //        JumpUnless(ELSE)
        //        Evaluate(default)
        //        Jump(END)
        // ELSE:  Noop
        //        Evalulate(inverse)
        // END:   Noop
        //        Exit
        if (!params || params.length !== 1) {
            throw new Error('SYNTAX ERROR: #if requires a single argument');
        }
        builder.startLabels();
        builder.pushFrame();
        builder.returnTo('END');
        expr(params[0], builder);
        builder.test('environment');
        builder.enter(1);
        builder.jumpUnless('ELSE');
        builder.invokeStatic(template);
        if (inverse) {
            builder.jump('EXIT');
            builder.label('ELSE');
            builder.invokeStatic(inverse);
            builder.label('EXIT');
            builder.exit();
            builder.return();
        } else {
            builder.label('ELSE');
            builder.exit();
            builder.return();
        }
        builder.label('END');
        builder.popFrame();
        builder.stopLabels();
    });
    blocks.add('unless', function (params, _hash, template, inverse, builder) {
        //        PutArgs
        //        Test(Environment)
        //        Enter(BEGIN, END)
        // BEGIN: Noop
        //        JumpUnless(ELSE)
        //        Evaluate(default)
        //        Jump(END)
        // ELSE:  Noop
        //        Evalulate(inverse)
        // END:   Noop
        //        Exit
        if (!params || params.length !== 1) {
            throw new Error('SYNTAX ERROR: #unless requires a single argument');
        }
        builder.startLabels();
        builder.pushFrame();
        builder.returnTo('END');
        expr(params[0], builder);
        builder.test('environment');
        builder.enter(1);
        builder.jumpIf('ELSE');
        builder.invokeStatic(template);
        if (inverse) {
            builder.jump('EXIT');
            builder.label('ELSE');
            builder.invokeStatic(inverse);
            builder.label('EXIT');
            builder.exit();
            builder.return();
        } else {
            builder.label('ELSE');
            builder.exit();
            builder.return();
        }
        builder.label('END');
        builder.popFrame();
        builder.stopLabels();
    });
    blocks.add('with', function (params, _hash, template, inverse, builder) {
        //        PutArgs
        //        Test(Environment)
        //        Enter(BEGIN, END)
        // BEGIN: Noop
        //        JumpUnless(ELSE)
        //        Evaluate(default)
        //        Jump(END)
        // ELSE:  Noop
        //        Evalulate(inverse)
        // END:   Noop
        //        Exit
        if (!params || params.length !== 1) {
            throw new Error('SYNTAX ERROR: #with requires a single argument');
        }
        builder.startLabels();
        builder.pushFrame();
        builder.returnTo('END');
        expr(params[0], builder);
        builder.dup();
        builder.test('environment');
        builder.enter(2);
        builder.jumpUnless('ELSE');
        builder.invokeStatic(template, 1);
        if (inverse) {
            builder.jump('EXIT');
            builder.label('ELSE');
            builder.invokeStatic(inverse);
            builder.label('EXIT');
            builder.exit();
            builder.return();
        } else {
            builder.label('ELSE');
            builder.exit();
            builder.return();
        }
        builder.label('END');
        builder.popFrame();
        builder.stopLabels();
    });
    blocks.add('each', function (params, hash, template, inverse, builder) {
        //         Enter(BEGIN, END)
        // BEGIN:  Noop
        //         PutArgs
        //         PutIterable
        //         JumpUnless(ELSE)
        //         EnterList(BEGIN2, END2)
        // ITER:   Noop
        //         NextIter(BREAK)
        // BEGIN2: Noop
        //         PushChildScope
        //         Evaluate(default)
        //         PopScope
        // END2:   Noop
        //         Exit
        //         Jump(ITER)
        // BREAK:  Noop
        //         ExitList
        //         Jump(END)
        // ELSE:   Noop
        //         Evalulate(inverse)
        // END:    Noop
        //         Exit
        builder.startLabels();
        builder.pushFrame();
        builder.returnTo('END');
        if (hash && hash[0][0] === 'key') {
            expr(hash[1][0], builder);
        } else {
            builder.primitive(null);
        }
        expr(params[0], builder);
        builder.enter(2);
        builder.putIterator();
        builder.jumpUnless('ELSE');
        builder.pushFrame();
        builder.returnTo('ITER');
        builder.dup(Register.fp, 1);
        builder.enterList('BODY');
        builder.label('ITER');
        builder.iterate('BREAK');
        builder.label('BODY');
        builder.invokeStatic(template, 2);
        builder.pop(2);
        builder.exit();
        builder.return();
        builder.label('BREAK');
        builder.exitList();
        builder.popFrame();
        if (inverse) {
            builder.jump('EXIT');
            builder.label('ELSE');
            builder.invokeStatic(inverse);
            builder.label('EXIT');
            builder.exit();
            builder.return();
        } else {
            builder.label('ELSE');
            builder.exit();
            builder.return();
        }
        builder.label('END');
        builder.popFrame();
        builder.stopLabels();
    });
    blocks.add('-in-element', function (params, hash, template, _inverse, builder) {
        if (!params || params.length !== 1) {
            throw new Error('SYNTAX ERROR: #-in-element requires a single argument');
        }
        builder.startLabels();
        builder.pushFrame();
        builder.returnTo('END');
        if (hash && hash[0].length) {
            var keys = hash[0],
                values = hash[1];

            if (keys.length === 1 && keys[0] === 'nextSibling') {
                expr(values[0], builder);
            } else {
                throw new Error('SYNTAX ERROR: #-in-element does not take a `' + keys[0] + '` option');
            }
        } else {
            expr(null, builder);
        }
        expr(params[0], builder);
        builder.dup();
        builder.test('simple');
        builder.enter(3);
        builder.jumpUnless('ELSE');
        builder.pushRemoteElement();
        builder.invokeStatic(template);
        builder.popRemoteElement();
        builder.label('ELSE');
        builder.exit();
        builder.return();
        builder.label('END');
        builder.popFrame();
        builder.stopLabels();
    });
    blocks.add('-with-dynamic-vars', function (_params, hash, template, _inverse, builder) {
        if (hash) {
            var names = hash[0],
                expressions = hash[1];

            compileList(expressions, builder);
            builder.pushDynamicScope();
            builder.bindDynamicScope(names);
            builder.invokeStatic(template);
            builder.popDynamicScope();
        } else {
            builder.invokeStatic(template);
        }
    });
    return { blocks: blocks, inlines: inlines };
}
export function compileStatement(statement, builder) {
    STATEMENTS.compile(statement, builder);
}
export function compileStatements(statements, meta, env) {
    var b = new OpcodeBuilder(env, meta);
    for (var i = 0; i < statements.length; i++) {
        compileStatement(statements[i], b);
    }
    return b;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["lib/syntax/functions.js"],"names":["map","assert","dict","EMPTY_ARRAY","WireFormat","OpcodeBuilder","Register","ClientSide","RawInlineBlock","Ops","ATTRS_BLOCK","Compilers","offset","names","funcs","add","name","func","push","length","compile","sexp","builder","index","STATEMENTS","CLIENT_SIDE","Text","text","Comment","comment","CloseElement","_sexp","closeElement","FlushElement","flushElement","Modifier","env","meta","params","hash","hasModifier","templateMeta","compileArgs","modifier","lookupModifier","Error","StaticAttr","value","namespace","staticAttr","DynamicAttr","dynamicAttr","TrustingAttr","trusting","expr","dynamicAttrNS","OpenElement","openPrimitiveElement","OpenComponentElement","pushComponentOperations","openElementWithOperations","DidCreateElement","didCreateElement","s0","DidRenderLayout","didRenderLayout","Append","macros","inlines","returned","isGet","E","isMaybeLocal","guardedAppend","cautiousAppend","Block","_template","_inverse","template","inverse","templateBlock","scan","inverseBlock","blocks","InvokeDynamicLayout","attrs","invoke","vm","layout","symbolTable","symbols","hasEval","stack","scope","pushRootScope","bindSelf","pop","bindBlock","indexOf","lookup","$eval","callerNames","i","symbol","bindSymbol","numPositionalArgs","inverseSymbol","defaultSymbol","defaultBlock","bindEvalScope","pushFrame","call","handle","toJSON","GlimmerDebug","Component","tag","args","block","hasComponentDefinition","child","attrsBlock","definition","getComponentDefinition","pushComponentManager","invokeComponent","parameters","stmts","statements","PartialInvoker","outerSymbols","evalInfo","_partial","partial","partialSymbols","outerScope","partialScope","bindCallerScope","getCallerScope","getEvalScope","getSelf","locals","slot","ref","getSymbol","evalScope","undefined","bind","bindPartialMap","Partial","helper","nameRef","positional","at","n","hasPartial","lookupPartial","String","startLabels","returnTo","pushImmediate","pushArgs","dup","test","enter","jumpUnless","getPartialTemplate","compileDynamicBlock","invokeDynamic","popScope","popFrame","label","exit","return","stopLabels","InvokeDynamicYield","callerCount","pushCallerScope","table","calleeCount","count","Math","min","fromBase","Yield","to","compileList","getBlock","Debugger","debugger","ClientSideStatement","EXPRESSIONS","CLIENT_SIDE_EXPRS","Expressions","expression","Array","isArray","primitive","Unknown","hasHelper","Helper","asPartial","resolveMaybeLocal","getVariable","getProperty","Concat","parts","concat","FunctionExpression","function","lookupHelper","Get","head","path","MaybeLocal","slice","Undefined","HasBlock","hasBlock","HasBlockParams","hasBlockParams","ClientSideExpression","Blocks","addMissing","missing","handled","BLOCKS","Inlines","INLINES","populateBuiltins","_hash","invokeStatic","jump","jumpIf","putIterator","fp","enterList","iterate","exitList","keys","values","pushRemoteElement","popRemoteElement","_params","expressions","pushDynamicScope","bindDynamicScope","popDynamicScope","compileStatement","statement","compileStatements","b"],"mappings":"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