@glimmer/runtime/dist/commonjs/es2017/lib/compiled/opcodes/component.js

Minimal runtime needed to render Glimmer templates

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DidUpdateLayoutOpcode = exports.UpdateComponentOpcode = exports.ComponentElementOperations = void 0;

var _env = require("@glimmer/env");

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

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

var _vm2 = require("@glimmer/vm");

var _destroyable = require("@glimmer/destroyable");

var _manager = require("@glimmer/manager");

var _resolve = require("../../component/resolve");

var _interfaces = require("../../component/interfaces");

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

var _classList = _interopRequireDefault(require("../../references/class-list"));

var _symbols = require("../../symbols");

var _arguments = require("../../vm/arguments");

var _dom = require("./dom");

var _curriedValue = require("../../curried-value");

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

_opcodes.APPEND_OPCODES.add(78
/* PushComponentDefinition */
, (vm, {
  op1: handle
}) => {
  let definition = vm[_symbols.CONSTANTS].getValue(handle);

  false && (0, _util.assert)(!!definition, `Missing component for ${handle}`);
  let {
    manager,
    capabilities
  } = definition;
  let instance = {
    definition,
    manager,
    capabilities,
    state: null,
    handle: null,
    table: null,
    lookup: null
  };
  vm.stack.push(instance);
});

_opcodes.APPEND_OPCODES.add(80
/* ResolveDynamicComponent */
, (vm, {
  op1: _isStrict
}) => {
  let stack = vm.stack;
  let component = (0, _reference.valueForRef)(stack.pop());
  let constants = vm[_symbols.CONSTANTS];
  let owner = vm.getOwner();
  let isStrict = constants.getValue(_isStrict);
  vm.loadValue(_vm2.$t1, null); // Clear the temp register

  let definition;

  if (typeof component === 'string') {
    if (_env.DEBUG && isStrict) {
      throw new Error(`Attempted to resolve a dynamic component with a string definition, \`${component}\` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.`);
    }

    let resolvedDefinition = (0, _resolve.resolveComponent)(vm.runtime.resolver, constants, component, owner);
    definition = resolvedDefinition;
  } else if ((0, _curriedValue.isCurriedValue)(component)) {
    definition = component;
  } else {
    definition = constants.component(component, owner);
  }

  stack.push(definition);
});

_opcodes.APPEND_OPCODES.add(81
/* ResolveCurriedComponent */
, vm => {
  let stack = vm.stack;
  let ref = stack.pop();
  let value = (0, _reference.valueForRef)(ref);
  let constants = vm[_symbols.CONSTANTS];
  let definition;

  if (_env.DEBUG && !(typeof value === 'function' || typeof value === 'object' && value !== null)) {
    throw new Error(`Expected a component definition, but received ${value}. You may have accidentally done <${ref.debugLabel}>, where "${ref.debugLabel}" was a string instead of a curried component definition. You must either use the component definition directly, or use the {{component}} helper to create a curried component definition when invoking dynamically.`);
  }

  if ((0, _curriedValue.isCurriedValue)(value)) {
    definition = value;
  } else {
    definition = constants.component(value, vm.getOwner(), true);

    if (_env.DEBUG && definition === null) {
      throw new Error(`Expected a dynamic component definition, but received an object or function that did not have a component manager associated with it. The dynamic invocation was \`<${ref.debugLabel}>\` or \`{{${ref.debugLabel}}}\`, and the incorrect definition is the value at the path \`${ref.debugLabel}\`, which was: ${(0, _util.debugToString)(value)}`);
    }
  }

  stack.push(definition);
});

_opcodes.APPEND_OPCODES.add(79
/* PushDynamicComponentInstance */
, vm => {
  let {
    stack
  } = vm;
  let definition = stack.pop();
  let capabilities, manager;

  if ((0, _curriedValue.isCurriedValue)(definition)) {
    manager = capabilities = null;
  } else {
    manager = definition.manager;
    capabilities = definition.capabilities;
  }

  stack.push({
    definition,
    capabilities,
    manager,
    state: null,
    handle: null,
    table: null
  });
});

