ember-source 5.0.0-beta.1 → 5.0.0

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0",
   "buildType": "tag",
-  "SHA": "a04ef94c9106b1aeaa267f146cc4463ee9ba3ebc",
-  "assetPath": "/tag/shas/a04ef94c9106b1aeaa267f146cc4463ee9ba3ebc.tgz"
+  "SHA": "18af34b221d79b4d4536d59af4fa8d331f0cf315",
+  "assetPath": "/tag/shas/18af34b221d79b4d4536d59af4fa8d331f0cf315.tgz"
 }

package/dist/dependencies/@glimmer/destroyable.js

@@ -1,6 +1,6 @@
 import { DEBUG } from '@glimmer/env';
 import { debugToString } from '@glimmer/util';
-import { scheduleDestroy, scheduleDestroyed } from '@glimmer/global-context';
+import { scheduleDestroyed, scheduleDestroy } from '@glimmer/global-context';
 
 let DESTROYABLE_META = new WeakMap();
 
@@ -200,4 +200,4 @@ if (DEBUG) {
   };
 }
 
-export { associateDestroyableChild, registerDestructor, unregisterDestructor, destroy, destroyChildren, _hasDestroyableChildren, isDestroying, isDestroyed, enableDestroyableTracking, assertDestroyablesDestroyed };
+export { _hasDestroyableChildren, assertDestroyablesDestroyed, associateDestroyableChild, destroy, destroyChildren, enableDestroyableTracking, isDestroyed, isDestroying, registerDestructor, unregisterDestructor };

package/dist/dependencies/@glimmer/env.js

@@ -1,4 +1,4 @@
 const DEBUG = false;
 const CI = false;
 
-export { DEBUG, CI };
+export { CI, DEBUG };

package/dist/dependencies/@glimmer/global-context.js

@@ -188,4 +188,4 @@ if (DEBUG) {
 }
 
 export default setGlobalContext;
-export { FEATURE_DEFAULT_HELPER_MANAGER, scheduleRevalidate, scheduleDestroy, scheduleDestroyed, toIterator, toBool, getProp, setProp, getPath, setPath, warnIfStyleNotTrusted, assert, deprecate, assertGlobalContextWasSet, testOverrideGlobalContext };
+export { FEATURE_DEFAULT_HELPER_MANAGER, assert, assertGlobalContextWasSet, deprecate, getPath, getProp, scheduleDestroy, scheduleDestroyed, scheduleRevalidate, setPath, setProp, testOverrideGlobalContext, toBool, toIterator, warnIfStyleNotTrusted };

package/dist/dependencies/@glimmer/low-level.js

@@ -74,4 +74,4 @@ class Stack {
 
 }
 
-export { Storage, Stack };
+export { Stack, Storage };

package/dist/dependencies/@glimmer/manager.js

@@ -1,9 +1,9 @@
 import { DEBUG } from '@glimmer/env';
 import { _WeakSet, HAS_NATIVE_PROXY, debugToString } from '@glimmer/util';
