@tko/observable 4.0.0-alpha7.3 → 4.0.0-beta1.0

package/dist/observable.es6.js

@@ -1,918 +0,0 @@
-/*!
- * TKO subscribables and observables 🥊  @tko/observable@4.0.0-alpha7.3
- * (c) The Knockout.js Team - https://tko.io
- * License: MIT (http://www.opensource.org/licenses/mit-license.php)
- */
-
-import { tasks, removeDisposeCallback, addDisposeCallback, options, objectForEach, throttle, debounce, arrayRemoveItem, overwriteLengthPropertyIfSupported, extend, compareArrays, findMovesInArrayComparison, arrayIndexOf, arrayForEach } from '@tko/utils';
-
-/**
- * Create a subscribable symbol that's used to identify subscribables.
- */
-const SUBSCRIBABLE_SYM = Symbol('Knockout Subscribable');
-
-function isSubscribable (instance) {
-  return (instance && instance[SUBSCRIBABLE_SYM]) || false
-}
-
-//
-
-const outerFrames = [];
-let currentFrame;
-let lastId = 0;
-
-// Return a unique ID that can be assigned to an observable for dependency tracking.
-// Theoretically, you could eventually overflow the number storage size, resulting
-// in duplicate IDs. But in JavaScript, the largest exact integral value is 2^53
-// or 9,007,199,254,740,992. If you created 1,000,000 IDs per second, it would
-// take over 285 years to reach that number.
-// Reference http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html
-function getId () {
-  return ++lastId
-}
-
-function begin (options$$1) {
-  outerFrames.push(currentFrame);
-  currentFrame = options$$1;
-}
-
-function end () {
-  currentFrame = outerFrames.pop();
-}
-
-function registerDependency (subscribable) {
-  if (currentFrame) {
-    if (!isSubscribable(subscribable)) { throw new Error('Only subscribable things can act as dependencies') }
-    currentFrame.callback.call(currentFrame.callbackTarget, subscribable, subscribable._id || (subscribable._id = getId()));
-  }
-}
-
-function ignore (callback, callbackTarget, callbackArgs) {
-  try {
-    begin();
-    return callback.apply(callbackTarget, callbackArgs || [])
-  } finally {
-    end();
-  }
-}
-
-function getDependenciesCount () {
-  if (currentFrame) { return currentFrame.computed.getDependenciesCount() }
-}
-
-function getDependencies () {
-  if (currentFrame) { return currentFrame.computed.getDependencies() }
-}
-
-function isInitial () {
-  if (currentFrame) { return currentFrame.isInitial }
-}
-
-var dependencyDetection = /*#__PURE__*/Object.freeze({
-  begin: begin,
-  end: end,
-  registerDependency: registerDependency,
-  ignore: ignore,
-  getDependenciesCount: getDependenciesCount,
-  getDependencies: getDependencies,
-  isInitial: isInitial,
-  ignoreDependencies: ignore
-});
-
-//
-
-function deferUpdates (target) {
-  if (target._deferUpdates) { return }
-  target._deferUpdates = true;
-  target.limit(function (callback) {
-    let handle;
-    let ignoreUpdates = false;
-    return function () {
-      if (!ignoreUpdates) {
-        tasks.cancel(handle);
-        handle = tasks.schedule(callback);
-        try {
-          ignoreUpdates = true;
-          target.notifySubscribers(undefined, 'dirty');
-        } finally {
-          ignoreUpdates = false;
-        }
-      }
-    }
-  });
-}
-
-class Subscription {
-  constructor (target, observer, disposeCallback) {
-    this._target = target;
-    this._callback = observer.next;
-    this._disposeCallback = disposeCallback;
-    this._isDisposed = false;
-    this._domNodeDisposalCallback = null;
-  }
-
-  dispose () {
-    if (this._domNodeDisposalCallback) {
-      removeDisposeCallback(this._node, this._domNodeDisposalCallback);
-    }
-    this._isDisposed = true;
-    this._disposeCallback();
-  }
-
-  disposeWhenNodeIsRemoved (node) {
-    this._node = node;
-    addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
-  }
-
-  // TC39 Observable API
-  unsubscribe () { this.dispose(); }
-  get closed () { return this._isDisposed }
-}
-
-//
-
-var primitiveTypes = {
-  'undefined': 1, 'boolean': 1, 'number': 1, 'string': 1
-};
-
-function valuesArePrimitiveAndEqual (a, b) {
-  var oldValueIsPrimitive = (a === null) || (typeof (a) in primitiveTypes);
-  return oldValueIsPrimitive ? (a === b) : false
-}
-
-function applyExtenders (requestedExtenders) {
-  var target = this;
-  if (requestedExtenders) {
-    objectForEach(requestedExtenders, function (key, value) {
-      var extenderHandler = extenders[key];
-      if (typeof extenderHandler === 'function') {
-        target = extenderHandler(target, value) || target;
-      } else {
-        options.onError(new Error('Extender not found: ' + key));
-      }
-    });
-  }
-  return target
-}
-
-/*
-                --- DEFAULT EXTENDERS ---
- */
-
-// Change when notifications are published.
-function notify (target, notifyWhen) {
-  target.equalityComparer = notifyWhen == 'always'
-        ? null  // null equalityComparer means to always notify
-        : valuesArePrimitiveAndEqual;
-}
-
-function deferred (target, option) {
-  if (option !== true) {
-    throw new Error('The \'deferred\' extender only accepts the value \'true\', because it is not supported to turn deferral off once enabled.')
-  }
-  deferUpdates(target);
-}
-
-function rateLimit (target, options$$1) {
-  var timeout, method, limitFunction;
-
-  if (typeof options$$1 === 'number') {
-    timeout = options$$1;
-  } else {
-    timeout = options$$1.timeout;
-    method = options$$1.method;
-  }
-
-    // rateLimit supersedes deferred updates
-  target._deferUpdates = false;
-
-  limitFunction = method === 'notifyWhenChangesStop' ? debounce : throttle;
-
-  target.limit(function (callback) {
-    return limitFunction(callback, timeout)
-  });
-}
-
-var extenders = {
-  notify: notify,
-  deferred: deferred,
-  rateLimit: rateLimit
-};
-
-/* eslint no-cond-assign: 0 */
-
-// Descendants may have a LATEST_VALUE, which if present
-// causes TC39 subscriptions to emit the latest value when
-// subscribed.
-const LATEST_VALUE = Symbol('Knockout latest value');
-
-function subscribable () {
-  Object.setPrototypeOf(this, ko_subscribable_fn);
-  ko_subscribable_fn.init(this);
-}
-
-var defaultEvent = 'change';
-
-var ko_subscribable_fn = {
-  [SUBSCRIBABLE_SYM]: true,
-  [Symbol.observable] () { return this },
-
-  init (instance) {
-    instance._subscriptions = { change: [] };
-    instance._versionNumber = 1;
-  },
-
-  subscribe (callback, callbackTarget, event) {
-    // TC39 proposed standard Observable { next: () => ... }
-    const isTC39Callback = typeof callback === 'object' && callback.next;
-
-    event = event || defaultEvent;
-    const observer = isTC39Callback ? callback : {
-      next: callbackTarget ? callback.bind(callbackTarget) : callback
-    };
-
-    const subscriptionInstance = new Subscription(this, observer, () => {
-      arrayRemoveItem(this._subscriptions[event], subscriptionInstance);
-      if (this.afterSubscriptionRemove) {
-        this.afterSubscriptionRemove(event);
-      }
-    });
-
-    if (this.beforeSubscriptionAdd) {
-      this.beforeSubscriptionAdd(event);
-    }
-
-    if (!this._subscriptions[event]) {
-      this._subscriptions[event] = [];
-    }
-    this._subscriptions[event].push(subscriptionInstance);
-
-    // Have TC39 `subscribe` immediately emit.
-    // https://github.com/tc39/proposal-observable/issues/190
-
-    if (isTC39Callback && LATEST_VALUE in this) {
-      observer.next(this[LATEST_VALUE]);
-    }
-
-    return subscriptionInstance
-  },
-
-  notifySubscribers (valueToNotify, event) {
-    event = event || defaultEvent;
-    if (event === defaultEvent) {
-      this.updateVersion();
-    }
-    if (this.hasSubscriptionsForEvent(event)) {
-      const subs = event === defaultEvent && this._changeSubscriptions
-        || [...this._subscriptions[event]];
-
-      try {
-        begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)
-        for (let i = 0, subscriptionInstance; subscriptionInstance = subs[i]; ++i) {
-                    // In case a subscription was disposed during the arrayForEach cycle, check
-                    // for isDisposed on each subscription before invoking its callback
-          if (!subscriptionInstance._isDisposed) {
-            subscriptionInstance._callback(valueToNotify);
-          }
-        }
-      } finally {
-        end(); // End suppressing dependency detection
-      }
-    }
-  },
-
-  getVersion () {
-    return this._versionNumber
-  },
-
-  hasChanged (versionToCheck) {
-    return this.getVersion() !== versionToCheck
-  },
-
-  updateVersion () {
-    ++this._versionNumber;
-  },
-
-  hasSubscriptionsForEvent (event) {
-    return this._subscriptions[event] && this._subscriptions[event].length
-  },
-
-  getSubscriptionsCount (event) {
-    if (event) {
-      return this._subscriptions[event] && this._subscriptions[event].length || 0
-    } else {
-      var total = 0;
-      objectForEach(this._subscriptions, function (eventName, subscriptions) {
-        if (eventName !== 'dirty') {
-          total += subscriptions.length;
-        }
-      });
-      return total
-    }
-  },
-
-  isDifferent (oldValue, newValue) {
-    return !this.equalityComparer ||
-               !this.equalityComparer(oldValue, newValue)
-  },
-
-  once (cb) {
-    const subs = this.subscribe((nv) => {
-      subs.dispose();
-      cb(nv);
-    });
-  },
-
-  when (test, returnValue) {
-    const current = this.peek();
-    const givenRv = arguments.length > 1;
-    const testFn = typeof test === 'function' ? test : v => v === test;
-    if (testFn(current)) {
-      return options.Promise.resolve(givenRv ? returnValue : current)
-    }
-    return new options.Promise((resolve, reject) => {
-      const subs = this.subscribe(newValue => {
-        if (testFn(newValue)) {
-          subs.dispose();
-          resolve(givenRv ? returnValue : newValue);
-        }
-      });
-    })
-  },
-
-  yet (test, ...args) {
-    const testFn = typeof test === 'function' ? test : v => v === test;
-    const negated = v => !testFn(v);
-    return this.when(negated, ...args)
-  },
-
-  next () { return new Promise(resolve => this.once(resolve)) },
-
-  toString () { return '[object Object]' },
-
-  extend: applyExtenders
-};
-
-// For browsers that support proto assignment, we overwrite the prototype of each
-// observable instance. Since observables are functions, we need Function.prototype
-// to still be in the prototype chain.
-Object.setPrototypeOf(ko_subscribable_fn, Function.prototype);
-
-subscribable.fn = ko_subscribable_fn;
-
-//
-
-function observable (initialValue) {
-  function Observable () {
-    if (arguments.length > 0) {
-            // Write
-            // Ignore writes if the value hasn't changed
-      if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {
-        Observable.valueWillMutate();
-        Observable[LATEST_VALUE] = arguments[0];
-        Observable.valueHasMutated();
-      }
-      return this // Permits chained assignments
-    } else {
-            // Read
-      registerDependency(Observable); // The caller only needs to be notified of changes if they did a "read" operation
-      return Observable[LATEST_VALUE]
-    }
-  }
-
-  overwriteLengthPropertyIfSupported(Observable, { value: undefined });
-
-  Observable[LATEST_VALUE] = initialValue;
-
-  subscribable.fn.init(Observable);
-
-    // Inherit from 'observable'
-  Object.setPrototypeOf(Observable, observable.fn);
-
-  if (options.deferUpdates) {
-    deferUpdates(Observable);
-  }
-
-  return Observable
-}
-
-// Define prototype for observables
-observable.fn = {
-  equalityComparer: valuesArePrimitiveAndEqual,
-  peek () { return this[LATEST_VALUE] },
-  valueHasMutated () {
-    this.notifySubscribers(this[LATEST_VALUE], 'spectate');
-    this.notifySubscribers(this[LATEST_VALUE]);
-  },
-  valueWillMutate () {
-    this.notifySubscribers(this[LATEST_VALUE], 'beforeChange');
-  },
-
-  modify (fn, peek = true) {
-    return this(fn(peek ? this.peek() : this()))
-  },
-
-  // Some observables may not always be writeable, notably computeds.
-  isWriteable: true
-};
-
-// Moved out of "limit" to avoid the extra closure
-function limitNotifySubscribers (value, event) {
-  if (!event || event === defaultEvent) {
-    this._limitChange(value);
-  } else if (event === 'beforeChange') {
-    this._limitBeforeChange(value);
-  } else {
-    this._origNotifySubscribers(value, event);
-  }
-}
-
-// Add `limit` function to the subscribable prototype
-subscribable.fn.limit = function limit (limitFunction) {
-  var self = this;
-  var selfIsObservable = isObservable(self);
-  var beforeChange = 'beforeChange';
-  var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
-
-  if (!self._origNotifySubscribers) {
-    self._origNotifySubscribers = self.notifySubscribers;
-    self.notifySubscribers = limitNotifySubscribers;
-  }
-
-  var finish = limitFunction(function () {
-    self._notificationIsPending = false;
-
-    // If an observable provided a reference to itself, access it to get the latest value.
-    // This allows computed observables to delay calculating their value until needed.
-    if (selfIsObservable && pendingValue === self) {
-      pendingValue = self._evalIfChanged ? self._evalIfChanged() : self();
-    }
-    const shouldNotify = notifyNextChange || (
-      didUpdate && self.isDifferent(previousValue, pendingValue)
-    );
-    self._notifyNextChange = didUpdate = ignoreBeforeChange = false;
-    if (shouldNotify) {
-      self._origNotifySubscribers(previousValue = pendingValue);
-    }
-  });
-
-  Object.assign(self, {
-    _limitChange  (value, isDirty) {
-      if (!isDirty || !self._notificationIsPending) {
-        didUpdate = !isDirty;
-      }
-      self._changeSubscriptions = [...self._subscriptions[defaultEvent]];
-      self._notificationIsPending = ignoreBeforeChange = true;
-      pendingValue = value;
-      finish();
-    },
-
-    _limitBeforeChange (value) {
-      if (!ignoreBeforeChange) {
-        previousValue = value;
-        self._origNotifySubscribers(value, beforeChange);
-      }
-    },
-
-    _notifyNextChangeIfValueIsDifferent () {
-      if (self.isDifferent(previousValue, self.peek(true /* evaluate */))) {
-        notifyNextChange = true;
-      }
-    },
-
-    _recordUpdate () {
-      didUpdate = true;
-    }
-  });
-};
-
-Object.setPrototypeOf(observable.fn, subscribable.fn);
-
-var protoProperty = observable.protoProperty = options.protoProperty;
-observable.fn[protoProperty] = observable;
-
-// Subclasses can add themselves to observableProperties so that
-// isObservable will be `true`.
-observable.observablePrototypes = new Set([observable]);
-
-function isObservable (instance) {
-  const proto = typeof instance === 'function' && instance[protoProperty];
-  if (proto && !observable.observablePrototypes.has(proto)) {
-    throw Error('Invalid object that looks like an observable; possibly from another Knockout instance')
-  }
-  return !!proto
-}
-
-function unwrap (value) {
-  return isObservable(value) ? value() : value
-}
-
-function peek (value) {
-  return isObservable(value) ? value.peek() : value
-}
-
-function isWriteableObservable (instance) {
-  return isObservable(instance) && instance.isWriteable
-}
-
-//
-
-var arrayChangeEventName = 'arrayChange';
-
-function trackArrayChanges (target, options$$1) {
-    // Use the provided options--each call to trackArrayChanges overwrites the previously set options
-  target.compareArrayOptions = {};
-  if (options$$1 && typeof options$$1 === 'object') {
-    extend(target.compareArrayOptions, options$$1);
-  }
-  target.compareArrayOptions.sparse = true;
-
-    // Only modify the target observable once
-  if (target.cacheDiffForKnownOperation) {
-    return
-  }
-  let trackingChanges = false;
-  let cachedDiff = null;
-  let arrayChangeSubscription;
-  let pendingNotifications = 0;
-  let underlyingNotifySubscribersFunction;
-  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
-  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
-
-    // Watch "subscribe" calls, and for array change events, ensure change tracking is enabled
-  target.beforeSubscriptionAdd = function (event) {
-    if (underlyingBeforeSubscriptionAddFunction) {
-      underlyingBeforeSubscriptionAddFunction.call(target, event);
-    }
-    if (event === arrayChangeEventName) {
-      trackChanges();
-    }
-  };
-
-    // Watch "dispose" calls, and for array change events, ensure change tracking is disabled when all are disposed
-  target.afterSubscriptionRemove = function (event) {
-    if (underlyingAfterSubscriptionRemoveFunction) {
-      underlyingAfterSubscriptionRemoveFunction.call(target, event);
-    }
-    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
-      if (underlyingNotifySubscribersFunction) {
-        target.notifySubscribers = underlyingNotifySubscribersFunction;
-        underlyingNotifySubscribersFunction = undefined;
-      }
-      if (arrayChangeSubscription) {
-        arrayChangeSubscription.dispose();
-      }
-      arrayChangeSubscription = null;
-      trackingChanges = false;
-    }
-  };
-
-  function trackChanges () {
-        // Calling 'trackChanges' multiple times is the same as calling it once
-    if (trackingChanges) {
-      return
-    }
-
-    trackingChanges = true;
-
-        // Intercept "notifySubscribers" to track how many times it was called.
-    underlyingNotifySubscribersFunction = target['notifySubscribers'];
-    target.notifySubscribers = function (valueToNotify, event) {
-      if (!event || event === defaultEvent) {
-        ++pendingNotifications;
-      }
-      return underlyingNotifySubscribersFunction.apply(this, arguments)
-    };
-
-        // Each time the array changes value, capture a clone so that on the next
-        // change it's possible to produce a diff
-    var previousContents = [].concat(target.peek() === undefined ? [] : target.peek());
-    cachedDiff = null;
-    arrayChangeSubscription = target.subscribe(function (currentContents) {
-      let changes;
-            // Make a copy of the current contents and ensure it's an array
-      currentContents = [].concat(currentContents || []);
-
-            // Compute the diff and issue notifications, but only if someone is listening
-      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
-        changes = getChanges(previousContents, currentContents);
-      }
-
-            // Eliminate references to the old, removed items, so they can be GCed
-      previousContents = currentContents;
-      cachedDiff = null;
-      pendingNotifications = 0;
-
-      if (changes && changes.length) {
-        target.notifySubscribers(changes, arrayChangeEventName);
-      }
-    });
-  }
-
-  function getChanges (previousContents, currentContents) {
-        // We try to re-use cached diffs.
-        // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates
-        // plugin, which without this check would not be compatible with arrayChange notifications. Normally,
-        // notifications are issued immediately so we wouldn't be queueing up more than one.
-    if (!cachedDiff || pendingNotifications > 1) {
-      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions);
-    }
-
-    return cachedDiff
-  }
-
-  target.cacheDiffForKnownOperation = function (rawArray, operationName, args) {
-      // Only run if we're currently tracking changes for this observable array
-      // and there aren't any pending deferred notifications.
-    if (!trackingChanges || pendingNotifications) {
-      return
-    }
-    var diff = [],
-      arrayLength = rawArray.length,
-      argsLength = args.length,
-      offset = 0;
-
-    function pushDiff (status, value, index) {
-      return diff[diff.length] = { 'status': status, 'value': value, 'index': index }
-    }
-    switch (operationName) {
-      case 'push':
-        offset = arrayLength;
-      case 'unshift':
-        for (let index = 0; index < argsLength; index++) {
-          pushDiff('added', args[index], offset + index);
-        }
-        break
-
-      case 'pop':
-        offset = arrayLength - 1;
-      case 'shift':
-        if (arrayLength) {
-          pushDiff('deleted', rawArray[offset], offset);
-        }
-        break
-
-      case 'splice':
-            // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].
-            // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
-        var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),
-          endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),
-          endAddIndex = startIndex + argsLength - 2,
-          endIndex = Math.max(endDeleteIndex, endAddIndex),
-          additions = [], deletions = [];
-        for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
-          if (index < endDeleteIndex) { deletions.push(pushDiff('deleted', rawArray[index], index)); }
-          if (index < endAddIndex) { additions.push(pushDiff('added', args[argsIndex], index)); }
-        }
-        findMovesInArrayComparison(deletions, additions);
-        break
-
-      default:
-        return
-    }
-    cachedDiff = diff;
-  };
-}
-
-// Expose compareArrays for testing.
-trackArrayChanges.compareArrays = compareArrays;
-
-// Add the trackArrayChanges extender so we can use
-// obs.extend({ trackArrayChanges: true })
-extenders.trackArrayChanges = trackArrayChanges;
-
-//
-
-function observableArray (initialValues) {
-  initialValues = initialValues || [];
-
-  if (typeof initialValues !== 'object' || !('length' in initialValues)) { throw new Error('The argument passed when initializing an observable array must be an array, or null, or undefined.') }
-
-  var result = observable(initialValues);
-  Object.setPrototypeOf(result, observableArray.fn);
-  trackArrayChanges(result);
-        // ^== result.extend({ trackArrayChanges: true })
-  overwriteLengthPropertyIfSupported(result, { get: () => result().length });
-  return result
-}
-
-function isObservableArray (instance) {
-  return isObservable(instance) && typeof instance.remove === 'function' && typeof instance.push === 'function'
-}
-
-observableArray.fn = {
-  remove (valueOrPredicate) {
-    var underlyingArray = this.peek();
-    var removedValues = [];
-    var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate };
-    for (var i = 0; i < underlyingArray.length; i++) {
-      var value = underlyingArray[i];
-      if (predicate(value)) {
-        if (removedValues.length === 0) {
-          this.valueWillMutate();
-        }
-        if (underlyingArray[i] !== value) {
-          throw Error("Array modified during remove; cannot remove item")
-        }
-        removedValues.push(value);
-        underlyingArray.splice(i, 1);
-        i--;
-      }
-    }
-    if (removedValues.length) {
-      this.valueHasMutated();
-    }
-    return removedValues
-  },
-
-  removeAll (arrayOfValues) {
-        // If you passed zero args, we remove everything
-    if (arrayOfValues === undefined) {
-      var underlyingArray = this.peek();
-      var allValues = underlyingArray.slice(0);
-      this.valueWillMutate();
-      underlyingArray.splice(0, underlyingArray.length);
-      this.valueHasMutated();
-      return allValues
-    }
-        // If you passed an arg, we interpret it as an array of entries to remove
-    if (!arrayOfValues) {
-      return []
-    }
-    return this['remove'](function (value) {
-      return arrayIndexOf(arrayOfValues, value) >= 0
-    })
-  },
-
-  destroy (valueOrPredicate) {
-    var underlyingArray = this.peek();
-    var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate };
-    this.valueWillMutate();
-    for (var i = underlyingArray.length - 1; i >= 0; i--) {
-      var value = underlyingArray[i];
-      if (predicate(value)) {
-        value['_destroy'] = true;
-      }
-    }
-    this.valueHasMutated();
-  },
-
-  destroyAll (arrayOfValues) {
-        // If you passed zero args, we destroy everything
-    if (arrayOfValues === undefined) { return this.destroy(function () { return true }) }
-
-        // If you passed an arg, we interpret it as an array of entries to destroy
-    if (!arrayOfValues) {
-      return []
-    }
-    return this.destroy(function (value) {
-      return arrayIndexOf(arrayOfValues, value) >= 0
-    })
-  },
-
-  indexOf (item) {
-    return arrayIndexOf(this(), item)
-  },
-
-  replace (oldItem, newItem) {
-    var index = this.indexOf(oldItem);
-    if (index >= 0) {
-      this.valueWillMutate();
-      this.peek()[index] = newItem;
-      this.valueHasMutated();
-    }
-  },
-
-  sorted (compareFn) {
-    return [...this()].sort(compareFn)
-  },
-
-  reversed () {
-    return [...this()].reverse()
-  },
-
-  [Symbol.iterator]: function * () {
-    yield * this();
-  }
-};
-
-Object.setPrototypeOf(observableArray.fn, observable.fn);
-
-// Populate ko.observableArray.fn with read/write functions from native arrays
-// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array
-// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale
-arrayForEach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (methodName) {
-  observableArray.fn[methodName] = function () {
-        // Use "peek" to avoid creating a subscription in any computed that we're executing in the context of
-        // (for consistency with mutating regular observables)
-    var underlyingArray = this.peek();
-    this.valueWillMutate();
-    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
-    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
-    this.valueHasMutated();
-        // The native sort and reverse methods return a reference to the array, but it makes more sense to return the observable array instead.
-    return methodCallResult === underlyingArray ? this : methodCallResult
-  };
-});
-
-// Populate ko.observableArray.fn with read-only functions from native arrays
-arrayForEach(['slice'], function (methodName) {
-  observableArray.fn[methodName] = function () {
-    var underlyingArray = this();
-    return underlyingArray[methodName].apply(underlyingArray, arguments)
-  };
-});
-
-// Expose for testing.
-observableArray.trackArrayChanges = trackArrayChanges;
-
-//
-
-var maxNestedObservableDepth = 10; // Escape the (unlikely) pathological case where an observable's current value is itself (or similar reference cycle)
-
-function toJS (rootObject) {
-  if (arguments.length == 0) { throw new Error('When calling ko.toJS, pass the object you want to convert.') }
-
-    // We just unwrap everything at every level in the object graph
-  return mapJsObjectGraph(rootObject, function (valueToMap) {
-        // Loop because an observable's value might in turn be another observable wrapper
-    for (var i = 0; isObservable(valueToMap) && (i < maxNestedObservableDepth); i++) { valueToMap = valueToMap(); }
-    return valueToMap
-  })
-}
-
-function toJSON (rootObject, replacer, space) {     // replacer and space are optional
-  var plainJavaScriptObject = toJS(rootObject);
-  return JSON.stringify(plainJavaScriptObject, replacer, space)
-}
-
-function mapJsObjectGraph (rootObject, mapInputCallback, visitedObjects) {
-  visitedObjects = visitedObjects || new objectLookup();
-
-  rootObject = mapInputCallback(rootObject);
-  var canHaveProperties = (typeof rootObject === 'object') && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof RegExp)) && (!(rootObject instanceof Date)) && (!(rootObject instanceof String)) && (!(rootObject instanceof Number)) && (!(rootObject instanceof Boolean));
-  if (!canHaveProperties) { return rootObject }
-
-  var outputProperties = rootObject instanceof Array ? [] : {};
-  visitedObjects.save(rootObject, outputProperties);
-
-  visitPropertiesOrArrayEntries(rootObject, function (indexer) {
-    var propertyValue = mapInputCallback(rootObject[indexer]);
-
-    switch (typeof propertyValue) {
-      case 'boolean':
-      case 'number':
-      case 'string':
-      case 'function':
-        outputProperties[indexer] = propertyValue;
-        break
-      case 'object':
-      case 'undefined':
-        var previouslyMappedValue = visitedObjects.get(propertyValue);
-        outputProperties[indexer] = (previouslyMappedValue !== undefined)
-                ? previouslyMappedValue
-                : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
-        break
-    }
-  });
-
-  return outputProperties
-}
-
-function visitPropertiesOrArrayEntries (rootObject, visitorCallback) {
-  if (rootObject instanceof Array) {
-    for (var i = 0; i < rootObject.length; i++) { visitorCallback(i); }
-
-        // For arrays, also respect toJSON property for custom mappings (fixes #278)
-    if (typeof rootObject['toJSON'] === 'function') { visitorCallback('toJSON'); }
-  } else {
-    for (var propertyName in rootObject) {
-      visitorCallback(propertyName);
-    }
-  }
-}
-
-function objectLookup () {
-  this.keys = [];
-  this.values = [];
-}
-
-objectLookup.prototype = {
-  constructor: objectLookup,
-  save: function (key, value) {
-    var existingIndex = arrayIndexOf(this.keys, key);
-    if (existingIndex >= 0) { this.values[existingIndex] = value; } else {
-      this.keys.push(key);
-      this.values.push(value);
-    }
-  },
-  get: function (key) {
-    var existingIndex = arrayIndexOf(this.keys, key);
-    return (existingIndex >= 0) ? this.values[existingIndex] : undefined
-  }
-};
-
-//
-
-export { dependencyDetection, observable, isObservable, unwrap, peek, isWriteableObservable, isWriteableObservable as isWritableObservable, isSubscribable, subscribable, LATEST_VALUE, observableArray, isObservableArray, trackArrayChanges, arrayChangeEventName, toJS, toJSON, deferUpdates, valuesArePrimitiveAndEqual, applyExtenders, extenders };
-//# sourceMappingURL=observable.es6.js.map