diff --git a/packages/tko.utils/src/array.ts b/packages/tko.utils/src/array.ts
index 567a0542..c975d1c0 100644
--- a/packages/tko.utils/src/array.ts
+++ b/packages/tko.utils/src/array.ts
@@ -4,165 +4,193 @@
 // Note that the array functions may be called with
 // Array-like things, such as NodeList.
 
-const {isArray} = Array
+const {isArray} = Array;
 
-export function arrayForEach (array, action, thisArg) {
-  if (arguments.length > 2) { action = action.bind(thisArg) }
+// export function arrayForEach<T, TThis>(array: T[], action: (this: TThis, item: T, index: number, array: T[]) => void, thisArg: TThis): void;
+export function arrayForEach<T>(array: T[], action: (item: T, index: number, array: T[]) => void, thisArg?: any) {
+  if (thisArg) { action = action.bind(thisArg); }
   for (let i = 0, j = array.length; i < j; ++i) {
-    action(array[i], i, array)
+    action(array[i], i, array);
   }
 }
 
-export function arrayIndexOf (array, item) {
-  return (isArray(array) ? array : [...array]).indexOf(item)
+export function arrayIndexOf<T>(array: T[], item: T) {
+  return (isArray(array) ? array : [...array]).indexOf(item);
 }
 
-export function arrayFirst (array, predicate, predicateOwner) {
-  return (isArray(array) ? array : [...array])
-    .find(predicate, predicateOwner) || undefined
+// export function arrayFirst<T, TThis>(array: T[], predicate: (this: TThis, value: T, index: number, obj: T[]) => boolean, predicateOwner: TThis): void;
+export function arrayFirst<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean, predicateOwner?: any) {
+  const arr: T[] = (isArray(array) ? array : [...array]);
+  return arr.find(predicate, predicateOwner) || undefined;
 }
 
-export function arrayMap (array = [], mapping, thisArg) {
-  if (arguments.length > 2) { mapping = mapping.bind(thisArg) }
-  return Array.from(array, mapping)
+export function arrayMap<T, U= T, TTHis= void>(array: T[], mapping: (this: TTHis, v: T, k: number) => U, thisArg: TTHis): U[];
+export function arrayMap<T, U= T>(array: T[] = [], mapping?: (v: T, k: number) => U, thisArg?: any) {
+  return thisArg && mapping ? Array.from<T, U>(array, mapping.bind(thisArg)) : Array.from(array);
 }
 
-export function arrayRemoveItem (array, itemToRemove) {
-  var index = arrayIndexOf(array, itemToRemove)
+export function arrayRemoveItem<T>(array: T[], itemToRemove: T) {
+  const index = arrayIndexOf(array, itemToRemove);
   if (index > 0) {
-    array.splice(index, 1)
+    array.splice(index, 1);
   } else if (index === 0) {
-    array.shift()
+    array.shift();
   }
 }
 
-export function arrayGetDistinctValues (array = []) {
-  const seen = new Set()
+export function arrayGetDistinctValues<T>(array: T[] = []) {
+  const seen = new Set();
   return (isArray(array) ? array : [...array])
-    .filter(item => seen.has(item) ? false : seen.add(item))
+    .filter(item => seen.has(item) ? false : seen.add(item));
 }
 
-export function arrayFilter (array, predicate, thisArg) {
-  if (arguments.length > 2) { predicate = predicate.bind(thisArg) }
-  return (isArray(array) ? array : [...array]).filter(predicate)
+export function arrayFilter<T, TThis= void>(array: T[], predicate: (this: TThis, value: T, index: number, array: T[]) => any, thisArg: TThis): T[];
+export function arrayFilter<T>(array: T[], predicate: (value: T, index: number, array: T[]) => any, thisArg?: any) {
+  if (thisArg) { predicate = predicate.bind(thisArg); }
+  return (isArray(array) ? array : [...array]).filter(predicate);
 }
 
-export function arrayPushAll (array, valuesToPush) {
+export function arrayPushAll<T>(array: T[], valuesToPush: ArrayLike<T>) {
   if (isArray(valuesToPush)) {
-    array.push.apply(array, valuesToPush)
+    array.push.apply(array, valuesToPush);
   } else {
-    for (var i = 0, j = valuesToPush.length; i < j; i++) { array.push(valuesToPush[i]) }
+    for (let i = 0, j = valuesToPush.length; i < j; i++) {
+      array.push(valuesToPush[i]);
+    }
   }
-  return array
+
+  return array;
 }
 
-export function addOrRemoveItem (array, value, included) {
-  var existingEntryIndex = arrayIndexOf(typeof array.peek === 'function' ? array.peek() : array, value)
+export function addOrRemoveItem<T>(array: T[], value: T, included?: boolean) {
+  const existingEntryIndex = arrayIndexOf('peek' in array && typeof (array as any).peek === 'function' ? (array as any).peek() : array, value);
   if (existingEntryIndex < 0) {
-    if (included) { array.push(value) }
+    if (included) { array.push(value); }
   } else {
-    if (!included) { array.splice(existingEntryIndex, 1) }
+    if (!included) { array.splice(existingEntryIndex, 1); }
   }
 }
 
-export function makeArray (arrayLikeObject) {
-  return Array.from(arrayLikeObject)
+export function makeArray<T>(arrayLikeObject: ArrayLike<T>) {
+  return Array.from(arrayLikeObject);
 }
 
-export function range (min, max) {
-  min = typeof min === 'function' ? min() : min
-  max = typeof max === 'function' ? max() : max
-  var result = []
-  for (var i = min; i <= max; i++) { result.push(i) }
-  return result
+export type RangeFunction = () => number;
+export function range(min: number|RangeFunction, max: number|RangeFunction) {
+  min = typeof min === 'function' ? min() : min;
+  max = typeof max === 'function' ? max() : max;
+  const result = [];
+
+  for (let i = min; i <= max; i++) { result.push(i); }
+
+  return result;
 }
 
 // Go through the items that have been added and deleted and try to find matches between them.
-export function findMovesInArrayComparison (left, right, limitFailedCompares) {
+export function findMovesInArrayComparison(left: any[], right: any[], limitFailedCompares: number|boolean) {
   if (left.length && right.length) {
-    var failedCompares, l, r, leftItem, rightItem
+    let failedCompares, l, r, leftItem, rightItem;
+
+    // tslint:disable-next-line:no-conditional-assignment
     for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
+      // tslint:disable-next-line:no-conditional-assignment
       for (r = 0; rightItem = right[r]; ++r) {
-        if (leftItem['value'] === rightItem['value']) {
-          leftItem['moved'] = rightItem['index']
-          rightItem['moved'] = leftItem['index']
-          right.splice(r, 1)         // This item is marked as moved; so remove it from right list
-          failedCompares = r = 0     // Reset failed compares count because we're checking for consecutive failures
-          break
+        if (leftItem.value === rightItem.value) {
+          leftItem.moved = rightItem.index;
+          rightItem.moved = leftItem.index;
+          right.splice(r, 1);         // This item is marked as moved; so remove it from right list
+          failedCompares = r = 0;     // Reset failed compares count because we're checking for consecutive failures
+          break;
         }
       }
-      failedCompares += r
+      failedCompares += r;
     }
   }
 }
 
-var statusNotInOld = 'added', statusNotInNew = 'deleted'
+const statusNotInOld = 'added', statusNotInNew = 'deleted';
+
+export interface ICompareArrayOptions {
+  dontLimitMoves?: boolean;
+  sparse?: boolean;
+}
 
     // Simple calculation based on Levenshtein distance.
-export function compareArrays (oldArray, newArray, options) {
+export function compareArrays<T>(oldArray: T[], newArray: T[], options ?: boolean|ICompareArrayOptions) {
     // For backward compatibility, if the third arg is actually a bool, interpret
     // it as the old parameter 'dontLimitMoves'. Newer code should use { dontLimitMoves: true }.
-  options = (typeof options === 'boolean') ? { 'dontLimitMoves': options } : (options || {})
-  oldArray = oldArray || []
-  newArray = newArray || []
+  options = (typeof options === 'boolean') ? { dontLimitMoves: options } : (options || {});
+  oldArray = oldArray || [];
+  newArray = newArray || [];
 
-  if (oldArray.length < newArray.length) { return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options) } else { return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options) }
+  if (oldArray.length < newArray.length) {
+     return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options);
+  } else {
+     return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options);
+  }
 }
 
-function compareSmallArrayToBigArray (smlArray, bigArray, statusNotInSml, statusNotInBig, options) {
-  var myMin = Math.min,
+function compareSmallArrayToBigArray<T>(smlArray: T[], bigArray: T[], statusNotInSml: any, statusNotInBig: any, options: ICompareArrayOptions) {
+  // tslint:disable:prefer-const
+  let myMin = Math.min,
     myMax = Math.max,
     editDistanceMatrix = [],
     smlIndex, smlIndexMax = smlArray.length,
     bigIndex, bigIndexMax = bigArray.length,
     compareRange = (bigIndexMax - smlIndexMax) || 1,
     maxDistance = smlIndexMax + bigIndexMax + 1,
-    thisRow, lastRow,
-    bigIndexMaxForRow, bigIndexMinForRow
+    thisRow, lastRow: any,
+    bigIndexMaxForRow, bigIndexMinForRow;
 
   for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
-    lastRow = thisRow
-    editDistanceMatrix.push(thisRow = [])
-    bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange)
-    bigIndexMinForRow = myMax(0, smlIndex - 1)
+    lastRow = thisRow;
+    editDistanceMatrix.push(thisRow = []);
+    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)  // Top row - transform empty array into new array via additions
-              { thisRow[bigIndex] = bigIndex + 1 } else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1]) { thisRow[bigIndex] = lastRow[bigIndex - 1] }                  // copy value (no edit)
-      else {
-                var northDistance = lastRow[bigIndex] || maxDistance       // not in big (deletion)
-                var westDistance = thisRow[bigIndex - 1] || maxDistance    // not in small (addition)
-                thisRow[bigIndex] = myMin(northDistance, westDistance) + 1
-              }
+      if (!bigIndex) {
+        thisRow[bigIndex] = smlIndex + 1;
+      } else if (!smlIndex) {
+        // Top row - transform empty array into new array via additions
+        thisRow[bigIndex] = bigIndex + 1;
+      } else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1]) {
+        // copy value (no edit)
+        thisRow[bigIndex] = lastRow && lastRow[bigIndex - 1];
+      } else {
+        const northDistance = lastRow && lastRow[bigIndex] || maxDistance;       // not in big (deletion)
+        const westDistance: any = thisRow[bigIndex - 1] || maxDistance;    // not in small (addition)
+        thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;
+      }
     }
   }
 
-  var editScript = [], meMinusOne, notInSml = [], notInBig = []
+  let editScript = [], meMinusOne, notInSml = [], notInBig = [];
   for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex;) {
-    meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1
+    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 })
+        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 })
+        status: statusNotInBig,
+        value: smlArray[--smlIndex],
+        index: smlIndex });
     } else {
-      --bigIndex
-      --smlIndex
-      if (!options['sparse']) {
+      --bigIndex;
+      --smlIndex;
+      if (!options.sparse) {
         editScript.push({
-          'status': 'retained',
-          'value': bigArray[bigIndex] })
+          status: 'retained',
+          value: bigArray[bigIndex] });
       }
     }
   }
 
     // Set a limit on the number of consecutive non-matching comparisons; having it a multiple of
     // smlIndexMax keeps the time complexity of this algorithm linear.
-  findMovesInArrayComparison(notInBig, notInSml, !options['dontLimitMoves'] && smlIndexMax * 10)
+  findMovesInArrayComparison(notInBig, notInSml, !options.dontLimitMoves && smlIndexMax * 10);
 
-  return editScript.reverse()
+  return editScript.reverse();
 }
diff --git a/packages/tko.utils/src/async.ts b/packages/tko.utils/src/async.ts
index d700aef6..629c2df2 100644
--- a/packages/tko.utils/src/async.ts
+++ b/packages/tko.utils/src/async.ts
@@ -1,24 +1,26 @@
 //
 // Asynchronous functionality
 // ---
-import { safeSetTimeout } from './error.js'
+import { safeSetTimeout } from './error';
 