+import { FEATURE_DEFAULT_HELPER_MANAGER } from '@glimmer/global-context';
+import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
 import { valueForRef, createComputeRef, createConstRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
 import { track, createUpdatableTag, untrack } from '@glimmer/validator';
-import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
-import { FEATURE_DEFAULT_HELPER_MANAGER } from '@glimmer/global-context';
 
 const FROM_CAPABILITIES = DEBUG ? new _WeakSet() : undefined;
 function buildCapabilities(capabilities) {
@@ -505,17 +505,13 @@ function getInternalComponentManager(definition, isOptional) {
 } ///////////
 
 function hasInternalComponentManager(definition) {
-  return hasDefaultComponentManager(definition) || getManager(COMPONENT_MANAGERS, definition) !== undefined;
+  return  getManager(COMPONENT_MANAGERS, definition) !== undefined;
 }
 function hasInternalHelperManager(definition) {
   return hasDefaultHelperManager(definition) || getManager(HELPER_MANAGERS, definition) !== undefined;
 }
 function hasInternalModifierManager(definition) {
-  return hasDefaultModifierManager(definition) || getManager(MODIFIER_MANAGERS, definition) !== undefined;
-}
-
-function hasDefaultComponentManager(_definition) {
-  return false;
+  return  getManager(MODIFIER_MANAGERS, definition) !== undefined;
 }
 
 function hasDefaultHelperManager(definition) {
@@ -526,10 +522,6 @@ function hasDefaultHelperManager(definition) {
   return false;
 }
 
-function hasDefaultModifierManager(_definition) {
-  return false;
-}
-
 const CAPABILITIES = {
   dynamicLayout: false,
   dynamicTag: false,
@@ -888,4 +880,4 @@ function getComponentTemplate(obj) {
   return undefined;
 }
 
-export { setInternalHelperManager, setInternalModifierManager, setInternalComponentManager, getInternalHelperManager, getInternalModifierManager, getInternalComponentManager, hasInternalHelperManager, hasInternalModifierManager, hasInternalComponentManager, setHelperManager, setModifierManager, setComponentManager, componentCapabilities, CustomComponentManager, modifierCapabilities, CustomModifierManager, helperCapabilities, hasDestroyable, hasValue, CustomHelperManager, getComponentTemplate, setComponentTemplate, capabilityFlagsFrom, hasCapability, managerHasCapability, getCustomTagFor, setCustomTagFor };
+export { CustomComponentManager, CustomHelperManager, CustomModifierManager, capabilityFlagsFrom, componentCapabilities, getComponentTemplate, getCustomTagFor, getInternalComponentManager, getInternalHelperManager, getInternalModifierManager, hasCapability, hasDestroyable, hasInternalComponentManager, hasInternalHelperManager, hasInternalModifierManager, hasValue, helperCapabilities, managerHasCapability, modifierCapabilities, setComponentManager, setComponentTemplate, setCustomTagFor, setHelperManager, setInternalComponentManager, setInternalHelperManager, setInternalModifierManager, setModifierManager };

package/dist/dependencies/@glimmer/node.js

@@ -1,4 +1,4 @@
-import { ConcreteBounds, DOMTreeConstruction, NewElementBuilder } from '@glimmer/runtime';
+import { DOMTreeConstruction, ConcreteBounds, NewElementBuilder } from '@glimmer/runtime';
 import createHTMLDocument from '@simple-dom/document';
 
 class NodeDOMTreeConstruction extends DOMTreeConstruction {

package/dist/dependencies/@glimmer/opcode-compiler.js

@@ -1,8 +1,8 @@
-import { dict, assign, isSmallInt, debugToString, EMPTY_ARRAY, EMPTY_STRING_ARRAY, encodeImmediate, Stack, encodeHandle } from '@glimmer/util';
-import { DEBUG } from '@glimmer/env';
-import { $v0, $fp, $s0, $s1, $sp, isMachineOp } from '@glimmer/vm';
-import { assert, deprecate } from '@glimmer/global-context';
+import { $v0, $fp, $sp, $s0, $s1, isMachineOp } from '@glimmer/vm';
 import { hasCapability } from '@glimmer/manager';
+import { assign, dict, debugToString, EMPTY_STRING_ARRAY, EMPTY_ARRAY, isSmallInt, encodeImmediate, Stack, encodeHandle } from '@glimmer/util';
+import { assert, deprecate } from '@glimmer/global-context';
+import { DEBUG } from '@glimmer/env';
 import { InstructionEncoderImpl } from '@glimmer/encoder';
 
 class NamedBlocksImpl {
@@ -495,8 +495,8 @@ EXPRESSIONS.add(28
 });
 EXPRESSIONS.add(50
 /* Curry */
-, (op, [, expr$$1, type, positional, named]) => {
-  Curry(op, type, expr$$1, positional, named);
+, (op, [, expr, type, positional, named]) => {
+  Curry(op, type, expr, positional, named);
 });
 EXPRESSIONS.add(30
 /* GetSymbol */
@@ -537,14 +537,14 @@ EXPRESSIONS.add(34
 });
 EXPRESSIONS.add(36
 /* GetFreeAsHelperHeadOrThisFallback */
-, (op, expr$$1) => {
+, (op, expr) => {
   // <div id={{baz}}>
   op(1010
   /* ResolveLocal */
-  , expr$$1[1], _name => {
+  , expr[1], _name => {
     op(1006
     /* ResolveOptionalHelper */
-    , expr$$1, {
+    , expr, {
       ifHelper: handle => {
         Call(op, handle, null, null);
       }
@@ -553,17 +553,17 @@ EXPRESSIONS.add(36
 });
 EXPRESSIONS.add(99
 /* GetFreeAsDeprecatedHelperHeadOrThisFallback */
-, (op, expr$$1) => {
+, (op, expr) => {
   // <Foo @bar={{baz}}>
   op(1010
   /* ResolveLocal */
-  , expr$$1[1], _name => {
+  , expr[1], _name => {
     op(1006
     /* ResolveOptionalHelper */
-    , expr$$1, {
+    , expr, {
       ifHelper: (handle, name, moduleName) => {
-        assert(expr$$1[2] && expr$$1[2].length === 1, '[BUG] Missing argument name');
-        let arg = expr$$1[2][0];
+        assert(expr[2] && expr[2].length === 1, '[BUG] Missing argument name');
+        let arg = expr[2][0];
         deprecate(`The \`${name}\` helper was used in the \`${moduleName}\` template as \`${arg}={{${name}}}\`. ` + `This is ambigious between wanting the \`${arg}\` argument to be the \`${name}\` helper itself, ` + `or the result of invoking the \`${name}\` helper (current behavior). ` + `This implicit invocation behavior has been deprecated.\n\n` + `Instead, please explicitly invoke the helper with parenthesis, i.e. \`${arg}={{(${name})}}\`.\n\n` + `Note: the parenthesis are only required in this exact scenario where an ambiguity is present – where ` + `\`${name}\` referes to a global helper (as opposed to a local variable), AND ` + `the \`${name}\` helper invocation does not take any arguments, AND ` + `this occurs in a named argument position of a component invocation.\n\n` + `We expect this combination to be quite rare, as most helpers require at least one argument. ` + `There is no need to refactor helper invocations in cases where this deprecation was not triggered.`, false, {
           id: 'argument-less-helper-paren-less-invocation'
         });
@@ -1596,14 +1596,14 @@ function InvokeNonStaticComponent(op, {
   positional,
   named,
   atNames,
-  blocks: namedBlocks$$1,
+  blocks: namedBlocks,
   layout
 }) {
-  let bindableBlocks = !!namedBlocks$$1;
+  let bindableBlocks = !!namedBlocks;
   let bindableAtNames = capabilities === true || hasCapability(capabilities, 4
   /* PrepareArgs */
   ) || !!(named && named[0].length !== 0);
-  let blocks = namedBlocks$$1.with('attrs', elementBlock);
+  let blocks = namedBlocks.with('attrs', elementBlock);
   op(36
   /* Fetch */
   , $s0);
@@ -1973,17 +1973,17 @@ STATEMENTS.add(11
 });
 STATEMENTS.add(8
 /* Component */
-, (op, [, expr$$1, elementBlock, named, blocks]) => {
-  if (isGetFreeComponent(expr$$1)) {
+, (op, [, expr, elementBlock, named, blocks]) => {
+  if (isGetFreeComponent(expr)) {
     op(1004
     /* ResolveComponent */
-    , expr$$1, component => {
+    , expr, component => {
       InvokeComponent(op, component, elementBlock, null, named, blocks);
     });
   } else {
     // otherwise, the component name was an expression, so resolve the expression
     // and invoke it as a dynamic component
-    InvokeDynamicComponent(op, expr$$1, elementBlock, null, named, blocks, true, true);
+    InvokeDynamicComponent(op, expr, elementBlock, null, named, blocks, true, true);
   }
 });
 STATEMENTS.add(18
@@ -2140,15 +2140,15 @@ STATEMENTS.add(2
 });
 STATEMENTS.add(6
 /* Block */
-, (op, [, expr$$1, positional, named, blocks]) => {
-  if (isGetFreeComponent(expr$$1)) {
+, (op, [, expr, positional, named, blocks]) => {
+  if (isGetFreeComponent(expr)) {
     op(1004
     /* ResolveComponent */
-    , expr$$1, component => {
+    , expr, component => {
       InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
     });
   } else {
-    InvokeDynamicComponent(op, expr$$1, null, positional, named, blocks, false, false);
+    InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
   }
 });
 STATEMENTS.add(40
@@ -2292,15 +2292,15 @@ STATEMENTS.add(45
 });
 STATEMENTS.add(46
 /* InvokeComponent */
-, (op, [, expr$$1, positional, named, blocks]) => {
-  if (isGetFreeComponent(expr$$1)) {
+, (op, [, expr, positional, named, blocks]) => {
+  if (isGetFreeComponent(expr)) {
     op(1004
     /* ResolveComponent */
-    , expr$$1, component => {
+    , expr, component => {
       InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
     });
   } else {
-    InvokeDynamicComponent(op, expr$$1, null, positional, named, blocks, false, false);
+    InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
   }
 });
 
@@ -2313,11 +2313,11 @@ function hashToArgs(hash) {
 const PLACEHOLDER_HANDLE = -1;
 
 class CompilableTemplateImpl {
-  constructor(statements, meta$$1, // Part of CompilableTemplate
+  constructor(statements, meta, // Part of CompilableTemplate
   symbolTable, // Used for debugging
   moduleName = 'plain block') {
     this.statements = statements;
-    this.meta = meta$$1;
+    this.meta = meta;
     this.symbolTable = symbolTable;
     this.moduleName = moduleName;
     this.compiled = null;
@@ -2343,16 +2343,16 @@ function maybeCompile(compilable, context) {
   compilable.compiled = PLACEHOLDER_HANDLE;
   let {
     statements,
-    meta: meta$$1
+    meta
   } = compilable;
-  let result = compileStatements(statements, meta$$1, context);
+  let result = compileStatements(statements, meta, context);
   compilable.compiled = result;
   return result;
 }
 
-function compileStatements(statements, meta$$1, syntaxContext) {
+function compileStatements(statements, meta, syntaxContext) {
   let sCompiler = STATEMENTS;
-  let context = templateCompilationContext(syntaxContext, meta$$1);
+  let context = templateCompilationContext(syntaxContext, meta);
   let {
     encoder,
     program: {
@@ -2362,14 +2362,14 @@ function compileStatements(statements, meta$$1, syntaxContext) {
   } = context;
 
   function pushOp(...op) {
-    encodeOp(encoder, constants, resolver, meta$$1, op);
+    encodeOp(encoder, constants, resolver, meta, op);
   }
 
   for (let i = 0; i < statements.length; i++) {
     sCompiler.compile(pushOp, statements[i]);
   }
 
-  let handle = context.encoder.commit(meta$$1.size);
+  let handle = context.encoder.commit(meta.size);
 
   return handle;
 }
@@ -3001,4 +3001,4 @@ class TemplateImpl {
 
 }
 
-export { debugCompiler, compileStatements, compilable, InvokeStaticBlockWithStack as invokeStaticBlockWithStack, InvokeStaticBlock as invokeStaticBlock, compileStd, meta, StdLib, templateFactory, templateCacheCounters, WrappedBuilder, EMPTY_BLOCKS, CompileTimeCompilationContextImpl, programCompilationContext, templateCompilationContext, DEFAULT_CAPABILITIES, MINIMAL_CAPABILITIES };
+export { CompileTimeCompilationContextImpl, DEFAULT_CAPABILITIES, EMPTY_BLOCKS, MINIMAL_CAPABILITIES, StdLib, WrappedBuilder, compilable, compileStatements, compileStd, debugCompiler, InvokeStaticBlock as invokeStaticBlock, InvokeStaticBlockWithStack as invokeStaticBlockWithStack, meta, programCompilationContext, templateCacheCounters, templateCompilationContext, templateFactory };

package/dist/dependencies/@glimmer/program.js

@@ -1,5 +1,5 @@
 import { constants, unwrapTemplate } from '@glimmer/util';
-import { capabilityFlagsFrom, getComponentTemplate, getInternalComponentManager, getInternalHelperManager, getInternalModifierManager, managerHasCapability } from '@glimmer/manager';
+import { getInternalHelperManager, getInternalModifierManager, getInternalComponentManager, capabilityFlagsFrom, getComponentTemplate, managerHasCapability } from '@glimmer/manager';
 import { templateFactory } from '@glimmer/opcode-compiler';
 
 /**
@@ -154,16 +154,16 @@ class ConstantsImpl extends CompileTimeConstantImpl {
         return null;
       }
       let capabilities = capabilityFlagsFrom(manager.getCapabilities(definitionState));
-      let templateFactory$$1 = getComponentTemplate(definitionState);
+      let templateFactory = getComponentTemplate(definitionState);
       let compilable = null;
       let template;
 
       if (!managerHasCapability(manager, capabilities, 1
       /* DynamicLayout */
       )) {
-        template = (_a = templateFactory$$1 === null || templateFactory$$1 === void 0 ? void 0 : templateFactory$$1(owner)) !== null && _a !== void 0 ? _a : this.defaultTemplate;
+        template = (_a = templateFactory === null || templateFactory === void 0 ? void 0 : templateFactory(owner)) !== null && _a !== void 0 ? _a : this.defaultTemplate;
       } else {
-        template = templateFactory$$1 === null || templateFactory$$1 === void 0 ? void 0 : templateFactory$$1(owner);
+        template = templateFactory === null || templateFactory === void 0 ? void 0 : templateFactory(owner);
       }
 
       if (template !== undefined) {
@@ -319,7 +319,7 @@ class RuntimeHeapImpl {
   }
 
   sizeof(handle) {
-    return sizeof(this.table, handle);
+    return sizeof(this.table);
   }
 
 }
@@ -402,7 +402,7 @@ class HeapImpl {
   }
 
   sizeof(handle) {
-    return sizeof(this.handleTable, handle);
+    return sizeof(this.handleTable);
   }
 
   free(handle) {
@@ -476,8 +476,8 @@ class HeapImpl {
 
 }
 class RuntimeProgramImpl {
-  constructor(constants$$1, heap) {
-    this.constants = constants$$1;
+  constructor(constants, heap) {
+    this.constants = constants;
     this.heap = heap;
     this._opcode = new RuntimeOpImpl(this.heap);
   }
@@ -516,4 +516,4 @@ function artifacts() {
   };
 }
 
-export { CompileTimeConstantImpl, RuntimeConstantsImpl, ConstantsImpl, RuntimeHeapImpl, hydrateHeap, HeapImpl, RuntimeProgramImpl, RuntimeOpImpl, artifacts };
+export { CompileTimeConstantImpl, ConstantsImpl, HeapImpl, RuntimeConstantsImpl, RuntimeHeapImpl, RuntimeOpImpl, RuntimeProgramImpl, artifacts, hydrateHeap };

package/dist/dependencies/@glimmer/reference.js

@@ -1,7 +1,7 @@
 import { DEBUG } from '@glimmer/env';
-import { getProp, setProp, getPath, toIterator } from '@glimmer/global-context';
-import { isDict, symbol, EMPTY_ARRAY, isObject } from '@glimmer/util';
-import { CONSTANT_TAG, consumeTag, INITIAL, track, validateTag, valueForTag, createTag, dirtyTag } from '@glimmer/validator';
+import { setProp, getProp, toIterator, getPath } from '@glimmer/global-context';
+import { symbol, isDict, EMPTY_ARRAY, isObject } from '@glimmer/util';
+import { CONSTANT_TAG, validateTag, track, valueForTag, consumeTag, INITIAL, createTag, dirtyTag } from '@glimmer/validator';
 
 const REFERENCE = symbol('REFERENCE');
 
@@ -437,4 +437,4 @@ class ArrayIterator {
 
 }
 
-export { REFERENCE, createPrimitiveRef, createConstRef, createUnboundRef, createComputeRef, createDebugAliasRef, createReadOnlyRef, createInvokableRef, isInvokableRef, isConstRef, isUpdatableRef, valueForRef, updateRef, childRefFor, childRefFromParts, UNDEFINED_REFERENCE, NULL_REFERENCE, TRUE_REFERENCE, FALSE_REFERENCE, createIteratorRef, createIteratorItemRef };
+export { FALSE_REFERENCE, NULL_REFERENCE, REFERENCE, TRUE_REFERENCE, UNDEFINED_REFERENCE, childRefFor, childRefFromParts, createComputeRef, createConstRef, createDebugAliasRef, createInvokableRef, createIteratorItemRef, createIteratorRef, createPrimitiveRef, createReadOnlyRef, createUnboundRef, isConstRef, isInvokableRef, isUpdatableRef, updateRef, valueForRef };

package/dist/dependencies/@glimmer/runtime.js

@@ -1,15 +1,15 @@
-import { assign, symbol, Stack, fillNulls, _WeakSet, isObject, dict, emptyArray, EMPTY_STRING_ARRAY, debugToString, decodeHandle, decodeImmediate, isHandle, unwrapTemplate, clearElement, unwrapHandle, buildUntouchableThis, HAS_NATIVE_PROXY, isDict } from '@glimmer/util';
-import { UNDEFINED_REFERENCE, valueForRef, createComputeRef, createDebugAliasRef, childRefFor, TRUE_REFERENCE, FALSE_REFERENCE, isConstRef, createPrimitiveRef, NULL_REFERENCE, createConstRef, createIteratorRef, updateRef, createIteratorItemRef, isInvokableRef } from '@glimmer/reference';
+import { UNDEFINED_REFERENCE, createComputeRef, valueForRef, createDebugAliasRef, childRefFor, TRUE_REFERENCE, FALSE_REFERENCE, createConstRef, createPrimitiveRef, isConstRef, NULL_REFERENCE, createIteratorRef, updateRef, createIteratorItemRef, isInvokableRef } from '@glimmer/reference';
+import { assign, symbol, Stack, fillNulls, _WeakSet, isObject, emptyArray, EMPTY_STRING_ARRAY, dict, decodeHandle, debugToString, isHandle, decodeImmediate, unwrapTemplate, clearElement, unwrapHandle, buildUntouchableThis, HAS_NATIVE_PROXY, isDict } from '@glimmer/util';
+import { $pc, $sp, $v0, $t0, $t1, $ra, $fp, isLowLevelRegister, $s1, $s0 } from '@glimmer/vm';
+import { registerDestructor, destroy, associateDestroyableChild, _hasDestroyableChildren, destroyChildren, isDestroying, isDestroyed } from '@glimmer/destroyable';
+export { destroy, isDestroyed, isDestroying, registerDestructor } from '@glimmer/destroyable';
 import { warnIfStyleNotTrusted, toBool, assertGlobalContextWasSet, deprecate, getPath, setPath } from '@glimmer/global-context';
 import { DEBUG } from '@glimmer/env';
-import { destroy, registerDestructor, associateDestroyableChild, _hasDestroyableChildren, destroyChildren, isDestroyed, isDestroying } from '@glimmer/destroyable';
-export { destroy, registerDestructor, isDestroying, isDestroyed } from '@glimmer/destroyable';
-import { $fp, $pc, $ra, $sp, $v0, $t0, $t1, $s0, $s1, isLowLevelRegister } from '@glimmer/vm';
-import { CONSTANT_TAG, valueForTag, validateTag, INITIAL, beginTrackFrame, endTrackFrame, consumeTag, CURRENT_TAG, track, updateTag, resetTracking, runInTrackingTransaction, createCache, getValue, createUpdatableTag } from '@glimmer/validator';
-import { managerHasCapability, hasInternalComponentManager, hasInternalHelperManager, setInternalComponentManager, getInternalHelperManager, hasDestroyable, hasValue, setInternalHelperManager, setInternalModifierManager } from '@glimmer/manager';
+import { CONSTANT_TAG, beginTrackFrame, endTrackFrame, INITIAL, validateTag, consumeTag, valueForTag, CURRENT_TAG, track, updateTag, runInTrackingTransaction, resetTracking, createCache, getValue, createUpdatableTag } from '@glimmer/validator';
+import { managerHasCapability, hasInternalComponentManager, hasInternalHelperManager, setInternalComponentManager, getInternalHelperManager, hasValue, hasDestroyable, setInternalHelperManager, setInternalModifierManager } from '@glimmer/manager';
 import { RuntimeProgramImpl } from '@glimmer/program';
 import { getOwner } from '@glimmer/owner';
-import { reifyPositional, reifyNamed } from '@glimmer/runtime';
+import { reifyPositional as reifyPositional$1, reifyNamed as reifyNamed$1 } from '@glimmer/runtime';
 
 class DynamicScopeImpl {
   constructor(bucket) {
@@ -78,12 +78,12 @@ class PartialScopeImpl {
     return this.get(0);
   }
 
-  getSymbol(symbol$$1) {
-    return this.get(symbol$$1);
+  getSymbol(symbol) {
+    return this.get(symbol);
   }
 
-  getBlock(symbol$$1) {
-    let block = this.get(symbol$$1);
+  getBlock(symbol) {
+    let block = this.get(symbol);
     return block === UNDEFINED_REFERENCE ? null : block;
   }
 
@@ -95,20 +95,20 @@ class PartialScopeImpl {
     return this.partialMap;
   }
 
-  bind(symbol$$1, value) {
-    this.set(symbol$$1, value);
+  bind(symbol, value) {
+    this.set(symbol, value);
   }
 
   bindSelf(self) {
     this.set(0, self);
   }
 
-  bindSymbol(symbol$$1, value) {
-    this.set(symbol$$1, value);
+  bindSymbol(symbol, value) {
+    this.set(symbol, value);
   }
 
-  bindBlock(symbol$$1, value) {
-    this.set(symbol$$1, value);
+  bindBlock(symbol, value) {
+    this.set(symbol, value);
   }
 
   bindEvalScope(map) {
@@ -1815,7 +1815,7 @@ function createCapturedArgs(named, positional) {
     positional
   };
 }
-function reifyNamed$1(named) {
+function reifyNamed(named) {
   let reified = dict();
 
   for (let key in named) {
@@ -1824,13 +1824,13 @@ function reifyNamed$1(named) {
 
   return reified;
 }
-function reifyPositional$1(positional) {
+function reifyPositional(positional) {
   return positional.map(valueForRef);
 }
 function reifyArgs(args) {
   return {
-    named: reifyNamed$1(args.named),
-    positional: reifyPositional$1(args.positional)
+    named: reifyNamed(args.named),
+    positional: reifyPositional(args.positional)
   };
 }
 const EMPTY_NAMED = Object.freeze(Object.create(null));
@@ -1941,28 +1941,28 @@ APPEND_OPCODES.add(16
 APPEND_OPCODES.add(21
 /* GetVariable */
 , (vm, {
-  op1: symbol$$1
+  op1: symbol
 }) => {
-  let expr = vm.referenceForSymbol(symbol$$1);
+  let expr = vm.referenceForSymbol(symbol);
   vm.stack.push(expr);
 });
 APPEND_OPCODES.add(19
 /* SetVariable */
 , (vm, {
-  op1: symbol$$1
+  op1: symbol
 }) => {
   let expr = vm.stack.pop();
-  vm.scope().bindSymbol(symbol$$1, expr);
+  vm.scope().bindSymbol(symbol, expr);
 });
 APPEND_OPCODES.add(20
 /* SetBlock */
 , (vm, {
-  op1: symbol$$1
+  op1: symbol
 }) => {
   let handle = vm.stack.pop();
   let scope = vm.stack.pop();
   let table = vm.stack.pop();
-  vm.scope().bindBlock(symbol$$1, [handle, scope, table]);
+  vm.scope().bindBlock(symbol, [handle, scope, table]);
 });
 APPEND_OPCODES.add(102
 /* ResolveMaybeLocal */
@@ -2109,7 +2109,7 @@ APPEND_OPCODES.add(112
   } = vm.stack.pop().capture();
   vm.loadValue($v0, createComputeRef(() => {
     // eslint-disable-next-line no-console
-    console.log(...reifyPositional$1(positional));
+    console.log(...reifyPositional(positional));
   }));
 });
 
@@ -3532,17 +3532,17 @@ APPEND_OPCODES.add(17
 
   for (let i = callerNames.length - 1; i >= 0; i--) {
     let atName = callerNames[i];
-    let symbol$$1 = state.table.symbols.indexOf(callerNames[i]);
+    let symbol = state.table.symbols.indexOf(callerNames[i]);
     let value = args.named.get(atName, true);
-    if (symbol$$1 !== -1) scope.bindSymbol(symbol$$1 + 1, value);
+    if (symbol !== -1) scope.bindSymbol(symbol + 1, value);
     if (state.lookup) state.lookup[atName] = value;
   }
 });
 
 function bindBlock(symbolName, blockName, state, blocks, vm) {
-  let symbol$$1 = state.table.symbols.indexOf(symbolName);
+  let symbol = state.table.symbols.indexOf(symbolName);
   let block = blocks.get(blockName);
-  if (symbol$$1 !== -1) vm.scope().bindBlock(symbol$$1 + 1, block);
+  if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
   if (state.lookup) state.lookup[symbolName] = block;
 }
 
@@ -5730,8 +5730,8 @@ class VM {
     return this.scope().getSelf();
   }
 
-  referenceForSymbol(symbol$$1) {
-    return this.scope().getSymbol(symbol$$1);
+  referenceForSymbol(symbol) {
+    return this.scope().getSymbol(symbol);
   } /// EXECUTION
 
 
@@ -6594,7 +6594,7 @@ var fn = internalHelper(({
   if (DEBUG) assertCallbackIsFn(callbackRef);
   return createComputeRef(() => {
     return (...invocationArgs) => {
-      let [fn, ...args] = reifyPositional(positional);
+      let [fn, ...args] = reifyPositional$1(positional);
       if (DEBUG) assertCallbackIsFn(callbackRef);
 
       if (isInvokableRef(callbackRef)) {
@@ -6671,7 +6671,7 @@ var hash = internalHelper(({
   named
 }) => {
   let ref = createComputeRef(() => {
-    let hash = reifyNamed(named);
+    let hash = reifyNamed$1(named);
 
     if (DEBUG && HAS_NATIVE_PROXY) {
       hash = wrapHashProxy(hash);
@@ -6728,7 +6728,7 @@ var hash = internalHelper(({
 var array = internalHelper(({
   positional
 }) => {
-  return createComputeRef(() => reifyPositional(positional), null, 'array');
+  return createComputeRef(() => reifyPositional$1(positional), null, 'array');
 });
 
 /**
@@ -6867,7 +6867,7 @@ const normalizeTextValue = value => {
 var concat = internalHelper(({
   positional
 }) => {
-  return createComputeRef(() => reifyPositional(positional).map(normalizeTextValue).join(''), null, 'concat');
+  return createComputeRef(() => reifyPositional$1(positional).map(normalizeTextValue).join(''), null, 'concat');
 });
 
 const untouchableContext = buildUntouchableThis('`on` modifier');
@@ -6924,7 +6924,7 @@ class OnModifierState {
       once,
       passive,
       capture
-    } = reifyNamed(args.named);
+    } = reifyNamed$1(args.named);
 
     if (once !== this.once) {
       this.once = once;
@@ -7233,4 +7233,4 @@ class OnModifierManager {
 
 var on = setInternalModifierManager(new OnModifierManager(), {});
 
-export { clear, ConcreteBounds, CursorImpl, resetDebuggerCallback, setDebuggerCallback, curry, CurriedValue, TemplateOnlyComponentManager, TEMPLATE_ONLY_COMPONENT_MANAGER, TemplateOnlyComponentDefinition as TemplateOnlyComponent, templateOnlyComponent, helper$1 as DOMChanges, DOMChangesImpl as IDOMChanges, DOMTreeConstruction, isWhitespace, normalizeProperty, DynamicScopeImpl, PartialScopeImpl, runtimeContext, EnvironmentImpl, inTransaction, renderComponent, renderMain, renderSync, UpdatingVMImpl as UpdatingVM, VM as LowLevelVM, EMPTY_ARGS, EMPTY_NAMED, EMPTY_POSITIONAL, createCapturedArgs, reifyArgs, reifyNamed$1 as reifyNamed, reifyPositional$1 as reifyPositional, DynamicAttribute, dynamicAttribute, SimpleDynamicAttribute, clientBuilder, NewElementBuilder, UpdatableBlockImpl, RemoteLiveBlock, isSerializationFirstNode, RehydrateBuilder, rehydrationBuilder, SERIALIZATION_FIRST_NODE_STRING, invokeHelper, fn, hash, array, get, concat, on };
+export { ConcreteBounds, CurriedValue, CursorImpl, helper$1 as DOMChanges, DOMTreeConstruction, DynamicAttribute, DynamicScopeImpl, EMPTY_ARGS, EMPTY_NAMED, EMPTY_POSITIONAL, EnvironmentImpl, DOMChangesImpl as IDOMChanges, VM as LowLevelVM, NewElementBuilder, PartialScopeImpl, RehydrateBuilder, RemoteLiveBlock, SERIALIZATION_FIRST_NODE_STRING, SimpleDynamicAttribute, TEMPLATE_ONLY_COMPONENT_MANAGER, TemplateOnlyComponentDefinition as TemplateOnlyComponent, TemplateOnlyComponentManager, UpdatableBlockImpl, UpdatingVMImpl as UpdatingVM, array, clear, clientBuilder, concat, createCapturedArgs, curry, dynamicAttribute, fn, get, hash, inTransaction, invokeHelper, isSerializationFirstNode, isWhitespace, normalizeProperty, on, rehydrationBuilder, reifyArgs, reifyNamed, reifyPositional, renderComponent, renderMain, renderSync, resetDebuggerCallback, runtimeContext, setDebuggerCallback, templateOnlyComponent };

package/dist/dependencies/@glimmer/util.js

@@ -17,7 +17,7 @@ function isEmptyArray(input) {
 
 // import Logger from './logger';
 
-function debugAssert$$1(test, msg) {
+function debugAssert(test, msg) {
   // if (!alreadyWarned) {
   //   alreadyWarned = true;
   //   Logger.warn("Don't leave debug assertions on in public builds");
@@ -26,7 +26,7 @@ function debugAssert$$1(test, msg) {
     throw new Error(msg || 'assertion failure');
   }
 }
-function deprecate$$1(desc) {
+function deprecate(desc) {
   LOCAL_LOGGER.warn(`DEPRECATION: ${desc}`);
 }
 
@@ -574,4 +574,4 @@ function assertNever(value, desc = 'unexpected unreachable branch') {
   throw new Error(`code reached unreachable`);
 }
 
-export { LOCAL_LOGGER, LOGGER, assertNever, debugAssert$$1 as assert, deprecate$$1 as deprecate, dict, isDict, isObject, StackImpl as Stack, isSerializationFirstNode, SERIALIZATION_FIRST_NODE_STRING, assign, fillNulls, values, weakSet as _WeakSet, castToSimple, castToBrowser, checkNode, intern, buildUntouchableThis, debugToString$1 as debugToString, beginTestSteps, endTestSteps, logStep, verifySteps, EMPTY_ARRAY, emptyArray, EMPTY_STRING_ARRAY, EMPTY_NUMBER_ARRAY, isEmptyArray, clearElement, HAS_NATIVE_PROXY, HAS_NATIVE_SYMBOL, keys, unwrap, expect, unreachable, exhausted, tuple, enumerableSymbol, symbol, strip, isHandle, isNonPrimitiveHandle, constants, isSmallInt, encodeNegative, decodeNegative, encodePositive, decodePositive, encodeHandle, decodeHandle, encodeImmediate, decodeImmediate, unwrapHandle, unwrapTemplate, extractHandle, isOkHandle, isErrHandle, isPresent, ifPresent, toPresentOption, assertPresent, mapPresent };
+export { EMPTY_ARRAY, EMPTY_NUMBER_ARRAY, EMPTY_STRING_ARRAY, HAS_NATIVE_PROXY, HAS_NATIVE_SYMBOL, LOCAL_LOGGER, LOGGER, SERIALIZATION_FIRST_NODE_STRING, StackImpl as Stack, weakSet as _WeakSet, debugAssert as assert, assertNever, assertPresent, assign, beginTestSteps, buildUntouchableThis, castToBrowser, castToSimple, checkNode, clearElement, constants, debugToString$1 as debugToString, decodeHandle, decodeImmediate, decodeNegative, decodePositive, deprecate, dict, emptyArray, encodeHandle, encodeImmediate, encodeNegative, encodePositive, endTestSteps, enumerableSymbol, exhausted, expect, extractHandle, fillNulls, ifPresent, intern, isDict, isEmptyArray, isErrHandle, isHandle, isNonPrimitiveHandle, isObject, isOkHandle, isPresent, isSerializationFirstNode, isSmallInt, keys, logStep, mapPresent, strip, symbol, toPresentOption, tuple, unreachable, unwrap, unwrapHandle, unwrapTemplate, values, verifySteps };

package/dist/dependencies/@glimmer/validator.js

@@ -733,4 +733,4 @@ if (globalObj[GLIMMER_VALIDATOR_REGISTRATION] === true) {
 
 globalObj[GLIMMER_VALIDATOR_REGISTRATION] = true;
 
-export { ALLOW_CYCLES, bump, combine, COMPUTE, CONSTANT_TAG, CONSTANT, createTag, createUpdatableTag, CurrentTag, CURRENT_TAG, DIRTY_TAG as dirtyTag, INITIAL, isConstTag, UPDATE_TAG as updateTag, validateTag, valueForTag, VolatileTag, VOLATILE_TAG, VOLATILE, dirtyTagFor, tagFor, tagMetaFor, beginTrackFrame, endTrackFrame, beginUntrackFrame, endUntrackFrame, resetTracking, consumeTag, isTracking, track, untrack, createCache, isConst, getValue, trackedData, logTrackingStack, setTrackingTransactionEnv, runInTrackingTransaction, beginTrackingTransaction, endTrackingTransaction };
+export { ALLOW_CYCLES, COMPUTE, CONSTANT, CONSTANT_TAG, CURRENT_TAG, CurrentTag, INITIAL, VOLATILE, VOLATILE_TAG, VolatileTag, beginTrackFrame, beginTrackingTransaction, beginUntrackFrame, bump, combine, consumeTag, createCache, createTag, createUpdatableTag, DIRTY_TAG as dirtyTag, dirtyTagFor, endTrackFrame, endTrackingTransaction, endUntrackFrame, getValue, isConst, isConstTag, isTracking, logTrackingStack, resetTracking, runInTrackingTransaction, setTrackingTransactionEnv, tagFor, tagMetaFor, track, trackedData, untrack, UPDATE_TAG as updateTag, validateTag, valueForTag };