ember-source 5.12.0-beta.2 → 5.12.0

package/dist/packages/@glimmer/owner/index.js

@@ -1,4 +1,5 @@
-const OWNER = Symbol('OWNER');
+const OWNER = Symbol("OWNER");
+
 /**
   Framework objects in a Glimmer application may receive an owner object.
   Glimmer is unopinionated about this owner, but will forward it through its

package/dist/packages/@glimmer/program/index.js

@@ -7,40 +7,31 @@ import { SexpOpcodes as opcodes } from '../wire-format/index.js';
 /**
  * Default component template, which is a plain yield
  */
-const DEFAULT_TEMPLATE_BLOCK = [[[opcodes.Yield, 1, null]], ['&default'], false, []];
-const DEFAULT_TEMPLATE = {
-  // random uuid
-  id: '1b32f5c2-7623-43d6-a0ad-9672898920a1',
-  moduleName: '__default__.hbs',
-  block: JSON.stringify(DEFAULT_TEMPLATE_BLOCK),
-  scope: null,
-  isStrictMode: true
-};
-const WELL_KNOWN_EMPTY_ARRAY = Object.freeze([]);
-const STARTER_CONSTANTS = constants(WELL_KNOWN_EMPTY_ARRAY);
-const WELL_KNOWN_EMPTY_ARRAY_POSITION = STARTER_CONSTANTS.indexOf(WELL_KNOWN_EMPTY_ARRAY);
+const DEFAULT_TEMPLATE_BLOCK = [[[opcodes.Yield, 1, null]], ["&default"], !1, []],
+  DEFAULT_TEMPLATE = {
+    // random uuid
+    id: "1b32f5c2-7623-43d6-a0ad-9672898920a1",
+    moduleName: "__default__.hbs",
+    block: JSON.stringify(DEFAULT_TEMPLATE_BLOCK),
+    scope: null,
+    isStrictMode: !0
+  },
+  WELL_KNOWN_EMPTY_ARRAY = Object.freeze([]),
+  STARTER_CONSTANTS = constants(WELL_KNOWN_EMPTY_ARRAY),
+  WELL_KNOWN_EMPTY_ARRAY_POSITION = STARTER_CONSTANTS.indexOf(WELL_KNOWN_EMPTY_ARRAY);
 class CompileTimeConstantImpl {
   // `0` means NULL
-
   values = STARTER_CONSTANTS.slice();
   indexMap = new Map(this.values.map((value, index) => [value, index]));
   value(value) {
-    let indexMap = this.indexMap;
-    let index = indexMap.get(value);
-    if (index === undefined) {
-      index = this.values.push(value) - 1;
-      indexMap.set(value, index);
-    }
-    return index;
+    let indexMap = this.indexMap,
+      index = indexMap.get(value);
+    return void 0 === index && (index = this.values.push(value) - 1, indexMap.set(value, index)), index;
   }
   array(values) {
-    if (values.length === 0) {
-      return WELL_KNOWN_EMPTY_ARRAY_POSITION;
-    }
+    if (0 === values.length) return WELL_KNOWN_EMPTY_ARRAY_POSITION;
     let handles = new Array(values.length);
-    for (let i = 0; i < values.length; i++) {
-      handles[i] = this.value(values[i]);
-    }
+    for (let i = 0; i < values.length; i++) handles[i] = this.value(values[i]);
     return this.value(handles);
   }
   toPool() {
@@ -56,11 +47,9 @@ class RuntimeConstantsImpl {
     return this.values[handle];
   }
   getArray(value) {
-    let handles = this.getValue(value);
-    let reified = new Array(handles.length);
-    for (const [i, n] of enumerate(handles)) {
-      reified[i] = this.getValue(n);
-    }
+    let handles = this.getValue(value),
+      reified = new Array(handles.length);
+    for (const [i, n] of enumerate(handles)) reified[i] = this.getValue(n);
     return reified;
   }
 }
@@ -69,7 +58,6 @@ class ConstantsImpl extends CompileTimeConstantImpl {
     [WELL_KNOWN_EMPTY_ARRAY_POSITION]: WELL_KNOWN_EMPTY_ARRAY
   };
   defaultTemplate = templateFactory(DEFAULT_TEMPLATE)();
-
   // Used for tests and debugging purposes, and to be able to analyze large apps
   // This is why it's enabled even in production
   helperDefinitionCount = 0;
@@ -82,121 +70,83 @@ class ConstantsImpl extends CompileTimeConstantImpl {
   // TODO: Add a way to expose resolved name for debugging
   _resolvedName = null, isOptional) {
     let handle = this.helperDefinitionCache.get(definitionState);
-    if (handle === undefined) {
+    if (void 0 === handle) {
       let managerOrHelper = getInternalHelperManager(definitionState, isOptional);
-      if (managerOrHelper === null) {
-        this.helperDefinitionCache.set(definitionState, null);
-        return null;
-      }
-      debugAssert(managerOrHelper, 'BUG: expected manager or helper');
-      let helper = typeof managerOrHelper === 'function' ? managerOrHelper : managerOrHelper.getHelper(definitionState);
-      handle = this.value(helper);
-      this.helperDefinitionCache.set(definitionState, handle);
-      this.helperDefinitionCount++;
+      if (null === managerOrHelper) return this.helperDefinitionCache.set(definitionState, null), null;
+      debugAssert(managerOrHelper, "BUG: expected manager or helper");
+      let helper = "function" == typeof managerOrHelper ? managerOrHelper : managerOrHelper.getHelper(definitionState);
+      handle = this.value(helper), this.helperDefinitionCache.set(definitionState, handle), this.helperDefinitionCount++;
     }
     return handle;
   }
   modifier(definitionState, resolvedName = null, isOptional) {
     let handle = this.modifierDefinitionCache.get(definitionState);
-    if (handle === undefined) {
+    if (void 0 === handle) {
       let manager = getInternalModifierManager(definitionState, isOptional);
-      if (manager === null) {
-        this.modifierDefinitionCache.set(definitionState, null);
-        return null;
-      }
+      if (null === manager) return this.modifierDefinitionCache.set(definitionState, null), null;
       let definition = {
-        resolvedName,
-        manager,
+        resolvedName: resolvedName,
+        manager: manager,
         state: definitionState
       };
-      handle = this.value(definition);
-      this.modifierDefinitionCache.set(definitionState, handle);
-      this.modifierDefinitionCount++;
+      handle = this.value(definition), this.modifierDefinitionCache.set(definitionState, handle), this.modifierDefinitionCount++;
     }
     return handle;
   }
   component(definitionState, owner, isOptional) {
     let definition = this.componentDefinitionCache.get(definitionState);
-    if (definition === undefined) {
+    if (void 0 === definition) {
       let manager = getInternalComponentManager(definitionState, isOptional);
-      if (manager === null) {
-        this.componentDefinitionCache.set(definitionState, null);
-        return null;
-      }
-      debugAssert(manager, 'BUG: expected manager');
-      let capabilities = capabilityFlagsFrom(manager.getCapabilities(definitionState));
-      let templateFactory = getComponentTemplate(definitionState);
-      let compilable = null;
-      let template;
-      if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) {
-        template = templateFactory?.(owner) ?? this.defaultTemplate;
-      } else {
-        template = templateFactory?.(owner);
-      }
-      if (template !== undefined) {
-        template = unwrapTemplate(template);
-        compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout();
-      }
-      definition = {
+      if (null === manager) return this.componentDefinitionCache.set(definitionState, null), null;
+      debugAssert(manager, "BUG: expected manager");
+      let template,
+        capabilities = capabilityFlagsFrom(manager.getCapabilities(definitionState)),
+        templateFactory = getComponentTemplate(definitionState),
+        compilable = null;
+      template = managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout) ? templateFactory?.(owner) : templateFactory?.(owner) ?? this.defaultTemplate, void 0 !== template && (template = unwrapTemplate(template), compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout()), definition = {
         resolvedName: null,
         handle: -1,
         // replaced momentarily
-        manager,
-        capabilities,
+        manager: manager,
+        capabilities: capabilities,
         state: definitionState,
-        compilable
-      };
-      definition.handle = this.value(definition);
-      this.componentDefinitionCache.set(definitionState, definition);
-      this.componentDefinitionCount++;
+        compilable: compilable
+      }, definition.handle = this.value(definition), this.componentDefinitionCache.set(definitionState, definition), this.componentDefinitionCount++;
     }
     return definition;
   }
   resolvedComponent(resolvedDefinition, resolvedName) {
     let definition = this.componentDefinitionCache.get(resolvedDefinition);
-    if (definition === undefined) {
+    if (void 0 === definition) {
       let {
-        manager,
-        state,
-        template
-      } = resolvedDefinition;
-      let capabilities = capabilityFlagsFrom(manager.getCapabilities(resolvedDefinition));
-      let compilable = null;
-      if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout)) {
-        template = template ?? this.defaultTemplate;
-      }
-      if (template !== null) {
-        template = unwrapTemplate(template);
-        compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout();
-      }
-      definition = {
-        resolvedName,
+          manager: manager,
+          state: state,
+          template: template
+        } = resolvedDefinition,
+        capabilities = capabilityFlagsFrom(manager.getCapabilities(resolvedDefinition)),
+        compilable = null;
+      managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicLayout) || (template = template ?? this.defaultTemplate), null !== template && (template = unwrapTemplate(template), compilable = managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped) ? template.asWrappedLayout() : template.asLayout()), definition = {
+        resolvedName: resolvedName,
         handle: -1,
         // replaced momentarily
-        manager,
-        capabilities,
-        state,
-        compilable
-      };
-      definition.handle = this.value(definition);
-      this.componentDefinitionCache.set(resolvedDefinition, definition);
-      this.componentDefinitionCount++;
+        manager: manager,
+        capabilities: capabilities,
+        state: state,
+        compilable: compilable
+      }, definition.handle = this.value(definition), this.componentDefinitionCache.set(resolvedDefinition, definition), this.componentDefinitionCount++;
     }
