@glimmer/runtime
Version:
Minimal runtime needed to render Glimmer templates
485 lines (385 loc) • 43.8 kB
JavaScript
var _a;
import { assert, Stack, symbol } from '@glimmer/util';
import { clear, ConcreteBounds, CursorImpl, SingleNodeBounds } from '../bounds';
import { destroy, registerDestructor } from '@glimmer/destroyable';
import { dynamicAttribute } from './attributes/dynamic';
class First {
constructor(node) {
this.node = node;
}
firstNode() {
return this.node;
}
}
class Last {
constructor(node) {
this.node = node;
}
lastNode() {
return this.node;
}
}
export class Fragment {
constructor(bounds) {
this.bounds = bounds;
}
parentElement() {
return this.bounds.parentElement();
}
firstNode() {
return this.bounds.firstNode();
}
lastNode() {
return this.bounds.lastNode();
}
}
export const CURSOR_STACK = symbol('CURSOR_STACK');
export class NewElementBuilder {
constructor(env, parentNode, nextSibling) {
this.constructing = null;
this.operations = null;
this[_a] = new Stack();
this.modifierStack = new Stack();
this.blockStack = new Stack();
this.pushElement(parentNode, nextSibling);
this.env = env;
this.dom = env.getAppendOperations();
this.updateOperations = env.getDOM();
}
static forInitialRender(env, cursor) {
return new this(env, cursor.element, cursor.nextSibling).initialize();
}
static resume(env, block) {
let parentNode = block.parentElement();
let nextSibling = block.reset(env);
let stack = new this(env, parentNode, nextSibling).initialize();
stack.pushLiveBlock(block);
return stack;
}
initialize() {
this.pushSimpleBlock();
return this;
}
debugBlocks() {
return this.blockStack.toArray();
}
get element() {
return this[CURSOR_STACK].current.element;
}
get nextSibling() {
return this[CURSOR_STACK].current.nextSibling;
}
get hasBlocks() {
return this.blockStack.size > 0;
}
block() {
return this.blockStack.current;
}
popElement() {
this[CURSOR_STACK].pop();
this[CURSOR_STACK].current;
}
pushSimpleBlock() {
return this.pushLiveBlock(new SimpleLiveBlock(this.element));
}
pushUpdatableBlock() {
return this.pushLiveBlock(new UpdatableBlockImpl(this.element));
}
pushBlockList(list) {
return this.pushLiveBlock(new LiveBlockList(this.element, list));
}
pushLiveBlock(block, isRemote = false) {
let current = this.blockStack.current;
if (current !== null) {
if (!isRemote) {
current.didAppendBounds(block);
}
}
this.__openBlock();
this.blockStack.push(block);
return block;
}
popBlock() {
this.block().finalize(this);
this.__closeBlock();
return this.blockStack.pop();
}
__openBlock() {}
__closeBlock() {} // todo return seems unused
openElement(tag) {
let element = this.__openElement(tag);
this.constructing = element;
return element;
}
__openElement(tag) {
return this.dom.createElement(tag, this.element);
}
flushElement(modifiers) {
let parent = this.element;
let element = this.constructing;
this.__flushElement(parent, element);
this.constructing = null;
this.operations = null;
this.pushModifiers(modifiers);
this.pushElement(element, null);
this.didOpenElement(element);
}
__flushElement(parent, constructing) {
this.dom.insertBefore(parent, constructing, this.nextSibling);
}
closeElement() {
this.willCloseElement();
this.popElement();
return this.popModifiers();
}
pushRemoteElement(element, guid, insertBefore) {
return this.__pushRemoteElement(element, guid, insertBefore);
}
__pushRemoteElement(element, _guid, insertBefore) {
this.pushElement(element, insertBefore);
if (insertBefore === undefined) {
while (element.lastChild) {
element.removeChild(element.lastChild);
}
}
let block = new RemoteLiveBlock(element);
return this.pushLiveBlock(block, true);
}
popRemoteElement() {
this.popBlock();
this.popElement();
}
pushElement(element, nextSibling = null) {
this[CURSOR_STACK].push(new CursorImpl(element, nextSibling));
}
pushModifiers(modifiers) {
this.modifierStack.push(modifiers);
}
popModifiers() {
return this.modifierStack.pop();
}
didAppendBounds(bounds) {
this.block().didAppendBounds(bounds);
return bounds;
}
didAppendNode(node) {
this.block().didAppendNode(node);
return node;
}
didOpenElement(element) {
this.block().openElement(element);
return element;
}
willCloseElement() {
this.block().closeElement();
}
appendText(string) {
return this.didAppendNode(this.__appendText(string));
}
__appendText(text) {
let {
dom,
element,
nextSibling
} = this;
let node = dom.createTextNode(text);
dom.insertBefore(element, node, nextSibling);
return node;
}
__appendNode(node) {
this.dom.insertBefore(this.element, node, this.nextSibling);
return node;
}
__appendFragment(fragment) {
let first = fragment.firstChild;
if (first) {
let ret = new ConcreteBounds(this.element, first, fragment.lastChild);
this.dom.insertBefore(this.element, fragment, this.nextSibling);
return ret;
} else {
return new SingleNodeBounds(this.element, this.__appendComment(''));
}
}
__appendHTML(html) {
return this.dom.insertHTMLBefore(this.element, this.nextSibling, html);
}
appendDynamicHTML(value) {
let bounds = this.trustedContent(value);
this.didAppendBounds(bounds);
}
appendDynamicText(value) {
let node = this.untrustedContent(value);
this.didAppendNode(node);
return node;
}
appendDynamicFragment(value) {
let bounds = this.__appendFragment(value);
this.didAppendBounds(bounds);
}
appendDynamicNode(value) {
let node = this.__appendNode(value);
let bounds = new SingleNodeBounds(this.element, node);
this.didAppendBounds(bounds);
}
trustedContent(value) {
return this.__appendHTML(value);
}
untrustedContent(value) {
return this.__appendText(value);
}
appendComment(string) {
return this.didAppendNode(this.__appendComment(string));
}
__appendComment(string) {
let {
dom,
element,
nextSibling
} = this;
let node = dom.createComment(string);
dom.insertBefore(element, node, nextSibling);
return node;
}
__setAttribute(name, value, namespace) {
this.dom.setAttribute(this.constructing, name, value, namespace);
}
__setProperty(name, value) {
this.constructing[name] = value;
}
setStaticAttribute(name, value, namespace) {
this.__setAttribute(name, value, namespace);
}
setDynamicAttribute(name, value, trusting, namespace) {
let element = this.constructing;
let attribute = dynamicAttribute(element, name, namespace, trusting);
attribute.set(this, value, this.env);
return attribute;
}
}
_a = CURSOR_STACK;
export class SimpleLiveBlock {
constructor(parent) {
this.parent = parent;
this.first = null;
this.last = null;
this.nesting = 0;
}
parentElement() {
return this.parent;
}
firstNode() {
let first = this.first;
return first.firstNode();
}
lastNode() {
let last = this.last;
return last.lastNode();
}
openElement(element) {
this.didAppendNode(element);
this.nesting++;
}
closeElement() {
this.nesting--;
}
didAppendNode(node) {
if (this.nesting !== 0) return;
if (!this.first) {
this.first = new First(node);
}
this.last = new Last(node);
}
didAppendBounds(bounds) {
if (this.nesting !== 0) return;
if (!this.first) {
this.first = bounds;
}
this.last = bounds;
}
finalize(stack) {
if (this.first === null) {
stack.appendComment('');
}
}
}
export class RemoteLiveBlock extends SimpleLiveBlock {
constructor(parent) {
super(parent);
registerDestructor(this, () => {
// In general, you only need to clear the root of a hierarchy, and should never
// need to clear any child nodes. This is an important constraint that gives us
// a strong guarantee that clearing a subtree is a single DOM operation.
//
// Because remote blocks are not normally physically nested inside of the tree
// that they are logically nested inside, we manually clear remote blocks when
// a logical parent is cleared.
//
// HOWEVER, it is currently possible for a remote block to be physically nested
// inside of the block it is logically contained inside of. This happens when
// the remote block is appended to the end of the application's entire element.
//
// The problem with that scenario is that Glimmer believes that it owns more of
// the DOM than it actually does. The code is attempting to write past the end
// of the Glimmer-managed root, but Glimmer isn't aware of that.
//
// The correct solution to that problem is for Glimmer to be aware of the end
// of the bounds that it owns, and once we make that change, this check could
// be removed.
//
// For now, a more targeted fix is to check whether the node was already removed
// and avoid clearing the node if it was. In most cases this shouldn't happen,
// so this might hide bugs where the code clears nested nodes unnecessarily,
// so we should eventually try to do the correct fix.
if (this.parentElement() === this.firstNode().parentNode) {
clear(this);
}
});
}
}
export class UpdatableBlockImpl extends SimpleLiveBlock {
reset() {
destroy(this);
let nextSibling = clear(this);
this.first = null;
this.last = null;
this.nesting = 0;
return nextSibling;
}
} // FIXME: All the noops in here indicate a modelling problem
export class LiveBlockList {
constructor(parent, boundList) {
this.parent = parent;
this.boundList = boundList;
this.parent = parent;
this.boundList = boundList;
}
parentElement() {
return this.parent;
}
firstNode() {
let head = this.boundList[0];
return head.firstNode();
}
lastNode() {
let boundList = this.boundList;
let tail = boundList[boundList.length - 1];
return tail.lastNode();
}
openElement(_element) {
(false && assert(false, 'Cannot openElement directly inside a block list'));
}
closeElement() {
(false && assert(false, 'Cannot closeElement directly inside a block list'));
}
didAppendNode(_node) {
(false && assert(false, 'Cannot create a new node directly inside a block list'));
}
didAppendBounds(_bounds) {}
finalize(_stack) {
(false && assert(this.boundList.length > 0, 'boundsList cannot be empty'));
}
}
export function clientBuilder(env, cursor) {
return NewElementBuilder.forInitialRender(env, cursor);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../packages/@glimmer/runtime/lib/vm/element-builder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Bounds,\n  Cursor,\n  CursorStackSymbol,\n  ElementBuilder,\n  ElementOperations,\n  Environment,\n  GlimmerTreeChanges,\n  GlimmerTreeConstruction,\n  LiveBlock,\n  Maybe,\n  Option,\n  UpdatableBlock,\n  ModifierInstance,\n} from '@glimmer/interfaces';\nimport { assert, expect, Stack, symbol } from '@glimmer/util';\nimport {\n  AttrNamespace,\n  SimpleComment,\n  SimpleDocumentFragment,\n  SimpleElement,\n  SimpleNode,\n  SimpleText,\n} from '@simple-dom/interface';\nimport { clear, ConcreteBounds, CursorImpl, SingleNodeBounds } from '../bounds';\nimport { destroy, registerDestructor } from '@glimmer/destroyable';\nimport { DynamicAttribute, dynamicAttribute } from './attributes/dynamic';\n\nexport interface FirstNode {\n  firstNode(): SimpleNode;\n}\n\nexport interface LastNode {\n  lastNode(): SimpleNode;\n}\n\nclass First {\n  constructor(private node: SimpleNode) {}\n\n  firstNode(): SimpleNode {\n    return this.node;\n  }\n}\n\nclass Last {\n  constructor(private node: SimpleNode) {}\n\n  lastNode(): SimpleNode {\n    return this.node;\n  }\n}\n\nexport class Fragment implements Bounds {\n  private bounds: Bounds;\n\n  constructor(bounds: Bounds) {\n    this.bounds = bounds;\n  }\n\n  parentElement(): SimpleElement {\n    return this.bounds.parentElement();\n  }\n\n  firstNode(): SimpleNode {\n    return this.bounds.firstNode();\n  }\n\n  lastNode(): SimpleNode {\n    return this.bounds.lastNode();\n  }\n}\n\nexport const CURSOR_STACK: CursorStackSymbol = symbol('CURSOR_STACK');\n\nexport class NewElementBuilder implements ElementBuilder {\n  public dom: GlimmerTreeConstruction;\n  public updateOperations: GlimmerTreeChanges;\n  public constructing: Option<SimpleElement> = null;\n  public operations: Option<ElementOperations> = null;\n  private env: Environment;\n\n  [CURSOR_STACK] = new Stack<Cursor>();\n  private modifierStack = new Stack<Option<ModifierInstance[]>>();\n  private blockStack = new Stack<LiveBlock>();\n\n  static forInitialRender(env: Environment, cursor: CursorImpl) {\n    return new this(env, cursor.element, cursor.nextSibling).initialize();\n  }\n\n  static resume(env: Environment, block: UpdatableBlock): NewElementBuilder {\n    let parentNode = block.parentElement();\n    let nextSibling = block.reset(env);\n\n    let stack = new this(env, parentNode, nextSibling).initialize();\n    stack.pushLiveBlock(block);\n\n    return stack;\n  }\n\n  constructor(env: Environment, parentNode: SimpleElement, nextSibling: Option<SimpleNode>) {\n    this.pushElement(parentNode, nextSibling);\n\n    this.env = env;\n    this.dom = env.getAppendOperations();\n    this.updateOperations = env.getDOM();\n  }\n\n  protected initialize(): this {\n    this.pushSimpleBlock();\n    return this;\n  }\n\n  debugBlocks(): LiveBlock[] {\n    return this.blockStack.toArray();\n  }\n\n  get element(): SimpleElement {\n    return this[CURSOR_STACK].current!.element;\n  }\n\n  get nextSibling(): Option<SimpleNode> {\n    return this[CURSOR_STACK].current!.nextSibling;\n  }\n\n  get hasBlocks() {\n    return this.blockStack.size > 0;\n  }\n\n  protected block(): LiveBlock {\n    return expect(this.blockStack.current, 'Expected a current live block');\n  }\n\n  popElement() {\n    this[CURSOR_STACK].pop();\n    expect(this[CURSOR_STACK].current, \"can't pop past the last element\");\n  }\n\n  pushSimpleBlock(): LiveBlock {\n    return this.pushLiveBlock(new SimpleLiveBlock(this.element));\n  }\n\n  pushUpdatableBlock(): UpdatableBlockImpl {\n    return this.pushLiveBlock(new UpdatableBlockImpl(this.element));\n  }\n\n  pushBlockList(list: LiveBlock[]): LiveBlockList {\n    return this.pushLiveBlock(new LiveBlockList(this.element, list));\n  }\n\n  protected pushLiveBlock<T extends LiveBlock>(block: T, isRemote = false): T {\n    let current = this.blockStack.current;\n\n    if (current !== null) {\n      if (!isRemote) {\n        current.didAppendBounds(block);\n      }\n    }\n\n    this.__openBlock();\n    this.blockStack.push(block);\n    return block;\n  }\n\n  popBlock(): LiveBlock {\n    this.block().finalize(this);\n    this.__closeBlock();\n    return expect(this.blockStack.pop(), 'Expected popBlock to return a block');\n  }\n\n  __openBlock(): void {}\n  __closeBlock(): void {}\n\n  // todo return seems unused\n  openElement(tag: string): SimpleElement {\n    let element = this.__openElement(tag);\n    this.constructing = element;\n\n    return element;\n  }\n\n  __openElement(tag: string): SimpleElement {\n    return this.dom.createElement(tag, this.element);\n  }\n\n  flushElement(modifiers: Option<ModifierInstance[]>) {\n    let parent = this.element;\n    let element = expect(\n      this.constructing,\n      `flushElement should only be called when constructing an element`\n    );\n\n    this.__flushElement(parent, element);\n\n    this.constructing = null;\n    this.operations = null;\n\n    this.pushModifiers(modifiers);\n    this.pushElement(element, null);\n    this.didOpenElement(element);\n  }\n\n  __flushElement(parent: SimpleElement, constructing: SimpleElement) {\n    this.dom.insertBefore(parent, constructing, this.nextSibling);\n  }\n\n  closeElement(): Option<ModifierInstance[]> {\n    this.willCloseElement();\n    this.popElement();\n    return this.popModifiers();\n  }\n\n  pushRemoteElement(\n    element: SimpleElement,\n    guid: string,\n    insertBefore: Maybe<SimpleNode>\n  ): Option<RemoteLiveBlock> {\n    return this.__pushRemoteElement(element, guid, insertBefore);\n  }\n\n  __pushRemoteElement(\n    element: SimpleElement,\n    _guid: string,\n    insertBefore: Maybe<SimpleNode>\n  ): Option<RemoteLiveBlock> {\n    this.pushElement(element, insertBefore);\n\n    if (insertBefore === undefined) {\n      while (element.lastChild) {\n        element.removeChild(element.lastChild);\n      }\n    }\n\n    let block = new RemoteLiveBlock(element);\n\n    return this.pushLiveBlock(block, true);\n  }\n\n  popRemoteElement() {\n    this.popBlock();\n    this.popElement();\n  }\n\n  protected pushElement(element: SimpleElement, nextSibling: Maybe<SimpleNode> = null) {\n    this[CURSOR_STACK].push(new CursorImpl(element, nextSibling));\n  }\n\n  private pushModifiers(modifiers: Option<ModifierInstance[]>): void {\n    this.modifierStack.push(modifiers);\n  }\n\n  private popModifiers(): Option<ModifierInstance[]> {\n    return this.modifierStack.pop();\n  }\n\n  didAppendBounds(bounds: Bounds): Bounds {\n    this.block().didAppendBounds(bounds);\n    return bounds;\n  }\n\n  didAppendNode<T extends SimpleNode>(node: T): T {\n    this.block().didAppendNode(node);\n    return node;\n  }\n\n  didOpenElement(element: SimpleElement): SimpleElement {\n    this.block().openElement(element);\n    return element;\n  }\n\n  willCloseElement() {\n    this.block().closeElement();\n  }\n\n  appendText(string: string): SimpleText {\n    return this.didAppendNode(this.__appendText(string));\n  }\n\n  __appendText(text: string): SimpleText {\n    let { dom, element, nextSibling } = this;\n    let node = dom.createTextNode(text);\n    dom.insertBefore(element, node, nextSibling);\n    return node;\n  }\n\n  __appendNode(node: SimpleNode): SimpleNode {\n    this.dom.insertBefore(this.element, node, this.nextSibling);\n    return node;\n  }\n\n  __appendFragment(fragment: SimpleDocumentFragment): Bounds {\n    let first = fragment.firstChild;\n\n    if (first) {\n      let ret = new ConcreteBounds(this.element, first, fragment.lastChild!);\n      this.dom.insertBefore(this.element, fragment, this.nextSibling);\n      return ret;\n    } else {\n      return new SingleNodeBounds(this.element, this.__appendComment(''));\n    }\n  }\n\n  __appendHTML(html: string): Bounds {\n    return this.dom.insertHTMLBefore(this.element, this.nextSibling, html);\n  }\n\n  appendDynamicHTML(value: string): void {\n    let bounds = this.trustedContent(value);\n    this.didAppendBounds(bounds);\n  }\n\n  appendDynamicText(value: string): SimpleText {\n    let node = this.untrustedContent(value);\n    this.didAppendNode(node);\n    return node;\n  }\n\n  appendDynamicFragment(value: SimpleDocumentFragment): void {\n    let bounds = this.__appendFragment(value);\n    this.didAppendBounds(bounds);\n  }\n\n  appendDynamicNode(value: SimpleNode): void {\n    let node = this.__appendNode(value);\n    let bounds = new SingleNodeBounds(this.element, node);\n    this.didAppendBounds(bounds);\n  }\n\n  private trustedContent(value: string): Bounds {\n    return this.__appendHTML(value);\n  }\n\n  private untrustedContent(value: string): SimpleText {\n    return this.__appendText(value);\n  }\n\n  appendComment(string: string): SimpleComment {\n    return this.didAppendNode(this.__appendComment(string));\n  }\n\n  __appendComment(string: string): SimpleComment {\n    let { dom, element, nextSibling } = this;\n    let node = dom.createComment(string);\n    dom.insertBefore(element, node, nextSibling);\n    return node;\n  }\n\n  __setAttribute(name: string, value: string, namespace: Option<AttrNamespace>): void {\n    this.dom.setAttribute(this.constructing!, name, value, namespace);\n  }\n\n  __setProperty(name: string, value: unknown): void {\n    (this.constructing! as any)[name] = value;\n  }\n\n  setStaticAttribute(name: string, value: string, namespace: Option<AttrNamespace>): void {\n    this.__setAttribute(name, value, namespace);\n  }\n\n  setDynamicAttribute(\n    name: string,\n    value: unknown,\n    trusting: boolean,\n    namespace: Option<AttrNamespace>\n  ): DynamicAttribute {\n    let element = this.constructing!;\n    let attribute = dynamicAttribute(element, name, namespace, trusting);\n    attribute.set(this, value, this.env);\n    return attribute;\n  }\n}\n\nexport class SimpleLiveBlock implements LiveBlock {\n  protected first: Option<FirstNode> = null;\n  protected last: Option<LastNode> = null;\n  protected nesting = 0;\n\n  constructor(private parent: SimpleElement) {}\n\n  parentElement() {\n    return this.parent;\n  }\n\n  firstNode(): SimpleNode {\n    let first = expect(\n      this.first,\n      'cannot call `firstNode()` while `SimpleLiveBlock` is still initializing'\n    );\n\n    return first.firstNode();\n  }\n\n  lastNode(): SimpleNode {\n    let last = expect(\n      this.last,\n      'cannot call `lastNode()` while `SimpleLiveBlock` is still initializing'\n    );\n\n    return last.lastNode();\n  }\n\n  openElement(element: SimpleElement) {\n    this.didAppendNode(element);\n    this.nesting++;\n  }\n\n  closeElement() {\n    this.nesting--;\n  }\n\n  didAppendNode(node: SimpleNode) {\n    if (this.nesting !== 0) return;\n\n    if (!this.first) {\n      this.first = new First(node);\n    }\n\n    this.last = new Last(node);\n  }\n\n  didAppendBounds(bounds: Bounds) {\n    if (this.nesting !== 0) return;\n\n    if (!this.first) {\n      this.first = bounds;\n    }\n\n    this.last = bounds;\n  }\n\n  finalize(stack: ElementBuilder) {\n    if (this.first === null) {\n      stack.appendComment('');\n    }\n  }\n}\n\nexport class RemoteLiveBlock extends SimpleLiveBlock {\n  constructor(parent: SimpleElement) {\n    super(parent);\n\n    registerDestructor(this, () => {\n      // In general, you only need to clear the root of a hierarchy, and should never\n      // need to clear any child nodes. This is an important constraint that gives us\n      // a strong guarantee that clearing a subtree is a single DOM operation.\n      //\n      // Because remote blocks are not normally physically nested inside of the tree\n      // that they are logically nested inside, we manually clear remote blocks when\n      // a logical parent is cleared.\n      //\n      // HOWEVER, it is currently possible for a remote block to be physically nested\n      // inside of the block it is logically contained inside of. This happens when\n      // the remote block is appended to the end of the application's entire element.\n      //\n      // The problem with that scenario is that Glimmer believes that it owns more of\n      // the DOM than it actually does. The code is attempting to write past the end\n      // of the Glimmer-managed root, but Glimmer isn't aware of that.\n      //\n      // The correct solution to that problem is for Glimmer to be aware of the end\n      // of the bounds that it owns, and once we make that change, this check could\n      // be removed.\n      //\n      // For now, a more targeted fix is to check whether the node was already removed\n      // and avoid clearing the node if it was. In most cases this shouldn't happen,\n      // so this might hide bugs where the code clears nested nodes unnecessarily,\n      // so we should eventually try to do the correct fix.\n      if (this.parentElement() === this.firstNode().parentNode) {\n        clear(this);\n      }\n    });\n  }\n}\n\nexport class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBlock {\n  reset(): Option<SimpleNode> {\n    destroy(this);\n    let nextSibling = clear(this);\n\n    this.first = null;\n    this.last = null;\n    this.nesting = 0;\n\n    return nextSibling;\n  }\n}\n\n// FIXME: All the noops in here indicate a modelling problem\nexport class LiveBlockList implements LiveBlock {\n  constructor(private readonly parent: SimpleElement, public boundList: LiveBlock[]) {\n    this.parent = parent;\n    this.boundList = boundList;\n  }\n\n  parentElement() {\n    return this.parent;\n  }\n\n  firstNode(): SimpleNode {\n    let head = expect(\n      this.boundList[0],\n      'cannot call `firstNode()` while `LiveBlockList` is still initializing'\n    );\n\n    return head.firstNode();\n  }\n\n  lastNode(): SimpleNode {\n    let boundList = this.boundList;\n\n    let tail = expect(\n      boundList[boundList.length - 1],\n      'cannot call `lastNode()` while `LiveBlockList` is still initializing'\n    );\n\n    return tail.lastNode();\n  }\n\n  openElement(_element: SimpleElement) {\n    assert(false, 'Cannot openElement directly inside a block list');\n  }\n\n  closeElement() {\n    assert(false, 'Cannot closeElement directly inside a block list');\n  }\n\n  didAppendNode(_node: SimpleNode) {\n    assert(false, 'Cannot create a new node directly inside a block list');\n  }\n\n  didAppendBounds(_bounds: Bounds) {}\n\n  finalize(_stack: ElementBuilder) {\n    assert(this.boundList.length > 0, 'boundsList cannot be empty');\n  }\n}\n\nexport function clientBuilder(env: Environment, cursor: CursorImpl): ElementBuilder {\n  return NewElementBuilder.forInitialRender(env, cursor);\n}\n"],"sourceRoot":""}