_opcodes.APPEND_OPCODES.add(82
/* PushArgs */
, (vm, {
  op1: _names,
  op2: _blockNames,
  op3: flags
}) => {
  let stack = vm.stack;

  let names = vm[_symbols.CONSTANTS].getArray(_names);

  let positionalCount = flags >> 4;
  let atNames = flags & 0b1000;
  let blockNames = flags & 0b0111 ? vm[_symbols.CONSTANTS].getArray(_blockNames) : _util.EMPTY_STRING_ARRAY;

  vm[_symbols.ARGS].setup(stack, names, blockNames, positionalCount, !!atNames);

  stack.push(vm[_symbols.ARGS]);
});

_opcodes.APPEND_OPCODES.add(83
/* PushEmptyArgs */
, vm => {
  let {
    stack
  } = vm;
  stack.push(vm[_symbols.ARGS].empty(stack));
});

_opcodes.APPEND_OPCODES.add(86
/* CaptureArgs */
, vm => {
  let stack = vm.stack;
  let args = stack.pop();
  let capturedArgs = args.capture();
  stack.push(capturedArgs);
});

_opcodes.APPEND_OPCODES.add(85
/* PrepareArgs */
, (vm, {
  op1: _state
}) => {
  let stack = vm.stack;
  let instance = vm.fetchValue(_state);
  let args = stack.pop();
  let {
    definition
  } = instance;

  if ((0, _curriedValue.isCurriedType)(definition, 0
  /* Component */
  )) {
    false && (0, _util.assert)(!definition.manager, "If the component definition was curried, we don't yet have a manager");
    let constants = vm[_symbols.CONSTANTS];
    let {
      definition: resolvedDefinition,
      owner,
      resolved,
      positional,
      named
    } = (0, _curriedValue.resolveCurriedValue)(definition);

    if (resolved === true) {
      definition = resolvedDefinition;
    } else if (typeof resolvedDefinition === 'string') {
      let resolvedValue = vm.runtime.resolver.lookupComponent(resolvedDefinition, owner);
      definition = constants.resolvedComponent(resolvedValue, resolvedDefinition);
    } else {
      definition = constants.component(resolvedDefinition, owner);
    }

    if (named !== undefined) {
      args.named.merge((0, _util.assign)({}, ...named));
    }

    if (positional !== undefined) {
      args.realloc(positional.length);
      args.positional.prepend(positional);
    }

    let {
      manager
    } = definition;
    false && (0, _util.assert)(instance.manager === null, 'component instance manager should not be populated yet');
    false && (0, _util.assert)(instance.capabilities === null, 'component instance manager should not be populated yet');
    instance.definition = definition;
    instance.manager = manager;
    instance.capabilities = definition.capabilities; // Save off the owner that this component was curried with. Later on,
    // we'll fetch the value of this register and set it as the owner on the
    // new root scope.

    vm.loadValue(_vm2.$t1, owner);
  }

  let {
    manager,
    state
  } = definition;
  let capabilities = instance.capabilities;

  if (!(0, _manager.managerHasCapability)(manager, capabilities, 4
  /* PrepareArgs */
  )) {
    stack.push(args);
    return;
  }

  let blocks = args.blocks.values;
  let blockNames = args.blocks.names;
  let preparedArgs = manager.prepareArgs(state, args);

  if (preparedArgs) {
    args.clear();

    for (let i = 0; i < blocks.length; i++) {
      stack.push(blocks[i]);
    }

    let {
      positional,
      named
    } = preparedArgs;
    let positionalCount = positional.length;

    for (let i = 0; i < positionalCount; i++) {
      stack.push(positional[i]);
    }

    let names = Object.keys(named);

    for (let i = 0; i < names.length; i++) {
      stack.push(named[names[i]]);
    }

    args.setup(stack, names, blockNames, positionalCount, false);
  }

  stack.push(args);
});

