ember-source 7.1.0-alpha.4 → 7.1.0-alpha.5

package/dist/prod/packages/shared-chunks/observers-Co4JALkS.js

@@ -0,0 +1,199 @@
+import { E as ENV } from './env-DXxsTFkM.js';
+import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { d as valueForTag, v as validateTag, i as CURRENT_TAG } from './cache-BIlOoPA7.js';
+import { a as tagMetaFor } from './meta-B9mldqPL.js';
+import { g as getChainTagsForKey } from './chain-tags-BJqcuCM1.js';
+import { a as addListener, r as removeListener, s as sendEvent } from './events-970OxD6Q.js';
+
+const AFTER_OBSERVERS = ':change';
+function changeEvent(keyName) {
+  return keyName + AFTER_OBSERVERS;
+}
+
+const SYNC_DEFAULT = !ENV._DEFAULT_ASYNC_OBSERVERS;
+const SYNC_OBSERVERS = new Map();
+const ASYNC_OBSERVERS = new Map();
+
+/**
+@module @ember/object
+*/
+
+/**
+  @method addObserver
+  @static
+  @for @ember/object/observers
+  @param obj
+  @param {String} path
+  @param {Object|Function} target
+  @param {Function|String} [method]
+  @public
+*/
+function addObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
+  let eventName = changeEvent(path);
+  addListener(obj, eventName, target, method, false, sync);
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
+    activateObserver(obj, eventName, sync);
+  }
+}
+
+/**
+  @method removeObserver
+  @static
+  @for @ember/object/observers
+  @param obj
+  @param {String} path
+  @param {Object|Function} target
+  @param {Function|String} [method]
+  @public
+*/
+function removeObserver(obj, path, target, method, sync = SYNC_DEFAULT) {
+  let eventName = changeEvent(path);
+  let meta = peekMeta(obj);
+  if (meta === null || !(meta.isPrototypeMeta(obj) || meta.isInitializing())) {
+    deactivateObserver(obj, eventName, sync);
+  }
+  removeListener(obj, eventName, target, method);
+}
+function getOrCreateActiveObserversFor(target, sync) {
+  let observerMap = sync === true ? SYNC_OBSERVERS : ASYNC_OBSERVERS;
+  if (!observerMap.has(target)) {
+    observerMap.set(target, new Map());
+    registerDestructor(target, () => destroyObservers(target), true);
+  }
+  return observerMap.get(target);
+}
+function activateObserver(target, eventName, sync = false) {
+  let activeObservers = getOrCreateActiveObserversFor(target, sync);
+  if (activeObservers.has(eventName)) {
+    activeObservers.get(eventName).count++;
+  } else {
+    let path = eventName.substring(0, eventName.lastIndexOf(':'));
+    let tag = getChainTagsForKey(target, path, tagMetaFor(target), peekMeta(target));
+    activeObservers.set(eventName, {
+      count: 1,
+      path,
+      tag,
+      lastRevision: valueForTag(tag),
+      suspended: false
+    });
+  }
+}
+let DEACTIVATE_SUSPENDED = false;
+let SCHEDULED_DEACTIVATE = [];
+function deactivateObserver(target, eventName, sync = false) {
+  if (DEACTIVATE_SUSPENDED === true) {
+    SCHEDULED_DEACTIVATE.push([target, eventName, sync]);
+    return;
+  }
+  let observerMap = sync === true ? SYNC_OBSERVERS : ASYNC_OBSERVERS;
+  let activeObservers = observerMap.get(target);
+  if (activeObservers !== undefined) {
+    let observer = activeObservers.get(eventName);
+    observer.count--;
+    if (observer.count === 0) {
+      activeObservers.delete(eventName);
+      if (activeObservers.size === 0) {
+        observerMap.delete(target);
+      }
+    }
+  }
+}
+function suspendedObserverDeactivation() {
+  DEACTIVATE_SUSPENDED = true;
+}
+function resumeObserverDeactivation() {
+  DEACTIVATE_SUSPENDED = false;
+  for (let [target, eventName, sync] of SCHEDULED_DEACTIVATE) {
+    deactivateObserver(target, eventName, sync);
+  }
+  SCHEDULED_DEACTIVATE = [];
+}
+
+/**
+ * Primarily used for cases where we are redefining a class, e.g. mixins/reopen
+ * being applied later. Revalidates all the observers, resetting their tags.
+ *
+ * @private
+ * @param target
+ */
+function revalidateObservers(target) {
+  if (ASYNC_OBSERVERS.has(target)) {
+    ASYNC_OBSERVERS.get(target).forEach(observer => {
+      observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+      observer.lastRevision = valueForTag(observer.tag);
+    });
+  }
+  if (SYNC_OBSERVERS.has(target)) {
+    SYNC_OBSERVERS.get(target).forEach(observer => {
+      observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+      observer.lastRevision = valueForTag(observer.tag);
+    });
+  }
+}
+let lastKnownRevision = 0;
+function flushAsyncObservers(_schedule) {
+  let currentRevision = valueForTag(CURRENT_TAG);
+  if (lastKnownRevision === currentRevision) {
+    return;
+  }
+  lastKnownRevision = currentRevision;
+  ASYNC_OBSERVERS.forEach((activeObservers, target) => {
+    let meta = peekMeta(target);
+    activeObservers.forEach((observer, eventName) => {
+      if (!validateTag(observer.tag, observer.lastRevision)) {
+        let sendObserver = () => {
+          try {
+            sendEvent(target, eventName, [target, observer.path], undefined, meta);
+          } finally {
+            observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+            observer.lastRevision = valueForTag(observer.tag);
+          }
+        };
+        if (_schedule) {
+          _schedule('actions', sendObserver);
+        } else {
+          sendObserver();
+        }
+      }
+    });
+  });
+}
+function flushSyncObservers() {
+  // When flushing synchronous observers, we know that something has changed (we
+  // only do this during a notifyPropertyChange), so there's no reason to check
+  // a global revision.
+
+  SYNC_OBSERVERS.forEach((activeObservers, target) => {
+    let meta = peekMeta(target);
+    activeObservers.forEach((observer, eventName) => {
+      if (!observer.suspended && !validateTag(observer.tag, observer.lastRevision)) {
+        try {
+          observer.suspended = true;
+          sendEvent(target, eventName, [target, observer.path], undefined, meta);
+        } finally {
+          observer.tag = getChainTagsForKey(target, observer.path, tagMetaFor(target), peekMeta(target));
+          observer.lastRevision = valueForTag(observer.tag);
+          observer.suspended = false;
+        }
+      }
+    });
+  });
+}
+function setObserverSuspended(target, property, suspended) {
+  let activeObservers = SYNC_OBSERVERS.get(target);
+  if (!activeObservers) {
+    return;
+  }
+  let observer = activeObservers.get(changeEvent(property));
+  if (observer) {
+    observer.suspended = suspended;
+  }
+}
+function destroyObservers(target) {
+  if (SYNC_OBSERVERS.size > 0) SYNC_OBSERVERS.delete(target);
+  if (ASYNC_OBSERVERS.size > 0) ASYNC_OBSERVERS.delete(target);
+}
+
+export { ASYNC_OBSERVERS as A, SYNC_OBSERVERS as S, activateObserver as a, addObserver as b, revalidateObservers as c, flushSyncObservers as d, resumeObserverDeactivation as e, flushAsyncObservers as f, setObserverSuspended as g, removeObserver as r, suspendedObserverDeactivation as s };

