@tko/bind 4.0.0-beta1.0 → 4.0.0

package/dist/BindingHandler.js

@@ -1,4 +1,5 @@
-// @tko/bind 🥊 4.0.0-beta1.0 ESM
+// @tko/bind 🥊 4.0.0 ESM
+"use strict";
 import { options } from "@tko/utils";
 import { isWriteableObservable } from "@tko/observable";
 import { LifeCycle } from "@tko/lifecycle";
@@ -6,13 +7,11 @@ 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.$element = $element;
+    this.valueAccessor = valueAccessor;
+    this.allBindings = allBindings;
+    this.$context = $context;
+    this.$data = $context.$data;
     this.anchorTo($element);
   }
   get value() {
@@ -35,14 +34,23 @@ export class BindingHandler extends LifeCycle {
   static get isBindingHandlerClass() {
     return true;
   }
+  /* Overload this for asynchronous bindings or bindings that recursively
+       apply bindings (e.g. components, foreach, template).
+  
+       A binding should be complete when it has run through once, notably
+       in server-side bindings for pre-rendering.
+    */
   get bindingCompleted() {
     return true;
   }
   static registerAs(name, provider = options.bindingProviderInstance) {
     provider.bindingHandlers.set(name, this);
   }
+  static registerBindingHandler(handler, name, provider = options.bindingProviderInstance) {
+    provider.bindingHandlers.set(name, handler);
+  }
 }
-const ResolveSymbol = Symbol("Async Binding Resolved");
+const ResolveSymbol = /* @__PURE__ */ Symbol("Async Binding Resolved");
 export class AsyncBindingHandler extends BindingHandler {
   constructor(params) {
     super(params);

package/dist/BindingHandler.js.map

@@ -1,7 +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;",
+  "sourcesContent": ["import { options } from '@tko/utils'\nimport { isWriteableObservable } from '@tko/observable'\nimport { LifeCycle } from '@tko/lifecycle'\nimport type { BindingContext } from './bindingContext'\n\nexport type BindingHandlerControlsDescendant = { controlsDescendantBindings: boolean }\nexport type BindingHandlerAddBinding = (name: string, value: any) => void\n\n// usage in applyBindings, BindingHandler, event, checked, options\nexport interface AllBindings {\n  (): any\n\n  get(name: string): any\n  get<T = any>(name: string): T\n\n  has(name: string): boolean\n}\n\nexport class BindingHandler<T = any> extends LifeCycle {\n  after?: string[]\n  init?: (\n    element: any,\n    valueAccessor: () => T,\n    allBindings: AllBindings,\n    viewModel: any,\n    bindingContext: BindingContext<any>\n  ) => void | BindingHandlerControlsDescendant\n  update?: (\n    element: any,\n    valueAccessor: () => T,\n    allBindings: AllBindings,\n    viewModel: any,\n    bindingContext: BindingContext<any>\n  ) => void\n  options?: any\n  preprocess?: (\n    value: string | undefined,\n    name: string,\n    addBinding: BindingHandlerAddBinding\n  ) => string | undefined | void\n\n  $context: BindingContext // most likly BindingContext but params must be typed first\n  $element: HTMLElement\n  $data: any\n  bindingCompletion: any\n  valueAccessor: Function\n  completeBinding: any\n  allBindings: AllBindings\n\n  constructor(params) {\n    super()\n    const { $element, valueAccessor, allBindings, $context } = params\n\n    this.$element = $element\n    this.valueAccessor = valueAccessor\n    this.allBindings = allBindings\n    this.$context = $context\n    this.$data = $context.$data\n\n    this.anchorTo($element)\n  }\n\n  get value() {\n    return this.valueAccessor()\n  }\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() {\n    return false\n  }\n\n  static get allowVirtualElements() {\n    return false\n  }\n  static get isBindingHandlerClass() {\n    return true\n  }\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(): Promise<boolean> | boolean {\n    return true\n  }\n\n  static registerAs(name: string, provider = options.bindingProviderInstance) {\n    provider.bindingHandlers.set(name, this) //todo dangerous javascript: this in static function = this is calling object\n  }\n\n  static registerBindingHandler(handler: BindingHandler, name: string, provider = options.bindingProviderInstance) {\n    provider.bindingHandlers.set(name, handler)\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  override get bindingCompleted(): Promise<boolean> {\n    return this.bindingCompletion\n  }\n}\n"],
+  "mappings": ";;AAAA,SAAS,eAAe;AACxB,SAAS,6BAA6B;AACtC,SAAS,iBAAiB;AAgBnB,aAAM,uBAAgC,UAAU;AAAA,EA+BrD,YAAY,QAAQ;AAClB,UAAM;AACN,UAAM,EAAE,UAAU,eAAe,aAAa,SAAS,IAAI;AAE3D,SAAK,WAAW;AAChB,SAAK,gBAAgB;AACrB,SAAK,cAAc;AACnB,SAAK,WAAW;AAChB,SAAK,QAAQ,SAAS;AAEtB,SAAK,SAAS,QAAQ;AAAA,EACxB;AAAA,EAEA,IAAI,QAAQ;AACV,WAAO,KAAK,cAAc;AAAA,EAC5B;AAAA,EACA,IAAI,MAAM,GAAG;AACX,UAAM,KAAK,KAAK,cAAc;AAC9B,QAAI,sBAAsB,EAAE,GAAG;AAC7B,SAAG,CAAC;AAAA,IACN,OAAO;AACL,WAAK,cAAc,CAAC;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,IAAI,sBAAsB;AACxB,WAAO;AAAA,EACT;AAAA,EAEA,WAAW,uBAAuB;AAChC,WAAO;AAAA,EACT;AAAA,EACA,WAAW,wBAAwB;AACjC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAI,mBAA+C;AACjD,WAAO;AAAA,EACT;AAAA,EAEA,OAAO,WAAW,MAAc,WAAW,QAAQ,yBAAyB;AAC1E,aAAS,gBAAgB,IAAI,MAAM,IAAI;AAAA,EACzC;AAAA,EAEA,OAAO,uBAAuB,SAAyB,MAAc,WAAW,QAAQ,yBAAyB;AAC/G,aAAS,gBAAgB,IAAI,MAAM,OAAO;AAAA,EAC5C;AACF;AAMA,MAAM,gBAAgB,uBAAO,wBAAwB;AAE9C,aAAM,4BAA4B,eAAe;AAAA,EACtD,YAAY,QAAQ;AAClB,UAAM,MAAM;AACZ,SAAK,oBAAoB,IAAI,QAAQ,aAAW;AAC9C,WAAK,aAAa,IAAI;AAAA,IACxB,CAAC;AACD,SAAK,kBAAkB,mBAAiB,KAAK,aAAa,EAAE,aAAa;AAAA,EAC3E;AAAA,EAEA,IAAa,mBAAqC;AAChD,WAAO,KAAK;AAAA,EACd;AACF;",
   "names": []
 }

package/dist/BindingResult.js

@@ -1,41 +1,18 @@
-// @tko/bind 🥊 4.0.0-beta1.0 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());
-  });
-};
+// @tko/bind 🥊 4.0.0 ESM
+"use strict";
 export class BindingResult {
   constructor({ asyncBindingsApplied, rootNode, bindingContext }) {
-    Object.assign(this, {
-      rootNode,
-      bindingContext,
-      isSync: asyncBindingsApplied.size === 0,
-      isComplete: this.isSync
-    });
+    this.rootNode = rootNode;
+    this.bindingContext = bindingContext;
+    this.isSync = asyncBindingsApplied.size === 0;
+    this.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;
-    });
+  async completeWhenBindingsFinish(asyncBindingsApplied) {
+    await Promise.all(asyncBindingsApplied);
+    this.isComplete = true;
+    return this;
   }
 }