_opcodes.APPEND_OPCODES.add(87
/* CreateComponent */
, (vm, {
  op1: flags,
  op2: _state
}) => {
  let instance = vm.fetchValue(_state);
  let {
    definition,
    manager,
    capabilities
  } = instance;

  if (!(0, _manager.managerHasCapability)(manager, capabilities, 512
  /* CreateInstance */
  )) {
    // TODO: Closure and Main components are always invoked dynamically, so this
    // opcode may run even if this capability is not enabled. In the future we
    // should handle this in a better way.
    return;
  }

  let dynamicScope = null;

  if ((0, _manager.managerHasCapability)(manager, capabilities, 64
  /* DynamicScope */
  )) {
    dynamicScope = vm.dynamicScope();
  }

  let hasDefaultBlock = flags & 1;
  let args = null;

  if ((0, _manager.managerHasCapability)(manager, capabilities, 8
  /* CreateArgs */
  )) {
    args = vm.stack.peek();
  }

  let self = null;

  if ((0, _manager.managerHasCapability)(manager, capabilities, 128
  /* CreateCaller */
  )) {
    self = vm.getSelf();
  }

  let state = manager.create(vm.getOwner(), definition.state, args, vm.env, dynamicScope, self, !!hasDefaultBlock); // We want to reuse the `state` POJO here, because we know that the opcodes
  // only transition at exactly one place.

  instance.state = state;

  if ((0, _manager.managerHasCapability)(manager, capabilities, 256
  /* UpdateHook */
  )) {
    vm.updateWith(new UpdateComponentOpcode(state, manager, dynamicScope));
  }
});

_opcodes.APPEND_OPCODES.add(88
/* RegisterComponentDestructor */
, (vm, {
  op1: _state
}) => {
  let {
    manager,
    state,
    capabilities
  } = vm.fetchValue(_state);
  let d = manager.getDestroyable(state);

  if (_env.DEBUG && !(0, _manager.managerHasCapability)(manager, capabilities, 2048
  /* WillDestroy */
  ) && d !== null && typeof 'willDestroy' in d) {
    throw new Error('BUG: Destructor has willDestroy, but the willDestroy capability was not enabled for this component. Pre-destruction hooks must be explicitly opted into');
  }

  if (d) vm.associateDestroyable(d);
});

_opcodes.APPEND_OPCODES.add(97
/* BeginComponentTransaction */
, (vm, {
  op1: _state
}) => {
  var _a;

  let name;

  if (_env.DEBUG) {
    let {
      definition,
      manager
    } = vm.fetchValue(_state);
    name = (_a = definition.resolvedName) !== null && _a !== void 0 ? _a : manager.getDebugName(definition.state);
  }

  vm.beginCacheGroup(name);
  vm.elements().pushSimpleBlock();
});

_opcodes.APPEND_OPCODES.add(89
/* PutComponentOperations */
, vm => {
  vm.loadValue(_vm2.$t0, new ComponentElementOperations());
});

_opcodes.APPEND_OPCODES.add(53
/* ComponentAttr */
, (vm, {
  op1: _name,
  op2: _trusting,
  op3: _namespace
}) => {
  let name = vm[_symbols.CONSTANTS].getValue(_name);

  let trusting = vm[_symbols.CONSTANTS].getValue(_trusting);

  let reference = vm.stack.pop();
  let namespace = _namespace ? vm[_symbols.CONSTANTS].getValue(_namespace) : null;
  vm.fetchValue(_vm2.$t0).setAttribute(name, reference, trusting, namespace);
});

_opcodes.APPEND_OPCODES.add(105
/* StaticComponentAttr */
, (vm, {
  op1: _name,
  op2: _value,
  op3: _namespace
}) => {
  let name = vm[_symbols.CONSTANTS].getValue(_name);

  let value = vm[_symbols.CONSTANTS].getValue(_value);

  let namespace = _namespace ? vm[_symbols.CONSTANTS].getValue(_namespace) : null;
  vm.fetchValue(_vm2.$t0).setStaticAttribute(name, value, namespace);
});

class ComponentElementOperations {
  constructor() {
    this.attributes = (0, _util.dict)();
    this.classes = [];
    this.modifiers = [];
  }

  setAttribute(name, value, trusting, namespace) {
    let deferred = {
      value,
      namespace,
      trusting
    };

    if (name === 'class') {
      this.classes.push(value);
    }

    this.attributes[name] = deferred;
  }

  setStaticAttribute(name, value, namespace) {
    let deferred = {
      value,
      namespace
    };

    if (name === 'class') {
      this.classes.push(value);
    }

    this.attributes[name] = deferred;
  }

  addModifier(modifier) {
    this.modifiers.push(modifier);
  }