package/dist/prod/packages/shared-chunks/on-C3ZQiUUD.js

@@ -0,0 +1,228 @@
+import { g as check } from './debug-render-tree-BLtnOSbb.js';
+import { registerDestructor } from '../@glimmer/destroyable/index.js';
+import { k as setInternalModifierManager } from './api-zh_k31vb.js';
+import { v as valueForRef } from './reference-BshxG6wn.js';
+import { c as createUpdatableTag } from './cache-BIlOoPA7.js';
+
+class OnModifierState {
+  tag = createUpdatableTag();
+  element;
+  args;
+  listener = null;
+  constructor(element, args) {
+    this.element = element;
+    this.args = args;
+    registerDestructor(this, () => {
+      let {
+        element,
+        listener
+      } = this;
+      if (listener) {
+        let {
+          eventName,
+          callback,
+          options
+        } = listener;
+        removeEventListener(element, eventName, callback, options);
+      }
+    });
+  }
+
+  // Update this.listener if needed
+  updateListener() {
+    let {
+      element,
+      args,
+      listener
+    } = this;
+    let arg0 = args.positional[0];
+    let eventName = check(arg0 ? valueForRef(arg0) : undefined);
+    let arg1 = args.positional[1];
+    let userProvidedCallback = check(arg1 ? valueForRef(arg1) : undefined);
+    let once = undefined;
+    let passive = undefined;
+    let capture = undefined;
+    {
+      let {
+        once: _once,
+        passive: _passive,
+        capture: _capture
+      } = args.named;
+      if (_once) {
+        once = valueForRef(_once);
+      }
+      if (_passive) {
+        passive = valueForRef(_passive);
+      }
+      if (_capture) {
+        capture = valueForRef(_capture);
+      }
+    }
+    let shouldUpdate = false;
+    if (listener === null) {
+      shouldUpdate = true;
+    } else {
+      shouldUpdate = eventName !== listener.eventName || userProvidedCallback !== listener.userProvidedCallback || once !== listener.once || passive !== listener.passive || capture !== listener.capture;
+    }
+    let options = undefined;
+
+    // we want to handle both `true` and `false` because both have a meaning:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=770208
+    if (shouldUpdate) {
+      if (once !== undefined || passive !== undefined || capture !== undefined) {
+        options = {
+          once,
+          passive,
+          capture
+        };
+      }
+    }
+    if (shouldUpdate) {
+      let callback = userProvidedCallback;
+      this.listener = {
+        eventName,
+        callback,
+        userProvidedCallback,
+        once,
+        passive,
+        capture,
+        options
+      };
+      if (listener) {
+        removeEventListener(element, listener.eventName, listener.callback, listener.options);
+      }
+      addEventListener(element, eventName, callback, options);
+    }
+  }
+}
+let adds = 0;
+let removes = 0;
+function removeEventListener(element, eventName, callback, options) {
+  removes++;
+  element.removeEventListener(eventName, callback, options);
+}
+function addEventListener(element, eventName, callback, options) {
+  adds++;
+  element.addEventListener(eventName, callback, options);
+}
+
+/**
+  The `{{on}}` modifier lets you easily add event listeners (it uses
+  [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
+  internally).
+
+  For example, if you'd like to run a function on your component when a `<button>`
+  in the components template is clicked you might do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' this.saveLike}}>Like this post!</button>
+  ```
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+
+  export default class LikePostComponent extends Component {
+    saveLike = () => {
+      // someone likes your post!
+      // better send a request off to your server...
+    }
+  }
+  ```
+
+  ### Arguments
+
+  `{{on}}` accepts two positional arguments, and a few named arguments.
+
+  The positional arguments are:
+
+  - `event` -- the name to use when calling `addEventListener`
+  - `callback` -- the function to be passed to `addEventListener`
+
+  The named arguments are:
+
+  - capture -- a `true` value indicates that events of this type will be dispatched
+    to the registered listener before being dispatched to any EventTarget beneath it
+    in the DOM tree.
+  - once -- indicates that the listener should be invoked at most once after being
+    added. If true, the listener would be automatically removed when invoked.
+  - passive -- if `true`, indicates that the function specified by listener will never
+    call preventDefault(). If a passive listener does call preventDefault(), the user
+    agent will do nothing other than generate a console warning. See
+    [Improving scrolling performance with passive listeners](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Improving_scrolling_performance_with_passive_listeners)
+    to learn more.
+
+  The callback function passed to `{{on}}` will receive any arguments that are passed
+  to the event handler. Most commonly this would be the `event` itself.
+
+  If you would like to pass additional arguments to the function you should use
+  the `{{fn}}` helper.
+
+  For example, in our example case above if you'd like to pass in the post that
+  was being liked when the button is clicked you could do something like:
+
+  ```app/components/like-post.hbs
+  <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
+  ```
+
+  In this case, the `saveLike` function will receive two arguments: the click event
+  and the value of `@post`.
+
+  ### Function Context
+
+  In the example above, we used an arrow function to ensure that `likePost` is
+  properly bound to the `items-list`, but let's explore what happens if we
+  left out the arrow function:
+
+  ```app/components/like-post.js
+  import Component from '@glimmer/component';
+
+  export default class LikePostComponent extends Component {
+    saveLike() {
+      // ...snip...
+    }
+  }
+  ```
+
+  In this example, when the button is clicked `saveLike` will be invoked,
+  it will **not** have access to the component instance. In other
+  words, it will have no `this` context, so please make sure your functions
+  are bound (via an arrow function or other means) before passing into `on`!
+
+  @method on
+  @public
+*/
+class OnModifierManager {
+  getDebugName() {
+    return 'on';
+  }
+  getDebugInstance() {
+    return null;
+  }
+  get counters() {
+    return {
+      adds,
+      removes
+    };
+  }
+  create(_owner, element, _state, args) {
+    return new OnModifierState(element, args);
+  }
+  getTag({
+    tag
+  }) {
+    return tag;
+  }
+  install(state) {
+    state.updateListener();
+  }
+  update(state) {
+    state.updateListener();
+  }
+  getDestroyable(state) {
+    return state;
+  }
+}
+const on = setInternalModifierManager(new OnModifierManager(), {});
+
+export { on as o };