package/dist/BindingResult.js.map

@@ -1,7 +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;",
+  "sourcesContent": ["import type { BindingContext } from './bindingContext'\n\nexport class BindingResult {\n  isSync: boolean\n  isComplete: boolean\n  completionPromise: Promise<BindingResult>\n  rootNode: Node\n  bindingContext: BindingContext\n\n  constructor({ asyncBindingsApplied, rootNode, bindingContext }) {\n    this.rootNode = rootNode\n    this.bindingContext = bindingContext\n    this.isSync = asyncBindingsApplied.size === 0\n    this.isComplete = this.isSync\n\n    if (!this.isSync) {\n      this.completionPromise = this.completeWhenBindingsFinish(asyncBindingsApplied)\n    }\n  }\n\n  async completeWhenBindingsFinish(asyncBindingsApplied: Set<any>) {\n    await Promise.all(asyncBindingsApplied)\n    this.isComplete = true\n    return this\n  }\n}\n"],
+  "mappings": ";;AAEO,aAAM,cAAc;AAAA,EAOzB,YAAY,EAAE,sBAAsB,UAAU,eAAe,GAAG;AAC9D,SAAK,WAAW;AAChB,SAAK,iBAAiB;AACtB,SAAK,SAAS,qBAAqB,SAAS;AAC5C,SAAK,aAAa,KAAK;AAEvB,QAAI,CAAC,KAAK,QAAQ;AAChB,WAAK,oBAAoB,KAAK,2BAA2B,oBAAoB;AAAA,IAC/E;AAAA,EACF;AAAA,EAEA,MAAM,2BAA2B,sBAAgC;AAC/D,UAAM,QAAQ,IAAI,oBAAoB;AACtC,SAAK,aAAa;AAClB,WAAO;AAAA,EACT;AACF;",
   "names": []
 }