  flush(vm) {
    let type;
    let attributes = this.attributes;

    for (let name in this.attributes) {
      if (name === 'type') {
        type = attributes[name];
        continue;
      }

      let attr = this.attributes[name];

      if (name === 'class') {
        setDeferredAttr(vm, 'class', mergeClasses(this.classes), attr.namespace, attr.trusting);
      } else {
        setDeferredAttr(vm, name, attr.value, attr.namespace, attr.trusting);
      }
    }

    if (type !== undefined) {
      setDeferredAttr(vm, 'type', type.value, type.namespace, type.trusting);
    }

    return this.modifiers;
  }

}

exports.ComponentElementOperations = ComponentElementOperations;

function mergeClasses(classes) {
  if (classes.length === 0) {
    return '';
  }

  if (classes.length === 1) {
    return classes[0];
  }

  if (allStringClasses(classes)) {
    return classes.join(' ');
  }

  return (0, _classList.default)(classes);
}

function allStringClasses(classes) {
  for (let i = 0; i < classes.length; i++) {
    if (typeof classes[i] !== 'string') {
      return false;
    }
  }

  return true;
}

function setDeferredAttr(vm, name, value, namespace, trusting = false) {
  if (typeof value === 'string') {
    vm.elements().setStaticAttribute(name, value, namespace);
  } else {
    let attribute = vm.elements().setDynamicAttribute(name, (0, _reference.valueForRef)(value), trusting, namespace);

    if (!(0, _reference.isConstRef)(value)) {
      vm.updateWith(new _dom.UpdateDynamicAttributeOpcode(value, attribute, vm.env));
    }
  }
}

_opcodes.APPEND_OPCODES.add(99
/* DidCreateElement */
, (vm, {
  op1: _state
}) => {
  let {
    definition,
    state
  } = vm.fetchValue(_state);
  let {
    manager
  } = definition;
  let operations = vm.fetchValue(_vm2.$t0);
  manager.didCreateElement(state, vm.elements().constructing, operations);
});

