@ember-data/legacy-compat 4.12.0-alpha.9

package/addon/index.js

@@ -0,0 +1,1797 @@
+import { macroCondition, isDevelopingApp, getOwnConfig } from '@embroider/macros';
+import { deprecate, assert } from '@ember/debug';
+import { S as SnapshotRecordArray } from "./snapshot-record-array-a4efeb60";
+
+/*!
+ * @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) {
+  var callbacks = object._promiseCallbacks;
+  if (!callbacks) {
+    callbacks = object._promiseCallbacks = {};
+  }
+  return callbacks;
+}
+
+/**
+  @class EventTarget
+  @for rsvp
+  @public
+*/
+var EventTarget = {
+  /**
+    `EventTarget.mixin` extends an object with EventTarget methods. For
+    Example:
+     ```javascript
+    import EventTarget from 'rsvp';
+     let object = {};
+     EventTarget.mixin(object);
+     object.on('finished', function(event) {
+      // handle event
+    });
+     object.trigger('finished', { detail: value });
+    ```
+     `EventTarget.mixin` also works with prototypes:
+     ```javascript
+    import EventTarget from 'rsvp';
+     let Person = function() {};
+    EventTarget.mixin(Person.prototype);
+     let yehuda = new Person();
+    let tom = new Person();
+     yehuda.on('poke', function(event) {
+      console.log('Yehuda says OW');
+    });
+     tom.on('poke', function(event) {
+      console.log('Tom says OW');
+    });
+     yehuda.trigger('poke');
+    tom.trigger('poke');
+    ```
+     @method mixin
+    @for rsvp
+    @private
+    @param {Object} object object to extend with EventTarget methods
+  */
+  mixin: function (object) {
+    object.on = this.on;
+    object.off = this.off;
+    object.trigger = this.trigger;
+    object._promiseCallbacks = undefined;
+    return object;
+  },
+  /**
+    Registers a callback to be executed when `eventName` is triggered
+     ```javascript
+    object.on('event', function(eventInfo){
+      // handle the event
+    });
+     object.trigger('event');
+    ```
+     @method on
+    @for EventTarget
+    @private
+    @param {String} eventName name of the event to listen for
+    @param {Function} callback function to be called when the event is triggered.
+  */
+  on: function (eventName, callback) {
+    if (typeof callback !== 'function') {
+      throw new TypeError('Callback must be a function');
+    }
+    var allCallbacks = callbacksFor(this);
+    var callbacks = allCallbacks[eventName];
+    if (!callbacks) {
+      callbacks = allCallbacks[eventName] = [];
+    }
+    if (callbacks.indexOf(callback) === -1) {
+      callbacks.push(callback);
+    }
+  },
+  /**
+    You can use `off` to stop firing a particular callback for an event:
+     ```javascript
+    function doStuff() { // do stuff! }
+    object.on('stuff', doStuff);
+     object.trigger('stuff'); // doStuff will be called
+     // Unregister ONLY the doStuff callback
+    object.off('stuff', doStuff);
+    object.trigger('stuff'); // doStuff will NOT be called
+    ```
+     If you don't pass a `callback` argument to `off`, ALL callbacks for the
+    event will not be executed when the event fires. For example:
+     ```javascript
+    let callback1 = function(){};
+    let callback2 = function(){};
+     object.on('stuff', callback1);
+    object.on('stuff', callback2);
+     object.trigger('stuff'); // callback1 and callback2 will be executed.
+     object.off('stuff');
+    object.trigger('stuff'); // callback1 and callback2 will not be executed!
+    ```
+     @method off
+    @for rsvp
+    @private
+    @param {String} eventName event to stop listening to
+    @param {Function} [callback] optional argument. If given, only the function
+    given will be removed from the event's callback queue. If no `callback`
+    argument is given, all callbacks will be removed from the event's callback
+    queue.
+  */
+  off: function (eventName, callback) {
+    var allCallbacks = callbacksFor(this);
+    if (!callback) {
+      allCallbacks[eventName] = [];
+      return;
+    }
+    var callbacks = allCallbacks[eventName];
+    var index = callbacks.indexOf(callback);
+    if (index !== -1) {
+      callbacks.splice(index, 1);
+    }
+  },
+  /**
+    Use `trigger` to fire custom events. For example:
+     ```javascript
+    object.on('foo', function(){
+      console.log('foo event happened!');
+    });
+    object.trigger('foo');
+    // 'foo event happened!' logged to the console
+    ```
+     You can also pass a value as a second argument to `trigger` that will be
+    passed as an argument to all event listeners for the event:
+     ```javascript
+    object.on('foo', function(value){
+      console.log(value.name);
+    });
+     object.trigger('foo', { name: 'bar' });
+    // 'bar' logged to the console
+    ```
+     @method trigger
+    @for rsvp
+    @private
+    @param {String} eventName name of the event to be triggered
+    @param {*} [options] optional value to be passed to any event handlers for
+    the given `eventName`
+  */
+  trigger: function (eventName, options, label) {
+    var allCallbacks = callbacksFor(this);
+    var callbacks = allCallbacks[eventName];
+    if (callbacks) {
+      // Don't cache the callbacks.length since it may grow
+      var callback = void 0;
+      for (var i = 0; i < callbacks.length; i++) {
+        callback = callbacks[i];
+        callback(options, label);
+      }
+    }
+  }
+};
+var config = {
+  instrument: false
+};
+EventTarget['mixin'](config);
+function configure(name, value) {
+  if (arguments.length === 2) {
+    config[name] = value;
+  } else {
+    return config[name];
+  }
+}
+var queue = [];
+function scheduleFlush() {
+  setTimeout(function () {
+    for (var i = 0; i < queue.length; i++) {
+      var entry = queue[i];
+      var payload = entry.payload;
+      payload.guid = payload.key + payload.id;
+      payload.childGuid = payload.key + payload.childId;
+      if (payload.error) {
+        payload.stack = payload.error.stack;
+      }
+      config['trigger'](entry.name, entry.payload);
+    }
+    queue.length = 0;
+  }, 50);
+}
+function instrument(eventName, promise, child) {
+  if (1 === queue.push({
+    name: eventName,
+    payload: {
+      key: promise._guidKey,
+      id: promise._id,
+      eventName: eventName,
+      detail: promise._result,
+      childId: child && child._id,
+      label: promise._label,
+      timeStamp: Date.now(),
+      error: config["instrument-with-stack"] ? new Error(promise._label) : null
+    }
+  })) {
+    scheduleFlush();
+  }
+}
+
+/**
+  `Promise.resolve` returns a promise that will become resolved with the
+  passed `value`. It is shorthand for the following:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  let promise = new Promise(function(resolve, reject){
+    resolve(1);
+  });
+
+  promise.then(function(value){
+    // value === 1
+  });
+  ```
+
+  Instead of writing the above, your code now simply becomes the following:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  let promise = RSVP.Promise.resolve(1);
+
+  promise.then(function(value){
+    // value === 1
+  });
+  ```
+
+  @method resolve
+  @for Promise
+  @static
+  @param {*} object value that the returned promise will be resolved with
+  @param {String} [label] optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise that will become fulfilled with the given
+  `value`
+*/
+function resolve$$1(object, label) {
+  /*jshint validthis:true */
+  var Constructor = this;
+  if (object && typeof object === 'object' && object.constructor === Constructor) {
+    return object;
+  }
+  var promise = new Constructor(noop, label);
+  resolve$1(promise, object);
+  return promise;
+}
+function withOwnPromise() {
+  return new TypeError('A promises callback cannot return that same promise.');
+}
+function objectOrFunction(x) {
+  var type = typeof x;
+  return x !== null && (type === 'object' || type === 'function');
+}
+function noop() {}
+var PENDING = void 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+var TRY_CATCH_ERROR = {
+  error: null
+};
+function getThen(promise) {
+  try {
+    return promise.then;
+  } catch (error) {
+    TRY_CATCH_ERROR.error = error;
+    return TRY_CATCH_ERROR;
+  }
+}
+var tryCatchCallback = void 0;
+function tryCatcher() {
+  try {
+    var target = tryCatchCallback;
+    tryCatchCallback = null;
+    return target.apply(this, arguments);
+  } catch (e) {
+    TRY_CATCH_ERROR.error = e;
+    return TRY_CATCH_ERROR;
+  }
+}
+function tryCatch(fn) {
+  tryCatchCallback = fn;
+  return tryCatcher;
+}
+function handleForeignThenable(promise, thenable, then$$1) {
+  config.async(function (promise) {
+    var sealed = false;
+    var result = tryCatch(then$$1).call(thenable, function (value) {
+      if (sealed) {
+        return;
+      }
+      sealed = true;
+      if (thenable === value) {
+        fulfill(promise, value);
+      } else {
+        resolve$1(promise, value);
+      }
+    }, function (reason) {
+      if (sealed) {
+        return;
+      }
+      sealed = true;
+      reject(promise, reason);
+    }, 'Settle: ' + (promise._label || ' unknown promise'));
+    if (!sealed && result === TRY_CATCH_ERROR) {
+      sealed = true;
+      var error = TRY_CATCH_ERROR.error;
+      TRY_CATCH_ERROR.error = null;
+      reject(promise, error);
+    }
+  }, promise);
+}
+function handleOwnThenable(promise, thenable) {
+  if (thenable._state === FULFILLED) {
+    fulfill(promise, thenable._result);
+  } else if (thenable._state === REJECTED) {
+    thenable._onError = null;
+    reject(promise, thenable._result);
+  } else {
+    subscribe(thenable, undefined, function (value) {
+      if (thenable === value) {
+        fulfill(promise, value);
+      } else {
+        resolve$1(promise, value);
+      }
+    }, function (reason) {
+      return reject(promise, reason);
+    });
+  }
+}
+function handleMaybeThenable(promise, maybeThenable, then$$1) {
+  var isOwnThenable = maybeThenable.constructor === promise.constructor && then$$1 === then && promise.constructor.resolve === resolve$$1;
+  if (isOwnThenable) {
+    handleOwnThenable(promise, maybeThenable);
+  } else if (then$$1 === TRY_CATCH_ERROR) {
+    var 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);
+  }
+}
+function resolve$1(promise, value) {
+  if (promise === value) {
+    fulfill(promise, value);
+  } else if (objectOrFunction(value)) {
+    handleMaybeThenable(promise, value, getThen(value));
+  } else {
+    fulfill(promise, value);
+  }
+}
+function publishRejection(promise) {
+  if (promise._onError) {
+    promise._onError(promise._result);
+  }
+  publish(promise);
+}
+function fulfill(promise, value) {
+  if (promise._state !== PENDING) {
+    return;
+  }
+  promise._result = value;
+  promise._state = FULFILLED;
+  if (promise._subscribers.length === 0) {
+    if (config.instrument) {
+      instrument('fulfilled', promise);
+    }
+  } else {
+    config.async(publish, promise);
+  }
+}
+function reject(promise, reason) {
+  if (promise._state !== PENDING) {
+    return;
+  }
+  promise._state = REJECTED;
+  promise._result = reason;
+  config.async(publishRejection, promise);
+}
+function subscribe(parent, child, onFulfillment, onRejection) {
+  var subscribers = parent._subscribers;
+  var length = subscribers.length;
+  parent._onError = null;
+  subscribers[length] = child;
+  subscribers[length + FULFILLED] = onFulfillment;
+  subscribers[length + REJECTED] = onRejection;
+  if (length === 0 && parent._state) {
+    config.async(publish, parent);
+  }
+}
+function publish(promise) {
+  var subscribers = promise._subscribers;
+  var settled = promise._state;
+  if (config.instrument) {
+    instrument(settled === FULFILLED ? 'fulfilled' : 'rejected', promise);
+  }
+  if (subscribers.length === 0) {
+    return;
+  }
+  var child = void 0,
+    callback = void 0,
+    result = promise._result;
+  for (var i = 0; i < subscribers.length; i += 3) {
+    child = subscribers[i];
+    callback = subscribers[i + settled];
+    if (child) {
+      invokeCallback(settled, child, callback, result);
+    } else {
+      callback(result);
+    }
+  }
+  promise._subscribers.length = 0;
+}
+function invokeCallback(state, promise, callback, result) {
+  var hasCallback = typeof callback === 'function';
+  var value = void 0;
+  if (hasCallback) {
+    value = tryCatch(callback)(result);
+  } else {
+    value = result;
+  }
+  if (promise._state !== PENDING) ;else if (value === promise) {
+    reject(promise, withOwnPromise());
+  } else if (value === TRY_CATCH_ERROR) {
+    var 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(promise, value);
+  }
+}
+function initializePromise(promise, resolver) {
+  var resolved = false;
+  try {
+    resolver(function (value) {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      resolve$1(promise, value);
+    }, function (reason) {
+      if (resolved) {
+        return;
+      }
+      resolved = true;
+      reject(promise, reason);
+    });
+  } catch (e) {
+    reject(promise, e);
+  }
+}
+function then(onFulfillment, onRejection, label) {
+  var parent = this;
+  var state = parent._state;
+  if (state === FULFILLED && !onFulfillment || state === REJECTED && !onRejection) {
+    config.instrument && instrument('chained', parent, parent);
+    return parent;
+  }
+  parent._onError = null;
+  var child = new parent.constructor(noop, label);
+  var result = parent._result;
+  config.instrument && instrument('chained', parent, child);
+  if (state === PENDING) {
+    subscribe(parent, child, onFulfillment, onRejection);
+  } else {
+    var callback = state === FULFILLED ? onFulfillment : onRejection;
+    config.async(function () {
+      return invokeCallback(state, child, callback, result);
+    });
+  }
+  return child;
+}
+var Enumerator = function () {
+  function Enumerator(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$$1;
+    this._init.apply(this, arguments);
+  }
+  Enumerator.prototype._init = function _init(Constructor, input) {
+    var len = input.length || 0;
+    this.length = len;
+    this._remaining = len;
+    this._result = new Array(len);
+    this._enumerate(input);
+  };
+  Enumerator.prototype._enumerate = function _enumerate(input) {
+    var length = this.length;
+    var promise = this.promise;
+    for (var i = 0; promise._state === PENDING && i < length; i++) {
+      this._eachEntry(input[i], i, true);
+    }
+    this._checkFullfillment();
+  };
+  Enumerator.prototype._checkFullfillment = function _checkFullfillment() {
+    if (this._remaining === 0) {
+      var result = this._result;
+      fulfill(this.promise, result);
+      this._result = null;
+    }
+  };
+  Enumerator.prototype._settleMaybeThenable = function _settleMaybeThenable(entry, i, firstPass) {
+    var c = this._instanceConstructor;
+    if (this._isUsingOwnResolve) {
+      var 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') {
+        this._settledAt(FULFILLED, i, entry, firstPass);
+      } else if (this._isUsingOwnPromise) {
+        var promise = new c(noop);
+        handleMaybeThenable(promise, entry, then$$1);
+        this._willSettleAt(promise, i, firstPass);
+      } else {
+        this._willSettleAt(new c(function (resolve) {
+          return resolve(entry);
+        }), i, firstPass);
+      }
+    } else {
+      this._willSettleAt(c.resolve(entry), i, firstPass);
+    }
+  };
+  Enumerator.prototype._eachEntry = function _eachEntry(entry, i, firstPass) {
+    if (entry !== null && typeof entry === 'object') {
+      this._settleMaybeThenable(entry, i, firstPass);
+    } else {
+      this._setResultAt(FULFILLED, i, entry, firstPass);
+    }
+  };
+  Enumerator.prototype._settledAt = function _settledAt(state, i, value, firstPass) {
+    var promise = this.promise;
+    if (promise._state === PENDING) {
+      if (this._abortOnReject && state === REJECTED) {
+        reject(promise, value);
+      } else {
+        this._setResultAt(state, i, value, firstPass);
+        this._checkFullfillment();
+      }
+    }
+  };
+  Enumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
+    this._remaining--;
+    this._result[i] = value;
+  };
+  Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i, firstPass) {
+    var _this = this;
+    subscribe(promise, undefined, function (value) {
+      return _this._settledAt(FULFILLED, i, value, firstPass);
+    }, function (reason) {
+      return _this._settledAt(REJECTED, i, reason, firstPass);
+    });
+  };
+  return Enumerator;
+}();
+function setSettledResult(state, i, value) {
+  this._remaining--;
+  if (state === FULFILLED) {
+    this._result[i] = {
+      state: 'fulfilled',
+      value: value
+    };
+  } else {
+    this._result[i] = {
+      state: 'rejected',
+      reason: value
+    };
+  }
+}
+
+/**
+  `Promise.all` accepts an array of promises, and returns a new promise which
+  is fulfilled with an array of fulfillment values for the passed promises, or
+  rejected with the reason of the first passed promise to be rejected. It casts all
+  elements of the passed iterable to promises as it runs this algorithm.
+
+  Example:
+
+  ```javascript
+  import Promise, { resolve } from 'rsvp';
+
+  let promise1 = resolve(1);
+  let promise2 = resolve(2);
+  let promise3 = resolve(3);
+  let promises = [ promise1, promise2, promise3 ];
+
+  Promise.all(promises).then(function(array){
+    // The array here would be [ 1, 2, 3 ];
+  });
+  ```
+
+  If any of the `promises` given to `RSVP.all` are rejected, the first promise
+  that is rejected will be given as an argument to the returned promises's
+  rejection handler. For example:
+
+  Example:
+
+  ```javascript
+  import Promise, { resolve, reject } from 'rsvp';
+
+  let promise1 = resolve(1);
+  let promise2 = reject(new Error("2"));
+  let promise3 = reject(new Error("3"));
+  let promises = [ promise1, promise2, promise3 ];
+
+  Promise.all(promises).then(function(array){
+    // Code here never runs because there are rejected promises!
+  }, function(error) {
+    // error.message === "2"
+  });
+  ```
+
+  @method all
+  @for Promise
+  @param {Array} entries array of promises
+  @param {String} [label] optional string for labeling the promise.
+  Useful for tooling.
+  @return {Promise} promise that is fulfilled when all `promises` have been
+  fulfilled, or rejected if any of them become rejected.
+  @static
+*/
+function all(entries, label) {
+  if (!Array.isArray(entries)) {
+    return this.reject(new TypeError("Promise.all must be called with an array"), label);
+  }
+  return new Enumerator(this, entries, true /* abort on reject */, label).promise;
+}
+
+/**
+  `Promise.race` returns a new promise which is settled in the same way as the
+  first passed promise to settle.
+
+  Example:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  let promise1 = new Promise(function(resolve, reject){
+    setTimeout(function(){
+      resolve('promise 1');
+    }, 200);
+  });
+
+  let promise2 = new Promise(function(resolve, reject){
+    setTimeout(function(){
+      resolve('promise 2');
+    }, 100);
+  });
+
+  Promise.race([promise1, promise2]).then(function(result){
+    // result === 'promise 2' because it was resolved before promise1
+    // was resolved.
+  });
+  ```
+
+  `Promise.race` is deterministic in that only the state of the first
+  settled promise matters. For example, even if other promises given to the
+  `promises` array argument are resolved, but the first settled promise has
+  become rejected before the other promises became fulfilled, the returned
+  promise will become rejected:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  let promise1 = new Promise(function(resolve, reject){
+    setTimeout(function(){
+      resolve('promise 1');
+    }, 200);
+  });
+
+  let promise2 = new Promise(function(resolve, reject){
+    setTimeout(function(){
+      reject(new Error('promise 2'));
+    }, 100);
+  });
+
+  Promise.race([promise1, promise2]).then(function(result){
+    // Code here never runs
+  }, function(reason){
+    // reason.message === 'promise 2' because promise 2 became rejected before
+    // promise 1 became fulfilled
+  });
+  ```
+
+  An example real-world use case is implementing timeouts:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  Promise.race([ajax('foo.json'), timeout(5000)])
+  ```
+
+  @method race
+  @for Promise
+  @static
+  @param {Array} entries array of promises to observe
+  @param {String} [label] optional string for describing the promise returned.
+  Useful for tooling.
+  @return {Promise} a promise which settles in the same way as the first passed
+  promise to settle.
+*/
+function race(entries, label) {
+  /*jshint validthis:true */
+  var Constructor = this;
+  var promise = new Constructor(noop, label);
+  if (!Array.isArray(entries)) {
+    reject(promise, new TypeError('Promise.race must be called with an array'));
+    return promise;
+  }
+  for (var i = 0; promise._state === PENDING && i < entries.length; i++) {
+    subscribe(Constructor.resolve(entries[i]), undefined, function (value) {
+      return resolve$1(promise, value);
+    }, function (reason) {
+      return reject(promise, reason);
+    });
+  }
+  return promise;
+}
+
+/**
+  `Promise.reject` returns a promise rejected with the passed `reason`.
+  It is shorthand for the following:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  let promise = new Promise(function(resolve, reject){
+    reject(new Error('WHOOPS'));
+  });
+
+  promise.then(function(value){
+    // Code here doesn't run because the promise is rejected!
+  }, function(reason){
+    // reason.message === 'WHOOPS'
+  });
+  ```
+
+  Instead of writing the above, your code now simply becomes the following:
+
+  ```javascript
+  import Promise from 'rsvp';
+
+  let promise = Promise.reject(new Error('WHOOPS'));
+
+  promise.then(function(value){
+    // Code here doesn't run because the promise is rejected!
+  }, function(reason){
+    // reason.message === 'WHOOPS'
+  });
+  ```
+
+  @method reject
+  @for Promise
+  @static
+  @param {*} reason value that the returned promise will be rejected with.
+  @param {String} [label] optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise rejected with the given `reason`.
+*/
+function reject$1(reason, label) {
+  /*jshint validthis:true */
+  var Constructor = this;
+  var promise = new Constructor(noop, label);
+  reject(promise, reason);
+  return promise;
+}
+var guidKey = 'rsvp_' + Date.now() + '-';
+var counter = 0;
+function needsResolver() {
+  throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
+}
+function needsNew() {
+  throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
+}
+
+/**
+  Promise objects represent the eventual result of an asynchronous operation. The
+  primary way of interacting with a promise is through its `then` method, which
+  registers callbacks to receive either a promise’s eventual value or the reason
+  why the promise cannot be fulfilled.
+
+  Terminology
+  -----------
+
+  - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
+  - `thenable` is an object or function that defines a `then` method.
+  - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
+  - `exception` is a value that is thrown using the throw statement.
+  - `reason` is a value that indicates why a promise was rejected.
+  - `settled` the final resting state of a promise, fulfilled or rejected.
+
+  A promise can be in one of three states: pending, fulfilled, or rejected.
+
+  Promises that are fulfilled have a fulfillment value and are in the fulfilled
+  state.  Promises that are rejected have a rejection reason and are in the
+  rejected state.  A fulfillment value is never a thenable.
+
+  Promises can also be said to *resolve* a value.  If this value is also a
+  promise, then the original promise's settled state will match the value's
+  settled state.  So a promise that *resolves* a promise that rejects will
+  itself reject, and a promise that *resolves* a promise that fulfills will
+  itself fulfill.
+
+
+  Basic Usage:
+  ------------
+
+  ```js
+  let promise = new Promise(function(resolve, reject) {
+    // on success
+    resolve(value);
+
+    // on failure
+    reject(reason);
+  });
+
+  promise.then(function(value) {
+    // on fulfillment
+  }, function(reason) {
+    // on rejection
+  });
+  ```
+
+  Advanced Usage:
+  ---------------
+
+  Promises shine when abstracting away asynchronous interactions such as
+  `XMLHttpRequest`s.
+
+  ```js
+  function getJSON(url) {
+    return new Promise(function(resolve, reject){
+      let xhr = new XMLHttpRequest();
+
+      xhr.open('GET', url);
+      xhr.onreadystatechange = handler;
+      xhr.responseType = 'json';
+      xhr.setRequestHeader('Accept', 'application/json');
+      xhr.send();
+
+      function handler() {
+        if (this.readyState === this.DONE) {
+          if (this.status === 200) {
+            resolve(this.response);
+          } else {
+            reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
+          }
+        }
+      };
+    });
+  }
+
+  getJSON('/posts.json').then(function(json) {
+    // on fulfillment
+  }, function(reason) {
+    // on rejection
+  });
+  ```
+
+  Unlike callbacks, promises are great composable primitives.
+
+  ```js
+  Promise.all([
+    getJSON('/posts'),
+    getJSON('/comments')
+  ]).then(function(values){
+    values[0] // => postsJSON
+    values[1] // => commentsJSON
+
+    return values;
+  });
+  ```
+
+  @class Promise
+  @public
+  @param {function} resolver
+  @param {String} [label] optional string for labeling the promise.
+  Useful for tooling.
+  @constructor
+*/
+
+var Promise$1 = function () {
+  function Promise(resolver, label) {
+    this._id = counter++;
+    this._label = label;
+    this._state = undefined;
+    this._result = undefined;
+    this._subscribers = [];
+    config.instrument && instrument('created', this);
+    if (noop !== resolver) {
+      typeof resolver !== 'function' && needsResolver();
+      this instanceof Promise ? initializePromise(this, resolver) : needsNew();
+    }
+  }
+  Promise.prototype._onError = function _onError(reason) {
+    var _this = this;
+    config.after(function () {
+      if (_this._onError) {
+        config.trigger('error', reason, _this._label);
+      }
+    });
+  };
+
+  /**
+    `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
+    as the catch block of a try/catch statement.
+  
+    ```js
+    function findAuthor(){
+      throw new Error('couldn\'t find that author');
+    }
+  
+    // synchronous
+    try {
+      findAuthor();
+    } catch(reason) {
+      // something went wrong
+    }
+  
+    // async with promises
+    findAuthor().catch(function(reason){
+      // something went wrong
+    });
+    ```
+  
+    @method catch
+    @param {Function} onRejection
+    @param {String} [label] optional string for labeling the promise.
+    Useful for tooling.
+    @return {Promise}
+  */
+
+  Promise.prototype.catch = function _catch(onRejection, label) {
+    return this.then(undefined, onRejection, label);
+  };
+
+  /**
+    `finally` will be invoked regardless of the promise's fate just as native
+    try/catch/finally behaves
+  
+    Synchronous example:
+  
+    ```js
+    findAuthor() {
+      if (Math.random() > 0.5) {
+        throw new Error();
+      }
+      return new Author();
+    }
+  
+    try {
+      return findAuthor(); // succeed or fail
+    } catch(error) {
+      return findOtherAuthor();
+    } finally {
+      // always runs
+      // doesn't affect the return value
+    }
+    ```
+  
+    Asynchronous example:
+  
+    ```js
+    findAuthor().catch(function(reason){
+      return findOtherAuthor();
+    }).finally(function(){
+      // author was either found, or not
+    });
+    ```
+  
+    @method finally
+    @param {Function} callback
+    @param {String} [label] optional string for labeling the promise.
+    Useful for tooling.
+    @return {Promise}
+  */
+
+  Promise.prototype.finally = function _finally(callback, label) {
+    var promise = this;
+    var constructor = promise.constructor;
+    if (typeof callback === 'function') {
+      return promise.then(function (value) {
+        return constructor.resolve(callback()).then(function () {
+          return value;
+        });
+      }, function (reason) {
+        return constructor.resolve(callback()).then(function () {
+          throw reason;
+        });
+      });
+    }
+    return promise.then(callback, callback);
+  };
+  return Promise;
+}();
+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;
+
+/**
+  The primary way of interacting with a promise is through its `then` method,
+  which registers callbacks to receive either a promise's eventual value or the
+  reason why the promise cannot be fulfilled.
+
+  ```js
+  findUser().then(function(user){
+    // user is available
+  }, function(reason){
+    // user is unavailable, and you are given the reason why
+  });
+  ```
+
+  Chaining
+  --------
+
+  The return value of `then` is itself a promise.  This second, 'downstream'
+  promise is resolved with the return value of the first promise's fulfillment
+  or rejection handler, or rejected if the handler throws an exception.
+
+  ```js
+  findUser().then(function (user) {
+    return user.name;
+  }, function (reason) {
+    return 'default name';
+  }).then(function (userName) {
+    // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
+    // will be `'default name'`
+  });
+
+  findUser().then(function (user) {
+    throw new Error('Found user, but still unhappy');
+  }, function (reason) {
+    throw new Error('`findUser` rejected and we\'re unhappy');
+  }).then(function (value) {
+    // never reached
+  }, function (reason) {
+    // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
+    // If `findUser` rejected, `reason` will be '`findUser` rejected and we\'re unhappy'.
+  });
+  ```
+  If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
+
+  ```js
+  findUser().then(function (user) {
+    throw new PedagogicalException('Upstream error');
+  }).then(function (value) {
+    // never reached
+  }).then(function (value) {
+    // never reached
+  }, function (reason) {
+    // The `PedgagocialException` is propagated all the way down to here
+  });
+  ```
+
+  Assimilation
+  ------------
+
+  Sometimes the value you want to propagate to a downstream promise can only be
+  retrieved asynchronously. This can be achieved by returning a promise in the
+  fulfillment or rejection handler. The downstream promise will then be pending
+  until the returned promise is settled. This is called *assimilation*.
+
+  ```js
+  findUser().then(function (user) {
+    return findCommentsByAuthor(user);
+  }).then(function (comments) {
+    // The user's comments are now available
+  });
+  ```
+
+  If the assimliated promise rejects, then the downstream promise will also reject.
+
+  ```js
+  findUser().then(function (user) {
+    return findCommentsByAuthor(user);
+  }).then(function (comments) {
+    // If `findCommentsByAuthor` fulfills, we'll have the value here
+  }, function (reason) {
+    // If `findCommentsByAuthor` rejects, we'll have the reason here
+  });
+  ```
+
+  Simple Example
+  --------------
+
+  Synchronous Example
+
+  ```javascript
+  let result;
+
+  try {
+    result = findResult();
+    // success
+  } catch(reason) {
+    // failure
+  }
+  ```
+
+  Errback Example
+
+  ```js
+  findResult(function(result, err){
+    if (err) {
+      // failure
+    } else {
+      // success
+    }
+  });
+  ```
+
+  Promise Example;
+
+  ```javascript
+  findResult().then(function(result){
+    // success
+  }, function(reason){
+    // failure
+  });
+  ```
+
+  Advanced Example
+  --------------
+
+  Synchronous Example
+
+  ```javascript
+  let author, books;
+
+  try {
+    author = findAuthor();
+    books  = findBooksByAuthor(author);
+    // success
+  } catch(reason) {
+    // failure
+  }
+  ```
+
+  Errback Example
+
+  ```js
+
+  function foundBooks(books) {
+
+  }
+
+  function failure(reason) {
+
+  }
+
+  findAuthor(function(author, err){
+    if (err) {
+      failure(err);
+      // failure
+    } else {
+      try {
+        findBoooksByAuthor(author, function(books, err) {
+          if (err) {
+            failure(err);
+          } else {
+            try {
+              foundBooks(books);
+            } catch(reason) {
+              failure(reason);
+            }
+          }
+        });
+      } catch(error) {
+        failure(err);
+      }
+      // success
+    }
+  });
+  ```
+
+  Promise Example;
+
+  ```javascript
+  findAuthor().
+    then(findBooksByAuthor).
+    then(function(books){
+      // found books
+  }).catch(function(reason){
+    // something went wrong
+  });
+  ```
+
+  @method then
+  @param {Function} onFulfillment
+  @param {Function} onRejection
+  @param {String} [label] optional string for labeling the promise.
+  Useful for tooling.
+  @return {Promise}
+*/
+Promise$1.prototype.then = then;
+function _possibleConstructorReturn(self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+}
+
+/**
+@module rsvp
+@public
+**/
+
+var AllSettled = function (_Enumerator) {
+  _inherits(AllSettled, _Enumerator);
+  function AllSettled(Constructor, entries, label) {
+    return _possibleConstructorReturn(this, _Enumerator.call(this, Constructor, entries, false /* don't abort on reject */, label));
+  }
+  return AllSettled;
+}(Enumerator);
+AllSettled.prototype._setResultAt = setSettledResult;
+function _possibleConstructorReturn$1(self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+}
+function _inherits$1(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+}
+var PromiseHash = function (_Enumerator) {
+  _inherits$1(PromiseHash, _Enumerator);
+  function PromiseHash(Constructor, object) {
+    var abortOnReject = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    var label = arguments[3];
+    return _possibleConstructorReturn$1(this, _Enumerator.call(this, Constructor, object, abortOnReject, label));
+  }
+  PromiseHash.prototype._init = function _init(Constructor, object) {
+    this._result = {};
+    this._enumerate(object);
+  };
+  PromiseHash.prototype._enumerate = function _enumerate(input) {
+    var keys = Object.keys(input);
+    var length = keys.length;
+    var promise = this.promise;
+    this._remaining = length;
+    var key = void 0,
+      val = void 0;
+    for (var i = 0; promise._state === PENDING && i < length; i++) {
+      key = keys[i];
+      val = input[key];
+      this._eachEntry(val, key, true);
+    }
+    this._checkFullfillment();
+  };
+  return PromiseHash;
+}(Enumerator);
+function _possibleConstructorReturn$2(self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+}
+function _inherits$2(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+}
+var HashSettled = function (_PromiseHash) {
+  _inherits$2(HashSettled, _PromiseHash);
+  function HashSettled(Constructor, object, label) {
+    return _possibleConstructorReturn$2(this, _PromiseHash.call(this, Constructor, object, false, label));
+  }
+  return HashSettled;
+}(PromiseHash);
+HashSettled.prototype._setResultAt = setSettledResult;
+function _possibleConstructorReturn$3(self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+}
+function _inherits$3(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+}
+var MapEnumerator = function (_Enumerator) {
+  _inherits$3(MapEnumerator, _Enumerator);
+  function MapEnumerator(Constructor, entries, mapFn, label) {
+    return _possibleConstructorReturn$3(this, _Enumerator.call(this, Constructor, entries, true, label, mapFn));
+  }
+  MapEnumerator.prototype._init = function _init(Constructor, input, bool, label, mapFn) {
+    var len = input.length || 0;
+    this.length = len;
+    this._remaining = len;
+    this._result = new Array(len);
+    this._mapFn = mapFn;
+    this._enumerate(input);
+  };
+  MapEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
+    if (firstPass) {
+      var 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--;
+      this._result[i] = value;
+    }
+  };
+  return MapEnumerator;
+}(Enumerator);
+
+/**
+  This is a convenient alias for `Promise.resolve`.
+
+  @method resolve
+  @public
+  @static
+  @for rsvp
+  @param {*} value value that the returned promise will be resolved with
+  @param {String} [label] optional string for identifying the returned promise.
+  Useful for tooling.
+  @return {Promise} a promise that will become fulfilled with the given
+  `value`
+*/
+function resolve$2(value, label) {
+  return Promise$1.resolve(value, label);
+}
+function _possibleConstructorReturn$4(self, call) {
+  if (!self) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return call && (typeof call === "object" || typeof call === "function") ? call : self;
+}
+function _inherits$4(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+  }
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+}
+var EMPTY_OBJECT = {};
+(function (_MapEnumerator) {
+  _inherits$4(FilterEnumerator, _MapEnumerator);
+  function FilterEnumerator() {
+    return _possibleConstructorReturn$4(this, _MapEnumerator.apply(this, arguments));
+  }
+  FilterEnumerator.prototype._checkFullfillment = function _checkFullfillment() {
+    if (this._remaining === 0 && this._result !== null) {
+      var result = this._result.filter(function (val) {
+        return val !== EMPTY_OBJECT;
+      });
+      fulfill(this.promise, result);
+      this._result = null;
+    }
+  };
+  FilterEnumerator.prototype._setResultAt = function _setResultAt(state, i, value, firstPass) {
+    if (firstPass) {
+      this._result[i] = value;
+      var 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--;
+      if (!value) {
+        this._result[i] = EMPTY_OBJECT;
+      }
+    }
+  };
+  return FilterEnumerator;
+})(MapEnumerator);
+var len = 0;
+var vertxNext = void 0;
+function asap(callback, 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$1();
+  }
+}
+var browserWindow = typeof window !== 'undefined' ? window : undefined;
+var browserGlobal = browserWindow || {};
+var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
+var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
+
+// test for web worker but not in IE10
+var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
+
+// node
+function useNextTick() {
+  var nextTick = process.nextTick;
+  // node version 0.10.x displays a deprecation warning when nextTick is used recursively
+  // setImmediate should be used instead instead
+  var version = process.versions.node.match(/^(?:(\d+)\.)?(?:(\d+)\.)?(\*|\d+)$/);
+  if (Array.isArray(version) && version[1] === '0' && version[2] === '10') {
+    nextTick = setImmediate;
+  }
+  return function () {
+    return nextTick(flush);
+  };
+}
+
+// vertx
+function useVertxTimer() {
+  if (typeof vertxNext !== 'undefined') {
+    return function () {
+      vertxNext(flush);
+    };
+  }
+  return useSetTimeout();
+}
+function useMutationObserver() {
+  var iterations = 0;
+  var observer = new BrowserMutationObserver(flush);
+  var node = document.createTextNode('');
+  observer.observe(node, {
+    characterData: true
+  });
+  return function () {
+    return node.data = iterations = ++iterations % 2;
+  };
+}
+
+// web worker
+function useMessageChannel() {
+  var channel = new MessageChannel();
+  channel.port1.onmessage = flush;
+  return function () {
+    return channel.port2.postMessage(0);
+  };
+}
+function useSetTimeout() {
+  return function () {
+    return setTimeout(flush, 1);
+  };
+}
+var queue$1 = new Array(1000);
+function flush() {
+  for (var i = 0; i < len; i += 2) {
+    var callback = queue$1[i];
+    var arg = queue$1[i + 1];
+    callback(arg);
+    queue$1[i] = undefined;
+    queue$1[i + 1] = undefined;
+  }
+  len = 0;
+}
+function attemptVertex() {
+  try {
+    var vertx = Function('return this')().require('vertx');
+    vertxNext = vertx.runOnLoop || vertx.runOnContext;
+    return useVertxTimer();
+  } catch (e) {
+    return useSetTimeout();
+  }
+}
+var scheduleFlush$1 = void 0;
+// Decide what async method to use to triggering processing of queued callbacks:
+if (isNode) {
+  scheduleFlush$1 = useNextTick();
+} else if (BrowserMutationObserver) {
+  scheduleFlush$1 = useMutationObserver();
+} else if (isWorker) {
+  scheduleFlush$1 = useMessageChannel();
+} else if (browserWindow === undefined && typeof require === 'function') {
+  scheduleFlush$1 = attemptVertex();
+} else {
+  scheduleFlush$1 = useSetTimeout();
+}
+
+// defaults
+config.async = asap;
+config.after = function (cb) {
+  return setTimeout(cb, 0);
+};
+function on() {
+  config.on.apply(config, arguments);
+}
+
+// Set up instrumentation through `window.__PROMISE_INTRUMENTATION__`
+if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'] === 'object') {
+  var callbacks = window['__PROMISE_INSTRUMENTATION__'];
+  configure('instrument', true);
+  for (var eventName in callbacks) {
+    if (callbacks.hasOwnProperty(eventName)) {
+      on(eventName, callbacks[eventName]);
+    }
+  }
+}
+function _guard(promise, test) {
+  let guarded = promise.finally(() => {
+    if (!test()) {
+      guarded._subscribers.length = 0;
+    }
+  });
+  return guarded;
+}
+function _objectIsAlive(object) {
+  return !(object.isDestroyed || object.isDestroying);
+}
+function guardDestroyedStore(promise, store, label) {
+  let wrapperPromise = resolve$2(promise, label).then(_v => {
+    if (!_objectIsAlive(store)) {
+      if (macroCondition(getOwnConfig().deprecations.DEPRECATE_RSVP_PROMISE)) {
+        deprecate(`A Promise did not resolve by the time the store was destroyed. This will error in a future release.`, false, {
+          id: 'ember-data:rsvp-unresolved-async',
+          until: '5.0',
+          for: '@ember-data/store',
+          since: {
+            available: '4.5',
+            enabled: '4.5'
+          }
+        });
+      }
+    }
+    return promise;
+  });
+  return _guard(wrapperPromise, () => {
+    return _objectIsAlive(store);
+  });
+}
+
+/**
+  This is a helper method that validates a JSON API top-level document
+
+  The format of a document is described here:
+  http://jsonapi.org/format/#document-top-level
+
+  @internal
+*/
+function validateDocumentStructure(doc) {
+  if (macroCondition(isDevelopingApp())) {
+    let errors = [];
+    if (!doc || typeof doc !== 'object') {
+      errors.push('Top level of a JSON API document must be an object');
+    } else {
+      if (!('data' in doc) && !('errors' in doc) && !('meta' in doc)) {
+        errors.push('One or more of the following keys must be present: "data", "errors", "meta".');
+      } else {
+        if ('data' in doc && 'errors' in doc) {
+          errors.push('Top level keys "errors" and "data" cannot both be present in a JSON API document');
+        }
+      }
+      if ('data' in doc) {
+        if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === 'object')) {
+          errors.push('data must be null, an object, or an array');
+        }
+      }
+      if ('meta' in doc) {
+        if (typeof doc.meta !== 'object') {
+          errors.push('meta must be an object');
+        }
+      }
+      if ('errors' in doc) {
+        if (!Array.isArray(doc.errors)) {
+          errors.push('errors must be an array');
+        }
+      }
+      if ('links' in doc) {
+        if (typeof doc.links !== 'object') {
+          errors.push('links must be an object');
+        }
+      }
+      if ('jsonapi' in doc) {
+        if (typeof doc.jsonapi !== 'object') {
+          errors.push('jsonapi must be an object');
+        }
+      }
+      if ('included' in doc) {
+        if (typeof doc.included !== 'object') {
+          errors.push('included must be an array');
+        }
+      }
+    }
+    assert(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join('\n\t* ')}`, errors.length === 0);
+  }
+}
+function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
+  let normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
+  validateDocumentStructure(normalizedResponse);
+  return normalizedResponse;
+}
+const LegacyNetworkHandler = {
+  request(context, next) {
+    // if we are not a legacy request, move on
+    if (context.request.url || !context.request.op) {
+      return next(context.request);
+    }
+    switch (context.request.op) {
+      case 'findAll':
+        return findAll(context);
+      case 'queryRecord':
+        return queryRecord(context);
+      case 'query':
+        return query(context);
+      default:
+        return next(context.request);
+    }
+  }
+};
+function findAll(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  const {
+    type,
+    options
+  } = data;
+  const adapter = store.adapterFor(type);
+  assert(`You tried to load all records but you have no adapter (for ${type})`, adapter);
+  assert(`You tried to load all records but your adapter does not implement 'findAll'`, typeof adapter.findAll === 'function');
+
+  // avoid initializing the liveArray just to set `isUpdating`
+  const maybeRecordArray = store.recordArrayManager._live.get(type);
+  const snapshotArray = new SnapshotRecordArray(store, type, options);
+  const shouldReload = options.reload || options.reload !== false && (adapter.shouldReloadAll && adapter.shouldReloadAll(store, snapshotArray) || !adapter.shouldReloadAll && snapshotArray.length === 0);
+  let fetch;
+  if (shouldReload) {
+    maybeRecordArray && (maybeRecordArray.isUpdating = true);
+    fetch = _findAll(adapter, store, type, snapshotArray);
+  } else {
+    fetch = Promise$1.resolve(store.peekAll(type));
+    if (options.backgroundReload || options.backgroundReload !== false && (!adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(store, snapshotArray))) {
+      maybeRecordArray && (maybeRecordArray.isUpdating = true);
+      void _findAll(adapter, store, type, snapshotArray);
+    }
+  }
+  return fetch;
+}
+function payloadIsNotBlank(adapterPayload) {
+  if (Array.isArray(adapterPayload)) {
+    return true;
+  } else {
+    return Object.keys(adapterPayload || {}).length;
+  }
+}
+function _findAll(adapter, store, type, snapshotArray) {
+  const schema = store.modelFor(type);
+  let promise = Promise$1.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
+  promise = guardDestroyedStore(promise, store, macroCondition(isDevelopingApp()) ? `DS: Handle Adapter#findAll of ${type}` : '');
+  return promise.then(adapterPayload => {
+    assert(`You made a 'findAll' request for '${type}' records, but the adapter's response did not have any data`, payloadIsNotBlank(adapterPayload));
+    const serializer = store.serializerFor(type);
+    const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'findAll');
+    store._push(payload);
+    snapshotArray._recordArray.isUpdating = false;
+    return snapshotArray._recordArray;
+  });
+}
+function query(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  let {
+    options
+  } = data;
+  const {
+    type,
+    query
+  } = data;
+  const adapter = store.adapterFor(type);
+  assert(`You tried to make a query but you have no adapter (for ${type})`, adapter);
+  assert(`You tried to make a query but your adapter does not implement 'query'`, typeof adapter.query === 'function');
+  const recordArray = options._recordArray || store.recordArrayManager.createArray({
+    type,
+    query
+  });
+  if (macroCondition(isDevelopingApp())) {
+    options = Object.assign({}, options);
+    delete options._recordArray;
+  } else {
+    delete options._recordArray;
+  }
+  const schema = store.modelFor(type);
+  let promise = Promise$1.resolve().then(() => adapter.query(store, schema, query, recordArray, options));
+  promise = guardDestroyedStore(promise, store, macroCondition(isDevelopingApp()) ? `DS: Handle Adapter#query of ${type}` : ``);
+  return promise.then(adapterPayload => {
+    const serializer = store.serializerFor(type);
+    const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'query');
+    const identifiers = store._push(payload);
+    assert('The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.', Array.isArray(identifiers));
+    store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
+    return recordArray;
+  });
+}
+function assertSingleResourceDocument(payload) {
+  assert(`Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`, !Array.isArray(payload.data));
+}
+function queryRecord(context) {
+  const {
+    store,
+    data
+  } = context.request;
+  const {
+    type,
+    query,
+    options
+  } = data;
+  const adapter = store.adapterFor(type);
+  assert(`You tried to make a query but you have no adapter (for ${type})`, adapter);
+  assert(`You tried to make a query but your adapter does not implement 'queryRecord'`, typeof adapter.queryRecord === 'function');
+  const schema = store.modelFor(type);
+  let promise = Promise$1.resolve().then(() => adapter.queryRecord(store, schema, query, options));
+  promise = guardDestroyedStore(promise, store, macroCondition(isDevelopingApp()) ? `DS: Handle Adapter#queryRecord of ${type}` : ``);
+  return promise.then(adapterPayload => {
+    const serializer = store.serializerFor(type);
+    const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, 'queryRecord');
+    assertSingleResourceDocument(payload);
+    return store.push(payload);
+  });
+}
+export { LegacyNetworkHandler };