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

package/dist/observable.js

@@ -1,915 +1,125 @@
-/*!
- * 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';
-
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */
-
-function __generator(thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-}
-
-function __values(o) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
-    if (m) return m.call(o);
-    return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-}
-
-function __read(o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-}
-
-function __spread() {
-    for (var ar = [], i = 0; i < arguments.length; i++)
-        ar = ar.concat(__read(arguments[i]));
-    return ar;
+// @tko/observable 🥊 4.0.0-beta1.0 ESM
+import {
+  options,
+  overwriteLengthPropertyIfSupported
+} from "@tko/utils";
+import * as dependencyDetection from "./dependencyDetection";
+import { deferUpdates } from "./defer";
+import { subscribable, defaultEvent, LATEST_VALUE } from "./subscribable";
+import { valuesArePrimitiveAndEqual } from "./extenders";
+export function observable(initialValue) {
+  function Observable() {
+    if (arguments.length > 0) {
+      if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {
+        Observable.valueWillMutate();
+        Observable[LATEST_VALUE] = arguments[0];
+        Observable.valueHasMutated();
+      }
+      return this;
+    } else {
+      dependencyDetection.registerDependency(Observable);
+      return Observable[LATEST_VALUE];
+    }
+  }
+  overwriteLengthPropertyIfSupported(Observable, { value: void 0 });
+  Observable[LATEST_VALUE] = initialValue;
+  subscribable.fn.init(Observable);
+  Object.setPrototypeOf(Observable, observable.fn);
+  if (options.deferUpdates) {
+    deferUpdates(Observable);
+  }
+  return Observable;
 }
-
-/**
- * Create a subscribable symbol that's used to identify subscribables.
- */
-var SUBSCRIBABLE_SYM = Symbol('Knockout Subscribable');
-function isSubscribable(instance) {
-    return (instance && instance[SUBSCRIBABLE_SYM]) || false;
+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, peek2 = true) {
+    return this(fn(peek2 ? this.peek() : this()));
+  },
+  isWriteable: true
+};
+function limitNotifySubscribers(value, event) {
+  if (!event || event === defaultEvent) {
+    this._limitChange(value);
+  } else if (event === "beforeChange") {
+    this._limitBeforeChange(value);
+  } else {
+    this._origNotifySubscribers(value, event);
+  }
 }
-
-//
-var outerFrames = [];
-var currentFrame;
-var 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;
-    }
+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 (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))) {
+        notifyNextChange = true;
+      }
+    },
+    _recordUpdate() {
+      didUpdate = true;
+    }
+  });
+};
+Object.setPrototypeOf(observable.fn, subscribable.fn);
+var protoProperty = observable.protoProperty = options.protoProperty;
+observable.fn[protoProperty] = observable;
+observable.observablePrototypes = /* @__PURE__ */ new Set([observable]);
+export 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;
 }
-
-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) {
-        var handle;
-        var ignoreUpdates = false;
-        return function () {
-            if (!ignoreUpdates) {
-                tasks.cancel(handle);
-                handle = tasks.schedule(callback);
-                try {
-                    ignoreUpdates = true;
-                    target.notifySubscribers(undefined, 'dirty');
-                }
-                finally {
-                    ignoreUpdates = false;
-                }
-            }
-        };
-    });
+export function unwrap(value) {
+  return isObservable(value) ? value() : value;
 }