package/dist/DescendantBindingHandler.js

@@ -1,42 +1,21 @@
-// @tko/bind 🥊 4.0.0-beta1.0 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());
-  });
-};
+// @tko/bind 🥊 4.0.0 ESM
+"use strict";
 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);
-    });
+  async applyBindingsToDescendants(childContext, callback) {
+    const bindingResult = applyBindingsToDescendants(childContext, this.$element);
+    if (bindingResult.isSync) {
+      this.bindingCompletion = bindingResult;
+    } else {
+      await bindingResult.completionPromise;
+    }
+    if (callback) {
+      callback(bindingResult);
+    }
+    this.completeBinding(bindingResult);
   }
 }

package/dist/DescendantBindingHandler.js.map

@@ -1,7 +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;",
+  "sourcesContent": ["import { applyBindingsToDescendants } from './applyBindings'\nimport { AsyncBindingHandler } from './BindingHandler'\nimport type { BindingResult } from './BindingResult'\nimport type { BindingContext } from './bindingContext'\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  override get controlsDescendants() {\n    return true\n  }\n\n  async applyBindingsToDescendants(childContext: BindingContext, callback?: (result: BindingResult) => void) {\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) {\n      callback(bindingResult)\n    }\n    this.completeBinding(bindingResult)\n  }\n}\n"],
+  "mappings": ";;AAAA,SAAS,kCAAkC;AAC3C,SAAS,2BAA2B;AAS7B,aAAM,iCAAiC,oBAAoB;AAAA,EAChE,IAAa,sBAAsB;AACjC,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,2BAA2B,cAA8B,UAA4C;AACzG,UAAM,gBAAgB,2BAA2B,cAAc,KAAK,QAAQ;AAC5E,QAAI,cAAc,QAAQ;AACxB,WAAK,oBAAoB;AAAA,IAC3B,OAAO;AACL,YAAM,cAAc;AAAA,IACtB;AACA,QAAI,UAAU;AACZ,eAAS,aAAa;AAAA,IACxB;AACA,SAAK,gBAAgB,aAAa;AAAA,EACpC;AACF;",
   "names": []
 }

package/dist/LegacyBindingHandler.js

