discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@glimmer/encoder.js

@@ -1,39 +0,0 @@
-class InstructionEncoder {
-    constructor(buffer) {
-        this.buffer = buffer;
-        this.typePos = 0;
-        this.size = 0;
-    }
-    encode(type, machine) {
-        if (type > 255 /* TYPE_SIZE */) {
-                throw new Error(`Opcode type over 8-bits. Got ${type}.`);
-            }
-        this.buffer.push(type | machine | arguments.length - 2 << 8 /* ARG_SHIFT */);
-        this.typePos = this.buffer.length - 1;
-        for (let i = 2; i < arguments.length; i++) {
-            let op = arguments[i];
-            if (typeof op === 'number' && op > 65535 /* MAX_SIZE */) {
-                    throw new Error(`Operand over 16-bits. Got ${op}.`);
-                }
-            this.buffer.push(op);
-        }
-        this.size = this.buffer.length;
-    }
-    patch(position, target) {
-        if (this.buffer[position + 1] === -1) {
-            this.buffer[position + 1] = target;
-        } else {
-            throw new Error('Trying to patch operand in populated slot instead of a reserved slot.');
-        }
-    }
-    patchWith(position, target, operand) {
-        if (this.buffer[position + 1] === -1) {
-            this.buffer[position + 1] = target;
-            this.buffer[position + 2] = operand;
-        } else {
-            throw new Error('Trying to patch operand in populated slot instead of a reserved slot.');
-        }
-    }
-}
-
-export { InstructionEncoder };

data/dist/es/@glimmer/low-level.js

@@ -1,82 +0,0 @@
-class Storage {
-    constructor() {
-        this.array = [];
-        this.next = 0;
-    }
-    add(element) {
-        let { next: slot, array } = this;
-        if (slot === array.length) {
-            this.next++;
-        } else {
-            let prev = array[slot];
-            this.next = prev;
-        }
-        this.array[slot] = element;
-        return slot;
-    }
-    deref(pointer) {
-        return this.array[pointer];
-    }
-    drop(pointer) {
-        this.array[pointer] = this.next;
-        this.next = pointer;
-    }
-}
-
-class Stack {
-    constructor(vec = []) {
-        this.vec = vec;
-    }
-    clone() {
-        return new Stack(this.vec.slice());
-    }
-    sliceFrom(start) {
-        return new Stack(this.vec.slice(start));
-    }
-    slice(start, end) {
-        return new Stack(this.vec.slice(start, end));
-    }
-    copy(from, to) {
-        this.vec[to] = this.vec[from];
-    }
-    // TODO: how to model u64 argument?
-    writeRaw(pos, value) {
-        // TODO: Grow?
-        this.vec[pos] = value;
-    }
-    writeSmi(pos, value) {
-        this.vec[pos] = encodeSmi(value);
-    }
-    // TODO: partially decoded enum?
-    getRaw(pos) {
-        return this.vec[pos];
-    }
-    getSmi(pos) {
-        return decodeSmi(this.vec[pos]);
-    }
-    reset() {
-        this.vec.length = 0;
-    }
-    len() {
-        return this.vec.length;
-    }
-}
-function decodeSmi(smi) {
-    switch (smi & 0b111) {
-        case 0 /* NUMBER */:
-            return smi >> 3;
-        case 4 /* NEGATIVE */:
-            return -(smi >> 3);
-        default:
-            throw new Error('unreachable');
-    }
-}
-function encodeSmi(primitive) {
-    if (primitive < 0) {
-        return Math.abs(primitive) << 3 | 4 /* NEGATIVE */;
-    } else {
-        return primitive << 3 | 0 /* NUMBER */;
-    }
-}
-
-export { Storage, Stack };

data/dist/es/@glimmer/node.js

@@ -1,112 +0,0 @@
-import { DOMTreeConstruction, ConcreteBounds, NewElementBuilder } from '@glimmer/runtime';
-
-class NodeDOMTreeConstruction extends DOMTreeConstruction {
-    constructor(doc) {
-        super(doc);
-    }
-    // override to prevent usage of `this.document` until after the constructor
-    setupUselessElement() {}
-    insertHTMLBefore(parent, reference, html) {
-        let prev = reference ? reference.previousSibling : parent.lastChild;
-        let raw = this.document.createRawHTMLSection(html);
-        parent.insertBefore(raw, reference);
-        let first = prev ? prev.nextSibling : parent.firstChild;
-        let last = reference ? reference.previousSibling : parent.lastChild;
-        return new ConcreteBounds(parent, first, last);
-    }
-    // override to avoid SVG detection/work when in node (this is not needed in SSR)
-    createElement(tag) {
-        return this.document.createElement(tag);
-    }
-    // override to avoid namespace shenanigans when in node (this is not needed in SSR)
-    setAttribute(element, name, value) {
-        element.setAttribute(name, value);
-    }
-}
-
-const TEXT_NODE = 3;
-function currentNode(cursor) {
-    let { element, nextSibling } = cursor;
-    if (nextSibling === null) {
-        return element.lastChild;
-    } else {
-        return nextSibling.previousSibling;
-    }
-}
-class SerializeBuilder extends NewElementBuilder {
-    constructor() {
-        super(...arguments);
-        this.serializeBlockDepth = 0;
-    }
-    __openBlock() {
-        let depth = this.serializeBlockDepth++;
-        this.__appendComment(`%+b:${depth}%`);
-        super.__openBlock();
-    }
-    __closeBlock() {
-        super.__closeBlock();
-        this.__appendComment(`%-b:${--this.serializeBlockDepth}%`);
-    }
-    __appendHTML(html) {
-        // Do we need to run the html tokenizer here?
-        let first = this.__appendComment('%glmr%');
-        if (this.element.tagName === 'TABLE') {
-            let openIndex = html.indexOf('<');
-            if (openIndex > -1) {
-                let tr = html.slice(openIndex + 1, openIndex + 3);
-                if (tr === 'tr') {
-                    html = `<tbody>${html}</tbody>`;
-                }
-            }
-        }
-        if (html === '') {
-            this.__appendComment('% %');
-        } else {
-            super.__appendHTML(html);
-        }
-        let last = this.__appendComment('%glmr%');
-        return new ConcreteBounds(this.element, first, last);
-    }
-    __appendText(string) {
-        let current = currentNode(this);
-        if (string === '') {
-            return this.__appendComment('% %');
-        } else if (current && current.nodeType === TEXT_NODE) {
-            this.__appendComment('%|%');
-        }
-        return super.__appendText(string);
-    }
-    closeElement() {
-        if (this.element['needsExtraClose'] === true) {
-            this.element['needsExtraClose'] = false;
-            super.closeElement();
-        }
-        super.closeElement();
-    }
-    openElement(tag) {
-        if (tag === 'tr') {
-            if (this.element.tagName !== 'TBODY') {
-                this.openElement('tbody');
-                // This prevents the closeBlock comment from being re-parented
-                // under the auto inserted tbody. Rehydration builder needs to
-                // account for the insertion since it is injected here and not
-                // really in the template.
-                this.constructing['needsExtraClose'] = true;
-                this.flushElement();
-            }
-        }
-        return super.openElement(tag);
-    }
-    pushRemoteElement(element, cursorId, nextSibling = null) {
-        let { dom } = this;
-        let script = dom.createElement('script');
-        script.setAttribute('glmr', cursorId);
-        dom.insertBefore(element, script, nextSibling);
-        super.pushRemoteElement(element, cursorId, nextSibling);
-    }
-}
-function serializeBuilder(env, cursor) {
-    return SerializeBuilder.forInitialRender(env, cursor);
-}
-
-export { NodeDOMTreeConstruction, serializeBuilder };

data/dist/es/@glimmer/opcode-compiler.js

