@tko/bind 4.0.0-alpha8.4 → 4.0.0-beta1.3

package/dist/BindingHandler.js

@@ -0,0 +1,57 @@
+// @tko/bind 🥊 4.0.0-beta1.3 ESM
+import { options } from "@tko/utils";
+import { isWriteableObservable } from "@tko/observable";
+import { LifeCycle } from "@tko/lifecycle";
+export class BindingHandler extends LifeCycle {
+  constructor(params) {
+    super();
+    const { $element, valueAccessor, allBindings, $context } = params;
+    Object.assign(this, {
+      valueAccessor,
+      allBindings,
+      $element,
+      $context,
+      $data: $context.$data
+    });
+    this.anchorTo($element);
+  }
+  get value() {
+    return this.valueAccessor();
+  }
+  set value(v) {
+    const va = this.valueAccessor();
+    if (isWriteableObservable(va)) {
+      va(v);
+    } else {
+      this.valueAccessor(v);
+    }
+  }
+  get controlsDescendants() {
+    return false;
+  }
+  static get allowVirtualElements() {
+    return false;
+  }
+  static get isBindingHandlerClass() {
+    return true;
+  }
+  get bindingCompleted() {
+    return true;
+  }
+  static registerAs(name, provider = options.bindingProviderInstance) {
+    provider.bindingHandlers.set(name, this);
+  }
+}
+const ResolveSymbol = Symbol("Async Binding Resolved");
+export class AsyncBindingHandler extends BindingHandler {
+  constructor(params) {
+    super(params);
+    this.bindingCompletion = new Promise((resolve) => {
+      this[ResolveSymbol] = resolve;
+    });
+    this.completeBinding = (bindingResult) => this[ResolveSymbol](bindingResult);
+  }
+  get bindingCompleted() {
+    return this.bindingCompletion;
+  }
+}

package/dist/BindingHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/BindingHandler.ts"],
+  "sourcesContent": ["\nimport { options } from '@tko/utils'\nimport { isWriteableObservable } from '@tko/observable'\nimport { LifeCycle } from '@tko/lifecycle'\n\nexport class BindingHandler extends LifeCycle {\n  constructor (params) {\n    super()\n    const {$element, valueAccessor, allBindings, $context} = params\n    Object.assign(this, {\n      valueAccessor,\n      allBindings,\n      $element,\n      $context,\n      $data: $context.$data\n    })\n\n    this.anchorTo($element)\n  }\n\n  get value () { return this.valueAccessor() }\n  set value (v) {\n    const va = this.valueAccessor()\n    if (isWriteableObservable(va)) {\n      va(v)\n    } else {\n      this.valueAccessor(v)\n    }\n  }\n\n  get controlsDescendants () { return false }\n\n  static get allowVirtualElements () { return false }\n  static get isBindingHandlerClass () { return true }\n\n  /* Overload this for asynchronous bindings or bindings that recursively\n     apply bindings (e.g. components, foreach, template).\n\n     A binding should be complete when it has run through once, notably\n     in server-side bindings for pre-rendering.\n  */\n  get bindingCompleted () { return true }\n\n  static registerAs (name, provider = options.bindingProviderInstance) {\n    provider.bindingHandlers.set(name, this)\n  }\n}\n\n/**\n * An AsyncBindingHandler shall call `completeBinding` when the binding\n * is to be considered complete.\n */\nconst ResolveSymbol = Symbol('Async Binding Resolved')\n\nexport class AsyncBindingHandler extends BindingHandler {\n  constructor (params) {\n    super(params)\n    this.bindingCompletion = new Promise((resolve) => {\n      this[ResolveSymbol] = resolve\n    })\n    this.completeBinding = bindingResult => this[ResolveSymbol](bindingResult)\n  }\n\n  get bindingCompleted () { return this.bindingCompletion }\n}\n"],
+  "mappings": ";AACA;AACA;AACA;AAEO,aAAM,uBAAuB,UAAU;AAAA,EAC5C,YAAa,QAAQ;AACnB,UAAM;AACN,UAAM,EAAC,UAAU,eAAe,aAAa,aAAY;AACzD,WAAO,OAAO,MAAM;AAAA,MAClB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,OAAO,SAAS;AAAA,IAClB,CAAC;AAED,SAAK,SAAS,QAAQ;AAAA,EACxB;AAAA,MAEI,QAAS;AAAE,WAAO,KAAK,cAAc;AAAA,EAAE;AAAA,MACvC,MAAO,GAAG;AACZ,UAAM,KAAK,KAAK,cAAc;AAC9B,QAAI,sBAAsB,EAAE,GAAG;AAC7B,SAAG,CAAC;AAAA,IACN,OAAO;AACL,WAAK,cAAc,CAAC;AAAA,IACtB;AAAA,EACF;AAAA,MAEI,sBAAuB;AAAE,WAAO;AAAA,EAAM;AAAA,aAE/B,uBAAwB;AAAE,WAAO;AAAA,EAAM;AAAA,aACvC,wBAAyB;AAAE,WAAO;AAAA,EAAK;AAAA,MAQ9C,mBAAoB;AAAE,WAAO;AAAA,EAAK;AAAA,SAE/B,WAAY,MAAM,WAAW,QAAQ,yBAAyB;AACnE,aAAS,gBAAgB,IAAI,MAAM,IAAI;AAAA,EACzC;AACF;AAMA,MAAM,gBAAgB,OAAO,wBAAwB;AAE9C,aAAM,4BAA4B,eAAe;AAAA,EACtD,YAAa,QAAQ;AACnB,UAAM,MAAM;AACZ,SAAK,oBAAoB,IAAI,QAAQ,CAAC,YAAY;AAChD,WAAK,iBAAiB;AAAA,IACxB,CAAC;AACD,SAAK,kBAAkB,mBAAiB,KAAK,eAAe,aAAa;AAAA,EAC3E;AAAA,MAEI,mBAAoB;AAAE,WAAO,KAAK;AAAA,EAAkB;AAC1D;",
+  "names": []
+}

package/dist/BindingResult.js

