ember-source 6.12.0-beta.3 → 7.0.0-alpha.1

package/dist/prod/packages/shared-chunks/program-B7SJZ5NF.js

@@ -0,0 +1,176 @@
+import { u as unwrap } from './collections-GpG8lT2g.js';
+import { O as OPERAND_LEN_MASK, A as ARG_SHIFT, M as MACHINE_MASK, T as TYPE_MASK } from './flags-B9qxc-pB.js';
+
+class RuntimeOpImpl {
+  offset = 0;
+  constructor(heap) {
+    this.heap = heap;
+  }
+  get size() {
+    let rawType = this.heap.getbyaddr(this.offset);
+    return ((rawType & OPERAND_LEN_MASK) >> ARG_SHIFT) + 1;
+  }
+  get isMachine() {
+    let rawType = this.heap.getbyaddr(this.offset);
+    return rawType & MACHINE_MASK ? 1 : 0;
+  }
+  get type() {
+    return this.heap.getbyaddr(this.offset) & TYPE_MASK;
+  }
+  get op1() {
+    return this.heap.getbyaddr(this.offset + 1);
+  }
+  get op2() {
+    return this.heap.getbyaddr(this.offset + 2);
+  }
+  get op3() {
+    return this.heap.getbyaddr(this.offset + 3);
+  }
+}
+
+const ALLOCATED = 0;
+const FREED = 1;
+const PURGED = 2;
+const POINTER = 3;
+const PAGE_SIZE = 0x100000;
+
+/**
+ * The Program Heap is responsible for dynamically allocating
+ * memory in which we read/write the VM's instructions
+ * from/to. When we malloc we pass out a VMHandle, which
+ * is used as an indirect way of accessing the memory during
+ * execution of the VM. Internally we track the different
+ * regions of the memory in an int array known as the table.
+ *
+ * The table 32-bit aligned and has the following layout:
+ *
+ * | ... | hp (u32) |       info (u32)   | size (u32) |
+ * | ... |  Handle  | Scope Size | State | Size       |
+ * | ... | 32bits   | 30bits     | 2bits | 32bit      |
+ *
+ * With this information we effectively have the ability to
+ * control when we want to free memory. That being said you
+ * can not free during execution as raw address are only
+ * valid during the execution. This means you cannot close
+ * over them as you will have a bad memory access exception.
+ */
+class ProgramHeapImpl {
+  offset = 0;
+  heap;
+  handleTable;
+  handleState;
+  constructor() {
+    this.heap = new Int32Array(PAGE_SIZE);
+    this.handleTable = [];
+    this.handleState = [];
+  }
+  entries() {
+    return this.offset;
+  }
+  pushRaw(value) {
+    this.sizeCheck();
+    this.heap[this.offset++] = value;
+  }
+  pushOp(item) {
+    this.pushRaw(item);
+  }
+  pushMachine(item) {
+    this.pushRaw(item | MACHINE_MASK);
+  }
+  sizeCheck() {
+    let {
+      heap
+    } = this;
+    if (this.offset === this.heap.length) {
+      let newHeap = new Int32Array(heap.length + PAGE_SIZE);
+      newHeap.set(heap, 0);
+      this.heap = newHeap;
+    }
+  }
+  getbyaddr(address) {
+    return unwrap(this.heap[address]);
+  }
+  setbyaddr(address, value) {
+    this.heap[address] = value;
+  }
+  malloc() {
+    // push offset, info, size
+    this.handleTable.push(this.offset);
+    return 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.
+  getaddr(handle) {
+    return unwrap(this.handleTable[handle]);
+  }
+  sizeof(handle) {
+    return sizeof(this.handleTable);
+  }
+  free(handle) {
+    this.handleState[handle] = 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.
+   */
+  compact() {
+    let compactedSize = 0;
+    let {
+      handleTable,
+      handleState,
+      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 === PURGED) {
+        continue;
+      } else if (state === FREED) {
+        // transition to "already freed" aka "purged"
+        // a good improvement would be to reuse
+        // these slots
+        handleState[i] = PURGED;
+        compactedSize += size;
+      } else if (state === ALLOCATED) {
+        for (let j = offset; j <= i + size; j++) {
+          heap[j - compactedSize] = unwrap(heap[j]);
+        }
+        handleTable[i] = offset - compactedSize;
+      } else if (state === POINTER) {
+        handleTable[i] = offset - compactedSize;
+      }
+    }
+    this.offset = this.offset - compactedSize;
+  }
+}
+class ProgramImpl {
+  _opcode;
+  constructor(constants, heap) {
+    this.constants = constants;
+    this.heap = heap;
+    this._opcode = new RuntimeOpImpl(this.heap);
+  }
+  opcode(offset) {
+    this._opcode.offset = offset;
+    return this._opcode;
+  }
+}
+function sizeof(table, handle) {
+  {
+    return -1;
+  }
+}
+
+export { ProgramImpl as P, RuntimeOpImpl as R, ProgramHeapImpl as a };

package/dist/prod/packages/shared-chunks/program-context-C-JdYXRA.js

@@ -0,0 +1,146 @@
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, d as VM_APPEND_HTML_OP, e as VM_APPEND_TEXT_OP, f as VM_RESOLVE_CURRIED_COMPONENT_OP, g as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, h as VM_APPEND_SAFE_HTML_OP, i as VM_APPEND_DOCUMENT_FRAGMENT_OP, j as VM_APPEND_NODE_OP, k as VM_INVOKE_STATIC_OP } from './fragment-EpVz5Xuc.js';
+import { ContentType } from '../@glimmer/vm/index.js';
+import { $ as $s0 } from './registers-ylirb0dq.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-CSVCFS_p.js';
+
+class StdLib {
+  constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {
+    this.main = main;
+    this.trustingGuardedAppend = trustingGuardedAppend;
+    this.cautiousGuardedAppend = cautiousGuardedAppend;
+    this.trustingNonDynamicAppend = trustingNonDynamicAppend;
+    this.cautiousNonDynamicAppend = cautiousNonDynamicAppend;
+  }
+  get 'trusting-append'() {
+    return this.trustingGuardedAppend;
+  }
+  get 'cautious-append'() {
+    return this.cautiousGuardedAppend;
+  }
+  get 'trusting-non-dynamic-append'() {
+    return this.trustingNonDynamicAppend;
+  }
+  get 'cautious-non-dynamic-append'() {
+    return this.cautiousNonDynamicAppend;
+  }
+  getAppend(trusting) {
+    return trusting ? this.trustingGuardedAppend : this.cautiousGuardedAppend;
+  }
+}
+
+function main(op) {
+  op(VM_MAIN_OP, $s0);
+  invokePreparedComponent(op, false, false, true);
+}
+
+/**
+ * Append content to the DOM. This standard function triages content and does the
+ * right thing based upon whether it's a string, safe string, component, fragment
+ * or node.
+ *
+ * @param trusting whether to interpolate a string as raw HTML (corresponds to
+ * triple curlies)
+ */
+function StdAppend(op, trusting, nonDynamicAppend) {
+  SwitchCases(op, () => op(VM_CONTENT_TYPE_OP), when => {
+    when(ContentType.String, () => {
+      if (trusting) {
+        op(VM_ASSERT_SAME_OP);
+        op(VM_APPEND_HTML_OP);
+      } else {
+        op(VM_APPEND_TEXT_OP);
+      }
+    });
+    if (typeof nonDynamicAppend === 'number') {
+      when(ContentType.Component, () => {
+        op(VM_RESOLVE_CURRIED_COMPONENT_OP);
+        op(VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP);
+        InvokeBareComponent(op);
+      });
+      when(ContentType.Helper, () => {
+        CallDynamic(op, null, null, () => {
+          op(VM_INVOKE_STATIC_OP, nonDynamicAppend);
+        });
+      });
+    } else {
+      // when non-dynamic, we can no longer call the value (potentially because we've already called it)
+      // this prevents infinite loops. We instead coerce the value, whatever it is, into the DOM.
+      when(ContentType.Component, () => {
+        op(VM_APPEND_TEXT_OP);
+      });
+      when(ContentType.Helper, () => {
+        op(VM_APPEND_TEXT_OP);
+      });
+    }
+    when(ContentType.SafeString, () => {
+      op(VM_ASSERT_SAME_OP);
+      op(VM_APPEND_SAFE_HTML_OP);
+    });
+    when(ContentType.Fragment, () => {
+      op(VM_ASSERT_SAME_OP);
+      op(VM_APPEND_DOCUMENT_FRAGMENT_OP);
+    });
+    when(ContentType.Node, () => {
+      op(VM_ASSERT_SAME_OP);
+      op(VM_APPEND_NODE_OP);
+    });
+  });
+}
+function compileStd(context) {
+  let mainHandle = build(context, op => main(op));
+  let trustingGuardedNonDynamicAppend = build(context, op => StdAppend(op, true, null));
+  let cautiousGuardedNonDynamicAppend = build(context, op => StdAppend(op, false, null));
+  let trustingGuardedDynamicAppend = build(context, op => StdAppend(op, true, trustingGuardedNonDynamicAppend));
+  let cautiousGuardedDynamicAppend = build(context, op => StdAppend(op, false, cautiousGuardedNonDynamicAppend));
+  return new StdLib(mainHandle, trustingGuardedDynamicAppend, cautiousGuardedDynamicAppend, trustingGuardedNonDynamicAppend, cautiousGuardedNonDynamicAppend);
+}
+const STDLIB_META = {
+  symbols: {
+    locals: null,
+    upvars: null
+  },
+  moduleName: 'stdlib',
+  // TODO: ??
+  scopeValues: null,
+  isStrictMode: true,
+  owner: null,
+  size: 0
+};
+function build(evaluation, builder) {
+  let encoder = new EncoderImpl(evaluation.program.heap, STDLIB_META);
+  function pushOp(...op) {
+    encodeOp(encoder, evaluation, STDLIB_META, op);
+  }
+  builder(pushOp);
+  let result = encoder.commit(0);
+  if (typeof result !== 'number') {
+    // This shouldn't be possible
+    throw new Error(`Unexpected errors compiling std`);
+  } else {
+    return result;
+  }
+}
+
+class EvaluationContextImpl {
+  constants;
+  heap;
+  resolver;
+  stdlib;
+  createOp;
+  env;
+  program;
+  constructor({
+    constants,
+    heap
+  }, createOp, runtime) {
+    this.constants = constants;
+    this.heap = heap;
+    this.resolver = runtime.resolver;
+    this.createOp = createOp;
+    this.env = runtime.env;
+    this.program = runtime.program;
+    this.stdlib = compileStd(this);
+  }
+}
+
+export { EvaluationContextImpl as E, StdLib as S, compileStd as c };

