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

The default blueprint for ember-cli addons.

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.INLINES = exports.Inlines = exports.BLOCKS = exports.Blocks = exports.PartialInvoker = exports.InvokeDynamicLayout = exports.ATTRS_BLOCK = undefined;
exports.expr = expr;
exports.compileList = compileList;
exports.populateBuiltins = populateBuiltins;
exports.compileStatement = compileStatement;
exports.compileStatements = compileStatements;

var _reference = require('@glimmer/reference');

var _util = require('@glimmer/util');

var _wireFormat = require('@glimmer/wire-format');

var WireFormat = _interopRequireWildcard(_wireFormat);

var _builder = require('../compiled/opcodes/builder');

var _builder2 = _interopRequireDefault(_builder);

var _opcodes = require('../opcodes');

var _clientSide = require('../syntax/client-side');

var ClientSide = _interopRequireWildcard(_clientSide);

var _rawBlock = require('./raw-block');

var _rawBlock2 = _interopRequireDefault(_rawBlock);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

var Ops = WireFormat.Ops;
const ATTRS_BLOCK = exports.ATTRS_BLOCK = '&attrs';
class Compilers {
    constructor(offset = 0) {
        this.offset = offset;
        this.names = (0, _util.dict)();
        this.funcs = [];
    }
    add(name, func) {
        this.funcs.push(func);
        this.names[name] = this.funcs.length - 1;
    }
    compile(sexp, builder) {
        let name = sexp[this.offset];
        let index = this.names[name];
        let func = this.funcs[index];
        (0, _util.assert)(!!func, `expected an implementation for ${this.offset === 0 ? Ops[sexp[0]] : ClientSide.Ops[sexp[1]]}`);
        func(sexp, builder);
    }
}
const STATEMENTS = new Compilers();
const CLIENT_SIDE = new Compilers(1);
STATEMENTS.add(Ops.Text, (sexp, builder) => {
    builder.text(sexp[1]);
});
STATEMENTS.add(Ops.Comment, (sexp, builder) => {
    builder.comment(sexp[1]);
});
STATEMENTS.add(Ops.CloseElement, (_sexp, builder) => {
    builder.closeElement();
});
STATEMENTS.add(Ops.FlushElement, (_sexp, builder) => {
    builder.flushElement();
});
STATEMENTS.add(Ops.Modifier, (sexp, builder) => {
    let { env, meta } = builder;
    let [, name, params, hash] = sexp;
    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, (sexp, builder) => {
    let [, name, value, namespace] = sexp;
    builder.staticAttr(name, namespace, value);
});
STATEMENTS.add(Ops.DynamicAttr, (sexp, builder) => {
    dynamicAttr(sexp, false, builder);
});
STATEMENTS.add(Ops.TrustingAttr, (sexp, builder) => {
    dynamicAttr(sexp, true, builder);
});
function dynamicAttr(sexp, trusting, builder) {
    let [, name, value, namespace] = sexp;
    expr(value, builder);
    if (namespace) {
        builder.dynamicAttrNS(name, namespace, trusting);
    } else {
        builder.dynamicAttr(name, trusting);
    }
}
STATEMENTS.add(Ops.OpenElement, (sexp, builder) => {
    builder.openPrimitiveElement(sexp[1]);
});
CLIENT_SIDE.add(ClientSide.Ops.OpenComponentElement, (sexp, builder) => {
    builder.pushComponentOperations();
    builder.openElementWithOperations(sexp[2]);
});
CLIENT_SIDE.add(ClientSide.Ops.DidCreateElement, (_sexp, builder) => {
    builder.didCreateElement(_opcodes.Register.s0);
});
CLIENT_SIDE.add(ClientSide.Ops.DidRenderLayout, (_sexp, builder) => {
    builder.didRenderLayout(_opcodes.Register.s0);
});
STATEMENTS.add(Ops.Append, (sexp, builder) => {
    let [, value, trusting] = sexp;
    let { inlines } = builder.env.macros();
    let returned = inlines.compile(sexp, builder) || value;
    if (returned === true) return;
    let isGet = E.isGet(value);
    let 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, (sexp, builder) => {
    let [, name, params, hash, _template, _inverse] = sexp;
    let template = builder.template(_template);
    let inverse = builder.template(_inverse);
    let templateBlock = template && template.scan();
    let inverseBlock = inverse && inverse.scan();
    let { blocks } = builder.env.macros();
    blocks.compile(name, params, hash, templateBlock, inverseBlock, builder);
});
class InvokeDynamicLayout {
    constructor(attrs) {
        this.attrs = attrs;
    }
    invoke(vm, layout) {
        let { symbols, hasEval } = layout.symbolTable;
        let stack = vm.stack;
        let scope = vm.pushRootScope(symbols.length + 1, true);
        scope.bindSelf(stack.pop());
        scope.bindBlock(symbols.indexOf(ATTRS_BLOCK) + 1, this.attrs);
        let lookup = null;
        let $eval = -1;
        if (hasEval) {
            $eval = symbols.indexOf('$eval') + 1;
            lookup = (0, _util.dict)();
        }
        let callerNames = stack.pop();
        for (let i = callerNames.length - 1; i >= 0; i--) {
            let symbol = symbols.indexOf(callerNames[i]);
            let value = stack.pop();
            if (symbol !== -1) scope.bindSymbol(symbol + 1, value);
            if (hasEval) lookup[callerNames[i]] = value;
        }
        let numPositionalArgs = stack.pop();
        (0, _util.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);
        let inverseSymbol = symbols.indexOf('&inverse');
        let inverse = stack.pop();
        if (inverseSymbol !== -1) {
            scope.bindBlock(inverseSymbol + 1, inverse);
        }
        if (lookup) lookup['&inverse'] = inverse;
        let defaultSymbol = symbols.indexOf('&default');
        let 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);
    }
    toJSON() {
        return { GlimmerDebug: '<invoke-dynamic-layout>' };
    }
}
exports.InvokeDynamicLayout = InvokeDynamicLayout;
STATEMENTS.add(Ops.Component, (sexp, builder) => {
    let [, tag, attrs, args, block] = sexp;
    if (builder.env.hasComponentDefinition(tag, builder.meta.templateMeta)) {
        let child = builder.template(block);
        let attrsBlock = new _rawBlock2.default(builder.meta, attrs, _util.EMPTY_ARRAY);
        let 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 (let i = 0; i < attrs.length; i++) {
            STATEMENTS.compile(attrs[i], builder);
        }
        builder.flushElement();
        if (block) {
            let stmts = block.statements;
            for (let i = 0; i < stmts.length; i++) {
                STATEMENTS.compile(stmts[i], builder);
            }
        }
        builder.closeElement();
    }
});
class PartialInvoker {
    constructor(outerSymbols, evalInfo) {
        this.outerSymbols = outerSymbols;
        this.evalInfo = evalInfo;
    }
    invoke(vm, _partial) {
        let partial = (0, _util.unwrap)(_partial);
        let partialSymbols = partial.symbolTable.symbols;
        let outerScope = vm.scope();
        let partialScope = vm.pushRootScope(partialSymbols.length, false);
        partialScope.bindCallerScope(outerScope.getCallerScope());
        partialScope.bindEvalScope(outerScope.getEvalScope());
        partialScope.bindSelf(outerScope.getSelf());
        let { evalInfo, outerSymbols } = this;
        let locals = (0, _util.dict)();
        for (let i = 0; i < evalInfo.length; i++) {
            let slot = evalInfo[i];
            let name = outerSymbols[slot - 1];
            let ref = outerScope.getSymbol(slot);
            locals[name] = ref;
        }
        let evalScope = outerScope.getEvalScope();
        for (let i = 0; i < partialSymbols.length; i++) {
            let name = partialSymbols[i];
            let symbol = i + 1;
            let value = evalScope[name];
            if (value !== undefined) partialScope.bind(symbol, value);
        }
        partialScope.bindPartialMap(locals);
        vm.pushFrame();
        vm.call(partial.handle);
    }
}
exports.PartialInvoker = PartialInvoker;
STATEMENTS.add(Ops.Partial, (sexp, builder) => {
    let [, name, evalInfo] = sexp;
    let { templateMeta, symbols } = builder.meta;
    function helper(vm, args) {
        let { env } = vm;
        let nameRef = args.positional.at(0);
        return (0, _reference.map)(nameRef, 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(_util.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();
});
class InvokeDynamicYield {
    constructor(callerCount) {
        this.callerCount = callerCount;
    }
    invoke(vm, block) {
        let { callerCount } = this;
        let stack = vm.stack;
        if (!block) {
            // To balance the pop{Frame,Scope}
            vm.pushFrame();
            vm.pushCallerScope();
            return;
        }
        let table = block.symbolTable;
        let locals = table.parameters; // always present in inline blocks
        let calleeCount = locals ? locals.length : 0;
        let count = Math.min(callerCount, calleeCount);
        vm.pushFrame();
        vm.pushCallerScope(calleeCount > 0);
        let scope = vm.scope();
        for (let i = 0; i < count; i++) {
            scope.bindSymbol(locals[i], stack.fromBase(callerCount - i));
        }
        vm.call(block.handle);
    }
    toJSON() {
        return { GlimmerDebug: `<invoke-dynamic-yield caller-count=${this.callerCount}>` };
    }
}
STATEMENTS.add(Ops.Yield, (sexp, builder) => {
    let [, to, params] = sexp;
    let 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, (sexp, builder) => {
    let [, evalInfo] = sexp;
    builder.debugger(builder.meta.symbols, evalInfo);
});
STATEMENTS.add(Ops.ClientSideStatement, (sexp, builder) => {
    CLIENT_SIDE.compile(sexp, builder);
});
const EXPRESSIONS = new Compilers();
const CLIENT_SIDE_EXPRS = new Compilers(1);
var E = WireFormat.Expressions;
function expr(expression, builder) {
    if (Array.isArray(expression)) {
        EXPRESSIONS.compile(expression, builder);
    } else {
        builder.primitive(expression);
    }
}
EXPRESSIONS.add(Ops.Unknown, (sexp, builder) => {
    let name = sexp[1];
    if (builder.env.hasHelper(name, builder.meta.templateMeta)) {
        EXPRESSIONS.compile([Ops.Helper, name, _util.EMPTY_ARRAY, null], builder);
    } else if (builder.meta.asPartial) {
        builder.resolveMaybeLocal(name);
    } else {
        builder.getVariable(0);
        builder.getProperty(name);
    }
});
EXPRESSIONS.add(Ops.Concat, (sexp, builder) => {
    let parts = sexp[1];
    for (let i = 0; i < parts.length; i++) {
        expr(parts[i], builder);
    }
    builder.concat(parts.length);
});
CLIENT_SIDE_EXPRS.add(ClientSide.Ops.FunctionExpression, (sexp, builder) => {
    builder.function(sexp[2]);
});
EXPRESSIONS.add(Ops.Helper, (sexp, builder) => {
    let { env, meta } = builder;
    let [, name, params, hash] = sexp;
    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, (sexp, builder) => {
    let [, head, path] = sexp;
    builder.getVariable(head);
    for (let i = 0; i < path.length; i++) {
        builder.getProperty(path[i]);
    }
});
EXPRESSIONS.add(Ops.MaybeLocal, (sexp, builder) => {
    let [, path] = sexp;
    if (builder.meta.asPartial) {
        let head = path[0];
        path = path.slice(1);
        builder.resolveMaybeLocal(head);
    } else {
        builder.getVariable(0);
    }
    for (let i = 0; i < path.length; i++) {
        builder.getProperty(path[i]);
    }
});
EXPRESSIONS.add(Ops.Undefined, (_sexp, builder) => {
    return builder.primitive(undefined);
});
EXPRESSIONS.add(Ops.HasBlock, (sexp, builder) => {
    builder.hasBlock(sexp[1]);
});
EXPRESSIONS.add(Ops.HasBlockParams, (sexp, builder) => {
    builder.hasBlockParams(sexp[1]);
});
EXPRESSIONS.add(Ops.ClientSideExpression, (sexp, builder) => {
    CLIENT_SIDE_EXPRS.compile(sexp, builder);
});
function compileList(params, builder) {
    if (!params) return 0;
    for (let i = 0; i < params.length; i++) {
        expr(params[i], builder);
    }
    return params.length;
}
class Blocks {
    constructor() {
        this.names = (0, _util.dict)();
        this.funcs = [];
    }
    add(name, func) {
        this.funcs.push(func);
        this.names[name] = this.funcs.length - 1;
    }
    addMissing(func) {
        this.missing = func;
    }
    compile(name, params, hash, template, inverse, builder) {
        let index = this.names[name];
        if (index === undefined) {
            (0, _util.assert)(!!this.missing, `${name} not found, and no catch-all block handler was registered`);
            let func = this.missing;
            let handled = func(name, params, hash, template, inverse, builder);
            (0, _util.assert)(!!handled, `${name} not found, and the catch-all block handler didn't handle it`);
        } else {
            let func = this.funcs[index];
            func(params, hash, template, inverse, builder);
        }
    }
}
exports.Blocks = Blocks;
const BLOCKS = exports.BLOCKS = new Blocks();
class Inlines {
    constructor() {
        this.names = (0, _util.dict)();
        this.funcs = [];
    }
    add(name, func) {
        this.funcs.push(func);
        this.names[name] = this.funcs.length - 1;
    }
    addMissing(func) {
        this.missing = func;
    }
    compile(sexp, builder) {
        let 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];
        let name;
        let params;
        let hash;
        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];
        }
        let index = this.names[name];
        if (index === undefined && this.missing) {
            let func = this.missing;
            let returned = func(name, params, hash, builder);
            return returned === false ? ['expr', value] : returned;
        } else if (index !== undefined) {
            let func = this.funcs[index];
            let returned = func(name, params, hash, builder);
            return returned === false ? ['expr', value] : returned;
        } else {
            return ['expr', value];
        }
    }
}
exports.Inlines = Inlines;
const INLINES = exports.INLINES = new Inlines();
populateBuiltins(BLOCKS, INLINES);
function populateBuiltins(blocks = new Blocks(), inlines = new Inlines()) {
    blocks.add('if', (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((0, _util.unwrap)(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', (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((0, _util.unwrap)(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', (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((0, _util.unwrap)(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', (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(_opcodes.Register.fp, 1);
        builder.enterList('BODY');
        builder.label('ITER');
        builder.iterate('BREAK');
        builder.label('BODY');
        builder.invokeStatic((0, _util.unwrap)(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', (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) {
            let [keys, values] = hash;
            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((0, _util.unwrap)(template));
        builder.popRemoteElement();
        builder.label('ELSE');
        builder.exit();
        builder.return();
        builder.label('END');
        builder.popFrame();
        builder.stopLabels();
    });
    blocks.add('-with-dynamic-vars', (_params, hash, template, _inverse, builder) => {
        if (hash) {
            let [names, expressions] = hash;
            compileList(expressions, builder);
            builder.pushDynamicScope();
            builder.bindDynamicScope(names);
            builder.invokeStatic((0, _util.unwrap)(template));
            builder.popDynamicScope();
        } else {
            builder.invokeStatic((0, _util.unwrap)(template));
        }
    });
    return { blocks, inlines };
}
function compileStatement(statement, builder) {
    STATEMENTS.compile(statement, builder);
}
function compileStatements(statements, meta, env) {
    let b = new _builder2.default(env, meta);
    for (let 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":["expr","compileList","populateBuiltins","compileStatement","compileStatements","WireFormat","ClientSide","Ops","ATTRS_BLOCK","Compilers","constructor","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","dynamicAttrNS","OpenElement","openPrimitiveElement","OpenComponentElement","pushComponentOperations","openElementWithOperations","DidCreateElement","didCreateElement","s0","DidRenderLayout","didRenderLayout","Append","inlines","macros","returned","isGet","E","isMaybeLocal","guardedAppend","cautiousAppend","Block","_template","_inverse","template","inverse","templateBlock","scan","inverseBlock","blocks","InvokeDynamicLayout","attrs","invoke","vm","layout","symbols","hasEval","symbolTable","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","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","_hash","invokeStatic","jump","jumpIf","putIterator","fp","enterList","iterate","exitList","keys","values","pushRemoteElement","popRemoteElement","_params","expressions","pushDynamicScope","bindDynamicScope","popDynamicScope","statement","b"],"mappings":"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