@@ -0,0 +1,41 @@
+// @tko/bind 🥊 4.0.0-beta1.3 ESM
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+export class BindingResult {
+  constructor({ asyncBindingsApplied, rootNode, bindingContext }) {
+    Object.assign(this, {
+      rootNode,
+      bindingContext,
+      isSync: asyncBindingsApplied.size === 0,
+      isComplete: this.isSync
+    });
+    if (!this.isSync) {
+      this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied);
+    }
+  }
+  completeWhenBindingsFinish(asyncBindingsApplied) {
+    return __async(this, null, function* () {
+      yield Promise.all(asyncBindingsApplied);
+      this.isComplete = true;
+      return this;
+    });
+  }
+}

package/dist/BindingResult.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/BindingResult.ts"],
+  "sourcesContent": ["\n\nexport class BindingResult {\n  constructor ({asyncBindingsApplied, rootNode, bindingContext}) {\n    Object.assign(this, {\n      rootNode,\n      bindingContext,\n      isSync: asyncBindingsApplied.size === 0,\n      isComplete: this.isSync\n    })\n\n    if (!this.isSync) {\n      this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied)\n    }\n  }\n\n  async completeWhenBindingsFinish (asyncBindingsApplied) {\n    await Promise.all(asyncBindingsApplied)\n    this.isComplete = true\n    return this\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAEO,aAAM,cAAc;AAAA,EACzB,YAAa,EAAC,sBAAsB,UAAU,kBAAiB;AAC7D,WAAO,OAAO,MAAM;AAAA,MAClB;AAAA,MACA;AAAA,MACA,QAAQ,qBAAqB,SAAS;AAAA,MACtC,YAAY,KAAK;AAAA,IACnB,CAAC;AAED,QAAI,CAAC,KAAK,QAAQ;AAChB,WAAK,oBAAoB,KAAK,2BAA2B,oBAAoB;AAAA,IAC/E;AAAA,EACF;AAAA,EAEM,2BAA4B,sBAAsB;AAAA;AACtD,YAAM,QAAQ,IAAI,oBAAoB;AACtC,WAAK,aAAa;AAClB,aAAO;AAAA,IACT;AAAA;AACF;",
+  "names": []
+}

package/dist/DescendantBindingHandler.js

@@ -0,0 +1,42 @@
+// @tko/bind 🥊 4.0.0-beta1.3 ESM
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { applyBindingsToDescendants } from "./applyBindings";
+import { AsyncBindingHandler } from "./BindingHandler";
+export class DescendantBindingHandler extends AsyncBindingHandler {
+  get controlsDescendants() {
+    return true;
+  }
+  applyBindingsToDescendants(childContext, callback) {
+    return __async(this, null, function* () {
+      const bindingResult = applyBindingsToDescendants(childContext, this.$element);
+      if (bindingResult.isSync) {
+        this.bindingCompletion = bindingResult;
+      } else {
+        yield bindingResult.completionPromise;
+      }
+      if (callback) {
+        callback(bindingResult);
+      }
+      this.completeBinding(bindingResult);
+    });
+  }
+}

package/dist/DescendantBindingHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/DescendantBindingHandler.ts"],
+  "sourcesContent": ["\n\nimport { applyBindingsToDescendants } from './applyBindings'\nimport { AsyncBindingHandler } from './BindingHandler'\n\n/**\n * This DescendantBindingHandler is a base class for bindings that control\n * descendants, such as the `if`, `with`, `component`, `foreach` and `template`\n * bindings.\n */\nexport class DescendantBindingHandler extends AsyncBindingHandler {\n  get controlsDescendants () { return true }\n\n  async applyBindingsToDescendants (childContext, callback) {\n    const bindingResult = applyBindingsToDescendants(childContext, this.$element)\n    if (bindingResult.isSync) {\n      this.bindingCompletion = bindingResult\n    } else {\n      await bindingResult.completionPromise\n    }\n    if (callback) { callback(bindingResult) }\n    this.completeBinding(bindingResult)\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAEA;AACA;AAOO,aAAM,iCAAiC,oBAAoB;AAAA,MAC5D,sBAAuB;AAAE,WAAO;AAAA,EAAK;AAAA,EAEnC,2BAA4B,cAAc,UAAU;AAAA;AACxD,YAAM,gBAAgB,2BAA2B,cAAc,KAAK,QAAQ;AAC5E,UAAI,cAAc,QAAQ;AACxB,aAAK,oBAAoB;AAAA,MAC3B,OAAO;AACL,cAAM,cAAc;AAAA,MACtB;AACA,UAAI,UAAU;AAAE,iBAAS,aAAa;AAAA,MAAE;AACxC,WAAK,gBAAgB,aAAa;AAAA,IACpC;AAAA;AACF;",
+  "names": []
+}

package/dist/LegacyBindingHandler.js

@@ -0,0 +1,84 @@
+// @tko/bind 🥊 4.0.0-beta1.3 ESM
+import { virtualElements, options } from "@tko/utils";
+import { BindingHandler } from "./BindingHandler";
+const PossibleWeakMap = options.global.WeakMap || Map;
+const legacyBindingMap = new PossibleWeakMap();
+export class LegacyBindingHandler extends BindingHandler {
+  constructor(params) {
+    super(params);
+    const handler = this.handler;
+    this.onError = params.onError;
+    if (typeof handler.dispose === "function") {
+      this.addDisposable(handler);
+    }
+    try {
+      this.initReturn = handler.init && handler.init(...this.legacyArgs);
+    } catch (e) {
+      params.onError("init", e);
+    }
+  }
+  onValueChange() {
+    const handler = this.handler;
+    if (typeof handler.update !== "function") {
+      return;
+    }
+    try {
+      handler.update(...this.legacyArgs);
+    } catch (e) {
+      this.onError("update", e);
+    }
+  }
+  get legacyArgs() {
+    return [
+      this.$element,
+      this.valueAccessor,
+      this.allBindings,
+      this.$data,
+      this.$context
+    ];
+  }
+  get controlsDescendants() {
+    const objectToTest = this.initReturn || this.handler || {};
+    return objectToTest.controlsDescendantBindings;
+  }
+  static getOrCreateFor(key, handler) {
+    if (legacyBindingMap.has(handler)) {
+      return legacyBindingMap.get(handler);
+    }
+    const newLegacyHandler = this.createFor(key, handler);
+    legacyBindingMap.set(handler, newLegacyHandler);
+    return newLegacyHandler;
+  }
+  static createFor(key, handler) {
+    if (typeof handler === "function") {
+      const [initFn, disposeFn] = [handler, handler.dispose];
+      return class extends LegacyBindingHandler {
+        get handler() {
+          const init = initFn.bind(this);
+          const dispose = disposeFn ? disposeFn.bind(this) : null;
+          return { init, dispose };
+        }
+        static get after() {
+          return handler.after;
+        }
+        static get allowVirtualElements() {
+          return handler.allowVirtualElements || virtualElements.allowedBindings[key];
+        }
+      };
+    }
+    if (typeof handler === "object") {
+      return class extends LegacyBindingHandler {
+        get handler() {
+          return handler;
+        }
+        static get after() {
+          return handler.after;
+        }
+        static get allowVirtualElements() {
+          return handler.allowVirtualElements || virtualElements.allowedBindings[key];
+        }
+      };
+    }
+    throw new Error("The given handler is not an appropriate type.");
+  }
+}