@@ -1,9 +1,13 @@
-// @tko/bind 🥊 4.0.0-beta1.0 ESM
+// @tko/bind 🥊 4.0.0 ESM
+"use strict";
 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 {
+  get handler() {
+    return void 0;
+  }
   constructor(params) {
     super(params);
     const handler = this.handler;
@@ -29,18 +33,21 @@ export class LegacyBindingHandler extends BindingHandler {
     }
   }
   get legacyArgs() {
-    return [
-      this.$element,
-      this.valueAccessor,
-      this.allBindings,
-      this.$data,
-      this.$context
-    ];
+    return [this.$element, this.valueAccessor, this.allBindings, this.$data, this.$context];
   }
   get controlsDescendants() {
     const objectToTest = this.initReturn || this.handler || {};
     return objectToTest.controlsDescendantBindings;
   }
+  /**
+   * Create a handler instance from the `origin`, which may be:
+   *
+   * 1. an object (becomes LegacyBindingHandler)
+   * 2. a function (becomes LegacyBindingHandler with `init: function`)
+   *
+   * If given an object (the only kind supported in knockout 3.x and before), it
+   * shall draw the `init`, `update`, and `allowVirtualElements` properties
+   */
   static getOrCreateFor(key, handler) {
     if (legacyBindingMap.has(handler)) {
       return legacyBindingMap.get(handler);

package/dist/LegacyBindingHandler.js.map

@@ -1,7 +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;",
+  "sourcesContent": ["import { 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  get handler(): any {\n    // Needed to prevent tsc error for using this.handler\n    // is overriden in factory functions. Any must be used for return type\n    return undefined\n  }\n  initReturn: any\n  onError: (step: string, error: unknown) => void\n  constructor(params: any) {\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(): void {\n    const handler = this.handler\n    if (typeof handler.update !== 'function') {\n      return\n    }\n    try {\n      handler.update(...this.legacyArgs)\n    } catch (e) {\n      this.onError('update', e)\n    }\n  }\n\n  get legacyArgs(): any[] {\n    return [this.$element, this.valueAccessor, this.allBindings, this.$data, this.$context]\n  }\n\n  override get controlsDescendants(): boolean {\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: string | undefined, handler: any): any {\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: string | undefined, handler: any): any {\n    if (typeof handler === 'function') {\n      const [initFn, disposeFn] = [handler, handler.dispose]\n      return class extends LegacyBindingHandler {\n        override 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() {\n          return handler.after\n        }\n        static override get allowVirtualElements() {\n          return handler.allowVirtualElements || virtualElements.allowedBindings[key!]\n        }\n      }\n    }\n\n    if (typeof handler === 'object') {\n      return class extends LegacyBindingHandler {\n        override get handler() {\n          return handler\n        }\n        static get after() {\n          return handler.after\n        }\n        static override 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": ";;AAAA,SAAS,iBAAiB,eAAe;AACzC,SAAS,sBAAsB;AAU/B,MAAM,kBAAkB,QAAQ,OAAO,WAAW;AAClD,MAAM,mBAAmB,IAAI,gBAAgB;AAEtC,aAAM,6BAA6B,eAAe;AAAA,EACvD,IAAI,UAAe;AAGjB,WAAO;AAAA,EACT;AAAA,EAGA,YAAY,QAAa;AACvB,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,GAAG;AACV,aAAO,QAAQ,QAAQ,CAAC;AAAA,IAC1B;AAAA,EACF;AAAA,EAEA,gBAAsB;AACpB,UAAM,UAAU,KAAK;AACrB,QAAI,OAAO,QAAQ,WAAW,YAAY;AACxC;AAAA,IACF;AACA,QAAI;AACF,cAAQ,OAAO,GAAG,KAAK,UAAU;AAAA,IACnC,SAAS,GAAG;AACV,WAAK,QAAQ,UAAU,CAAC;AAAA,IAC1B;AAAA,EACF;AAAA,EAEA,IAAI,aAAoB;AACtB,WAAO,CAAC,KAAK,UAAU,KAAK,eAAe,KAAK,aAAa,KAAK,OAAO,KAAK,QAAQ;AAAA,EACxF;AAAA,EAEA,IAAa,sBAA+B;AAC1C,UAAM,eAAe,KAAK,cAAc,KAAK,WAAW,CAAC;AACzD,WAAO,aAAa;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,eAAe,KAAyB,SAAmB;AAChE,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,EAEA,OAAO,UAAU,KAAyB,SAAmB;AAC3D,QAAI,OAAO,YAAY,YAAY;AACjC,YAAM,CAAC,QAAQ,SAAS,IAAI,CAAC,SAAS,QAAQ,OAAO;AACrD,aAAO,cAAc,qBAAqB;AAAA,QACxC,IAAa,UAAU;AACrB,gBAAM,OAAO,OAAO,KAAK,IAAI;AAC7B,gBAAM,UAAU,YAAY,UAAU,KAAK,IAAI,IAAI;AACnD,iBAAO,EAAE,MAAM,QAAQ;AAAA,QACzB;AAAA,QACA,WAAW,QAAQ;AACjB,iBAAO,QAAQ;AAAA,QACjB;AAAA,QACA,WAAoB,uBAAuB;AACzC,iBAAO,QAAQ,wBAAwB,gBAAgB,gBAAgB,GAAI;AAAA,QAC7E;AAAA,MACF;AAAA,IACF;AAEA,QAAI,OAAO,YAAY,UAAU;AAC/B,aAAO,cAAc,qBAAqB;AAAA,QACxC,IAAa,UAAU;AACrB,iBAAO;AAAA,QACT;AAAA,QACA,WAAW,QAAQ;AACjB,iBAAO,QAAQ;AAAA,QACjB;AAAA,QACA,WAAoB,uBAAuB;AACzC,iBAAO,QAAQ,wBAAwB,gBAAgB,gBAAgB,GAAI;AAAA,QAC7E;AAAA,MACF;AAAA,IACF;AAEA,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACjE;AACF;",
   "names": []
 }

package/dist/applyBindings.js

@@ -1,4 +1,5 @@
-// @tko/bind 🥊 4.0.0-beta1.0 ESM
+// @tko/bind 🥊 4.0.0 ESM
+"use strict";
 import {
   extend,
   objectMap,
@@ -10,37 +11,27 @@ import {
   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";
+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
+  // Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,
+  // because it's unexpected and a potential XSS issue.
+  // Also bindings should not operate on <template> elements since this breaks in Internet Explorer
+  // and because such elements' contents are always intended to be bound in a different context
+  // from where they appear in the document.
+  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];
+  const nodeTypes = provider.FOR_NODE_TYPES || [Node.ELEMENT_NODE, Node.TEXT_NODE, Node.COMMENT_NODE];
   return nodeTypes.includes(node.nodeType);
 }
 function asProperHandlerClass(handler, bindingKey) {
@@ -91,11 +82,11 @@ function nodeOrChildHasBindings(node) {
   return hasBindings(node) || [...node.childNodes].some((c) => nodeOrChildHasBindings(c));
 }
 function applyBindingsToNodeAndDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied) {
-  var isElement = nodeVerified.nodeType === 1;
+  const isElement = nodeVerified.nodeType === Node.ELEMENT_NODE;
   if (isElement) {
     virtualElements.normaliseVirtualElementDomStructure(nodeVerified);
   }
-  let shouldApplyBindings = isElement || hasBindings(nodeVerified);
+  const shouldApplyBindings = isElement || hasBindings(nodeVerified);
   const { shouldBindDescendants } = shouldApplyBindings ? applyBindingsToNodeInternal(nodeVerified, null, bindingContext2, asyncBindingsApplied) : { shouldBindDescendants: true };
   if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[tagNameLower(nodeVerified)]) {
     applyBindingsToDescendantsInternal(bindingContext2, nodeVerified, asyncBindingsApplied);
@@ -104,7 +95,7 @@ function applyBindingsToNodeAndDescendantsInternal(bindingContext2, nodeVerified
 function* topologicalSortBindings(bindings, $component) {
   const results = [];
   const bindingsConsidered = {};
-  const cyclicDependencyStack = [];
+  const cyclicDependencyStack = new Array();
   objectForEach(bindings, function pushBinding(bindingKey) {
     if (!bindingsConsidered[bindingKey]) {
       const binding = getBindingHandlerFromComponent(bindingKey, $component) || getBindingHandler(bindingKey);
@@ -118,7 +109,9 @@ function* topologicalSortBindings(bindings, $component) {
             return;
           }
           if (arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
-            throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", "));
+            throw Error(
+              "Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", ")
+            );
           } else {
             pushBinding(bindingDependencyKey);
           }
@@ -154,30 +147,32 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
   if (!alreadyBound) {
     bindingInfo.context = bindingContext2;
   }
-  var bindings;
+  let bindings = null;
+  let bindingsUpdater = null;
   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 });
+      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;
+  let bindingHandlerThatControlsDescendantBindings;
   if (bindings) {
-    let allBindings = function() {
-      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
-    };
     const $component = bindingContext2.$component || {};
     const allBindingHandlers = {};
     domData.set(node, "bindingHandlers", allBindingHandlers);
@@ -189,24 +184,32 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
         return valueAccessor(optionalValue);
       }
     } : (bindingKey) => bindings[bindingKey];
+    const allBindings = function() {
+      return objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
+    };
     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]));
-        }
-      });
+      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]));
+          }
+        },
+        null
+      );
     }
     const bindingsGenerated = topologicalSortBindings(bindings, $component);
     const nodeAsyncBindingPromises = /* @__PURE__ */ new Set();
     for (const [key, BindingHandlerClass] of bindingsGenerated) {
-      let reportBindingError = function(during, errorCaptured) {
+      const reportBindingError = function(during, errorCaptured) {
         onBindingError({
           during,
           errorCaptured,
@@ -218,26 +221,30 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
           valueAccessor: getValueAccessor(key)
         });
       };
-      if (node.nodeType === 8 && !BindingHandlerClass.allowVirtualElements) {
+      if (node.nodeType === Node.COMMENT_NODE && !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);
-          }
-        }));
+        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.");
+            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;
         }