package/dist/prod/packages/shared-chunks/property_set-O080KTKZ.js

@@ -0,0 +1,99 @@
+import './super-Cm_a_cLQ.js';
+import { l as lookupDescriptor } from './lookup-descriptor-CwcVgaLv.js';
+import '../@ember/-internals/environment/index.js';
+import { C as COMPUTED_SETTERS } from './decorator-BdDDBUd2.js';
+import { i as isPath, _ as _getPath } from './observers-R1ZklwWy.js';
+import { n as notifyPropertyChange } from './namespace_search-Aog9nySA.js';
+
+/**
+ @module @ember/object
+*/
+/**
+  Sets the value of a property on an object, respecting computed properties
+  and notifying observers and other listeners of the change.
+  If the specified property is not defined on the object and the object
+  implements the `setUnknownProperty` method, then instead of setting the
+  value of the property on the object, its `setUnknownProperty` handler
+  will be invoked with the two parameters `keyName` and `value`.
+
+  ```javascript
+  import { set } from '@ember/object';
+  set(obj, "name", value);
+  ```
+
+  @method set
+  @static
+  @for @ember/object
+  @param {Object} obj The object to modify.
+  @param {String} keyName The property key to set
+  @param {Object} value The value to set
+  @return {Object} the passed value.
+  @public
+*/
+function set(obj, keyName, value, tolerant) {
+  if (obj.isDestroyed) {
+    return value;
+  }
+  return isPath(keyName) ? _setPath(obj, keyName, value, tolerant) : _setProp(obj, keyName, value);
+}
+function _setProp(obj, keyName, value) {
+  let descriptor = lookupDescriptor(obj, keyName);
+  if (descriptor !== null && COMPUTED_SETTERS.has(descriptor.set)) {
+    obj[keyName] = value;
+    return value;
+  }
+  let currentValue;
+  {
+    currentValue = obj[keyName];
+  }
+  if (currentValue === undefined && 'object' === typeof obj && !(keyName in obj) && typeof obj.setUnknownProperty === 'function') {
+    /* unknown property */
+    obj.setUnknownProperty(keyName, value);
+  } else {
+    {
+      obj[keyName] = value;
+    }
+    if (currentValue !== value) {
+      notifyPropertyChange(obj, keyName);
+    }
+  }
+  return value;
+}
+function _setPath(root, path, value, tolerant) {
+  let parts = path.split('.');
+  let keyName = parts.pop();
+  let newRoot = _getPath(root, parts, true);
+  if (newRoot !== null && newRoot !== undefined) {
+    return set(newRoot, keyName, value);
+  } else if (!tolerant) {
+    throw new Error(`Property set failed: object in path "${parts.join('.')}" could not be found.`);
+  }
+}
+
+/**
+  Error-tolerant form of `set`. Will not blow up if any part of the
+  chain is `undefined`, `null`, or destroyed.
+
+  This is primarily used when syncing bindings, which may try to update after
+  an object has been destroyed.
+
+  ```javascript
+  import { trySet } from '@ember/object';
+
+  let obj = { name: "Zoey" };
+  trySet(obj, "contacts.twitter", "@emberjs");
+  ```
+
+  @method trySet
+  @static
+  @for @ember/object
+  @param {Object} root The object to modify.
+  @param {String} path The property path to set
+  @param {Object} value The value to set
+  @public
+*/
+function trySet(root, path, value) {
+  return set(root, path, value, true);
+}
+
+export { _setProp as _, set as s, trySet as t };