package/dist/LegacyBindingHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/LegacyBindingHandler.ts"],
+  "sourcesContent": ["\nimport { virtualElements, options } from '@tko/utils'\nimport { BindingHandler } from './BindingHandler'\n\n/**\n * We have no guarantees, for users employing legacy bindings,\n * that it has not been changed with a modification like\n *\n *    ko.bindingHandlers[name] = { init: ...}\n *\n * ... so we have to keep track by way of a map.\n */\nconst PossibleWeakMap = options.global.WeakMap || Map\nconst legacyBindingMap = new PossibleWeakMap()\n\nexport class LegacyBindingHandler extends BindingHandler {\n  constructor (params) {\n    super(params)\n    const handler = this.handler\n    this.onError = params.onError\n\n    if (typeof handler.dispose === 'function') {\n      this.addDisposable(handler)\n    }\n\n    try {\n      this.initReturn = handler.init && handler.init(...this.legacyArgs)\n    } catch (e) {\n      params.onError('init', e)\n    }\n  }\n\n  onValueChange () {\n    const handler = this.handler\n    if (typeof handler.update !== 'function') { return }\n    try {\n      handler.update(...this.legacyArgs)\n    } catch (e) {\n      this.onError('update', e)\n    }\n  }\n\n  get legacyArgs () {\n    return [\n      this.$element, this.valueAccessor, this.allBindings,\n      this.$data, this.$context\n    ]\n  }\n\n  get controlsDescendants () {\n    const objectToTest = this.initReturn || this.handler || {}\n    return objectToTest.controlsDescendantBindings\n  }\n\n  /**\n   * Create a handler instance from the `origin`, which may be:\n   *\n   * 1. an object (becomes LegacyBindingHandler)\n   * 2. a function (becomes LegacyBindingHandler with `init: function`)\n   *\n   * If given an object (the only kind supported in knockout 3.x and before), it\n   * shall draw the `init`, `update`, and `allowVirtualElements` properties\n   */\n  static getOrCreateFor (key, handler) {\n    if (legacyBindingMap.has(handler)) {\n      return legacyBindingMap.get(handler)\n    }\n    const newLegacyHandler = this.createFor(key, handler)\n    legacyBindingMap.set(handler, newLegacyHandler)\n    return newLegacyHandler\n  }\n\n  static createFor (key, handler) {\n    if (typeof handler === 'function') {\n      const [initFn, disposeFn] = [handler, handler.dispose]\n      return class extends LegacyBindingHandler {\n        get handler () {\n          const init = initFn.bind(this)\n          const dispose = disposeFn ? disposeFn.bind(this) : null\n          return { init, dispose }\n        }\n        static get after () { return handler.after }\n        static get allowVirtualElements () {\n          return handler.allowVirtualElements || virtualElements.allowedBindings[key]\n        }\n      }\n    }\n\n    if (typeof handler === 'object') {\n      return class extends LegacyBindingHandler {\n        get handler () { return handler }\n        static get after () { return handler.after }\n        static get allowVirtualElements () {\n          return handler.allowVirtualElements || virtualElements.allowedBindings[key]\n        }\n      }\n    }\n\n    throw new Error('The given handler is not an appropriate type.')\n  }\n}\n"],
+  "mappings": ";AACA;AACA;AAUA,MAAM,kBAAkB,QAAQ,OAAO,WAAW;AAClD,MAAM,mBAAmB,IAAI,gBAAgB;AAEtC,aAAM,6BAA6B,eAAe;AAAA,EACvD,YAAa,QAAQ;AACnB,UAAM,MAAM;AACZ,UAAM,UAAU,KAAK;AACrB,SAAK,UAAU,OAAO;AAEtB,QAAI,OAAO,QAAQ,YAAY,YAAY;AACzC,WAAK,cAAc,OAAO;AAAA,IAC5B;AAEA,QAAI;AACF,WAAK,aAAa,QAAQ,QAAQ,QAAQ,KAAK,GAAG,KAAK,UAAU;AAAA,IACnE,SAAS,GAAP;AACA,aAAO,QAAQ,QAAQ,CAAC;AAAA,IAC1B;AAAA,EACF;AAAA,EAEA,gBAAiB;AACf,UAAM,UAAU,KAAK;AACrB,QAAI,OAAO,QAAQ,WAAW,YAAY;AAAE;AAAA,IAAO;AACnD,QAAI;AACF,cAAQ,OAAO,GAAG,KAAK,UAAU;AAAA,IACnC,SAAS,GAAP;AACA,WAAK,QAAQ,UAAU,CAAC;AAAA,IAC1B;AAAA,EACF;AAAA,MAEI,aAAc;AAChB,WAAO;AAAA,MACL,KAAK;AAAA,MAAU,KAAK;AAAA,MAAe,KAAK;AAAA,MACxC,KAAK;AAAA,MAAO,KAAK;AAAA,IACnB;AAAA,EACF;AAAA,MAEI,sBAAuB;AACzB,UAAM,eAAe,KAAK,cAAc,KAAK,WAAW,CAAC;AACzD,WAAO,aAAa;AAAA,EACtB;AAAA,SAWO,eAAgB,KAAK,SAAS;AACnC,QAAI,iBAAiB,IAAI,OAAO,GAAG;AACjC,aAAO,iBAAiB,IAAI,OAAO;AAAA,IACrC;AACA,UAAM,mBAAmB,KAAK,UAAU,KAAK,OAAO;AACpD,qBAAiB,IAAI,SAAS,gBAAgB;AAC9C,WAAO;AAAA,EACT;AAAA,SAEO,UAAW,KAAK,SAAS;AAC9B,QAAI,OAAO,YAAY,YAAY;AACjC,YAAM,CAAC,QAAQ,aAAa,CAAC,SAAS,QAAQ,OAAO;AACrD,aAAO,cAAc,qBAAqB;AAAA,YACpC,UAAW;AACb,gBAAM,OAAO,OAAO,KAAK,IAAI;AAC7B,gBAAM,UAAU,YAAY,UAAU,KAAK,IAAI,IAAI;AACnD,iBAAO,EAAE,MAAM,QAAQ;AAAA,QACzB;AAAA,mBACW,QAAS;AAAE,iBAAO,QAAQ;AAAA,QAAM;AAAA,mBAChC,uBAAwB;AACjC,iBAAO,QAAQ,wBAAwB,gBAAgB,gBAAgB;AAAA,QACzE;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,YAAY,UAAU;AAC/B,aAAO,cAAc,qBAAqB;AAAA,YACpC,UAAW;AAAE,iBAAO;AAAA,QAAQ;AAAA,mBACrB,QAAS;AAAE,iBAAO,QAAQ;AAAA,QAAM;AAAA,mBAChC,uBAAwB;AACjC,iBAAO,QAAQ,wBAAwB,gBAAgB,gBAAgB;AAAA,QACzE;AAAA,MACF;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACjE;AACF;",
+  "names": []
+}