-export function throttle (callback, timeout) {
-  var timeoutInstance
-  return function (...args) {
+// tslint:disable-next-line:ban-types
+export function throttle(callback: Function, timeout: number) {
+  let timeoutInstance: number|undefined;
+  return (...args: any[]) => {
     if (!timeoutInstance) {
-      timeoutInstance = safeSetTimeout(function () {
-        timeoutInstance = undefined
-        callback(...args)
-      }, timeout)
+      timeoutInstance = safeSetTimeout(() => {
+        timeoutInstance = undefined;
+        callback(...args);
+      }, timeout);
     }
-  }
+  };
 }
 
-export function debounce (callback, timeout) {
-  var timeoutInstance
-  return function (...args) {
-    clearTimeout(timeoutInstance)
-    timeoutInstance = safeSetTimeout(() => callback(...args), timeout)
-  }
+// tslint:disable-next-line:ban-types
+export function debounce(callback: Function, timeout: number) {
+  let timeoutInstance: number|undefined;
+  return (...args: any[]) => {
+    clearTimeout(timeoutInstance);
+    timeoutInstance = safeSetTimeout(() => callback(...args), timeout);
+  };
 }
diff --git a/packages/tko.utils/src/css.ts b/packages/tko.utils/src/css.ts
index e1e2aefe..4a4fa778 100644
--- a/packages/tko.utils/src/css.ts
+++ b/packages/tko.utils/src/css.ts
@@ -2,36 +2,37 @@
 // DOM - CSS
 //
 
-import { arrayForEach, addOrRemoveItem } from './array.js'
+import { arrayForEach, addOrRemoveItem } from './array';
 
 // For details on the pattern for changing node classes
 // see: https://github.com/knockout/knockout/issues/1597
-var cssClassNameRegex = /\S+/g
+const cssClassNameRegex = /\S+/g;
 
-function toggleDomNodeCssClass (node, classNames, shouldHaveClass) {
-  var addOrRemoveFn
-  if (!classNames) { return }
+function toggleDomNodeCssClass(node: HTMLElement, classNames: string, shouldHaveClass?: boolean) {
+  let addOrRemoveFn: (className: string) => void;
+  if (!classNames) { return; }
   if (typeof node.classList === 'object') {
-    addOrRemoveFn = node.classList[shouldHaveClass ? 'add' : 'remove']
-    arrayForEach(classNames.match(cssClassNameRegex), function (className) {
-      addOrRemoveFn.call(node.classList, className)
-    })
-  } else if (typeof node.className['baseVal'] === 'string') {
+    addOrRemoveFn = node.classList[shouldHaveClass ? 'add' : 'remove'];
+    arrayForEach(classNames.match(cssClassNameRegex)!, (className: string) => {
+      addOrRemoveFn.call(node.classList, className);
+    });
+  } else if (typeof (node.className as any).baseVal === 'string') {
         // SVG tag .classNames is an SVGAnimatedString instance
-    toggleObjectClassPropertyString(node.className, 'baseVal', classNames, shouldHaveClass)
+    toggleObjectClassPropertyString(node.className, 'baseVal', classNames, shouldHaveClass);
   } else {
         // node.className ought to be a string.
-    toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass)
+    toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass);
   }
 }
 
-function toggleObjectClassPropertyString (obj, prop, classNames, shouldHaveClass) {
+function toggleObjectClassPropertyString(obj: any, prop: string, classNames: string, shouldHaveClass?: boolean) {
     // obj/prop is either a node/'className' or a SVGAnimatedString/'baseVal'.
-  var currentClassNames = obj[prop].match(cssClassNameRegex) || []
-  arrayForEach(classNames.match(cssClassNameRegex), function (className) {
-    addOrRemoveItem(currentClassNames, className, shouldHaveClass)
-  })
-  obj[prop] = currentClassNames.join(' ')
+  const currentClassNames = obj[prop].match(cssClassNameRegex) || [];
+  arrayForEach(classNames.match(cssClassNameRegex)!, (className: string) => {
+    addOrRemoveItem(currentClassNames, className, shouldHaveClass);
+  });
+
+  obj[prop] = currentClassNames.join(' ');
 }
 
-export { toggleDomNodeCssClass }
+export { toggleDomNodeCssClass };
diff --git a/packages/tko.utils/src/dom/data.ts b/packages/tko.utils/src/dom/data.ts
index d7f1215a..7eb022e9 100644
--- a/packages/tko.utils/src/dom/data.ts
+++ b/packages/tko.utils/src/dom/data.ts
@@ -1,13 +1,13 @@
 //
 // DOM node data
 //
-import { ieVersion } from '../ie'
+import { ieVersion } from '../ie';
 
-const datastoreTime = new Date().getTime()
-const dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`
-const dataStoreSymbol = Symbol('Knockout data')
-var dataStore
-let uniqueId = 0
+const datastoreTime = new Date().getTime();
+const dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`;
+const dataStoreSymbol = Symbol('Knockout data');
+const dataStore: any = {};
+let uniqueId = 0;
 
 /*
  * We considered using WeakMap, but it has a problem in IE 11 and Edge that
@@ -15,70 +15,74 @@ let uniqueId = 0
  * on the node. See https://github.com/knockout/knockout/issues/2141
  */
 const modern = {
-  getDataForNode (node, createIfNotFound) {
-    let dataForNode = node[dataStoreSymbol]
+  getDataForNode(node: any, createIfNotFound?: boolean): any {
+    let dataForNode = node[dataStoreSymbol];
     if (!dataForNode && createIfNotFound) {
-      dataForNode = node[dataStoreSymbol] = {}
+      dataForNode = node[dataStoreSymbol] = {};
     }
-    return dataForNode
+    return dataForNode;
   },
 
-  clear (node) {
-    if (node[dataStoreSymbol]) {
-      delete node[dataStoreSymbol]
-      return true
+  clear(node: Node) {
+    const internalNode = node as any;
+    if (internalNode[dataStoreSymbol]) {
+      delete internalNode[dataStoreSymbol];
+      return true;
     }
-    return false
+    return false;
   }
-}
+};
 
 /**
  * Old IE versions have memory issues if you store objects on the node, so we
  * use a separate data storage and link to it from the node using a string key.
  */
 const IE = {
-  getDataforNode (node, createIfNotFound) {
-    let dataStoreKey = node[dataStoreKeyExpandoPropertyName]
-    const hasExistingDataStore = dataStoreKey && (dataStoreKey !== 'null') && dataStore[dataStoreKey]
+  getDataForNode(node: any, createIfNotFound?: boolean): any {
+    let dataStoreKey = node[dataStoreKeyExpandoPropertyName];
+    const hasExistingDataStore = dataStoreKey && (dataStoreKey !== 'null') && dataStore[dataStoreKey];
     if (!hasExistingDataStore) {
       if (!createIfNotFound) {
-        return undefined
+        return undefined;
       }
-      dataStoreKey = node[dataStoreKeyExpandoPropertyName] = 'ko' + uniqueId++
-      dataStore[dataStoreKey] = {}
+      dataStoreKey = node[dataStoreKeyExpandoPropertyName] = 'ko' + uniqueId++;
+      dataStore[dataStoreKey] = {};
     }
-    return dataStore[dataStoreKey]
+    return dataStore[dataStoreKey];
   },
 
-  clear (node) {
-    const dataStoreKey = node[dataStoreKeyExpandoPropertyName]
+  clear(node: Node) {
+    const internalNode = node as any;
+    const dataStoreKey = internalNode[dataStoreKeyExpandoPropertyName];
     if (dataStoreKey) {
-      delete dataStore[dataStoreKey]
-      node[dataStoreKeyExpandoPropertyName] = null
-      return true // Exposing 'did clean' flag purely so specs can infer whether things have been cleaned up as intended
+      delete dataStore[dataStoreKey];
+      internalNode[dataStoreKeyExpandoPropertyName] = null;
+      return true; // Exposing 'did clean' flag purely so specs can infer whether things have been cleaned up as intended
     }
-    return false
+    return false;
   }
-}
+};
 
-const {getDataForNode, clear} = ieVersion ? IE : modern
+const {getDataForNode, clear} = ieVersion ? IE : modern;
 
 /**
  * Create a unique key-string identifier.
  */
-export function nextKey () {
-  return (uniqueId++) + dataStoreKeyExpandoPropertyName
+export function nextKey() {
+  return (uniqueId++) + dataStoreKeyExpandoPropertyName;
 }
 
-function get (node, key) {
-  const dataForNode = getDataForNode(node, false)
-  return dataForNode && dataForNode[key]
+function get<T= any>(node: Node, key: string) {
+  const dataForNode = getDataForNode(node, false);
+  return dataForNode && dataForNode[key];
 }
 
-function set (node, key, value) {
+function set<T= any>(node: Node, key: string, value?: T) {
   // Make sure we don't actually create a new domData key if we are actually deleting a value
-  var dataForNode = getDataForNode(node, value !== undefined /* createIfNotFound */)
-  dataForNode && (dataForNode[key] = value)
+  const dataForNode = getDataForNode(node, value !== undefined /* createIfNotFound */);
+  if (dataForNode) {
+    dataForNode[key] = value;
+  }
 }
 
-export { get, set, clear }
+export { get, set, clear };
diff --git a/packages/tko.utils/src/dom/disposal.ts b/packages/tko.utils/src/dom/disposal.ts
index 96b80ed7..a65a4b00 100644
--- a/packages/tko.utils/src/dom/disposal.ts
+++ b/packages/tko.utils/src/dom/disposal.ts
@@ -2,116 +2,132 @@
 // DOM node disposal
 //
 /* eslint no-cond-assign: 0 */
-import * as domData from './data.js'
-import {arrayRemoveItem} from '../array.js'
-import {jQueryInstance} from '../jquery.js'
+import * as domData from './data';
+import {arrayRemoveItem} from '../array';
+import {jQueryInstance} from '../jquery';
+
+const domDataKey = domData.nextKey();
 
-var domDataKey = domData.nextKey()
 // Node types:
 // 1: Element
 // 8: Comment
 // 9: Document
-var cleanableNodeTypes = { 1: true, 8: true, 9: true }
-var cleanableNodeTypesWithDescendants = { 1: true, 9: true }
+const cleanableNodeTypes: {[nodeType: number]: boolean|undefined} = { 1: true, 8: true, 9: true };
+const cleanableNodeTypesWithDescendants: {[nodeType: number]: boolean|undefined} = { 1: true, 9: true };
 
-function getDisposeCallbacksCollection (node, createIfNotFound) {
-  var allDisposeCallbacks = domData.get(node, domDataKey)
+function getDisposeCallbacksCollection(node: Node, createIfNotFound?: boolean) {
+  let allDisposeCallbacks = domData.get(node, domDataKey);
   if ((allDisposeCallbacks === undefined) && createIfNotFound) {
-    allDisposeCallbacks = []
-    domData.set(node, domDataKey, allDisposeCallbacks)
+    allDisposeCallbacks = [];
+    domData.set(node, domDataKey, allDisposeCallbacks);
   }
-  return allDisposeCallbacks
+  return allDisposeCallbacks;
 }
-function destroyCallbacksCollection (node) {
-  domData.set(node, domDataKey, undefined)
+
+function destroyCallbacksCollection(node: Node) {
+  domData.set(node, domDataKey, undefined);
 }
 
-function cleanSingleNode (node) {
-    // Run all the dispose callbacks
-  var callbacks = getDisposeCallbacksCollection(node, false)
+// Expose supplemental node cleaning functions.
+export type NodeCleanerCallback = (node: Node) => void;
+export const otherNodeCleanerFunctions: NodeCleanerCallback[] = [];
+
+function cleanSingleNode(node: Node) {
+  // Run all the dispose callbacks
+  let callbacks = getDisposeCallbacksCollection(node, false);
   if (callbacks) {
-    callbacks = callbacks.slice(0) // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)
-    for (let i = 0; i < callbacks.length; i++) { callbacks[i](node) }
+    callbacks = callbacks.slice(0); // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)
+    for (const cb of callbacks) {
+      callbacks(node);
+    }
   }
 
     // Erase the DOM data
-  domData.clear(node)
+  domData.clear(node);
 
     // Perform cleanup needed by external libraries (currently only jQuery, but can be extended)
   for (let i = 0, j = otherNodeCleanerFunctions.length; i < j; ++i) {
-    otherNodeCleanerFunctions[i](node)
+   otherNodeCleanerFunctions[i](node);
   }
 
     // Clear any immediate-child comment nodes, as these wouldn't have been found by
     // node.getElementsByTagName('*') in cleanNode() (comment nodes aren't elements)
-  if (cleanableNodeTypesWithDescendants[node.nodeType]) { cleanImmediateCommentTypeChildren(node) }
+  if (cleanableNodeTypesWithDescendants[node.nodeType]) { cleanImmediateCommentTypeChildren(node); }
 }
 
-function cleanImmediateCommentTypeChildren (nodeWithChildren) {
-  const children = nodeWithChildren.childNodes
-  let cleanedNode
+function cleanImmediateCommentTypeChildren(nodeWithChildren: Node) {
+  const children = nodeWithChildren.childNodes;
+  let cleanedNode: Node;
+
+  // tslint:disable-next-line:prefer-for-of
   for (let i = 0; i < children.length; ++i) {
     if (children[i].nodeType === 8) {
-      cleanSingleNode(cleanedNode = children[i])
+      cleanSingleNode(cleanedNode = children[i]);
       if (children[i] !== cleanedNode) {
-        throw Error('ko.cleanNode: An already cleaned node was removed from the document')
+        throw Error('ko.cleanNode: An already cleaned node was removed from the document');
       }
     }
   }
 }
 
 // Exports
-export function addDisposeCallback (node, callback) {
-  if (typeof callback !== 'function') { throw new Error('Callback must be a function') }
-  getDisposeCallbacksCollection(node, true).push(callback)
+export type DisposeCallback = () => void;
+
+export function addDisposeCallback(node: Node, callback: DisposeCallback) {
+  if (typeof callback !== 'function') { throw new Error('Callback must be a function'); }
+  getDisposeCallbacksCollection(node, true).push(callback);
 }
 
-export function removeDisposeCallback (node, callback) {
-  var callbacksCollection = getDisposeCallbacksCollection(node, false)
+export function removeDisposeCallback(node: Node, callback: DisposeCallback) {
+  const callbacksCollection = getDisposeCallbacksCollection(node, false);
   if (callbacksCollection) {
-    arrayRemoveItem(callbacksCollection, callback)
-    if (callbacksCollection.length === 0) { destroyCallbacksCollection(node) }
+    arrayRemoveItem(callbacksCollection, callback);
+    if (callbacksCollection.length === 0) { destroyCallbacksCollection(node); }
   }
 }
 
-export function cleanNode (node) {
+function isCleanableNodeWithDescendants(node: Node): node is Element {
+  return cleanableNodeTypesWithDescendants[node.nodeType] === true;
+}
+
+export function cleanNode(node: Node) {
     // First clean this node, where applicable
   if (cleanableNodeTypes[node.nodeType]) {
-    cleanSingleNode(node)
+    cleanSingleNode(node);
 
         // ... then its descendants, where applicable
-    if (cleanableNodeTypesWithDescendants[node.nodeType]) {
-      const descendants = node.getElementsByTagName('*')
+    if (isCleanableNodeWithDescendants(node)) {
+      const descendants = node.getElementsByTagName('*');
+
+      // tslint:disable-next-line:prefer-for-of
       for (let i = 0; i < descendants.length; ++i) {
-        let cleanedNode = descendants[i]
-        cleanSingleNode(cleanedNode)
+        const cleanedNode = descendants[i];
+        cleanSingleNode(cleanedNode);
         if (descendants[i] !== cleanedNode) {
-          throw Error('ko.cleanNode: An already cleaned node was removed from the document')
+          throw Error('ko.cleanNode: An already cleaned node was removed from the document');
         }
       }
     }
   }
-  return node
+  return node;
 }
 
-export function removeNode (node) {
-  cleanNode(node)
-  if (node.parentNode) { node.parentNode.removeChild(node) }
+export function removeNode(node: Node) {
+  cleanNode(node);
+  if (node.parentNode) { node.parentNode.removeChild(node); }
 }
 
-// Expose supplemental node cleaning functions.
-export var otherNodeCleanerFunctions = []
-
 // Special support for jQuery here because it's so commonly used.
 // Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData
 // so notify it to tear down any resources associated with the node & descendants here.
-export function cleanjQueryData (node) {
-  var jQueryCleanNodeFn = jQueryInstance
-        ? jQueryInstance.cleanData : null
+export function cleanjQueryData(node: Node) {
+  // Note: cleanData is an internal jQuery function
+  const jQueryCleanNodeFn = jQueryInstance
+        ? (jQueryInstance as any).cleanData : null;
 
   if (jQueryCleanNodeFn) {
-    jQueryCleanNodeFn([node])
+    jQueryCleanNodeFn([node]);
   }
 }
 
-otherNodeCleanerFunctions.push(cleanjQueryData)
+otherNodeCleanerFunctions.push(cleanjQueryData);
diff --git a/packages/tko.utils/src/dom/event.ts b/packages/tko.utils/src/dom/event.ts
index ccc08444..0d660951 100644
--- a/packages/tko.utils/src/dom/event.ts
+++ b/packages/tko.utils/src/dom/event.ts
@@ -2,94 +2,100 @@
 // DOM Events
 //
 
-import { objectForEach } from '../object.js'
-import { jQueryInstance } from '../jquery.js'
-import { ieVersion } from '../ie.js'
-import { catchFunctionErrors } from '../error.js'
+import { objectForEach } from '../object';
+import { jQueryInstance } from '../jquery';
+import { ieVersion } from '../ie';
+import { catchFunctionErrors } from '../error';
 
-import { tagNameLower } from './info.js'
-import { addDisposeCallback } from './disposal.js'
-import options from '../options.js'
+import { tagNameLower } from './info';
+import { addDisposeCallback } from './disposal';
+import options from '../options';
 
 // Represent the known event types in a compact way, then at runtime transform it into a hash with event name as key (for fast lookup)
-var knownEvents = {},
-  knownEventTypesByEventName = {}
+const knownEvents: {[evType: string]: string[]} = {},
+  knownEventTypesByEventName: {[evType: string]: string} = {};
 
-var keyEventTypeName = (options.global.navigator && /Firefox\/2/i.test(options.global.navigator.userAgent)) ? 'KeyboardEvent' : 'UIEvents'
+const keyEventTypeName = (options.global.navigator && /Firefox\/2/i.test(options.global.navigator.userAgent)) ? 'KeyboardEvent' : 'UIEvents';
 
-knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress']
+knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress'];
 
-knownEvents['MouseEvents'] = [
+knownEvents.MouseEvents = [
   'click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover',
-  'mouseout', 'mouseenter', 'mouseleave']
+  'mouseout', 'mouseenter', 'mouseleave'];
 
-objectForEach(knownEvents, function (eventType, knownEventsForType) {
+objectForEach(knownEvents, (eventType, knownEventsForType) => {
   if (knownEventsForType.length) {
-    for (var i = 0, j = knownEventsForType.length; i < j; i++) { knownEventTypesByEventName[knownEventsForType[i]] = eventType }
+    for (let i = 0, j = knownEventsForType.length; i < j; i++) { knownEventTypesByEventName[knownEventsForType[i]] = eventType; }
   }
-})
+});
 
-function isClickOnCheckableElement (element, eventType) {
-  if ((tagNameLower(element) !== 'input') || !element.type) return false
-  if (eventType.toLowerCase() != 'click') return false
-  var inputType = element.type
-  return (inputType == 'checkbox') || (inputType == 'radio')
+function isClickOnCheckableElement(element: HTMLElement, eventType: string) {
+  if ((tagNameLower(element) !== 'input') || !(element as HTMLInputElement).type) {
+    return false;
+  }
+
+  if (eventType.toLowerCase() !== 'click') {
+    return false;
+  }
+
+  const inputType = (element as HTMLInputElement).type;
+  return (inputType === 'checkbox') || (inputType === 'radio');
 }
 
 // Workaround for an IE9 issue - https://github.com/SteveSanderson/knockout/issues/406
-var eventsThatMustBeRegisteredUsingAttachEvent = { 'propertychange': true }
-let jQueryEventAttachName
+const eventsThatMustBeRegisteredUsingAttachEvent: {[type: string]: boolean} = { propertychange: true };
+let jQueryEventAttachName: any;
 
-export function registerEventHandler (element, eventType, handler, eventOptions = false) {
-  const wrappedHandler = catchFunctionErrors(handler)
-  const mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType]
-  const mustUseNative = Boolean(eventOptions)
+export function registerEventHandler(element: HTMLElement, eventType: string, handler: EventListener, eventOptions = false) {
+  const wrappedHandler = catchFunctionErrors(handler);
+  const mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];
+  const mustUseNative = Boolean(eventOptions);
 
   if (!options.useOnlyNativeEvents && !mustUseAttachEvent && !mustUseNative && jQueryInstance) {
     if (!jQueryEventAttachName) {
-      jQueryEventAttachName = (typeof jQueryInstance(element).on === 'function') ? 'on' : 'bind'
+      jQueryEventAttachName = (typeof jQueryInstance(element).on === 'function') ? 'on' : 'bind';
     }
-    jQueryInstance(element)[jQueryEventAttachName](eventType, wrappedHandler)
+    (jQueryInstance(element) as any)[jQueryEventAttachName](eventType, wrappedHandler);
   } else if (!mustUseAttachEvent && typeof element.addEventListener === 'function') {
-    element.addEventListener(eventType, wrappedHandler, eventOptions)
-  } else if (typeof element.attachEvent !== 'undefined') {
-    const attachEventHandler = function (event) { wrappedHandler.call(element, event) }
-    const attachEventName = 'on' + eventType
-    element.attachEvent(attachEventName, attachEventHandler)
+    element.addEventListener(eventType, wrappedHandler, eventOptions);
+  } else if (typeof (element as any).attachEvent !== 'undefined') {
+    const attachEventHandler = (event: any) => wrappedHandler.call(element, event);
+    const attachEventName = 'on' + eventType;
+    (element as any).attachEvent(attachEventName, attachEventHandler);
 
     // IE does not dispose attachEvent handlers automatically (unlike with addEventListener)
     // so to avoid leaks, we have to remove them manually. See bug #856
-    addDisposeCallback(element, function () {
-      element.detachEvent(attachEventName, attachEventHandler)
-    })
+    addDisposeCallback(element, () => {
+      (element as any).detachEvent(attachEventName, attachEventHandler);
+    });
   } else {
-    throw new Error("Browser doesn't support addEventListener or attachEvent")
+    throw new Error("Browser doesn't support addEventListener or attachEvent");
   }
 }
 
-export function triggerEvent (element, eventType) {
-  if (!(element && element.nodeType)) { throw new Error('element must be a DOM node when calling triggerEvent') }
+export function triggerEvent(element: HTMLElement, eventType: string) {
+  if (!(element && element.nodeType)) { throw new Error('element must be a DOM node when calling triggerEvent'); }
 
     // For click events on checkboxes and radio buttons, jQuery toggles the element checked state *after* the
     // event handler runs instead of *before*. (This was fixed in 1.9 for checkboxes but not for radio buttons.)
     // IE doesn't change the checked state when you trigger the click event using "fireEvent".
     // In both cases, we'll use the click method instead.
-  var useClickWorkaround = isClickOnCheckableElement(element, eventType)
+  const useClickWorkaround = isClickOnCheckableElement(element, eventType);
 
   if (!options.useOnlyNativeEvents && jQueryInstance && !useClickWorkaround) {
-    jQueryInstance(element).trigger(eventType)
+    jQueryInstance(element).trigger(eventType);
   } else if (typeof document.createEvent === 'function') {
     if (typeof element.dispatchEvent === 'function') {
-      var eventCategory = knownEventTypesByEventName[eventType] || 'HTMLEvents'
-      var event = document.createEvent(eventCategory)
-      event.initEvent(eventType, true, true, options.global, 0, 0, 0, 0, 0, false, false, false, false, 0, element)
-      element.dispatchEvent(event)
-    } else { throw new Error("The supplied element doesn't support dispatchEvent") }
+      const eventCategory = knownEventTypesByEventName[eventType] || 'HTMLEvents';
+      const event = document.createEvent(eventCategory);
+      (event as any).initEvent(eventType, true, true, options.global, 0, 0, 0, 0, 0, false, false, false, false, 0, element);
+      element.dispatchEvent(event);
+    } else { throw new Error("The supplied element doesn't support dispatchEvent"); }
   } else if (useClickWorkaround && element.click) {
-    element.click()
-  } else if (typeof element.fireEvent !== 'undefined') {
-    element.fireEvent('on' + eventType)
+    element.click();
+  } else if (typeof (element as any).fireEvent !== 'undefined') {
+    (element as any).fireEvent('on' + eventType);
   } else {
-    throw new Error("Browser doesn't support triggering events")
+    throw new Error("Browser doesn't support triggering events");
   }
 }
diff --git a/packages/tko.utils/src/dom/fixes.ts b/packages/tko.utils/src/dom/fixes.ts
index e99b7903..0db13c7e 100644
--- a/packages/tko.utils/src/dom/fixes.ts
+++ b/packages/tko.utils/src/dom/fixes.ts
@@ -1,9 +1,9 @@
 //
 //  DOM node manipulation
 //
-import { ieVersion } from '../ie.js'
+import { ieVersion } from '../ie';
 
-export function fixUpContinuousNodeArray (continuousNodeArray, parentNode) {
+export function fixUpContinuousNodeArray(continuousNodeArray: Node[], parentNode: Node) {
     // Before acting on a set of nodes that were previously outputted by a template function, we have to reconcile
     // them against what is in the DOM right now. It may be that some of the nodes have already been removed, or that
     // new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been
@@ -22,50 +22,51 @@ export function fixUpContinuousNodeArray (continuousNodeArray, parentNode) {
 
   if (continuousNodeArray.length) {
         // The parent node can be a virtual element; so get the real parent node
-    parentNode = (parentNode.nodeType === 8 && parentNode.parentNode) || parentNode
+    parentNode = (parentNode.nodeType === 8 && parentNode.parentNode) || parentNode;
 
         // Rule [A]
-    while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode) { continuousNodeArray.splice(0, 1) }
+    while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode) { continuousNodeArray.splice(0, 1); }
 
         // Rule [B]
-    while (continuousNodeArray.length > 1 && continuousNodeArray[continuousNodeArray.length - 1].parentNode !== parentNode) { continuousNodeArray.length-- }
+    while (continuousNodeArray.length > 1 && continuousNodeArray[continuousNodeArray.length - 1].parentNode !== parentNode) { continuousNodeArray.length--; }
 
         // Rule [C]
     if (continuousNodeArray.length > 1) {
-      var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1]
+      let current: Node|null = continuousNodeArray[0];
+      const last = continuousNodeArray[continuousNodeArray.length - 1];
             // Replace with the actual new continuous node set
-      continuousNodeArray.length = 0
-      while (current !== last) {
-        continuousNodeArray.push(current)
-        current = current.nextSibling
+      continuousNodeArray.length = 0;
+      while (current !== last && current) {
+        continuousNodeArray.push(current);
+        current = current.nextSibling;
       }
-      continuousNodeArray.push(last)
+      continuousNodeArray.push(last);
     }
   }
-  return continuousNodeArray
+  return continuousNodeArray;
 }
 
-export function setOptionNodeSelectionState (optionNode, isSelected) {
+export function setOptionNodeSelectionState(optionNode: HTMLOptionElement, isSelected: boolean) {
     // IE6 sometimes throws "unknown error" if you try to write to .selected directly, whereas Firefox struggles with setAttribute. Pick one based on browser.
-  if (ieVersion < 7) { optionNode.setAttribute('selected', isSelected) } else { optionNode.selected = isSelected }
+  if (ieVersion && ieVersion < 7) { optionNode.setAttribute('selected', isSelected.toString()); } else { optionNode.selected = isSelected; }
 }
 
-export function forceRefresh (node) {
+export function forceRefresh(node: Node) {
     // Workaround for an IE9 rendering bug - https://github.com/SteveSanderson/knockout/issues/209
-  if (ieVersion >= 9) {
+  if (ieVersion && ieVersion >= 9) {
         // For text nodes and comment nodes (most likely virtual elements), we will have to refresh the container
-    var elem = node.nodeType == 1 ? node : node.parentNode
-    if (elem.style) { elem.style.zoom = elem.style.zoom }
+    const elem = (node.nodeType === 1 ? node : node.parentNode) as HTMLElement;
+    if (elem && elem.style) { elem.style.zoom = elem.style.zoom; }
   }
 }
 
-export function ensureSelectElementIsRenderedCorrectly (selectElement) {
+export function ensureSelectElementIsRenderedCorrectly(selectElement: HTMLSelectElement) {
     // Workaround for IE9 rendering bug - it doesn't reliably display all the text in dynamically-added select boxes unless you force it to re-render by updating the width.
     // (See https://github.com/SteveSanderson/knockout/issues/312, http://stackoverflow.com/questions/5908494/select-only-shows-first-char-of-selected-option)
     // Also fixes IE7 and IE8 bug that causes selects to be zero width if enclosed by 'if' or 'with'. (See issue #839)
   if (ieVersion) {
-    var originalWidth = selectElement.style.width
-    selectElement.style.width = 0
-    selectElement.style.width = originalWidth
+    const originalWidth = selectElement.style.width;
+    selectElement.style.width = '0';
+    selectElement.style.width = originalWidth;
   }
 }
diff --git a/packages/tko.utils/src/dom/html.ts b/packages/tko.utils/src/dom/html.ts
index 09bade62..2bef2aa9 100644
--- a/packages/tko.utils/src/dom/html.ts
+++ b/packages/tko.utils/src/dom/html.ts
@@ -1,50 +1,54 @@
 //
 // HTML-based manipulation
 //
-import { stringTrim } from '../string.js'
-import { makeArray } from '../array.js'
-import { emptyDomNode, moveCleanedNodesToContainerElement } from './manipulation.js'
-import { jQueryInstance } from '../jquery.js'
-import * as virtualElements from './virtualElements'
-import options from '../options'
-
-var none = [0, '', ''],
-  table = [1, '<table>', '</table>'],
-  tbody = [2, '<table><tbody>', '</tbody></table>'],
-  colgroup = [ 2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
-  tr = [3, '<table><tbody><tr>', '</tr></tbody></table>'],
-  select = [1, "<select multiple='multiple'>", '</select>'],
-  fieldset = [1, '<fieldset>', '</fieldset>'],
-  map = [1, '<map>', '</map>'],
-  object = [1, '<object>', '</object>'],
-  lookup = {
-    'area': map,
-    'col': colgroup,
-    'colgroup': table,
-    'caption': table,
-    'legend': fieldset,
-    'thead': table,
-    'tbody': table,
-    'tfoot': table,
-    'tr': tbody,
-    'td': tr,
-    'th': tr,
-    'option': select,
-    'optgroup': select,
-    'param': object
+import { stringTrim } from '../string';
+import { makeArray } from '../array';
+import { emptyDomNode, moveCleanedNodesToContainerElement } from './manipulation';
+import { jQueryInstance } from '../jquery';
+import * as virtualElements from './virtualElements';
+import options from '../options';
+
+type TagMap = [number, string, string];
+const none: TagMap = [0, '', ''],
+  table: TagMap = [1, '<table>', '</table>'],
+  tbody: TagMap = [2, '<table><tbody>', '</tbody></table>'],
+  colgroup: TagMap = [ 2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
+  tr: TagMap = [3, '<table><tbody><tr>', '</tr></tbody></table>'],
+  select: TagMap = [1, "<select multiple='multiple'>", '</select>'],
+  fieldset: TagMap = [1, '<fieldset>', '</fieldset>'],
+  map: TagMap = [1, '<map>', '</map>'],
+  object: TagMap = [1, '<object>', '</object>'],
+  lookup: {[tag: string]: TagMap} = {
+    area: map,
+    col: colgroup,
+    colgroup: table,
+    caption: table,
+    legend: fieldset,
+    thead: table,
+    tbody: table,
+    tfoot: table,
+    tr: tbody,
+    td: tr,
+    th: tr,
+    option: select,
+    optgroup: select,
+    param: object
   },
 
     // The canonical way to test that the HTML5 <template> tag is supported
-  supportsTemplateTag = options.document && 'content' in options.document.createElement('template')
+  supportsTemplateTag = options.document && 'content' in options.document.createElement('template');
 
-function getWrap (tags) {
-  var m = tags.match(/^<([a-z]+)[ >]/)
-  return (m && lookup[m[1]]) || none
+function getWrap(tags: string) {
+  const m = tags.match(/^<([a-z]+)[ >]/);
+  return (m && lookup[m[1]]) || none;
 }
 
-function simpleHtmlParse (html, documentContext) {
-  documentContext || (documentContext = document)
-  var windowContext = documentContext['parentWindow'] || documentContext['defaultView'] || window
+function simpleHtmlParse(html: string, documentContext: any) {
+  if (!documentContext) {
+    documentContext = document;
+  }
+
+  const windowContext = documentContext.parentWindow || documentContext.defaultView || window;
 
     // Based on jQuery's "clean" function, but only accounting for table-related elements.
     // If you have referenced jQuery, this won't be used anyway - KO will use jQuery's "clean" function directly
@@ -55,55 +59,54 @@ function simpleHtmlParse (html, documentContext) {
     // (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.
 
     // Trim whitespace, otherwise indexOf won't work as expected
-  var tags = stringTrim(html).toLowerCase(), div = documentContext.createElement('div'),
-    wrap = getWrap(tags),
-    depth = wrap[0]
+  const tags = stringTrim(html).toLowerCase(), wrap = getWrap(tags);
+  let div = documentContext.createElement('div'), depth = wrap[0];
 
     // Go to html and back, then peel off extra wrappers
     // Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.
-  var markup = 'ignored<div>' + wrap[1] + html + wrap[2] + '</div>'
-  if (typeof windowContext['innerShiv'] === 'function') {
+  const markup = 'ignored<div>' + wrap[1] + html + wrap[2] + '</div>';
+  if (typeof windowContext.innerShiv === 'function') {
         // Note that innerShiv is deprecated in favour of html5shiv. We should consider adding
         // support for html5shiv (except if no explicit support is needed, e.g., if html5shiv
         // somehow shims the native APIs so it just works anyway)
-    div.appendChild(windowContext['innerShiv'](markup))
+    div.appendChild(windowContext.innerShiv(markup));
   } else {
-    div.innerHTML = markup
+    div.innerHTML = markup;
   }
 
     // Move to the right depth
-  while (depth--) { div = div.lastChild }
+  while (depth--) { div = div.lastChild; }
 
-  return makeArray(div.lastChild.childNodes)
+  return makeArray(div.lastChild.childNodes);
 }
 
-function templateHtmlParse (html, documentContext) {
-  if (!documentContext) { documentContext = document }
-  var template = documentContext.createElement('template')
-  template.innerHTML = html
-  return makeArray(template.content.childNodes)
+function templateHtmlParse(html: string, documentContext: any) {
+  if (!documentContext) { documentContext = document; }
+  const template = documentContext.createElement('template');
+  template.innerHTML = html;
+  return makeArray(template.content.childNodes);
 }
 
-function jQueryHtmlParse (html, documentContext) {
+function jQueryHtmlParse(html: string, documentContext: any) {
     // jQuery's "parseHTML" function was introduced in jQuery 1.8.0 and is a documented public API.
-  if (jQueryInstance.parseHTML) {
-    return jQueryInstance.parseHTML(html, documentContext) || [] // Ensure we always return an array and never null
+  if ((jQueryInstance as any).parseHTML) {
+    return (jQueryInstance as any).parseHTML(html, documentContext) || []; // Ensure we always return an array and never null
   } else {
         // For jQuery < 1.8.0, we fall back on the undocumented internal "clean" function.
-    var elems = jQueryInstance.clean([html], documentContext)
+    const elems = (jQueryInstance as any).clean([html], documentContext);
 
         // As of jQuery 1.7.1, jQuery parses the HTML by appending it to some dummy parent nodes held in an in-memory document fragment.
         // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.
         // Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.
     if (elems && elems[0]) {
             // Find the top-most parent element that's a direct child of a document fragment
-      var elem = elems[0]
-      while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */) { elem = elem.parentNode }
+      let elem = elems[0];
+      while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */) { elem = elem.parentNode; }
             // ... then detach it
-      if (elem.parentNode) { elem.parentNode.removeChild(elem) }
+      if (elem.parentNode) { elem.parentNode.removeChild(elem); }
     }
 
-    return elems
+    return elems;
   }
 }
 
@@ -117,7 +120,7 @@ function jQueryHtmlParse (html, documentContext) {
  * @param  {Object} documentContext That owns the executing code.
  * @return {[DOMNode]}              Parsed DOM Nodes
  */
-export function parseHtmlFragment (html, documentContext) {
+export function parseHtmlFragment(html: string, documentContext: any) {
     // Prefer <template>-tag based HTML parsing.
   return supportsTemplateTag ? templateHtmlParse(html, documentContext)
 
@@ -127,15 +130,17 @@ export function parseHtmlFragment (html, documentContext) {
         : (jQueryInstance ? jQueryHtmlParse(html, documentContext)
 
         // ... otherwise, this simple logic will do in most common cases.
-        : simpleHtmlParse(html, documentContext))
+        : simpleHtmlParse(html, documentContext));
 }
 
-export function parseHtmlForTemplateNodes (html, documentContext) {
-  const nodes = parseHtmlFragment(html, documentContext)
-  return (nodes.length && nodes[0].parentElement) || moveCleanedNodesToContainerElement(nodes)
+export function parseHtmlForTemplateNodes(html: string, documentContext: any) {
+  const nodes = parseHtmlFragment(html, documentContext);
+  return (nodes.length && nodes[0].parentElement) || moveCleanedNodesToContainerElement(nodes);
 }
 
-/**
+type StringGetter = () => string;
+
+ /**
   * setHtml empties the node's contents, unwraps the HTML, and
   * sets the node's HTML using jQuery.html or parseHtmlFragment
   *
@@ -143,17 +148,17 @@ export function parseHtmlForTemplateNodes (html, documentContext) {
   * @param {DOMNode} html HTML to be inserted in node
   * @returns undefined
   */
-export function setHtml (node, html) {
-  emptyDomNode(node)
+export function setHtml(node: Node, html: string|StringGetter|any) {
+  emptyDomNode(node);
 
     // There's few cases where we would want to display a stringified
     // function, so we unwrap it.
   if (typeof html === 'function') {
-    html = html()
+    html = html();
   }
 
   if ((html !== null) && (html !== undefined)) {
-    if (typeof html !== 'string') { html = html.toString() }
+    if (typeof html !== 'string') { html = html.toString(); }
 
         // If the browser supports <template> tags, prefer that, as
         // it obviates all the complex workarounds of jQuery.
@@ -162,19 +167,19 @@ export function setHtml (node, html) {
         // for example <tr> elements which are not normally allowed to exist on their own.
         // If you've referenced jQuery (and template tags are not supported) we'll use that rather than duplicating its code.
     if (jQueryInstance && !supportsTemplateTag) {
-      jQueryInstance(node).html(html)
+      jQueryInstance(node).html(html);
     } else {
             // ... otherwise, use KO's own parsing logic.
-      var parsedNodes = parseHtmlFragment(html, node.ownerDocument)
+      const parsedNodes = parseHtmlFragment(html, node.ownerDocument);
 
       if (node.nodeType === 8) {
         if (html === null) {
-          virtualElements.emptyNode(node)
+          virtualElements.emptyNode(node);
         } else {
-          virtualElements.setDomNodeChildren(node, parsedNodes)
+          virtualElements.setDomNodeChildren(node, parsedNodes);
         }
       } else {
-        for (var i = 0; i < parsedNodes.length; i++) { node.appendChild(parsedNodes[i]) }
+        for (const parsedNode of parsedNodes) { node.appendChild(parsedNodes); }
       }
     }
   }
diff --git a/packages/tko.utils/src/dom/info.ts b/packages/tko.utils/src/dom/info.ts
index a98c444e..8e7cea36 100644
--- a/packages/tko.utils/src/dom/info.ts
+++ b/packages/tko.utils/src/dom/info.ts
@@ -1,46 +1,55 @@
 //
 // Information about the DOM
 //
-import { arrayFirst } from '../array.js'
-
-export function domNodeIsContainedBy (node, containedByNode) {
-  if (node === containedByNode) { return true }
-  if (node.nodeType === 11) { return false } // Fixes issue #1162 - can't use node.contains for document fragments on IE8
-  if (containedByNode.contains) { return containedByNode.contains(node.nodeType !== 1 ? node.parentNode : node) }
-  if (containedByNode.compareDocumentPosition) { return (containedByNode.compareDocumentPosition(node) & 16) == 16 }
-  while (node && node != containedByNode) {
-    node = node.parentNode
+import { arrayFirst } from '../array';
+
+export function domNodeIsContainedBy(node: Node, containedByNode: Node) {
+  if (node === containedByNode) { return true; }
+  if (node.nodeType === 11) { return false; } // Fixes issue #1162 - can't use node.contains for document fragments on IE8
+  if (containedByNode.contains) {
+    const childNode = node.nodeType !== 1 ? node.parentNode : node;
+    return childNode && containedByNode.contains(childNode) || false;
+  }
+
+  if (containedByNode.compareDocumentPosition) {
+    // tslint:disable-next-line:no-bitwise
+    return (containedByNode.compareDocumentPosition(node) & 16) === 16;
+  }
+
+  let parentNode: Node|null = node;
+  while (parentNode && parentNode !== containedByNode) {
+    parentNode = parentNode.parentNode;
   }
-  return !!node
+  return !!parentNode;
 }
 
-export function domNodeIsAttachedToDocument (node) {
-  return domNodeIsContainedBy(node, node.ownerDocument.documentElement)
+export function domNodeIsAttachedToDocument(node: Node) {
+  return domNodeIsContainedBy(node, node.ownerDocument.documentElement);
 }
 
-export function anyDomNodeIsAttachedToDocument (nodes) {
-  return !!arrayFirst(nodes, domNodeIsAttachedToDocument)
+export function anyDomNodeIsAttachedToDocument(nodes: Node[]) {
+  return !!arrayFirst(nodes, domNodeIsAttachedToDocument);
 }
 
-export function tagNameLower (element) {
+export function tagNameLower(element: Element) {
     // For HTML elements, tagName will always be upper case; for XHTML elements, it'll be lower case.
     // Possible future optimization: If we know it's an element from an XHTML document (not HTML),
     // we don't need to do the .toLowerCase() as it will always be lower case anyway.
-  return element && element.tagName && element.tagName.toLowerCase()
+  return element && element.tagName && element.tagName.toLowerCase();
 }
 
-export function isDomElement (obj) {
-  if (window.HTMLElement) {
-    return obj instanceof HTMLElement
+export function isDomElement(obj: any): obj is HTMLElement {
+  if ((window as any).HTMLElement) {
+    return obj instanceof HTMLElement;
   } else {
-    return obj && obj.tagName && obj.nodeType === 1
+    return obj && obj.tagName && obj.nodeType === 1;
   }
 }
 
-export function isDocumentFragment (obj) {
-  if (window.DocumentFragment) {
-    return obj instanceof DocumentFragment
+export function isDocumentFragment(obj: any): obj is DocumentFragment {
+  if ((window as any).DocumentFragment) {
+    return obj instanceof DocumentFragment;
   } else {
-    return obj && obj.nodeType === 11
+    return obj && obj.nodeType === 11;
   }
 }
diff --git a/packages/tko.utils/src/dom/manipulation.ts b/packages/tko.utils/src/dom/manipulation.ts
index b8049e2c..4e489b99 100644
--- a/packages/tko.utils/src/dom/manipulation.ts
+++ b/packages/tko.utils/src/dom/manipulation.ts
@@ -2,84 +2,90 @@
 // DOM manipulation
 //
 /* eslint no-empty: 0 */
-import { makeArray } from '../array.js'
-import { ieVersion } from '../ie.js'
-import { cleanNode, removeNode } from './disposal.js'
-import { forceRefresh } from './fixes.js'
-import * as virtualElements from './virtualElements.js'
+const {isArray} = Array;
 
-export function moveCleanedNodesToContainerElement (nodes) {
+import { makeArray } from '../array';
+import { ieVersion } from '../ie';
+import { cleanNode, removeNode } from './disposal';
+import { forceRefresh } from './fixes';
+import * as virtualElements from './virtualElements';
+
+export function moveCleanedNodesToContainerElement(nodes: ArrayLike<Node>) {
     // Ensure it's a real array, as we're about to reparent the nodes and
     // we don't want the underlying collection to change while we're doing that.
-  var nodesArray = makeArray(nodes)
-  var templateDocument = (nodesArray[0] && nodesArray[0].ownerDocument) || document
+  const nodesArray = makeArray(nodes);
+  const templateDocument = (nodesArray[0] && nodesArray[0].ownerDocument) || document;
 
-  var container = templateDocument.createElement('div')
-  for (var i = 0, j = nodesArray.length; i < j; i++) {
-    container.appendChild(cleanNode(nodesArray[i]))
+  const container = templateDocument.createElement('div');
+  for (let i = 0, j = nodesArray.length; i < j; i++) {
+    container.appendChild(cleanNode(nodesArray[i]));
   }
-  return container
+  return container;
 }
 
-export function cloneNodes (nodesArray, shouldCleanNodes) {
-  for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {
-    var clonedNode = nodesArray[i].cloneNode(true)
-    newNodesArray.push(shouldCleanNodes ? cleanNode(clonedNode) : clonedNode)
+export function cloneNodes(nodesArray: ArrayLike<Node>, shouldCleanNodes?: boolean) {
+  const newNodesArray = [];
+
+  for (let i = 0, j = nodesArray.length; i < j; i++) {
+    const clonedNode = nodesArray[i].cloneNode(true);
+    newNodesArray.push(shouldCleanNodes ? cleanNode(clonedNode) : clonedNode);
   }
-  return newNodesArray
+
+  return newNodesArray;
 }
 
-export function setDomNodeChildren (domNode, childNodes) {
-  emptyDomNode(domNode)
+export function setDomNodeChildren(domNode: Node, childNodes: ArrayLike<Node>) {
+  emptyDomNode(domNode);
   if (childNodes) {
-    for (var i = 0, j = childNodes.length; i < j; i++) { domNode.appendChild(childNodes[i]) }
+    for (let i = 0, j = childNodes.length; i < j; i++) { domNode.appendChild(childNodes[i]); }
   }
 }
 
-export function replaceDomNodes (nodeToReplaceOrNodeArray, newNodesArray) {
-  var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray
+export function replaceDomNodes(nodeToReplaceOrNodeArray: Node[]|Node, newNodesArray: Node[]) {
+  const nodesToReplaceArray = !isArray(nodeToReplaceOrNodeArray) ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;
   if (nodesToReplaceArray.length > 0) {
-    var insertionPoint = nodesToReplaceArray[0]
-    var parent = insertionPoint.parentNode
-    for (var i = 0, j = newNodesArray.length; i < j; i++) { parent.insertBefore(newNodesArray[i], insertionPoint) }
-    for (i = 0, j = nodesToReplaceArray.length; i < j; i++) {
-      removeNode(nodesToReplaceArray[i])
+    const insertionPoint = nodesToReplaceArray[0];
+    const parent = insertionPoint.parentNode;
+    for (let i = 0, j = newNodesArray.length; i < j; i++) { parent!.insertBefore(newNodesArray[i], insertionPoint); }
+    for (let i = 0, j = nodesToReplaceArray.length; i < j; i++) {
+      removeNode(nodesToReplaceArray[i]);
     }
   }
 }
 
-export function setElementName (element, name) {
-  element.name = name
+export function setElementName(element: HTMLElement, name: string) {
+  (element as any).name = name;
 
     // Workaround IE 6/7 issue
     // - https://github.com/SteveSanderson/knockout/issues/197
     // - http://www.matts411.com/post/setting_the_name_attribute_in_ie_dom/
-  if (ieVersion <= 7) {
+  if (ieVersion && ieVersion <= 7) {
     try {
-      element.mergeAttributes(document.createElement("<input name='" + element.name + "'/>"), false)
+      (element as any).mergeAttributes(document.createElement("<input name='" + (element as any).name + "'/>"), false);
     } catch (e) {} // For IE9 with doc mode "IE9 Standards" and browser mode "IE9 Compatibility View"
   }
 }
 
-export function setTextContent (element, textContent) {
-  var value = typeof textContent === 'function' ? textContent() : textContent
-  if ((value === null) || (value === undefined)) { value = '' }
+type StringFunction = () => string;
+export function setTextContent(element: HTMLElement, textContent: string|StringFunction) {
+  let value = typeof textContent === 'function' ? textContent() : textContent;
+  if ((value === null) || (value === undefined)) { value = ''; }
 
     // We need there to be exactly one child: a text node.
     // If there are no children, more than one, or if it's not a text node,
     // we'll clear everything and create a single text node.
-  var innerTextNode = virtualElements.firstChild(element)
-  if (!innerTextNode || innerTextNode.nodeType != 3 || virtualElements.nextSibling(innerTextNode)) {
-    virtualElements.setDomNodeChildren(element, [element.ownerDocument.createTextNode(value)])
+  const innerTextNode = virtualElements.firstChild(element);
+  if (!innerTextNode || innerTextNode.nodeType !== 3 || virtualElements.nextSibling(innerTextNode)) {
+    virtualElements.setDomNodeChildren(element, [element.ownerDocument.createTextNode(value)]);
   } else {
-    innerTextNode.data = value
+    (innerTextNode as any).data = value;
   }
 
-  forceRefresh(element)
+  forceRefresh(element);
 }
 
-export function emptyDomNode (domNode) {
+export function emptyDomNode(domNode: Node) {
   while (domNode.firstChild) {
-    removeNode(domNode.firstChild)
+    removeNode(domNode.firstChild);
   }
 }
diff --git a/packages/tko.utils/src/dom/selectExtensions.ts b/packages/tko.utils/src/dom/selectExtensions.ts
index 4d4e20de..b8fe27a1 100644
--- a/packages/tko.utils/src/dom/selectExtensions.ts
+++ b/packages/tko.utils/src/dom/selectExtensions.ts
@@ -1,77 +1,77 @@
 
-import { ieVersion } from '../ie'
-import { safeSetTimeout } from '../error'
+import { ieVersion } from '../ie';
+import { safeSetTimeout } from '../error';
 
-import { tagNameLower } from './info'
-import * as domData from './data'
+import { tagNameLower } from './info';
+import * as domData from './data';
 
-var hasDomDataExpandoProperty = Symbol('Knockout selectExtensions hasDomDataProperty')
+const hasDomDataExpandoProperty = Symbol('Knockout selectExtensions hasDomDataProperty');
 
 // Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values
 // are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values
 // that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.
 //
-export var selectExtensions = {
+export const selectExtensions = {
   optionValueDomDataKey: domData.nextKey(),
 
-  readValue: function (element) {
+  readValue(element: HTMLSelectElement|HTMLOptionElement): any {
     switch (tagNameLower(element)) {
       case 'option':
-        if (element[hasDomDataExpandoProperty] === true) { return domData.get(element, selectExtensions.optionValueDomDataKey) }
-        return element.value
+        if ((element as any)[hasDomDataExpandoProperty] === true) { return domData.get(element, selectExtensions.optionValueDomDataKey); }
+        return element.value;
       case 'select':
-        return element.selectedIndex >= 0 ? selectExtensions.readValue(element.options[element.selectedIndex]) : undefined
+        return (element as HTMLSelectElement).selectedIndex >= 0 ? selectExtensions.readValue((element as HTMLSelectElement).options[(element as HTMLSelectElement).selectedIndex]) : undefined;
       default:
-        return element.value
+        return element.value;
     }
   },
 
-  writeValue: function (element, value, allowUnset) {
+  writeValue(element: HTMLSelectElement, value: any, allowUnset: boolean) {
     switch (tagNameLower(element)) {
       case 'option':
         if (typeof value === 'string') {
-          domData.set(element, selectExtensions.optionValueDomDataKey, undefined)
+          domData.set(element, selectExtensions.optionValueDomDataKey, undefined);
           if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node
-            delete element[hasDomDataExpandoProperty]
+            delete element[hasDomDataExpandoProperty];
           }
-          element.value = value
+          element.value = value;
         } else {
                         // Store arbitrary object using DomData
-          domData.set(element, selectExtensions.optionValueDomDataKey, value)
-          element[hasDomDataExpandoProperty] = true
+          domData.set(element, selectExtensions.optionValueDomDataKey, value);
+          element[hasDomDataExpandoProperty] = true;
                         // Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.
-          element.value = typeof value === 'number' ? value : ''
+          (element as any).value = typeof value === 'number' ? value : '';
         }
 
-        break
+        break;
       case 'select':
         if (value === '' || value === null) {
           // A blank string or null value will select the caption
-          value = undefined
+          value = undefined;
         }
-        var selection = -1
+        let selection = -1;
         for (let i = 0, n = element.options.length, optionValue; i < n; ++i) {
-          optionValue = selectExtensions.readValue(element.options[i])
+          optionValue = selectExtensions.readValue(element.options[i]);
           // Include special check to handle selecting a caption with a blank string value
           if (optionValue === value || (optionValue === '' && value === undefined)) {
-            selection = i
-            break
+            selection = i;
+            break;
           }
         }
         if (allowUnset || selection >= 0 || (value === undefined && element.size > 1)) {
-          element.selectedIndex = selection
+          element.selectedIndex = selection;
           if (ieVersion === 6) {
             // Workaround for IE6 bug: It won't reliably apply values to SELECT nodes during the same execution thread
             // right after you've changed the set of OPTION nodes on it. So for that node type, we'll schedule a second thread
             // to apply the value as well.
-            safeSetTimeout(() => { element.selectedIndex = selection }, 0)
+            safeSetTimeout(() => { element.selectedIndex = selection; }, 0);
           }
         }
-        break
+        break;
       default:
-        if ((value === null) || (value === undefined)) { value = '' }
-        element.value = value
-        break
+        if ((value === null) || (value === undefined)) { value = ''; }
+        element.value = value;
+        break;
     }
   }
-}
+};
diff --git a/packages/tko.utils/src/dom/virtualElements.ts b/packages/tko.utils/src/dom/virtualElements.ts
index 6d202ee9..bbe16253 100644
--- a/packages/tko.utils/src/dom/virtualElements.ts
+++ b/packages/tko.utils/src/dom/virtualElements.ts
@@ -14,203 +14,235 @@
 // IE 9 cannot reliably read the "nodeValue" property of a comment node (see https://github.com/SteveSanderson/knockout/issues/186)
 // but it does give them a nonstandard alternative property called "text" that it can read reliably. Other browsers don't have that property.
 // So, use node.text where available, and node.nodeValue elsewhere
-import { emptyDomNode, setDomNodeChildren as setRegularDomNodeChildren } from './manipulation.js'
-import { removeNode } from './disposal.js'
-import { tagNameLower } from './info.js'
-import * as domData from './data'
-import options from '../options'
+import { emptyDomNode, setDomNodeChildren as setRegularDomNodeChildren } from './manipulation';
+import { removeNode } from './disposal';
+import { tagNameLower, isDomElement } from './info';
+import * as domData from './data';
+import options from '../options';
+import _let from '../../../tko.binding.core/src/let';
 
-var commentNodesHaveTextProperty = options.document && options.document.createComment('test').text === '<!--test-->'
+const commentNodesHaveTextProperty = options.document && options.document.createComment('test').text === '<!--test-->';
 
-export var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+([\s\S]+))?\s*-->$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/
-export var endCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/
-var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true }
+export const startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+([\s\S]+))?\s*-->$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/;
+export const endCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
+const htmlTagsWithOptionallyClosingChildren: {[tagName: string]: boolean|undefined} = { ul: true, ol: true };
 
-export function isStartComment (node) {
-  return (node.nodeType == 8) && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue)
+export function isStartComment(node: Node) {
+  return (node.nodeType === 8) && startCommentRegex.test(commentNodesHaveTextProperty ? (node as any).text : node.nodeValue);
 }
 
-export function isEndComment (node) {
-  return (node.nodeType == 8) && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue)
+export function isEndComment(node: Node) {
+  return (node.nodeType === 8) && endCommentRegex.test(commentNodesHaveTextProperty ? (node as any).text : node.nodeValue);
 }
 
-function isUnmatchedEndComment (node) {
-  return isEndComment(node) && !domData.get(node, matchedEndCommentDataKey)
+function isUnmatchedEndComment(node: Node) {
+  return isEndComment(node) && !domData.get(node, matchedEndCommentDataKey);
 }
 
-const matchedEndCommentDataKey = '__ko_matchedEndComment__'
+const matchedEndCommentDataKey = '__ko_matchedEndComment__';
+
+export function getVirtualChildren(startComment: Node, allowUnbalanced?: boolean) {
+  let currentNode: Node|null = startComment;
+  let depth = 1;
+  const children = [];
 
-export function getVirtualChildren (startComment, allowUnbalanced) {
-  var currentNode = startComment
-  var depth = 1
-  var children = []
   while (currentNode = currentNode.nextSibling) {
     if (isEndComment(currentNode)) {
-      domData.set(currentNode, matchedEndCommentDataKey, true)
-      depth--
-      if (depth === 0) { return children }
+      domData.set(currentNode, matchedEndCommentDataKey, true);
+      depth--;
+      if (depth === 0) { return children; }
     }
 
-    children.push(currentNode)
+    children.push(currentNode);
 
-    if (isStartComment(currentNode)) { depth++ }
+    if (isStartComment(currentNode)) { depth++; }
   }
-  if (!allowUnbalanced) { throw new Error('Cannot find closing comment tag to match: ' + startComment.nodeValue) }
-  return null
+  if (!allowUnbalanced) { throw new Error('Cannot find closing comment tag to match: ' + startComment.nodeValue); }
+  return null;
 }
 
-function getMatchingEndComment (startComment, allowUnbalanced) {
-  var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced)
+function getMatchingEndComment(startComment: Node, allowUnbalanced?: boolean) {
+  const allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
   if (allVirtualChildren) {
-    if (allVirtualChildren.length > 0) { return allVirtualChildren[allVirtualChildren.length - 1].nextSibling }
-    return startComment.nextSibling
-  } else { return null } // Must have no matching end comment, and allowUnbalanced is true
+    if (allVirtualChildren.length > 0) { return allVirtualChildren[allVirtualChildren.length - 1].nextSibling; }
+    return startComment.nextSibling;
+  } else { return null; } // Must have no matching end comment, and allowUnbalanced is true
 }
 
-function getUnbalancedChildTags (node) {
+function getUnbalancedChildTags(node: Node) {
     // e.g., from <div>OK</div><!-- ko blah --><span>Another</span>, returns: <!-- ko blah --><span>Another</span>
     //       from <div>OK</div><!-- /ko --><!-- /ko -->,             returns: <!-- /ko --><!-- /ko -->
-  var childNode = node.firstChild, captureRemaining = null
+  let childNode = node.firstChild, captureRemaining = null;
   if (childNode) {
     do {
-      if (captureRemaining)                   // We already hit an unbalanced node and are now just scooping up all subsequent nodes
-          { captureRemaining.push(childNode) } else if (isStartComment(childNode)) {
-            var matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true)
-            if (matchingEndComment)             // It's a balanced tag, so skip immediately to the end of this virtual set
-                  { childNode = matchingEndComment } else { captureRemaining = [childNode] } // It's unbalanced, so start capturing from this point
-          } else if (isEndComment(childNode)) {
-            captureRemaining = [childNode]     // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing
-          }
-    } while (childNode = childNode.nextSibling)
+      if (captureRemaining) {
+        // We already hit an unbalanced node and are now just scooping up all subsequent nodes
+        captureRemaining.push(childNode);
+      } else if (isStartComment(childNode)) {
+        const matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true);
+        if (matchingEndComment) {
+          // It's a balanced tag, so skip immediately to the end of this virtual set
+          childNode = matchingEndComment;
+        } else {
+          // It's unbalanced, so start capturing from this point
+          captureRemaining = [childNode];
+        }
+      } else if (isEndComment(childNode)) {
+        captureRemaining = [childNode];     // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing
+      }
+    } while (childNode = childNode.nextSibling);
   }
-  return captureRemaining
+
+  return captureRemaining;
 }
 
-export var allowedBindings = {}
-export var hasBindingValue = isStartComment
+export const allowedBindings = {};
+export const hasBindingValue = isStartComment;
 
-export function childNodes (node) {
-  return isStartComment(node) ? getVirtualChildren(node) : node.childNodes
+export function childNodes(node: Node) {
+  return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
 }
 
-export function emptyNode (node) {
-  if (!isStartComment(node)) { emptyDomNode(node) } else {
-    var virtualChildren = childNodes(node)
-    for (var i = 0, j = virtualChildren.length; i < j; i++) { removeNode(virtualChildren[i]) }
+export function emptyNode(node: Node) {
+  if (!isStartComment(node)) { emptyDomNode(node); } else {
+    const virtualChildren = childNodes(node);
+    if (virtualChildren) {
+      for (let i = 0, j = virtualChildren.length; i < j; i++) { removeNode(virtualChildren[i]); }
+    }
   }
 }
 
-export function setDomNodeChildren (node, childNodes) {
-  if (!isStartComment(node)) { setRegularDomNodeChildren(node, childNodes) } else {
-    emptyNode(node)
-    var endCommentNode = node.nextSibling // Must be the next sibling, as we just emptied the children
-    for (var i = 0, j = childNodes.length; i < j; i++) { endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode) }
+export function setDomNodeChildren(node: Node, childNodes: ArrayLike<Node>) {
+  if (!isStartComment(node)) { setRegularDomNodeChildren(node, childNodes); } else {
+    emptyNode(node);
+    const endCommentNode = node.nextSibling; // Must be the next sibling, as we just emptied the children
+    for (let i = 0, j = childNodes.length; i < j; i++) {
+      if (endCommentNode && endCommentNode.parentNode) {
+        endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode);
+      }
+    }
   }
 }
 
-export function prepend (containerNode, nodeToPrepend) {
+export function prepend(containerNode: Node, nodeToPrepend: Node) {
   if (!isStartComment(containerNode)) {
-    if (containerNode.firstChild) { containerNode.insertBefore(nodeToPrepend, containerNode.firstChild) } else { containerNode.appendChild(nodeToPrepend) }
+    if (containerNode.firstChild) { containerNode.insertBefore(nodeToPrepend, containerNode.firstChild); } else { containerNode.appendChild(nodeToPrepend); }
   } else {
         // Start comments must always have a parent and at least one following sibling (the end comment)
-    containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling)
+    if (containerNode.parentNode) {
+      containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
+    }
   }
 }
 
-export function insertAfter (containerNode, nodeToInsert, insertAfterNode) {
+export function insertAfter(containerNode: Node, nodeToInsert: Node, insertAfterNode?: Node) {
   if (!insertAfterNode) {
-    prepend(containerNode, nodeToInsert)
+    prepend(containerNode, nodeToInsert);
   } else if (!isStartComment(containerNode)) {
         // Insert after insertion point
-    if (insertAfterNode.nextSibling) { containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling) } else { containerNode.appendChild(nodeToInsert) }
+    if (insertAfterNode.nextSibling) { containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling); } else { containerNode.appendChild(nodeToInsert); }
   } else {
         // Children of start comments must always have a parent and at least one following sibling (the end comment)
-    containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling)
+    if (containerNode.parentNode) {
+      containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+    }
   }
 }
 
-export function firstChild (node) {
+export function firstChild(node: Node) {
   if (!isStartComment(node)) {
     if (node.firstChild && isEndComment(node.firstChild)) {
-      throw new Error('Found invalid end comment, as the first child of ' + node.outerHTML)
+      throw new Error('Found invalid end comment, as the first child of ' + (isDomElement(node) ? node.outerHTML : node));
     }
-    return node.firstChild
+    return node.firstChild;
   }
   if (!node.nextSibling || isEndComment(node.nextSibling)) {
-    return null
+    return null;
   }
-  return node.nextSibling
+  return node.nextSibling;
 }
 
-export function lastChild (node) {
-  let nextChild = firstChild(node)
-  let lastChildNode
+export function lastChild(node: Node) {
+  let nextChild = firstChild(node);
+  let lastChildNode;
 
   do {
-    lastChildNode = nextChild
-  } while (nextChild = nextSibling(nextChild))
+    lastChildNode = nextChild;
+  } while (nextChild = nextSibling(nextChild));
 
-  return lastChildNode
+  return lastChildNode;
 }
 
-export function nextSibling (node) {
+export function nextSibling(node: Node|null) {
+  if (!node) {
+    return null;
+  }
+
   if (isStartComment(node)) {
-    node = getMatchingEndComment(node)
+    node = getMatchingEndComment(node);
+  }
+
+  if (!node) {
+    return null;
   }
 
   if (node.nextSibling && isEndComment(node.nextSibling)) {
     if (isUnmatchedEndComment(node.nextSibling)) {
-      throw Error('Found end comment without a matching opening comment, as next sibling of ' + node.outerHTML)
+      throw Error('Found end comment without a matching opening comment, as next sibling of ' + (isDomElement(node) ? node.outerHTML : node));
     }
-    return null
+    return null;
   } else {
-    return node.nextSibling
+    return node.nextSibling;
   }
 }
 
-export function previousSibling (node) {
-  var depth = 0
+export function previousSibling(node: Node|null) {
+  if (!node) {
+    return null;
+  }
+
+  let depth = 0;
   do {
     if (node.nodeType === 8) {
       if (isStartComment(node)) {
         if (--depth === 0) {
-          return node
+          return node;
         }
       } else if (isEndComment(node)) {
-        depth++
+        depth++;
       }
     } else {
-      if (depth === 0) { return node }
+      if (depth === 0) { return node; }
     }
-  } while (node = node.previousSibling)
+  } while (node = node.previousSibling);
 }
 
-export function virtualNodeBindingValue (node) {
-  var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex)
-  return regexMatch ? regexMatch[1] : null
+export function virtualNodeBindingValue(node: Node) {
+  const regexMatch = (commentNodesHaveTextProperty ? (node as any).text : node.nodeValue).match(startCommentRegex);
+  return regexMatch ? regexMatch[1] : null;
 }
 
-export function normaliseVirtualElementDomStructure (elementVerified) {
+export function normaliseVirtualElementDomStructure(elementVerified: Element) {
     // Workaround for https://github.com/SteveSanderson/knockout/issues/155
     // (IE <= 8 or IE 9 quirks mode parses your HTML weirdly, treating closing </li> tags as if they don't exist, thereby moving comment nodes
     // that are direct descendants of <ul> into the preceding <li>)
-  if (!htmlTagsWithOptionallyClosingChildren[tagNameLower(elementVerified)]) { return }
+  if (!htmlTagsWithOptionallyClosingChildren[tagNameLower(elementVerified)]) { return; }
 
     // Scan immediate children to see if they contain unbalanced comment tags. If they do, those comment tags
     // must be intended to appear *after* that child, so move them there.
-  var childNode = elementVerified.firstChild
+  let childNode = elementVerified.firstChild;
   if (childNode) {
     do {
       if (childNode.nodeType === 1) {
-        var unbalancedTags = getUnbalancedChildTags(childNode)
+        const unbalancedTags = getUnbalancedChildTags(childNode);
         if (unbalancedTags) {
                     // Fix up the DOM by moving the unbalanced tags to where they most likely were intended to be placed - *after* the child
-          var nodeToInsertBefore = childNode.nextSibling
-          for (var i = 0; i < unbalancedTags.length; i++) {
-            if (nodeToInsertBefore) { elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore) } else { elementVerified.appendChild(unbalancedTags[i]) }
+          const nodeToInsertBefore = childNode.nextSibling;
+          for (const unbalancedTag of unbalancedTags) {
+            if (nodeToInsertBefore) { elementVerified.insertBefore(unbalancedTag, nodeToInsertBefore); } else { elementVerified.appendChild(unbalancedTag); }
           }
         }
       }
-    } while (childNode = childNode.nextSibling)
+    } while (childNode = childNode.nextSibling);
   }
 }
diff --git a/packages/tko.utils/src/error.ts b/packages/tko.utils/src/error.ts
index 7e213d95..a6081cd6 100644
--- a/packages/tko.utils/src/error.ts
+++ b/packages/tko.utils/src/error.ts
@@ -3,22 +3,24 @@
 // ---
 //
 // The default onError handler is to re-throw.
-import options from './options.js'
+import options from './options.js';
 
-export function catchFunctionErrors (delegate) {
-  return options.onError ? function () {
+// tslint:disable:ban-types
+export function catchFunctionErrors<T extends Function>(delegate: T): T {
+  // Though this is a very nasty catch (and potentially wrong, because on error this may return undefined, it makes working with this function much more pleasant)
+  return options.onError ? (function(this: any) {
     try {
-      return delegate.apply(this, arguments)
+      return delegate.apply(this, arguments);
     } catch (e) {
-      options.onError(e)
+      options.onError(e);
     }
-  } : delegate
+  }) as any : delegate;
 }
 
-export function deferError (error) {
-  safeSetTimeout(function () { options.onError(error) }, 0)
+export function deferError(error: Error) {
+  safeSetTimeout(() => options.onError(error), 0);
 }
 
-export function safeSetTimeout (handler, timeout) {
-  return setTimeout(catchFunctionErrors(handler), timeout)
+export function safeSetTimeout(handler: Function, timeout: number) {
+  return setTimeout(catchFunctionErrors(handler), timeout);
 }
diff --git a/packages/tko.utils/src/function.ts b/packages/tko.utils/src/function.ts
index 4ed93ee9..24c45acc 100644
--- a/packages/tko.utils/src/function.ts
+++ b/packages/tko.utils/src/function.ts
@@ -1,17 +1,18 @@
 
-function testOverwrite () {
+function testOverwrite() {
   try {
-    Object.defineProperty(function x () {}, 'length', {})
-    return true
+    Object.defineProperty(function x() {}, 'length', {});
+    return true;
   } catch (e) {
-    return false
+    return false;
   }
 }
 
-export const functionSupportsLengthOverwrite = testOverwrite()
+export const functionSupportsLengthOverwrite = testOverwrite();
 
-export function overwriteLengthPropertyIfSupported (fn, descriptor) {
+// tslint:disable-next-line:ban-types
+export function overwriteLengthPropertyIfSupported(fn: Function, descriptor: PropertyDescriptor & ThisType<any>) {
   if (functionSupportsLengthOverwrite) {
-    Object.defineProperty(fn, 'length', descriptor)
+    Object.defineProperty(fn, 'length', descriptor);
   }
 }
diff --git a/packages/tko.utils/src/ie.ts b/packages/tko.utils/src/ie.ts
index 0616909f..9f4a2ffa 100644
--- a/packages/tko.utils/src/ie.ts
+++ b/packages/tko.utils/src/ie.ts
@@ -1,26 +1,27 @@
 //
 // Detection and Workarounds for Internet Explorer
 //
-import options from './options'
+import options from './options';
 
-const ieVersion = options.document && (function () {
-  var version = 3, div = options.document.createElement('div'), iElems = div.getElementsByTagName('i')
+const ieVersion = options.document && (() => {
+  let version = 3;
+  const div = options.document.createElement('div'), iElems = div.getElementsByTagName('i');
 
     // Keep constructing conditional HTML blocks until we hit one that resolves to an empty fragment
-  while (
-        div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',
-        iElems[0]
-    ) {}
+  do {
+    div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->';
+  }
+  while (iElems[0]);
 
   if (!version) {
-    const userAgent = window.navigator.userAgent
+    const userAgent = window.navigator.userAgent;
     // Detect IE 10/11
-    return ua.match(/MSIE ([^ ]+)/) || ua.match(/rv:([^ )]+)/)
+    return userAgent.match(/MSIE ([^ ]+)/) || userAgent.match(/rv:([^ )]+)/);
   }
-  return version > 4 ? version : undefined
-}())
+  return version > 4 ? version : undefined;
+})();
 
-const isIe6 = ieVersion === 6
-const isIe7 = ieVersion === 7
+const isIe6 = ieVersion === 6;
+const isIe7 = ieVersion === 7;
 
-export { ieVersion, isIe6, isIe7 }
+export { ieVersion, isIe6, isIe7 };
diff --git a/packages/tko.utils/src/index.ts b/packages/tko.utils/src/index.ts
index 19694760..8a5e6894 100644
--- a/packages/tko.utils/src/index.ts
+++ b/packages/tko.utils/src/index.ts
@@ -4,32 +4,32 @@
 
 */
 
-export * from './array.js'
-export * from './async.js'
-export * from './error.js'
-export * from './ie.js'
-export * from './object.js'
-export * from './function.js'
-export * from './proto.js'
-export * from './string.js'
-export * from './symbol.js'
-export * from './css.js'
-export { jQuerySetInstance } from './jquery.js'
-export { default as options } from './options.js'
+export * from './array';
+export * from './async';
+export * from './error';
+export * from './ie';
+export * from './object';
+export * from './function';
+export * from './proto';
+export * from './string';
+export * from './symbol';
+export * from './css';
+export { jQuerySetInstance } from './jquery';
+export { default as options } from './options';
 
 // DOM;
-export * from './dom/event.js'
-export * from './dom/info.js'
-export * from './dom/manipulation.js'
-export * from './dom/fixes.js'
-export * from './dom/html.js'
-export * from './dom/disposal.js'
-export * from './dom/selectExtensions.js'
+export * from './dom/event';
+export * from './dom/info';
+export * from './dom/manipulation';
+export * from './dom/fixes';
+export * from './dom/html';
+export * from './dom/disposal';
+export * from './dom/selectExtensions';
 
 // Sub-Modules;
-import * as memoization from './memoization'
-import * as tasks from './tasks.js'
-import * as virtualElements from './dom/virtualElements.js'
-import * as domData from './dom/data.js'
+import * as memoization from './memoization';
+import * as tasks from './tasks';
+import * as virtualElements from './dom/virtualElements';
+import * as domData from './dom/data';
 
-export {tasks, virtualElements, domData, memoization}
+export {tasks, virtualElements, domData, memoization};
diff --git a/packages/tko.utils/src/jquery.ts b/packages/tko.utils/src/jquery.ts
index 10f450fb..7facd852 100644
--- a/packages/tko.utils/src/jquery.ts
+++ b/packages/tko.utils/src/jquery.ts
@@ -3,10 +3,10 @@
 //
 // TODO: deprecate in favour of options.$
 
-import options from './options'
+import options from './options';
 
-export var jQueryInstance = options.global && options.global.jQuery
+export let jQueryInstance = options.jQuery;
 
-export function jQuerySetInstance (jquery) {
-  options.jQuery = jQueryInstance = jquery
+export function jQuerySetInstance(jquery: JQueryStatic) {
+  options.jQuery = jQueryInstance = jquery;
 }
diff --git a/packages/tko.utils/src/memoization.ts b/packages/tko.utils/src/memoization.ts
index 411c70da..3ce57288 100644
--- a/packages/tko.utils/src/memoization.ts
+++ b/packages/tko.utils/src/memoization.ts
@@ -1,58 +1,63 @@
 //
 // Memoization
 //
-import { arrayPushAll } from './array.js'
+import { arrayPushAll } from './array';
 
-var memos = {}
+// tslint:disable-next-line:ban-types
+type Memo = Function;
+interface IMemo { domNode: Node; memoId: string; }
 
-function randomMax8HexChars () {
-  return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1)
+const memos: {[memoId: string]: Memo}  = {};
+
+function randomMax8HexChars() {
+  // tslint:disable-next-line:no-bitwise
+  return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
 }
 
-function generateRandomId () {
-  return randomMax8HexChars() + randomMax8HexChars()
+function generateRandomId() {
+  return randomMax8HexChars() + randomMax8HexChars();
 }
 
-function findMemoNodes (rootNode, appendToArray) {
-  if (!rootNode) { return }
-  if (rootNode.nodeType == 8) {
-    var memoId = parseMemoText(rootNode.nodeValue)
-    if (memoId != null) { appendToArray.push({ domNode: rootNode, memoId: memoId }) }
-  } else if (rootNode.nodeType == 1) {
-    for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++) { findMemoNodes(childNodes[i], appendToArray) }
+function findMemoNodes(rootNode: Node, appendToArray: IMemo[]) {
+  if (!rootNode) { return; }
+  if (rootNode.nodeType === 8) {
+    const memoId = parseMemoText(rootNode.nodeValue);
+    if (memoId != null) { appendToArray.push({ domNode: rootNode, memoId }); }
+  } else if (rootNode.nodeType === 1) {
+    for (let i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++) { findMemoNodes(childNodes[i], appendToArray); }
   }
 }
 
-export function memoize (callback) {
-  if (typeof callback !== 'function') { throw new Error('You can only pass a function to memoization.memoize()') }
-  var memoId = generateRandomId()
-  memos[memoId] = callback
-  return '<!--[ko_memo:' + memoId + ']-->'
+export function memoize(callback: Memo) {
+  if (typeof callback !== 'function') { throw new Error('You can only pass a function to memoization.memoize()'); }
+  const memoId = generateRandomId();
+  memos[memoId] = callback;
+  return '<!--[ko_memo:' + memoId + ']-->';
 }
 
-export function unmemoize (memoId, callbackParams) {
-  var callback = memos[memoId]
-  if (callback === undefined) { throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.") }
+export function unmemoize(memoId: string, callbackParams: any[]) {
+  const callback = memos[memoId];
+  if (callback === undefined) { throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized."); }
   try {
-    callback.apply(null, callbackParams || [])
-    return true
-  } finally { delete memos[memoId] }
+    callback.apply(null, callbackParams || []);
+    return true;
+  } finally { delete memos[memoId]; }
 }
 
-export function unmemoizeDomNodeAndDescendants (domNode, extraCallbackParamsArray) {
-  var memos = []
-  findMemoNodes(domNode, memos)
-  for (var i = 0, j = memos.length; i < j; i++) {
-    var node = memos[i].domNode
-    var combinedParams = [node]
-    if (extraCallbackParamsArray) { arrayPushAll(combinedParams, extraCallbackParamsArray) }
-    unmemoize(memos[i].memoId, combinedParams)
-    node.nodeValue = '' // Neuter this node so we don't try to unmemoize it again
-    if (node.parentNode) { node.parentNode.removeChild(node) } // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)
+export function unmemoizeDomNodeAndDescendants(domNode: Node, extraCallbackParamsArray: any[]) {
+  const memos: IMemo[] = [];
+  findMemoNodes(domNode, memos);
+  for (let i = 0, j = memos.length; i < j; i++) {
+    const node = memos[i].domNode;
+    const combinedParams = [node];
+    if (extraCallbackParamsArray) { arrayPushAll(combinedParams, extraCallbackParamsArray); }
+    unmemoize(memos[i].memoId, combinedParams);
+    node.nodeValue = ''; // Neuter this node so we don't try to unmemoize it again
+    if (node.parentNode) { node.parentNode.removeChild(node); } // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)
   }
 }
 
-export function parseMemoText (memoText) {
-  var match = memoText.match(/^\[ko_memo\:(.*?)\]$/)
-  return match ? match[1] : null
+export function parseMemoText(memoText: string|null) {
+  const match = memoText && memoText.match(/^\[ko_memo\:(.*?)\]$/);
+  return match ? match[1] : null;
 }
diff --git a/packages/tko.utils/src/object.ts b/packages/tko.utils/src/object.ts
index 6331402a..5037fe41 100644
--- a/packages/tko.utils/src/object.ts
+++ b/packages/tko.utils/src/object.ts
@@ -2,62 +2,63 @@
 // Object functions
 //
 
-export function hasOwnProperty(obj, propName) {
-  return Object.prototype.hasOwnProperty.call(obj, propName)
+export function hasOwnProperty(obj: any, propName: string) {
+  return Object.prototype.hasOwnProperty.call(obj, propName) as boolean;
 }
 
-export function extend (target, source) {
+export function extend(target: any, source: any) {
   if (source) {
-    for (var prop in source) {
+    for (const prop in source) {
       if (hasOwnProperty(source, prop)) {
-        target[prop] = source[prop]
+        target[prop] = source[prop];
       }
     }
   }
-  return target
+  return target;
 }
 
-export function objectForEach (obj, action) {
-  for (var prop in obj) {
+export function objectForEach<T>(obj: T, action: (prop: keyof T, value: T[keyof T]) => void) {
+  for (const prop in obj) {
     if (hasOwnProperty(obj, prop)) {
-      action(prop, obj[prop])
+      action(prop, obj[prop]);
     }
   }
 }
 
-export function objectMap (source, mapping, thisArg) {
-  if (!source) { return source }
-  if (arguments.length > 2) { mapping = mapping.bind(thisArg) }
-  var target = {}
-  for (var prop in source) {
+export type MappingFunction<TSource, TThis= void> = (value: TSource[keyof TSource], prop: keyof TSource, source: TSource) => any;
+export function objectMap<TSource, TThis= void>(source: TSource, mapping: MappingFunction<TSource, TThis>, thisArg?: TThis) {
+  if (!source) { return source; }
+  if (thisArg) { mapping = mapping.bind(thisArg); }
+  const target: any = {};
+  for (const prop in source) {
     if (hasOwnProperty(source, prop)) {
-      target[prop] = mapping(source[prop], prop, source)
+      target[prop] = mapping(source[prop], prop, source);
     }
   }
-  return target
+  return target;
 }
-export function getObjectOwnProperty (obj, propName) {
-  return hasOwnProperty(obj, propName) ? obj[propName] : undefined
+export function getObjectOwnProperty<TSource>(obj: TSource, propName: keyof TSource) {
+  return hasOwnProperty(obj, propName) ? obj[propName] : undefined;
 }
 
-export function clonePlainObjectDeep (obj, seen) {
-  if (!seen) { seen = [] }
+export function clonePlainObjectDeep(obj: any, seen?: any[]) {
+  if (!seen) { seen = []; }
 
   if (!obj || typeof obj !== 'object' ||
         obj.constructor !== Object ||
         seen.indexOf(obj) !== -1) {
-    return obj
+    return obj;
   }
 
     // Anything that makes it below is a plain object that has not yet
     // been seen/cloned.
-  seen.push(obj)
+  seen.push(obj);
 
-  var result = {}
-  for (var prop in obj) {
+  const result: any = {};
+  for (const prop in obj) {
     if (hasOwnProperty(obj, prop)) {
-      result[prop] = clonePlainObjectDeep(obj[prop], seen)
+      result[prop] = clonePlainObjectDeep(obj[prop], seen);
     }
   }
-  return result
+  return result;
 }
diff --git a/packages/tko.utils/src/options.ts b/packages/tko.utils/src/options.ts
index ccbeeccd..ecffdc5b 100644
--- a/packages/tko.utils/src/options.ts
+++ b/packages/tko.utils/src/options.ts
@@ -4,56 +4,84 @@
 //
 // This is the root 'options', which must be extended by others.
 
-var _global
+// tslint:disable-next-line:variable-name
+let _global: Window;
+let jq: JQueryStatic|null = null;
+let promise: PromiseConstructorLike|null = null;
+let document: Document|null = null;
+
+try {
+  _global = window;
+  jq = jQuery;
+  document = window.document;
+} catch (e) {
+  _global = global as any as Window;
+}
+
+if ('Promise' in _global) {
+  promise = (_global as any).Promise as PromiseConstructorLike;
+}
 
-try { _global = window } catch (e) { _global = global }
+// tslint:disable-next-line:ban-types
+type TaskScheduler = (callback: Function) => any;
+const taskScheduler = null; // Workaround for typedef
 
-var options = {
+const options = {
   deferUpdates: false,
 
   useOnlyNativeEvents: false,
 
   protoProperty: '__ko_proto__',
 
-    // Modify the default attribute from `data-bind`.
+  /**
+   * Modify the default attribute from `data-bind`.
+   */
   defaultBindingAttribute: 'data-bind',
 
-    // Enable/disable <!-- ko binding: ... -> style bindings
+  /**
+   * Enable/disable <!-- ko binding: ... -> style bindings
+   */
   allowVirtualElements: true,
 
-    // Global variables that can be accessed from bindings.
+  /**
+   * Global variables that can be accessed from bindings.
+   */
   bindingGlobals: _global,
 
-    // An instance of the binding provider.
+  /**
+   * An instance of the binding provider.
+   */
   bindingProviderInstance: null,
 
-    // jQuery will be automatically set to _global.jQuery in applyBindings
-    // if it is (strictly equal to) undefined.  Set it to false or null to
-    // disable automatically setting jQuery.
-  jQuery: _global && _global.jQuery,
+  /**
+   * jQuery will be automatically set to _global.jQuery in applyBindings
+   * if it is (strictly equal to) undefined.  Set it to false or null to
+   * disable automatically setting jQuery.
+   */
+  jQuery: jq,
 
-  Promise: _global && _global.Promise,
+  Promise: promise,
 
-  taskScheduler: null,
+  taskScheduler: (taskScheduler as TaskScheduler|null),
 
   debug: false,
 
   global: _global,
-  document: _global.document,
+  document,
 
-    // Filters for bindings
-    //   data-bind="expression | filter_1 | filter_2"
+  /**
+   * Filters for bindings
+   *   data-bind="expression | filter_1 | filter_2"
+   */
   filters: {},
 
-  onError: function (e) { throw e },
+  onError(e: Error) { throw e; },
 
-  set: function (name, value) {
-    options[name] = value
-  }
-}
+  set(name: string, value: any) {
+    (options as any)[name] = value;
+  },
 
-Object.defineProperty(options, '$', {
-  get: function () { return options.jQuery }
-})
+  $: jQuery
+};
 
-export default options
+export default options;
diff --git a/packages/tko.utils/src/proto.ts b/packages/tko.utils/src/proto.ts
index 48c1ec6a..4f629213 100644
--- a/packages/tko.utils/src/proto.ts
+++ b/packages/tko.utils/src/proto.ts
@@ -1,16 +1,16 @@
 //
 // Prototype Functions
 //
-import { extend } from './object.js'
-import options from './options.js'
+import { extend } from './object.js';
+import options from './options.js';
 
-var protoProperty = options.protoProperty
+const protoProperty = options.protoProperty;
 
-export var canSetPrototype = ({ __proto__: [] } instanceof Array)
+export const canSetPrototype = ({ __proto__: [] } instanceof Array);
 
-export function setPrototypeOf (obj, proto) {
-  obj.__proto__ = proto
-  return obj
+export function setPrototypeOf(obj: any, proto: any) {
+  obj.__proto__ = proto;
+  return obj;
 }
 
-export var setPrototypeOfOrExtend = canSetPrototype ? setPrototypeOf : extend
+export const setPrototypeOfOrExtend = canSetPrototype ? setPrototypeOf : extend;
diff --git a/packages/tko.utils/src/string.ts b/packages/tko.utils/src/string.ts
index 58b59a52..1fb16a4a 100644
--- a/packages/tko.utils/src/string.ts
+++ b/packages/tko.utils/src/string.ts
@@ -2,32 +2,34 @@
 // String (and JSON)
 //
 
-export function stringTrim (string) {
-  return string === null || string === undefined ? ''
-        : string.trim
-            ? string.trim()
-            : string.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, '')
+export function stringTrim(str: string) {
+  return str === null || str === undefined ? ''
+        : str.trim
+            ? str.trim()
+            : str.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');
 }
 
-export function stringStartsWith (string, startsWith) {
-  string = string || ''
-  if (startsWith.length > string.length) { return false }
-  return string.substring(0, startsWith.length) === startsWith
+export function stringStartsWith(str: string, startsWith: string) {
+  str = str || '';
+  if (startsWith.length > str.length) { return false; }
+  return str.substring(0, startsWith.length) === startsWith;
 }
 
-export function parseJson (jsonString) {
+export function parseJson(jsonString: string) {
   if (typeof jsonString === 'string') {
-    jsonString = stringTrim(jsonString)
+    jsonString = stringTrim(jsonString);
     if (jsonString) {
-      if (JSON && JSON.parse) // Use native parsing where available
-            { return JSON.parse(jsonString) }
-      return (new Function('return ' + jsonString))() // Fallback on less safe parsing for older browsers
+      if (JSON && JSON.parse) { return JSON.parse(jsonString); } // Use native parsing where available
+      return (new Function('return ' + jsonString))(); // Fallback on less safe parsing for older browsers
     }
   }
-  return null
+  return null;
 }
 
-export function stringifyJson (data, replacer, space) {   // replacer and space are optional
-  if (!JSON || !JSON.stringify) { throw new Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js") }
-  return JSON.stringify(typeof data === 'function' ? data() : data, replacer, space)
+export function stringifyJson(data: any, replacer ?: (key: string, value: any) => any, space ?: string | number) {   // replacer and space are optional
+  if (!JSON || !JSON.stringify) {
+    throw new Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");
+  }
+
+  return JSON.stringify(typeof data === 'function' ? data() : data, replacer, space);
 }
diff --git a/packages/tko.utils/src/symbol.ts b/packages/tko.utils/src/symbol.ts
index 53668136..01253c7b 100644
--- a/packages/tko.utils/src/symbol.ts
+++ b/packages/tko.utils/src/symbol.ts
@@ -2,8 +2,8 @@
 // ES6 Symbols
 //
 
-export var useSymbols = typeof Symbol === 'function'
+export const useSymbols = typeof Symbol === 'function';
 
-export function createSymbolOrString (identifier) {
-  return useSymbols ? Symbol(identifier) : identifier
+export function createSymbolOrString(identifier: any) {
+  return useSymbols ? Symbol(identifier) : identifier;
 }
diff --git a/packages/tko.utils/src/tasks.ts b/packages/tko.utils/src/tasks.ts
index dc1290b4..0dee9014 100644
--- a/packages/tko.utils/src/tasks.ts
+++ b/packages/tko.utils/src/tasks.ts
@@ -3,101 +3,106 @@
 //  ===
 //
 /* eslint no-cond-assign: 0 */
-import options from './options'
-import { deferError } from './error.js'
+import options from './options';
+import { deferError } from './error';
 
-var taskQueue = [],
-  taskQueueLength = 0,
+// tslint:disable:ban-types
+type Task = Function;
+
+const taskQueue: Array<Task|null> = [], w = options.global;
+let taskQueueLength = 0,
   nextHandle = 1,
-  nextIndexToProcess = 0,
-  w = options.global
+  nextIndexToProcess = 0;
 
-if (w && w.MutationObserver && !(w.navigator && w.navigator.standalone)) {
+if (w && (w as any).MutationObserver && !(w.navigator && (w.navigator as any).standalone)) {
     // Chrome 27+, Firefox 14+, IE 11+, Opera 15+, Safari 6.1+, node
     // From https://github.com/petkaantonov/bluebird * Copyright (c) 2014 Petka Antonov * License: MIT
-  options.taskScheduler = (function (callback) {
-    var div = w.document.createElement('div')
-    new w.MutationObserver(callback).observe(div, {attributes: true})
-    return function () { div.classList.toggle('foo') }
-  })(scheduledProcess)
+  options.taskScheduler = ((callback: Function) => {
+    const div = w.document.createElement('div');
+    new MutationObserver(callback as MutationCallback).observe(div, {attributes: true});
+    return () => { div.classList.toggle('foo'); };
+  })(scheduledProcess);
 } else if (w && w.document && 'onreadystatechange' in w.document.createElement('script')) {
     // IE 6-10
     // From https://github.com/YuzuJS/setImmediate * Copyright (c) 2012 Barnesandnoble.com, llc, Donavon West, and Domenic Denicola * License: MIT
-  options.taskScheduler = function (callback) {
-    var script = document.createElement('script')
-    script.onreadystatechange = function () {
-      script.onreadystatechange = null
-      document.documentElement.removeChild(script)
-      script = null
-      callback()
-    }
-    document.documentElement.appendChild(script)
-  }
+  options.taskScheduler = (callback: Function) => {
+    let script: HTMLScriptElement|null = document.createElement('script');
+    (script as any).onreadystatechange = () => {
+      (script as any).onreadystatechange = null;
+      document.documentElement.removeChild(script!);
+      script = null;
+      callback();
+    };
+
+    document.documentElement.appendChild(script);
+  };
 } else {
-  options.taskScheduler = function (callback) {
-    setTimeout(callback, 0)
-  }
+  options.taskScheduler = (callback: Function) => {
+    setTimeout(callback, 0);
+  };
 }
 
-function processTasks () {
+function processTasks() {
   if (taskQueueLength) {
         // Each mark represents the end of a logical group of tasks and the number of these groups is
         // limited to prevent unchecked recursion.
-    var mark = taskQueueLength, countMarks = 0
+    let mark = taskQueueLength, countMarks = 0;
 
         // nextIndexToProcess keeps track of where we are in the queue; processTasks can be called recursively without issue
-    for (var task; nextIndexToProcess < taskQueueLength;) {
+    for (let task; nextIndexToProcess < taskQueueLength;) {
       if (task = taskQueue[nextIndexToProcess++]) {
         if (nextIndexToProcess > mark) {
           if (++countMarks >= 5000) {
-            nextIndexToProcess = taskQueueLength   // skip all tasks remaining in the queue since any of them could be causing the recursion
-            deferError(Error("'Too much recursion' after processing " + countMarks + ' task groups.'))
-            break
+            nextIndexToProcess = taskQueueLength;   // skip all tasks remaining in the queue since any of them could be causing the recursion
+            deferError(Error("'Too much recursion' after processing " + countMarks + ' task groups.'));
+            break;
           }
-          mark = taskQueueLength
+          mark = taskQueueLength;
         }
         try {
-          task()
+          task();
         } catch (ex) {
-          deferError(ex)
+          deferError(ex);
         }
       }
     }
   }
 }
 
-function scheduledProcess () {
-  processTasks()
+function scheduledProcess() {
+  processTasks();
 
     // Reset the queue
-  nextIndexToProcess = taskQueueLength = taskQueue.length = 0
+  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
 }
 
-function scheduleTaskProcessing () {
-  options.taskScheduler(scheduledProcess)
+function scheduleTaskProcessing() {
+  options.taskScheduler!(scheduledProcess);
 }
 
-export function schedule (func) {
+export type TaskHandle = number;
+
+export function schedule(func: Function): TaskHandle {
   if (!taskQueueLength) {
-    scheduleTaskProcessing()
+    scheduleTaskProcessing();
   }
 
-  taskQueue[taskQueueLength++] = func
-  return nextHandle++
+  taskQueue[taskQueueLength++] = func;
+  return nextHandle++;
 }
 
-export function cancel (handle) {
-  var index = handle - (nextHandle - taskQueueLength)
+export function cancel(handle: TaskHandle) {
+  const index = handle - (nextHandle - taskQueueLength);
   if (index >= nextIndexToProcess && index < taskQueueLength) {
-    taskQueue[index] = null
+    taskQueue[index] = null;
   }
 }
 
 // For testing only: reset the queue and return the previous queue length
-export function resetForTesting () {
-  var length = taskQueueLength - nextIndexToProcess
-  nextIndexToProcess = taskQueueLength = taskQueue.length = 0
-  return length
+export function resetForTesting() {
+  const length = taskQueueLength - nextIndexToProcess;
+  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
+  return length;
 }
 
-export {processTasks as runEarly}
+export {processTasks as runEarly};