@@ -1,1999 +0,0 @@
-import { dict, EMPTY_ARRAY, unreachable, Stack, assign } from '@glimmer/util';
-import { Register } from '@glimmer/vm';
-import { Ops } from '@glimmer/wire-format';
-import { InstructionEncoder } from '@glimmer/encoder';
-import { Program, LazyConstants } from '@glimmer/program';
-
-const PLACEHOLDER_HANDLE = -1;
-
-var Ops$1;
-(function (Ops$$1) {
-    Ops$$1[Ops$$1["OpenComponentElement"] = 0] = "OpenComponentElement";
-    Ops$$1[Ops$$1["DidCreateElement"] = 1] = "DidCreateElement";
-    Ops$$1[Ops$$1["SetComponentAttrs"] = 2] = "SetComponentAttrs";
-    Ops$$1[Ops$$1["DidRenderLayout"] = 3] = "DidRenderLayout";
-    Ops$$1[Ops$$1["Debugger"] = 4] = "Debugger";
-})(Ops$1 || (Ops$1 = {}));
-
-var Ops$2 = Ops;
-const ATTRS_BLOCK = '&attrs';
-class Compilers {
-    constructor(offset = 0) {
-        this.offset = offset;
-        this.names = 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];
-
-        func(sexp, builder);
-    }
-}
-let _statementCompiler;
-function statementCompiler() {
-    if (_statementCompiler) {
-        return _statementCompiler;
-    }
-    const STATEMENTS = _statementCompiler = new Compilers();
-    STATEMENTS.add(Ops$2.Text, (sexp, builder) => {
-        builder.text(sexp[1]);
-    });
-    STATEMENTS.add(Ops$2.Comment, (sexp, builder) => {
-        builder.comment(sexp[1]);
-    });
-    STATEMENTS.add(Ops$2.CloseElement, (_sexp, builder) => {
-        builder.closeElement();
-    });
-    STATEMENTS.add(Ops$2.FlushElement, (_sexp, builder) => {
-        builder.flushElement();
-    });
-    STATEMENTS.add(Ops$2.Modifier, (sexp, builder) => {
-        let { referrer } = builder;
-        let [, name, params, hash] = sexp;
-        let handle = builder.compiler.resolveModifier(name, referrer);
-        if (handle !== null) {
-            builder.modifier(handle, params, hash);
-        } else {
-            throw new Error(`Compile Error ${name} is not a modifier: Helpers may not be used in the element form.`);
-        }
-    });
-    STATEMENTS.add(Ops$2.StaticAttr, (sexp, builder) => {
-        let [, name, value, namespace] = sexp;
-        builder.staticAttr(name, namespace, value);
-    });
-    STATEMENTS.add(Ops$2.DynamicAttr, (sexp, builder) => {
-        dynamicAttr(sexp, false, builder);
-    });
-    STATEMENTS.add(Ops$2.TrustingAttr, (sexp, builder) => {
-        dynamicAttr(sexp, true, builder);
-    });
-    STATEMENTS.add(Ops$2.OpenElement, (sexp, builder) => {
-        builder.openPrimitiveElement(sexp[1]);
-    });
-    STATEMENTS.add(Ops$2.OpenSplattedElement, (sexp, builder) => {
-        builder.setComponentAttrs(true);
-        builder.putComponentOperations();
-        builder.openPrimitiveElement(sexp[1]);
-    });
-    STATEMENTS.add(Ops$2.DynamicComponent, (sexp, builder) => {
-        let [, definition, attrs, args, template] = sexp;
-        let block = builder.template(template);
-        let attrsBlock = null;
-        if (attrs.length > 0) {
-            let wrappedAttrs = [[Ops$2.ClientSideStatement, Ops$1.SetComponentAttrs, true], ...attrs, [Ops$2.ClientSideStatement, Ops$1.SetComponentAttrs, false]];
-            attrsBlock = builder.inlineBlock({ statements: wrappedAttrs, parameters: EMPTY_ARRAY });
-        }
-        builder.dynamicComponent(definition, attrsBlock, null, args, false, block, null);
-    });
-    STATEMENTS.add(Ops$2.Component, (sexp, builder) => {
-        let [, tag, _attrs, args, block] = sexp;
-        let { referrer } = builder;
-        let { handle, capabilities, compilable } = builder.compiler.resolveLayoutForTag(tag, referrer);
-        if (handle !== null && capabilities !== null) {
-            let attrs = [[Ops$2.ClientSideStatement, Ops$1.SetComponentAttrs, true], ..._attrs, [Ops$2.ClientSideStatement, Ops$1.SetComponentAttrs, false]];
-            let attrsBlock = builder.inlineBlock({ statements: attrs, parameters: EMPTY_ARRAY });
-            let child = builder.template(block);
-            if (compilable) {
-                builder.pushComponentDefinition(handle);
-                builder.invokeStaticComponent(capabilities, compilable, attrsBlock, null, args, false, child && child);
-            } else {
-                builder.pushComponentDefinition(handle);
-                builder.invokeComponent(capabilities, attrsBlock, null, args, false, child && child);
-            }
-        } else {
-            throw new Error(`Compile Error: Cannot find component ${tag}`);
-        }
-    });
-    STATEMENTS.add(Ops$2.Partial, (sexp, builder) => {
-        let [, name, evalInfo] = sexp;
-        let { referrer } = builder;
-        builder.replayableIf({
-            args() {
-                builder.expr(name);
-                builder.dup();
-                return 2;
-            },
-            ifTrue() {
-                builder.invokePartial(referrer, builder.evalSymbols(), evalInfo);
-                builder.popScope();
-                builder.popFrame(); // FIXME: WAT
-            }
-        });
-    });
-    STATEMENTS.add(Ops$2.Yield, (sexp, builder) => {
-        let [, to, params] = sexp;
-        builder.yield(to, params);
-    });
-    STATEMENTS.add(Ops$2.AttrSplat, (sexp, builder) => {
-        let [, to] = sexp;
-        builder.yield(to, []);
-        builder.setComponentAttrs(false);
-    });
-    STATEMENTS.add(Ops$2.Debugger, (sexp, builder) => {
-        let [, evalInfo] = sexp;
-        builder.debugger(builder.evalSymbols(), evalInfo);
-    });
-    STATEMENTS.add(Ops$2.ClientSideStatement, (sexp, builder) => {
-        CLIENT_SIDE.compile(sexp, builder);
-    });
-    STATEMENTS.add(Ops$2.Append, (sexp, builder) => {
-        let [, value, trusting] = sexp;
-        let returned = builder.compileInline(sexp) || value;
-        if (returned === true) return;
-        builder.guardedAppend(value, trusting);
-    });
-    STATEMENTS.add(Ops$2.Block, (sexp, builder) => {
-        let [, name, params, hash, _template, _inverse] = sexp;
-        let template = builder.template(_template);
-        let inverse = builder.template(_inverse);
-        let templateBlock = template && template;
-        let inverseBlock = inverse && inverse;
-        builder.compileBlock(name, params, hash, templateBlock, inverseBlock);
-    });
-    const CLIENT_SIDE = new Compilers(1);
-    CLIENT_SIDE.add(Ops$1.OpenComponentElement, (sexp, builder) => {
-        builder.putComponentOperations();
-        builder.openPrimitiveElement(sexp[2]);
-    });
-    CLIENT_SIDE.add(Ops$1.DidCreateElement, (_sexp, builder) => {
-        builder.didCreateElement(Register.s0);
-    });
-    CLIENT_SIDE.add(Ops$1.SetComponentAttrs, (sexp, builder) => {
-        builder.setComponentAttrs(sexp[2]);
-    });
-    CLIENT_SIDE.add(Ops$1.Debugger, () => {
-        // tslint:disable-next-line:no-debugger
-        debugger;
-    });
-    CLIENT_SIDE.add(Ops$1.DidRenderLayout, (_sexp, builder) => {
-        builder.didRenderLayout(Register.s0);
-    });
-    return STATEMENTS;
-}
-function dynamicAttr(sexp, trusting, builder) {
-    let [, name, value, namespace] = sexp;
-    builder.expr(value);
-    if (namespace) {
-        builder.dynamicAttr(name, namespace, trusting);
-    } else {
-        builder.dynamicAttr(name, null, trusting);
-    }
-}
-let _expressionCompiler;
-function expressionCompiler() {
-    if (_expressionCompiler) {
-        return _expressionCompiler;
-    }
-    const EXPRESSIONS = _expressionCompiler = new Compilers();
-    EXPRESSIONS.add(Ops$2.Unknown, (sexp, builder) => {
-        let { compiler, referrer, containingLayout: { asPartial } } = builder;
-        let name = sexp[1];
-        let handle = compiler.resolveHelper(name, referrer);
-        if (handle !== null) {
-            builder.helper(handle, null, null);
-        } else if (asPartial) {
-            builder.resolveMaybeLocal(name);
-        } else {
-            builder.getVariable(0);
-            builder.getProperty(name);
-        }
-    });
-    EXPRESSIONS.add(Ops$2.Concat, (sexp, builder) => {
-        let parts = sexp[1];
-        for (let i = 0; i < parts.length; i++) {
-            builder.expr(parts[i]);
-        }
-        builder.concat(parts.length);
-    });
-    EXPRESSIONS.add(Ops$2.Helper, (sexp, builder) => {
-        let { compiler, referrer } = builder;
-        let [, name, params, hash] = sexp;
-        // TODO: triage this in the WF compiler
-        if (name === 'component') {
-
-            let [definition, ...restArgs] = params;
-            builder.curryComponent(definition, restArgs, hash, true);
-            return;
-        }
-        let handle = compiler.resolveHelper(name, referrer);
-        if (handle !== null) {
-            builder.helper(handle, params, hash);
-        } else {
-            throw new Error(`Compile Error: ${name} is not a helper`);
-        }
-    });
-    EXPRESSIONS.add(Ops$2.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$2.MaybeLocal, (sexp, builder) => {
-        let [, path] = sexp;
-        if (builder.containingLayout.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$2.Undefined, (_sexp, builder) => {
-        return builder.pushPrimitiveReference(undefined);
-    });
-    EXPRESSIONS.add(Ops$2.HasBlock, (sexp, builder) => {
-        builder.hasBlock(sexp[1]);
-    });
-    EXPRESSIONS.add(Ops$2.HasBlockParams, (sexp, builder) => {
-        builder.hasBlockParams(sexp[1]);
-    });
-    return EXPRESSIONS;
-}
-class Macros {
-    constructor() {
-        let { blocks, inlines } = populateBuiltins();
-        this.blocks = blocks;
-        this.inlines = inlines;
-    }
-}
-class Blocks {
-    constructor() {
-        this.names = 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) {
-
-            let func = this.missing;
-            let handled = func(name, params, hash, template, inverse, builder);
-        } else {
-            let func = this.funcs[index];
-            func(params, hash, template, inverse, builder);
-        }
-    }
-}
-class Inlines {
-    constructor() {
-        this.names = 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$2.Helper) {
-            name = value[1];
-            params = value[2];
-            hash = value[3];
-        } else if (value[0] === Ops$2.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];
-        }
-    }
-}
-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.replayableIf({
-            args() {
-                builder.expr(params[0]);
-                builder.toBoolean();
-                return 1;
-            },
-            ifTrue() {
-                builder.invokeStaticBlock(template);
-            },
-            ifFalse() {
-                if (inverse) {
-                    builder.invokeStaticBlock(inverse);
-                }
-            }
-        });
-    });
-    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.replayableIf({
-            args() {
-                builder.expr(params[0]);
-                builder.toBoolean();
-                return 1;
-            },
-            ifTrue() {
-                if (inverse) {
-                    builder.invokeStaticBlock(inverse);
-                }
-            },
-            ifFalse() {
-                builder.invokeStaticBlock(template);
-            }
-        });
-    });
-    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.replayableIf({
-            args() {
-                builder.expr(params[0]);
-                builder.dup();
-                builder.toBoolean();
-                return 2;
-            },
-            ifTrue() {
-                builder.invokeStaticBlock(template, 1);
-            },
-            ifFalse() {
-                if (inverse) {
-                    builder.invokeStaticBlock(inverse);
-                }
-            }
-        });
-    });
-    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.replayable({
-            args() {
-                if (hash && hash[0][0] === 'key') {
-                    builder.expr(hash[1][0]);
-                } else {
-                    builder.pushPrimitiveReference(null);
-                }
-                builder.expr(params[0]);
-                return 2;
-            },
-            body() {
-                builder.putIterator();
-                builder.jumpUnless('ELSE');
-                builder.pushFrame();
-                builder.dup(Register.fp, 1);
-                builder.returnTo('ITER');
-                builder.enterList('BODY');
-                builder.label('ITER');
-                builder.iterate('BREAK');
-                builder.label('BODY');
-                builder.invokeStaticBlock(template, 2);
-                builder.pop(2);
-                builder.jump('FINALLY');
-                builder.label('BREAK');
-                builder.exitList();
-                builder.popFrame();
-                builder.jump('FINALLY');
-                builder.label('ELSE');
-                if (inverse) {
-                    builder.invokeStaticBlock(inverse);
-                }
-            }
-        });
-    });
-    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.replayableIf({
-            args() {
-                let [keys, values] = hash;
-                for (let i = 0; i < keys.length; i++) {
-                    let key = keys[i];
-                    if (key === 'nextSibling' || key === 'guid') {
-                        builder.expr(values[i]);
-                    } else {
-                        throw new Error(`SYNTAX ERROR: #in-element does not take a \`${keys[0]}\` option`);
-                    }
-                }
-                builder.expr(params[0]);
-                builder.dup();
-                return 4;
-            },
-            ifTrue() {
-                builder.pushRemoteElement();
-                builder.invokeStaticBlock(template);
-                builder.popRemoteElement();
-            }
-        });
-    });
-    blocks.add('-with-dynamic-vars', (_params, hash, template, _inverse, builder) => {
-        if (hash) {
-            let [names, expressions] = hash;
-            builder.compileParams(expressions);
-            builder.pushDynamicScope();
-            builder.bindDynamicScope(names);
-            builder.invokeStaticBlock(template);
-            builder.popDynamicScope();
-        } else {
-            builder.invokeStaticBlock(template);
-        }
-    });
-    blocks.add('component', (_params, hash, template, inverse, builder) => {
-
-        let tag = _params[0];
-        if (typeof tag === 'string') {
-            let returned = builder.staticComponentHelper(_params[0], hash, template);
-            if (returned) return;
-        }
-        let [definition, ...params] = _params;
-        builder.dynamicComponent(definition, null, params, hash, true, template, inverse);
-    });
-    inlines.add('component', (_name, _params, hash, builder) => {
-
-        let tag = _params && _params[0];
-        if (typeof tag === 'string') {
-            let returned = builder.staticComponentHelper(tag, hash, null);
-            if (returned) return true;
-        }
-        let [definition, ...params] = _params;
-        builder.dynamicComponent(definition, null, params, hash, true, null, null);
-        return true;
-    });
-    return { blocks, inlines };
-}
-
-const PLACEHOLDER_HANDLE$1 = -1;
-class CompilableProgram {
-    constructor(compiler, layout) {
-        this.compiler = compiler;
-        this.layout = layout;
-        this.compiled = null;
-    }
-    get symbolTable() {
-        return this.layout.block;
-    }
-    compile() {
-        if (this.compiled !== null) return this.compiled;
-        this.compiled = PLACEHOLDER_HANDLE$1;
-        let { block: { statements } } = this.layout;
-        return this.compiled = this.compiler.add(statements, this.layout);
-    }
-}
-class CompilableBlock {
-    constructor(compiler, parsed) {
-        this.compiler = compiler;
-        this.parsed = parsed;
-        this.compiled = null;
-    }
-    get symbolTable() {
-        return this.parsed.block;
-    }
-    compile() {
-        if (this.compiled !== null) return this.compiled;
-        // Track that compilation has started but not yet finished by temporarily
-        // using a placeholder handle. In eager compilation mode, where compile()
-        // may be called recursively, we use this as a signal that the handle cannot
-        // be known synchronously and must be linked lazily.
-        this.compiled = PLACEHOLDER_HANDLE$1;
-        let { block: { statements }, containingLayout } = this.parsed;
-        return this.compiled = this.compiler.add(statements, containingLayout);
-    }
-}
-
-function compile(statements, builder, compiler) {
-    let sCompiler = statementCompiler();
-    for (let i = 0; i < statements.length; i++) {
-        sCompiler.compile(statements[i], builder);
-    }
-    let handle = builder.commit();
-    return handle;
-}
-
-function debugSlice(program, start, end) {
-}
-function logOpcode(type, params) {
-    let out = type;
-    if (params) {
-        let args = Object.keys(params).map(p => ` ${p}=${json(params[p])}`).join('');
-        out += args;
-    }
-    return `(${out})`;
-}
-function json(param) {
-}
-function debug(pos, c, op, ...operands) {
-    let metadata = null;
-    if (!metadata) {
-        throw unreachable(`Missing Opcode Metadata for ${op}`);
-    }
-    let out = dict();
-    metadata.ops.forEach((operand, index) => {
-        let op = operands[index];
-        switch (operand.type) {
-            case 'to':
-                out[operand.name] = pos + op;
-                break;
-            case 'i32':
-            case 'symbol':
-            case 'block':
-                out[operand.name] = op;
-                break;
-            case 'handle':
-                out[operand.name] = c.resolveHandle(op);
-                break;
-            case 'str':
-                out[operand.name] = c.getString(op);
-                break;
-            case 'option-str':
-                out[operand.name] = op ? c.getString(op) : null;
-                break;
-            case 'str-array':
-                out[operand.name] = c.getStringArray(op);
-                break;
-            case 'array':
-                out[operand.name] = c.getArray(op);
-                break;
-            case 'bool':
-                out[operand.name] = !!op;
-                break;
-            case 'primitive':
-                out[operand.name] = decodePrimitive(op, c);
-                break;
-            case 'register':
-                out[operand.name] = Register[op];
-                break;
-            case 'serializable':
-                out[operand.name] = c.getSerializable(op);
-                break;
-            case 'lazy-constant':
-                out[operand.name] = c.getOther(op);
-                break;
-        }
-    });
-    return [metadata.name, out];
-}
-function decodePrimitive(primitive, constants) {
-    let flag = primitive & 7; // 111
-    let value = primitive >> 3;
-    switch (flag) {
-        case 0 /* NUMBER */:
-            return value;
-        case 1 /* FLOAT */:
-            return constants.getNumber(value);
-        case 2 /* STRING */:
-            return constants.getString(value);
-        case 3 /* BOOLEAN_OR_VOID */:
-            switch (value) {
-                case 0:
-                    return false;
-                case 1:
-                    return true;
-                case 2:
-                    return null;
-                case 3:
-                    return undefined;
-            }
-        case 4 /* NEGATIVE */:
-            return constants.getNumber(value);
-        default:
-            throw unreachable();
-    }
-}
-
-class StdLib {
-    constructor(main, trustingGuardedAppend, cautiousGuardedAppend) {
-        this.main = main;
-        this.trustingGuardedAppend = trustingGuardedAppend;
-        this.cautiousGuardedAppend = cautiousGuardedAppend;
-    }
-    static compile(compiler) {
-        let main = this.std(compiler, b => b.main());
-        let trustingGuardedAppend = this.std(compiler, b => b.stdAppend(true));
-        let cautiousGuardedAppend = this.std(compiler, b => b.stdAppend(false));
-        return new StdLib(main, trustingGuardedAppend, cautiousGuardedAppend);
-    }
-    static std(compiler, callback) {
-        return StdOpcodeBuilder.build(compiler, callback);
-    }
-    getAppend(trusting) {
-        return trusting ? this.trustingGuardedAppend : this.cautiousGuardedAppend;
-    }
-}
-class AbstractCompiler {
-    constructor(macros, program, resolver) {
-        this.macros = macros;
-        this.program = program;
-        this.resolver = resolver;
-        this.initialize();
-    }
-    initialize() {
-        this.stdLib = StdLib.compile(this);
-    }
-    get constants() {
-        return this.program.constants;
-    }
-    compileInline(sexp, builder) {
-        let { inlines } = this.macros;
-        return inlines.compile(sexp, builder);
-    }
-    compileBlock(name, params, hash, template, inverse, builder) {
-        let { blocks } = this.macros;
-        blocks.compile(name, params, hash, template, inverse, builder);
-    }
-    add(statements, containingLayout) {
-        return compile(statements, this.builderFor(containingLayout), this);
-    }
-    commit(scopeSize, buffer) {
-        let heap = this.program.heap;
-        // TODO: change the whole malloc API and do something more efficient
-        let handle = heap.malloc();
-        for (let i = 0; i < buffer.length; i++) {
-            let value = buffer[i];
-            if (typeof value === 'function') {
-                heap.pushPlaceholder(value);
-            } else {
-                heap.push(value);
-            }
-        }
-        heap.finishMalloc(handle, scopeSize);
-        return handle;
-    }
-    resolveLayoutForTag(tag, referrer) {
-        let { resolver } = this;
-        let handle = resolver.lookupComponentDefinition(tag, referrer);
-        if (handle === null) return { handle: null, capabilities: null, compilable: null };
-        return this.resolveLayoutForHandle(handle);
-    }
-    resolveLayoutForHandle(handle) {
-        let { resolver } = this;
-        let capabilities = resolver.getCapabilities(handle);
-        let compilable = null;
-        if (!capabilities.dynamicLayout) {
-            compilable = resolver.getLayout(handle);
-        }
-        return {
-            handle,
-            capabilities,
-            compilable
-        };
-    }
-    resolveModifier(name, referrer) {
-        return this.resolver.lookupModifier(name, referrer);
-    }
-    resolveHelper(name, referrer) {
-        return this.resolver.lookupHelper(name, referrer);
-    }
-}
-let debugCompiler;
-
-class WrappedBuilder {
-    constructor(compiler, layout) {
-        this.compiler = compiler;
-        this.layout = layout;
-        this.compiled = null;
-        let { block } = layout;
-        let symbols = block.symbols.slice();
-        // ensure ATTRS_BLOCK is always included (only once) in the list of symbols
-        let attrsBlockIndex = symbols.indexOf(ATTRS_BLOCK);
-        if (attrsBlockIndex === -1) {
-            this.attrsBlockNumber = symbols.push(ATTRS_BLOCK);
-        } else {
-            this.attrsBlockNumber = attrsBlockIndex + 1;
-        }
-        this.symbolTable = {
-            hasEval: block.hasEval,
-            symbols
-        };
-    }
-    compile() {
-        if (this.compiled !== null) return this.compiled;
-        //========DYNAMIC
-        //        PutValue(TagExpr)
-        //        Test
-        //        JumpUnless(BODY)
-        //        PutComponentOperations
-        //        OpenDynamicPrimitiveElement
-        //        DidCreateElement
-        //        ...attr statements...
-        //        FlushElement
-        // BODY:  Noop
-        //        ...body statements...
-        //        PutValue(TagExpr)
-        //        Test
-        //        JumpUnless(END)
-        //        CloseElement
-        // END:   Noop
-        //        DidRenderLayout
-        //        Exit
-        //
-        //========STATIC
-        //        OpenPrimitiveElementOpcode
-        //        DidCreateElement
-        //        ...attr statements...
-        //        FlushElement
-        //        ...body statements...
-        //        CloseElement
-        //        DidRenderLayout
-        //        Exit
-        let { compiler, layout } = this;
-        let b = compiler.builderFor(layout);
-        b.startLabels();
-        b.fetch(Register.s1);
-        b.getComponentTagName(Register.s0);
-        b.primitiveReference();
-        b.dup();
-        b.load(Register.s1);
-        b.jumpUnless('BODY');
-        b.fetch(Register.s1);
-        b.setComponentAttrs(true);
-        b.putComponentOperations();
-        b.openDynamicElement();
-        b.didCreateElement(Register.s0);
-        b.yield(this.attrsBlockNumber, []);
-        b.setComponentAttrs(false);
-        b.flushElement();
-        b.label('BODY');
-        b.invokeStaticBlock(blockFor(layout, compiler));
-        b.fetch(Register.s1);
-        b.jumpUnless('END');
-        b.closeElement();
-        b.label('END');
-        b.load(Register.s1);
-        b.stopLabels();
-        let handle = b.commit();
-        return this.compiled = handle;
-    }
-}
-function blockFor(layout, compiler) {
-    return new CompilableBlock(compiler, {
-        block: {
-            statements: layout.block.statements,
-            parameters: EMPTY_ARRAY
-        },
-        containingLayout: layout
-    });
-}
-class ComponentBuilder {
-    constructor(builder) {
-        this.builder = builder;
-    }
-    static(handle, args) {
-        let [params, hash, _default, inverse] = args;
-        let { builder } = this;
-        if (handle !== null) {
-            let { capabilities, compilable } = builder.compiler.resolveLayoutForHandle(handle);
-            if (compilable) {
-                builder.pushComponentDefinition(handle);
-                builder.invokeStaticComponent(capabilities, compilable, null, params, hash, false, _default, inverse);
-            } else {
-                builder.pushComponentDefinition(handle);
-                builder.invokeComponent(capabilities, null, params, hash, false, _default, inverse);
-            }
-        }
-    }
-}
-
-class Labels {
-    constructor() {
-        this.labels = dict();
-        this.targets = [];
-    }
-    label(name, index) {
-        this.labels[name] = index;
-    }
-    target(at, target) {
-        this.targets.push({ at, target });
-    }
-    patch(encoder) {
-        let { targets, labels } = this;
-        for (let i = 0; i < targets.length; i++) {
-            let { at, target } = targets[i];
-            let address = labels[target] - at;
-            encoder.patch(at, address);
-        }
-    }
-}
-class StdOpcodeBuilder {
-    constructor(compiler, size = 0) {
-        this.size = size;
-        this.encoder = new InstructionEncoder([]);
-        this.labelsStack = new Stack();
-        this.compiler = compiler;
-    }
-    static build(compiler, callback) {
-        let builder = new StdOpcodeBuilder(compiler);
-        callback(builder);
-        return builder.commit();
-    }
-    push(name) {
-        switch (arguments.length) {
-            case 1:
-                return this.encoder.encode(name, 0);
-            case 2:
-                return this.encoder.encode(name, 0, arguments[1]);
-            case 3:
-                return this.encoder.encode(name, 0, arguments[1], arguments[2]);
-            default:
-                return this.encoder.encode(name, 0, arguments[1], arguments[2], arguments[3]);
-        }
-    }
-    pushMachine(name) {
-        switch (arguments.length) {
-            case 1:
-                return this.encoder.encode(name, 1024 /* MACHINE_MASK */);
-            case 2:
-                return this.encoder.encode(name, 1024 /* MACHINE_MASK */, arguments[1]);
-            case 3:
-                return this.encoder.encode(name, 1024 /* MACHINE_MASK */, arguments[1], arguments[2]);
-            default:
-                return this.encoder.encode(name, 1024 /* MACHINE_MASK */, arguments[1], arguments[2], arguments[3]);
-        }
-    }
-    commit() {
-        this.pushMachine(24 /* Return */);
-        return this.compiler.commit(this.size, this.encoder.buffer);
-    }
-    reserve(name) {
-        this.encoder.encode(name, 0, -1);
-    }
-    reserveWithOperand(name, operand) {
-        this.encoder.encode(name, 0, -1, operand);
-    }
-    reserveMachine(name) {
-        this.encoder.encode(name, 1024 /* MACHINE_MASK */, -1);
-    }
-    ///
-    main() {
-        this.push(68 /* Main */, Register.s0);
-        this.invokePreparedComponent(false, false, true);
-    }
-    appendHTML() {
-        this.push(28 /* AppendHTML */);
-    }
-    appendSafeHTML() {
-        this.push(29 /* AppendSafeHTML */);
-    }
-    appendDocumentFragment() {
-        this.push(30 /* AppendDocumentFragment */);
-    }
-    appendNode() {
-        this.push(31 /* AppendNode */);
-    }
-    appendText() {
-        this.push(32 /* AppendText */);
-    }
-    beginComponentTransaction() {
-        this.push(91 /* BeginComponentTransaction */);
-    }
-    commitComponentTransaction() {
-        this.push(92 /* CommitComponentTransaction */);
-    }
-    pushDynamicScope() {
-        this.push(44 /* PushDynamicScope */);
-    }
-    popDynamicScope() {
-        this.push(45 /* PopDynamicScope */);
-    }
-    pushRemoteElement() {
-        this.push(41 /* PushRemoteElement */);
-    }
-    popRemoteElement() {
-        this.push(42 /* PopRemoteElement */);
-    }
-    pushRootScope(symbols, bindCallerScope) {
-        this.push(20 /* RootScope */, symbols, bindCallerScope ? 1 : 0);
-    }
-    pushVirtualRootScope(register) {
-        this.push(21 /* VirtualRootScope */, register);
-    }
-    pushChildScope() {
-        this.push(22 /* ChildScope */);
-    }
-    popScope() {
-        this.push(23 /* PopScope */);
-    }
-    prepareArgs(state) {
-        this.push(79 /* PrepareArgs */, state);
-    }
-    createComponent(state, hasDefault) {
-        let flag = hasDefault | 0;
-        this.push(81 /* CreateComponent */, flag, state);
-    }
-    registerComponentDestructor(state) {
-        this.push(82 /* RegisterComponentDestructor */, state);
-    }
-    putComponentOperations() {
-        this.push(83 /* PutComponentOperations */);
-    }
-    getComponentSelf(state) {
-        this.push(84 /* GetComponentSelf */, state);
-    }
-    getComponentTagName(state) {
-        this.push(85 /* GetComponentTagName */, state);
-    }
-    getComponentLayout(state) {
-        this.push(86 /* GetComponentLayout */, state);
-    }
-    setupForEval(state) {
-        this.push(87 /* SetupForEval */, state);
-    }
-    invokeComponentLayout(state) {
-        this.push(90 /* InvokeComponentLayout */, state);
-    }
-    didCreateElement(state) {
-        this.push(93 /* DidCreateElement */, state);
-    }
-    didRenderLayout(state) {
-        this.push(94 /* DidRenderLayout */, state);
-    }
-    pushFrame() {
-        this.pushMachine(57 /* PushFrame */);
-    }
-    popFrame() {
-        this.pushMachine(58 /* PopFrame */);
-    }
-    pushSmallFrame() {
-        this.pushMachine(59 /* PushSmallFrame */);
-    }
-    popSmallFrame() {
-        this.pushMachine(60 /* PopSmallFrame */);
-    }
-    invokeVirtual() {
-        this.pushMachine(49 /* InvokeVirtual */);
-    }
-    invokeYield() {
-        this.push(51 /* InvokeYield */);
-    }
-    toBoolean() {
-        this.push(63 /* ToBoolean */);
-    }
-    invokePreparedComponent(hasBlock, bindableBlocks, bindableAtNames, populateLayout = null) {
-        this.beginComponentTransaction();
-        this.pushDynamicScope();
-        this.createComponent(Register.s0, hasBlock);
-        // this has to run after createComponent to allow
-        // for late-bound layouts, but a caller is free
-        // to populate the layout earlier if it wants to
-        // and do nothing here.
-        if (populateLayout) populateLayout();
-        this.registerComponentDestructor(Register.s0);
-        this.getComponentSelf(Register.s0);
-        this.pushVirtualRootScope(Register.s0);
-        this.setVariable(0);
-        this.setupForEval(Register.s0);
-        if (bindableAtNames) this.setNamedVariables(Register.s0);
-        if (bindableBlocks) this.setBlocks(Register.s0);
-        this.pop();
-        this.invokeComponentLayout(Register.s0);
-        this.didRenderLayout(Register.s0);
-        this.popFrame();
-        this.popScope();
-        this.popDynamicScope();
-        this.commitComponentTransaction();
-    }
-    get pos() {
-        return this.encoder.typePos;
-    }
-    get nextPos() {
-        return this.encoder.size;
-    }
-    ///
-    compileInline(sexp) {
-        return this.compiler.compileInline(sexp, this);
-    }
-    compileBlock(name, params, hash, template, inverse) {
-        this.compiler.compileBlock(name, params, hash, template, inverse, this);
-    }
-    label(name) {
-        this.labels.label(name, this.nextPos);
-    }
-    // helpers
-    get labels() {
-        return this.labelsStack.current;
-    }
-    startLabels() {
-        this.labelsStack.push(new Labels());
-    }
-    stopLabels() {
-        let label = this.labelsStack.pop();
-        label.patch(this.encoder);
-    }
-    // components
-    pushCurriedComponent() {
-        this.push(74 /* PushCurriedComponent */);
-    }
-    pushDynamicComponentInstance() {
-        this.push(73 /* PushDynamicComponentInstance */);
-    }
-    // dom
-    openDynamicElement() {
-        this.push(34 /* OpenDynamicElement */);
-    }
-    flushElement() {
-        this.push(38 /* FlushElement */);
-    }
-    closeElement() {
-        this.push(39 /* CloseElement */);
-    }
-    // lists
-    putIterator() {
-        this.push(66 /* PutIterator */);
-    }
-    enterList(start) {
-        this.reserve(64 /* EnterList */);
-        this.labels.target(this.pos, start);
-    }
-    exitList() {
-        this.push(65 /* ExitList */);
-    }
-    iterate(breaks) {
-        this.reserve(67 /* Iterate */);
-        this.labels.target(this.pos, breaks);
-    }
-    // expressions
-    setNamedVariables(state) {
-        this.push(2 /* SetNamedVariables */, state);
-    }
-    setBlocks(state) {
-        this.push(3 /* SetBlocks */, state);
-    }
-    setVariable(symbol) {
-        this.push(4 /* SetVariable */, symbol);
-    }
-    setBlock(symbol) {
-        this.push(5 /* SetBlock */, symbol);
-    }
-    getVariable(symbol) {
-        this.push(6 /* GetVariable */, symbol);
-    }
-    getBlock(symbol) {
-        this.push(8 /* GetBlock */, symbol);
-    }
-    hasBlock(symbol) {
-        this.push(9 /* HasBlock */, symbol);
-    }
-    concat(size) {
-        this.push(11 /* Concat */, size);
-    }
-    load(register) {
-        this.push(18 /* Load */, register);
-    }
-    fetch(register) {
-        this.push(19 /* Fetch */, register);
-    }
-    dup(register = Register.sp, offset = 0) {
-        return this.push(16 /* Dup */, register, offset);
-    }
-    pop(count = 1) {
-        return this.push(17 /* Pop */, count);
-    }
-    // vm
-    returnTo(label) {
-        this.reserveMachine(25 /* ReturnTo */);
-        this.labels.target(this.pos, label);
-    }
-    primitiveReference() {
-        this.push(14 /* PrimitiveReference */);
-    }
-    reifyU32() {
-        this.push(15 /* ReifyU32 */);
-    }
-    enter(args) {
-        this.push(61 /* Enter */, args);
-    }
-    exit() {
-        this.push(62 /* Exit */);
-    }
-    return() {
-        this.pushMachine(24 /* Return */);
-    }
-    jump(target) {
-        this.reserveMachine(52 /* Jump */);
-        this.labels.target(this.pos, target);
-    }
-    jumpIf(target) {
-        this.reserve(53 /* JumpIf */);
-        this.labels.target(this.pos, target);
-    }
-    jumpUnless(target) {
-        this.reserve(54 /* JumpUnless */);
-        this.labels.target(this.pos, target);
-    }
-    jumpEq(value, target) {
-        this.reserveWithOperand(55 /* JumpEq */, value);
-        this.labels.target(this.pos, target);
-    }
-    assertSame() {
-        this.push(56 /* AssertSame */);
-    }
-    pushEmptyArgs() {
-        this.push(77 /* PushEmptyArgs */);
-    }
-    switch(_opcode, callback) {
-        // Setup the switch DSL
-        let clauses = [];
-        let count = 0;
-        function when(match, callback) {
-            clauses.push({ match, callback, label: `CLAUSE${count++}` });
-        }
-        // Call the callback
-        callback(when);
-        // Emit the opcodes for the switch
-        this.enter(2);
-        this.assertSame();
-        this.reifyU32();
-        this.startLabels();
-        // First, emit the jump opcodes. We don't need a jump for the last
-        // opcode, since it bleeds directly into its clause.
-        clauses.slice(0, -1).forEach(clause => this.jumpEq(clause.match, clause.label));
-        // Enumerate the clauses in reverse order. Earlier matches will
-        // require fewer checks.
-        for (let i = clauses.length - 1; i >= 0; i--) {
-            let clause = clauses[i];
-            this.label(clause.label);
-            this.pop(2);
-            clause.callback();
-            // The first match is special: it is placed directly before the END
-            // label, so no additional jump is needed at the end of it.
-            if (i !== 0) {
-                this.jump('END');
-            }
-        }
-        this.label('END');
-        this.stopLabels();
-        this.exit();
-    }
-    stdAppend(trusting) {
-        this.switch(this.contentType(), when => {
-            when(1 /* String */, () => {
-                if (trusting) {
-                    this.assertSame();
-                    this.appendHTML();
-                } else {
-                    this.appendText();
-                }
-            });
-            when(0 /* Component */, () => {
-                this.pushCurriedComponent();
-                this.pushDynamicComponentInstance();
-                this.invokeBareComponent();
-            });
-            when(3 /* SafeString */, () => {
-                this.assertSame();
-                this.appendSafeHTML();
-            });
-            when(4 /* Fragment */, () => {
-                this.assertSame();
-                this.appendDocumentFragment();
-            });
-            when(5 /* Node */, () => {
-                this.assertSame();
-                this.appendNode();
-            });
-        });
-    }
-    populateLayout(state) {
-        this.push(89 /* PopulateLayout */, state);
-    }
-    invokeBareComponent() {
-        this.fetch(Register.s0);
-        this.dup(Register.sp, 1);
-        this.load(Register.s0);
-        this.pushFrame();
-        this.pushEmptyArgs();
-        this.prepareArgs(Register.s0);
-        this.invokePreparedComponent(false, false, true, () => {
-            this.getComponentLayout(Register.s0);
-            this.populateLayout(Register.s0);
-        });
-        this.load(Register.s0);
-    }
-    isComponent() {
-        this.push(69 /* IsComponent */);
-    }
-    contentType() {
-        this.push(70 /* ContentType */);
-    }
-    pushBlockScope() {
-        this.push(47 /* PushBlockScope */);
-    }
-}
-class OpcodeBuilder extends StdOpcodeBuilder {
-    constructor(compiler, containingLayout) {
-        super(compiler, containingLayout ? containingLayout.block.symbols.length : 0);
-        this.containingLayout = containingLayout;
-        this.component = new ComponentBuilder(this);
-        this.expressionCompiler = expressionCompiler();
-        this.isComponentAttrs = false;
-        this.constants = compiler.constants;
-        this.stdLib = compiler.stdLib;
-    }
-    /// MECHANICS
-    get referrer() {
-        return this.containingLayout && this.containingLayout.referrer;
-    }
-    setComponentAttrs(enabled) {
-        this.isComponentAttrs = enabled;
-    }
-    expr(expression) {
-        if (Array.isArray(expression)) {
-            this.expressionCompiler.compile(expression, this);
-        } else {
-            this.pushPrimitiveReference(expression);
-        }
-    }
-    ///
-    // args
-    pushArgs(names, flags) {
-        let serialized = this.constants.stringArray(names);
-        this.push(76 /* PushArgs */, serialized, flags);
-    }
-    pushYieldableBlock(block) {
-        this.pushSymbolTable(block && block.symbolTable);
-        this.pushBlockScope();
-        this.pushBlock(block);
-    }
-    curryComponent(definition,
-    /* TODO: attrs: Option<RawInlineBlock>, */params, hash, synthetic) {
-        let referrer = this.containingLayout.referrer;
-        this.pushFrame();
-        this.compileArgs(params, hash, null, synthetic);
-        this.push(80 /* CaptureArgs */);
-        this.expr(definition);
-        this.push(71 /* CurryComponent */, this.constants.serializable(referrer));
-        this.popFrame();
-        this.fetch(Register.v0);
-    }
-    pushSymbolTable(table) {
-        if (table) {
-            let constant = this.constants.serializable(table);
-            this.push(48 /* PushSymbolTable */, constant);
-        } else {
-            this.primitive(null);
-        }
-    }
-    invokeComponent(capabilities, attrs, params, hash, synthetic, block, inverse = null, layout) {
-        this.fetch(Register.s0);
-        this.dup(Register.sp, 1);
-        this.load(Register.s0);
-        this.pushFrame();
-        let bindableBlocks = !!(block || inverse || attrs);
-        let bindableAtNames = capabilities === true || capabilities.prepareArgs || !!(hash && hash[0].length !== 0);
-        let blocks = { main: block, else: inverse, attrs };
-        this.compileArgs(params, hash, blocks, synthetic);
-        this.prepareArgs(Register.s0);
-        this.invokePreparedComponent(block !== null, bindableBlocks, bindableAtNames, () => {
-            if (layout) {
-                this.pushSymbolTable(layout.symbolTable);
-                this.pushLayout(layout);
-                this.resolveLayout();
-            } else {
-                this.getComponentLayout(Register.s0);
-            }
-            this.populateLayout(Register.s0);
-        });
-        this.load(Register.s0);
-    }
-    invokeStaticComponent(capabilities, layout, attrs, params, hash, synthetic, block, inverse = null) {
-        let { symbolTable } = layout;
-        let bailOut = symbolTable.hasEval || capabilities.prepareArgs;
-        if (bailOut) {
-            this.invokeComponent(capabilities, attrs, params, hash, synthetic, block, inverse, layout);
-            return;
-        }
-        this.fetch(Register.s0);
-        this.dup(Register.sp, 1);
-        this.load(Register.s0);
-        let { symbols } = symbolTable;
-        if (capabilities.createArgs) {
-            this.pushFrame();
-            this.compileArgs(null, hash, null, synthetic);
-        }
-        this.beginComponentTransaction();
-        if (capabilities.dynamicScope) {
-            this.pushDynamicScope();
-        }
-        if (capabilities.createInstance) {
-            this.createComponent(Register.s0, block !== null);
-        }
-        if (capabilities.createArgs) {
-            this.popFrame();
-        }
-        this.pushFrame();
-        this.registerComponentDestructor(Register.s0);
-        let bindings = [];
-        this.getComponentSelf(Register.s0);
-        bindings.push({ symbol: 0, isBlock: false });
-        for (let i = 0; i < symbols.length; i++) {
-            let symbol = symbols[i];
-            switch (symbol.charAt(0)) {
-                case '&':
-                    let callerBlock = null;
-                    if (symbol === '&default') {
-                        callerBlock = block;
-                    } else if (symbol === '&inverse') {
-                        callerBlock = inverse;
-                    } else if (symbol === ATTRS_BLOCK) {
-                        callerBlock = attrs;
-                    } else {
-                        throw unreachable();
-                    }
-                    if (callerBlock) {
-                        this.pushYieldableBlock(callerBlock);
-                        bindings.push({ symbol: i + 1, isBlock: true });
-                    } else {
-                        this.pushYieldableBlock(null);
-                        bindings.push({ symbol: i + 1, isBlock: true });
-                    }
-                    break;
-                case '@':
-                    if (!hash) {
-                        break;
-                    }
-                    let [keys, values] = hash;
-                    let lookupName = symbol;
-                    if (synthetic) {
-                        lookupName = symbol.slice(1);
-                    }
-                    let index = keys.indexOf(lookupName);
-                    if (index !== -1) {
-                        this.expr(values[index]);
-                        bindings.push({ symbol: i + 1, isBlock: false });
-                    }
-                    break;
-            }
-        }
-        this.pushRootScope(symbols.length + 1, !!(block || inverse || attrs));
-        for (let i = bindings.length - 1; i >= 0; i--) {
-            let { symbol, isBlock } = bindings[i];
-            if (isBlock) {
-                this.setBlock(symbol);
-            } else {
-                this.setVariable(symbol);
-            }
-        }
-        this.invokeStatic(layout);
-        if (capabilities.createInstance) {
-            this.didRenderLayout(Register.s0);
-        }
-        this.popFrame();
-        this.popScope();
-        if (capabilities.dynamicScope) {
-            this.popDynamicScope();
-        }
-        this.commitComponentTransaction();
-        this.load(Register.s0);
-    }
-    dynamicComponent(definition, attrs, params, hash, synthetic, block, inverse = null) {
-        this.replayable({
-            args: () => {
-                this.expr(definition);
-                this.dup();
-                return 2;
-            },
-            body: () => {
-                this.jumpUnless('ELSE');
-                this.resolveDynamicComponent(this.containingLayout.referrer);
-                this.pushDynamicComponentInstance();
-                this.invokeComponent(true, attrs, params, hash, synthetic, block, inverse);
-                this.label('ELSE');
-            }
-        });
-    }
-    yield(to, params) {
-        this.compileArgs(params, null, null, false);
-        this.getBlock(to);
-        this.resolveBlock();
-        this.invokeYield();
-        this.popScope();
-        this.popFrame();
-    }
-    guardedAppend(expression, trusting) {
-        this.pushFrame();
-        this.expr(expression);
-        this.pushMachine(50 /* InvokeStatic */, this.stdLib.getAppend(trusting));
-        this.popFrame();
-    }
-    invokeStaticBlock(block, callerCount = 0) {
-        let { parameters } = block.symbolTable;
-        let calleeCount = parameters.length;
-        let count = Math.min(callerCount, calleeCount);
-        this.pushFrame();
-        if (count) {
-            this.pushChildScope();
-            for (let i = 0; i < count; i++) {
-                this.dup(Register.fp, callerCount - i);
-                this.setVariable(parameters[i]);
-            }
-        }
-        this.pushBlock(block);
-        this.resolveBlock();
-        this.invokeVirtual();
-        if (count) {
-            this.popScope();
-        }
-        this.popFrame();
-    }
-    /// CONVENIENCE
-    // internal helpers
-    string(_string) {
-        return this.constants.string(_string);
-    }
-    names(_names) {
-        let names = [];
-        for (let i = 0; i < _names.length; i++) {
-            let n = _names[i];
-            names[i] = this.constants.string(n);
-        }
-        return this.constants.array(names);
-    }
-    symbols(symbols) {
-        return this.constants.array(symbols);
-    }
-    // vm
-    primitive(_primitive) {
-        let type = 0 /* NUMBER */;
-        let primitive;
-        switch (typeof _primitive) {
-            case 'number':
-                if (_primitive % 1 === 0) {
-                    if (_primitive > -1) {
-                        primitive = _primitive;
-                    } else {
-                        primitive = this.constants.number(_primitive);
-                        type = 4 /* NEGATIVE */;
-                    }
-                } else {
-                    primitive = this.constants.number(_primitive);
-                    type = 1 /* FLOAT */;
-                }
-                break;
-            case 'string':
-                primitive = this.string(_primitive);
-                type = 2 /* STRING */;
-                break;
-            case 'boolean':
-                primitive = _primitive | 0;
-                type = 3 /* BOOLEAN_OR_VOID */;
-                break;
-            case 'object':
-                // assume null
-                primitive = 2;
-                type = 3 /* BOOLEAN_OR_VOID */;
-                break;
-            case 'undefined':
-                primitive = 3;
-                type = 3 /* BOOLEAN_OR_VOID */;
-                break;
-            default:
-                throw new Error('Invalid primitive passed to pushPrimitive');
-        }
-        let immediate = this.sizeImmediate(primitive << 3 | type, primitive);
-        this.push(13 /* Primitive */, immediate);
-    }
-    sizeImmediate(shifted, primitive) {
-        if (shifted >= 65535 /* MAX_SIZE */ || shifted < 0) {
-            return this.constants.number(primitive) << 3 | 5 /* BIG_NUM */;
-        }
-        return shifted;
-    }
-    pushPrimitiveReference(primitive) {
-        this.primitive(primitive);
-        this.primitiveReference();
-    }
-    // components
-    pushComponentDefinition(handle) {
-        this.push(72 /* PushComponentDefinition */, this.constants.handle(handle));
-    }
-    resolveDynamicComponent(referrer) {
-        this.push(75 /* ResolveDynamicComponent */, this.constants.serializable(referrer));
-    }
-    staticComponentHelper(tag, hash, template) {
-        let { handle, capabilities, compilable } = this.compiler.resolveLayoutForTag(tag, this.referrer);
-        if (handle !== null && capabilities !== null) {
-            if (compilable) {
-                if (hash) {
-                    for (let i = 0; i < hash.length; i = i + 2) {
-                        hash[i][0] = `@${hash[i][0]}`;
-                    }
-                }
-                this.pushComponentDefinition(handle);
-                this.invokeStaticComponent(capabilities, compilable, null, null, hash, false, template && template);
-                return true;
-            }
-        }
-        return false;
-    }
-    // partial
-    invokePartial(referrer, symbols, evalInfo) {
-        let _meta = this.constants.serializable(referrer);
-        let _symbols = this.constants.stringArray(symbols);
-        let _evalInfo = this.constants.array(evalInfo);
-        this.push(95 /* InvokePartial */, _meta, _symbols, _evalInfo);
-    }
-    resolveMaybeLocal(name) {
-        this.push(96 /* ResolveMaybeLocal */, this.string(name));
-    }
-    // debugger
-    debugger(symbols, evalInfo) {
-        this.push(97 /* Debugger */, this.constants.stringArray(symbols), this.constants.array(evalInfo));
-    }
-    // dom
-    text(text) {
-        this.push(26 /* Text */, this.constants.string(text));
-    }
-    openPrimitiveElement(tag) {
-        this.push(33 /* OpenElement */, this.constants.string(tag));
-    }
-    modifier(locator, params, hash) {
-        this.pushFrame();
-        this.compileArgs(params, hash, null, true);
-        this.push(40 /* Modifier */, this.constants.handle(locator));
-        this.popFrame();
-    }
-    comment(_comment) {
-        let comment = this.constants.string(_comment);
-        this.push(27 /* Comment */, comment);
-    }
-    dynamicAttr(_name, _namespace, trusting) {
-        let name = this.constants.string(_name);
-        let namespace = _namespace ? this.constants.string(_namespace) : 0;
-        if (this.isComponentAttrs) {
-            this.push(37 /* ComponentAttr */, name, trusting === true ? 1 : 0, namespace);
-        } else {
-            this.push(36 /* DynamicAttr */, name, trusting === true ? 1 : 0, namespace);
-        }
-    }
-    staticAttr(_name, _namespace, _value) {
-        let name = this.constants.string(_name);
-        let namespace = _namespace ? this.constants.string(_namespace) : 0;
-        if (this.isComponentAttrs) {
-            this.pushPrimitiveReference(_value);
-            this.push(37 /* ComponentAttr */, name, 1, namespace);
-        } else {
-            let value = this.constants.string(_value);
-            this.push(35 /* StaticAttr */, name, value, namespace);
-        }
-    }
-    // expressions
-    hasBlockParams(to) {
-        this.getBlock(to);
-        this.resolveBlock();
-        this.push(10 /* HasBlockParams */);
-    }
-    getProperty(key) {
-        this.push(7 /* GetProperty */, this.string(key));
-    }
-    helper(helper, params, hash) {
-        this.pushFrame();
-        this.compileArgs(params, hash, null, true);
-        this.push(1 /* Helper */, this.constants.handle(helper));
-        this.popFrame();
-        this.fetch(Register.v0);
-    }
-    bindDynamicScope(_names) {
-        this.push(43 /* BindDynamicScope */, this.names(_names));
-    }
-    // convenience methods
-    /**
-     * A convenience for pushing some arguments on the stack and
-     * running some code if the code needs to be re-executed during
-     * updating execution if some of the arguments have changed.
-     *
-     * # Initial Execution
-     *
-     * The `args` function should push zero or more arguments onto
-     * the stack and return the number of arguments pushed.
-     *
-     * The `body` function provides the instructions to execute both
-     * during initial execution and during updating execution.
-     *
-     * Internally, this function starts by pushing a new frame, so
-     * that the body can return and sets the return point ($ra) to
-     * the ENDINITIAL label.
-     *
-     * It then executes the `args` function, which adds instructions
-     * responsible for pushing the arguments for the block to the
-     * stack. These arguments will be restored to the stack before
-     * updating execution.
-     *
-     * Next, it adds the Enter opcode, which marks the current position
-     * in the DOM, and remembers the current $pc (the next instruction)
-     * as the first instruction to execute during updating execution.
-     *
-     * Next, it runs `body`, which adds the opcodes that should
-     * execute both during initial execution and during updating execution.
-     * If the `body` wishes to finish early, it should Jump to the
-     * `FINALLY` label.
-     *
-     * Next, it adds the FINALLY label, followed by:
-     *
-     * - the Exit opcode, which finalizes the marked DOM started by the
-     *   Enter opcode.
-     * - the Return opcode, which returns to the current return point
-     *   ($ra).
-     *
-     * Finally, it adds the ENDINITIAL label followed by the PopFrame
-     * instruction, which restores $fp, $sp and $ra.
-     *
-     * # Updating Execution
-     *
-     * Updating execution for this `replayable` occurs if the `body` added an
-     * assertion, via one of the `JumpIf`, `JumpUnless` or `AssertSame` opcodes.
-     *
-     * If, during updating executon, the assertion fails, the initial VM is
-     * restored, and the stored arguments are pushed onto the stack. The DOM
-     * between the starting and ending markers is cleared, and the VM's cursor
-     * is set to the area just cleared.
-     *
-     * The return point ($ra) is set to -1, the exit instruction.
-     *
-     * Finally, the $pc is set to to the instruction saved off by the
-     * Enter opcode during initial execution, and execution proceeds as
-     * usual.
-     *
-     * The only difference is that when a `Return` instruction is
-     * encountered, the program jumps to -1 rather than the END label,
-     * and the PopFrame opcode is not needed.
-     */
-    replayable({ args, body }) {
-        // Start a new label frame, to give END and RETURN
-        // a unique meaning.
-        this.startLabels();
-        this.pushFrame();
-        // If the body invokes a block, its return will return to
-        // END. Otherwise, the return in RETURN will return to END.
-        this.returnTo('ENDINITIAL');
-        // Push the arguments onto the stack. The args() function
-        // tells us how many stack elements to retain for re-execution
-        // when updating.
-        let count = args();
-        // Start a new updating closure, remembering `count` elements
-        // from the stack. Everything after this point, and before END,
-        // will execute both initially and to update the block.
-        //
-        // The enter and exit opcodes also track the area of the DOM
-        // associated with this block. If an assertion inside the block
-        // fails (for example, the test value changes from true to false
-        // in an #if), the DOM is cleared and the program is re-executed,
-        // restoring `count` elements to the stack and executing the
-        // instructions between the enter and exit.
-        this.enter(count);
-        // Evaluate the body of the block. The body of the block may
-        // return, which will jump execution to END during initial
-        // execution, and exit the updating routine.
-        body();
-        // All execution paths in the body should run the FINALLY once
-        // they are done. It is executed both during initial execution
-        // and during updating execution.
-        this.label('FINALLY');
-        // Finalize the DOM.
-        this.exit();
-        // In initial execution, this is a noop: it returns to the
-        // immediately following opcode. In updating execution, this
-        // exits the updating routine.
-        this.return();
-        // Cleanup code for the block. Runs on initial execution
-        // but not on updating.
-        this.label('ENDINITIAL');
-        this.popFrame();
-        this.stopLabels();
-    }
-    /**
-     * A specialized version of the `replayable` convenience that allows the
-     * caller to provide different code based upon whether the item at
-     * the top of the stack is true or false.
-     *
-     * As in `replayable`, the `ifTrue` and `ifFalse` code can invoke `return`.
-     *
-     * During the initial execution, a `return` will continue execution
-     * in the cleanup code, which finalizes the current DOM block and pops
-     * the current frame.
-     *
-     * During the updating execution, a `return` will exit the updating
-     * routine, as it can reuse the DOM block and is always only a single
-     * frame deep.
-     */
-    replayableIf({ args, ifTrue, ifFalse }) {
-        this.replayable({
-            args,
-            body: () => {
-                // If the conditional is false, jump to the ELSE label.
-                this.jumpUnless('ELSE');
-                // Otherwise, execute the code associated with the true branch.
-                ifTrue();
-                // We're done, so return. In the initial execution, this runs
-                // the cleanup code. In the updating VM, it exits the updating
-                // routine.
-                this.jump('FINALLY');
-                this.label('ELSE');
-                // If the conditional is false, and code associatied ith the
-                // false branch was provided, execute it. If there was no code
-                // associated with the false branch, jumping to the else statement
-                // has no other behavior.
-                if (ifFalse) {
-                    ifFalse();
-                }
-            }
-        });
-    }
-    inlineBlock(block) {
-        return new CompilableBlock(this.compiler, {
-            block,
-            containingLayout: this.containingLayout
-        });
-    }
-    evalSymbols() {
-        let { containingLayout: { block } } = this;
-        return block.hasEval ? block.symbols : null;
-    }
-    compileParams(params) {
-        if (!params) return 0;
-        for (let i = 0; i < params.length; i++) {
-            this.expr(params[i]);
-        }
-        return params.length;
-    }
-    compileArgs(params, hash, blocks, synthetic) {
-        if (blocks) {
-            this.pushYieldableBlock(blocks.main);
-            this.pushYieldableBlock(blocks.else);
-            this.pushYieldableBlock(blocks.attrs);
-        }
-        let count = this.compileParams(params);
-        let flags = count << 4;
-        if (synthetic) flags |= 0b1000;
-        if (blocks) {
-            flags |= 0b111;
-        }
-        let names = EMPTY_ARRAY;
-        if (hash) {
-            names = hash[0];
-            let val = hash[1];
-            for (let i = 0; i < val.length; i++) {
-                this.expr(val[i]);
-            }
-        }
-        this.pushArgs(names, flags);
-    }
-    template(block) {
-        if (!block) return null;
-        return this.inlineBlock(block);
-    }
-}
-class LazyOpcodeBuilder extends OpcodeBuilder {
-    pushBlock(block) {
-        if (block) {
-            this.pushOther(block);
-        } else {
-            this.primitive(null);
-        }
-    }
-    resolveBlock() {
-        this.push(46 /* CompileBlock */);
-    }
-    pushLayout(layout) {
-        if (layout) {
-            this.pushOther(layout);
-        } else {
-            this.primitive(null);
-        }
-    }
-    resolveLayout() {
-        this.push(46 /* CompileBlock */);
-    }
-    invokeStatic(compilable) {
-        this.pushOther(compilable);
-        this.push(46 /* CompileBlock */);
-        this.pushMachine(49 /* InvokeVirtual */);
-    }
-    pushOther(value) {
-        this.push(12 /* Constant */, this.other(value));
-    }
-    other(value) {
-        return this.constants.other(value);
-    }
-}
-class EagerOpcodeBuilder extends OpcodeBuilder {
-    pushBlock(block) {
-        let handle = block ? block.compile() : null;
-        this.primitive(handle);
-    }
-    resolveBlock() {
-        return;
-    }
-    pushLayout(layout) {
-        if (layout) {
-            this.primitive(layout.compile());
-        } else {
-            this.primitive(null);
-        }
-    }
-    resolveLayout() {}
-    invokeStatic(compilable) {
-        let handle = compilable.compile();
-        // If the handle for the invoked component is not yet known (for example,
-        // because this is a recursive invocation and we're still compiling), push a
-        // function that will produce the correct handle when the heap is
-        // serialized.
-        if (handle === PLACEHOLDER_HANDLE$1) {
-            this.pushMachine(50 /* InvokeStatic */, () => compilable.compile());
-        } else {
-            this.pushMachine(50 /* InvokeStatic */, handle);
-        }
-    }
-}
-
-class LazyCompiler extends AbstractCompiler {
-    // FIXME: turn to static method
-    constructor(lookup, resolver, macros) {
-        let constants = new LazyConstants(resolver);
-        let program = new Program(constants);
-        super(macros, program, lookup);
-    }
-    builderFor(containingLayout) {
-        return new LazyOpcodeBuilder(this, containingLayout);
-    }
-}
-
-class PartialDefinition {
-    constructor(name, // for debugging
-    template) {
-        this.name = name;
-        this.template = template;
-    }
-    getPartial() {
-        let partial = this.template.asPartial();
-        let handle = partial.compile();
-        return { symbolTable: partial.symbolTable, handle };
-    }
-}
-
-let clientId = 0;
-function templateFactory({ id: templateId, meta, block }) {
-    let parsedBlock;
-    let id = templateId || `client-${clientId++}`;
-    let create = (compiler, envMeta) => {
-        let newMeta = envMeta ? assign({}, envMeta, meta) : meta;
-        if (!parsedBlock) {
-            parsedBlock = JSON.parse(block);
-        }
-        return new TemplateImpl(compiler, { id, block: parsedBlock, referrer: newMeta });
-    };
-    return { id, meta, create };
-}
-class TemplateImpl {
-    constructor(compiler, parsedLayout) {
-        this.compiler = compiler;
-        this.parsedLayout = parsedLayout;
-        this.layout = null;
-        this.partial = null;
-        this.wrappedLayout = null;
-        let { block } = parsedLayout;
-        this.symbols = block.symbols;
-        this.hasEval = block.hasEval;
-        this.referrer = parsedLayout.referrer;
-        this.id = parsedLayout.id || `client-${clientId++}`;
-    }
-    asLayout() {
-        if (this.layout) return this.layout;
-        return this.layout = new CompilableProgram(this.compiler, Object.assign({}, this.parsedLayout, { asPartial: false }));
-    }
-    asPartial() {
-        if (this.partial) return this.partial;
-        return this.layout = new CompilableProgram(this.compiler, Object.assign({}, this.parsedLayout, { asPartial: true }));
-    }
-    asWrappedLayout() {
-        if (this.wrappedLayout) return this.wrappedLayout;
-        return this.wrappedLayout = new WrappedBuilder(this.compiler, Object.assign({}, this.parsedLayout, { asPartial: false }));
-    }
-}
-
-export { ATTRS_BLOCK, Macros, LazyCompiler, compile, AbstractCompiler, debugCompiler, CompilableBlock, CompilableProgram, LazyOpcodeBuilder, EagerOpcodeBuilder, OpcodeBuilder, StdOpcodeBuilder, PartialDefinition, templateFactory, debug, debugSlice, logOpcode, WrappedBuilder, PLACEHOLDER_HANDLE };