package/dist/applyBindings.js

@@ -0,0 +1,331 @@
+// @tko/bind 🥊 4.0.0-beta1.3 ESM
+import {
+  extend,
+  objectMap,
+  virtualElements,
+  tagNameLower,
+  domData,
+  objectForEach,
+  arrayIndexOf,
+  arrayForEach,
+  options
+} from "@tko/utils";
+import {
+  dependencyDetection
+} from "@tko/observable";
+import {
+  computed
+} from "@tko/computed";
+import {
+  dataFor,
+  bindingContext,
+  boundElementDomDataKey,
+  contextSubscribeSymbol
+} from "./bindingContext";
+import {
+  bindingEvent
+} from "./bindingEvent";
+import {
+  BindingResult
+} from "./BindingResult";
+import {
+  LegacyBindingHandler
+} from "./LegacyBindingHandler";
+const bindingDoesNotRecurseIntoElementTypes = {
+  "script": true,
+  "textarea": true,
+  "template": true
+};
+function getBindingProvider() {
+  return options.bindingProviderInstance.instance || options.bindingProviderInstance;
+}
+function isProviderForNode(provider, node) {
+  const nodeTypes = provider.FOR_NODE_TYPES || [1, 3, 8];
+  return nodeTypes.includes(node.nodeType);
+}
+function asProperHandlerClass(handler, bindingKey) {
+  if (!handler) {
+    return;
+  }
+  return handler.isBindingHandlerClass ? handler : LegacyBindingHandler.getOrCreateFor(bindingKey, handler);
+}
+function getBindingHandlerFromComponent(bindingKey, $component) {
+  if (!$component || typeof $component.getBindingHandler !== "function") {
+    return;
+  }
+  return asProperHandlerClass($component.getBindingHandler(bindingKey));
+}
+export function getBindingHandler(bindingKey) {
+  const bindingDefinition = options.getBindingHandler(bindingKey) || getBindingProvider().bindingHandlers.get(bindingKey);
+  return asProperHandlerClass(bindingDefinition, bindingKey);
+}
+function evaluateValueAccessor(valueAccessor) {
+  return valueAccessor();
+}
+function applyBindingsToDescendantsInternal(bindingContext2, elementOrVirtualElement, asyncBindingsApplied) {
+  let nextInQueue = virtualElements.firstChild(elementOrVirtualElement);
+  if (!nextInQueue) {
+    return;
+  }
+  let currentChild;
+  const provider = getBindingProvider();
+  const preprocessNode = provider.preprocessNode;
+  if (preprocessNode) {
+    while (currentChild = nextInQueue) {
+      nextInQueue = virtualElements.nextSibling(currentChild);
+      preprocessNode.call(provider, currentChild);
+    }
+    nextInQueue = virtualElements.firstChild(elementOrVirtualElement);
+  }
+  while (currentChild = nextInQueue) {
+    nextInQueue = virtualElements.nextSibling(currentChild);
+    applyBindingsToNodeAndDescendantsInternal(bindingContext2, currentChild, asyncBindingsApplied);
+  }
+  bindingEvent.notify(elementOrVirtualElement, bindingEvent.childrenComplete);
+}
+function hasBindings(node) {
+  const provider = getBindingProvider();
+  return isProviderForNode(provider, node) && provider.nodeHasBindings(node);
+}
+function nodeOrChildHasBindings(node) {
+  return hasBindings(node) || [...node.childNodes].some((c) => nodeOrChildHasBindings(c));
+}
+function applyBindingsToNodeAndDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied) {
+  var isElement = nodeVerified.nodeType === 1;
+  if (isElement) {
+    virtualElements.normaliseVirtualElementDomStructure(nodeVerified);
+  }
+  let shouldApplyBindings = isElement || hasBindings(nodeVerified);
+  const { shouldBindDescendants } = shouldApplyBindings ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext2, asyncBindingsApplied) : { shouldBindDescendants: true };
+  if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[tagNameLower(nodeVerified)]) {
+    applyBindingsToDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied);
+  }
+}
+function* topologicalSortBindings(bindings, $component) {
+  const results = [];
+  const bindingsConsidered = {};
+  const cyclicDependencyStack = [];
+  objectForEach(bindings, function pushBinding(bindingKey) {
+    if (!bindingsConsidered[bindingKey]) {
+      const binding = getBindingHandlerFromComponent(bindingKey, $component) || getBindingHandler(bindingKey);
+      if (!binding) {
+        return;
+      }
+      if (binding.after) {
+        cyclicDependencyStack.push(bindingKey);
+        arrayForEach(binding.after, function(bindingDependencyKey) {
+          if (!bindings[bindingDependencyKey]) {
+            return;
+          }
+          if (arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
+            throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", "));
+          } else {
+            pushBinding(bindingDependencyKey);
+          }
+        });
+        cyclicDependencyStack.length--;
+      }
+      results.push([bindingKey, binding]);
+    }
+    bindingsConsidered[bindingKey] = true;
+  });
+  for (const result of results) {
+    yield result;
+  }
+}
+function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyncBindingsApplied) {
+  const bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {});
+  const alreadyBound = bindingInfo.alreadyBound;
+  if (!sourceBindings) {
+    if (alreadyBound) {
+      if (!nodeOrChildHasBindings(node)) {
+        return false;
+      }
+      onBindingError({
+        during: "apply",
+        errorCaptured: new Error("You cannot apply bindings multiple times to the same element."),
+        element: node,
+        bindingContext: bindingContext2
+      });
+      return false;
+    }
+    bindingInfo.alreadyBound = true;
+  }
+  if (!alreadyBound) {
+    bindingInfo.context = bindingContext2;
+  }
+  var bindings;
+  if (sourceBindings && typeof sourceBindings !== "function") {
+    bindings = sourceBindings;
+  } else {
+    const provider = getBindingProvider();
+    const getBindings = provider.getBindingAccessors;
+    if (isProviderForNode(provider, node)) {
+      var bindingsUpdater = computed(function() {
+        bindings = sourceBindings ? sourceBindings(bindingContext2, node) : getBindings.call(provider, node, bindingContext2);
+        if (bindings && bindingContext2[contextSubscribeSymbol]) {
+          bindingContext2[contextSubscribeSymbol]();
+        }
+        return bindings;
+      }, null, { disposeWhenNodeIsRemoved: node });
+      if (!bindings || !bindingsUpdater.isActive()) {
+        bindingsUpdater = null;
+      }
+    }
+  }
+  var bindingHandlerThatControlsDescendantBindings;
+  if (bindings) {
+    let allBindings = function() {
+      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
+    };
+    const $component = bindingContext2.$component || {};
+    const allBindingHandlers = {};
+    domData.set(node, "bindingHandlers", allBindingHandlers);
+    const getValueAccessor = bindingsUpdater ? (bindingKey) => function(optionalValue) {
+      const valueAccessor = bindingsUpdater()[bindingKey];
+      if (arguments.length === 0) {
+        return evaluateValueAccessor(valueAccessor);
+      } else {
+        return valueAccessor(optionalValue);
+      }
+    } : (bindingKey) => bindings[bindingKey];
+    allBindings.has = (key) => key in bindings;
+    allBindings.get = (key) => bindings[key] && evaluateValueAccessor(getValueAccessor(key));
+    if (bindingEvent.childrenComplete in bindings) {
+      bindingEvent.subscribe(node, bindingEvent.childrenComplete, () => {
+        const callback = evaluateValueAccessor(bindings[bindingEvent.childrenComplete]);
+        if (!callback) {
+          return;
+        }
+        const nodes = virtualElements.childNodes(node);
+        if (nodes.length) {
+          callback(nodes, dataFor(nodes[0]));
+        }
+      });
+    }
+    const bindingsGenerated = topologicalSortBindings(bindings, $component);
+    const nodeAsyncBindingPromises = /* @__PURE__ */ new Set();
+    for (const [key, BindingHandlerClass] of bindingsGenerated) {
+      let reportBindingError = function(during, errorCaptured) {
+        onBindingError({
+          during,
+          errorCaptured,
+          bindings,
+          allBindings,
+          bindingKey: key,
+          bindingContext: bindingContext2,
+          element: node,
+          valueAccessor: getValueAccessor(key)
+        });
+      };
+      if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {
+        throw new Error(`The binding '${key}' cannot be used with virtual elements`);
+      }
+      try {
+        const bindingHandler = dependencyDetection.ignore(() => new BindingHandlerClass({
+          allBindings,
+          $element: node,
+          $context: bindingContext2,
+          onError: reportBindingError,
+          valueAccessor(...v) {
+            return getValueAccessor(key)(...v);
+          }
+        }));
+        if (bindingHandler.onValueChange) {
+          dependencyDetection.ignore(() => bindingHandler.computed("onValueChange"));
+        }
+        allBindingHandlers[key] = bindingHandler;
+        if (bindingHandler.controlsDescendants) {
+          if (bindingHandlerThatControlsDescendantBindings !== void 0) {
+            throw new Error("Multiple bindings (" + bindingHandlerThatControlsDescendantBindings + " and " + key + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
+          }
+          bindingHandlerThatControlsDescendantBindings = key;
+        }
+        if (bindingHandler.bindingCompleted instanceof Promise) {
+          asyncBindingsApplied.add(bindingHandler.bindingCompleted);
+          nodeAsyncBindingPromises.add(bindingHandler.bindingCompleted);
+        }
+      } catch (err) {
+        reportBindingError("creation", err);
+      }
+    }
+    triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises);
+  }
+  const shouldBindDescendants = bindingHandlerThatControlsDescendantBindings === void 0;
+  return { shouldBindDescendants };
+}
+function triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises) {
+  const hasBindingHandler = bindingEvent.descendantsComplete in bindings;
+  const hasFirstChild = virtualElements.firstChild(node);
+  const accessor = hasBindingHandler && evaluateValueAccessor(bindings[bindingEvent.descendantsComplete]);
+  const callback = () => {
+    bindingEvent.notify(node, bindingEvent.descendantsComplete);
+    if (accessor && hasFirstChild) {
+      accessor(node);
+    }
+  };
+  if (nodeAsyncBindingPromises.size) {
+    Promise.all(nodeAsyncBindingPromises).then(callback);
+  } else {
+    callback();
+  }
+}
+function getBindingContext(viewModelOrBindingContext, extendContextCallback) {
+  return viewModelOrBindingContext && viewModelOrBindingContext instanceof bindingContext ? viewModelOrBindingContext : new bindingContext(viewModelOrBindingContext, void 0, void 0, extendContextCallback);
+}
+export function applyBindingAccessorsToNode(node, bindings, viewModelOrBindingContext, asyncBindingsApplied) {
+  if (node.nodeType === 1) {
+    virtualElements.normaliseVirtualElementDomStructure(node);
+  }
+  return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), asyncBindingsApplied);
+}
+export function applyBindingsToNode(node, bindings, viewModelOrBindingContext) {
+  const asyncBindingsApplied = /* @__PURE__ */ new Set();
+  const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+  const bindingAccessors = getBindingProvider().makeBindingAccessors(bindings, bindingContext2, node);
+  applyBindingAccessorsToNode(node, bindingAccessors, bindingContext2, asyncBindingsApplied);
+  return new BindingResult({ asyncBindingsApplied, rootNode: node, bindingContext: bindingContext2 });
+}
+export function applyBindingsToDescendants(viewModelOrBindingContext, rootNode) {
+  const asyncBindingsApplied = /* @__PURE__ */ new Set();
+  if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {
+    const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+    applyBindingsToDescendantsInternal(bindingContext2, rootNode, asyncBindingsApplied);
+    return new BindingResult({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 });
+  }
+  return new BindingResult({ asyncBindingsApplied, rootNode });
+}
+export function applyBindings(viewModelOrBindingContext, rootNode, extendContextCallback) {
+  const asyncBindingsApplied = /* @__PURE__ */ new Set();
+  if (!options.jQuery === void 0 && options.jQuery) {
+    options.jQuery = options.jQuery;
+  }
+  if (!rootNode) {
+    rootNode = window.document.body;
+    if (!rootNode) {
+      throw Error("ko.applyBindings: could not find window.document.body; has the document been loaded?");
+    }
+  } else if (rootNode.nodeType !== 1 && rootNode.nodeType !== 8) {
+    throw Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");
+  }
+  const rootContext = getBindingContext(viewModelOrBindingContext, extendContextCallback);
+  applyBindingsToNodeAndDescendantsInternal(rootContext, rootNode, asyncBindingsApplied);
+  return Promise.all(asyncBindingsApplied);
+}
+function onBindingError(spec) {
+  var error, bindingText;
+  if (spec.bindingKey) {
+    error = spec.errorCaptured;
+    spec.message = 'Unable to process binding "' + spec.bindingKey + '" in binding "' + spec.bindingKey + '"\nMessage: ' + (error.message ? error.message : error);
+  } else {
+    error = spec.errorCaptured;
+  }
+  try {
+    extend(error, spec);
+  } catch (e) {
+    spec.stack = error.stack;
+    error = new Error(error.message ? error.message : error);
+    extend(error, spec);
+  }
+  options.onError(error);
+}

