ember-source 7.3.0-alpha.5 → 7.4.0-alpha.1

package/dist/dev/packages/shared-chunks/{index-Czn34wUZ.js → index-Bv9SQpEx.js}

@@ -5,7 +5,7 @@ import { associateDestroyableChild, destroy, registerDestructor, isDestroyed, is
 import { artifacts } from '../@glimmer/program/index.js';
 import { R as RuntimeOpImpl } from './program-DlgjqLa6.js';
 import { c as clientBuilder } from './api-Dz70AUL_.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1 } from './render-CtH73XOv.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1 } from './render-D_Rawf-r.js';
 import { c as consumeTag, z as isTracking, e as debug, a as valueForTag, k as CURRENT_TAG, v as validateTag } from './cache-DGDPVCpC.js';
 import { h as hasDOM } from './index-BGP1rw3B.js';
 import { g as get$1, b as _getProp } from './property_get-DXwpgTe7.js';
@@ -28,15 +28,15 @@ import { isFactory } from '../@ember/-internals/owner/index.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { g as getComponentTemplate } from './template-R_5UMHhb.js';
 import { a as getInternalHelperManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DuLOZMO_.js';
-import { h as hash, f as fn, a as array } from './hash-6NDs_5_f.js';
-import { g as get, c as concat } from './get-6I3sjd-I.js';
-import { o as on } from './on-DlF0Wy7P.js';
+import { h as hash, f as fn, a as array } from './hash-BFu91gtE.js';
+import { g as get, c as concat } from './get-zsePWrJL.js';
+import { o as on } from './on-CVIjn2C-.js';
 import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-Cu639ICT.js';
 import { i as isCurlyManager } from './curly-brand-B_F79Dep.js';
 import { i as isClassicHelper } from './helper-brand-C9_8vvOf.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-DQOhouG1.js';
-import { E as EvaluationContextImpl } from './program-context-Dq8xN2HI.js';
+import { a as uniqueId } from './unique-id-Csxuh1I7.js';
+import { E as EvaluationContextImpl } from './program-context-BBB1Ga5h.js';
 
 /**
 @module ember
@@ -150,7 +150,7 @@ const trackArray = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 /**
@@ -160,46 +160,91 @@ const trackArray = internalHelper(({
   The default behavior of `{{#each}}` is to yield its inner block once for every
   item in an array passing the item as the first block parameter.
 
-  Assuming the `@developers` argument contains this array:
+  ```gjs {data-filename="app/components/developer-list.gjs"}
+  import Component from '@glimmer/component';
 
-  ```javascript
-  [{ name: 'Yehuda' },{ name: 'Tom' }, { name: 'Paul' }];
-  ```
+  export default class DeveloperList extends Component {
+    developers = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person|}}
-      <li>Hello, {{person.name}}!</li>
-    {{/each}}
-  </ul>
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  The same rules apply to arrays of primitives.
+  The same rules apply to arrays of primitives:
+
+  ```gjs {data-filename="app/components/developer-names.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperNames extends Component {
+    developerNames = ['Yehuda', 'Tom', 'Paul'];
 
-  ```javascript
-  ['Yehuda', 'Tom', 'Paul']
+    <template>
+      <ul>
+        {{#each this.developerNames as |name|}}
+          <li>Hello, {{name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  ```handlebars
-  <ul>
-    {{#each @developerNames as |name|}}
-      <li>Hello, {{name}}!</li>
-    {{/each}}
-  </ul>
+  `{{#each}}` also supports native JavaScript [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set)
+  values and other iterables:
+
+  ```gjs {data-filename="app/components/developer-set.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperSet extends Component {
+    developers = new Set([
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ]);
+
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
-  During iteration, the index of each item in the array is provided as a second block
-  parameter.
+  During iteration, the index of each item in the array is provided as a second
+  block parameter:
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person index|}}
-      <li>Hello, {{person.name}}! You're number {{index}} in line</li>
-    {{/each}}
-  </ul>
+  ```gjs {data-filename="app/components/developer-list-with-index.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperListWithIndex extends Component {
+    developers = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
+
+    <template>
+      <ul>
+        {{#each this.developers as |person index|}}
+          <li>Hello, {{person.name}}! You're number {{index}} in line</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
-    
-  `#each` is a keyword and does not need to be imported. 
+
+  `#each` is a keyword and does not need to be imported.
 
   ### Specifying Keys
 
@@ -215,72 +260,91 @@ const trackArray = internalHelper(({
   needed. However, in some rare cases, the objects' identities may change even
   though they represent the same underlying data.
 
-  For example:
+  For example, mapping over `people` produces a new array of new objects on each
+  render. Use `key` so Ember can match items across those renders:
 
-  ```javascript
-  people.map(person => {
-    return { ...person, type: 'developer' };
-  });
-  ```
+  ```gjs {data-filename="app/components/mapped-developers.gjs"}
+  import Component from '@glimmer/component';
 
-  In this case, each time the `people` array is `map`-ed over, it will produce
-  an new array with completely different objects between renders. In these cases,
-  you can help Ember determine how these objects related to each other with the
-  `key` option:
+  export default class MappedDevelopers extends Component {
+    people = [
+      { name: 'Yehuda' },
+      { name: 'Tom' },
+      { name: 'Paul' },
+    ];
 
-  ```handlebars
-  <ul>
-    {{#each @developers key="name" as |person|}}
-      <li>Hello, {{person.name}}!</li>
-    {{/each}}
-  </ul>
+    get developers() {
+      return this.people.map((person) => {
+        return { ...person, type: 'developer' };
+      });
+    }
+
+    <template>
+      <ul>
+        {{#each this.developers key="name" as |person|}}
+          <li>Hello, {{person.name}}!</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
   By doing so, Ember will use the value of the property specified (`person.name`
   in the example) to find a "match" from the previous render. That is, if Ember
-  has previously seen an object from the `@developers` array with a matching
+  has previously seen an object from the `developers` array with a matching
   name, its DOM elements will be re-used.
 
   There are two special values for `key`:
 
+    * `@identity` - The item in the array itself. This is the default.
     * `@index` - The index of the item in the array.
-    * `@identity` - The item in the array itself.
 
   ### {{else}} condition
 
   `{{#each}}` can have a matching `{{else}}`. The contents of this block will render
   if the collection is empty.
 
-  ```handlebars
-  <ul>
-    {{#each @developers as |person|}}
-      <li>{{person.name}} is available!</li>
-    {{else}}
-      <li>Sorry, nobody is available for this task.</li>
-    {{/each}}
-  </ul>
+  ```gjs {data-filename="app/components/available-developers.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class AvailableDevelopers extends Component {
+    developers = [];
+
+    <template>
+      <ul>
+        {{#each this.developers as |person|}}
+          <li>{{person.name}} is available!</li>
+        {{else}}
+          <li>Sorry, nobody is available for this task.</li>
+        {{/each}}
+      </ul>
+    </template>
+  }
   ```
 
   @method each
-  @for Ember.Templates.helpers
+  @for Keywords
+  @static
+  @noimport
   @public
  */
 
 /**
-  The `{{#each-in}}` keyword loops over properties on an object.
+  The `{{#each-in}}` keyword loops over properties on an object, or entries in a
+  native JavaScript [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map).
 
   For example, given this component definition:
 
-  ```app/components/developer-details.gjs
+  ```gjs {data-filename="app/components/developer-details.gjs"}
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
 
-  export default class extends Component {
+  export default class DeveloperDetails extends Component {
     @tracked developer = {
-      "name": "Shelly Sails",
-      "age": 42
+      name: 'Shelly Sails',
+      age: 42,
     };
-    
+
     <template>
       <ul>
         {{#each-in this.developer as |key value|}}
@@ -300,11 +364,80 @@ const trackArray = internalHelper(({
     <li>age: 42</li>
   </ul>
   ```
- 
+
+  The same pattern works with a `Map`:
+
+  ```gjs {data-filename="app/components/developer-map.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class DeveloperMap extends Component {
+    map = new Map([
+      ['name', 'Shelly Sails'],
+      ['age', 42],
+    ]);
+
+    <template>
+      <ul>
+        {{#each-in this.map as |key value|}}
+          <li>{{key}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
+  }
+  ```
+
+  When a `Map` uses object keys, you can pass `key="@identity"` to explicitly
+  track entries across re-renders using the JavaScript identity of each key:
+
+  ```gjs {data-filename="app/components/object-keyed-map.gjs"}
+  import Component from '@glimmer/component';
+
+  export default class ObjectKeyedMap extends Component {
+    map = new Map([
+      [{ name: 'one' }, 'foo'],
+      [{ name: 'two' }, 'bar'],
+    ]);
+
+    <template>
+      <ul>
+        {{#each-in this.map key="@identity" as |key value|}}
+          <li>{{key.name}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
+  }
+  ```
+
   `#each-in` is a keyword and does not need to be imported.
 
+  ### Specifying Keys
+
+  Like `{{#each}}`, `{{#each-in}}` accepts a `key` option to decide which DOM
+  elements can be reused between renders. Since `{{#each-in}}` yields two block
+  params, the special values pick which one is used:
+
+    * `@identity` - The second block param: the property's value. This is the
+      default. Changing a value replaces that entry's DOM instead of updating it
+      in place.
+    * `@key` - The first block param: the property name, or for a `Map`, its key.
+
+  Any other string is a path, looked up on the value: `key="id"` keys each entry
+  by its `value.id`.
+
+  For example, `@key` keeps each entry's DOM as its score changes, so anything
+  stateful inside it — focus, a running transition, a component instance — survives
+  the update:
+
+  ```handlebars
+  {{#each-in this.scores key="@key" as |player score|}}
+    <PlayerScore @name={{player}} @score={{score}} />
+  {{/each-in}}
+  ```
+
   @method each-in
-  @for Ember.Templates.helpers
+  @static
+  @noimport
+  @for Keywords
   @public
   @since 2.1.0
 */
@@ -331,7 +464,7 @@ const eachIn = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 /**
@@ -351,7 +484,7 @@ const eachIn = internalHelper(({
 
   The child `Component` would invoke the function with the new click count:
 
-  ```app/components/my-child.gjs
+  ```gjs {data-filename="app/components/my-child.gjs"}
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
     
@@ -373,7 +506,8 @@ const eachIn = internalHelper(({
 
   @method mut
   @param {Object} [attr] the "two-way" attribute that can be modified.
-  @for Ember.Templates.helpers
+  @static
+  @for Keywords
   @public
 */
 
@@ -398,7 +532,7 @@ const mut = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -510,7 +644,9 @@ const mut = internalHelper(({
 
   @method readonly
   @param {Object} [attr] the read-only attribute.
-  @for Ember.Templates.helpers
+  @for Keywords
+  @noimport
+  @static
   @private
 */
 const readonly = internalHelper(({
@@ -522,7 +658,7 @@ const readonly = internalHelper(({
 });
 
 /**
-@module ember
+@module @ember/helper
 */
 
 
@@ -548,9 +684,13 @@ const readonly = internalHelper(({
 
   The `unbound` helper only accepts a single argument, and it return an
   unbound value.
+ 
+ `unbound` is a template keyword and does not need to be imported.
 
   @method unbound
-  @for Ember.Templates.helpers
+  @static
+  @noimport
+  @for Keywords
   @public
 */
 

package/dist/dev/packages/shared-chunks/{invoke-d9sqa50M.js → invoke-CgF42joE.js}

@@ -2,7 +2,7 @@ import { isDestroying, isDestroyed, associateDestroyableChild } from '../@glimme
 import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-DuLOZMO_.js';
 import { getOwner } from '../@glimmer/owner/index.js';
 import { g as createCache, h as getValue } from './cache-DGDPVCpC.js';
-import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './arguments-CDkbOqTS.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './arguments-DniR8eF2.js';
 
 let ARGS_CACHES = new WeakMap() ;
 function getArgs(proxy) {

package/dist/dev/packages/shared-chunks/{not-DYh6AY9Z.js → not-0cVb-rLf.js}

@@ -1,6 +1,6 @@
 import { toBool } from '../@glimmer/global-context/index.js';
 import { c as createComputeRef, v as valueForRef } from './reference-BqOLhKFy.js';
-import { i as internalHelper } from './hash-6NDs_5_f.js';
+import { i as internalHelper } from './hash-BFu91gtE.js';
 
 /**
  * Performs a strict equality comparison.

package/dist/dev/packages/shared-chunks/{on-DlF0Wy7P.js → on-CVIjn2C-.js}

@@ -1,4 +1,4 @@
-import { g as buildUntouchableThis, h as check, e as reifyNamed } from './arguments-CDkbOqTS.js';
+import { g as buildUntouchableThis, h as check, e as reifyNamed } from './arguments-DniR8eF2.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';
 import { k as setInternalModifierManager } from './api-DuLOZMO_.js';
 import { v as valueForRef } from './reference-BqOLhKFy.js';
@@ -131,6 +131,10 @@ function addEventListener(element, eventName, callback, options) {
   element.addEventListener(eventName, callback, options);
 }
 
+/**
+ @module @ember/helper
+ */
+
 /**
   The `{{on}}` modifier lets you easily add event listeners (it uses
   [EventTarget.addEventListener](https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener)
@@ -139,12 +143,13 @@ function addEventListener(element, eventName, callback, options) {
   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.gjs
+  ```gjs {data-filename="app/components/like-post.gjs"}
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
 
-  export default class LikePostComponent extends Component {
-    saveLike = () => {
+  export default class LikePost extends Component {
+    @action
+    saveLike() {
       // someone likes your post!
       // better send a request off to your server...
     }
@@ -186,7 +191,7 @@ function addEventListener(element, eventName, callback, options) {
   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
+  ```hbs
   <button {{on 'click' (fn this.saveLike @post)}}>Like this post!</button>
   ```
 
@@ -195,14 +200,14 @@ function addEventListener(element, eventName, callback, options) {
 
   ### 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:
+  In the example above, we used `@action` to ensure that `likePost` is
+  properly bound to the `LikePost` Component, but let's explore what happens if we
+  left out `@action`:
 
-  ```app/components/like-post.gjs
+  ```gjs {data-filename="app/components/like-post.gjs"}
   import Component from '@glimmer/component';
 
-  export default class LikePostComponent extends Component {
+  export default class LikePost extends Component {
     saveLike() {
       // ...snip...
     }
@@ -212,10 +217,16 @@ function addEventListener(element, eventName, callback, options) {
   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`!
+  are bound (via `@action` or other means) before passing into `on`!
+
+  The `on` modifier is a keyword and does not need to be imported.
 
   @method on
+  @static
+  @for Keywords
+  @noimport
   @public
+  @since 3.11.0
 */
 class OnModifierManager {
   getDebugName() {

package/dist/dev/packages/shared-chunks/{opcodes-CplRyHl_.js → opcodes-DDajoGhq.js}

@@ -3,9 +3,7 @@ const opcodes = {
   TrustingAppend: 2,
   Comment: 3,
   Modifier: 4,
-  StrictModifier: 5,
   Block: 6,
-  StrictBlock: 7,
   Component: 8,
   OpenElement: 10,
   OpenElementWithSplat: 11,
@@ -16,8 +14,6 @@ const opcodes = {
   ComponentAttr: 16,
   AttrSplat: 17,
   Yield: 18,
-  DynamicArg: 20,
-  StaticArg: 21,
   TrustingDynamicAttr: 22,
   TrustingComponentAttr: 23,
   StaticComponentAttr: 24,

package/dist/dev/packages/shared-chunks/{outlet-B4qORyui.js → outlet-BO5-QFmm.js}

@@ -2,9 +2,9 @@ import '../@ember/debug/index.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { c as capabilityFlagsFrom } from './capabilities-CajW4QjE.js';
 import { v as valueForRef, U as UNDEFINED_REFERENCE } from './reference-BqOLhKFy.js';
-import { E as EMPTY_ARGS } from './arguments-CDkbOqTS.js';
-import { u as unwrapTemplate } from './curly-BbL6STF2.js';
-import { t as templateFactory } from './index-DaFzpTIE.js';
+import { E as EMPTY_ARGS } from './arguments-DniR8eF2.js';
+import { u as unwrapTemplate } from './curly-BCD_vyHq.js';
+import { t as templateFactory } from './index-BYUSIu_W.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function instrumentationPayload(def) {

package/dist/dev/packages/shared-chunks/{program-context-Dq8xN2HI.js → program-context-BBB1Ga5h.js}

@@ -1,8 +1,8 @@
-import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP } from './syscall-ops-CN7STuUn.js';
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP } from './syscall-ops-CkPT1Kfx.js';
 import { V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
 import { $ as $s0 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-DaFzpTIE.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-BYUSIu_W.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {

package/dist/dev/packages/shared-chunks/{render-CtH73XOv.js → render-D_Rawf-r.js}

@@ -4,7 +4,7 @@ import { U as UNDEFINED_REFERENCE, c as createComputeRef, v as valueForRef, f as
 import { t as track, U as UPDATE_TAG, e as debug, B as resetTracking, o as beginTrackFrame, s as endTrackFrame } from './cache-DGDPVCpC.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
 import { P as ProgramImpl } from './program-DlgjqLa6.js';
-import { D as DebugRenderTreeImpl, i as isArgumentError, j as isCurriedType, d as curry, A as APPEND_OPCODES, h as check, k as resolveCurriedValue, f as reifyPositional, l as AssertFilter, V as VMArgumentsImpl, m as externs, J as JumpIfNotModifiedOpcode, B as BeginTrackFrameOpcode, n as EndTrackFrameOpcode } from './arguments-CDkbOqTS.js';
+import { D as DebugRenderTreeImpl, i as isArgumentError, j as isCurriedType, d as curry, A as APPEND_OPCODES, h as check, k as resolveCurriedValue, f as reifyPositional, l as AssertFilter, V as VMArgumentsImpl, m as externs, J as JumpIfNotModifiedOpcode, B as BeginTrackFrameOpcode, n as EndTrackFrameOpcode } from './arguments-DniR8eF2.js';
 import { B as BLACKLIST_TABLE, f as DOMOperations, D as DOMTreeConstruction, N as NewTreeBuilder } from './api-Dz70AUL_.js';
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { associateDestroyableChild, _hasDestroyableChildren, destroy, destroyChildren, registerDestructor } from '../@glimmer/destroyable/index.js';
@@ -14,7 +14,7 @@ import { r as reverse } from './array-utils-CZQxrdD3.js';
 import { a as $v0, d as $pc, e as $ra, f as $fp, g as $sp, i as isLowLevelRegister } from './registers-C_W2qYHJ.js';
 import { a as VM_RETURN_TO_OP, b as VM_RETURN_OP, c as VM_JUMP_OP, d as VM_INVOKE_VIRTUAL_OP, V as VM_INVOKE_STATIC_OP, e as VM_POP_FRAME_OP, f as VM_PUSH_FRAME_OP } from './vm-ops-ImHv0Wtg.js';
 import { a as CURRIED_COMPONENT, b as CURRIED_HELPER } from './curried-BZnYakIg.js';
-import { ai as VM_CURRY_OP, p as decodeHandle, aj as VM_DYNAMIC_HELPER_OP, ak as VM_HELPER_OP, al as VM_GET_VARIABLE_OP, am as VM_SET_VARIABLE_OP, an as VM_SET_BLOCK_OP, ao as VM_ROOT_SCOPE_OP, ap as VM_GET_PROPERTY_OP, aq as VM_GET_BLOCK_OP, ar as VM_SPREAD_BLOCK_OP, as as VM_HAS_BLOCK_OP, at as VM_HAS_BLOCK_PARAMS_OP, au as VM_CONCAT_OP, av as VM_IF_INLINE_OP, aw as VM_NOT_OP, ax as VM_GET_DYNAMIC_VAR_OP, ay as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, az as VM_DYNAMIC_CONTENT_TYPE_OP, c as VM_APPEND_HTML_OP, g as VM_APPEND_SAFE_HTML_OP, d as VM_APPEND_TEXT_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, aA as VM_DEBUGGER_OP, aB as VM_ENTER_LIST_OP, aC as VM_EXIT_LIST_OP, aD as VM_ITERATE_OP } from './syscall-ops-CN7STuUn.js';
+import { ah as VM_CURRY_OP, p as decodeHandle, ai as VM_DYNAMIC_HELPER_OP, aj as VM_HELPER_OP, ak as VM_GET_VARIABLE_OP, al as VM_SET_VARIABLE_OP, am as VM_SET_BLOCK_OP, an as VM_ROOT_SCOPE_OP, ao as VM_GET_PROPERTY_OP, ap as VM_GET_BLOCK_OP, aq as VM_SPREAD_BLOCK_OP, ar as VM_HAS_BLOCK_OP, as as VM_HAS_BLOCK_PARAMS_OP, at as VM_CONCAT_OP, au as VM_IF_INLINE_OP, av as VM_NOT_OP, aw as VM_GET_DYNAMIC_VAR_OP, ax as VM_LOG_OP, a as VM_CONTENT_TYPE_OP, ay as VM_DYNAMIC_CONTENT_TYPE_OP, c as VM_APPEND_HTML_OP, g as VM_APPEND_SAFE_HTML_OP, d as VM_APPEND_TEXT_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP, az as VM_DEBUGGER_OP, aA as VM_ENTER_LIST_OP, aB as VM_EXIT_LIST_OP, aC as VM_ITERATE_OP } from './syscall-ops-CkPT1Kfx.js';
 import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
 import { a as getInternalHelperManager, c as hasInternalComponentManager, d as hasInternalHelperManager } from './api-DuLOZMO_.js';
 import { ContentType } from '../@glimmer/vm/index.js';