package/dist/prod/packages/shared-chunks/public-api-C3KlJmEr.js

@@ -0,0 +1,10 @@
+import Test from '../ember-testing/lib/test.js';
+import Adapter from '../ember-testing/lib/adapters/adapter.js';
+
+const EmberTesting = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	Adapter,
+	Test
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { EmberTesting as E };

package/dist/prod/packages/shared-chunks/reference-BNqcwZWH.js

@@ -0,0 +1,151 @@
+import { i as isDict, e as expect } from './collections-GpG8lT2g.js';
+import { setProp, getProp } from '../@glimmer/global-context/index.js';
+import { CONSTANT_TAG, INITIAL, validateTag, track, valueForTag, consumeTag } from '../@glimmer/validator/index.js';
+
+const REFERENCE = Symbol('REFERENCE');
+const CONSTANT = 0;
+const COMPUTE = 1;
+const UNBOUND = 2;
+const INVOKABLE = 3;
+
+//////////
+
+class ReferenceImpl {
+  [REFERENCE];
+  tag = null;
+  lastRevision = INITIAL;
+  lastValue;
+  children = null;
+  compute = null;
+  update = null;
+  debugLabel;
+  constructor(type) {
+    this[REFERENCE] = type;
+  }
+}
+function createPrimitiveRef(value) {
+  const ref = new ReferenceImpl(UNBOUND);
+  ref.tag = CONSTANT_TAG;
+  ref.lastValue = value;
+  return ref;
+}
+const UNDEFINED_REFERENCE = createPrimitiveRef(undefined);
+const NULL_REFERENCE = createPrimitiveRef(null);
+const TRUE_REFERENCE = createPrimitiveRef(true);
+const FALSE_REFERENCE = createPrimitiveRef(false);
+function createConstRef(value, debugLabel) {
+  const ref = new ReferenceImpl(CONSTANT);
+  ref.lastValue = value;
+  ref.tag = CONSTANT_TAG;
+  return ref;
+}
+function createUnboundRef(value, debugLabel) {
+  const ref = new ReferenceImpl(UNBOUND);
+  ref.lastValue = value;
+  ref.tag = CONSTANT_TAG;
+  return ref;
+}
+function createComputeRef(compute, update = null, debugLabel = 'unknown') {
+  const ref = new ReferenceImpl(COMPUTE);
+  ref.compute = compute;
+  ref.update = update;
+  return ref;
+}
+function createReadOnlyRef(ref) {
+  if (!isUpdatableRef(ref)) return ref;
+  return createComputeRef(() => valueForRef(ref), null, ref.debugLabel);
+}
+function isInvokableRef(ref) {
+  return ref[REFERENCE] === INVOKABLE;
+}
+function createInvokableRef(inner) {
+  const ref = createComputeRef(() => valueForRef(inner), value => updateRef(inner, value));
+  ref.debugLabel = inner.debugLabel;
+  ref[REFERENCE] = INVOKABLE;
+  return ref;
+}
+function isConstRef(_ref) {
+  const ref = _ref;
+  return ref.tag === CONSTANT_TAG;
+}
+function isUpdatableRef(_ref) {
+  const ref = _ref;
+  return ref.update !== null;
+}
+function valueForRef(_ref) {
+  const ref = _ref;
+  let {
+    tag
+  } = ref;
+  if (tag === CONSTANT_TAG) {
+    return ref.lastValue;
+  }
+  const {
+    lastRevision
+  } = ref;
+  let lastValue;
+  if (tag === null || !validateTag(tag, lastRevision)) {
+    const {
+      compute
+    } = ref;
+    const newTag = track(() => {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+      lastValue = ref.lastValue = compute();
+    });
+    tag = ref.tag = newTag;
+    ref.lastRevision = valueForTag(newTag);
+  } else {
+    lastValue = ref.lastValue;
+  }
+  consumeTag(tag);
+  return lastValue;
+}
+function updateRef(_ref, value) {
+  const ref = _ref;
+  const update = expect(ref.update);
+  update(value);
+}
+function childRefFor(_parentRef, path) {
+  const parentRef = _parentRef;
+  const type = parentRef[REFERENCE];
+  let children = parentRef.children;
+  let child;
+  if (children === null) {
+    children = parentRef.children = new Map();
+  } else {
+    const next = children.get(path);
+    if (next) return next;
+  }
+  if (type === UNBOUND) {
+    const parent = valueForRef(parentRef);
+    if (isDict(parent)) {
+      child = createUnboundRef(parent[path]);
+    } else {
+      child = UNDEFINED_REFERENCE;
+    }
+  } else {
+    child = createComputeRef(() => {
+      const parent = valueForRef(parentRef);
+      if (isDict(parent)) {
+        return getProp(parent, path);
+      }
+    }, val => {
+      const parent = valueForRef(parentRef);
+      if (isDict(parent)) {
+        return setProp(parent, path, val);
+      }
+    });
+  }
+  children.set(path, child);
+  return child;
+}
+function childRefFromParts(root, parts) {
+  let reference = root;
+  for (const part of parts) {
+    reference = childRefFor(reference, part);
+  }
+  return reference;
+}
+let createDebugAliasRef;
+
+export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, createConstRef as a, childRefFor as b, createComputeRef as c, createPrimitiveRef as d, isInvokableRef as e, childRefFromParts as f, createDebugAliasRef as g, createInvokableRef as h, isConstRef as i, createReadOnlyRef as j, createUnboundRef as k, isUpdatableRef as l, updateRef as u, valueForRef as v };