package/dist/applyBindings.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/applyBindings.ts"],
+  "sourcesContent": ["\n/* eslint no-cond-assign: 0 */\n\nimport {\n    extend, objectMap, virtualElements, tagNameLower, domData, objectForEach,\n    arrayIndexOf, arrayForEach, options\n} from '@tko/utils'\n\nimport {\n    dependencyDetection\n} from '@tko/observable'\n\nimport {\n    computed\n} from '@tko/computed'\n\nimport {\n  dataFor, bindingContext, boundElementDomDataKey, contextSubscribeSymbol\n} from './bindingContext'\n\nimport {\n  bindingEvent\n} from './bindingEvent'\n\nimport {\n  BindingResult\n} from './BindingResult'\n\nimport {\n  LegacyBindingHandler\n} from './LegacyBindingHandler'\n\n// The following element types will not be recursed into during binding.\nconst bindingDoesNotRecurseIntoElementTypes = {\n    // Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,\n    // because it's unexpected and a potential XSS issue.\n    // Also bindings should not operate on <template> elements since this breaks in Internet Explorer\n    // and because such elements' contents are always intended to be bound in a different context\n    // from where they appear in the document.\n  'script': true,\n  'textarea': true,\n  'template': true\n}\n\nfunction getBindingProvider () {\n  return options.bindingProviderInstance.instance || options.bindingProviderInstance\n}\n\nfunction isProviderForNode (provider, node) {\n  const nodeTypes = provider.FOR_NODE_TYPES || [1, 3, 8]\n  return nodeTypes.includes(node.nodeType)\n}\n\nfunction asProperHandlerClass (handler, bindingKey) {\n  if (!handler) { return }\n  return handler.isBindingHandlerClass ? handler\n    : LegacyBindingHandler.getOrCreateFor(bindingKey, handler)\n}\n\nfunction getBindingHandlerFromComponent (bindingKey, $component) {\n  if (!$component || typeof $component.getBindingHandler !== 'function') { return }\n  return asProperHandlerClass($component.getBindingHandler(bindingKey))\n}\n\nexport function getBindingHandler (bindingKey) {\n  const bindingDefinition = options.getBindingHandler(bindingKey) || getBindingProvider().bindingHandlers.get(bindingKey)\n  return asProperHandlerClass(bindingDefinition, bindingKey)\n}\n\n// Returns the value of a valueAccessor function\nfunction evaluateValueAccessor (valueAccessor) {\n  return valueAccessor()\n}\n\nfunction applyBindingsToDescendantsInternal (bindingContext, elementOrVirtualElement, asyncBindingsApplied) {\n  let nextInQueue = virtualElements.firstChild(elementOrVirtualElement)\n\n  if (!nextInQueue) { return }\n\n  let currentChild\n  const provider = getBindingProvider()\n  const preprocessNode = provider.preprocessNode\n\n  // Preprocessing allows a binding provider to mutate a node before bindings are applied to it. For example it's\n  // possible to insert new siblings after it, and/or replace the node with a different one. This can be used to\n  // implement custom binding syntaxes, such as {{ value }} for string interpolation, or custom element types that\n  // trigger insertion of <template> contents at that point in the document.\n  if (preprocessNode) {\n    while (currentChild = nextInQueue) {\n      nextInQueue = virtualElements.nextSibling(currentChild)\n      preprocessNode.call(provider, currentChild)\n    }\n\n    // Reset nextInQueue for the next loop\n    nextInQueue = virtualElements.firstChild(elementOrVirtualElement)\n  }\n\n  while (currentChild = nextInQueue) {\n    // Keep a record of the next child *before* applying bindings, in case the binding removes the current child from its position\n    nextInQueue = virtualElements.nextSibling(currentChild)\n    applyBindingsToNodeAndDescendantsInternal(bindingContext, currentChild, asyncBindingsApplied)\n  }\n\n  bindingEvent.notify(elementOrVirtualElement, bindingEvent.childrenComplete)\n}\n\nfunction hasBindings (node) {\n  const provider = getBindingProvider()\n  return isProviderForNode(provider, node) && provider.nodeHasBindings(node)\n}\n\nfunction nodeOrChildHasBindings (node) {\n  return hasBindings(node) || [...node.childNodes].some(c => nodeOrChildHasBindings(c))\n}\n\nfunction applyBindingsToNodeAndDescendantsInternal (bindingContext, nodeVerified, asyncBindingsApplied) {\n  var isElement = nodeVerified.nodeType === 1\n  if (isElement) { // Workaround IE <= 8 HTML parsing weirdness\n    virtualElements.normaliseVirtualElementDomStructure(nodeVerified)\n  }\n\n  // Perf optimisation: Apply bindings only if...\n  // (1) We need to store the binding info for the node (all element nodes)\n  // (2) It might have bindings (e.g., it has a data-bind attribute, or it's a marker for a containerless template)\n\n  let shouldApplyBindings = isElement || // Case (1)\n      hasBindings(nodeVerified)          // Case (2)\n\n  const { shouldBindDescendants } = shouldApplyBindings\n    ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext, asyncBindingsApplied)\n    : { shouldBindDescendants: true }\n\n  if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[tagNameLower(nodeVerified)]) {\n    // We're recursing automatically into (real or virtual) child nodes without changing binding contexts. So,\n    //  * For children of a *real* element, the binding context is certainly the same as on their DOM .parentNode,\n    //    hence bindingContextsMayDifferFromDomParentElement is false\n    //  * For children of a *virtual* element, we can't be sure. Evaluating .parentNode on those children may\n    //    skip over any number of intermediate virtual elements, any of which might define a custom binding context,\n    //    hence bindingContextsMayDifferFromDomParentElement is true\n    applyBindingsToDescendantsInternal(bindingContext, nodeVerified, asyncBindingsApplied)\n  }\n}\n\n\nfunction * topologicalSortBindings (bindings, $component) {\n  const results = []\n  // Depth-first sort\n  const bindingsConsidered = {}    // A temporary record of which bindings are already in 'result'\n  const cyclicDependencyStack = [] // Keeps track of a depth-search so that, if there's a cycle, we know which bindings caused it\n\n  objectForEach(bindings, function pushBinding (bindingKey) {\n    if (!bindingsConsidered[bindingKey]) {\n      const binding = getBindingHandlerFromComponent(bindingKey, $component) || getBindingHandler(bindingKey)\n      if (!binding) { return }\n        // First add dependencies (if any) of the current binding\n      if (binding.after) {\n        cyclicDependencyStack.push(bindingKey)\n        arrayForEach(binding.after, function (bindingDependencyKey) {\n          if (!bindings[bindingDependencyKey]) { return }\n          if (arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {\n            throw Error('Cannot combine the following bindings, because they have a cyclic dependency: ' + cyclicDependencyStack.join(', '))\n          } else {\n            pushBinding(bindingDependencyKey)\n          }\n        })\n        cyclicDependencyStack.length--\n      }\n        // Next add the current binding\n      results.push([ bindingKey, binding ])\n    }\n    bindingsConsidered[bindingKey] = true\n  })\n\n  for (const result of results) { yield result }\n}\n\nfunction applyBindingsToNodeInternal (node, sourceBindings, bindingContext, asyncBindingsApplied) {\n  const bindingInfo = domData.getOrSet(node, boundElementDomDataKey, {})\n  // Prevent multiple applyBindings calls for the same node, except when a binding value is specified\n  const alreadyBound = bindingInfo.alreadyBound\n  if (!sourceBindings) {\n    if (alreadyBound) {\n      if (!nodeOrChildHasBindings(node)) { return false }\n      onBindingError({\n        during: 'apply',\n        errorCaptured: new Error('You cannot apply bindings multiple times to the same element.'),\n        element: node,\n        bindingContext\n      })\n      return false\n    }\n    bindingInfo.alreadyBound = true\n  }\n\n  if (!alreadyBound) {\n    bindingInfo.context = bindingContext\n  }\n\n  // Use bindings if given, otherwise fall back on asking the bindings provider to give us some bindings\n  var bindings\n  if (sourceBindings && typeof sourceBindings !== 'function') {\n    bindings = sourceBindings\n  } else {\n    const provider = getBindingProvider()\n    const getBindings = provider.getBindingAccessors\n\n    if (isProviderForNode(provider, node)) {\n          // Get the binding from the provider within a computed observable so that we can update the bindings whenever\n          // the binding context is updated or if the binding provider accesses observables.\n      var bindingsUpdater = computed(\n              function () {\n                bindings = sourceBindings ? sourceBindings(bindingContext, node) : getBindings.call(provider, node, bindingContext)\n                  // Register a dependency on the binding context to support observable view models.\n                if (bindings && bindingContext[contextSubscribeSymbol]) { bindingContext[contextSubscribeSymbol]() }\n                return bindings\n              },\n              null, { disposeWhenNodeIsRemoved: node }\n          )\n\n      if (!bindings || !bindingsUpdater.isActive()) { bindingsUpdater = null }\n    }\n  }\n\n  var bindingHandlerThatControlsDescendantBindings\n  if (bindings) {\n    const $component = bindingContext.$component || {}\n\n    const allBindingHandlers = {}\n    domData.set(node, 'bindingHandlers', allBindingHandlers)\n\n        // Return the value accessor for a given binding. When bindings are static (won't be updated because of a binding\n        // context update), just return the value accessor from the binding. Otherwise, return a function that always gets\n        // the latest binding value and registers a dependency on the binding updater.\n    const getValueAccessor = bindingsUpdater\n            ? (bindingKey) => function (optionalValue) {\n              const valueAccessor = bindingsUpdater()[bindingKey]\n              if (arguments.length === 0) {\n                return evaluateValueAccessor(valueAccessor)\n              } else {\n                return valueAccessor(optionalValue)\n              }\n            } : (bindingKey) => bindings[bindingKey]\n\n        // Use of allBindings as a function is maintained for backwards compatibility, but its use is deprecated\n    function allBindings () {\n      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor)\n    }\n\n        // The following is the 3.x allBindings API\n    allBindings.has = (key) => key in bindings\n    allBindings.get = (key) => bindings[key] && evaluateValueAccessor(getValueAccessor(key))\n\n    if (bindingEvent.childrenComplete in bindings) {\n      bindingEvent.subscribe(node, bindingEvent.childrenComplete, () => {\n        const callback = evaluateValueAccessor(bindings[bindingEvent.childrenComplete])\n        if (!callback) { return }\n        const nodes = virtualElements.childNodes(node)\n        if (nodes.length) { callback(nodes, dataFor(nodes[0])) }\n      })\n    }\n\n    const bindingsGenerated = topologicalSortBindings(bindings, $component)\n    const nodeAsyncBindingPromises = new Set()\n    for (const [key, BindingHandlerClass] of bindingsGenerated) {\n        // Go through the sorted bindings, calling init and update for each\n      function reportBindingError (during, errorCaptured) {\n        onBindingError({\n          during,\n          errorCaptured,\n          bindings,\n          allBindings,\n          bindingKey: key,\n          bindingContext,\n          element: node,\n          valueAccessor: getValueAccessor(key)\n        })\n      }\n\n      if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {\n        throw new Error(`The binding '${key}' cannot be used with virtual elements`)\n      }\n\n      try {\n        const bindingHandler = dependencyDetection.ignore(() =>\n          new BindingHandlerClass({\n            allBindings,\n            $element: node,\n            $context: bindingContext,\n            onError: reportBindingError,\n            valueAccessor (...v) { return getValueAccessor(key)(...v) }\n          })\n        )\n\n        if (bindingHandler.onValueChange) {\n          dependencyDetection.ignore(() =>\n            bindingHandler.computed('onValueChange')\n          )\n        }\n\n        // Expose the bindings via domData.\n        allBindingHandlers[key] = bindingHandler\n\n        if (bindingHandler.controlsDescendants) {\n          if (bindingHandlerThatControlsDescendantBindings !== undefined) { throw new Error('Multiple bindings (' + bindingHandlerThatControlsDescendantBindings + ' and ' + key + ') are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.') }\n          bindingHandlerThatControlsDescendantBindings = key\n        }\n\n        if (bindingHandler.bindingCompleted instanceof Promise) {\n          asyncBindingsApplied.add(bindingHandler.bindingCompleted)\n          nodeAsyncBindingPromises.add(bindingHandler.bindingCompleted)\n        }\n      } catch (err) {\n        reportBindingError('creation', err)\n      }\n    }\n\n    triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises)\n  }\n\n  const shouldBindDescendants = bindingHandlerThatControlsDescendantBindings === undefined\n  return { shouldBindDescendants }\n}\n\n/**\n *\n * @param {HTMLElement} node\n * @param {Object} bindings\n * @param {[Promise]} nodeAsyncBindingPromises\n */\nfunction triggerDescendantsComplete (node, bindings, nodeAsyncBindingPromises) {\n  /** descendantsComplete ought to be an instance of the descendantsComplete\n    *  binding handler. */\n  const hasBindingHandler = bindingEvent.descendantsComplete in bindings\n  const hasFirstChild = virtualElements.firstChild(node)\n  const accessor = hasBindingHandler && evaluateValueAccessor(bindings[bindingEvent.descendantsComplete])\n  const callback = () => {\n    bindingEvent.notify(node, bindingEvent.descendantsComplete)\n    if (accessor && hasFirstChild) { accessor(node) }\n  }\n  if (nodeAsyncBindingPromises.size) {\n    Promise.all(nodeAsyncBindingPromises).then(callback)\n  } else {\n    callback()\n  }\n}\n\n\nfunction getBindingContext (viewModelOrBindingContext, extendContextCallback) {\n  return viewModelOrBindingContext && (viewModelOrBindingContext instanceof bindingContext)\n    ? viewModelOrBindingContext\n    : new bindingContext(viewModelOrBindingContext, undefined, undefined, extendContextCallback)\n}\n\nexport function applyBindingAccessorsToNode (node, bindings, viewModelOrBindingContext, asyncBindingsApplied) {\n  if (node.nodeType === 1) { // If it's an element, workaround IE <= 8 HTML parsing weirdness\n    virtualElements.normaliseVirtualElementDomStructure(node)\n  }\n  return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), asyncBindingsApplied)\n}\n\nexport function applyBindingsToNode (node, bindings, viewModelOrBindingContext) {\n  const asyncBindingsApplied = new Set()\n  const bindingContext = getBindingContext(viewModelOrBindingContext)\n  const bindingAccessors = getBindingProvider().makeBindingAccessors(bindings, bindingContext, node)\n  applyBindingAccessorsToNode(node, bindingAccessors, bindingContext, asyncBindingsApplied)\n  return new BindingResult({asyncBindingsApplied, rootNode: node, bindingContext})\n}\n\nexport function applyBindingsToDescendants (viewModelOrBindingContext, rootNode) {\n  const asyncBindingsApplied = new Set()\n  if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {\n    const bindingContext = getBindingContext(viewModelOrBindingContext)\n    applyBindingsToDescendantsInternal(bindingContext, rootNode, asyncBindingsApplied)\n    return new BindingResult({asyncBindingsApplied, rootNode, bindingContext})\n  }\n  return new BindingResult({asyncBindingsApplied, rootNode})\n}\n\nexport function applyBindings (viewModelOrBindingContext, rootNode, extendContextCallback) {\n  const asyncBindingsApplied = new Set()\n  // If jQuery is loaded after Knockout, we won't initially have access to it. So save it here.\n  if (!options.jQuery === undefined && options.jQuery) {\n    options.jQuery = options.jQuery\n  }\n\n  // rootNode is optional\n  if (!rootNode) {\n    rootNode = window.document.body\n    if (!rootNode) {\n      throw Error('ko.applyBindings: could not find window.document.body; has the document been loaded?')\n    }\n  } else if (rootNode.nodeType !== 1 && rootNode.nodeType !== 8) {\n    throw Error('ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node')\n  }\n  const rootContext = getBindingContext(viewModelOrBindingContext, extendContextCallback)\n  applyBindingsToNodeAndDescendantsInternal(rootContext, rootNode, asyncBindingsApplied)\n  return Promise.all(asyncBindingsApplied)\n}\n\nfunction onBindingError (spec) {\n  var error, bindingText\n  if (spec.bindingKey) {\n        // During: 'init' or initial 'update'\n    error = spec.errorCaptured\n    spec.message = 'Unable to process binding \"' + spec.bindingKey +\n            '\" in binding \"' + spec.bindingKey +\n            '\"\\nMessage: ' + (error.message ? error.message : error)\n  } else {\n        // During: 'apply'\n    error = spec.errorCaptured\n  }\n  try {\n    extend(error, spec)\n  } catch (e) {\n        // Read-only error e.g. a DOMEXception.\n    spec.stack = error.stack\n    error = new Error(error.message ? error.message : error)\n    extend(error, spec)\n  }\n  options.onError(error)\n}\n"],
+  "mappings": "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",
+  "names": []
+}