@tko/computed - npm Package Compare versions

Comparing version 4.0.0 to 4.0.1

dist/computed.js

@@ -1,2 +0,2 @@
-// @tko/computed 🥊 4.0.0 ESM
+// @tko/computed 🥊 4.0.1 ESM
 "use strict";
@@ -239,3 +239,3 @@ import {
   evaluateImmediate(notifyChange) {
-    let computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
+    let state = this[computedState], disposeWhen = state.disposeWhen, changed = false;
     if (state.isBeingEvaluated) {
@@ -249,3 +249,3 @@ return;
       if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {
-        computedObservable.dispose();
+        this.dispose();
         return;
@@ -265,5 +265,5 @@ }
   evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {
-    let computedObservable = this, state = computedObservable[computedState], changed = false;
+    let state = this[computedState], changed = false;
     const isInitial = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
-      computedObservable,
+      computedObservable: this,
       disposalCandidates: state.dependencyTracking,
@@ -275,3 +275,3 @@ disposalCount: state.dependenciesCount
       callback: computedBeginDependencyDetectionCallback,
-      computed: computedObservable,
+      computed: this,
       isInitial
@@ -283,27 +283,27 @@ });
     if (!state.dependenciesCount) {
-      computedObservable.dispose();
+      this.dispose();
       changed = true;
     } else {
-      changed = computedObservable.isDifferent(state.latestValue, newValue);
+      changed = this.isDifferent(state.latestValue, newValue);
     }
     if (changed) {
       if (!state.isSleeping) {
-        computedObservable.notifySubscribers(state.latestValue, "beforeChange");
+        this.notifySubscribers(state.latestValue, "beforeChange");
       } else {
-        computedObservable.updateVersion();
+        this.updateVersion();
       }
       state.latestValue = newValue;
       if (options.debug) {
-        computedObservable._latestValue = newValue;
+        this._latestValue = newValue;
       }
-      computedObservable.notifySubscribers(state.latestValue, "spectate");
+      this.notifySubscribers(state.latestValue, "spectate");
       if (!state.isSleeping && notifyChange) {
-        computedObservable.notifySubscribers(state.latestValue);
+        this.notifySubscribers(state.latestValue);
       }
-      if (computedObservable._recordUpdate) {
-        computedObservable._recordUpdate();
+      if (this._recordUpdate) {
+        this._recordUpdate();
       }
     }
     if (isInitial) {
-      computedObservable.notifySubscribers(state.latestValue, "awake");
+      this.notifySubscribers(state.latestValue, "awake");
     }
@@ -310,0 +310,0 @@ return changed;

dist/computed.js.map

 {
   "version": 3,
   "sources": ["../src/computed.ts"],
-  "sourcesContent": ["//\n// Computed Observable Values\n//\n// (before tko, `computed` was also known as `dependentObservable`)\n//\nimport {\n  addDisposeCallback,\n  arrayForEach,\n  createSymbolOrString,\n  domNodeIsAttachedToDocument,\n  extend,\n  options,\n  hasOwnProperty,\n  objectForEach,\n  options as koOptions,\n  removeDisposeCallback,\n  safeSetTimeout\n} from '@tko/utils'\n\nimport {\n  dependencyDetection,\n  extenders,\n  valuesArePrimitiveAndEqual,\n  observable,\n  subscribable,\n  LATEST_VALUE\n} from '@tko/observable'\n\nimport type { Observable, Subscribable } from '@tko/observable'\n\nconst computedState: symbol = createSymbolOrString('_state')\nconst DISPOSED_STATE = {\n  dependencyTracking: null,\n  dependenciesCount: 0,\n  isDisposed: true,\n  isStale: false,\n  isDirty: false,\n  isSleeping: false,\n  disposeWhenNodeIsRemoved: null,\n  readFunction: null,\n  _options: null\n}\n\nexport interface Computed<T = any> extends ComputedFunctions<T> {\n  (): T\n  (value: T): this\n}\n\nexport interface ComputedFunctions<T = any> extends Subscribable<T> {\n  // It's possible for a to be undefined, since the equalityComparer is run on the initial\n  // computation with undefined as the first argument. This is user-relevant for deferred computeds.\n  equalityComparer(a: T | undefined, b: T): boolean\n  peek(): T\n  dispose(): void\n  isActive(): boolean\n  getDependenciesCount(): number\n  getDependencies(): Subscribable[]\n}\n\n// used in computed, but empty interface is pointless. Check if it's needed\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface PureComputed<T = any> extends Computed<T> {}\n\nexport type ComputedReadFunction<T = any, TTarget = void> =\n  | Subscribable<T>\n  | Observable<T>\n  | Computed<T>\n  | ((this: TTarget) => T)\nexport type ComputedWriteFunction<T = any, TTarget = void> = (this: TTarget, val: T) => void\nexport type MaybeComputed<T = any> = T | Computed<T>\n\nexport interface ComputedOptions<T = any, TTarget = void> {\n  read?: ComputedReadFunction<T, TTarget>\n  write?: ComputedWriteFunction<T, TTarget>\n  owner?: TTarget\n  pure?: boolean\n  deferEvaluation?: boolean\n  disposeWhenNodeIsRemoved?: Node\n  disposeWhen?: () => boolean\n}\n\ninterface State {\n  latestValue?: any\n  isStale: boolean\n  isDirty: boolean\n  isBeingEvaluated: boolean\n  suppressDisposalUntilDisposeWhenReturnsFalse: boolean\n  isDisposed: boolean\n  pure: boolean\n  isSleeping: boolean\n  readFunction: ComputedReadFunction\n  evaluatorFunctionTarget: any\n  disposeWhenNodeIsRemoved: Node | null\n  disposeWhen?: () => boolean\n  domNodeDisposalCallback: (() => void) | null\n  dependencyTracking: any\n  dependenciesCount: number\n  evaluationTimeoutInstance: any\n}\n\nexport function computed(\n  evaluatorFunctionOrOptions?: ComputedOptions<any, void> | ComputedReadFunction<any, any>,\n  evaluatorFunctionTarget?: any,\n  options?: ComputedOptions\n): Computed {\n  if (typeof evaluatorFunctionOrOptions === 'object') {\n    // Single-parameter syntax - everything is on this \"options\" param\n    options = evaluatorFunctionOrOptions as ComputedOptions\n  } else {\n    // Multi-parameter syntax - construct the options according to the params passed\n    options = options || {}\n    if (evaluatorFunctionOrOptions) {\n      options!.read = evaluatorFunctionOrOptions\n    }\n  }\n  if (typeof options?.read !== 'function') {\n    throw Error('Pass a function that returns the value of the computed')\n  }\n\n  const writeFunction = options.write\n  const state: State = {\n    latestValue: undefined,\n    isStale: true,\n    isDirty: true,\n    isBeingEvaluated: false,\n    suppressDisposalUntilDisposeWhenReturnsFalse: false,\n    isDisposed: false,\n    pure: false,\n    isSleeping: false,\n    readFunction: options.read,\n    evaluatorFunctionTarget: evaluatorFunctionTarget || options.owner,\n    disposeWhenNodeIsRemoved: options.disposeWhenNodeIsRemoved || null,\n    disposeWhen: options.disposeWhen,\n    domNodeDisposalCallback: null,\n    dependencyTracking: {},\n    dependenciesCount: 0,\n    evaluationTimeoutInstance: null\n  }\n\n  function computedObservable() {\n    if (arguments.length > 0) {\n      if (typeof writeFunction === 'function') {\n        // Writing a value\n        writeFunction.apply(state.evaluatorFunctionTarget, arguments as any)\n      } else {\n        throw new Error(\n          \"Cannot write a value to a computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.\"\n        )\n      }\n      return this // Permits chained assignments\n    } else {\n      // Reading the value\n      if (!state.isDisposed) {\n        dependencyDetection.registerDependency(computedObservable)\n      }\n      if (state.isDirty || (state.isSleeping && (computedObservable as any).haveDependenciesChanged())) {\n        ;(computedObservable as any).evaluateImmediate()\n      }\n      return state.latestValue\n    }\n  }\n\n  computedObservable[computedState] = state\n  computedObservable.isWriteable = typeof writeFunction === 'function'\n\n  subscribable.fn.init(computedObservable)\n\n  // Inherit from 'computed'\n  Object.setPrototypeOf(computedObservable, computed.fn)\n\n  if (options.pure) {\n    state.pure = true\n    state.isSleeping = true // Starts off sleeping; will awake on the first subscription\n    extend(computedObservable, pureComputedOverrides)\n  } else if (options.deferEvaluation) {\n    extend(computedObservable, deferEvaluationOverrides)\n  }\n\n  if (koOptions.deferUpdates) {\n    extenders.deferred(computedObservable, true)\n  }\n\n  if (koOptions.debug) {\n    // #1731 - Aid debugging by exposing the computed's options\n    computedObservable._options = options\n  }\n\n  if (state.disposeWhenNodeIsRemoved) {\n    // Since this computed is associated with a DOM node, and we don't want to dispose the computed\n    // until the DOM node is *removed* from the document (as opposed to never having been in the document),\n    // we'll prevent disposal until \"disposeWhen\" first returns false.\n    state.suppressDisposalUntilDisposeWhenReturnsFalse = true\n\n    // disposeWhenNodeIsRemoved: true can be used to opt into the \"only dispose after first false result\"\n    // behavior even if there's no specific node to watch. In that case, clear the option so we don't try\n    // to watch for a non-node's disposal. This technique is intended for KO's internal use only and shouldn't\n    // be documented or used by application code, as it's likely to change in a future version of KO.\n    if (!state.disposeWhenNodeIsRemoved.nodeType) {\n      state.disposeWhenNodeIsRemoved = null\n    }\n  }\n\n  // Evaluate, unless sleeping or deferEvaluation is true\n  if (!state.isSleeping && !options.deferEvaluation) {\n    ;(computedObservable as any).evaluateImmediate()\n  }\n\n  // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is\n  // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).\n  if (state.disposeWhenNodeIsRemoved && (computedObservable as any).isActive()) {\n    addDisposeCallback(\n      state.disposeWhenNodeIsRemoved,\n      (state.domNodeDisposalCallback = function () {\n        ;(computedObservable as any).dispose()\n      })\n    )\n  }\n\n  return computedObservable as unknown as Computed\n}\n\n// Utility function that disposes a given dependencyTracking entry\nfunction computedDisposeDependencyCallback(id, entryToDispose) {\n  if (entryToDispose !== null && entryToDispose.dispose) {\n    entryToDispose.dispose()\n  }\n}\n\n// This function gets called each time a dependency is detected while evaluating a computed.\n// It's factored out as a shared function to avoid creating unnecessary function instances during evaluation.\nfunction computedBeginDependencyDetectionCallback(subscribable, id) {\n  const computedObservable = this.computedObservable,\n    state = computedObservable[computedState]\n  if (!state.isDisposed) {\n    if (this.disposalCount && this.disposalCandidates[id]) {\n      // Don't want to dispose this subscription, as it's still being used\n      computedObservable.addDependencyTracking(id, subscribable, this.disposalCandidates[id])\n      this.disposalCandidates[id] = null // No need to actually delete the property - disposalCandidates is a transient object anyway\n      --this.disposalCount\n    } else if (!state.dependencyTracking[id]) {\n      // Brand new subscription - add it\n      computedObservable.addDependencyTracking(\n        id,\n        subscribable,\n        state.isSleeping ? { _target: subscribable } : computedObservable.subscribeToDependency(subscribable)\n      )\n    }\n    // If the observable we've accessed has a pending notification, ensure\n    // we get notified of the actual final value (bypass equality checks)\n    if (subscribable._notificationIsPending) {\n      subscribable._notifyNextChangeIfValueIsDifferent()\n    }\n  }\n}\n\ncomputed.fn = {\n  equalityComparer: valuesArePrimitiveAndEqual,\n  getDependenciesCount(): number {\n    return this[computedState].dependenciesCount\n  },\n\n  getDependencies() {\n    const dependencyTracking = this[computedState].dependencyTracking\n    const dependentObservables = new Array()\n\n    objectForEach(dependencyTracking, function (id, dependency) {\n      dependentObservables[dependency._order] = dependency._target\n    })\n\n    return dependentObservables\n  },\n\n  addDependencyTracking(id, target, trackingObj) {\n    if (this[computedState].pure && target === this) {\n      throw Error(\"A 'pure' computed must not be called recursively\")\n    }\n\n    this[computedState].dependencyTracking[id] = trackingObj\n    trackingObj._order = this[computedState].dependenciesCount++\n    trackingObj._version = target.getVersion()\n  },\n  haveDependenciesChanged() {\n    let id,\n      dependency,\n      dependencyTracking = this[computedState].dependencyTracking\n    for (id in dependencyTracking) {\n      if (hasOwnProperty(dependencyTracking, id)) {\n        dependency = dependencyTracking[id]\n        if (\n          (this._evalDelayed && dependency._target._notificationIsPending)\n          || dependency._target.hasChanged(dependency._version)\n        ) {\n          return true\n        }\n      }\n    }\n    return false\n  },\n  markDirty() {\n    // Process \"dirty\" events if we can handle delayed notifications\n    if (this._evalDelayed && !this[computedState].isBeingEvaluated) {\n      this._evalDelayed(false /* notifyChange */)\n    }\n  },\n  isActive() {\n    const state = this[computedState]\n    return state.isDirty || state.dependenciesCount > 0\n  },\n  respondToChange() {\n    // Ignore \"change\" events if we've already scheduled a delayed notification\n    if (!this._notificationIsPending) {\n      this.evaluatePossiblyAsync()\n    } else if (this[computedState].isDirty) {\n      this[computedState].isStale = true\n    }\n  },\n  subscribeToDependency(target) {\n    if (target._deferUpdates) {\n      const dirtySub = target.subscribe(this.markDirty, this, 'dirty'),\n        changeSub = target.subscribe(this.respondToChange, this)\n      return {\n        _target: target,\n        dispose() {\n          dirtySub.dispose()\n          changeSub.dispose()\n        }\n      }\n    } else {\n      return target.subscribe(this.evaluatePossiblyAsync, this)\n    }\n  },\n  evaluatePossiblyAsync() {\n    const computedObservable = this,\n      throttleEvaluationTimeout = computedObservable.throttleEvaluation\n    if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {\n      clearTimeout(this[computedState].evaluationTimeoutInstance)\n      this[computedState].evaluationTimeoutInstance = safeSetTimeout(function () {\n        computedObservable.evaluateImmediate(true /* notifyChange */)\n      }, throttleEvaluationTimeout)\n    } else if (computedObservable._evalDelayed) {\n      computedObservable._evalDelayed(true /* notifyChange */)\n    } else {\n      computedObservable.evaluateImmediate(true /* notifyChange */)\n    }\n  },\n  evaluateImmediate(notifyChange) {\n    let computedObservable = this,\n      state = computedObservable[computedState],\n      disposeWhen = state.disposeWhen,\n      changed = false\n\n    if (state.isBeingEvaluated) {\n      // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.\n      // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost\n      // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing\n      // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387\n      return\n    }\n\n    // Do not evaluate (and possibly capture new dependencies) if disposed\n    if (state.isDisposed) {\n      return\n    }\n\n    if (\n      (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved))\n      || (disposeWhen && disposeWhen())\n    ) {\n      // See comment above about suppressDisposalUntilDisposeWhenReturnsFalse\n      if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {\n        computedObservable.dispose()\n        return\n      }\n    } else {\n      // It just did return false, so we can stop suppressing now\n      state.suppressDisposalUntilDisposeWhenReturnsFalse = false\n    }\n\n    state.isBeingEvaluated = true\n    try {\n      changed = this.evaluateImmediate_CallReadWithDependencyDetection(notifyChange)\n    } finally {\n      state.isBeingEvaluated = false\n    }\n\n    return changed\n  },\n  evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {\n    // This function is really just part of the evaluateImmediate logic. You would never call it from anywhere else.\n    // Factoring it out into a separate function means it can be independent of the try/catch block in evaluateImmediate,\n    // which contributes to saving about 40% off the CPU overhead of computed evaluation (on V8 at least).\n\n    let computedObservable = this,\n      state = computedObservable[computedState],\n      changed = false\n\n    // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).\n    // Then, during evaluation, we cross off any that are in fact still being used.\n    const isInitial = state.pure ? undefined : !state.dependenciesCount, // If we're evaluating when there are no previous dependencies, it must be the first time\n      dependencyDetectionContext = {\n        computedObservable: computedObservable,\n        disposalCandidates: state.dependencyTracking,\n        disposalCount: state.dependenciesCount\n      }\n\n    dependencyDetection.begin({\n      callbackTarget: dependencyDetectionContext,\n      callback: computedBeginDependencyDetectionCallback,\n      computed: computedObservable,\n      isInitial: isInitial\n    })\n\n    state.dependencyTracking = {}\n    state.dependenciesCount = 0\n\n    const newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext)\n\n    if (!state.dependenciesCount) {\n      computedObservable.dispose()\n      changed = true // When evaluation causes a disposal, make sure all dependent computeds get notified so they'll see the new state\n    } else {\n      changed = computedObservable.isDifferent(state.latestValue, newValue)\n    }\n\n    if (changed) {\n      if (!state.isSleeping) {\n        computedObservable.notifySubscribers(state.latestValue, 'beforeChange')\n      } else {\n        computedObservable.updateVersion()\n      }\n\n      state.latestValue = newValue\n      if (options.debug) {\n        computedObservable._latestValue = newValue\n      }\n\n      computedObservable.notifySubscribers(state.latestValue, 'spectate')\n\n      if (!state.isSleeping && notifyChange) {\n        computedObservable.notifySubscribers(state.latestValue)\n      }\n\n      if (computedObservable._recordUpdate) {\n        computedObservable._recordUpdate()\n      }\n    }\n\n    if (isInitial) {\n      computedObservable.notifySubscribers(state.latestValue, 'awake')\n    }\n\n    return changed\n  },\n  evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext) {\n    // This function is really part of the evaluateImmediate_CallReadWithDependencyDetection logic.\n    // You'd never call it from anywhere else. Factoring it out means that evaluateImmediate_CallReadWithDependencyDetection\n    // can be independent of try/finally blocks, which contributes to saving about 40% off the CPU\n    // overhead of computed evaluation (on V8 at least).\n\n    try {\n      const readFunction = state.readFunction\n      return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction()\n    } finally {\n      dependencyDetection.end()\n\n      // For each subscription no longer being used, remove it from the active subscriptions list and dispose it\n      if (dependencyDetectionContext.disposalCount && !state.isSleeping) {\n        objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback)\n      }\n\n      state.isStale = state.isDirty = false\n    }\n  },\n  peek(forceEvaluate) {\n    // Peek won't ordinarily re-evaluate, except while the computed is sleeping\n    //  or to get the initial value when \"deferEvaluation\" is set.\n    const state = this[computedState]\n    if (\n      (state.isDirty && (forceEvaluate || !state.dependenciesCount))\n      || (state.isSleeping && this.haveDependenciesChanged())\n    ) {\n      this.evaluateImmediate()\n    }\n    return state.latestValue\n  },\n\n  get [LATEST_VALUE]() {\n    return this.peek()\n  },\n\n  limit(limitFunction) {\n    const state = this[computedState]\n    // Override the limit function with one that delays evaluation as well\n    ;(subscribable.fn as any).limit.call(this, limitFunction)\n    Object.assign(this, {\n      _evalIfChanged() {\n        if (!this[computedState].isSleeping) {\n          if (this[computedState].isStale) {\n            this.evaluateImmediate()\n          } else {\n            this[computedState].isDirty = false\n          }\n        }\n        return state.latestValue\n      },\n      _evalDelayed(isChange) {\n        this._limitBeforeChange(state.latestValue)\n\n        // Mark as dirty\n        state.isDirty = true\n        if (isChange) {\n          state.isStale = true\n        }\n\n        // Pass the observable to the \"limit\" code, which will evaluate it when\n        // it's time to do the notification.\n        this._limitChange(this, !isChange /* isDirty */)\n      }\n    })\n  },\n  dispose() {\n    const state = this[computedState]\n    if (!state.isSleeping && state.dependencyTracking) {\n      objectForEach(state.dependencyTracking, function (id, dependency) {\n        if (dependency.dispose) {\n          dependency.dispose()\n        }\n      })\n    }\n    if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {\n      removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback)\n    }\n    Object.assign(state, DISPOSED_STATE)\n  }\n}\n\nconst pureComputedOverrides = {\n  beforeSubscriptionAdd(event: string) {\n    // If asleep, wake up the computed by subscribing to any dependencies.\n    const computedObservable = this,\n      state = computedObservable[computedState]\n    if (!state.isDisposed && state.isSleeping && event === 'change') {\n      state.isSleeping = false\n      if (state.isStale || computedObservable.haveDependenciesChanged()) {\n        state.dependencyTracking = null\n        state.dependenciesCount = 0\n        if (computedObservable.evaluateImmediate()) {\n          computedObservable.updateVersion()\n        }\n      } else {\n        // First put the dependencies in order\n        const dependenciesOrder = new Array()\n        objectForEach(state.dependencyTracking, function (id, dependency) {\n          dependenciesOrder[dependency._order] = id\n        })\n        // Next, subscribe to each one\n        arrayForEach(dependenciesOrder, function (id, order) {\n          const dependency = state.dependencyTracking[id],\n            subscription = computedObservable.subscribeToDependency(dependency._target)\n          subscription._order = order\n          subscription._version = dependency._version\n          state.dependencyTracking[id] = subscription\n        })\n\n        // Waking dependencies may have triggered effects\n        if (computedObservable.haveDependenciesChanged()) {\n          if (computedObservable.evaluateImmediate()) {\n            computedObservable.updateVersion()\n          }\n        }\n      }\n\n      if (!state.isDisposed) {\n        // test since evaluating could trigger disposal\n        computedObservable.notifySubscribers(state.latestValue, 'awake')\n      }\n    }\n  },\n  afterSubscriptionRemove(event: string) {\n    const state = this[computedState]\n    if (!state.isDisposed && event === 'change' && !this.hasSubscriptionsForEvent('change')) {\n      objectForEach(state.dependencyTracking, function (id, dependency) {\n        if (dependency.dispose) {\n          state.dependencyTracking[id] = {\n            _target: dependency._target,\n            _order: dependency._order,\n            _version: dependency._version\n          }\n          dependency.dispose()\n        }\n      })\n      state.isSleeping = true\n      this.notifySubscribers(undefined, 'asleep')\n    }\n  },\n  getVersion() {\n    // Because a pure computed is not automatically updated while it is sleeping, we can't\n    // simply return the version number. Instead, we check if any of the dependencies have\n    // changed and conditionally re-evaluate the computed observable.\n    const state = this[computedState]\n    if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {\n      this.evaluateImmediate()\n    }\n    return subscribable.fn.getVersion.call(this)\n  }\n}\n\nconst deferEvaluationOverrides = {\n  beforeSubscriptionAdd(event) {\n    // This will force a computed with deferEvaluation to evaluate when the first subscription is registered.\n    if (event === 'change' || event === 'beforeChange') {\n      this.peek()\n    }\n  }\n}\n\nObject.setPrototypeOf(computed.fn, subscribable.fn)\n\n// Set the proto values for ko.computed\nconst protoProp = observable.protoProperty // == \"__ko_proto__\"\ncomputed.fn[protoProp] = computed\n\n/* This is used by ko.isObservable */\nobservable.observablePrototypes.add(computed as any)\n\nexport function isComputed<T = any>(instance: any): instance is Computed<T> {\n  return typeof instance === 'function' && instance[protoProp] === computed\n}\n\nexport function isPureComputed<T = any>(instance: any): instance is PureComputed<T> {\n  return isComputed(instance) && instance[computedState] && (instance[computedState] as unknown as State).pure\n}\n\nexport function pureComputed<T = any>(\n  evaluatorFunctionOrOptions: ComputedOptions | ComputedReadFunction,\n  evaluatorFunctionTarget?\n): Computed<T> {\n  if (typeof evaluatorFunctionOrOptions === 'function') {\n    const evaluator = evaluatorFunctionOrOptions as ComputedReadFunction\n    return computed(evaluator, evaluatorFunctionTarget, { pure: true })\n  } else {\n    let options = evaluatorFunctionOrOptions as ComputedOptions\n    options = extend({}, options) // make a copy of the parameter object\n    options.pure = true\n    return computed(options, evaluatorFunctionTarget)\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["//\n// Computed Observable Values\n//\n// (before tko, `computed` was also known as `dependentObservable`)\n//\nimport {\n  addDisposeCallback,\n  arrayForEach,\n  createSymbolOrString,\n  domNodeIsAttachedToDocument,\n  extend,\n  options,\n  hasOwnProperty,\n  objectForEach,\n  options as koOptions,\n  removeDisposeCallback,\n  safeSetTimeout\n} from '@tko/utils'\n\nimport {\n  dependencyDetection,\n  extenders,\n  valuesArePrimitiveAndEqual,\n  observable,\n  subscribable,\n  LATEST_VALUE\n} from '@tko/observable'\n\nimport type { Observable, Subscribable } from '@tko/observable'\n\nconst computedState: symbol = createSymbolOrString('_state')\nconst DISPOSED_STATE = {\n  dependencyTracking: null,\n  dependenciesCount: 0,\n  isDisposed: true,\n  isStale: false,\n  isDirty: false,\n  isSleeping: false,\n  disposeWhenNodeIsRemoved: null,\n  readFunction: null,\n  _options: null\n}\n\nexport interface Computed<T = any> extends ComputedFunctions<T> {\n  (): T\n  (value: T): this\n}\n\nexport interface ComputedFunctions<T = any> extends Subscribable<T> {\n  // It's possible for a to be undefined, since the equalityComparer is run on the initial\n  // computation with undefined as the first argument. This is user-relevant for deferred computeds.\n  equalityComparer(a: T | undefined, b: T): boolean\n  peek(): T\n  dispose(): void\n  isActive(): boolean\n  getDependenciesCount(): number\n  getDependencies(): Subscribable[]\n}\n\n// used in computed, but empty interface is pointless. Check if it's needed\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface PureComputed<T = any> extends Computed<T> {}\n\nexport type ComputedReadFunction<T = any, TTarget = void> =\n  | Subscribable<T>\n  | Observable<T>\n  | Computed<T>\n  | ((this: TTarget) => T)\nexport type ComputedWriteFunction<T = any, TTarget = void> = (this: TTarget, val: T) => void\nexport type MaybeComputed<T = any> = T | Computed<T>\n\nexport interface ComputedOptions<T = any, TTarget = void> {\n  read?: ComputedReadFunction<T, TTarget>\n  write?: ComputedWriteFunction<T, TTarget>\n  owner?: TTarget\n  pure?: boolean\n  deferEvaluation?: boolean\n  disposeWhenNodeIsRemoved?: Node\n  disposeWhen?: () => boolean\n}\n\ninterface State {\n  latestValue?: any\n  isStale: boolean\n  isDirty: boolean\n  isBeingEvaluated: boolean\n  suppressDisposalUntilDisposeWhenReturnsFalse: boolean\n  isDisposed: boolean\n  pure: boolean\n  isSleeping: boolean\n  readFunction: ComputedReadFunction\n  evaluatorFunctionTarget: any\n  disposeWhenNodeIsRemoved: Node | null\n  disposeWhen?: () => boolean\n  domNodeDisposalCallback: (() => void) | null\n  dependencyTracking: any\n  dependenciesCount: number\n  evaluationTimeoutInstance: any\n}\n\nexport function computed(\n  evaluatorFunctionOrOptions?: ComputedOptions<any, void> | ComputedReadFunction<any, any>,\n  evaluatorFunctionTarget?: any,\n  options?: ComputedOptions\n): Computed {\n  if (typeof evaluatorFunctionOrOptions === 'object') {\n    // Single-parameter syntax - everything is on this \"options\" param\n    options = evaluatorFunctionOrOptions as ComputedOptions\n  } else {\n    // Multi-parameter syntax - construct the options according to the params passed\n    options = options || {}\n    if (evaluatorFunctionOrOptions) {\n      options!.read = evaluatorFunctionOrOptions\n    }\n  }\n  if (typeof options?.read !== 'function') {\n    throw Error('Pass a function that returns the value of the computed')\n  }\n\n  const writeFunction = options.write\n  const state: State = {\n    latestValue: undefined,\n    isStale: true,\n    isDirty: true,\n    isBeingEvaluated: false,\n    suppressDisposalUntilDisposeWhenReturnsFalse: false,\n    isDisposed: false,\n    pure: false,\n    isSleeping: false,\n    readFunction: options.read,\n    evaluatorFunctionTarget: evaluatorFunctionTarget || options.owner,\n    disposeWhenNodeIsRemoved: options.disposeWhenNodeIsRemoved || null,\n    disposeWhen: options.disposeWhen,\n    domNodeDisposalCallback: null,\n    dependencyTracking: {},\n    dependenciesCount: 0,\n    evaluationTimeoutInstance: null\n  }\n\n  function computedObservable() {\n    if (arguments.length > 0) {\n      if (typeof writeFunction === 'function') {\n        // Writing a value\n        writeFunction.apply(state.evaluatorFunctionTarget, arguments as any)\n      } else {\n        throw new Error(\n          \"Cannot write a value to a computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.\"\n        )\n      }\n      return this // Permits chained assignments\n    } else {\n      // Reading the value\n      if (!state.isDisposed) {\n        dependencyDetection.registerDependency(computedObservable)\n      }\n      if (state.isDirty || (state.isSleeping && (computedObservable as any).haveDependenciesChanged())) {\n        ;(computedObservable as any).evaluateImmediate()\n      }\n      return state.latestValue\n    }\n  }\n\n  computedObservable[computedState] = state\n  computedObservable.isWriteable = typeof writeFunction === 'function'\n\n  subscribable.fn.init(computedObservable)\n\n  // Inherit from 'computed'\n  Object.setPrototypeOf(computedObservable, computed.fn)\n\n  if (options.pure) {\n    state.pure = true\n    state.isSleeping = true // Starts off sleeping; will awake on the first subscription\n    extend(computedObservable, pureComputedOverrides)\n  } else if (options.deferEvaluation) {\n    extend(computedObservable, deferEvaluationOverrides)\n  }\n\n  if (koOptions.deferUpdates) {\n    extenders.deferred(computedObservable, true)\n  }\n\n  if (koOptions.debug) {\n    // #1731 - Aid debugging by exposing the computed's options\n    computedObservable._options = options\n  }\n\n  if (state.disposeWhenNodeIsRemoved) {\n    // Since this computed is associated with a DOM node, and we don't want to dispose the computed\n    // until the DOM node is *removed* from the document (as opposed to never having been in the document),\n    // we'll prevent disposal until \"disposeWhen\" first returns false.\n    state.suppressDisposalUntilDisposeWhenReturnsFalse = true\n\n    // disposeWhenNodeIsRemoved: true can be used to opt into the \"only dispose after first false result\"\n    // behavior even if there's no specific node to watch. In that case, clear the option so we don't try\n    // to watch for a non-node's disposal. This technique is intended for KO's internal use only and shouldn't\n    // be documented or used by application code, as it's likely to change in a future version of KO.\n    if (!state.disposeWhenNodeIsRemoved.nodeType) {\n      state.disposeWhenNodeIsRemoved = null\n    }\n  }\n\n  // Evaluate, unless sleeping or deferEvaluation is true\n  if (!state.isSleeping && !options.deferEvaluation) {\n    ;(computedObservable as any).evaluateImmediate()\n  }\n\n  // Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is\n  // removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).\n  if (state.disposeWhenNodeIsRemoved && (computedObservable as any).isActive()) {\n    addDisposeCallback(\n      state.disposeWhenNodeIsRemoved,\n      (state.domNodeDisposalCallback = function () {\n        ;(computedObservable as any).dispose()\n      })\n    )\n  }\n\n  return computedObservable as unknown as Computed\n}\n\n// Utility function that disposes a given dependencyTracking entry\nfunction computedDisposeDependencyCallback(id, entryToDispose) {\n  if (entryToDispose !== null && entryToDispose.dispose) {\n    entryToDispose.dispose()\n  }\n}\n\n// This function gets called each time a dependency is detected while evaluating a computed.\n// It's factored out as a shared function to avoid creating unnecessary function instances during evaluation.\nfunction computedBeginDependencyDetectionCallback(subscribable, id) {\n  const computedObservable = this.computedObservable,\n    state = computedObservable[computedState]\n  if (!state.isDisposed) {\n    if (this.disposalCount && this.disposalCandidates[id]) {\n      // Don't want to dispose this subscription, as it's still being used\n      computedObservable.addDependencyTracking(id, subscribable, this.disposalCandidates[id])\n      this.disposalCandidates[id] = null // No need to actually delete the property - disposalCandidates is a transient object anyway\n      --this.disposalCount\n    } else if (!state.dependencyTracking[id]) {\n      // Brand new subscription - add it\n      computedObservable.addDependencyTracking(\n        id,\n        subscribable,\n        state.isSleeping ? { _target: subscribable } : computedObservable.subscribeToDependency(subscribable)\n      )\n    }\n    // If the observable we've accessed has a pending notification, ensure\n    // we get notified of the actual final value (bypass equality checks)\n    if (subscribable._notificationIsPending) {\n      subscribable._notifyNextChangeIfValueIsDifferent()\n    }\n  }\n}\n\ncomputed.fn = {\n  equalityComparer: valuesArePrimitiveAndEqual,\n  getDependenciesCount(): number {\n    return this[computedState].dependenciesCount\n  },\n\n  getDependencies() {\n    const dependencyTracking = this[computedState].dependencyTracking\n    const dependentObservables = new Array()\n\n    objectForEach(dependencyTracking, function (id, dependency) {\n      dependentObservables[dependency._order] = dependency._target\n    })\n\n    return dependentObservables\n  },\n\n  addDependencyTracking(id, target, trackingObj) {\n    if (this[computedState].pure && target === this) {\n      throw Error(\"A 'pure' computed must not be called recursively\")\n    }\n\n    this[computedState].dependencyTracking[id] = trackingObj\n    trackingObj._order = this[computedState].dependenciesCount++\n    trackingObj._version = target.getVersion()\n  },\n  haveDependenciesChanged() {\n    let id,\n      dependency,\n      dependencyTracking = this[computedState].dependencyTracking\n    for (id in dependencyTracking) {\n      if (hasOwnProperty(dependencyTracking, id)) {\n        dependency = dependencyTracking[id]\n        if (\n          (this._evalDelayed && dependency._target._notificationIsPending) ||\n          dependency._target.hasChanged(dependency._version)\n        ) {\n          return true\n        }\n      }\n    }\n    return false\n  },\n  markDirty() {\n    // Process \"dirty\" events if we can handle delayed notifications\n    if (this._evalDelayed && !this[computedState].isBeingEvaluated) {\n      this._evalDelayed(false /* notifyChange */)\n    }\n  },\n  isActive() {\n    const state = this[computedState]\n    return state.isDirty || state.dependenciesCount > 0\n  },\n  respondToChange() {\n    // Ignore \"change\" events if we've already scheduled a delayed notification\n    if (!this._notificationIsPending) {\n      this.evaluatePossiblyAsync()\n    } else if (this[computedState].isDirty) {\n      this[computedState].isStale = true\n    }\n  },\n  subscribeToDependency(target) {\n    if (target._deferUpdates) {\n      const dirtySub = target.subscribe(this.markDirty, this, 'dirty'),\n        changeSub = target.subscribe(this.respondToChange, this)\n      return {\n        _target: target,\n        dispose() {\n          dirtySub.dispose()\n          changeSub.dispose()\n        }\n      }\n    } else {\n      return target.subscribe(this.evaluatePossiblyAsync, this)\n    }\n  },\n  evaluatePossiblyAsync() {\n    const computedObservable = this,\n      throttleEvaluationTimeout = computedObservable.throttleEvaluation\n    if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {\n      clearTimeout(this[computedState].evaluationTimeoutInstance)\n      this[computedState].evaluationTimeoutInstance = safeSetTimeout(function () {\n        computedObservable.evaluateImmediate(true /* notifyChange */)\n      }, throttleEvaluationTimeout)\n    } else if (computedObservable._evalDelayed) {\n      computedObservable._evalDelayed(true /* notifyChange */)\n    } else {\n      computedObservable.evaluateImmediate(true /* notifyChange */)\n    }\n  },\n  evaluateImmediate(notifyChange) {\n    let state = this[computedState],\n      disposeWhen = state.disposeWhen,\n      changed = false\n\n    if (state.isBeingEvaluated) {\n      // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.\n      // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost\n      // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing\n      // their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387\n      return\n    }\n\n    // Do not evaluate (and possibly capture new dependencies) if disposed\n    if (state.isDisposed) {\n      return\n    }\n\n    if (\n      (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved)) ||\n      (disposeWhen && disposeWhen())\n    ) {\n      // See comment above about suppressDisposalUntilDisposeWhenReturnsFalse\n      if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {\n        this.dispose()\n        return\n      }\n    } else {\n      // It just did return false, so we can stop suppressing now\n      state.suppressDisposalUntilDisposeWhenReturnsFalse = false\n    }\n\n    state.isBeingEvaluated = true\n    try {\n      changed = this.evaluateImmediate_CallReadWithDependencyDetection(notifyChange)\n    } finally {\n      state.isBeingEvaluated = false\n    }\n\n    return changed\n  },\n  evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {\n    // This function is really just part of the evaluateImmediate logic. You would never call it from anywhere else.\n    // Factoring it out into a separate function means it can be independent of the try/catch block in evaluateImmediate,\n    // which contributes to saving about 40% off the CPU overhead of computed evaluation (on V8 at least).\n\n    let state = this[computedState],\n      changed = false\n\n    // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).\n    // Then, during evaluation, we cross off any that are in fact still being used.\n    const isInitial = state.pure ? undefined : !state.dependenciesCount, // If we're evaluating when there are no previous dependencies, it must be the first time\n      dependencyDetectionContext = {\n        computedObservable: this,\n        disposalCandidates: state.dependencyTracking,\n        disposalCount: state.dependenciesCount\n      }\n\n    dependencyDetection.begin({\n      callbackTarget: dependencyDetectionContext,\n      callback: computedBeginDependencyDetectionCallback,\n      computed: this,\n      isInitial: isInitial\n    })\n\n    state.dependencyTracking = {}\n    state.dependenciesCount = 0\n\n    const newValue = this.evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext)\n\n    if (!state.dependenciesCount) {\n      this.dispose()\n      changed = true // When evaluation causes a disposal, make sure all dependent computeds get notified so they'll see the new state\n    } else {\n      changed = this.isDifferent(state.latestValue, newValue)\n    }\n\n    if (changed) {\n      if (!state.isSleeping) {\n        this.notifySubscribers(state.latestValue, 'beforeChange')\n      } else {\n        this.updateVersion()\n      }\n\n      state.latestValue = newValue\n      if (options.debug) {\n        this._latestValue = newValue\n      }\n\n      this.notifySubscribers(state.latestValue, 'spectate')\n\n      if (!state.isSleeping && notifyChange) {\n        this.notifySubscribers(state.latestValue)\n      }\n\n      if (this._recordUpdate) {\n        this._recordUpdate()\n      }\n    }\n\n    if (isInitial) {\n      this.notifySubscribers(state.latestValue, 'awake')\n    }\n\n    return changed\n  },\n  evaluateImmediate_CallReadThenEndDependencyDetection(state, dependencyDetectionContext) {\n    // This function is really part of the evaluateImmediate_CallReadWithDependencyDetection logic.\n    // You'd never call it from anywhere else. Factoring it out means that evaluateImmediate_CallReadWithDependencyDetection\n    // can be independent of try/finally blocks, which contributes to saving about 40% off the CPU\n    // overhead of computed evaluation (on V8 at least).\n\n    try {\n      const readFunction = state.readFunction\n      return state.evaluatorFunctionTarget ? readFunction.call(state.evaluatorFunctionTarget) : readFunction()\n    } finally {\n      dependencyDetection.end()\n\n      // For each subscription no longer being used, remove it from the active subscriptions list and dispose it\n      if (dependencyDetectionContext.disposalCount && !state.isSleeping) {\n        objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback)\n      }\n\n      state.isStale = state.isDirty = false\n    }\n  },\n  peek(forceEvaluate) {\n    // Peek won't ordinarily re-evaluate, except while the computed is sleeping\n    //  or to get the initial value when \"deferEvaluation\" is set.\n    const state = this[computedState]\n    if (\n      (state.isDirty && (forceEvaluate || !state.dependenciesCount)) ||\n      (state.isSleeping && this.haveDependenciesChanged())\n    ) {\n      this.evaluateImmediate()\n    }\n    return state.latestValue\n  },\n\n  get [LATEST_VALUE]() {\n    return this.peek()\n  },\n\n  limit(limitFunction) {\n    const state = this[computedState]\n    // Override the limit function with one that delays evaluation as well\n    ;(subscribable.fn as any).limit.call(this, limitFunction)\n    Object.assign(this, {\n      _evalIfChanged() {\n        if (!this[computedState].isSleeping) {\n          if (this[computedState].isStale) {\n            this.evaluateImmediate()\n          } else {\n            this[computedState].isDirty = false\n          }\n        }\n        return state.latestValue\n      },\n      _evalDelayed(isChange) {\n        this._limitBeforeChange(state.latestValue)\n\n        // Mark as dirty\n        state.isDirty = true\n        if (isChange) {\n          state.isStale = true\n        }\n\n        // Pass the observable to the \"limit\" code, which will evaluate it when\n        // it's time to do the notification.\n        this._limitChange(this, !isChange /* isDirty */)\n      }\n    })\n  },\n  dispose() {\n    const state = this[computedState]\n    if (!state.isSleeping && state.dependencyTracking) {\n      objectForEach(state.dependencyTracking, function (id, dependency) {\n        if (dependency.dispose) {\n          dependency.dispose()\n        }\n      })\n    }\n    if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {\n      removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback)\n    }\n    Object.assign(state, DISPOSED_STATE)\n  }\n}\n\nconst pureComputedOverrides = {\n  beforeSubscriptionAdd(event: string) {\n    // If asleep, wake up the computed by subscribing to any dependencies.\n    const computedObservable = this,\n      state = computedObservable[computedState]\n    if (!state.isDisposed && state.isSleeping && event === 'change') {\n      state.isSleeping = false\n      if (state.isStale || computedObservable.haveDependenciesChanged()) {\n        state.dependencyTracking = null\n        state.dependenciesCount = 0\n        if (computedObservable.evaluateImmediate()) {\n          computedObservable.updateVersion()\n        }\n      } else {\n        // First put the dependencies in order\n        const dependenciesOrder = new Array()\n        objectForEach(state.dependencyTracking, function (id, dependency) {\n          dependenciesOrder[dependency._order] = id\n        })\n        // Next, subscribe to each one\n        arrayForEach(dependenciesOrder, function (id, order) {\n          const dependency = state.dependencyTracking[id],\n            subscription = computedObservable.subscribeToDependency(dependency._target)\n          subscription._order = order\n          subscription._version = dependency._version\n          state.dependencyTracking[id] = subscription\n        })\n\n        // Waking dependencies may have triggered effects\n        if (computedObservable.haveDependenciesChanged()) {\n          if (computedObservable.evaluateImmediate()) {\n            computedObservable.updateVersion()\n          }\n        }\n      }\n\n      if (!state.isDisposed) {\n        // test since evaluating could trigger disposal\n        computedObservable.notifySubscribers(state.latestValue, 'awake')\n      }\n    }\n  },\n  afterSubscriptionRemove(event: string) {\n    const state = this[computedState]\n    if (!state.isDisposed && event === 'change' && !this.hasSubscriptionsForEvent('change')) {\n      objectForEach(state.dependencyTracking, function (id, dependency) {\n        if (dependency.dispose) {\n          state.dependencyTracking[id] = {\n            _target: dependency._target,\n            _order: dependency._order,\n            _version: dependency._version\n          }\n          dependency.dispose()\n        }\n      })\n      state.isSleeping = true\n      this.notifySubscribers(undefined, 'asleep')\n    }\n  },\n  getVersion() {\n    // Because a pure computed is not automatically updated while it is sleeping, we can't\n    // simply return the version number. Instead, we check if any of the dependencies have\n    // changed and conditionally re-evaluate the computed observable.\n    const state = this[computedState]\n    if (state.isSleeping && (state.isStale || this.haveDependenciesChanged())) {\n      this.evaluateImmediate()\n    }\n    return subscribable.fn.getVersion.call(this)\n  }\n}\n\nconst deferEvaluationOverrides = {\n  beforeSubscriptionAdd(event) {\n    // This will force a computed with deferEvaluation to evaluate when the first subscription is registered.\n    if (event === 'change' || event === 'beforeChange') {\n      this.peek()\n    }\n  }\n}\n\nObject.setPrototypeOf(computed.fn, subscribable.fn)\n\n// Set the proto values for ko.computed\nconst protoProp = observable.protoProperty // == \"__ko_proto__\"\ncomputed.fn[protoProp] = computed\n\n/* This is used by ko.isObservable */\nobservable.observablePrototypes.add(computed as any)\n\nexport function isComputed<T = any>(instance: any): instance is Computed<T> {\n  return typeof instance === 'function' && instance[protoProp] === computed\n}\n\nexport function isPureComputed<T = any>(instance: any): instance is PureComputed<T> {\n  return isComputed(instance) && instance[computedState] && (instance[computedState] as unknown as State).pure\n}\n\nexport function pureComputed<T = any>(\n  evaluatorFunctionOrOptions: ComputedOptions | ComputedReadFunction,\n  evaluatorFunctionTarget?\n): Computed<T> {\n  if (typeof evaluatorFunctionOrOptions === 'function') {\n    const evaluator = evaluatorFunctionOrOptions as ComputedReadFunction\n    return computed(evaluator, evaluatorFunctionTarget, { pure: true })\n  } else {\n    let options = evaluatorFunctionOrOptions as ComputedOptions\n    options = extend({}, options) // make a copy of the parameter object\n    options.pure = true\n    return computed(options, evaluatorFunctionTarget)\n  }\n}\n"],
+  "mappings": "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",
   "names": ["options", "subscribable"]
 }

dist/index.cjs

@@ -1,2 +0,2 @@
-// @tko/computed 🥊 4.0.0 CommonJS
+// @tko/computed 🥊 4.0.1 CommonJS
 "use strict";
@@ -7,6 +7,2 @@ var __defProp = Object.defineProperty;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
 var __export = (target, all) => {
@@ -25,34 +21,2 @@ for (var name in all)
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __await = function(promise, isYieldStar) {
-  this[0] = promise;
-  this[1] = isYieldStar;
-};
-var __yieldStar = (value) => {
-  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
-  if (obj == null) {
-    obj = value[__knownSymbol("iterator")]();
-    method = (k) => it[k] = (x) => obj[k](x);
-  } else {
-    obj = obj.call(value);
-    method = (k) => it[k] = (v) => {
-      if (isAwait) {
-        isAwait = false;
-        if (k === "throw") throw v;
-        return v;
-      }
-      isAwait = true;
-      return {
-        done: false,
-        value: new __await(new Promise((resolve) => {
-          var x = obj[k](v);
-          if (!(x instanceof Object)) __typeError("Object expected");
-          resolve(x);
-        }), 1)
-      };
-    };
-  }
-  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
-    throw x;
-  }, "return" in obj && method("return"), it;
-};
 
@@ -72,1224 +36,6 @@ // index.ts
 
-// ../utils/dist/array.js
-var { isArray } = Array;
-function arrayForEach(array, action, actionOwner) {
-  if (arguments.length > 2) {
-    action = action.bind(actionOwner);
-  }
-  for (let i = 0, j = array.length; i < j; ++i) {
-    action(array[i], i, array);
-  }
-}
-function arrayIndexOf(array, item) {
-  return (isArray(array) ? array : [...array]).indexOf(item);
-}
-function arrayRemoveItem(array, itemToRemove) {
-  const index = arrayIndexOf(array, itemToRemove);
-  if (index > 0) {
-    array.splice(index, 1);
-  } else if (index === 0) {
-    array.shift();
-  }
-}
-function findMovesInArrayComparison(left, right, limitFailedCompares) {
-  if (left.length && right.length) {
-    let failedCompares, l, r, leftItem, rightItem;
-    for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
-      for (r = 0; rightItem = right[r]; ++r) {
-        if (leftItem.value === rightItem.value) {
-          leftItem.moved = rightItem.index;
-          rightItem.moved = leftItem.index;
-          right.splice(r, 1);
-          failedCompares = r = 0;
-          break;
-        }
-      }
-      failedCompares += r;
-    }
-  }
-}
-var statusNotInOld = "added";
-var statusNotInNew = "deleted";
-function compareArrays(oldArray, newArray, options2) {
-  options2 = typeof options2 === "boolean" ? { dontLimitMoves: options2 } : options2 || {};
-  oldArray = oldArray || [];
-  newArray = newArray || [];
-  if (oldArray.length < newArray.length) {
-    return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options2);
-  } else {
-    return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options2);
-  }
-}
-function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options2) {
-  let myMin = Math.min, myMax = Math.max, editDistanceMatrix = new Array(), smlIndex, smlIndexMax = smlArray.length, bigIndex, bigIndexMax = bigArray.length, compareRange = bigIndexMax - smlIndexMax || 1, maxDistance = smlIndexMax + bigIndexMax + 1, thisRow, lastRow, bigIndexMaxForRow, bigIndexMinForRow;
-  for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
-    lastRow = thisRow;
-    editDistanceMatrix.push(thisRow = new Array());
-    bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange);
-    bigIndexMinForRow = myMax(0, smlIndex - 1);
-    for (bigIndex = bigIndexMinForRow; bigIndex <= bigIndexMaxForRow; bigIndex++) {
-      if (!bigIndex) {
-        thisRow[bigIndex] = smlIndex + 1;
-      } else if (!smlIndex) {
-        thisRow[bigIndex] = bigIndex + 1;
-      } else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1]) {
-        thisRow[bigIndex] = lastRow[bigIndex - 1];
-      } else {
-        const northDistance = lastRow[bigIndex] || maxDistance;
-        const westDistance = thisRow[bigIndex - 1] || maxDistance;
-        thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;
-      }
-    }
-  }
-  let editScript = new Array(), meMinusOne, notInSml = new Array(), notInBig = new Array();
-  for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex; ) {
-    meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1;
-    if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex - 1]) {
-      notInSml.push(
-        editScript[editScript.length] = {
-          // added
-          status: statusNotInSml,
-          value: bigArray[--bigIndex],
-          index: bigIndex
-        }
-      );
-    } else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
-      notInBig.push(
-        editScript[editScript.length] = {
-          // deleted
-          status: statusNotInBig,
-          value: smlArray[--smlIndex],
-          index: smlIndex
-        }
-      );
-    } else {
-      --bigIndex;
-      --smlIndex;
-      if (!(options2 == null ? void 0 : options2.sparse)) {
-        editScript.push({ status: "retained", value: bigArray[bigIndex] });
-      }
-    }
-  }
-  findMovesInArrayComparison(notInBig, notInSml, !options2.dontLimitMoves && smlIndexMax * 10);
-  return editScript.reverse();
-}
-
-// ../utils/dist/options.js
-var Options = class {
-  constructor() {
-    this.bindingStringPreparsers = [];
-    this.knockoutInstance = null;
-    this.deferUpdates = false;
-    this.useOnlyNativeEvents = true;
-    this.useTemplateTag = true;
-    this.protoProperty = "__ko_proto__";
-    this.defaultBindingAttribute = "data-bind";
-    this.allowVirtualElements = true;
-    this.bindingGlobals = /* @__PURE__ */ Object.create(null);
-    this.createChildContextWithAs = false;
-    this.disableJQueryUsage = false;
-    this.Promise = globalThis.Promise;
-    this.taskScheduler = null;
-    this.debug = false;
-    this.templateSizeLimit = 4096;
-    this.allowScriptTagsInTemplates = false;
-    this._sanitizeWarningLogged = false;
-    this.global = globalThis;
-    this.document = globalThis.document;
-    this.filters = {};
-    this.includeDestroyed = false;
-    this.foreachHidesDestroyed = false;
-  }
-  get jQuery() {
-    var _a;
-    if (this.disableJQueryUsage) return;
-    return (_a = this._jQuery) != null ? _a : globalThis.jQuery;
-  }
-  /**
-   * Set jQuery manuall to be used by TKO.
-   * @param jQuery If jQuery set to undefined, TKO will not use jQuery and this.disableJQueryUsage to true.
-   */
-  set jQuery(jQuery) {
-    if (!jQuery) {
-      this.disableJQueryUsage = true;
-      this._jQuery = void 0;
-    } else {
-      this._jQuery = jQuery;
-      this.disableJQueryUsage = false;
-    }
-  }
-  /**
-   * Sanitize HTML templates before parsing them. Default is a no-op.
-   * Please configure something like DOMPurify or validator.js for your environment.
-   * @param html HTML string to be sanitized
-   * @returns Sanitized HTML string
-   */
-  sanitizeHtmlTemplate(html) {
-    if (!this._sanitizeWarningLogged) {
-      console.warn(
-        "WARNING -- You don't have a HTML sanitizer configured. Please configure options.sanitizeHtmlTemplate to avoid XSS vulnerabilities."
-      );
-      this._sanitizeWarningLogged = true;
-    }
-    return html;
-  }
-  onError(e, throws = true) {
-    if (throws) throw e;
-    return e;
-  }
-  set(name, value) {
-    this[name] = value;
-  }
-  // Overload getBindingHandler to have a custom lookup function.
-  getBindingHandler(key) {
-    return null;
-  }
-  cleanExternalData(node, callback) {
-  }
-};
-var options = new Options();
-var options_default = options;
-
-// ../utils/dist/error.js
-function catchFunctionErrors(delegate) {
-  if (!options_default.onError) {
-    return delegate;
-  }
-  return (...args) => {
-    try {
-      return delegate(...args);
-    } catch (err) {
-      options_default.onError(err);
-    }
-  };
-}
-function deferError(error) {
-  safeSetTimeout(function() {
-    throw error;
-  }, 0);
-}
-function safeSetTimeout(handler, timeout) {
-  return setTimeout(catchFunctionErrors(handler), timeout);
-}
-
-// ../utils/dist/async.js
-function throttle(callback, timeout) {
-  let timeoutInstance;
-  return function(...args) {
-    if (!timeoutInstance) {
-      timeoutInstance = safeSetTimeout(function() {
-        timeoutInstance = void 0;
-        callback(...args);
-      }, timeout);
-    }
-  };
-}
-function debounce(callback, timeout) {
-  let timeoutInstance;
-  return function(...args) {
-    clearTimeout(timeoutInstance);
-    timeoutInstance = safeSetTimeout(() => callback(...args), timeout);
-  };
-}
-
-// ../utils/dist/object.js
-function hasOwnProperty(obj, propName) {
-  return Object.prototype.hasOwnProperty.call(obj, propName);
-}
-function extend(target, source) {
-  if (source) {
-    for (const prop of Object.keys(source)) {
-      if (hasOwnProperty(source, prop)) {
-        ;
-        target[prop] = source[prop];
-      }
-    }
-  }
-  return target;
-}
-function objectForEach(obj, action) {
-  for (const prop in obj) {
-    if (hasOwnProperty(obj, prop)) {
-      action(prop, obj[prop]);
-    }
-  }
-}
-
-// ../utils/dist/function.js
-function testOverwrite() {
-  try {
-    Object.defineProperty(function x() {
-    }, "length", {});
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-var functionSupportsLengthOverwrite = testOverwrite();
-function overwriteLengthPropertyIfSupported(fn, descriptor) {
-  if (functionSupportsLengthOverwrite) {
-    Object.defineProperty(fn, "length", descriptor);
-  }
-}
-
-// ../utils/dist/symbol.js
-var useSymbols = typeof Symbol === "function";
-function createSymbolOrString(identifier) {
-  return useSymbols ? Symbol(identifier) : identifier;
-}
-
-// ../utils/dist/dom/info.js
-function domNodeIsContainedBy(node, containedByNode) {
-  if (node === containedByNode) {
-    return true;
-  }
-  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
-    return false;
-  }
-  if (containedByNode.contains) {
-    return containedByNode.contains(node.nodeType !== Node.ELEMENT_NODE ? node.parentNode : node);
-  }
-  if (containedByNode.compareDocumentPosition) {
-    return (containedByNode.compareDocumentPosition(node) & 16) == 16;
-  }
-  let parentNode = node;
-  while (parentNode && parentNode != containedByNode) {
-    parentNode = parentNode.parentNode;
-  }
-  return !!parentNode;
-}
-function domNodeIsAttachedToDocument(node) {
-  return domNodeIsContainedBy(node, node.ownerDocument.documentElement);
-}
-function tagNameLower(element) {
-  return element && element.tagName && element.tagName.toLowerCase();
-}
-
-// ../utils/dist/dom/event.js
-var knownEvents = {};
-var knownEventTypesByEventName = {};
-knownEvents["UIEvents"] = ["keyup", "keydown", "keypress"];
-knownEvents["MouseEvents"] = [
-  "click",
-  "dblclick",
-  "mousedown",
-  "mouseup",
-  "mousemove",
-  "mouseover",
-  "mouseout",
-  "mouseenter",
-  "mouseleave"
-];
-objectForEach(knownEvents, function(eventType, knownEventsForType) {
-  if (knownEventsForType.length) {
-    for (let i = 0, j = knownEventsForType.length; i < j; i++) {
-      knownEventTypesByEventName[knownEventsForType[i]] = eventType;
-    }
-  }
-});
-
-// ../utils/dist/dom/data.js
-var datastoreTime = (/* @__PURE__ */ new Date()).getTime();
-var dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`;
-var dataStoreSymbol = /* @__PURE__ */ Symbol("Knockout data");
-var uniqueId = 0;
-function isSafeKey(key) {
-  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
-}
-function getDataForNode(node, createIfNotFound) {
-  let dataForNode = node[dataStoreSymbol];
-  if (!dataForNode && createIfNotFound) {
-    dataForNode = node[dataStoreSymbol] = {};
-  }
-  return dataForNode;
-}
-function nextKey() {
-  return uniqueId++ + dataStoreKeyExpandoPropertyName;
-}
-function get(node, key) {
-  if (!isSafeKey(key)) throw new Error("Unsafe key for DOM data: " + key);
-  const dataForNode = getDataForNode(node, false);
-  return dataForNode && dataForNode[key];
-}
-function set(node, key, value) {
-  if (!isSafeKey(key)) throw new Error("Unsafe key for DOM data: " + key);
-  const dataForNode = getDataForNode(
-    node,
-    value !== void 0
-    /* createIfNotFound */
-  );
-  if (dataForNode) {
-    dataForNode[key] = value;
-  }
-}
-
-// ../utils/dist/dom/disposal.js
-var domDataKey = nextKey();
-function getDisposeCallbacksCollection(node, createIfNotFound) {
-  let allDisposeCallbacks = get(node, domDataKey);
-  if (allDisposeCallbacks === void 0 && createIfNotFound) {
-    allDisposeCallbacks = new Array();
-    set(node, domDataKey, allDisposeCallbacks);
-  }
-  return allDisposeCallbacks;
-}
-function destroyCallbacksCollection(node) {
-  set(node, domDataKey, void 0);
-}
-function addDisposeCallback(node, callback) {
-  if (typeof callback !== "function") {
-    throw new Error("Callback must be a function");
-  }
-  getDisposeCallbacksCollection(node, true).push(callback);
-}
-function removeDisposeCallback(node, callback) {
-  const callbacksCollection = getDisposeCallbacksCollection(node, false);
-  if (callbacksCollection) {
-    arrayRemoveItem(callbacksCollection, callback);
-    if (callbacksCollection.length === 0) {
-      destroyCallbacksCollection(node);
-    }
-  }
-}
-var otherNodeCleanerFunctions = new Array();
-function cleanjQueryData(node) {
-  const jQueryCleanNodeFn = options_default.jQuery ? options_default.jQuery.cleanData : null;
-  if (jQueryCleanNodeFn) {
-    jQueryCleanNodeFn([node]);
-  }
-}
-otherNodeCleanerFunctions.push(cleanjQueryData);
-
-// ../utils/dist/dom/html.js
-var supportsTemplateTag = options_default.useTemplateTag && options_default.document && "content" in options_default.document.createElement("template");
-
-// ../utils/dist/dom/selectExtensions.js
-var hasDomDataExpandoProperty = /* @__PURE__ */ Symbol("Knockout selectExtensions hasDomDataProperty");
-var selectExtensions = {
-  optionValueDomDataKey: nextKey(),
-  readValue: function(element) {
-    switch (tagNameLower(element)) {
-      case "option": {
-        if (element[hasDomDataExpandoProperty] === true) {
-          return get(element, selectExtensions.optionValueDomDataKey);
-        }
-        return element.value;
-      }
-      case "select": {
-        const selectElement = element;
-        return selectElement.selectedIndex >= 0 ? selectExtensions.readValue(selectElement.options[selectElement.selectedIndex]) : void 0;
-      }
-      default:
-        return element.value;
-    }
-  },
-  writeValue: function(element, value, allowUnset) {
-    switch (tagNameLower(element)) {
-      case "option":
-        if (typeof value === "string") {
-          set(element, selectExtensions.optionValueDomDataKey, void 0);
-          if (hasDomDataExpandoProperty in element) {
-            delete element[hasDomDataExpandoProperty];
-          }
-          ;
-          element.value = value;
-        } else {
-          const el = element;
-          set(element, selectExtensions.optionValueDomDataKey, value);
-          el[hasDomDataExpandoProperty] = true;
-          el.value = typeof value === "number" ? value : "";
-        }
-        break;
-      case "select":
-        {
-          if (value === "" || value === null) {
-            value = void 0;
-          }
-          let selection = -1;
-          const selectElement = element;
-          for (let i = 0, n = selectElement.options.length, optionValue; i < n; ++i) {
-            optionValue = selectExtensions.readValue(selectElement.options[i]);
-            const strictEqual = optionValue === value;
-            const blankEqual = optionValue === "" && value === void 0;
-            const numericEqual = typeof value === "number" && Number(optionValue) === value;
-            if (strictEqual || blankEqual || numericEqual) {
-              selection = i;
-              break;
-            }
-          }
-          if (allowUnset || selection >= 0 || value === void 0 && selectElement.size > 1) {
-            selectElement.selectedIndex = selection;
-          }
-        }
-        break;
-      default:
-        if (value === null || value === void 0) {
-          value = "";
-        }
-        ;
-        element.value = value;
-        break;
-    }
-  }
-};
-
-// ../utils/dist/tasks.js
-var tasks_exports = {};
-__export(tasks_exports, {
-  cancel: () => cancel,
-  resetForTesting: () => resetForTesting,
-  runEarly: () => processTasks,
-  schedule: () => schedule
-});
-var taskQueue = new Array();
-var taskQueueLength = 0;
-var nextHandle = 1;
-var nextIndexToProcess = 0;
-var w = options_default.global;
-if (w && w.MutationObserver && !(w.navigator && w.navigator.standalone)) {
-  options_default.taskScheduler = (function(callback) {
-    const div = w.document.createElement("div");
-    new w.MutationObserver(callback).observe(div, { attributes: true });
-    return function() {
-      div.classList.toggle("foo");
-    };
-  })(scheduledProcess);
-} else {
-  options_default.taskScheduler = function(callback) {
-    setTimeout(callback, 0);
-  };
-}
-function processTasks() {
-  if (taskQueueLength) {
-    let mark = taskQueueLength, countMarks = 0;
-    for (let task; nextIndexToProcess < taskQueueLength; ) {
-      if (task = taskQueue[nextIndexToProcess++]) {
-        if (nextIndexToProcess > mark) {
-          if (++countMarks >= 5e3) {
-            nextIndexToProcess = taskQueueLength;
-            deferError(Error("'Too much recursion' after processing " + countMarks + " task groups."));
-            break;
-          }
-          mark = taskQueueLength;
-        }
-        try {
-          task();
-        } catch (ex) {
-          deferError(ex);
-        }
-      }
-    }
-  }
-}
-function scheduledProcess() {
-  processTasks();
-  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
-}
-function scheduleTaskProcessing() {
-  options_default.taskScheduler(scheduledProcess);
-}
-function schedule(func) {
-  if (!taskQueueLength) {
-    scheduleTaskProcessing();
-  }
-  taskQueue[taskQueueLength++] = func;
-  return nextHandle++;
-}
-function cancel(handle) {
-  const index = handle - (nextHandle - taskQueueLength);
-  if (index >= nextIndexToProcess && index < taskQueueLength) {
-    taskQueue[index] = null;
-  }
-}
-function resetForTesting() {
-  const length = taskQueueLength - nextIndexToProcess;
-  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
-  return length;
-}
-
-// ../observable/dist/dependencyDetection.js
-var dependencyDetection_exports = {};
-__export(dependencyDetection_exports, {
-  begin: () => begin,
-  end: () => end,
-  getDependencies: () => getDependencies,
-  getDependenciesCount: () => getDependenciesCount,
-  ignore: () => ignore,
-  ignoreDependencies: () => ignore,
-  isInitial: () => isInitial,
-  registerDependency: () => registerDependency
-});
-
-// ../observable/dist/subscribableSymbol.js
-var SUBSCRIBABLE_SYM = /* @__PURE__ */ Symbol("Knockout Subscribable");
-function isSubscribable(instance) {
-  return instance && instance[SUBSCRIBABLE_SYM] || false;
-}
-
-// ../observable/dist/dependencyDetection.js
-var outerFrames = new Array();
-var currentFrame;
-var lastId = 0;
-function getId() {
-  return ++lastId;
-}
-function begin(options2) {
-  outerFrames.push(currentFrame);
-  currentFrame = options2;
-}
-function end() {
-  currentFrame = outerFrames.pop();
-}
-function registerDependency(subscribable2) {
-  if (currentFrame) {
-    if (!isSubscribable(subscribable2)) {
-      throw new Error("Only subscribable things can act as dependencies");
-    }
-    currentFrame.callback.call(
-      currentFrame.callbackTarget,
-      subscribable2,
-      subscribable2._id || (subscribable2._id = getId())
-    );
-  }
-}
-function ignore(callback, callbackTarget, callbackArgs) {
-  try {
-    begin();
-    return callback.apply(callbackTarget, callbackArgs || []);
-  } finally {
-    end();
-  }
-}
-function getDependenciesCount() {
-  if (currentFrame) {
-    return currentFrame.computed.getDependenciesCount();
-  }
-  return void 0;
-}
-function getDependencies() {
-  if (currentFrame) {
-    return currentFrame.computed.getDependencies();
-  }
-  return void 0;
-}
-function isInitial() {
-  if (currentFrame) {
-    return currentFrame.isInitial;
-  }
-  return void 0;
-}
-
-// ../observable/dist/defer.js
-function deferUpdates(target) {
-  if (target._deferUpdates) {
-    return;
-  }
-  target._deferUpdates = true;
-  target.limit(function(callback) {
-    let handle;
-    let ignoreUpdates = false;
-    return function() {
-      if (!ignoreUpdates) {
-        tasks_exports.cancel(handle);
-        handle = tasks_exports.schedule(callback);
-        try {
-          ignoreUpdates = true;
-          target.notifySubscribers(void 0, "dirty");
-        } finally {
-          ignoreUpdates = false;
-        }
-      }
-    };
-  });
-}
-
-// ../observable/dist/Subscription.js
-var Subscription = class {
-  constructor(target, observer, disposeCallback) {
-    this._target = target;
-    this._callback = observer.next;
-    this._disposeCallback = disposeCallback;
-    this._isDisposed = false;
-    this._domNodeDisposalCallback = null;
-  }
-  dispose() {
-    if (this._domNodeDisposalCallback) {
-      removeDisposeCallback(this._node, this._domNodeDisposalCallback);
-    }
-    this._isDisposed = true;
-    this._disposeCallback();
-  }
-  disposeWhenNodeIsRemoved(node) {
-    this._node = node;
-    addDisposeCallback(node, this._domNodeDisposalCallback = this.dispose.bind(this));
-  }
-  // TC39 Observable API
-  unsubscribe() {
-    this.dispose();
-  }
-  get closed() {
-    return this._isDisposed;
-  }
-};
-
-// ../observable/dist/extenders.js
-var primitiveTypes = { undefined: 1, boolean: 1, number: 1, string: 1 };
-function valuesArePrimitiveAndEqual(a, b) {
-  const oldValueIsPrimitive = a === null || typeof a in primitiveTypes;
-  return oldValueIsPrimitive ? a === b : false;
-}
-function applyExtenders(requestedExtenders) {
-  let target = this;
-  if (requestedExtenders) {
-    objectForEach(requestedExtenders, function(key, value) {
-      const extenderHandler = extenders[key];
-      if (typeof extenderHandler === "function") {
-        target = extenderHandler(target, value) || target;
-      } else {
-        options_default.onError(new Error("Extender not found: " + key));
-      }
-    });
-  }
-  return target;
-}
-function notify(target, notifyWhen) {
-  target.equalityComparer = notifyWhen == "always" ? null : 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, options2) {
-  let timeout, method, limitFunction;
-  if (typeof options2 === "number") {
-    timeout = options2;
-  } else {
-    timeout = options2.timeout;
-    method = options2.method;
-  }
-  target._deferUpdates = false;
-  limitFunction = method === "notifyWhenChangesStop" ? debounce : throttle;
-  target.limit(function(callback) {
-    return limitFunction(callback, timeout);
-  });
-}
-var extenders = { notify, deferred, rateLimit };
-
-// ../observable/dist/subscribable.js
-var LATEST_VALUE = /* @__PURE__ */ Symbol("Knockout latest value");
-if (!Symbol.observable) {
-  Symbol.observable = /* @__PURE__ */ Symbol.for("@tko/Symbol.observable");
-}
-var subscribable = function subscribableFactory() {
-  Object.setPrototypeOf(this, ko_subscribable_fn);
-  ko_subscribable_fn.init(this);
-};
-var defaultEvent = "change";
-var ko_subscribable_fn = {
-  [SUBSCRIBABLE_SYM]: true,
-  [Symbol.observable]() {
-    return this;
-  },
-  init(instance) {
-    instance._subscriptions = { change: [] };
-    instance._versionNumber = 1;
-  },
-  subscribe(callback, callbackTarget, event) {
-    const isTC39Callback = typeof callback === "object" && callback.next;
-    event = event || defaultEvent;
-    const observer = isTC39Callback ? callback : { next: callbackTarget ? callback.bind(callbackTarget) : callback };
-    const subscriptionInstance = new Subscription(this, observer, () => {
-      arrayRemoveItem(this._subscriptions[event], subscriptionInstance);
-      if (this.afterSubscriptionRemove) {
-        this.afterSubscriptionRemove(event);
-      }
-    });
-    if (this.beforeSubscriptionAdd) {
-      this.beforeSubscriptionAdd(event);
-    }
-    if (!this._subscriptions[event]) {
-      this._subscriptions[event] = new Array();
-    }
-    this._subscriptions[event].push(subscriptionInstance);
-    if (isTC39Callback && LATEST_VALUE in this) {
-      observer.next(this[LATEST_VALUE]);
-    }
-    return subscriptionInstance;
-  },
-  notifySubscribers(valueToNotify, event) {
-    event = event || defaultEvent;
-    if (event === defaultEvent) {
-      this.updateVersion();
-    }
-    if (this.hasSubscriptionsForEvent(event)) {
-      const subs = event === defaultEvent && this._changeSubscriptions || [...this._subscriptions[event]];
-      try {
-        begin();
-        for (let i = 0, subscriptionInstance; subscriptionInstance = subs[i]; ++i) {
-          if (!subscriptionInstance._isDisposed) {
-            subscriptionInstance._callback(valueToNotify);
-          }
-        }
-      } finally {
-        end();
-      }
-    }
-  },
-  getVersion() {
-    return this._versionNumber;
-  },
-  hasChanged(versionToCheck) {
-    return this.getVersion() !== versionToCheck;
-  },
-  updateVersion() {
-    ++this._versionNumber;
-  },
-  hasSubscriptionsForEvent(event) {
-    return this._subscriptions[event] && this._subscriptions[event].length;
-  },
-  getSubscriptionsCount(event) {
-    if (event) {
-      return this._subscriptions[event] && this._subscriptions[event].length || 0;
-    } else {
-      let total = 0;
-      objectForEach(this._subscriptions, function(eventName, subscriptions) {
-        if (eventName !== "dirty") {
-          total += subscriptions.length;
-        }
-      });
-      return total;
-    }
-  },
-  isDifferent(oldValue, newValue) {
-    return !this.equalityComparer || !this.equalityComparer(oldValue, newValue);
-  },
-  once(cb) {
-    const subs = this.subscribe((nv) => {
-      subs.dispose();
-      cb(nv);
-    });
-  },
-  when(test, returnValue) {
-    const current = this.peek();
-    const givenRv = arguments.length > 1;
-    const testFn = typeof test === "function" ? test : (v) => v === test;
-    if (testFn(current)) {
-      return options_default.Promise.resolve(givenRv ? returnValue : current);
-    }
-    return new options_default.Promise((resolve, reject) => {
-      const subs = this.subscribe((newValue) => {
-        if (testFn(newValue)) {
-          subs.dispose();
-          resolve(givenRv ? returnValue : newValue);
-        }
-      });
-    });
-  },
-  yet(test, ...args) {
-    const testFn = typeof test === "function" ? test : (v) => v === test;
-    const negated = (v) => !testFn(v);
-    return this.when(negated, ...args);
-  },
-  next() {
-    return new Promise((resolve) => this.once(resolve));
-  },
-  toString() {
-    return "[object Object]";
-  },
-  extend: applyExtenders
-};
-Object.setPrototypeOf(ko_subscribable_fn, Function.prototype);
-subscribable.fn = ko_subscribable_fn;
-
-// ../observable/dist/observable.js
-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 {
-      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_default.deferUpdates) {
-    deferUpdates(Observable);
-  }
-  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, peek22 = true) {
-    this(fn(peek22 ? this.peek() : this()));
-  },
-  // Some observables may not always be writeable, notably computeds.
-  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);
-  }
-}
-subscribable.fn.limit = function limit(limitFunction) {
-  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;
-  }
-  const 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
-        /* evaluate */
-      ))) {
-        notifyNextChange = true;
-      }
-    },
-    _recordUpdate() {
-      didUpdate = true;
-    }
-  });
-};
-Object.setPrototypeOf(observable.fn, subscribable.fn);
-var protoProperty = observable.protoProperty = options_default.protoProperty;
-observable.fn[protoProperty] = observable;
-observable.observablePrototypes = /* @__PURE__ */ new Set([observable]);
-function isObservable(instance) {
-  const proto = typeof instance === "function" && instance[protoProperty];
-  if (proto && !observable.observablePrototypes.has(proto)) {
-    throw Error("Invalid object that looks like an observable; possibly from another Knockout instance");
-  }
-  return !!proto;
-}
-function unwrap(value) {
-  return isObservable(value) ? value() : value;
-}
-
-// ../observable/dist/observableArray.changeTracking.js
-var arrayChangeEventName = "arrayChange";
-function trackArrayChanges(target, options2) {
-  target.compareArrayOptions = {};
-  if (options2 && typeof options2 === "object") {
-    extend(target.compareArrayOptions, options2);
-  }
-  target.compareArrayOptions.sparse = true;
-  if (target.cacheDiffForKnownOperation) {
-    return;
-  }
-  let trackingChanges = false;
-  let cachedDiff = null;
-  let arrayChangeSubscription;
-  let pendingNotifications = 0;
-  let underlyingNotifySubscribersFunction;
-  const underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd;
-  const underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
-  target.beforeSubscriptionAdd = function(event) {
-    if (underlyingBeforeSubscriptionAddFunction) {
-      underlyingBeforeSubscriptionAddFunction.call(target, event);
-    }
-    if (event === arrayChangeEventName) {
-      trackChanges();
-    }
-  };
-  target.afterSubscriptionRemove = function(event) {
-    if (underlyingAfterSubscriptionRemoveFunction) {
-      underlyingAfterSubscriptionRemoveFunction.call(target, event);
-    }
-    if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
-      if (underlyingNotifySubscribersFunction) {
-        target.notifySubscribers = underlyingNotifySubscribersFunction;
-        underlyingNotifySubscribersFunction = void 0;
-      }
-      if (arrayChangeSubscription) {
-        arrayChangeSubscription.dispose();
-      }
-      arrayChangeSubscription = null;
-      trackingChanges = false;
-    }
-  };
-  function trackChanges() {
-    if (trackingChanges) {
-      return;
-    }
-    trackingChanges = true;
-    underlyingNotifySubscribersFunction = target["notifySubscribers"];
-    target.notifySubscribers = function(valueToNotify, event) {
-      if (!event || event === defaultEvent) {
-        ++pendingNotifications;
-      }
-      return underlyingNotifySubscribersFunction.apply(this, arguments);
-    };
-    let previousContents = new Array().concat(target.peek() === void 0 ? [] : target.peek());
-    cachedDiff = null;
-    arrayChangeSubscription = target.subscribe(function(currentContents) {
-      let changes;
-      currentContents = new Array().concat(currentContents || []);
-      if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
-        changes = getChanges(previousContents, currentContents);
-      }
-      previousContents = currentContents;
-      cachedDiff = null;
-      pendingNotifications = 0;
-      if (changes && changes.length) {
-        target.notifySubscribers(changes, arrayChangeEventName);
-      }
-    });
-  }
-  function getChanges(previousContents, currentContents) {
-    if (!cachedDiff || pendingNotifications > 1) {
-      cachedDiff = trackArrayChanges.compareArrays(previousContents, currentContents, target.compareArrayOptions);
-    }
-    return cachedDiff;
-  }
-  target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
-    if (!trackingChanges || pendingNotifications) {
-      return;
-    }
-    let diff = new Array(), arrayLength = rawArray.length, argsLength = args.length, offset = 0;
-    function pushDiff(status, value, index) {
-      return diff[diff.length] = { status, value, index };
-    }
-    switch (operationName) {
-      case "push":
-        offset = arrayLength;
-      case "unshift":
-        for (let index = 0; index < argsLength; index++) {
-          pushDiff("added", args[index], offset + index);
-        }
-        break;
-      case "pop":
-        offset = arrayLength - 1;
-      case "shift":
-        if (arrayLength) {
-          pushDiff("deleted", rawArray[offset], offset);
-        }
-        break;
-      case "splice":
-        {
-          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);
-        }
-        break;
-      default:
-        return;
-    }
-    cachedDiff = diff;
-  };
-}
-trackArrayChanges.compareArrays = compareArrays;
-extenders.trackArrayChanges = trackArrayChanges;
-
-// ../observable/dist/observableArray.js
-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."
-    );
-  }
-  const result = Object.setPrototypeOf(observable(initialValues), observableArray.fn);
-  trackArrayChanges(result);
-  overwriteLengthPropertyIfSupported(result, { get: () => {
-    var _a;
-    return (_a = result()) == null ? void 0 : _a.length;
-  } });
-  return result;
-}
-observableArray.fn = {
-  remove(valueOrPredicate) {
-    const underlyingArray = this.peek();
-    const removedValues = new Array();
-    const predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value) {
-      return value === valueOrPredicate;
-    };
-    for (let i = 0; i < underlyingArray.length; i++) {
-      const value = underlyingArray[i];
-      if (predicate(value)) {
-        if (removedValues.length === 0) {
-          this.valueWillMutate();
-        }
-        if (underlyingArray[i] !== value) {
-          throw Error("Array modified during remove; cannot remove item");
-        }
-        removedValues.push(value);
-        underlyingArray.splice(i, 1);
-        i--;
-      }
-    }
-    if (removedValues.length) {
-      this.valueHasMutated();
-    }
-    return removedValues;
-  },
-  removeAll(arrayOfValues) {
-    if (arrayOfValues === void 0) {
-      const underlyingArray = this.peek();
-      const allValues = underlyingArray.slice(0);
-      this.valueWillMutate();
-      underlyingArray.splice(0, underlyingArray.length);
-      this.valueHasMutated();
-      return allValues;
-    }
-    if (!arrayOfValues) {
-      return [];
-    }
-    return this["remove"](function(value) {
-      return arrayIndexOf(arrayOfValues, value) >= 0;
-    });
-  },
-  destroy(valueOrPredicate) {
-    const underlyingArray = this.peek();
-    const predicate = typeof valueOrPredicate === "function" && !isObservable(valueOrPredicate) ? valueOrPredicate : function(value) {
-      return value === valueOrPredicate;
-    };
-    this.valueWillMutate();
-    for (let i = underlyingArray.length - 1; i >= 0; i--) {
-      const value = underlyingArray[i];
-      if (predicate(value)) {
-        value["_destroy"] = true;
-      }
-    }
-    this.valueHasMutated();
-  },
-  destroyAll(arrayOfValues) {
-    if (arrayOfValues === void 0) {
-      return this.destroy(function() {
-        return true;
-      });
-    }
-    if (!arrayOfValues) {
-      return [];
-    }
-    return this.destroy(function(value) {
-      return arrayIndexOf(arrayOfValues, value) >= 0;
-    });
-  },
-  indexOf(item) {
-    return arrayIndexOf(this(), item);
-  },
-  replace(oldItem, newItem) {
-    const index = this.indexOf(oldItem);
-    if (index >= 0) {
-      this.valueWillMutate();
-      this.peek()[index] = newItem;
-      this.valueHasMutated();
-    }
-  },
-  sorted(compareFn) {
-    return [...this()].sort(compareFn);
-  },
-  reversed() {
-    return [...this()].reverse();
-  },
-  [Symbol.iterator]: function* () {
-    yield* __yieldStar(this());
-  }
-};
-Object.setPrototypeOf(observableArray.fn, observable.fn);
-arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function(methodName) {
-  observableArray.fn[methodName] = function() {
-    const underlyingArray = this.peek();
-    this.valueWillMutate();
-    this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
-    const methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
-    this.valueHasMutated();
-    return methodCallResult === underlyingArray ? this : methodCallResult;
-  };
-});
-arrayForEach(["slice"], function(methodName) {
-  observableArray.fn[methodName] = function() {
-    const underlyingArray = this();
-    return underlyingArray[methodName].apply(underlyingArray, arguments);
-  };
-});
-observableArray.trackArrayChanges = trackArrayChanges;
-
 // src/computed.ts
-var computedState = createSymbolOrString("_state");
+var import_utils = require("@tko/utils");
+var import_observable = require("@tko/observable");
+var computedState = (0, import_utils.createSymbolOrString)("_state");
 var DISPOSED_STATE = {
@@ -1349,3 +95,3 @@ dependencyTracking: null,
       if (!state.isDisposed) {
-        dependencyDetection_exports.registerDependency(computedObservable);
+        import_observable.dependencyDetection.registerDependency(computedObservable);
       }
@@ -1361,3 +107,3 @@ if (state.isDirty || state.isSleeping && computedObservable.haveDependenciesChanged()) {
   computedObservable.isWriteable = typeof writeFunction === "function";
-  subscribable.fn.init(computedObservable);
+  import_observable.subscribable.fn.init(computedObservable);
   Object.setPrototypeOf(computedObservable, computed.fn);
@@ -1367,10 +113,10 @@ if (options2.pure) {
     state.isSleeping = true;
-    extend(computedObservable, pureComputedOverrides);
+    (0, import_utils.extend)(computedObservable, pureComputedOverrides);
   } else if (options2.deferEvaluation) {
-    extend(computedObservable, deferEvaluationOverrides);
+    (0, import_utils.extend)(computedObservable, deferEvaluationOverrides);
   }
-  if (options_default.deferUpdates) {
-    extenders.deferred(computedObservable, true);
+  if (import_utils.options.deferUpdates) {
+    import_observable.extenders.deferred(computedObservable, true);
   }
-  if (options_default.debug) {
+  if (import_utils.options.debug) {
     computedObservable._options = options2;
@@ -1389,3 +135,3 @@ }
   if (state.disposeWhenNodeIsRemoved && computedObservable.isActive()) {
-    addDisposeCallback(
+    (0, import_utils.addDisposeCallback)(
       state.disposeWhenNodeIsRemoved,
@@ -1425,3 +171,3 @@ state.domNodeDisposalCallback = function() {
 computed.fn = {
-  equalityComparer: valuesArePrimitiveAndEqual,
+  equalityComparer: import_observable.valuesArePrimitiveAndEqual,
   getDependenciesCount() {
@@ -1433,3 +179,3 @@ return this[computedState].dependenciesCount;
     const dependentObservables = new Array();
-    objectForEach(dependencyTracking, function(id, dependency) {
+    (0, import_utils.objectForEach)(dependencyTracking, function(id, dependency) {
       dependentObservables[dependency._order] = dependency._target;
@@ -1450,3 +196,3 @@ });
     for (id in dependencyTracking) {
-      if (hasOwnProperty(dependencyTracking, id)) {
+      if ((0, import_utils.hasOwnProperty)(dependencyTracking, id)) {
         dependency = dependencyTracking[id];
@@ -1497,3 +243,3 @@ if (this._evalDelayed && dependency._target._notificationIsPending || dependency._target.hasChanged(dependency._version)) {
       clearTimeout(this[computedState].evaluationTimeoutInstance);
-      this[computedState].evaluationTimeoutInstance = safeSetTimeout(function() {
+      this[computedState].evaluationTimeoutInstance = (0, import_utils.safeSetTimeout)(function() {
         computedObservable.evaluateImmediate(
@@ -1517,3 +263,3 @@ true
   evaluateImmediate(notifyChange) {
-    let computedObservable = this, state = computedObservable[computedState], disposeWhen = state.disposeWhen, changed = false;
+    let state = this[computedState], disposeWhen = state.disposeWhen, changed = false;
     if (state.isBeingEvaluated) {
@@ -1525,5 +271,5 @@ return;
     }
-    if (state.disposeWhenNodeIsRemoved && !domNodeIsAttachedToDocument(state.disposeWhenNodeIsRemoved) || disposeWhen && disposeWhen()) {
+    if (state.disposeWhenNodeIsRemoved && !(0, import_utils.domNodeIsAttachedToDocument)(state.disposeWhenNodeIsRemoved) || disposeWhen && disposeWhen()) {
       if (!state.suppressDisposalUntilDisposeWhenReturnsFalse) {
-        computedObservable.dispose();
+        this.dispose();
         return;
@@ -1543,13 +289,13 @@ }
   evaluateImmediate_CallReadWithDependencyDetection(notifyChange) {
-    let computedObservable = this, state = computedObservable[computedState], changed = false;
-    const isInitial2 = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
-      computedObservable,
+    let state = this[computedState], changed = false;
+    const isInitial = state.pure ? void 0 : !state.dependenciesCount, dependencyDetectionContext = {
+      computedObservable: this,
       disposalCandidates: state.dependencyTracking,
       disposalCount: state.dependenciesCount
     };
-    dependencyDetection_exports.begin({
+    import_observable.dependencyDetection.begin({
       callbackTarget: dependencyDetectionContext,
       callback: computedBeginDependencyDetectionCallback,
-      computed: computedObservable,
-      isInitial: isInitial2
+      computed: this,
+      isInitial
     });
@@ -1560,27 +306,27 @@ state.dependencyTracking = {};
     if (!state.dependenciesCount) {
-      computedObservable.dispose();
+      this.dispose();
       changed = true;
     } else {
-      changed = computedObservable.isDifferent(state.latestValue, newValue);
+      changed = this.isDifferent(state.latestValue, newValue);
     }
     if (changed) {
       if (!state.isSleeping) {
-        computedObservable.notifySubscribers(state.latestValue, "beforeChange");
+        this.notifySubscribers(state.latestValue, "beforeChange");
       } else {
-        computedObservable.updateVersion();
+        this.updateVersion();
       }
       state.latestValue = newValue;
-      if (options_default.debug) {
-        computedObservable._latestValue = newValue;
+      if (import_utils.options.debug) {
+        this._latestValue = newValue;
       }
-      computedObservable.notifySubscribers(state.latestValue, "spectate");
+      this.notifySubscribers(state.latestValue, "spectate");
       if (!state.isSleeping && notifyChange) {
-        computedObservable.notifySubscribers(state.latestValue);
+        this.notifySubscribers(state.latestValue);
       }
-      if (computedObservable._recordUpdate) {
-        computedObservable._recordUpdate();
+      if (this._recordUpdate) {
+        this._recordUpdate();
       }
     }
-    if (isInitial2) {
-      computedObservable.notifySubscribers(state.latestValue, "awake");
+    if (isInitial) {
+      this.notifySubscribers(state.latestValue, "awake");
     }
@@ -1594,5 +340,5 @@ return changed;
     } finally {
-      dependencyDetection_exports.end();
+      import_observable.dependencyDetection.end();
       if (dependencyDetectionContext.disposalCount && !state.isSleeping) {
-        objectForEach(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback);
+        (0, import_utils.objectForEach)(dependencyDetectionContext.disposalCandidates, computedDisposeDependencyCallback);
       }
@@ -1609,3 +355,3 @@ state.isStale = state.isDirty = false;
   },
-  get [LATEST_VALUE]() {
+  get [import_observable.LATEST_VALUE]() {
     return this.peek();
@@ -1615,3 +361,3 @@ },
     const state = this[computedState];
-    subscribable.fn.limit.call(this, limitFunction);
+    import_observable.subscribable.fn.limit.call(this, limitFunction);
     Object.assign(this, {
@@ -1645,3 +391,3 @@ _evalIfChanged() {
     if (!state.isSleeping && state.dependencyTracking) {
-      objectForEach(state.dependencyTracking, function(id, dependency) {
+      (0, import_utils.objectForEach)(state.dependencyTracking, function(id, dependency) {
         if (dependency.dispose) {
@@ -1653,3 +399,3 @@ dependency.dispose();
     if (state.disposeWhenNodeIsRemoved && state.domNodeDisposalCallback) {
-      removeDisposeCallback(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback);
+      (0, import_utils.removeDisposeCallback)(state.disposeWhenNodeIsRemoved, state.domNodeDisposalCallback);
     }
@@ -1672,6 +418,6 @@ Object.assign(state, DISPOSED_STATE);
         const dependenciesOrder = new Array();
-        objectForEach(state.dependencyTracking, function(id, dependency) {
+        (0, import_utils.objectForEach)(state.dependencyTracking, function(id, dependency) {
           dependenciesOrder[dependency._order] = id;
         });
-        arrayForEach(dependenciesOrder, function(id, order) {
+        (0, import_utils.arrayForEach)(dependenciesOrder, function(id, order) {
           const dependency = state.dependencyTracking[id], subscription = computedObservable.subscribeToDependency(dependency._target);
@@ -1696,3 +442,3 @@ subscription._order = order;
     if (!state.isDisposed && event === "change" && !this.hasSubscriptionsForEvent("change")) {
-      objectForEach(state.dependencyTracking, function(id, dependency) {
+      (0, import_utils.objectForEach)(state.dependencyTracking, function(id, dependency) {
         if (dependency.dispose) {
@@ -1716,3 +462,3 @@ state.dependencyTracking[id] = {
     }
-    return subscribable.fn.getVersion.call(this);
+    return import_observable.subscribable.fn.getVersion.call(this);
   }
@@ -1727,6 +473,6 @@ };
 };
-Object.setPrototypeOf(computed.fn, subscribable.fn);
-var protoProp = observable.protoProperty;
+Object.setPrototypeOf(computed.fn, import_observable.subscribable.fn);
+var protoProp = import_observable.observable.protoProperty;
 computed.fn[protoProp] = computed;
-observable.observablePrototypes.add(computed);
+import_observable.observable.observablePrototypes.add(computed);
 function isComputed(instance) {
@@ -1744,3 +490,3 @@ return typeof instance === "function" && instance[protoProp] === computed;
     let options2 = evaluatorFunctionOrOptions;
-    options2 = extend({}, options2);
+    options2 = (0, import_utils.extend)({}, options2);
     options2.pure = true;
@@ -1752,5 +498,6 @@ return computed(options2, evaluatorFunctionTarget);
 // src/throttleExtender.ts
+var import_observable2 = require("@tko/observable");
 function throttleExtender(target, timeout) {
   target.throttleEvaluation = timeout;
-  let writeTimeoutInstance = void 0;
+  let writeTimeoutInstance;
   return computed({
@@ -1766,6 +513,7 @@ read: target,
 }
-var extenders2 = extenders;
+var extenders2 = import_observable2.extenders;
 extenders2.throttle = throttleExtender;
 
 // src/proxy.ts
+var import_observable3 = require("@tko/observable");
 var PROXY_SYM = /* @__PURE__ */ Symbol("Knockout Proxied Object");
@@ -1784,3 +532,3 @@ var MIRROR_SYM = /* @__PURE__ */ Symbol("Knockout Proxied Observables");
   if (!mirror[prop]) {
-    const ctr = Array.isArray(value) ? observableArray : typeof value === "function" ? makeComputed.bind(null, proxy2) : observable;
+    const ctr = Array.isArray(value) ? import_observable3.observableArray : typeof value === "function" ? makeComputed.bind(null, proxy2) : import_observable3.observable;
     mirror[prop] = ctr(value);
@@ -1806,3 +554,3 @@ } else {
     get(target, prop) {
-      return unwrap(mirror[prop]);
+      return (0, import_observable3.unwrap)(mirror[prop]);
     },
@@ -1850,3 +598,3 @@ set(target, prop, value, receiver) {
 }
-function peek2(proxied, prop) {
+function peek(proxied, prop) {
   return getObservable(proxied, prop).peek();
@@ -1857,8 +605,8 @@ }
 }
-Object.assign(proxy, { getObservable, peek: peek2, isProxied });
+Object.assign(proxy, { getObservable, peek, isProxied });
 
 // src/when.ts
 function kowhen(predicate, context, resolve) {
-  const observable2 = pureComputed(predicate, context).extend({ notify: "always" });
-  const subscription = observable2.subscribe((value) => {
+  const observable3 = pureComputed(predicate, context).extend({ notify: "always" });
+  const subscription = observable3.subscribe((value) => {
     if (value) {
@@ -1869,3 +617,3 @@ subscription.dispose();
   });
-  observable2.notifySubscribers(observable2.peek());
+  observable3.notifySubscribers(observable3.peek());
   return subscription;
@@ -1872,0 +620,0 @@ }

dist/index.js

@@ -1,6 +0,6 @@
-// @tko/computed 🥊 4.0.0 ESM
+// @tko/computed 🥊 4.0.1 ESM
 "use strict";
-export { computed, isComputed, isPureComputed, pureComputed } from "./computed";
-export { throttleExtender } from "./throttleExtender";
-export { proxy } from "./proxy";
-export { when } from "./when";
+export { computed, isComputed, isPureComputed, pureComputed } from "./computed.js";
+export { throttleExtender } from "./throttleExtender.js";
+export { proxy } from "./proxy.js";
+export { when } from "./when.js";

dist/index.mjs

@@ -1,6 +0,6 @@
-// @tko/computed 🥊 4.0.0 MJS
+// @tko/computed 🥊 4.0.1 MJS
 "use strict";
-export { computed, isComputed, isPureComputed, pureComputed } from "./computed";
-export { throttleExtender } from "./throttleExtender";
-export { proxy } from "./proxy";
-export { when } from "./when";
+export { computed, isComputed, isPureComputed, pureComputed } from "./computed.js";
+export { throttleExtender } from "./throttleExtender.js";
+export { proxy } from "./proxy.js";
+export { when } from "./when.js";

dist/proxy.js

@@ -1,5 +0,5 @@
-// @tko/computed 🥊 4.0.0 ESM
+// @tko/computed 🥊 4.0.1 ESM
 "use strict";
 import { observable, observableArray, unwrap } from "@tko/observable";
-import { computed } from "./computed";
+import { computed } from "./computed.js";
 const PROXY_SYM = /* @__PURE__ */ Symbol("Knockout Proxied Object");
@@ -6,0 +6,0 @@ const MIRROR_SYM = /* @__PURE__ */ Symbol("Knockout Proxied Observables");

dist/throttleExtender.js

@@ -1,8 +0,8 @@
-// @tko/computed 🥊 4.0.0 ESM
+// @tko/computed 🥊 4.0.1 ESM
 "use strict";
 import { extenders as baseExtenders } from "@tko/observable";
-import { computed } from "./computed";
+import { computed } from "./computed.js";
 export function throttleExtender(target, timeout) {
   target.throttleEvaluation = timeout;
-  let writeTimeoutInstance = void 0;
+  let writeTimeoutInstance;
   return computed({
@@ -9,0 +9,0 @@ read: target,

dist/throttleExtender.js.map

 {
   "version": 3,
   "sources": ["../src/throttleExtender.ts"],
-  "sourcesContent": ["import { extenders as baseExtenders } from '@tko/observable'\nimport { computed } from './computed'\n\nexport function throttleExtender(target: any, timeout: number) {\n  // Throttling means two things:\n\n  // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies\n  //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate\n  target.throttleEvaluation = timeout\n\n  // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*\n  //     so the target cannot change value synchronously or faster than a certain rate\n  let writeTimeoutInstance: ReturnType<typeof setTimeout> | undefined = undefined\n  return computed({\n    read: target,\n    write: function (value) {\n      clearTimeout(writeTimeoutInstance)\n      writeTimeoutInstance = setTimeout(function () {\n        target(value)\n      }, timeout)\n    }\n  })\n}\n\nconst extenders = baseExtenders\n\nextenders.throttle = throttleExtender\n"],
-  "mappings": ";;AAAA,SAAS,aAAa,qBAAqB;AAC3C,SAAS,gBAAgB;AAElB,gBAAS,iBAAiB,QAAa,SAAiB;AAK7D,SAAO,qBAAqB;AAI5B,MAAI,uBAAkE;AACtE,SAAO,SAAS;AAAA,IACd,MAAM;AAAA,IACN,OAAO,SAAU,OAAO;AACtB,mBAAa,oBAAoB;AACjC,6BAAuB,WAAW,WAAY;AAC5C,eAAO,KAAK;AAAA,MACd,GAAG,OAAO;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAEA,MAAM,YAAY;AAElB,UAAU,WAAW;",
+  "sourcesContent": ["import { extenders as baseExtenders } from '@tko/observable'\nimport { computed } from './computed'\n\nexport function throttleExtender(target: any, timeout: number) {\n  // Throttling means two things:\n\n  // (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies\n  //     notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate\n  target.throttleEvaluation = timeout\n\n  // (2) For writable targets (observables, or writable dependent observables), we throttle *writes*\n  //     so the target cannot change value synchronously or faster than a certain rate\n  let writeTimeoutInstance: ReturnType<typeof setTimeout> | undefined\n  return computed({\n    read: target,\n    write: function (value) {\n      clearTimeout(writeTimeoutInstance)\n      writeTimeoutInstance = setTimeout(function () {\n        target(value)\n      }, timeout)\n    }\n  })\n}\n\nconst extenders = baseExtenders\n\nextenders.throttle = throttleExtender\n"],
+  "mappings": ";;AAAA,SAAS,aAAa,qBAAqB;AAC3C,SAAS,gBAAgB;AAElB,gBAAS,iBAAiB,QAAa,SAAiB;AAK7D,SAAO,qBAAqB;AAI5B,MAAI;AACJ,SAAO,SAAS;AAAA,IACd,MAAM;AAAA,IACN,OAAO,SAAU,OAAO;AACtB,mBAAa,oBAAoB;AACjC,6BAAuB,WAAW,WAAY;AAC5C,eAAO,KAAK;AAAA,MACd,GAAG,OAAO;AAAA,IACZ;AAAA,EACF,CAAC;AACH;AAEA,MAAM,YAAY;AAElB,UAAU,WAAW;",
   "names": []
 }

dist/when.js

@@ -1,4 +0,4 @@
-// @tko/computed 🥊 4.0.0 ESM
+// @tko/computed 🥊 4.0.1 ESM
 "use strict";
-import { pureComputed } from "./computed";
+import { pureComputed } from "./computed.js";
 function kowhen(predicate, context, resolve) {
@@ -5,0 +5,0 @@ const observable = pureComputed(predicate, context).extend({ notify: "always" });

package.json

 {
-  "version": "4.0.0",
+  "version": "4.0.1",
   "name": "@tko/computed",
   "description": "TKO Computed Observables",
-  "module": "dist/computed.js",
+  "module": "dist/index.js",
   "files": [
-    "dist/",
-    "helpers/"
+    "dist/"
   ],
   "dependencies": {
-    "@tko/observable": "^4.0.0",
-    "@tko/utils": "^4.0.0",
+    "@tko/observable": "^4.0.1",
+    "@tko/utils": "^4.0.1",
     "tslib": "^2.2.0"
@@ -29,7 +28,2 @@ },
   "homepage": "https://tko.io",
-  "karma": {
-    "frameworks": [
-      "jasmine"
-    ]
-  },
   "licenses": [
@@ -45,5 +39,7 @@ {
       "import": "./dist/index.js"
-    },
-    "./helpers/*": "./helpers/*"
+    }
+  },
+  "scripts": {
+    "build": "bun ../../tools/build.ts"
   }
 }

No alert changes

Worsened metrics

Total package byte prevSize

121713

-49.78%

Lines of code

1181

-51.02%

Dependency changes

• Updated

  @tko/observable@^4.0.1

• Updated

  @tko/utils@^4.0.1