package/dist/prod/packages/shared-chunks/registers-ylirb0dq.js

@@ -0,0 +1,35 @@
+/**
+ * Registers
+ *
+ * For the most part, these follows MIPS naming conventions, however the
+ * register numbers are different.
+ */
+
+// $0 or $pc (program counter): pointer into `program` for the next insturction; -1 means exit
+
+const $pc = 0;
+// $1 or $ra (return address): pointer into `program` for the return
+
+const $ra = 1;
+// $2 or $fp (frame pointer): pointer into the `evalStack` for the base of the stack
+
+const $fp = 2;
+// $3 or $sp (stack pointer): pointer into the `evalStack` for the top of the stack
+
+const $sp = 3;
+// $4-$5 or $s0-$s1 (saved): callee saved general-purpose registers
+
+const $s0 = 4;
+const $s1 = 5;
+// $6-$7 or $t0-$t1 (temporaries): caller saved general-purpose registers
+
+const $t0 = 6;
+const $t1 = 7;
+// $8 or $v0 (return value)
+
+const $v0 = 8;
+function isLowLevelRegister(register) {
+  return register <= $sp;
+}
+
+export { $s0 as $, $pc as a, $ra as b, $fp as c, $sp as d, $v0 as e, $t1 as f, $t0 as g, $s1 as h, isLowLevelRegister as i };