ember-source 7.2.0-alpha.4 → 7.2.0-beta.1

package/dist/dev/packages/shared-chunks/{rsvp-C6j8G1D1.js → rsvp.es-DR7yS7qg.js}

@@ -1,3 +1,11 @@
+/*!
+ * @overview RSVP - a tiny implementation of Promises/A+.
+ * @copyright Copyright (c) 2016 Yehuda Katz, Tom Dale, Stefan Penner and contributors
+ * @license   Licensed under MIT license
+ *            See https://raw.githubusercontent.com/tildeio/rsvp.js/master/LICENSE
+ * @version   4.8.4+ff10049b
+ */
+
 function callbacksFor(object) {
   let callbacks = object._promiseCallbacks;
   if (!callbacks) {
@@ -11,7 +19,7 @@ function callbacksFor(object) {
   @for rsvp
   @public
 */
-const EventTarget = {
+var EventTarget = {
   /**
     `EventTarget.mixin` extends an object with EventTarget methods. For
     Example:
@@ -159,7 +167,6 @@ const EventTarget = {
     }
   }
 };
-
 const config = {
   instrument: false
 };
@@ -171,12 +178,11 @@ function configure(name, value) {
     return config[name];
   }
 }
-
-const queue$1 = [];
-function scheduleFlush$1() {
+const queue = [];
+function scheduleFlush() {
   setTimeout(() => {
-    for (let i = 0; i < queue$1.length; i++) {
-      let entry = queue$1[i];
+    for (let i = 0; i < queue.length; i++) {
+      let entry = queue[i];
       let payload = entry.payload;
       payload.guid = payload.key + payload.id;
       payload.childGuid = payload.key + payload.childId;
@@ -185,11 +191,11 @@ function scheduleFlush$1() {
       }
       config['trigger'](entry.name, entry.payload);
     }
-    queue$1.length = 0;
+    queue.length = 0;
   }, 50);
 }
 function instrument(eventName, promise, child) {
-  if (1 === queue$1.push({
+  if (1 === queue.push({
     name: eventName,
     payload: {
       key: promise._guidKey,
@@ -202,7 +208,7 @@ function instrument(eventName, promise, child) {
       error: config["instrument-with-stack"] ? new Error(promise._label) : null
     }
   })) {
-    scheduleFlush$1();
+    scheduleFlush();
   }
 }
 
@@ -243,7 +249,7 @@ function instrument(eventName, promise, child) {
   @return {Promise} a promise that will become fulfilled with the given
   `value`
 */
-function resolve$2(object, label) {
+function resolve$$1(object, label) {
   /*jshint validthis:true */
   let Constructor = this;
   if (object && typeof object === 'object' && object.constructor === Constructor) {
@@ -253,7 +259,6 @@ function resolve$2(object, label) {
   resolve$1(promise, object);
   return promise;
 }
-
 function withOwnPromise() {
   return new TypeError('A promises callback cannot return that same promise.');
 }
@@ -265,17 +270,36 @@ function noop() {}
 const PENDING = void 0;
 const FULFILLED = 1;
 const REJECTED = 2;
-function tryThen(then, value, fulfillmentHandler, rejectionHandler) {
+const TRY_CATCH_ERROR = {
+  error: null
+};
+function getThen(promise) {
+  try {
+    return promise.then;
+  } catch (error) {
+    TRY_CATCH_ERROR.error = error;
+    return TRY_CATCH_ERROR;
+  }
+}
+let tryCatchCallback;
+function tryCatcher() {
   try {
-    then.call(value, fulfillmentHandler, rejectionHandler);
+    let target = tryCatchCallback;
+    tryCatchCallback = null;
+    return target.apply(this, arguments);
   } catch (e) {
-    return e;
+    TRY_CATCH_ERROR.error = e;
+    return TRY_CATCH_ERROR;
   }
 }
-function handleForeignThenable(promise, thenable, then) {
+function tryCatch(fn) {
+  tryCatchCallback = fn;
+  return tryCatcher;
+}
+function handleForeignThenable(promise, thenable, then$$1) {
   config.async(promise => {
     let sealed = false;
-    let error = tryThen(then, thenable, value => {
+    let result = tryCatch(then$$1).call(thenable, value => {
       if (sealed) {
         return;
       }
@@ -290,11 +314,13 @@ function handleForeignThenable(promise, thenable, then) {
         return;
       }
       sealed = true;
-      reject$2(promise, reason);
+      reject(promise, reason);
     }, 'Settle: ' + (promise._label || ' unknown promise'));
-    if (!sealed && error) {
+    if (!sealed && result === TRY_CATCH_ERROR) {
       sealed = true;
-      reject$2(promise, error);
+      let error = TRY_CATCH_ERROR.error;
+      TRY_CATCH_ERROR.error = null;
+      reject(promise, error);
     }
   }, promise);
 }
@@ -303,7 +329,7 @@ function handleOwnThenable(promise, thenable) {
     fulfill(promise, thenable._result);
   } else if (thenable._state === REJECTED) {
     thenable._onError = null;
-    reject$2(promise, thenable._result);
+    reject(promise, thenable._result);
   } else {
     subscribe(thenable, undefined, value => {
       if (thenable === value) {
@@ -311,15 +337,19 @@ function handleOwnThenable(promise, thenable) {
       } else {
         resolve$1(promise, value);
       }
-    }, reason => reject$2(promise, reason));
+    }, reason => reject(promise, reason));
   }
 }
-function handleMaybeThenable(promise, maybeThenable, then$1) {
-  let isOwnThenable = maybeThenable.constructor === promise.constructor && then$1 === then && promise.constructor.resolve === resolve$2;
+function handleMaybeThenable(promise, maybeThenable, then$$1) {
+  let isOwnThenable = maybeThenable.constructor === promise.constructor && then$$1 === then && promise.constructor.resolve === resolve$$1;
   if (isOwnThenable) {
     handleOwnThenable(promise, maybeThenable);
-  } else if (typeof then$1 === 'function') {
-    handleForeignThenable(promise, maybeThenable, then$1);
+  } else if (then$$1 === TRY_CATCH_ERROR) {
+    let error = TRY_CATCH_ERROR.error;
+    TRY_CATCH_ERROR.error = null;
+    reject(promise, error);
+  } else if (typeof then$$1 === 'function') {
+    handleForeignThenable(promise, maybeThenable, then$$1);
   } else {
     fulfill(promise, maybeThenable);
   }
@@ -328,14 +358,7 @@ function resolve$1(promise, value) {
   if (promise === value) {
     fulfill(promise, value);
   } else if (objectOrFunction(value)) {
-    let then;
-    try {
-      then = value.then;
-    } catch (error) {
-      reject$2(promise, error);
-      return;
-    }
-    handleMaybeThenable(promise, value, then);
+    handleMaybeThenable(promise, value, getThen(value));
   } else {
     fulfill(promise, value);
   }
@@ -360,7 +383,7 @@ function fulfill(promise, value) {
     config.async(publish, promise);
   }
 }
-function reject$2(promise, reason) {
+function reject(promise, reason) {
   if (promise._state !== PENDING) {
     return;
   }
@@ -404,29 +427,24 @@ function publish(promise) {
 }
 function invokeCallback(state, promise, callback, result) {
   let hasCallback = typeof callback === 'function';
-  let value,
-    succeeded = true,
-    error;
+  let value;
   if (hasCallback) {
-    try {
-      value = callback(result);
-    } catch (e) {
-      succeeded = false;
-      error = e;
-    }
+    value = tryCatch(callback)(result);
   } else {
     value = result;
   }
   if (promise._state !== PENDING) ; else if (value === promise) {
-    reject$2(promise, withOwnPromise());
-  } else if (succeeded === false) {
-    reject$2(promise, error);
+    reject(promise, withOwnPromise());
+  } else if (value === TRY_CATCH_ERROR) {
+    let error = TRY_CATCH_ERROR.error;
+    TRY_CATCH_ERROR.error = null; // release
+    reject(promise, error);
   } else if (hasCallback) {
     resolve$1(promise, value);
   } else if (state === FULFILLED) {
     fulfill(promise, value);
   } else if (state === REJECTED) {
-    reject$2(promise, value);
+    reject(promise, value);
   }
 }
 function initializePromise(promise, resolver) {
@@ -443,13 +461,12 @@ function initializePromise(promise, resolver) {
         return;
       }
       resolved = true;
-      reject$2(promise, reason);
+      reject(promise, reason);
     });
   } catch (e) {
-    reject$2(promise, e);
+    reject(promise, e);
   }
 }
-
 function then(onFulfillment, onRejection, label) {
   let parent = this;
   let state = parent._state;
@@ -469,14 +486,13 @@ function then(onFulfillment, onRejection, label) {
   }
   return child;
 }
-
 class Enumerator {
   constructor(Constructor, input, abortOnReject, label) {
     this._instanceConstructor = Constructor;
     this.promise = new Constructor(noop, label);
     this._abortOnReject = abortOnReject;
     this._isUsingOwnPromise = Constructor === Promise$1;
-    this._isUsingOwnResolve = Constructor.resolve === resolve$2;
+    this._isUsingOwnResolve = Constructor.resolve === resolve$$1;
     this._init(...arguments);
   }
   _init(Constructor, input) {
@@ -504,28 +520,16 @@ class Enumerator {
   _settleMaybeThenable(entry, i, firstPass) {
     let c = this._instanceConstructor;
     if (this._isUsingOwnResolve) {
-      let then$1,
-        error,
-        succeeded = true;
-      try {
-        then$1 = entry.then;
-      } catch (e) {
-        succeeded = false;
-        error = e;
-      }
-      if (then$1 === then && entry._state !== PENDING) {
+      let then$$1 = getThen(entry);
+      if (then$$1 === then && entry._state !== PENDING) {
         entry._onError = null;
         this._settledAt(entry._state, i, entry._result, firstPass);
-      } else if (typeof then$1 !== 'function') {
+      } else if (typeof then$$1 !== 'function') {
         this._settledAt(FULFILLED, i, entry, firstPass);
       } else if (this._isUsingOwnPromise) {
         let promise = new c(noop);
-        if (succeeded === false) {
-          reject$2(promise, error);
-        } else {
-          handleMaybeThenable(promise, entry, then$1);
-          this._willSettleAt(promise, i, firstPass);
-        }
+        handleMaybeThenable(promise, entry, then$$1);
+        this._willSettleAt(promise, i, firstPass);
       } else {
         this._willSettleAt(new c(resolve => resolve(entry)), i, firstPass);
       }
@@ -544,7 +548,7 @@ class Enumerator {
     let promise = this.promise;
     if (promise._state === PENDING) {
       if (this._abortOnReject && state === REJECTED) {
-        reject$2(promise, value);
+        reject(promise, value);
       } else {
         this._setResultAt(state, i, value, firstPass);
         this._checkFullfillment();
@@ -625,7 +629,7 @@ function setSettledResult(state, i, value) {
   fulfilled, or rejected if any of them become rejected.
   @static
 */
-function all$1(entries, label) {
+function all(entries, label) {
   if (!Array.isArray(entries)) {
     return this.reject(new TypeError("Promise.all must be called with an array"), label);
   }
@@ -705,16 +709,16 @@ function all$1(entries, label) {
   @return {Promise} a promise which settles in the same way as the first passed
   promise to settle.
 */
-function race$1(entries, label) {
+function race(entries, label) {
   /*jshint validthis:true */
   let Constructor = this;
   let promise = new Constructor(noop, label);
   if (!Array.isArray(entries)) {
-    reject$2(promise, new TypeError('Promise.race must be called with an array'));
+    reject(promise, new TypeError('Promise.race must be called with an array'));
     return promise;
   }
   for (let i = 0; promise._state === PENDING && i < entries.length; i++) {
-    subscribe(Constructor.resolve(entries[i]), undefined, value => resolve$1(promise, value), reason => reject$2(promise, reason));
+    subscribe(Constructor.resolve(entries[i]), undefined, value => resolve$1(promise, value), reason => reject(promise, reason));
   }
   return promise;
 }
@@ -763,10 +767,9 @@ function reject$1(reason, label) {
   /*jshint validthis:true */
   let Constructor = this;
   let promise = new Constructor(noop, label);
-  reject$2(promise, reason);
+  reject(promise, reason);
   return promise;
 }
-
 const guidKey = 'rsvp_' + Date.now() + '-';
 let counter = 0;
 function needsResolver() {
@@ -985,10 +988,10 @@ let Promise$1 = class Promise {
     return promise.then(callback, callback);
   }
 };
-Promise$1.cast = resolve$2; // deprecated
-Promise$1.all = all$1;
-Promise$1.race = race$1;
-Promise$1.resolve = resolve$2;
+Promise$1.cast = resolve$$1; // deprecated
+Promise$1.all = all;
+Promise$1.race = race;
+Promise$1.resolve = resolve$$1;
 Promise$1.reject = reject$1;
 Promise$1.prototype._guidKey = guidKey;
 
@@ -1187,7 +1190,6 @@ Promise$1.prototype._guidKey = guidKey;
   @return {Promise}
 */
 Promise$1.prototype.then = then;
-
 function makeObject(_, argumentNames) {
   let obj = {};
   let length = _.length;
@@ -1351,25 +1353,16 @@ function denodeify(nodeFunc, options) {
     let promiseInput = false;
     for (let i = 0; i < l; ++i) {
       let arg = arguments[i];
-
-      // TODO: this code really needs to be cleaned up
       if (!promiseInput) {
-        if (arg !== null && typeof arg === 'object') {
-          if (arg.constructor === Promise$1) {
-            promiseInput = true;
-          } else {
-            try {
-              promiseInput = arg.then;
-            } catch (error) {
-              let p = new Promise$1(noop);
-              reject$2(p, error);
-              return p;
-            }
-          }
-        } else {
-          promiseInput = false;
-        }
-        if (promiseInput && promiseInput !== true) {
+        // TODO: clean this up
+        promiseInput = needsPromiseInput(arg);
+        if (promiseInput === TRY_CATCH_ERROR) {
+          let error = TRY_CATCH_ERROR.error;
+          TRY_CATCH_ERROR.error = null;
+          let p = new Promise$1(noop);
+          reject(p, error);
+          return p;
+        } else if (promiseInput && promiseInput !== true) {
           arg = wrapThenable(promiseInput, arg);
         }
       }
@@ -1378,7 +1371,7 @@ function denodeify(nodeFunc, options) {
     let promise = new Promise$1(noop);
     args[l] = function (err, val) {
       if (err) {
-        reject$2(promise, err);
+        reject(promise, err);
       } else if (options === undefined) {
         resolve$1(promise, val);
       } else if (options === true) {
@@ -1399,16 +1392,28 @@ function denodeify(nodeFunc, options) {
   return fn;
 }
 function handleValueInput(promise, args, nodeFunc, self) {
-  try {
-    nodeFunc.apply(self, args);
-  } catch (error) {
-    reject$2(promise, error);
+  let result = tryCatch(nodeFunc).apply(self, args);
+  if (result === TRY_CATCH_ERROR) {
+    let error = TRY_CATCH_ERROR.error;
+    TRY_CATCH_ERROR.error = null;
+    reject(promise, error);
   }
   return promise;
 }
 function handlePromiseInput(promise, args, nodeFunc, self) {
   return Promise$1.all(args).then(args => handleValueInput(promise, args, nodeFunc, self));
 }
+function needsPromiseInput(arg) {
+  if (arg !== null && typeof arg === 'object') {
+    if (arg.constructor === Promise$1) {
+      return true;
+    } else {
+      return getThen(arg);
+    }
+  } else {
+    return false;
+  }
+}
 
 /**
   This is a convenient alias for `Promise.all`.
@@ -1421,7 +1426,7 @@ function handlePromiseInput(promise, args, nodeFunc, self) {
   @param {String} [label] An optional label. This is useful
   for tooling.
 */
-function all(array, label) {
+function all$1(array, label) {
   return Promise$1.all(array, label);
 }
 
@@ -1501,10 +1506,9 @@ function allSettled(entries, label) {
   @param {String} [label] An optional label. This is useful
   for tooling.
  */
-function race(array, label) {
+function race$1(array, label) {
   return Promise$1.race(array, label);
 }
-
 class PromiseHash extends Enumerator {
   constructor(Constructor, object, abortOnReject = true, label) {
     super(Constructor, object, abortOnReject, label);
@@ -1626,7 +1630,6 @@ function hash(object, label) {
     return new PromiseHash(Promise$1, object, label).promise;
   });
 }
-
 class HashSettled extends PromiseHash {
   constructor(Constructor, object, label) {
     super(Constructor, object, false, label);
@@ -1847,7 +1850,6 @@ function defer(label) {
   }, label);
   return deferred;
 }
-
 class MapEnumerator extends Enumerator {
   constructor(Constructor, entries, mapFn, label) {
     super(Constructor, entries, true, label, mapFn);
@@ -1862,10 +1864,11 @@ class MapEnumerator extends Enumerator {
   }
   _setResultAt(state, i, value, firstPass) {
     if (firstPass) {
-      try {
-        this._eachEntry(this._mapFn(value, i), i, false);
-      } catch (error) {
-        this._settledAt(REJECTED, i, error, false);
+      let val = tryCatch(this._mapFn)(value, i);
+      if (val === TRY_CATCH_ERROR) {
+        this._settledAt(REJECTED, i, val.error, false);
+      } else {
+        this._eachEntry(val, i, false);
       }
     } else {
       this._remaining--;
@@ -1980,7 +1983,7 @@ function map(promises, mapFn, label) {
   @return {Promise} a promise that will become fulfilled with the given
   `value`
 */
-function resolve(value, label) {
+function resolve$2(value, label) {
   return Promise$1.resolve(value, label);
 }
 
@@ -1996,10 +1999,9 @@ function resolve(value, label) {
   Useful for tooling.
   @return {Promise} a promise rejected with the given `reason`.
 */
-function reject(reason, label) {
+function reject$2(reason, label) {
   return Promise$1.reject(reason, label);
 }
-
 const EMPTY_OBJECT = {};
 class FilterEnumerator extends MapEnumerator {
   _checkFullfillment() {
@@ -2012,15 +2014,10 @@ class FilterEnumerator extends MapEnumerator {
   _setResultAt(state, i, value, firstPass) {
     if (firstPass) {
       this._result[i] = value;
-      let val,
-        succeeded = true;
-      try {
-        val = this._mapFn(value, i);
-      } catch (error) {
-        succeeded = false;
-        this._settledAt(REJECTED, i, error, false);
-      }
-      if (succeeded) {
+      let val = tryCatch(this._mapFn)(value, i);
+      if (val === TRY_CATCH_ERROR) {
+        this._settledAt(REJECTED, i, val.error, false);
+      } else {
         this._eachEntry(val, i, false);
       }
     } else {
@@ -2134,18 +2131,17 @@ function filter(promises, filterFn, label) {
     return new FilterEnumerator(Promise$1, promises, filterFn, label).promise;
   });
 }
-
 let len = 0;
 let vertxNext;
 function asap(callback, arg) {
-  queue[len] = callback;
-  queue[len + 1] = arg;
+  queue$1[len] = callback;
+  queue$1[len + 1] = arg;
   len += 2;
   if (len === 2) {
     // If len is 1, that means that we need to schedule an async flush.
     // If additional callbacks are queued before the queue is flushed, they
     // will be processed by this flush that we are scheduling.
-    scheduleFlush();
+    scheduleFlush$1();
   }
 }
 const browserWindow = typeof window !== 'undefined' ? window : undefined;
@@ -2196,14 +2192,14 @@ function useMessageChannel() {
 function useSetTimeout() {
   return () => setTimeout(flush, 1);
 }
-const queue = new Array(1000);
+const queue$1 = new Array(1000);
 function flush() {
   for (let i = 0; i < len; i += 2) {
-    let callback = queue[i];
-    let arg = queue[i + 1];
+    let callback = queue$1[i];
+    let arg = queue$1[i + 1];
     callback(arg);
-    queue[i] = undefined;
-    queue[i + 1] = undefined;
+    queue$1[i] = undefined;
+    queue$1[i + 1] = undefined;
   }
   len = 0;
 }
@@ -2216,24 +2212,24 @@ function attemptVertex() {
     return useSetTimeout();
   }
 }
-let scheduleFlush;
+let scheduleFlush$1;
 // Decide what async method to use to triggering processing of queued callbacks:
 if (isNode) {
-  scheduleFlush = useNextTick();
+  scheduleFlush$1 = useNextTick();
 } else if (BrowserMutationObserver) {
-  scheduleFlush = useMutationObserver();
+  scheduleFlush$1 = useMutationObserver();
 } else if (isWorker) {
-  scheduleFlush = useMessageChannel();
+  scheduleFlush$1 = useMessageChannel();
 } else if (browserWindow === undefined && typeof require === 'function') {
-  scheduleFlush = attemptVertex();
+  scheduleFlush$1 = attemptVertex();
 } else {
-  scheduleFlush = useSetTimeout();
+  scheduleFlush$1 = useSetTimeout();
 }
 
 // defaults
 config.async = asap;
 config.after = cb => setTimeout(cb, 0);
-const cast = resolve;
+const cast = resolve$2;
 const async = (callback, arg) => config.async(callback, arg);
 function on() {
   config.on(...arguments);
@@ -2255,14 +2251,14 @@ if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'
 
 // the default export here is for backwards compat:
 //   https://github.com/tildeio/rsvp.js/issues/434
-const RSVP = {
+var rsvp = {
   asap,
   cast,
   Promise: Promise$1,
   EventTarget,
-  all,
+  all: all$1,
   allSettled,
-  race,
+  race: race$1,
   hash,
   hashSettled,
   rethrow,
@@ -2271,24 +2267,24 @@ const RSVP = {
   configure,
   on,
   off,
-  resolve,
-  reject,
+  resolve: resolve$2,
+  reject: reject$2,
   map,
   async,
   filter
 };
 
-const RSVP$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+const RSVP = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   __proto__: null,
   EventTarget,
   Promise: Promise$1,
-  all,
+  all: all$1,
   allSettled,
   asap,
   async,
   cast,
   configure,
-  default: RSVP,
+  default: rsvp,
   defer,
   denodeify,
   filter,
@@ -2297,10 +2293,10 @@ const RSVP$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   map,
   off,
   on,
-  race,
-  reject,
-  resolve,
+  race: race$1,
+  reject: reject$2,
+  resolve: resolve$2,
   rethrow
 }, Symbol.toStringTag, { value: 'Module' }));
 
-export { EventTarget as E, Promise$1 as P, RSVP$1 as R, RSVP as a, all as b, allSettled as c, asap as d, async as e, cast as f, configure as g, defer as h, denodeify as i, filter as j, hash as k, hashSettled as l, map as m, on as n, off as o, reject as p, resolve as q, race as r, rethrow as s };
+export { Promise$1 as P, RSVP as R, configure as c, on as o };

package/dist/dev/packages/shared-chunks/{serialize-builder-DKliZPPG.js → serialize-builder-BlxBjwO-.js}

@@ -1,5 +1,5 @@
-import { C as ConcreteBounds } from './normalize-CxG_iVLJ.js';
-import { c as NewTreeBuilder } from './element-builder-Cl1kHFJE.js';
+import { C as ConcreteBounds } from './normalize-CKySQVU7.js';
+import { N as NewTreeBuilder } from './api-C0PAtEgQ.js';
 
 /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
 

package/dist/dev/packages/shared-chunks/{set_properties-CNds2HCH.js → set_properties-C4TSebH6.js}

@@ -1,5 +1,5 @@
-import { c as changeProperties } from './computed-Daavz6vC.js';
-import { s as set } from './property_set-LJskl202.js';
+import { f as changeProperties } from './computed-BPCtuOxQ.js';
+import { s as set } from './property_set-qCUylPEK.js';
 
 /**
  @module @ember/object