-    return expect(definition, 'BUG: resolved component definitions cannot be null');
+    return expect(definition, "BUG: resolved component definitions cannot be null");
   }
   getValue(index) {
-    debugAssert(index >= 0, `cannot get value for handle: ${index}`);
-    return this.values[index];
+    return debugAssert(index >= 0, `cannot get value for handle: ${index}`), this.values[index];
   }
   getArray(index) {
-    let reifiedArrs = this.reifiedArrs;
-    let reified = reifiedArrs[index];
-    if (reified === undefined) {
+    let reifiedArrs = this.reifiedArrs,
+      reified = reifiedArrs[index];
+    if (void 0 === reified) {
       let names = this.getValue(index);
       reified = new Array(names.length);
-      for (const [i, name] of enumerate(names)) {
-        reified[i] = this.getValue(name);
-      }
+      for (const [i, name] of enumerate(names)) reified[i] = this.getValue(name);
       reifiedArrs[index] = reified;
     }
     return reified;
@@ -208,12 +158,10 @@ class RuntimeOpImpl {
     this.heap = heap;
   }
   get size() {
-    let rawType = this.heap.getbyaddr(this.offset);
-    return ((rawType & OPERAND_LEN_MASK) >> ARG_SHIFT) + 1;
+    return 1 + ((this.heap.getbyaddr(this.offset) & OPERAND_LEN_MASK) >> ARG_SHIFT);
   }
   get isMachine() {
-    let rawType = this.heap.getbyaddr(this.offset);
-    return rawType & MACHINE_MASK ? 1 : 0;
+    return this.heap.getbyaddr(this.offset) & MACHINE_MASK ? 1 : 0;
   }
   get type() {
     return this.heap.getbyaddr(this.offset) & TYPE_MASK;
@@ -228,26 +176,19 @@ class RuntimeOpImpl {
     return this.heap.getbyaddr(this.offset + 3);
   }
 }
-var TableSlotState = /*#__PURE__*/function (TableSlotState) {
-  TableSlotState[TableSlotState["Allocated"] = 0] = "Allocated";
-  TableSlotState[TableSlotState["Freed"] = 1] = "Freed";
-  TableSlotState[TableSlotState["Purged"] = 2] = "Purged";
-  TableSlotState[TableSlotState["Pointer"] = 3] = "Pointer";
-  return TableSlotState;
+var TableSlotState = function (TableSlotState) {
+  return TableSlotState[TableSlotState.Allocated = 0] = "Allocated", TableSlotState[TableSlotState.Freed = 1] = "Freed", TableSlotState[TableSlotState.Purged = 2] = "Purged", TableSlotState[TableSlotState.Pointer = 3] = "Pointer", TableSlotState;
 }(TableSlotState || {});
-const PAGE_SIZE = 0x100000;
 class RuntimeHeapImpl {
   heap;
   table;
   constructor(serializedHeap) {
     let {
-      buffer,
-      table
+      buffer: buffer,
+      table: table
     } = serializedHeap;
-    this.heap = new Int32Array(buffer);
-    this.table = table;
+    this.heap = new Int32Array(buffer), this.table = table;
   }
-
   // It is illegal to close over this address, as compaction
   // may move it. However, it is legal to use this address
   // multiple times between compactions.
@@ -255,10 +196,10 @@ class RuntimeHeapImpl {
     return unwrap(this.table[handle]);
   }
   getbyaddr(address) {
-    return expect(this.heap[address], 'Access memory out of bounds of the heap');
+    return expect(this.heap[address], "Access memory out of bounds of the heap");
   }
   sizeof(handle) {
-    return sizeof(this.table);
+    return this.table, -1;
   }
 }
 function hydrateHeap(serializedHeap) {
@@ -292,13 +233,10 @@ class HeapImpl {
   handleState;
   handle = 0;
   constructor() {
-    this.heap = new Int32Array(PAGE_SIZE);
-    this.handleTable = [];
-    this.handleState = [];
+    this.heap = new Int32Array(1048576), this.handleTable = [], this.handleState = [];
   }
   pushRaw(value) {
-    this.sizeCheck();
-    this.heap[this.offset++] = value;
+    this.sizeCheck(), this.heap[this.offset++] = value;
   }
   pushOp(item) {
     this.pushRaw(item);
@@ -308,12 +246,11 @@ class HeapImpl {
   }
   sizeCheck() {
     let {
-      heap
+      heap: heap
     } = this;
     if (this.offset === this.heap.length) {
-      let newHeap = new Int32Array(heap.length + PAGE_SIZE);
-      newHeap.set(heap, 0);
-      this.heap = newHeap;
+      let newHeap = new Int32Array(heap.length + 1048576);
+      newHeap.set(heap, 0), this.heap = newHeap;
     }
   }
   getbyaddr(address) {
@@ -324,14 +261,12 @@ class HeapImpl {
   }
   malloc() {
     // push offset, info, size
-    this.handleTable.push(this.offset);
-    return this.handleTable.length - 1;
+    return this.handleTable.push(this.offset), this.handleTable.length - 1;
   }
   finishMalloc(handle) {}
   size() {
     return this.offset;
   }
-
   // It is illegal to close over this address, as compaction
   // may move it. However, it is legal to use this address
   // multiple times between compactions.
@@ -339,52 +274,48 @@ class HeapImpl {
     return unwrap(this.handleTable[handle]);
   }
   sizeof(handle) {
-    return sizeof(this.handleTable);
+    return this.handleTable, -1;
   }
   free(handle) {
     this.handleState[handle] = TableSlotState.Freed;
   }
-
   /**
-   * The heap uses the [Mark-Compact Algorithm](https://en.wikipedia.org/wiki/Mark-compact_algorithm) to shift
-   * reachable memory to the bottom of the heap and freeable
-   * memory to the top of the heap. When we have shifted all
-   * the reachable memory to the top of the heap, we move the
-   * offset to the next free position.
-   */
+  * The heap uses the [Mark-Compact Algorithm](https://en.wikipedia.org/wiki/Mark-compact_algorithm) to shift
+  * reachable memory to the bottom of the heap and freeable
+  * memory to the top of the heap. When we have shifted all
+  * the reachable memory to the top of the heap, we move the
+  * offset to the next free position.
+  */
   compact() {
-    let compactedSize = 0;
-    let {
-      handleTable,
-      handleState,
-      heap
-    } = this;
+    let compactedSize = 0,
+      {
+        handleTable: handleTable,
+        handleState: handleState,
+        heap: heap
+      } = this;
     for (let i = 0; i < length; i++) {
-      let offset = unwrap(handleTable[i]);
-      let size = unwrap(handleTable[i + 1]) - unwrap(offset);
-      let state = handleState[i];
-      if (state === TableSlotState.Purged) {
-        continue;
-      } else if (state === TableSlotState.Freed) {
+      let offset = unwrap(handleTable[i]),
+        size = unwrap(handleTable[i + 1]) - unwrap(offset),
+        state = handleState[i];
+      if (state !== TableSlotState.Purged) if (state === TableSlotState.Freed)
         // transition to "already freed" aka "purged"
         // a good improvement would be to reuse
         // these slots
-        handleState[i] = TableSlotState.Purged;
-        compactedSize += size;
-      } else if (state === TableSlotState.Allocated) {
-        for (let j = offset; j <= i + size; j++) {
-          heap[j - compactedSize] = unwrap(heap[j]);
-        }
+        handleState[i] = TableSlotState.Purged, compactedSize += size;else if (state === TableSlotState.Allocated) {
+        for (let j = offset; j <= i + size; j++) heap[j - compactedSize] = unwrap(heap[j]);
         handleTable[i] = offset - compactedSize;
-      } else if (state === TableSlotState.Pointer) {
-        handleTable[i] = offset - compactedSize;
-      }
+      } else state === TableSlotState.Pointer && (handleTable[i] = offset - compactedSize);
     }
     this.offset = this.offset - compactedSize;
   }
   capture(offset = this.offset) {
     // Only called in eager mode
-    let buffer = slice(this.heap, 0, offset).buffer;
+    let buffer = function (arr, start, end) {
+      if (void 0 !== arr.slice) return arr.slice(start, end);
+      let ret = new Int32Array(end);
+      for (; start < end; start++) ret[start] = unwrap(arr[start]);
+      return ret;
+    }(this.heap, 0, offset).buffer;
     return {
       handle: this.handle,
       table: this.handleTable,
@@ -395,28 +326,10 @@ class HeapImpl {
 class RuntimeProgramImpl {
   _opcode;
   constructor(constants, heap) {
-    this.constants = constants;
-    this.heap = heap;
-    this._opcode = new RuntimeOpImpl(this.heap);
+    this.constants = constants, this.heap = heap, this._opcode = new RuntimeOpImpl(this.heap);
   }
   opcode(offset) {
-    this._opcode.offset = offset;
-    return this._opcode;
-  }
-}
-function slice(arr, start, end) {
-  if (arr.slice !== undefined) {
-    return arr.slice(start, end);
-  }
-  let ret = new Int32Array(end);
-  for (; start < end; start++) {
-    ret[start] = unwrap(arr[start]);
-  }
-  return ret;
-}
-function sizeof(table, handle) {
-  {
-    return -1;
+    return this._opcode.offset = offset, this._opcode;
   }
 }
 function artifacts() {