@@ -246,7 +253,8 @@ function applyBindingsToNodeInternal(node, sourceBindings, bindingContext2, asyn
           nodeAsyncBindingPromises.add(bindingHandler.bindingCompleted);
         }
       } catch (err) {
-        reportBindingError("creation", err);
+        const error = err instanceof Error ? err : new Error(String(err));
+        reportBindingError("creation", error);
       }
     }
     triggerDescendantsComplete(node, bindings, nodeAsyncBindingPromises);
@@ -274,10 +282,15 @@ 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) {
+  if (node.nodeType === Node.ELEMENT_NODE) {
     virtualElements.normaliseVirtualElementDomStructure(node);
   }
-  return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), asyncBindingsApplied);
+  return applyBindingsToNodeInternal(
+    node,
+    bindings,
+    getBindingContext(viewModelOrBindingContext),
+    asyncBindingsApplied
+  );
 }
 export function applyBindingsToNode(node, bindings, viewModelOrBindingContext) {
   const asyncBindingsApplied = /* @__PURE__ */ new Set();
@@ -288,24 +301,21 @@ export function applyBindingsToNode(node, bindings, viewModelOrBindingContext) {
 }
 export function applyBindingsToDescendants(viewModelOrBindingContext, rootNode) {
   const asyncBindingsApplied = /* @__PURE__ */ new Set();
-  if (rootNode.nodeType === 1 || rootNode.nodeType === 8) {
-    const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+  const bindingContext2 = getBindingContext(viewModelOrBindingContext);
+  if (rootNode.nodeType === Node.ELEMENT_NODE || rootNode.nodeType === Node.COMMENT_NODE) {
     applyBindingsToDescendantsInternal(bindingContext2, rootNode, asyncBindingsApplied);
     return new BindingResult({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 });
   }
-  return new BindingResult({ asyncBindingsApplied, rootNode });
+  return new BindingResult({ asyncBindingsApplied, rootNode, bindingContext: bindingContext2 });
 }
 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) {
+  } else if (rootNode.nodeType !== Node.ELEMENT_NODE && rootNode.nodeType !== Node.COMMENT_NODE) {
     throw Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");
   }
   const rootContext = getBindingContext(viewModelOrBindingContext, extendContextCallback);
@@ -313,7 +323,7 @@ export function applyBindings(viewModelOrBindingContext, rootNode, extendContext
   return Promise.all(asyncBindingsApplied);
 }
 function onBindingError(spec) {
-  var error, bindingText;
+  let error;
   if (spec.bindingKey) {
     error = spec.errorCaptured;
     spec.message = 'Unable to process binding "' + spec.bindingKey + '" in binding "' + spec.bindingKey + '"\nMessage: ' + (error.message ? error.message : error);
@@ -324,7 +334,12 @@ function onBindingError(spec) {
     extend(error, spec);
   } catch (e) {
     spec.stack = error.stack;
-    error = new Error(error.message ? error.message : error);
+    const message = error.message || String(error);
+    const originalName = error.name;
+    error = new Error(message);
+    if (originalName && originalName !== "Error") {
+      error.name = originalName;
+    }
     extend(error, spec);
   }
   options.onError(error);