-
-var Subscription = /** @class */ (function () {
-    function Subscription(target, observer, disposeCallback) {
-        this._target = target;
-        this._callback = observer.next;
-        this._disposeCallback = disposeCallback;
-        this._isDisposed = false;
-        this._domNodeDisposalCallback = null;
-    }
-    Subscription.prototype.dispose = function () {
-        if (this._domNodeDisposalCallback) {
-            removeDisposeCallback(this._node, this._domNodeDisposalCallback);
-        }
-        this._isDisposed = true;
-        this._disposeCallback();
-    };
-    Subscription.prototype.disposeWhenNodeIsRemoved = function (node) {
-        this._node = node;
-        addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
-    };
-    // TC39 Observable API
-    Subscription.prototype.unsubscribe = function () { this.dispose(); };
-    Object.defineProperty(Subscription.prototype, "closed", {
-        get: function () { return this._isDisposed; },
-        enumerable: true,
-        configurable: true
-    });
-    return Subscription;
-}());
-
-//
-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
-};
-
-var _a;
-// Descendants may have a LATEST_VALUE, which if present
-// causes TC39 subscriptions to emit the latest value when
-// subscribed.
-var 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 = (_a = {},
-    _a[SUBSCRIBABLE_SYM] = true,
-    _a[Symbol.observable] = function () { return this; },
-    _a.init = function (instance) {
-        instance._subscriptions = { change: [] };
-        instance._versionNumber = 1;
-    },
-    _a.subscribe = function (callback, callbackTarget, event) {
-        var _this = this;
-        // TC39 proposed standard Observable { next: () => ... }
-        var isTC39Callback = typeof callback === 'object' && callback.next;
-        event = event || defaultEvent;
-        var observer = isTC39Callback ? callback : {
-            next: callbackTarget ? callback.bind(callbackTarget) : callback
-        };
-        var subscriptionInstance = new Subscription(this, observer, function () {
-            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;
-    },
-    _a.notifySubscribers = function (valueToNotify, event) {
-        event = event || defaultEvent;
-        if (event === defaultEvent) {
-            this.updateVersion();
-        }
-        if (this.hasSubscriptionsForEvent(event)) {
-            var subs = event === defaultEvent && this._changeSubscriptions
-                || __spread(this._subscriptions[event]);
-            try {
-                begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)
-                for (var i = 0, subscriptionInstance = void 0; 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
-            }
-        }
-    },
-    _a.getVersion = function () {
-        return this._versionNumber;
-    },
-    _a.hasChanged = function (versionToCheck) {
-        return this.getVersion() !== versionToCheck;
-    },
-    _a.updateVersion = function () {
-        ++this._versionNumber;
-    },
-    _a.hasSubscriptionsForEvent = function (event) {
-        return this._subscriptions[event] && this._subscriptions[event].length;
-    },
-    _a.getSubscriptionsCount = function (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;
-        }
-    },
-    _a.isDifferent = function (oldValue, newValue) {
-        return !this.equalityComparer ||
-            !this.equalityComparer(oldValue, newValue);
-    },
-    _a.once = function (cb) {
-        var subs = this.subscribe(function (nv) {
-            subs.dispose();
-            cb(nv);
-        });
-    },
-    _a.when = function (test, returnValue) {
-        var _this = this;
-        var current = this.peek();
-        var givenRv = arguments.length > 1;
-        var testFn = typeof test === 'function' ? test : function (v) { return v === test; };
-        if (testFn(current)) {
-            return options.Promise.resolve(givenRv ? returnValue : current);
-        }
-        return new options.Promise(function (resolve, reject) {
-            var subs = _this.subscribe(function (newValue) {
-                if (testFn(newValue)) {
-                    subs.dispose();
-                    resolve(givenRv ? returnValue : newValue);
-                }
-            });
-        });
-    },
-    _a.yet = function (test) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var testFn = typeof test === 'function' ? test : function (v) { return v === test; };
-        var negated = function (v) { return !testFn(v); };
-        return this.when.apply(this, __spread([negated], args));
-    },
-    _a.next = function () {
-        var _this = this;
-        return new Promise(function (resolve) { return _this.once(resolve); });
-    },
-    _a.toString = function () { return '[object Object]'; },
-    _a.extend = applyExtenders,
-    _a);
-// 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: function () { return this[LATEST_VALUE]; },
-    valueHasMutated: function () {
-        this.notifySubscribers(this[LATEST_VALUE], 'spectate');
-        this.notifySubscribers(this[LATEST_VALUE]);
-    },
-    valueWillMutate: function () {
-        this.notifySubscribers(this[LATEST_VALUE], 'beforeChange');
-    },
-    modify: function (fn, peek) {
-        if (peek === void 0) { 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();
-        }
-        var shouldNotify = notifyNextChange || (didUpdate && self.isDifferent(previousValue, pendingValue));
-        self._notifyNextChange = didUpdate = ignoreBeforeChange = false;
-        if (shouldNotify) {
-            self._origNotifySubscribers(previousValue = pendingValue);
-        }
-    });
-    Object.assign(self, {
-        _limitChange: function (value, isDirty) {
-            if (!isDirty || !self._notificationIsPending) {
-                didUpdate = !isDirty;
-            }
-            self._changeSubscriptions = __spread(self._subscriptions[defaultEvent]);
-            self._notificationIsPending = ignoreBeforeChange = true;
-            pendingValue = value;
-            finish();
-        },
-        _limitBeforeChange: function (value) {
-            if (!ignoreBeforeChange) {
-                previousValue = value;
-                self._origNotifySubscribers(value, beforeChange);
-            }
-        },
-        _notifyNextChangeIfValueIsDifferent: function () {
-            if (self.isDifferent(previousValue, self.peek(true /* evaluate */))) {
-                notifyNextChange = true;
-            }
-        },
-        _recordUpdate: function () {
-            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) {
-    var 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;
+export function peek(value) {
+  return isObservable(value) ? value.peek() : value;
 }
-
-//
-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;
-    }
-    var trackingChanges = false;
-    var cachedDiff = null;
-    var arrayChangeSubscription;
-    var pendingNotifications = 0;
-    var underlyingNotifySubscribersFunction;
-    var underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
-    var 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) {
-            var 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 (var 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 (var 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;
-
-var _a$1;
-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: function () { return result().length; } });
-    return result;
-}
-function isObservableArray(instance) {
-    return isObservable(instance) && typeof instance.remove === 'function' && typeof instance.push === 'function';
-}
-observableArray.fn = (_a$1 = {
-        remove: function (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: function (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: function (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: function (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: function (item) {
-            return arrayIndexOf(this(), item);
-        },
-        replace: function (oldItem, newItem) {
-            var index = this.indexOf(oldItem);
-            if (index >= 0) {
-                this.valueWillMutate();
-                this.peek()[index] = newItem;
-                this.valueHasMutated();
-            }
-        },
-        sorted: function (compareFn) {
-            return __spread(this()).sort(compareFn);
-        },
-        reversed: function () {
-            return __spread(this()).reverse();
-        }
-    },
-    _a$1[Symbol.iterator] = function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [5 /*yield**/, __values(this())];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    },
-    _a$1);
-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) {
-    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.js.map
+export function isWriteableObservable(instance) {
+  return isObservable(instance) && instance.isWriteable;
+}
+export { isWriteableObservable as isWritableObservable };