_opcodes.APPEND_OPCODES.add(90
/* GetComponentSelf */
, (vm, {
  op1: _state,
  op2: _names
}) => {
  var _a;

  let instance = vm.fetchValue(_state);
  let {
    definition,
    state
  } = instance;
  let {
    manager
  } = definition;
  let selfRef = manager.getSelf(state);

  if (vm.env.debugRenderTree !== undefined) {
    let instance = vm.fetchValue(_state);
    let {
      definition,
      manager
    } = instance;
    let args;

    if (vm.stack.peek() === vm[_symbols.ARGS]) {
      args = vm[_symbols.ARGS].capture();
    } else {
      let names = vm[_symbols.CONSTANTS].getArray(_names);

      vm[_symbols.ARGS].setup(vm.stack, names, [], 0, true);

      args = vm[_symbols.ARGS].capture();
    }

    let moduleName;
    let compilable = definition.compilable;

    if (compilable === null) {
      false && (0, _util.assert)((0, _manager.managerHasCapability)(manager, instance.capabilities, 1
      /* DynamicLayout */
      ), 'BUG: No template was found for this component, and the component did not have the dynamic layout capability');
      compilable = manager.getDynamicLayout(state, vm.runtime.resolver);

      if (compilable !== null) {
        moduleName = compilable.moduleName;
      } else {
        moduleName = '__default__.hbs';
      }
    } else {
      moduleName = compilable.moduleName;
    } // For tearing down the debugRenderTree


    vm.associateDestroyable(instance);

    if ((0, _interfaces.hasCustomDebugRenderTreeLifecycle)(manager)) {
      let nodes = manager.getDebugCustomRenderTree(instance.definition.state, instance.state, args, moduleName);
      nodes.forEach(node => {
        let {
          bucket
        } = node;
        vm.env.debugRenderTree.create(bucket, node);
        (0, _destroyable.registerDestructor)(instance, () => {
          var _a;

          (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.willDestroy(bucket);
        });
        vm.updateWith(new DebugRenderTreeUpdateOpcode(bucket));
      });
    } else {
      let name = (_a = definition.resolvedName) !== null && _a !== void 0 ? _a : manager.getDebugName(definition.state);
      vm.env.debugRenderTree.create(instance, {
        type: 'component',
        name,
        args,
        template: moduleName,
        instance: (0, _reference.valueForRef)(selfRef)
      });
      vm.associateDestroyable(instance);
      (0, _destroyable.registerDestructor)(instance, () => {
        var _a;

        (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.willDestroy(instance);
      });
      vm.updateWith(new DebugRenderTreeUpdateOpcode(instance));
    }
  }

  vm.stack.push(selfRef);
});

_opcodes.APPEND_OPCODES.add(91
/* GetComponentTagName */
, (vm, {
  op1: _state
}) => {
  let {
    definition,
    state
  } = vm.fetchValue(_state);
  let {
    manager
  } = definition;
  let tagName = manager.getTagName(state); // User provided value from JS, so we don't bother to encode

  vm.stack.push(tagName);
}); // Dynamic Invocation Only


_opcodes.APPEND_OPCODES.add(92
/* GetComponentLayout */
, (vm, {
  op1: _state
}) => {
  let instance = vm.fetchValue(_state);
  let {
    manager,
    definition
  } = instance;
  let {
    stack
  } = vm;
  let {
    compilable
  } = definition;

  if (compilable === null) {
    let {
      capabilities
    } = instance;
    false && (0, _util.assert)((0, _manager.managerHasCapability)(manager, capabilities, 1
    /* DynamicLayout */
    ), 'BUG: No template was found for this component, and the component did not have the dynamic layout capability');
    compilable = manager.getDynamicLayout(instance.state, vm.runtime.resolver);

    if (compilable === null) {
      if ((0, _manager.managerHasCapability)(manager, capabilities, 1024
      /* Wrapped */
      )) {
        compilable = (0, _util.unwrapTemplate)(vm[_symbols.CONSTANTS].defaultTemplate).asWrappedLayout();
      } else {
        compilable = (0, _util.unwrapTemplate)(vm[_symbols.CONSTANTS].defaultTemplate).asLayout();
      }
    }
  }

  let handle = compilable.compile(vm.context);
  stack.push(compilable.symbolTable);
  stack.push(handle);
});

_opcodes.APPEND_OPCODES.add(75
/* Main */
, (vm, {
  op1: register
}) => {
  let definition = vm.stack.pop();
  let invocation = vm.stack.pop();
  let {
    manager,
    capabilities
  } = definition;
  let state = {
    definition,
    manager,
    capabilities,
    state: null,
    handle: invocation.handle,
    table: invocation.symbolTable,
    lookup: null
  };
  vm.loadValue(register, state);
});

_opcodes.APPEND_OPCODES.add(95
/* PopulateLayout */
, (vm, {
  op1: _state
}) => {
  let {
    stack
  } = vm; // In DEBUG handles could be ErrHandle objects

  let handle = stack.pop();
  let table = stack.pop();
  let state = vm.fetchValue(_state);
  state.handle = handle;
  state.table = table;
});

_opcodes.APPEND_OPCODES.add(38
/* VirtualRootScope */
, (vm, {
  op1: _state
}) => {
  let {
    table,
    manager,
    capabilities,
    state
  } = vm.fetchValue(_state);
  let owner;

  if ((0, _manager.managerHasCapability)(manager, capabilities, 4096
  /* HasSubOwner */
  )) {
    owner = manager.getOwner(state);
    vm.loadValue(_vm2.$t1, null); // Clear the temp register
  } else {
    // Check the temp register to see if an owner was resolved from currying
    owner = vm.fetchValue(_vm2.$t1);

    if (owner === null) {
      // If an owner wasn't found, default to using the current owner. This
      // will happen for normal dynamic component invocation,
      // e.g. <SomeClassicEmberComponent/>
      owner = vm.getOwner();
    } else {
      // Else the owner was found, so clear the temp register. This will happen
      // if we are loading a curried component, e.g. <@someCurriedComponent/>
      vm.loadValue(_vm2.$t1, null);
    }
  }

  vm.pushRootScope(table.symbols.length + 1, owner);
});

_opcodes.APPEND_OPCODES.add(94
/* SetupForEval */
, (vm, {
  op1: _state
}) => {
  let state = vm.fetchValue(_state);

  if (state.table.hasEval) {
    let lookup = state.lookup = (0, _util.dict)();
    vm.scope().bindEvalScope(lookup);
  }
});

_opcodes.APPEND_OPCODES.add(17
/* SetNamedVariables */
, (vm, {
  op1: _state
}) => {
  let state = vm.fetchValue(_state);
  let scope = vm.scope();
  let args = vm.stack.peek();
  let callerNames = args.named.atNames;

  for (let i = callerNames.length - 1; i >= 0; i--) {
    let atName = callerNames[i];
    let symbol = state.table.symbols.indexOf(callerNames[i]);
    let value = args.named.get(atName, true);
    if (symbol !== -1) scope.bindSymbol(symbol + 1, value);
    if (state.lookup) state.lookup[atName] = value;
  }
});

function bindBlock(symbolName, blockName, state, blocks, vm) {
  let symbol = state.table.symbols.indexOf(symbolName);
  let block = blocks.get(blockName);
  if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
  if (state.lookup) state.lookup[symbolName] = block;
}

_opcodes.APPEND_OPCODES.add(18
/* SetBlocks */
, (vm, {
  op1: _state
}) => {
  let state = vm.fetchValue(_state);
  let {
    blocks
  } = vm.stack.peek();

  for (let i = 0; i < blocks.names.length; i++) {
    bindBlock(blocks.symbolNames[i], blocks.names[i], state, blocks, vm);
  }
}); // Dynamic Invocation Only


_opcodes.APPEND_OPCODES.add(96
/* InvokeComponentLayout */
, (vm, {
  op1: _state
}) => {
  let state = vm.fetchValue(_state);
  vm.call(state.handle);
});

_opcodes.APPEND_OPCODES.add(100
/* DidRenderLayout */
, (vm, {
  op1: _state
}) => {
  let instance = vm.fetchValue(_state);
  let {
    manager,
    state,
    capabilities
  } = instance;
  let bounds = vm.elements().popBlock();

  if (vm.env.debugRenderTree !== undefined) {
    if ((0, _interfaces.hasCustomDebugRenderTreeLifecycle)(manager)) {
      let nodes = manager.getDebugCustomRenderTree(instance.definition.state, state, _arguments.EMPTY_ARGS);
      nodes.reverse().forEach(node => {
        let {
          bucket
        } = node;
        vm.env.debugRenderTree.didRender(bucket, bounds);
        vm.updateWith(new DebugRenderTreeDidRenderOpcode(bucket, bounds));
      });
    } else {
      vm.env.debugRenderTree.didRender(instance, bounds);
      vm.updateWith(new DebugRenderTreeDidRenderOpcode(instance, bounds));
    }
  }

  if ((0, _manager.managerHasCapability)(manager, capabilities, 512
  /* CreateInstance */
  )) {
    let mgr = manager;
    mgr.didRenderLayout(state, bounds);
    vm.env.didCreate(instance);
    vm.updateWith(new DidUpdateLayoutOpcode(instance, bounds));
  }
});

_opcodes.APPEND_OPCODES.add(98
/* CommitComponentTransaction */
, vm => {
  vm.commitCacheGroup();
});

class UpdateComponentOpcode {
  constructor(component, manager, dynamicScope) {
    this.component = component;
    this.manager = manager;
    this.dynamicScope = dynamicScope;
  }

  evaluate(_vm) {
    let {
      component,
      manager,
      dynamicScope
    } = this;
    manager.update(component, dynamicScope);
  }

}

exports.UpdateComponentOpcode = UpdateComponentOpcode;

class DidUpdateLayoutOpcode {
  constructor(component, bounds) {
    this.component = component;
    this.bounds = bounds;
  }

  evaluate(vm) {
    let {
      component,
      bounds
    } = this;
    let {
      manager,
      state
    } = component;
    manager.didUpdateLayout(state, bounds);
    vm.env.didUpdate(component);
  }

}

exports.DidUpdateLayoutOpcode = DidUpdateLayoutOpcode;

class DebugRenderTreeUpdateOpcode {
  constructor(bucket) {
    this.bucket = bucket;
  }

  evaluate(vm) {
    var _a;

    (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.update(this.bucket);
  }

}

class DebugRenderTreeDidRenderOpcode {
  constructor(bucket, bounds) {
    this.bucket = bucket;
    this.bounds = bounds;
  }

  evaluate(vm) {
    var _a;

    (_a = vm.env.debugRenderTree) === null || _a === void 0 ? void 0 : _a.didRender(this.bucket, this.bounds);
  }

}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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