package/dist/prod/packages/shared-chunks/opcode-metadata-9iSW5JGP.js

@@ -0,0 +1,285 @@
+import { C as CURRIED_MODIFIER, a as CURRIED_HELPER, b as CURRIED_COMPONENT } from './curried-BVwSNqpf.js';
+import { a as $v0, b as $t1, c as $t0, d as $s1, $ as $s0, e as $sp, f as $fp, g as $ra, h as $pc } from './registers-DoamZwaG.js';
+
+const SIGN_BIT = -536870913;
+const MAX_INT = ~SIGN_BIT - 1;
+const MIN_INT = ~MAX_INT;
+function isHandle(value) {
+  return value >= 0;
+}
+function constants(...values) {
+  return [false, true, null, undefined, ...values];
+}
+function isSmallInt(value) {
+  return value % 1 === 0 && value <= MAX_INT && value >= MIN_INT;
+}
+function encodeNegative(num) {
+  return num & SIGN_BIT;
+}
+function decodeNegative(num) {
+  return num | ~SIGN_BIT;
+}
+function encodePositive(num) {
+  return ~num;
+}
+function decodePositive(num) {
+  return ~num;
+}
+function encodeHandle(num) {
+  return num;
+}
+function decodeHandle(num) {
+  return num;
+}
+function encodeImmediate(num) {
+  num |= 0;
+  return num < 0 ? encodeNegative(num) : encodePositive(num);
+}
+function decodeImmediate(num) {
+  num |= 0;
+  return num > SIGN_BIT ? decodePositive(num) : decodeNegative(num);
+}
+[1, -1].forEach(x => decodeImmediate(encodeImmediate(x)));
+
+const VM_HELPER_OP = 16;
+const VM_SET_NAMED_VARIABLES_OP = 17;
+const VM_SET_BLOCKS_OP = 18;
+const VM_SET_VARIABLE_OP = 19;
+const VM_SET_BLOCK_OP = 20;
+const VM_GET_VARIABLE_OP = 21;
+const VM_GET_PROPERTY_OP = 22;
+const VM_GET_BLOCK_OP = 23;
+const VM_SPREAD_BLOCK_OP = 24;
+const VM_HAS_BLOCK_OP = 25;
+const VM_HAS_BLOCK_PARAMS_OP = 26;
+const VM_CONCAT_OP = 27;
+const VM_CONSTANT_OP = 28;
+const VM_CONSTANT_REFERENCE_OP = 29;
+const VM_PRIMITIVE_OP = 30;
+const VM_PRIMITIVE_REFERENCE_OP = 31;
+const VM_DUP_OP = 33;
+const VM_POP_OP = 34;
+const VM_LOAD_OP = 35;
+const VM_FETCH_OP = 36;
+const VM_ROOT_SCOPE_OP = 37;
+const VM_VIRTUAL_ROOT_SCOPE_OP = 38;
+const VM_CHILD_SCOPE_OP = 39;
+const VM_POP_SCOPE_OP = 40;
+const VM_TEXT_OP = 41;
+const VM_COMMENT_OP = 42;
+const VM_APPEND_HTML_OP = 43;
+const VM_APPEND_SAFE_HTML_OP = 44;
+const VM_APPEND_DOCUMENT_FRAGMENT_OP = 45;
+const VM_APPEND_NODE_OP = 46;
+const VM_APPEND_TEXT_OP = 47;
+const VM_OPEN_ELEMENT_OP = 48;
+const VM_OPEN_DYNAMIC_ELEMENT_OP = 49;
+const VM_PUSH_REMOTE_ELEMENT_OP = 50;
+const VM_STATIC_ATTR_OP = 51;
+const VM_DYNAMIC_ATTR_OP = 52;
+const VM_COMPONENT_ATTR_OP = 53;
+const VM_FLUSH_ELEMENT_OP = 54;
+const VM_CLOSE_ELEMENT_OP = 55;
+const VM_POP_REMOTE_ELEMENT_OP = 56;
+const VM_MODIFIER_OP = 57;
+const VM_BIND_DYNAMIC_SCOPE_OP = 58;
+const VM_PUSH_DYNAMIC_SCOPE_OP = 59;
+const VM_POP_DYNAMIC_SCOPE_OP = 60;
+const VM_COMPILE_BLOCK_OP = 61;
+const VM_PUSH_BLOCK_SCOPE_OP = 62;
+const VM_PUSH_SYMBOL_TABLE_OP = 63;
+const VM_INVOKE_YIELD_OP = 64;
+const VM_JUMP_IF_OP = 65;
+const VM_JUMP_UNLESS_OP = 66;
+const VM_JUMP_EQ_OP = 67;
+const VM_ASSERT_SAME_OP = 68;
+const VM_ENTER_OP = 69;
+const VM_EXIT_OP = 70;
+const VM_TO_BOOLEAN_OP = 71;
+const VM_ENTER_LIST_OP = 72;
+const VM_EXIT_LIST_OP = 73;
+const VM_ITERATE_OP = 74;
+const VM_MAIN_OP = 75;
+const VM_CONTENT_TYPE_OP = 76;
+const VM_CURRY_OP = 77;
+const VM_PUSH_COMPONENT_DEFINITION_OP = 78;
+const VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP = 79;
+const VM_RESOLVE_DYNAMIC_COMPONENT_OP = 80;
+const VM_RESOLVE_CURRIED_COMPONENT_OP = 81;
+const VM_PUSH_ARGS_OP = 82;
+const VM_PUSH_EMPTY_ARGS_OP = 83;
+const VM_PREPARE_ARGS_OP = 85;
+const VM_CAPTURE_ARGS_OP = 86;
+const VM_CREATE_COMPONENT_OP = 87;
+const VM_REGISTER_COMPONENT_DESTRUCTOR_OP = 88;
+const VM_PUT_COMPONENT_OPERATIONS_OP = 89;
+const VM_GET_COMPONENT_SELF_OP = 90;
+const VM_GET_COMPONENT_TAG_NAME_OP = 91;
+const VM_GET_COMPONENT_LAYOUT_OP = 92;
+const VM_POPULATE_LAYOUT_OP = 95;
+const VM_INVOKE_COMPONENT_LAYOUT_OP = 96;
+const VM_BEGIN_COMPONENT_TRANSACTION_OP = 97;
+const VM_COMMIT_COMPONENT_TRANSACTION_OP = 98;
+const VM_DID_CREATE_ELEMENT_OP = 99;
+const VM_DID_RENDER_LAYOUT_OP = 100;
+const VM_DEBUGGER_OP = 103;
+const VM_STATIC_COMPONENT_ATTR_OP = 105;
+const VM_DYNAMIC_CONTENT_TYPE_OP = 106;
+const VM_DYNAMIC_HELPER_OP = 107;
+const VM_DYNAMIC_MODIFIER_OP = 108;
+const VM_IF_INLINE_OP = 109;
+const VM_NOT_OP = 110;
+const VM_GET_DYNAMIC_VAR_OP = 111;
+const VM_LOG_OP = 112;
+const VM_SYSCALL_SIZE = 113;
+
+function decodeCurry(curry) {
+  switch (curry) {
+    case CURRIED_COMPONENT:
+      return 'component';
+    case CURRIED_HELPER:
+      return 'helper';
+    case CURRIED_MODIFIER:
+      return 'modifier';
+    default:
+      throw Error(`Unexpected curry value: ${curry}`);
+  }
+}
+function decodeRegister(register) {
+  switch (register) {
+    case $pc:
+      return '$pc';
+    case $ra:
+      return '$ra';
+    case $fp:
+      return '$fp';
+    case $sp:
+      return '$sp';
+    case $s0:
+      return '$s0';
+    case $s1:
+      return '$s1';
+    case $t0:
+      return '$t0';
+    case $t1:
+      return '$t1';
+    case $v0:
+      return '$v0';
+    default:
+      return `$bug${register}`;
+  }
+}
+function decodePrimitive(primitive, constants) {
+  if (primitive >= 0) {
+    return constants.getValue(decodeHandle(primitive));
+  }
+  return decodeImmediate(primitive);
+}
+
+const todo = ({
+  label,
+  value
+}) => ['error:operand', value, {
+  label
+}];
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+class Disassembler {
+  static build(builder) {
+    return builder(new Disassembler()).#disms;
+  }
+  #disms;
+  constructor() {
+    this.#disms = {};
+  }
+  addNullable(names, dism) {
+    for (const name of names) {
+      this.#disms[name] = dism;
+      this.#disms[`${name}?`] = dism;
+    }
+    return this;
+  }
+  add(names, dism) {
+    const add = (name, dism) => this.#disms[name] = dism;
+    for (const name of names) {
+      add(name, dism);
+    }
+    return this;
+  }
+}
+Disassembler.build(d => {
+  return d.add(['imm/u32', 'imm/i32', 'imm/u32{todo}', 'imm/i32{todo}'], ({
+    value
+  }) => ['number', value]).add(['const/i32[]'], ({
+    value,
+    constants
+  }) => ['array', constants.getArray(value), {
+    kind: Number
+  }]).add(['const/bool'], ({
+    value
+  }) => ['boolean', !!value]).add(['imm/bool'], ({
+    value,
+    constants
+  }) => ['boolean', constants.getValue(decodeHandle(value))]).add(['handle'], ({
+    constants,
+    value
+  }) => ['constant', constants.getValue(value)]).add(['handle/block'], ({
+    value,
+    heap
+  }) => ['instruction', heap.getaddr(value)]).add(['imm/pc'], ({
+    value
+  }) => ['instruction', value]).add(['const/any[]'], ({
+    value,
+    constants
+  }) => ['array', constants.getArray(value)]).add(['const/primitive'], ({
+    value,
+    constants
+  }) => ['primitive', decodePrimitive(value, constants)]).add(['register'], ({
+    value
+  }) => ['register', decodeRegister(value)]).add(['const/any'], ({
+    value,
+    constants
+  }) => ['dynamic', constants.getValue(value)]).add(['variable'], ({
+    value,
+    meta
+  }) => {
+    return ['variable', value, {
+      name: meta?.symbols.lexical?.at(value) ?? null
+    }];
+  }).add(['register/instruction'], ({
+    value
+  }) => ['instruction', value]).add(['imm/enum<curry>'], ({
+    value
+  }) => ['enum<curry>', decodeCurry(value)]).addNullable(['const/str'], ({
+    value,
+    constants
+  }) => ['string', constants.getValue(value)]).addNullable(['const/str[]'], ({
+    value,
+    constants
+  }) => ['array', constants.getArray(value), {
+    kind: String
+  }]).add(['imm/block:handle'], todo).add(['const/definition'], todo).add(['const/fn'], todo).add(['instruction/relative'], ({
+    value,
+    offset
+  }) => ['instruction', offset + value]).add(['register/sN'], todo).add(['register/stack'], todo).add(['register/tN'], todo).add(['register/v0'], todo);
+});
+
+const VM_PUSH_FRAME_OP = 0;
+const VM_POP_FRAME_OP = 1;
+const VM_INVOKE_VIRTUAL_OP = 2;
+const VM_INVOKE_STATIC_OP = 3;
+const VM_JUMP_OP = 4;
+const VM_RETURN_OP = 5;
+const VM_RETURN_TO_OP = 6;
+const VM_MACHINE_SIZE = 7;
+function isMachineOp(value) {
+  return value >= 0 && value <= 15;
+}
+
+/* This file is generated by build/debug.js */
+
+new Array(VM_SYSCALL_SIZE).fill(null);
+new Array(VM_MACHINE_SIZE).fill(null);
+
+export { VM_PUSH_EMPTY_ARGS_OP as $, VM_BIND_DYNAMIC_SCOPE_OP as A, VM_ENTER_OP as B, VM_EXIT_OP as C, VM_PUSH_SYMBOL_TABLE_OP as D, VM_PUSH_BLOCK_SCOPE_OP as E, VM_COMPILE_BLOCK_OP as F, VM_INVOKE_YIELD_OP as G, VM_JUMP_IF_OP as H, VM_JUMP_UNLESS_OP as I, VM_JUMP_EQ_OP as J, VM_TO_BOOLEAN_OP as K, VM_TEXT_OP as L, VM_COMMENT_OP as M, VM_OPEN_ELEMENT_OP as N, VM_OPEN_DYNAMIC_ELEMENT_OP as O, VM_PUSH_REMOTE_ELEMENT_OP as P, VM_POP_REMOTE_ELEMENT_OP as Q, VM_FLUSH_ELEMENT_OP as R, VM_CLOSE_ELEMENT_OP as S, VM_MODIFIER_OP as T, VM_DYNAMIC_MODIFIER_OP as U, VM_MAIN_OP as V, VM_STATIC_ATTR_OP as W, VM_DYNAMIC_ATTR_OP as X, VM_PUSH_COMPONENT_DEFINITION_OP as Y, VM_RESOLVE_DYNAMIC_COMPONENT_OP as Z, VM_PUSH_ARGS_OP as _, VM_CONTENT_TYPE_OP as a, VM_CAPTURE_ARGS_OP as a0, VM_PREPARE_ARGS_OP as a1, VM_CREATE_COMPONENT_OP as a2, VM_REGISTER_COMPONENT_DESTRUCTOR_OP as a3, VM_BEGIN_COMPONENT_TRANSACTION_OP as a4, VM_PUT_COMPONENT_OPERATIONS_OP as a5, VM_COMPONENT_ATTR_OP as a6, VM_STATIC_COMPONENT_ATTR_OP as a7, VM_DID_CREATE_ELEMENT_OP as a8, VM_GET_COMPONENT_SELF_OP as a9, VM_LOG_OP as aA, VM_DYNAMIC_CONTENT_TYPE_OP as aB, VM_ENTER_LIST_OP as aC, VM_EXIT_LIST_OP as aD, VM_ITERATE_OP as aE, VM_RETURN_TO_OP as aF, VM_RETURN_OP as aG, VM_JUMP_OP as aH, VM_INVOKE_VIRTUAL_OP as aI, VM_POP_FRAME_OP as aJ, VM_PUSH_FRAME_OP as aK, constants as aL, encodeHandle as aM, isMachineOp as aN, isSmallInt as aO, encodeImmediate as aP, VM_GET_COMPONENT_TAG_NAME_OP as aa, VM_GET_COMPONENT_LAYOUT_OP as ab, VM_POPULATE_LAYOUT_OP as ac, VM_VIRTUAL_ROOT_SCOPE_OP as ad, VM_SET_NAMED_VARIABLES_OP as ae, VM_SET_BLOCKS_OP as af, VM_INVOKE_COMPONENT_LAYOUT_OP as ag, VM_DID_RENDER_LAYOUT_OP as ah, VM_COMMIT_COMPONENT_TRANSACTION_OP as ai, VM_DEBUGGER_OP as aj, VM_CURRY_OP as ak, VM_DYNAMIC_HELPER_OP as al, VM_HELPER_OP as am, VM_GET_VARIABLE_OP as an, VM_SET_VARIABLE_OP as ao, VM_SET_BLOCK_OP as ap, VM_ROOT_SCOPE_OP as aq, VM_GET_PROPERTY_OP as ar, VM_GET_BLOCK_OP as as, VM_SPREAD_BLOCK_OP as at, VM_HAS_BLOCK_OP as au, VM_HAS_BLOCK_PARAMS_OP as av, VM_CONCAT_OP as aw, VM_IF_INLINE_OP as ax, VM_NOT_OP as ay, VM_GET_DYNAMIC_VAR_OP as az, VM_ASSERT_SAME_OP as b, VM_APPEND_HTML_OP as c, VM_APPEND_TEXT_OP as d, VM_RESOLVE_CURRIED_COMPONENT_OP as e, VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP as f, VM_APPEND_SAFE_HTML_OP as g, VM_APPEND_DOCUMENT_FRAGMENT_OP as h, VM_APPEND_NODE_OP as i, VM_INVOKE_STATIC_OP as j, VM_SYSCALL_SIZE as k, VM_CHILD_SCOPE_OP as l, VM_POP_SCOPE_OP as m, VM_PUSH_DYNAMIC_SCOPE_OP as n, VM_POP_DYNAMIC_SCOPE_OP as o, VM_CONSTANT_OP as p, decodeHandle as q, VM_CONSTANT_REFERENCE_OP as r, VM_PRIMITIVE_OP as s, isHandle as t, decodeImmediate as u, VM_PRIMITIVE_REFERENCE_OP as v, VM_DUP_OP as w, VM_POP_OP as x, VM_LOAD_OP as y, VM_FETCH_OP as z };