@tko/observable 4.0.0-beta1.0 → 4.0.0

package/dist/mappingHelpers.js

@@ -1,31 +1,32 @@
-// @tko/observable 🥊 4.0.0-beta1.0 ESM
+// @tko/observable 🥊 4.0.0 ESM
+"use strict";
 import { isObservable } from "./observable";
-var maxNestedObservableDepth = 10;
+const maxNestedObservableDepth = 10;
 export function toJS(rootObject) {
   if (arguments.length == 0) {
     throw new Error("When calling ko.toJS, pass the object you want to convert.");
   }
   return mapJsObjectGraph(rootObject, function(valueToMap) {
-    for (var i = 0; isObservable(valueToMap) && i < maxNestedObservableDepth; i++) {
+    for (let i = 0; isObservable(valueToMap) && i < maxNestedObservableDepth; i++) {
       valueToMap = valueToMap();
     }
     return valueToMap;
   });
 }
 export function toJSON(rootObject, replacer, space) {
-  var plainJavaScriptObject = toJS(rootObject);
+  const plainJavaScriptObject = toJS(rootObject);
   return JSON.stringify(plainJavaScriptObject, replacer, space);
 }
 function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects = /* @__PURE__ */ new Map()) {
   rootObject = mapInputCallback(rootObject);
-  var canHaveProperties = typeof rootObject === "object" && rootObject !== null && rootObject !== void 0 && !(rootObject instanceof RegExp) && !(rootObject instanceof Date) && !(rootObject instanceof String) && !(rootObject instanceof Number) && !(rootObject instanceof Boolean);
+  const canHaveProperties = typeof rootObject === "object" && rootObject !== null && rootObject !== void 0 && !(rootObject instanceof RegExp) && !(rootObject instanceof Date) && !(rootObject instanceof String) && !(rootObject instanceof Number) && !(rootObject instanceof Boolean);
   if (!canHaveProperties) {
     return rootObject;
   }
-  var outputProperties = rootObject instanceof Array ? [] : {};
+  const outputProperties = rootObject instanceof Array ? [] : {};
   visitedObjects.set(rootObject, outputProperties);
   visitPropertiesOrArrayEntries(rootObject, function(indexer) {
-    var propertyValue = mapInputCallback(rootObject[indexer]);
+    const propertyValue = mapInputCallback(rootObject[indexer]);
     switch (typeof propertyValue) {
       case "boolean":
       case "number":
@@ -35,8 +36,10 @@ function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects = /* @__P
         break;
       case "object":
       case "undefined":
-        var previouslyMappedValue = visitedObjects.get(propertyValue);
-        outputProperties[indexer] = previouslyMappedValue !== void 0 ? previouslyMappedValue : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
+        {
+          const previouslyMappedValue = visitedObjects.get(propertyValue);
+          outputProperties[indexer] = previouslyMappedValue !== void 0 ? previouslyMappedValue : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
+        }
         break;
     }
   });
@@ -44,14 +47,14 @@ function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects = /* @__P
 }
 function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
   if (rootObject instanceof Array) {
-    for (var i = 0; i < rootObject.length; i++) {
+    for (let i = 0; i < rootObject.length; i++) {
       visitorCallback(i);
     }
     if (typeof rootObject["toJSON"] === "function") {
       visitorCallback("toJSON");
     }
   } else {
-    for (var propertyName in rootObject) {
+    for (const propertyName in rootObject) {
       visitorCallback(propertyName);
     }
   }

package/dist/mappingHelpers.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/mappingHelpers.ts"],
-  "sourcesContent": ["//\n// Helpers\n// ---\n// toJS & toJSON\n//\n\nimport { isObservable } from './observable'\n\nvar maxNestedObservableDepth = 10 // Escape the (unlikely) pathological case where an observable's current value is itself (or similar reference cycle)\n\nexport function toJS (rootObject) {\n  if (arguments.length == 0) { throw new Error('When calling ko.toJS, pass the object you want to convert.') }\n\n    // We just unwrap everything at every level in the object graph\n  return mapJsObjectGraph(rootObject, function (valueToMap) {\n        // Loop because an observable's value might in turn be another observable wrapper\n    for (var i = 0; isObservable(valueToMap) && (i < maxNestedObservableDepth); i++) { valueToMap = valueToMap() }\n    return valueToMap\n  })\n}\n\nexport function toJSON (rootObject, replacer, space) {     // replacer and space are optional\n  var plainJavaScriptObject = toJS(rootObject)\n  return JSON.stringify(plainJavaScriptObject, replacer, space)\n}\n\nfunction mapJsObjectGraph (rootObject, mapInputCallback, visitedObjects = new Map()) {\n  rootObject = mapInputCallback(rootObject)\n  var canHaveProperties = (typeof rootObject === 'object') && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof RegExp)) && (!(rootObject instanceof Date)) && (!(rootObject instanceof String)) && (!(rootObject instanceof Number)) && (!(rootObject instanceof Boolean))\n  if (!canHaveProperties) { return rootObject }\n\n  var outputProperties = rootObject instanceof Array ? [] : {}\n  visitedObjects.set(rootObject, outputProperties)\n\n  visitPropertiesOrArrayEntries(rootObject, function (indexer) {\n    var propertyValue = mapInputCallback(rootObject[indexer])\n\n    switch (typeof propertyValue) {\n      case 'boolean':\n      case 'number':\n      case 'string':\n      case 'function':\n        outputProperties[indexer] = propertyValue\n        break\n      case 'object':\n      case 'undefined':\n        var previouslyMappedValue = visitedObjects.get(propertyValue)\n        outputProperties[indexer] = (previouslyMappedValue !== undefined)\n                ? previouslyMappedValue\n                : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects)\n        break\n    }\n  })\n\n  return outputProperties\n}\n\nfunction visitPropertiesOrArrayEntries (rootObject, visitorCallback) {\n  if (rootObject instanceof Array) {\n    for (var i = 0; i < rootObject.length; i++) { visitorCallback(i) }\n\n        // For arrays, also respect toJSON property for custom mappings (fixes #278)\n    if (typeof rootObject['toJSON'] === 'function') { visitorCallback('toJSON') }\n  } else {\n    for (var propertyName in rootObject) {\n      visitorCallback(propertyName)\n    }\n  }\n}\n"],
-  "mappings": ";AAMA;AAEA,IAAI,2BAA2B;AAExB,qBAAe,YAAY;AAChC,MAAI,UAAU,UAAU,GAAG;AAAE,UAAM,IAAI,MAAM,4DAA4D;AAAA,EAAE;AAG3G,SAAO,iBAAiB,YAAY,SAAU,YAAY;AAExD,aAAS,IAAI,GAAG,aAAa,UAAU,KAAM,IAAI,0BAA2B,KAAK;AAAE,mBAAa,WAAW;AAAA,IAAE;AAC7G,WAAO;AAAA,EACT,CAAC;AACH;AAEO,uBAAiB,YAAY,UAAU,OAAO;AACnD,MAAI,wBAAwB,KAAK,UAAU;AAC3C,SAAO,KAAK,UAAU,uBAAuB,UAAU,KAAK;AAC9D;AAEA,0BAA2B,YAAY,kBAAkB,iBAAiB,oBAAI,IAAI,GAAG;AACnF,eAAa,iBAAiB,UAAU;AACxC,MAAI,oBAAqB,OAAO,eAAe,YAAc,eAAe,QAAU,eAAe,UAAe,CAAE,uBAAsB,WAAa,CAAE,uBAAsB,SAAW,CAAE,uBAAsB,WAAa,CAAE,uBAAsB,WAAa,CAAE,uBAAsB;AAC9R,MAAI,CAAC,mBAAmB;AAAE,WAAO;AAAA,EAAW;AAE5C,MAAI,mBAAmB,sBAAsB,QAAQ,CAAC,IAAI,CAAC;AAC3D,iBAAe,IAAI,YAAY,gBAAgB;AAE/C,gCAA8B,YAAY,SAAU,SAAS;AAC3D,QAAI,gBAAgB,iBAAiB,WAAW,QAAQ;AAExD,YAAQ,OAAO;AAAA,WACR;AAAA,WACA;AAAA,WACA;AAAA,WACA;AACH,yBAAiB,WAAW;AAC5B;AAAA,WACG;AAAA,WACA;AACH,YAAI,wBAAwB,eAAe,IAAI,aAAa;AAC5D,yBAAiB,WAAY,0BAA0B,SAC7C,wBACA,iBAAiB,eAAe,kBAAkB,cAAc;AAC1E;AAAA;AAAA,EAEN,CAAC;AAED,SAAO;AACT;AAEA,uCAAwC,YAAY,iBAAiB;AACnE,MAAI,sBAAsB,OAAO;AAC/B,aAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAAE,sBAAgB,CAAC;AAAA,IAAE;AAGjE,QAAI,OAAO,WAAW,cAAc,YAAY;AAAE,sBAAgB,QAAQ;AAAA,IAAE;AAAA,EAC9E,OAAO;AACL,aAAS,gBAAgB,YAAY;AACnC,sBAAgB,YAAY;AAAA,IAC9B;AAAA,EACF;AACF;",
+  "sourcesContent": ["//\n// Helpers\n// ---\n// toJS & toJSON\n//\n\nimport { isObservable } from './observable'\n\nconst maxNestedObservableDepth: number = 10 // Escape the (unlikely) pathological case where an observable's current value is itself (or similar reference cycle)\n\nexport function toJS<T = any>(rootObject: T): T {\n  if (arguments.length == 0) {\n    throw new Error('When calling ko.toJS, pass the object you want to convert.')\n  }\n\n  // We just unwrap everything at every level in the object graph\n  return mapJsObjectGraph(rootObject, function (valueToMap: any) {\n    // Loop because an observable's value might in turn be another observable wrapper\n    for (let i = 0; isObservable(valueToMap) && i < maxNestedObservableDepth; i++) {\n      valueToMap = valueToMap()\n    }\n    return valueToMap\n  })\n}\n\nexport function toJSON<T = any>(\n  rootObject: T,\n  replacer?: (key: string, value: any) => any,\n  space?: string | number\n): string {\n  // replacer and space are optional\n  const plainJavaScriptObject = toJS(rootObject)\n  return JSON.stringify(plainJavaScriptObject, replacer, space)\n}\n\nfunction mapJsObjectGraph<T = any>(\n  rootObject: T | undefined,\n  mapInputCallback: (value: any) => any,\n  visitedObjects = new Map()\n): any {\n  rootObject = mapInputCallback(rootObject)\n  const canHaveProperties =\n    typeof rootObject === 'object'\n    && rootObject !== null\n    && rootObject !== undefined\n    && !(rootObject instanceof RegExp)\n    && !(rootObject instanceof Date)\n    && !(rootObject instanceof String)\n    && !(rootObject instanceof Number)\n    && !(rootObject instanceof Boolean)\n  if (!canHaveProperties) {\n    return rootObject\n  }\n\n  const outputProperties: any = rootObject instanceof Array ? [] : {}\n  visitedObjects.set(rootObject, outputProperties)\n\n  visitPropertiesOrArrayEntries(rootObject, function (indexer: any) {\n    const propertyValue = mapInputCallback(rootObject![indexer])\n\n    switch (typeof propertyValue) {\n      case 'boolean':\n      case 'number':\n      case 'string':\n      case 'function':\n        outputProperties[indexer] = propertyValue\n        break\n      case 'object':\n      case 'undefined':\n        {\n          const previouslyMappedValue = visitedObjects.get(propertyValue)\n          outputProperties[indexer] =\n            previouslyMappedValue !== undefined\n              ? previouslyMappedValue\n              : mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects)\n        }\n        break\n    }\n  })\n\n  return outputProperties\n}\n\nfunction visitPropertiesOrArrayEntries<T = any>(rootObject: T, visitorCallback: (indexer: any) => void): void {\n  if (rootObject instanceof Array) {\n    for (let i = 0; i < rootObject.length; i++) {\n      visitorCallback(i)\n    }\n\n    // For arrays, also respect toJSON property for custom mappings (fixes #278)\n    if (typeof rootObject['toJSON'] === 'function') {\n      visitorCallback('toJSON')\n    }\n  } else {\n    for (const propertyName in rootObject) {\n      visitorCallback(propertyName)\n    }\n  }\n}\n"],
+  "mappings": ";;AAMA,SAAS,oBAAoB;AAE7B,MAAM,2BAAmC;AAElC,gBAAS,KAAc,YAAkB;AAC9C,MAAI,UAAU,UAAU,GAAG;AACzB,UAAM,IAAI,MAAM,4DAA4D;AAAA,EAC9E;AAGA,SAAO,iBAAiB,YAAY,SAAU,YAAiB;AAE7D,aAAS,IAAI,GAAG,aAAa,UAAU,KAAK,IAAI,0BAA0B,KAAK;AAC7E,mBAAa,WAAW;AAAA,IAC1B;AACA,WAAO;AAAA,EACT,CAAC;AACH;AAEO,gBAAS,OACd,YACA,UACA,OACQ;AAER,QAAM,wBAAwB,KAAK,UAAU;AAC7C,SAAO,KAAK,UAAU,uBAAuB,UAAU,KAAK;AAC9D;AAEA,SAAS,iBACP,YACA,kBACA,iBAAiB,oBAAI,IAAI,GACpB;AACL,eAAa,iBAAiB,UAAU;AACxC,QAAM,oBACJ,OAAO,eAAe,YACnB,eAAe,QACf,eAAe,UACf,EAAE,sBAAsB,WACxB,EAAE,sBAAsB,SACxB,EAAE,sBAAsB,WACxB,EAAE,sBAAsB,WACxB,EAAE,sBAAsB;AAC7B,MAAI,CAAC,mBAAmB;AACtB,WAAO;AAAA,EACT;AAEA,QAAM,mBAAwB,sBAAsB,QAAQ,CAAC,IAAI,CAAC;AAClE,iBAAe,IAAI,YAAY,gBAAgB;AAE/C,gCAA8B,YAAY,SAAU,SAAc;AAChE,UAAM,gBAAgB,iBAAiB,WAAY,OAAO,CAAC;AAE3D,YAAQ,OAAO,eAAe;AAAA,MAC5B,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AACH,yBAAiB,OAAO,IAAI;AAC5B;AAAA,MACF,KAAK;AAAA,MACL,KAAK;AACH;AACE,gBAAM,wBAAwB,eAAe,IAAI,aAAa;AAC9D,2BAAiB,OAAO,IACtB,0BAA0B,SACtB,wBACA,iBAAiB,eAAe,kBAAkB,cAAc;AAAA,QACxE;AACA;AAAA,IACJ;AAAA,EACF,CAAC;AAED,SAAO;AACT;AAEA,SAAS,8BAAuC,YAAe,iBAA+C;AAC5G,MAAI,sBAAsB,OAAO;AAC/B,aAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC1C,sBAAgB,CAAC;AAAA,IACnB;AAGA,QAAI,OAAO,WAAW,QAAQ,MAAM,YAAY;AAC9C,sBAAgB,QAAQ;AAAA,IAC1B;AAAA,EACF,OAAO;AACL,eAAW,gBAAgB,YAAY;AACrC,sBAAgB,YAAY;AAAA,IAC9B;AAAA,EACF;AACF;",
   "names": []
 }

package/dist/observable.js

@@ -1,8 +1,6 @@
-// @tko/observable 🥊 4.0.0-beta1.0 ESM
-import {
-  options,
-  overwriteLengthPropertyIfSupported
-} from "@tko/utils";
+// @tko/observable 🥊 4.0.0 ESM
+"use strict";
+import { options, overwriteLengthPropertyIfSupported } from "@tko/utils";
 import * as dependencyDetection from "./dependencyDetection";
 import { deferUpdates } from "./defer";
 import { subscribable, defaultEvent, LATEST_VALUE } from "./subscribable";
@@ -11,6 +9,7 @@ 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();
@@ -31,20 +30,43 @@ export function observable(initialValue) {
   return Observable;
 }
 observable.fn = {
+  /**
+   * Compares two values for equality.
+   * @param a The first value.
+   * @param b The second value.
+   * @returns True if the values are equal, otherwise false.
+   */
   equalityComparer: valuesArePrimitiveAndEqual,
+  /**
+   * Returns the current value of the observable without creating a dependency.
+   * @returns The current value.
+   */
   peek() {
     return this[LATEST_VALUE];
   },
+  /**
+   * Notifies subscribers that the value has changed.
+   */
   valueHasMutated() {
     this.notifySubscribers(this[LATEST_VALUE], "spectate");
     this.notifySubscribers(this[LATEST_VALUE]);
   },
+  /**
+   * Notifies subscribers that the value is about to change.
+   */
   valueWillMutate() {
     this.notifySubscribers(this[LATEST_VALUE], "beforeChange");
   },
+  /**
+   * Modifies the value of the observable using a function.
+   * @param fn The function to modify the value.
+   * @param peek Whether to use the current value without creating a dependency.
+   * @returns The modified observable.
+   */
   modify(fn, peek2 = true) {
-    return this(fn(peek2 ? this.peek() : this()));
+    this(fn(peek2 ? this.peek() : this()));
   },
+  // Some observables may not always be writeable, notably computeds.
   isWriteable: true
 };
 function limitNotifySubscribers(value, event) {
@@ -56,16 +78,17 @@ function limitNotifySubscribers(value, event) {
     this._origNotifySubscribers(value, event);
   }
 }
+;
 subscribable.fn.limit = function limit(limitFunction) {
-  var self = this;
-  var selfIsObservable = isObservable(self);
-  var beforeChange = "beforeChange";
-  var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
+  const self = this;
+  const selfIsObservable = isObservable(self);
+  const beforeChange = "beforeChange";
+  let ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate;
   if (!self._origNotifySubscribers) {
     self._origNotifySubscribers = self.notifySubscribers;
     self.notifySubscribers = limitNotifySubscribers;
   }
-  var finish = limitFunction(function() {
+  const finish = limitFunction(function() {
     self._notificationIsPending = false;
     if (selfIsObservable && pendingValue === self) {
       pendingValue = self._evalIfChanged ? self._evalIfChanged() : self();
@@ -93,7 +116,10 @@ subscribable.fn.limit = function limit(limitFunction) {
       }
     },
     _notifyNextChangeIfValueIsDifferent() {
-      if (self.isDifferent(previousValue, self.peek(true))) {
+      if (self.isDifferent(previousValue, self.peek(
+        true
+        /* evaluate */
+      ))) {
         notifyNextChange = true;
       }
     },
@@ -103,7 +129,7 @@ subscribable.fn.limit = function limit(limitFunction) {
   });
 };
 Object.setPrototypeOf(observable.fn, subscribable.fn);
-var protoProperty = observable.protoProperty = options.protoProperty;
+const protoProperty = observable.protoProperty = options.protoProperty;
 observable.fn[protoProperty] = observable;
 observable.observablePrototypes = /* @__PURE__ */ new Set([observable]);
 export function isObservable(instance) {

package/dist/observable.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/observable.ts"],
-  "sourcesContent": ["//\n//  Observable values\n//  ---\n//\nimport {\n  options, overwriteLengthPropertyIfSupported\n} from '@tko/utils'\n\nimport * as dependencyDetection from './dependencyDetection'\nimport { deferUpdates } from './defer'\nimport { subscribable, defaultEvent, LATEST_VALUE } from './subscribable'\nimport { valuesArePrimitiveAndEqual } from './extenders'\n\nexport function observable (initialValue) {\n  function Observable () {\n    if (arguments.length > 0) {\n            // Write\n            // Ignore writes if the value hasn't changed\n      if (Observable.isDifferent(Observable[LATEST_VALUE], arguments[0])) {\n        Observable.valueWillMutate()\n        Observable[LATEST_VALUE] = arguments[0]\n        Observable.valueHasMutated()\n      }\n      return this // Permits chained assignments\n    } else {\n            // Read\n      dependencyDetection.registerDependency(Observable) // The caller only needs to be notified of changes if they did a \"read\" operation\n      return Observable[LATEST_VALUE]\n    }\n  }\n\n  overwriteLengthPropertyIfSupported(Observable, { value: undefined })\n\n  Observable[LATEST_VALUE] = initialValue\n\n  subscribable.fn.init(Observable)\n\n    // Inherit from 'observable'\n  Object.setPrototypeOf(Observable, observable.fn)\n\n  if (options.deferUpdates) {\n    deferUpdates(Observable)\n  }\n\n  return Observable\n}\n\n// Define prototype for observables\nobservable.fn = {\n  equalityComparer: valuesArePrimitiveAndEqual,\n  peek () { return this[LATEST_VALUE] },\n  valueHasMutated () {\n    this.notifySubscribers(this[LATEST_VALUE], 'spectate')\n    this.notifySubscribers(this[LATEST_VALUE])\n  },\n  valueWillMutate () {\n    this.notifySubscribers(this[LATEST_VALUE], 'beforeChange')\n  },\n\n  modify (fn, peek = true) {\n    return this(fn(peek ? this.peek() : this()))\n  },\n\n  // Some observables may not always be writeable, notably computeds.\n  isWriteable: true\n}\n\n// Moved out of \"limit\" to avoid the extra closure\nfunction limitNotifySubscribers (value, event) {\n  if (!event || event === defaultEvent) {\n    this._limitChange(value)\n  } else if (event === 'beforeChange') {\n    this._limitBeforeChange(value)\n  } else {\n    this._origNotifySubscribers(value, event)\n  }\n}\n\n// Add `limit` function to the subscribable prototype\nsubscribable.fn.limit = function limit (limitFunction) {\n  var self = this\n  var selfIsObservable = isObservable(self)\n  var beforeChange = 'beforeChange'\n  var ignoreBeforeChange, notifyNextChange, previousValue, pendingValue, didUpdate\n\n  if (!self._origNotifySubscribers) {\n    self._origNotifySubscribers = self.notifySubscribers\n    self.notifySubscribers = limitNotifySubscribers\n  }\n\n  var finish = limitFunction(function () {\n    self._notificationIsPending = false\n\n    // If an observable provided a reference to itself, access it to get the latest value.\n    // This allows computed observables to delay calculating their value until needed.\n    if (selfIsObservable && pendingValue === self) {\n      pendingValue = self._evalIfChanged ? self._evalIfChanged() : self()\n    }\n    const shouldNotify = notifyNextChange || (\n      didUpdate && self.isDifferent(previousValue, pendingValue)\n    )\n    self._notifyNextChange = didUpdate = ignoreBeforeChange = false\n    if (shouldNotify) {\n      self._origNotifySubscribers(previousValue = pendingValue)\n    }\n  })\n\n  Object.assign(self, {\n    _limitChange  (value, isDirty) {\n      if (!isDirty || !self._notificationIsPending) {\n        didUpdate = !isDirty\n      }\n      self._changeSubscriptions = [...self._subscriptions[defaultEvent]]\n      self._notificationIsPending = ignoreBeforeChange = true\n      pendingValue = value\n      finish()\n    },\n\n    _limitBeforeChange (value) {\n      if (!ignoreBeforeChange) {\n        previousValue = value\n        self._origNotifySubscribers(value, beforeChange)\n      }\n    },\n\n    _notifyNextChangeIfValueIsDifferent () {\n      if (self.isDifferent(previousValue, self.peek(true /* evaluate */))) {\n        notifyNextChange = true\n      }\n    },\n\n    _recordUpdate () {\n      didUpdate = true\n    }\n  })\n}\n\nObject.setPrototypeOf(observable.fn, subscribable.fn)\n\nvar protoProperty = observable.protoProperty = options.protoProperty\nobservable.fn[protoProperty] = observable\n\n// Subclasses can add themselves to observableProperties so that\n// isObservable will be `true`.\nobservable.observablePrototypes = new Set([observable])\n\nexport function isObservable (instance) {\n  const proto = typeof instance === 'function' && instance[protoProperty]\n  if (proto && !observable.observablePrototypes.has(proto)) {\n    throw Error('Invalid object that looks like an observable; possibly from another Knockout instance')\n  }\n  return !!proto\n}\n\nexport function unwrap (value) {\n  return isObservable(value) ? value() : value\n}\n\nexport function peek (value) {\n  return isObservable(value) ? value.peek() : value\n}\n\nexport function isWriteableObservable (instance) {\n  return isObservable(instance) && instance.isWriteable\n}\n\nexport { isWriteableObservable as isWritableObservable }\n"],
-  "mappings": "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",
-  "names": []
+  "sourcesContent": ["//\n//  Observable values\n//  ---\n//\nimport { options, overwriteLengthPropertyIfSupported } from '@tko/utils'\n\nimport * as dependencyDetection from './dependencyDetection'\nimport { deferUpdates } from './defer'\nimport { subscribable, defaultEvent, LATEST_VALUE } from './subscribable'\nimport { valuesArePrimitiveAndEqual } from './extenders'\nimport type { Subscribable, MaybeSubscribable } from './subscribable'\n\n/**\n * Represents a value that can be either a plain value or an observable.\n */\nexport type MaybeObservable<T = any> = T | Observable<T>\n\n/**\n * Defines the functions available on an observable.\n */\nexport interface ObservableFunctions<T = any> extends Subscribable<T> {\n  /**\n   * Compares two values for equality.\n   * @param a The first value.\n   * @param b The second value.\n   * @returns True if the values are equal, otherwise false.\n   */\n  equalityComparer(a: T, b: T): boolean\n\n  /**\n   * Returns the current value of the observable without creating a dependency.\n   * @returns The current value.\n   */\n  peek(): T\n\n  /**\n   * Notifies subscribers that the value has changed.\n   */\n  valueHasMutated(): void\n\n  /**\n   * Notifies subscribers that the value is about to change.\n   */\n  valueWillMutate(): void\n\n  /**\n   * Modifies the value of the observable using a function.\n   * @param fn The function to modify the value.\n   * @param peek Whether to use the current value without creating a dependency.\n   */\n  modify(fn: (v: T) => T, peek?: boolean)\n\n  /**\n   * Some observables may not always be writeable, notably computeds.\n   */\n  isWriteable: boolean\n}\n\n/**\n * Represents an observable value.\n */\nexport interface Observable<T = any> extends ObservableFunctions<T> {\n  /**\n   * The latest value of the observable.\n   */\n  [LATEST_VALUE]: any;\n\n  /**\n   * Gets the current value of the observable.\n   * @returns The current value.\n   */\n  (): T\n\n  /**\n   * Sets the value of the observable.\n   * @param value The new value.\n   * @returns The observable.\n   */\n  (value: T): any\n}\n\n/**\n * Creates an observable object.\n * @param initialValue The initial value of the observable.\n * @returns The observable object.\n */\nexport function observable<T = any>(initialValue?: T): Observable {\n  function Observable() {\n    if (arguments.length > 0) {\n      // Write\n      // Ignore writes if the value hasn't changed\n      // inherits from interface SubscribableFunctions\n      if ((Observable as any).isDifferent(Observable[LATEST_VALUE], arguments[0])) {\n        ;(Observable as any).valueWillMutate()\n        Observable[LATEST_VALUE] = arguments[0]\n        ;(Observable as any).valueHasMutated()\n      }\n      return this // Permits chained assignments\n    } else {\n      // Read\n      dependencyDetection.registerDependency(Observable) // The caller only needs to be notified of changes if they did a \"read\" operation\n      return Observable[LATEST_VALUE]\n    }\n  }\n\n  overwriteLengthPropertyIfSupported(Observable as any, { value: undefined })\n\n  Observable[LATEST_VALUE] = initialValue\n\n  subscribable.fn.init(Observable)\n\n  // Inherit from 'observable'\n  Object.setPrototypeOf(Observable, observable.fn)\n\n  if (options.deferUpdates) {\n    deferUpdates(Observable)\n  }\n\n  // through setPrototypeOf we can cast to Observable\n  return Observable as unknown as Observable\n}\n\n/**\n * Defines prototype for observables.\n */\nobservable.fn = {\n  /**\n   * Compares two values for equality.\n   * @param a The first value.\n   * @param b The second value.\n   * @returns True if the values are equal, otherwise false.\n   */\n  equalityComparer: valuesArePrimitiveAndEqual,\n\n  /**\n   * Returns the current value of the observable without creating a dependency.\n   * @returns The current value.\n   */\n  peek() {\n    return this[LATEST_VALUE]\n  },\n\n  /**\n   * Notifies subscribers that the value has changed.\n   */\n  valueHasMutated() {\n    this.notifySubscribers(this[LATEST_VALUE], 'spectate')\n    this.notifySubscribers(this[LATEST_VALUE])\n  },\n\n  /**\n   * Notifies subscribers that the value is about to change.\n   */\n  valueWillMutate() {\n    this.notifySubscribers(this[LATEST_VALUE], 'beforeChange')\n  },\n\n  /**\n   * Modifies the value of the observable using a function.\n   * @param fn The function to modify the value.\n   * @param peek Whether to use the current value without creating a dependency.\n   * @returns The modified observable.\n   */\n  modify<T = any>(fn: (v: T) => T, peek = true) {\n    this(fn(peek ? this.peek() : this()))\n  },\n\n  // Some observables may not always be writeable, notably computeds.\n  isWriteable: true\n}\n\n/**\n * Limits the notifications to subscribers.\n * @param value The value to notify.\n * @param event The event type.\n */\nfunction limitNotifySubscribers(value, event?: string) {\n  if (!event || event === defaultEvent) {\n    this._limitChange(value)\n  } else if (event === 'beforeChange') {\n    this._limitBeforeChange(value)\n  } else {\n    this._origNotifySubscribers(value, event)\n  }\n}\n\n/**\n * Adds a limit function to the subscribable prototype.\n * @param limitFunction The function to limit notifications.\n */\n;(subscribable.fn as any).limit = function limit(limitFunction) {\n  const self = this\n  const selfIsObservable = isObservable(self)\n  const beforeChange = 'beforeChange'\n  let ignoreBeforeChange: boolean, notifyNextChange: boolean, previousValue: any, pendingValue: any, didUpdate: boolean\n\n  if (!self._origNotifySubscribers) {\n    // Moved out of \"limit\" to avoid the extra closure\n    self._origNotifySubscribers = self.notifySubscribers\n    self.notifySubscribers = limitNotifySubscribers\n  }\n\n  const finish = limitFunction(function () {\n    self._notificationIsPending = false\n\n    // If an observable provided a reference to itself, access it to get the latest value.\n    // This allows computed observables to delay calculating their value until needed.\n    if (selfIsObservable && pendingValue === self) {\n      //TODO This cast is a downcast to \"Computed\" that should be revisited\n      pendingValue = (self as any)._evalIfChanged ? (self as any)._evalIfChanged() : self()\n    }\n    const shouldNotify = notifyNextChange || (didUpdate && self.isDifferent(previousValue, pendingValue))\n    self._notifyNextChange = didUpdate = ignoreBeforeChange = false\n    if (shouldNotify) {\n      self._origNotifySubscribers((previousValue = pendingValue))\n    }\n  })\n\n  Object.assign(self, {\n    _limitChange(value: any, isDirty: boolean) {\n      if (!isDirty || !self._notificationIsPending) {\n        didUpdate = !isDirty\n      }\n      self._changeSubscriptions = [...self._subscriptions[defaultEvent]]\n      self._notificationIsPending = ignoreBeforeChange = true\n      pendingValue = value\n      finish()\n    },\n\n    _limitBeforeChange(value: any) {\n      if (!ignoreBeforeChange) {\n        previousValue = value\n        self._origNotifySubscribers(value, beforeChange)\n      }\n    },\n\n    _notifyNextChangeIfValueIsDifferent() {\n      if (self.isDifferent(previousValue, self.peek(true /* evaluate */))) {\n        notifyNextChange = true\n      }\n    },\n\n    _recordUpdate() {\n      didUpdate = true\n    }\n  })\n}\n\nObject.setPrototypeOf(observable.fn, subscribable.fn)\n\nconst protoProperty = (observable.protoProperty = options.protoProperty)\nobservable.fn[protoProperty] = observable\n\n// Subclasses can add themselves to observableProperties so that\n// isObservable will be `true`.\nobservable.observablePrototypes = new Set([observable])\n\n/**\n * Checks if an instance is an observable.\n * @param instance The instance to check.\n * @returns True if the instance is an observable, otherwise false.\n */\nexport function isObservable<T = any>(instance: any): instance is Observable<T> {\n  const proto = typeof instance === 'function' && instance[protoProperty]\n  if (proto && !observable.observablePrototypes.has(proto)) {\n    throw Error('Invalid object that looks like an observable; possibly from another Knockout instance')\n  }\n  return !!proto\n}\n\n/**\n * Unwraps the value if it is an observable.\n * @param value The value to unwrap.\n * @returns The unwrapped value.\n */\nexport function unwrap<T = any>(value: MaybeObservable<T>): T {\n  return isObservable<T>(value) ? value() : (value as T)\n}\n\n/**\n * Peeks at the value of a MaybeSubscribable without creating a dependency.\n * @param value The value to peek at.\n * @returns The peeked value.\n */\nexport function peek<T = any>(value: MaybeSubscribable<T>): T {\n  return isObservable<T>(value) ? value.peek() : (value as T)\n}\n\n/**\n * Checks if an instance is a writeable observable.\n * @param instance The instance to check.\n * @returns True if the instance is a writeable observable, otherwise false.\n */\nexport function isWriteableObservable<T = any>(instance: any): instance is Observable<T> {\n  return isObservable<T>(instance) && instance.isWriteable\n}\n\nexport { isWriteableObservable as isWritableObservable }\n"],
+  "mappings": "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",
+  "names": ["peek"]
 }

package/dist/observableArray.changeTracking.js

@@ -1,12 +1,9 @@
-// @tko/observable 🥊 4.0.0-beta1.0 ESM
-import {
-  extend,
-  compareArrays,
-  findMovesInArrayComparison
-} from "@tko/utils";
+// @tko/observable 🥊 4.0.0 ESM
+"use strict";
+import { extend, compareArrays, findMovesInArrayComparison } from "@tko/utils";
 import { defaultEvent } from "./subscribable";
 import { extenders } from "./extenders";
-export var arrayChangeEventName = "arrayChange";
+export const arrayChangeEventName = "arrayChange";
 export function trackArrayChanges(target, options) {
   target.compareArrayOptions = {};
   if (options && typeof options === "object") {
@@ -21,8 +18,8 @@ export function trackArrayChanges(target, options) {
   let arrayChangeSubscription;
   let pendingNotifications = 0;
   let underlyingNotifySubscribersFunction;
-  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
-  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
+  const underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
+  const underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
   target.beforeSubscriptionAdd = function(event) {
     if (underlyingBeforeSubscriptionAddFunction) {
       underlyingBeforeSubscriptionAddFunction.call(target, event);
@@ -59,11 +56,11 @@ export function trackArrayChanges(target, options) {
       }
       return underlyingNotifySubscribersFunction.apply(this, arguments);
     };
-    var previousContents = [].concat(target.peek() === void 0 ? [] : target.peek());
+    let previousContents = new Array().concat(target.peek() === void 0 ? [] : target.peek());
     cachedDiff = null;
     arrayChangeSubscription = target.subscribe(function(currentContents) {
       let changes;
-      currentContents = [].concat(currentContents || []);
+      currentContents = new Array().concat(currentContents || []);
       if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
         changes = getChanges(previousContents, currentContents);
       }
@@ -85,9 +82,9 @@ export function trackArrayChanges(target, options) {
     if (!trackingChanges || pendingNotifications) {
       return;
     }
-    var diff = [], arrayLength = rawArray.length, argsLength = args.length, offset = 0;
+    let diff = new Array(), arrayLength = rawArray.length, argsLength = args.length, offset = 0;
     function pushDiff(status, value, index) {
-      return diff[diff.length] = { "status": status, "value": value, "index": index };
+      return diff[diff.length] = { status, value, index };
     }
     switch (operationName) {
       case "push":
@@ -105,16 +102,18 @@ export function trackArrayChanges(target, options) {
         }
         break;
       case "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));
+        {
+          const 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 = new Array(), deletions = new Array();
+          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);
         }
-        findMovesInArrayComparison(deletions, additions);
         break;
       default:
         return;

package/dist/observableArray.changeTracking.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/observableArray.changeTracking.ts"],
-  "sourcesContent": ["//\n// Observable Array - Change Tracking Extender\n// ---\n//\n/* eslint no-fallthrough: 0 */\n\nimport {\n    extend, compareArrays, findMovesInArrayComparison\n} from '@tko/utils'\n\nimport { defaultEvent } from './subscribable'\nimport { extenders } from './extenders'\n\nexport var arrayChangeEventName = 'arrayChange'\n\nexport function trackArrayChanges (target, options) {\n    // Use the provided options--each call to trackArrayChanges overwrites the previously set options\n  target.compareArrayOptions = {}\n  if (options && typeof options === 'object') {\n    extend(target.compareArrayOptions, options)\n  }\n  target.compareArrayOptions.sparse = true\n\n    // Only modify the target observable once\n  if (target.cacheDiffForKnownOperation) {\n    return\n  }\n  let trackingChanges = false\n  let cachedDiff = null\n  let arrayChangeSubscription\n  let pendingNotifications = 0\n  let underlyingNotifySubscribersFunction\n  let underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd\n  let underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove\n\n    // Watch \"subscribe\" calls, and for array change events, ensure change tracking is enabled\n  target.beforeSubscriptionAdd = function (event) {\n    if (underlyingBeforeSubscriptionAddFunction) {\n      underlyingBeforeSubscriptionAddFunction.call(target, event)\n    }\n    if (event === arrayChangeEventName) {\n      trackChanges()\n    }\n  }\n\n    // Watch \"dispose\" calls, and for array change events, ensure change tracking is disabled when all are disposed\n  target.afterSubscriptionRemove = function (event) {\n    if (underlyingAfterSubscriptionRemoveFunction) {\n      underlyingAfterSubscriptionRemoveFunction.call(target, event)\n    }\n    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {\n      if (underlyingNotifySubscribersFunction) {\n        target.notifySubscribers = underlyingNotifySubscribersFunction\n        underlyingNotifySubscribersFunction = undefined\n      }\n      if (arrayChangeSubscription) {\n        arrayChangeSubscription.dispose()\n      }\n      arrayChangeSubscription = null\n      trackingChanges = false\n    }\n  }\n\n  function trackChanges () {\n        // Calling 'trackChanges' multiple times is the same as calling it once\n    if (trackingChanges) {\n      return\n    }\n\n    trackingChanges = true\n\n        // Intercept \"notifySubscribers\" to track how many times it was called.\n    underlyingNotifySubscribersFunction = target['notifySubscribers']\n    target.notifySubscribers = function (valueToNotify, event) {\n      if (!event || event === defaultEvent) {\n        ++pendingNotifications\n      }\n      return underlyingNotifySubscribersFunction.apply(this, arguments)\n    }\n\n        // Each time the array changes value, capture a clone so that on the next\n        // change it's possible to produce a diff\n    var previousContents = [].concat(target.peek() === undefined ? [] : target.peek())\n    cachedDiff = null\n    arrayChangeSubscription = target.subscribe(function (currentContents) {\n      let changes\n            // Make a copy of the current contents and ensure it's an array\n      currentContents = [].concat(currentContents || [])\n\n            // Compute the diff and issue notifications, but only if someone is listening\n      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {\n        changes = getChanges(previousContents, currentContents)\n      }\n\n            // Eliminate references to the old, removed items, so they can be GCed\n      previousContents = currentContents\n      cachedDiff = null\n      pendingNotifications = 0\n\n      if (changes && changes.length) {\n        target.notifySubscribers(changes, arrayChangeEventName)\n      }\n    })\n  }\n\n  function getChanges (previousContents, currentContents) {\n        // We try to re-use cached diffs.\n        // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates\n        // plugin, which without this check would not be compatible with arrayChange notifications. Normally,\n        // notifications are issued immediately so we wouldn't be queueing up more than one.\n    if (!cachedDiff || pendingNotifications > 1) {\n      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions)\n    }\n\n    return cachedDiff\n  }\n\n  target.cacheDiffForKnownOperation = function (rawArray, operationName, args) {\n      // Only run if we're currently tracking changes for this observable array\n      // and there aren't any pending deferred notifications.\n    if (!trackingChanges || pendingNotifications) {\n      return\n    }\n    var diff = [],\n      arrayLength = rawArray.length,\n      argsLength = args.length,\n      offset = 0\n\n    function pushDiff (status, value, index) {\n      return diff[diff.length] = { 'status': status, 'value': value, 'index': index }\n    }\n    switch (operationName) {\n      case 'push':\n        offset = arrayLength\n      case 'unshift':\n        for (let index = 0; index < argsLength; index++) {\n          pushDiff('added', args[index], offset + index)\n        }\n        break\n\n      case 'pop':\n        offset = arrayLength - 1\n      case 'shift':\n        if (arrayLength) {\n          pushDiff('deleted', rawArray[offset], offset)\n        }\n        break\n\n      case 'splice':\n            // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].\n            // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\n        var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),\n          endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),\n          endAddIndex = startIndex + argsLength - 2,\n          endIndex = Math.max(endDeleteIndex, endAddIndex),\n          additions = [], deletions = []\n        for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {\n          if (index < endDeleteIndex) { deletions.push(pushDiff('deleted', rawArray[index], index)) }\n          if (index < endAddIndex) { additions.push(pushDiff('added', args[argsIndex], index)) }\n        }\n        findMovesInArrayComparison(deletions, additions)\n        break\n\n      default:\n        return\n    }\n    cachedDiff = diff\n  }\n}\n\n// Expose compareArrays for testing.\ntrackArrayChanges.compareArrays = compareArrays\n\n// Add the trackArrayChanges extender so we can use\n// obs.extend({ trackArrayChanges: true })\nextenders.trackArrayChanges = trackArrayChanges\n"],
-  "mappings": "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",
+  "sourcesContent": ["//\n// Observable Array - Change Tracking Extender\n// ---\n//\n/* eslint no-fallthrough: 0 */\n\nimport { extend, compareArrays, findMovesInArrayComparison } from '@tko/utils'\n\nimport type { CompareArraysOptions } from '@tko/utils'\n\nimport { defaultEvent } from './subscribable'\nimport { extenders } from './extenders'\nimport type { ObservableArray } from './observableArray'\n\nexport const arrayChangeEventName = 'arrayChange'\n\nexport function trackArrayChanges(target: ObservableArray, options?: CompareArraysOptions) {\n  // Use the provided options--each call to trackArrayChanges overwrites the previously set options\n  target.compareArrayOptions = {}\n  if (options && typeof options === 'object') {\n    extend(target.compareArrayOptions, options)\n  }\n  target.compareArrayOptions.sparse = true\n\n  // Only modify the target observable once\n  if (target.cacheDiffForKnownOperation) {\n    return\n  }\n  let trackingChanges = false\n  let cachedDiff: any | null = null\n  let arrayChangeSubscription\n  let pendingNotifications = 0\n  let underlyingNotifySubscribersFunction\n  const underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd\n  const underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove\n\n  // Watch \"subscribe\" calls, and for array change events, ensure change tracking is enabled\n  target.beforeSubscriptionAdd = function (event) {\n    if (underlyingBeforeSubscriptionAddFunction) {\n      underlyingBeforeSubscriptionAddFunction.call(target, event)\n    }\n    if (event === arrayChangeEventName) {\n      trackChanges()\n    }\n  }\n\n  // Watch \"dispose\" calls, and for array change events, ensure change tracking is disabled when all are disposed\n  target.afterSubscriptionRemove = function (event) {\n    if (underlyingAfterSubscriptionRemoveFunction) {\n      underlyingAfterSubscriptionRemoveFunction.call(target, event)\n    }\n    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {\n      if (underlyingNotifySubscribersFunction) {\n        target.notifySubscribers = underlyingNotifySubscribersFunction\n        underlyingNotifySubscribersFunction = undefined\n      }\n      if (arrayChangeSubscription) {\n        arrayChangeSubscription.dispose()\n      }\n      arrayChangeSubscription = null\n      trackingChanges = false\n    }\n  }\n\n  function trackChanges() {\n    // Calling 'trackChanges' multiple times is the same as calling it once\n    if (trackingChanges) {\n      return\n    }\n\n    trackingChanges = true\n\n    // Intercept \"notifySubscribers\" to track how many times it was called.\n    underlyingNotifySubscribersFunction = target['notifySubscribers']\n    target.notifySubscribers = function (valueToNotify, event) {\n      if (!event || event === defaultEvent) {\n        ++pendingNotifications\n      }\n      return underlyingNotifySubscribersFunction.apply(this, arguments)\n    }\n\n    // Each time the array changes value, capture a clone so that on the next\n    // change it's possible to produce a diff\n    let previousContents = new Array().concat(target.peek() === undefined ? [] : target.peek())\n    cachedDiff = null\n    arrayChangeSubscription = target.subscribe(function (currentContents) {\n      let changes\n      // Make a copy of the current contents and ensure it's an array\n      currentContents = new Array().concat(currentContents || [])\n\n      // Compute the diff and issue notifications, but only if someone is listening\n      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {\n        changes = getChanges(previousContents, currentContents)\n      }\n\n      // Eliminate references to the old, removed items, so they can be GCed\n      previousContents = currentContents\n      cachedDiff = null\n      pendingNotifications = 0\n\n      if (changes && changes.length) {\n        target.notifySubscribers(changes, arrayChangeEventName)\n      }\n    })\n  }\n\n  function getChanges(previousContents, currentContents) {\n    // We try to re-use cached diffs.\n    // The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates\n    // plugin, which without this check would not be compatible with arrayChange notifications. Normally,\n    // notifications are issued immediately so we wouldn't be queueing up more than one.\n    if (!cachedDiff || pendingNotifications > 1) {\n      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions)\n    }\n\n    return cachedDiff\n  }\n\n  target.cacheDiffForKnownOperation = function (rawArray, operationName, args) {\n    // Only run if we're currently tracking changes for this observable array\n    // and there aren't any pending deferred notifications.\n    if (!trackingChanges || pendingNotifications) {\n      return\n    }\n    let diff = new Array(),\n      arrayLength = rawArray.length,\n      argsLength = args.length,\n      offset = 0\n\n    function pushDiff(status, value, index) {\n      return (diff[diff.length] = { status: status, value: value, index: index })\n    }\n    switch (operationName) {\n      case 'push':\n        offset = arrayLength\n      case 'unshift':\n        for (let index = 0; index < argsLength; index++) {\n          pushDiff('added', args[index], offset + index)\n        }\n        break\n\n      case 'pop':\n        offset = arrayLength - 1\n      case 'shift':\n        if (arrayLength) {\n          pushDiff('deleted', rawArray[offset], offset)\n        }\n        break\n\n      case 'splice':\n        {\n          // Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].\n          // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice\n          const startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),\n            endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),\n            endAddIndex = startIndex + argsLength - 2,\n            endIndex = Math.max(endDeleteIndex, endAddIndex),\n            additions = new Array(),\n            deletions = new Array()\n          for (let index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {\n            if (index < endDeleteIndex) {\n              deletions.push(pushDiff('deleted', rawArray[index], index))\n            }\n            if (index < endAddIndex) {\n              additions.push(pushDiff('added', args[argsIndex], index))\n            }\n          }\n          findMovesInArrayComparison(deletions, additions)\n        }\n        break\n\n      default:\n        return\n    }\n    cachedDiff = diff\n  }\n}\n\n// Expose compareArrays for testing.\ntrackArrayChanges.compareArrays = compareArrays\n\n// Add the trackArrayChanges extender so we can use\n// obs.extend({ trackArrayChanges: true })\nextenders.trackArrayChanges = trackArrayChanges\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/observableArray.js

@@ -1,20 +1,18 @@
-// @tko/observable 🥊 4.0.0-beta1.0 ESM
-import {
-  arrayIndexOf,
-  arrayForEach,
-  overwriteLengthPropertyIfSupported
-} from "@tko/utils";
+// @tko/observable 🥊 4.0.0 ESM
+"use strict";
+import { arrayIndexOf, arrayForEach, overwriteLengthPropertyIfSupported } from "@tko/utils";
 import { observable, isObservable } from "./observable";
 import { trackArrayChanges } from "./observableArray.changeTracking";
 export 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.");
+    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);
+  const result = Object.setPrototypeOf(observable(initialValues), observableArray.fn);
   trackArrayChanges(result);
-  overwriteLengthPropertyIfSupported(result, { get: () => result().length });
+  overwriteLengthPropertyIfSupported(result, { get: () => result()?.length });
   return result;
 }
 export function isObservableArray(instance) {
@@ -22,13 +20,13 @@ export function isObservableArray(instance) {
 }
 observableArray.fn = {
   remove(valueOrPredicate) {
-    var underlyingArray = this.peek();
-    var removedValues = [];
-    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
-      return value2 === valueOrPredicate;
+    const underlyingArray = this.peek();
+    const removedValues = new Array();
+    const predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value) {
+      return value === valueOrPredicate;
     };
-    for (var i = 0; i < underlyingArray.length; i++) {
-      var value = underlyingArray[i];
+    for (let i = 0; i < underlyingArray.length; i++) {
+      const value = underlyingArray[i];
       if (predicate(value)) {
         if (removedValues.length === 0) {
           this.valueWillMutate();
@@ -48,8 +46,8 @@ observableArray.fn = {
   },
   removeAll(arrayOfValues) {
     if (arrayOfValues === void 0) {
-      var underlyingArray = this.peek();
-      var allValues = underlyingArray.slice(0);
+      const underlyingArray = this.peek();
+      const allValues = underlyingArray.slice(0);
       this.valueWillMutate();
       underlyingArray.splice(0, underlyingArray.length);
       this.valueHasMutated();
@@ -63,13 +61,13 @@ observableArray.fn = {
     });
   },
   destroy(valueOrPredicate) {
-    var underlyingArray = this.peek();
-    var predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value2) {
-      return value2 === valueOrPredicate;
+    const underlyingArray = this.peek();
+    const 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];
+    for (let i = underlyingArray.length - 1; i >= 0; i--) {
+      const value = underlyingArray[i];
       if (predicate(value)) {
         value["_destroy"] = true;
       }
@@ -93,7 +91,7 @@ observableArray.fn = {
     return arrayIndexOf(this(), item);
   },
   replace(oldItem, newItem) {
-    var index = this.indexOf(oldItem);
+    const index = this.indexOf(oldItem);
     if (index >= 0) {
       this.valueWillMutate();
       this.peek()[index] = newItem;
@@ -113,17 +111,17 @@ observableArray.fn = {
 Object.setPrototypeOf(observableArray.fn, observable.fn);
 arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(methodName) {
   observableArray.fn[methodName] = function() {
-    var underlyingArray = this.peek();
+    const underlyingArray = this.peek();
     this.valueWillMutate();
     this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
-    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
+    const methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
     this.valueHasMutated();
     return methodCallResult === underlyingArray ? this : methodCallResult;
   };
 });
 arrayForEach(["slice"], function(methodName) {
   observableArray.fn[methodName] = function() {
-    var underlyingArray = this();
+    const underlyingArray = this();
     return underlyingArray[methodName].apply(underlyingArray, arguments);
   };
 });

package/dist/observableArray.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/observableArray.ts"],
-  "sourcesContent": ["//\n// Observable Arrays\n// ===\n//\nimport {\n    arrayIndexOf, arrayForEach, overwriteLengthPropertyIfSupported\n} from '@tko/utils'\n\nimport { observable, isObservable } from './observable'\n\nimport { trackArrayChanges } from './observableArray.changeTracking'\n\nexport function observableArray (initialValues) {\n  initialValues = initialValues || []\n\n  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.') }\n\n  var result = observable(initialValues)\n  Object.setPrototypeOf(result, observableArray.fn)\n  trackArrayChanges(result)\n        // ^== result.extend({ trackArrayChanges: true })\n  overwriteLengthPropertyIfSupported(result, { get: () => result().length })\n  return result\n}\n\nexport function isObservableArray (instance) {\n  return isObservable(instance) && typeof instance.remove === 'function' && typeof instance.push === 'function'\n}\n\nobservableArray.fn = {\n  remove (valueOrPredicate) {\n    var underlyingArray = this.peek()\n    var removedValues = []\n    var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate }\n    for (var i = 0; i < underlyingArray.length; i++) {\n      var value = underlyingArray[i]\n      if (predicate(value)) {\n        if (removedValues.length === 0) {\n          this.valueWillMutate()\n        }\n        if (underlyingArray[i] !== value) {\n          throw Error(\"Array modified during remove; cannot remove item\")\n        }\n        removedValues.push(value)\n        underlyingArray.splice(i, 1)\n        i--\n      }\n    }\n    if (removedValues.length) {\n      this.valueHasMutated()\n    }\n    return removedValues\n  },\n\n  removeAll (arrayOfValues) {\n        // If you passed zero args, we remove everything\n    if (arrayOfValues === undefined) {\n      var underlyingArray = this.peek()\n      var allValues = underlyingArray.slice(0)\n      this.valueWillMutate()\n      underlyingArray.splice(0, underlyingArray.length)\n      this.valueHasMutated()\n      return allValues\n    }\n        // If you passed an arg, we interpret it as an array of entries to remove\n    if (!arrayOfValues) {\n      return []\n    }\n    return this['remove'](function (value) {\n      return arrayIndexOf(arrayOfValues, value) >= 0\n    })\n  },\n\n  destroy (valueOrPredicate) {\n    var underlyingArray = this.peek()\n    var predicate = typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate }\n    this.valueWillMutate()\n    for (var i = underlyingArray.length - 1; i >= 0; i--) {\n      var value = underlyingArray[i]\n      if (predicate(value)) {\n        value['_destroy'] = true\n      }\n    }\n    this.valueHasMutated()\n  },\n\n  destroyAll (arrayOfValues) {\n        // If you passed zero args, we destroy everything\n    if (arrayOfValues === undefined) { return this.destroy(function () { return true }) }\n\n        // If you passed an arg, we interpret it as an array of entries to destroy\n    if (!arrayOfValues) {\n      return []\n    }\n    return this.destroy(function (value) {\n      return arrayIndexOf(arrayOfValues, value) >= 0\n    })\n  },\n\n  indexOf (item) {\n    return arrayIndexOf(this(), item)\n  },\n\n  replace (oldItem, newItem) {\n    var index = this.indexOf(oldItem)\n    if (index >= 0) {\n      this.valueWillMutate()\n      this.peek()[index] = newItem\n      this.valueHasMutated()\n    }\n  },\n\n  sorted (compareFn) {\n    return [...this()].sort(compareFn)\n  },\n\n  reversed () {\n    return [...this()].reverse()\n  },\n\n  [Symbol.iterator]: function * () {\n    yield * this()\n  }\n}\n\nObject.setPrototypeOf(observableArray.fn, observable.fn)\n\n// Populate ko.observableArray.fn with read/write functions from native arrays\n// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array\n// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale\narrayForEach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (methodName) {\n  observableArray.fn[methodName] = function () {\n        // Use \"peek\" to avoid creating a subscription in any computed that we're executing in the context of\n        // (for consistency with mutating regular observables)\n    var underlyingArray = this.peek()\n    this.valueWillMutate()\n    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments)\n    var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments)\n    this.valueHasMutated()\n        // The native sort and reverse methods return a reference to the array, but it makes more sense to return the observable array instead.\n    return methodCallResult === underlyingArray ? this : methodCallResult\n  }\n})\n\n// Populate ko.observableArray.fn with read-only functions from native arrays\narrayForEach(['slice'], function (methodName) {\n  observableArray.fn[methodName] = function () {\n    var underlyingArray = this()\n    return underlyingArray[methodName].apply(underlyingArray, arguments)\n  }\n})\n\n// Expose for testing.\nobservableArray.trackArrayChanges = trackArrayChanges\n"],
-  "mappings": "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",
+  "sourcesContent": ["//\n// Observable Arrays\n// ===\n//\nimport { arrayIndexOf, arrayForEach, overwriteLengthPropertyIfSupported } from '@tko/utils'\n\nimport type { CompareArraysOptions } from '@tko/utils'\n\nimport { observable, isObservable } from './observable'\n\nimport { trackArrayChanges } from './observableArray.changeTracking'\n\nimport type { Observable, ObservableFunctions } from './observable'\n\nexport type MaybeObservableArray<T = any> = T[] | ObservableArray<T>\n\nexport interface ObservableArrayFunctions<T = any> extends ObservableFunctions<T[]> {\n  /**\n   * Returns the index of the first occurrence of a value in an array.\n   * @param searchElement The value to locate in the array.\n   * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.\n   */\n  indexOf(searchElement: T, fromIndex?: number): number\n\n  /**\n   * Returns a section of an array.\n   * @param start The beginning of the specified portion of the array.\n   * @param end The end of the specified portion of the array. If omitted, all items after start are included\n   */\n  slice(start: number, end?: number): T[]\n\n  /**\n   * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.\n   * @param start The zero-based location in the array from which to start removing elements.\n   * @param deleteCount The number of elements to remove. Defaults to removing everything after `start`\n   * @param items Elements to insert into the array in place of the deleted elements.\n   */\n  splice(start: number, deleteCount?: number, ...items: T[]): T[]\n\n  /**\n   * Removes the last value from the array and returns it.\n   */\n  pop(): T\n  /**\n   * Adds a new item to the end of array.\n   * @param items Items to be added\n   */\n  push(...items: T[]): number\n  /**\n   * Removes the first value from the array and returns it.\n   */\n  shift(): T\n  /**\n   * Inserts a new item at the beginning of the array.\n   * @param items Items to be added\n   */\n  unshift(...items: T[]): number\n\n  /**\n   * Reverses the order of the array and returns the observableArray.\n   * Modifies the underlying array.\n   */\n  reverse(): this\n\n  /**\n   * Sorts the array contents and returns the observableArray.\n   * Modifies the underlying array.\n   */\n  sort(compareFunction?: (left: T, right: T) => number): this\n\n  /**\n   * Returns a reversed copy of the array.\n   * Does not modify the underlying array.\n   */\n  reversed(): T[]\n\n  /**\n   * Returns a reversed copy of the array.\n   * Does not modify the underlying array.\n   */\n  sorted(compareFunction?: (left: T, right: T) => number): T[]\n  /**\n   * Replaces the first value that equals oldItem with newItem\n   * @param oldItem Item to be replaced\n   * @param newItem Replacing item\n   */\n  replace(oldItem: T, newItem: T): void\n\n  /**\n   * Removes all values that equal item and returns them as an array.\n   * @param item The item to be removed\n   */\n  remove(item: T): T[]\n  /**\n   * Removes all values  and returns them as an array.\n   * @param removeFunction A function used to determine true if item should be removed and fasle otherwise\n   */\n  remove(removeFunction: (item: T) => boolean): T[]\n\n  /**\n   * Removes all values and returns them as an array.\n   */\n  removeAll(): T[]\n  /**\n   * Removes all values that equal any of the supplied items\n   * @param items Items to be removed\n   */\n  removeAll(items: T[]): T[]\n\n  // Ko specific Usually relevant to Ruby on Rails developers only\n  /**\n   * Finds any objects in the array that equal someItem and gives them a special property called _destroy with value true.\n   * Usually only relevant to Ruby on Rails development\n   * @param item Items to be marked with the property.\n   */\n  destroy(item: T): void\n  /**\n   * Finds any objects in the array filtered by a function and gives them a special property called _destroy with value true.\n   * Usually only relevant to Ruby on Rails development\n   * @param destroyFunction A function used to determine which items should be marked with the property.\n   */\n  destroy(destroyFunction: (item: T) => boolean): void\n\n  /**\n   * Gives a special property called _destroy with value true to all objects in the array.\n   * Usually only relevant to Ruby on Rails development\n   */\n  destroyAll(): void\n  /**\n   * Finds any objects in the array that equal supplied items and gives them a special property called _destroy with value true.\n   * Usually only relevant to Ruby on Rails development\n   * @param items\n   */\n  destroyAll(items: T[]): void\n}\n\nexport interface ObservableArray<T = any> extends Observable<T[]>, ObservableArrayFunctions<T> {\n  (value: T[] | null | undefined): this\n  compareArrayOptions?: CompareArraysOptions\n  cacheDiffForKnownOperation?: (rawArray: any[], operationName: string, args: any[]) => void\n}\n\nexport function observableArray<T = any>(initialValues?: T[]): ObservableArray<T> {\n  initialValues = initialValues || []\n\n  if (typeof initialValues !== 'object' || !('length' in initialValues)) {\n    throw new Error(\n      'The argument passed when initializing an observable array must be an array, or null, or undefined.'\n    )\n  }\n\n  const result = Object.setPrototypeOf(observable(initialValues), observableArray.fn) as ObservableArray<T>\n  trackArrayChanges(result)\n  // ^== result.extend({ trackArrayChanges: true })\n  overwriteLengthPropertyIfSupported(result, { get: () => result()?.length })\n  return result\n}\n\nexport function isObservableArray(instance: { remove: any; push: any }) {\n  return isObservable(instance) && typeof instance.remove === 'function' && typeof instance.push === 'function'\n}\n\nobservableArray.fn = {\n  remove(valueOrPredicate: any): any[] {\n    const underlyingArray = this.peek()\n    const removedValues = new Array()\n    const predicate =\n      typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate)\n        ? valueOrPredicate\n        : function (value: any) {\n            return value === valueOrPredicate\n          }\n    for (let i = 0; i < underlyingArray.length; i++) {\n      const value = underlyingArray[i]\n      if (predicate(value)) {\n        if (removedValues.length === 0) {\n          this.valueWillMutate()\n        }\n        if (underlyingArray[i] !== value) {\n          throw Error('Array modified during remove; cannot remove item')\n        }\n        removedValues.push(value)\n        underlyingArray.splice(i, 1)\n        i--\n      }\n    }\n    if (removedValues.length) {\n      this.valueHasMutated()\n    }\n    return removedValues\n  },\n\n  removeAll(arrayOfValues: undefined): any {\n    // If you passed zero args, we remove everything\n    if (arrayOfValues === undefined) {\n      const underlyingArray = this.peek()\n      const allValues = underlyingArray.slice(0)\n      this.valueWillMutate()\n      underlyingArray.splice(0, underlyingArray.length)\n      this.valueHasMutated()\n      return allValues\n    }\n    // If you passed an arg, we interpret it as an array of entries to remove\n    if (!arrayOfValues) {\n      return []\n    }\n    return this['remove'](function (value: any) {\n      return arrayIndexOf(arrayOfValues, value) >= 0\n    })\n  },\n\n  destroy(valueOrPredicate: any): void {\n    const underlyingArray = this.peek()\n    const predicate =\n      typeof valueOrPredicate === 'function' && !isObservable(valueOrPredicate)\n        ? valueOrPredicate\n        : function (value: any) {\n            return value === valueOrPredicate\n          }\n    this.valueWillMutate()\n    for (let i = underlyingArray.length - 1; i >= 0; i--) {\n      const value = underlyingArray[i]\n      if (predicate(value)) {\n        value['_destroy'] = true\n      }\n    }\n    this.valueHasMutated()\n  },\n\n  destroyAll(arrayOfValues: undefined): any {\n    // If you passed zero args, we destroy everything\n    if (arrayOfValues === undefined) {\n      return this.destroy(function () {\n        return true\n      })\n    }\n\n    // If you passed an arg, we interpret it as an array of entries to destroy\n    if (!arrayOfValues) {\n      return []\n    }\n    return this.destroy(function (value: any) {\n      return arrayIndexOf(arrayOfValues, value) >= 0\n    })\n  },\n\n  indexOf(item: any): number {\n    return arrayIndexOf(this(), item)\n  },\n\n  replace(oldItem: any, newItem: any): void {\n    const index = this.indexOf(oldItem)\n    if (index >= 0) {\n      this.valueWillMutate()\n      this.peek()[index] = newItem\n      this.valueHasMutated()\n    }\n  },\n\n  sorted(compareFn: ((a: any, b: any) => number) | undefined): any[] {\n    return [...this()].sort(compareFn)\n  },\n\n  reversed(): any[] {\n    return [...this()].reverse()\n  },\n\n  [Symbol.iterator]: function* (): Generator<any, void, any> {\n    yield* this()\n  }\n}\n\nObject.setPrototypeOf(observableArray.fn, observable.fn)\n\n// Populate ko.observableArray.fn with read/write functions from native arrays\n// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array\n// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale\narrayForEach(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (methodName: string | number) {\n  observableArray.fn[methodName] = function () {\n    // Use \"peek\" to avoid creating a subscription in any computed that we're executing in the context of\n    // (for consistency with mutating regular observables)\n    const underlyingArray = this.peek()\n    this.valueWillMutate()\n    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments)\n    const methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments)\n    this.valueHasMutated()\n    // The native sort and reverse methods return a reference to the array, but it makes more sense to return the observable array instead.\n    return methodCallResult === underlyingArray ? this : methodCallResult\n  }\n})\n\n// Populate ko.observableArray.fn with read-only functions from native arrays\narrayForEach(['slice'], function (methodName: string | number) {\n  observableArray.fn[methodName] = function () {\n    const underlyingArray = this()\n    return underlyingArray[methodName].apply(underlyingArray, arguments)\n  }\n})\n\n// Expose for testing.\nobservableArray.trackArrayChanges = trackArrayChanges\n"],
+  "mappings": ";;AAIA,SAAS,cAAc,cAAc,0CAA0C;AAI/E,SAAS,YAAY,oBAAoB;AAEzC,SAAS,yBAAyB;AAoI3B,gBAAS,gBAAyB,eAAyC;AAChF,kBAAgB,iBAAiB,CAAC;AAElC,MAAI,OAAO,kBAAkB,YAAY,EAAE,YAAY,gBAAgB;AACrE,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,QAAM,SAAS,OAAO,eAAe,WAAW,aAAa,GAAG,gBAAgB,EAAE;AAClF,oBAAkB,MAAM;AAExB,qCAAmC,QAAQ,EAAE,KAAK,MAAM,OAAO,GAAG,OAAO,CAAC;AAC1E,SAAO;AACT;AAEO,gBAAS,kBAAkB,UAAsC;AACtE,SAAO,aAAa,QAAQ,KAAK,OAAO,SAAS,WAAW,cAAc,OAAO,SAAS,SAAS;AACrG;AAEA,gBAAgB,KAAK;AAAA,EACnB,OAAO,kBAA8B;AACnC,UAAM,kBAAkB,KAAK,KAAK;AAClC,UAAM,gBAAgB,IAAI,MAAM;AAChC,UAAM,YACJ,OAAO,qBAAqB,cAAc,CAAC,aAAa,gBAAgB,IACpE,mBACA,SAAU,OAAY;AACpB,aAAO,UAAU;AAAA,IACnB;AACN,aAAS,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;AAC/C,YAAM,QAAQ,gBAAgB,CAAC;AAC/B,UAAI,UAAU,KAAK,GAAG;AACpB,YAAI,cAAc,WAAW,GAAG;AAC9B,eAAK,gBAAgB;AAAA,QACvB;AACA,YAAI,gBAAgB,CAAC,MAAM,OAAO;AAChC,gBAAM,MAAM,kDAAkD;AAAA,QAChE;AACA,sBAAc,KAAK,KAAK;AACxB,wBAAgB,OAAO,GAAG,CAAC;AAC3B;AAAA,MACF;AAAA,IACF;AACA,QAAI,cAAc,QAAQ;AACxB,WAAK,gBAAgB;AAAA,IACvB;AACA,WAAO;AAAA,EACT;AAAA,EAEA,UAAU,eAA+B;AAEvC,QAAI,kBAAkB,QAAW;AAC/B,YAAM,kBAAkB,KAAK,KAAK;AAClC,YAAM,YAAY,gBAAgB,MAAM,CAAC;AACzC,WAAK,gBAAgB;AACrB,sBAAgB,OAAO,GAAG,gBAAgB,MAAM;AAChD,WAAK,gBAAgB;AACrB,aAAO;AAAA,IACT;AAEA,QAAI,CAAC,eAAe;AAClB,aAAO,CAAC;AAAA,IACV;AACA,WAAO,KAAK,QAAQ,EAAE,SAAU,OAAY;AAC1C,aAAO,aAAa,eAAe,KAAK,KAAK;AAAA,IAC/C,CAAC;AAAA,EACH;AAAA,EAEA,QAAQ,kBAA6B;AACnC,UAAM,kBAAkB,KAAK,KAAK;AAClC,UAAM,YACJ,OAAO,qBAAqB,cAAc,CAAC,aAAa,gBAAgB,IACpE,mBACA,SAAU,OAAY;AACpB,aAAO,UAAU;AAAA,IACnB;AACN,SAAK,gBAAgB;AACrB,aAAS,IAAI,gBAAgB,SAAS,GAAG,KAAK,GAAG,KAAK;AACpD,YAAM,QAAQ,gBAAgB,CAAC;AAC/B,UAAI,UAAU,KAAK,GAAG;AACpB,cAAM,UAAU,IAAI;AAAA,MACtB;AAAA,IACF;AACA,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,WAAW,eAA+B;AAExC,QAAI,kBAAkB,QAAW;AAC/B,aAAO,KAAK,QAAQ,WAAY;AAC9B,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAGA,QAAI,CAAC,eAAe;AAClB,aAAO,CAAC;AAAA,IACV;AACA,WAAO,KAAK,QAAQ,SAAU,OAAY;AACxC,aAAO,aAAa,eAAe,KAAK,KAAK;AAAA,IAC/C,CAAC;AAAA,EACH;AAAA,EAEA,QAAQ,MAAmB;AACzB,WAAO,aAAa,KAAK,GAAG,IAAI;AAAA,EAClC;AAAA,EAEA,QAAQ,SAAc,SAAoB;AACxC,UAAM,QAAQ,KAAK,QAAQ,OAAO;AAClC,QAAI,SAAS,GAAG;AACd,WAAK,gBAAgB;AACrB,WAAK,KAAK,EAAE,KAAK,IAAI;AACrB,WAAK,gBAAgB;AAAA,IACvB;AAAA,EACF;AAAA,EAEA,OAAO,WAA4D;AACjE,WAAO,CAAC,GAAG,KAAK,CAAC,EAAE,KAAK,SAAS;AAAA,EACnC;AAAA,EAEA,WAAkB;AAChB,WAAO,CAAC,GAAG,KAAK,CAAC,EAAE,QAAQ;AAAA,EAC7B;AAAA,EAEA,CAAC,OAAO,QAAQ,GAAG,aAAwC;AACzD,WAAO,KAAK;AAAA,EACd;AACF;AAEA,OAAO,eAAe,gBAAgB,IAAI,WAAW,EAAE;AAKvD,aAAa,CAAC,OAAO,QAAQ,WAAW,SAAS,QAAQ,UAAU,SAAS,GAAG,SAAU,YAA6B;AACpH,kBAAgB,GAAG,UAAU,IAAI,WAAY;AAG3C,UAAM,kBAAkB,KAAK,KAAK;AAClC,SAAK,gBAAgB;AACrB,SAAK,2BAA2B,iBAAiB,YAAY,SAAS;AACtE,UAAM,mBAAmB,gBAAgB,UAAU,EAAE,MAAM,iBAAiB,SAAS;AACrF,SAAK,gBAAgB;AAErB,WAAO,qBAAqB,kBAAkB,OAAO;AAAA,EACvD;AACF,CAAC;AAGD,aAAa,CAAC,OAAO,GAAG,SAAU,YAA6B;AAC7D,kBAAgB,GAAG,UAAU,IAAI,WAAY;AAC3C,UAAM,kBAAkB,KAAK;AAC7B,WAAO,gBAAgB,UAAU,EAAE,MAAM,iBAAiB,SAAS;AAAA,EACrE;AACF,CAAC;AAGD,gBAAgB,oBAAoB;",
   "names": []
 }