From 5344957abb55dbbd561812b746fe8406d61b5252 Mon Sep 17 00:00:00 2001
From: Sebazzz <triadsebas@gmail.com>
Date: Wed, 25 Apr 2018 22:38:10 +0200
Subject: [PATCH] Initial Typescriptification of tko.utils - pending
 compilation issues in rollup

---
 package.json                                  |   2 +
 packages/node_modules                         |   1 -
 packages/tko.utils/package.json               |   3 +-
 packages/tko.utils/src/array.js               | 168 ------------
 packages/tko.utils/src/array.ts               | 196 ++++++++++++++
 packages/tko.utils/src/async.js               |  24 --
 packages/tko.utils/src/async.ts               |  26 ++
 .../src/{bind-shim.js => bind-shim.ts}        |   0
 packages/tko.utils/src/css.js                 |  37 ---
 packages/tko.utils/src/css.ts                 |  38 +++
 packages/tko.utils/src/dom/data.js            |  84 ------
 packages/tko.utils/src/dom/data.ts            |  88 +++++++
 packages/tko.utils/src/dom/disposal.js        | 117 ---------
 packages/tko.utils/src/dom/disposal.ts        | 133 ++++++++++
 packages/tko.utils/src/dom/event.js           |  95 -------
 packages/tko.utils/src/dom/event.ts           | 101 +++++++
 .../tko.utils/src/dom/{fixes.js => fixes.ts}  |  45 ++--
 .../tko.utils/src/dom/{html.js => html.ts}    | 155 +++++------
 packages/tko.utils/src/dom/info.js            |  46 ----
 packages/tko.utils/src/dom/info.ts            |  55 ++++
 packages/tko.utils/src/dom/manipulation.js    |  85 ------
 packages/tko.utils/src/dom/manipulation.ts    |  91 +++++++
 ...electExtensions.js => selectExtensions.ts} |  62 ++---
 packages/tko.utils/src/dom/virtualElements.js | 216 ---------------
 packages/tko.utils/src/dom/virtualElements.ts | 248 ++++++++++++++++++
 packages/tko.utils/src/error.js               |  24 --
 packages/tko.utils/src/error.ts               |  26 ++
 packages/tko.utils/src/function.js            |  17 --
 packages/tko.utils/src/function.ts            |  18 ++
 packages/tko.utils/src/ie.js                  |  26 --
 packages/tko.utils/src/ie.ts                  |  27 ++
 packages/tko.utils/src/index.js               |  35 ---
 packages/tko.utils/src/index.ts               |  35 +++
 packages/tko.utils/src/jquery.js              |  12 -
 packages/tko.utils/src/jquery.ts              |  12 +
 packages/tko.utils/src/memoization.js         |  58 ----
 packages/tko.utils/src/memoization.ts         |  63 +++++
 packages/tko.utils/src/object.js              |  63 -----
 packages/tko.utils/src/object.ts              |  64 +++++
 packages/tko.utils/src/options.js             |  59 -----
 packages/tko.utils/src/options.ts             |  87 ++++++
 packages/tko.utils/src/proto.js               |  16 --
 packages/tko.utils/src/proto.ts               |  16 ++
 packages/tko.utils/src/string.js              |  33 ---
 packages/tko.utils/src/string.ts              |  35 +++
 packages/tko.utils/src/symbol.js              |   9 -
 packages/tko.utils/src/symbol.ts              |   9 +
 packages/tko.utils/src/tasks.js               | 103 --------
 packages/tko.utils/src/tasks.ts               | 108 ++++++++
 tsconfig.json                                 |   4 +-
 tslint.json                                   |  46 ++++
 yarn.lock                                     |  78 +++++-
 52 files changed, 1740 insertions(+), 1459 deletions(-)
 delete mode 120000 packages/node_modules
 delete mode 100644 packages/tko.utils/src/array.js
 create mode 100644 packages/tko.utils/src/array.ts
 delete mode 100644 packages/tko.utils/src/async.js
 create mode 100644 packages/tko.utils/src/async.ts
 rename packages/tko.utils/src/{bind-shim.js => bind-shim.ts} (100%)
 delete mode 100644 packages/tko.utils/src/css.js
 create mode 100644 packages/tko.utils/src/css.ts
 delete mode 100644 packages/tko.utils/src/dom/data.js
 create mode 100644 packages/tko.utils/src/dom/data.ts
 delete mode 100644 packages/tko.utils/src/dom/disposal.js
 create mode 100644 packages/tko.utils/src/dom/disposal.ts
 delete mode 100644 packages/tko.utils/src/dom/event.js
 create mode 100644 packages/tko.utils/src/dom/event.ts
 rename packages/tko.utils/src/dom/{fixes.js => fixes.ts} (68%)
 rename packages/tko.utils/src/dom/{html.js => html.ts} (56%)
 delete mode 100644 packages/tko.utils/src/dom/info.js
 create mode 100644 packages/tko.utils/src/dom/info.ts
 delete mode 100644 packages/tko.utils/src/dom/manipulation.js
 create mode 100644 packages/tko.utils/src/dom/manipulation.ts
 rename packages/tko.utils/src/dom/{selectExtensions.js => selectExtensions.ts} (62%)
 delete mode 100644 packages/tko.utils/src/dom/virtualElements.js
 create mode 100644 packages/tko.utils/src/dom/virtualElements.ts
 delete mode 100644 packages/tko.utils/src/error.js
 create mode 100644 packages/tko.utils/src/error.ts
 delete mode 100644 packages/tko.utils/src/function.js
 create mode 100644 packages/tko.utils/src/function.ts
 delete mode 100644 packages/tko.utils/src/ie.js
 create mode 100644 packages/tko.utils/src/ie.ts
 delete mode 100644 packages/tko.utils/src/index.js
 create mode 100644 packages/tko.utils/src/index.ts
 delete mode 100644 packages/tko.utils/src/jquery.js
 create mode 100644 packages/tko.utils/src/jquery.ts
 delete mode 100644 packages/tko.utils/src/memoization.js
 create mode 100644 packages/tko.utils/src/memoization.ts
 delete mode 100644 packages/tko.utils/src/object.js
 create mode 100644 packages/tko.utils/src/object.ts
 delete mode 100644 packages/tko.utils/src/options.js
 create mode 100644 packages/tko.utils/src/options.ts
 delete mode 100644 packages/tko.utils/src/proto.js
 create mode 100644 packages/tko.utils/src/proto.ts
 delete mode 100644 packages/tko.utils/src/string.js
 create mode 100644 packages/tko.utils/src/string.ts
 delete mode 100644 packages/tko.utils/src/symbol.js
 create mode 100644 packages/tko.utils/src/symbol.ts
 delete mode 100644 packages/tko.utils/src/tasks.js
 create mode 100644 packages/tko.utils/src/tasks.ts
 create mode 100644 tslint.json

diff --git a/package.json b/package.json
index 09d5e711..40998c0c 100644
--- a/package.json
+++ b/package.json
@@ -62,6 +62,8 @@
     "rollup-plugin-visualizer": "^0.3.1",
     "sinon": "^4.1",
     "standard": "^10.0.3",
+    "tslint": "5.9.1",
+    "tslib": "1.9.0",
     "typescript": "^2.6.2"
   },
   "workspaces": [
diff --git a/packages/node_modules b/packages/node_modules
deleted file mode 120000
index 945c9b46..00000000
--- a/packages/node_modules
+++ /dev/null
@@ -1 +0,0 @@
-.
\ No newline at end of file
diff --git a/packages/tko.utils/package.json b/packages/tko.utils/package.json
index 3055fa0b..5f98e772 100644
--- a/packages/tko.utils/package.json
+++ b/packages/tko.utils/package.json
@@ -27,7 +27,8 @@
     ]
   },
   "dependencies": {
-    "tslib": "^1.8.0"
+    "@types/jquery": "3.3.1",
+    "tslib": "1.9.0"
   },
   "__about__shared.package.json": "These properties are copied into all packages/*/package.json",
   "standard": {
diff --git a/packages/tko.utils/src/array.js b/packages/tko.utils/src/array.js
deleted file mode 100644
index 567a0542..00000000
--- a/packages/tko.utils/src/array.js
+++ /dev/null
@@ -1,168 +0,0 @@
-//
-// Array utilities
-//
-// Note that the array functions may be called with
-// Array-like things, such as NodeList.
-
-const {isArray} = Array
-
-export function arrayForEach (array, action, thisArg) {
-  if (arguments.length > 2) { action = action.bind(thisArg) }
-  for (let i = 0, j = array.length; i < j; ++i) {
-    action(array[i], i, array)
-  }
-}
-
-export function arrayIndexOf (array, item) {
-  return (isArray(array) ? array : [...array]).indexOf(item)
-}
-
-export function arrayFirst (array, predicate, predicateOwner) {
-  return (isArray(array) ? array : [...array])
-    .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 arrayRemoveItem (array, itemToRemove) {
-  var index = arrayIndexOf(array, itemToRemove)
-  if (index > 0) {
-    array.splice(index, 1)
-  } else if (index === 0) {
-    array.shift()
-  }
-}
-
-export function arrayGetDistinctValues (array = []) {
-  const seen = new Set()
-  return (isArray(array) ? array : [...array])
-    .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 arrayPushAll (array, valuesToPush) {
-  if (isArray(valuesToPush)) {
-    array.push.apply(array, valuesToPush)
-  } else {
-    for (var i = 0, j = valuesToPush.length; i < j; i++) { array.push(valuesToPush[i]) }
-  }
-  return array
-}
-
-export function addOrRemoveItem (array, value, included) {
-  var existingEntryIndex = arrayIndexOf(typeof array.peek === 'function' ? array.peek() : array, value)
-  if (existingEntryIndex < 0) {
-    if (included) { array.push(value) }
-  } else {
-    if (!included) { array.splice(existingEntryIndex, 1) }
-  }
-}
-
-export function makeArray (arrayLikeObject) {
-  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
-}
-
-// Go through the items that have been added and deleted and try to find matches between them.
-export function findMovesInArrayComparison (left, right, limitFailedCompares) {
-  if (left.length && right.length) {
-    var failedCompares, l, r, leftItem, rightItem
-    for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
-      for (r = 0; rightItem = right[r]; ++r) {
-        if (leftItem['value'] === rightItem['value']) {
-          leftItem['moved'] = rightItem['index']
-          rightItem['moved'] = leftItem['index']
-          right.splice(r, 1)         // 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
-    }
-  }
-}
-
-var statusNotInOld = 'added', statusNotInNew = 'deleted'
-
-    // Simple calculation based on Levenshtein distance.
-export function compareArrays (oldArray, newArray, options) {
-    // 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 || []
-
-  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,
-    myMax = Math.max,
-    editDistanceMatrix = [],
-    smlIndex, smlIndexMax = smlArray.length,
-    bigIndex, bigIndexMax = bigArray.length,
-    compareRange = (bigIndexMax - smlIndexMax) || 1,
-    maxDistance = smlIndexMax + bigIndexMax + 1,
-    thisRow, lastRow,
-    bigIndexMaxForRow, bigIndexMinForRow
-
-  for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
-    lastRow = thisRow
-    editDistanceMatrix.push(thisRow = [])
-    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
-              }
-    }
-  }
-
-  var editScript = [], meMinusOne, notInSml = [], notInBig = []
-  for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex;) {
-    meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1
-    if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex - 1]) {
-      notInSml.push(editScript[editScript.length] = {     // added
-        'status': statusNotInSml,
-        'value': bigArray[--bigIndex],
-        'index': bigIndex })
-    } else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
-      notInBig.push(editScript[editScript.length] = {     // deleted
-        'status': statusNotInBig,
-        'value': smlArray[--smlIndex],
-        'index': smlIndex })
-    } else {
-      --bigIndex
-      --smlIndex
-      if (!options['sparse']) {
-        editScript.push({
-          '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)
-
-  return editScript.reverse()
-}
diff --git a/packages/tko.utils/src/array.ts b/packages/tko.utils/src/array.ts
new file mode 100644
index 00000000..c975d1c0
--- /dev/null
+++ b/packages/tko.utils/src/array.ts
@@ -0,0 +1,196 @@
+//
+// Array utilities
+//
+// Note that the array functions may be called with
+// Array-like things, such as NodeList.
+
+const {isArray} = Array;
+
+// 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);
+  }
+}
+
+export function arrayIndexOf<T>(array: T[], item: T) {
+  return (isArray(array) ? array : [...array]).indexOf(item);
+}
+
+// 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<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<T>(array: T[], itemToRemove: T) {
+  const index = arrayIndexOf(array, itemToRemove);
+  if (index > 0) {
+    array.splice(index, 1);
+  } else if (index === 0) {
+    array.shift();
+  }
+}
+
+export function arrayGetDistinctValues<T>(array: T[] = []) {
+  const seen = new Set();
+  return (isArray(array) ? array : [...array])
+    .filter(item => seen.has(item) ? false : seen.add(item));
+}
+
+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<T>(array: T[], valuesToPush: ArrayLike<T>) {
+  if (isArray(valuesToPush)) {
+    array.push.apply(array, valuesToPush);
+  } else {
+    for (let i = 0, j = valuesToPush.length; i < j; i++) {
+      array.push(valuesToPush[i]);
+    }
+  }
+
+  return array;
+}
+
+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); }
+  } else {
+    if (!included) { array.splice(existingEntryIndex, 1); }
+  }
+}
+
+export function makeArray<T>(arrayLikeObject: ArrayLike<T>) {
+  return Array.from(arrayLikeObject);
+}
+
+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: any[], right: any[], limitFailedCompares: number|boolean) {
+  if (left.length && right.length) {
+    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;
+        }
+      }
+      failedCompares += r;
+    }
+  }
+}
+
+const statusNotInOld = 'added', statusNotInNew = 'deleted';
+
+export interface ICompareArrayOptions {
+  dontLimitMoves?: boolean;
+  sparse?: boolean;
+}
+
+    // Simple calculation based on Levenshtein distance.
+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 || [];
+
+  if (oldArray.length < newArray.length) {
+     return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options);
+  } else {
+     return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options);
+  }
+}
+
+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: any,
+    bigIndexMaxForRow, bigIndexMinForRow;
+
+  for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
+    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]) {
+        // 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;
+      }
+    }
+  }
+
+  let editScript = [], meMinusOne, notInSml = [], notInBig = [];
+  for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex;) {
+    meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1;
+    if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex - 1]) {
+      notInSml.push(editScript[editScript.length] = {     // added
+        status: statusNotInSml,
+        value: bigArray[--bigIndex],
+        index: bigIndex });
+    } else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
+      notInBig.push(editScript[editScript.length] = {     // deleted
+        status: statusNotInBig,
+        value: smlArray[--smlIndex],
+        index: smlIndex });
+    } else {
+      --bigIndex;
+      --smlIndex;
+      if (!options.sparse) {
+        editScript.push({
+          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);
+
+  return editScript.reverse();
+}
diff --git a/packages/tko.utils/src/async.js b/packages/tko.utils/src/async.js
deleted file mode 100644
index d700aef6..00000000
--- a/packages/tko.utils/src/async.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Asynchronous functionality
-// ---
-import { safeSetTimeout } from './error.js'
-
-export function throttle (callback, timeout) {
-  var timeoutInstance
-  return function (...args) {
-    if (!timeoutInstance) {
-      timeoutInstance = safeSetTimeout(function () {
-        timeoutInstance = undefined
-        callback(...args)
-      }, timeout)
-    }
-  }
-}
-
-export function debounce (callback, timeout) {
-  var timeoutInstance
-  return function (...args) {
-    clearTimeout(timeoutInstance)
-    timeoutInstance = safeSetTimeout(() => callback(...args), timeout)
-  }
-}
diff --git a/packages/tko.utils/src/async.ts b/packages/tko.utils/src/async.ts
new file mode 100644
index 00000000..629c2df2
--- /dev/null
+++ b/packages/tko.utils/src/async.ts
@@ -0,0 +1,26 @@
+//
+// Asynchronous functionality
+// ---
+import { safeSetTimeout } from './error';
+
+// tslint:disable-next-line:ban-types
+export function throttle(callback: Function, timeout: number) {
+  let timeoutInstance: number|undefined;
+  return (...args: any[]) => {
+    if (!timeoutInstance) {
+      timeoutInstance = safeSetTimeout(() => {
+        timeoutInstance = undefined;
+        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/bind-shim.js b/packages/tko.utils/src/bind-shim.ts
similarity index 100%
rename from packages/tko.utils/src/bind-shim.js
rename to packages/tko.utils/src/bind-shim.ts
diff --git a/packages/tko.utils/src/css.js b/packages/tko.utils/src/css.js
deleted file mode 100644
index e1e2aefe..00000000
--- a/packages/tko.utils/src/css.js
+++ /dev/null
@@ -1,37 +0,0 @@
-//
-// DOM - CSS
-//
-
-import { arrayForEach, addOrRemoveItem } from './array.js'
-
-// For details on the pattern for changing node classes
-// see: https://github.com/knockout/knockout/issues/1597
-var cssClassNameRegex = /\S+/g
-
-function toggleDomNodeCssClass (node, classNames, shouldHaveClass) {
-  var addOrRemoveFn
-  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') {
-        // SVG tag .classNames is an SVGAnimatedString instance
-    toggleObjectClassPropertyString(node.className, 'baseVal', classNames, shouldHaveClass)
-  } else {
-        // node.className ought to be a string.
-    toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass)
-  }
-}
-
-function toggleObjectClassPropertyString (obj, prop, classNames, shouldHaveClass) {
-    // 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(' ')
-}
-
-export { toggleDomNodeCssClass }
diff --git a/packages/tko.utils/src/css.ts b/packages/tko.utils/src/css.ts
new file mode 100644
index 00000000..4a4fa778
--- /dev/null
+++ b/packages/tko.utils/src/css.ts
@@ -0,0 +1,38 @@
+//
+// DOM - CSS
+//
+
+import { arrayForEach, addOrRemoveItem } from './array';
+
+// For details on the pattern for changing node classes
+// see: https://github.com/knockout/knockout/issues/1597
+const cssClassNameRegex = /\S+/g;
+
+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)!, (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);
+  } else {
+        // node.className ought to be a string.
+    toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass);
+  }
+}
+
+function toggleObjectClassPropertyString(obj: any, prop: string, classNames: string, shouldHaveClass?: boolean) {
+    // obj/prop is either a node/'className' or a SVGAnimatedString/'baseVal'.
+  const currentClassNames = obj[prop].match(cssClassNameRegex) || [];
+  arrayForEach(classNames.match(cssClassNameRegex)!, (className: string) => {
+    addOrRemoveItem(currentClassNames, className, shouldHaveClass);
+  });
+
+  obj[prop] = currentClassNames.join(' ');
+}
+
+export { toggleDomNodeCssClass };
diff --git a/packages/tko.utils/src/dom/data.js b/packages/tko.utils/src/dom/data.js
deleted file mode 100644
index d7f1215a..00000000
--- a/packages/tko.utils/src/dom/data.js
+++ /dev/null
@@ -1,84 +0,0 @@
-//
-// DOM node data
-//
-import { ieVersion } from '../ie'
-
-const datastoreTime = new Date().getTime()
-const dataStoreKeyExpandoPropertyName = `__ko__${datastoreTime}`
-const dataStoreSymbol = Symbol('Knockout data')
-var dataStore
-let uniqueId = 0
-
-/*
- * We considered using WeakMap, but it has a problem in IE 11 and Edge that
- * prevents using it cross-window, so instead we just store the data directly
- * on the node. See https://github.com/knockout/knockout/issues/2141
- */
-const modern = {
-  getDataForNode (node, createIfNotFound) {
-    let dataForNode = node[dataStoreSymbol]
-    if (!dataForNode && createIfNotFound) {
-      dataForNode = node[dataStoreSymbol] = {}
-    }
-    return dataForNode
-  },
-
-  clear (node) {
-    if (node[dataStoreSymbol]) {
-      delete node[dataStoreSymbol]
-      return true
-    }
-    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]
-    if (!hasExistingDataStore) {
-      if (!createIfNotFound) {
-        return undefined
-      }
-      dataStoreKey = node[dataStoreKeyExpandoPropertyName] = 'ko' + uniqueId++
-      dataStore[dataStoreKey] = {}
-    }
-    return dataStore[dataStoreKey]
-  },
-
-  clear (node) {
-    const dataStoreKey = node[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
-    }
-    return false
-  }
-}
-
-const {getDataForNode, clear} = ieVersion ? IE : modern
-
-/**
- * Create a unique key-string identifier.
- */
-export function nextKey () {
-  return (uniqueId++) + dataStoreKeyExpandoPropertyName
-}
-
-function get (node, key) {
-  const dataForNode = getDataForNode(node, false)
-  return dataForNode && dataForNode[key]
-}
-
-function set (node, key, value) {
-  // 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)
-}
-
-export { get, set, clear }
diff --git a/packages/tko.utils/src/dom/data.ts b/packages/tko.utils/src/dom/data.ts
new file mode 100644
index 00000000..7eb022e9
--- /dev/null
+++ b/packages/tko.utils/src/dom/data.ts
@@ -0,0 +1,88 @@
+//
+// DOM node data
+//
+import { ieVersion } from '../ie';
+
+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
+ * prevents using it cross-window, so instead we just store the data directly
+ * on the node. See https://github.com/knockout/knockout/issues/2141
+ */
+const modern = {
+  getDataForNode(node: any, createIfNotFound?: boolean): any {
+    let dataForNode = node[dataStoreSymbol];
+    if (!dataForNode && createIfNotFound) {
+      dataForNode = node[dataStoreSymbol] = {};
+    }
+    return dataForNode;
+  },
+
+  clear(node: Node) {
+    const internalNode = node as any;
+    if (internalNode[dataStoreSymbol]) {
+      delete internalNode[dataStoreSymbol];
+      return true;
+    }
+    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: any, createIfNotFound?: boolean): any {
+    let dataStoreKey = node[dataStoreKeyExpandoPropertyName];
+    const hasExistingDataStore = dataStoreKey && (dataStoreKey !== 'null') && dataStore[dataStoreKey];
+    if (!hasExistingDataStore) {
+      if (!createIfNotFound) {
+        return undefined;
+      }
+      dataStoreKey = node[dataStoreKeyExpandoPropertyName] = 'ko' + uniqueId++;
+      dataStore[dataStoreKey] = {};
+    }
+    return dataStore[dataStoreKey];
+  },
+
+  clear(node: Node) {
+    const internalNode = node as any;
+    const dataStoreKey = internalNode[dataStoreKeyExpandoPropertyName];
+    if (dataStoreKey) {
+      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;
+  }
+};
+
+const {getDataForNode, clear} = ieVersion ? IE : modern;
+
+/**
+ * Create a unique key-string identifier.
+ */
+export function nextKey() {
+  return (uniqueId++) + dataStoreKeyExpandoPropertyName;
+}
+
+function get<T= any>(node: Node, key: string) {
+  const dataForNode = getDataForNode(node, false);
+  return dataForNode && dataForNode[key];
+}
+
+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
+  const dataForNode = getDataForNode(node, value !== undefined /* createIfNotFound */);
+  if (dataForNode) {
+    dataForNode[key] = value;
+  }
+}
+
+export { get, set, clear };
diff --git a/packages/tko.utils/src/dom/disposal.js b/packages/tko.utils/src/dom/disposal.js
deleted file mode 100644
index 96b80ed7..00000000
--- a/packages/tko.utils/src/dom/disposal.js
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// DOM node disposal
-//
-/* eslint no-cond-assign: 0 */
-import * as domData from './data.js'
-import {arrayRemoveItem} from '../array.js'
-import {jQueryInstance} from '../jquery.js'
-
-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 }
-
-function getDisposeCallbacksCollection (node, createIfNotFound) {
-  var allDisposeCallbacks = domData.get(node, domDataKey)
-  if ((allDisposeCallbacks === undefined) && createIfNotFound) {
-    allDisposeCallbacks = []
-    domData.set(node, domDataKey, allDisposeCallbacks)
-  }
-  return allDisposeCallbacks
-}
-function destroyCallbacksCollection (node) {
-  domData.set(node, domDataKey, undefined)
-}
-
-function cleanSingleNode (node) {
-    // Run all the dispose callbacks
-  var 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) }
-  }
-
-    // Erase the DOM data
-  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)
-  }
-
-    // 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) }
-}
-
-function cleanImmediateCommentTypeChildren (nodeWithChildren) {
-  const children = nodeWithChildren.childNodes
-  let cleanedNode
-  for (let i = 0; i < children.length; ++i) {
-    if (children[i].nodeType === 8) {
-      cleanSingleNode(cleanedNode = children[i])
-      if (children[i] !== cleanedNode) {
-        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 function removeDisposeCallback (node, callback) {
-  var callbacksCollection = getDisposeCallbacksCollection(node, false)
-  if (callbacksCollection) {
-    arrayRemoveItem(callbacksCollection, callback)
-    if (callbacksCollection.length === 0) { destroyCallbacksCollection(node) }
-  }
-}
-
-export function cleanNode (node) {
-    // First clean this node, where applicable
-  if (cleanableNodeTypes[node.nodeType]) {
-    cleanSingleNode(node)
-
-        // ... then its descendants, where applicable
-    if (cleanableNodeTypesWithDescendants[node.nodeType]) {
-      const descendants = node.getElementsByTagName('*')
-      for (let i = 0; i < descendants.length; ++i) {
-        let cleanedNode = descendants[i]
-        cleanSingleNode(cleanedNode)
-        if (descendants[i] !== cleanedNode) {
-          throw Error('ko.cleanNode: An already cleaned node was removed from the document')
-        }
-      }
-    }
-  }
-  return node
-}
-
-export function removeNode (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
-
-  if (jQueryCleanNodeFn) {
-    jQueryCleanNodeFn([node])
-  }
-}
-
-otherNodeCleanerFunctions.push(cleanjQueryData)
diff --git a/packages/tko.utils/src/dom/disposal.ts b/packages/tko.utils/src/dom/disposal.ts
new file mode 100644
index 00000000..a65a4b00
--- /dev/null
+++ b/packages/tko.utils/src/dom/disposal.ts
@@ -0,0 +1,133 @@
+//
+// DOM node disposal
+//
+/* eslint no-cond-assign: 0 */
+import * as domData from './data';
+import {arrayRemoveItem} from '../array';
+import {jQueryInstance} from '../jquery';
+
+const domDataKey = domData.nextKey();
+
+// Node types:
+// 1: Element
+// 8: Comment
+// 9: Document
+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: Node, createIfNotFound?: boolean) {
+  let allDisposeCallbacks = domData.get(node, domDataKey);
+  if ((allDisposeCallbacks === undefined) && createIfNotFound) {
+    allDisposeCallbacks = [];
+    domData.set(node, domDataKey, allDisposeCallbacks);
+  }
+  return allDisposeCallbacks;
+}
+
+function destroyCallbacksCollection(node: Node) {
+  domData.set(node, domDataKey, undefined);
+}
+
+// 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 (const cb of callbacks) {
+      callbacks(node);
+    }
+  }
+
+    // Erase the DOM data
+  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);
+  }
+
+    // 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); }
+}
+
+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]);
+      if (children[i] !== cleanedNode) {
+        throw Error('ko.cleanNode: An already cleaned node was removed from the document');
+      }
+    }
+  }
+}
+
+// Exports
+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: Node, callback: DisposeCallback) {
+  const callbacksCollection = getDisposeCallbacksCollection(node, false);
+  if (callbacksCollection) {
+    arrayRemoveItem(callbacksCollection, callback);
+    if (callbacksCollection.length === 0) { destroyCallbacksCollection(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);
+
+        // ... then its descendants, where applicable
+    if (isCleanableNodeWithDescendants(node)) {
+      const descendants = node.getElementsByTagName('*');
+
+      // tslint:disable-next-line:prefer-for-of
+      for (let i = 0; i < descendants.length; ++i) {
+        const cleanedNode = descendants[i];
+        cleanSingleNode(cleanedNode);
+        if (descendants[i] !== cleanedNode) {
+          throw Error('ko.cleanNode: An already cleaned node was removed from the document');
+        }
+      }
+    }
+  }
+  return node;
+}
+
+export function removeNode(node: Node) {
+  cleanNode(node);
+  if (node.parentNode) { node.parentNode.removeChild(node); }
+}
+
+// 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: Node) {
+  // Note: cleanData is an internal jQuery function
+  const jQueryCleanNodeFn = jQueryInstance
+        ? (jQueryInstance as any).cleanData : null;
+
+  if (jQueryCleanNodeFn) {
+    jQueryCleanNodeFn([node]);
+  }
+}
+
+otherNodeCleanerFunctions.push(cleanjQueryData);
diff --git a/packages/tko.utils/src/dom/event.js b/packages/tko.utils/src/dom/event.js
deleted file mode 100644
index ccc08444..00000000
--- a/packages/tko.utils/src/dom/event.js
+++ /dev/null
@@ -1,95 +0,0 @@
-//
-// DOM Events
-//
-
-import { objectForEach } from '../object.js'
-import { jQueryInstance } from '../jquery.js'
-import { ieVersion } from '../ie.js'
-import { catchFunctionErrors } from '../error.js'
-
-import { tagNameLower } from './info.js'
-import { addDisposeCallback } from './disposal.js'
-import options from '../options.js'
-
-// 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 = {}
-
-var keyEventTypeName = (options.global.navigator && /Firefox\/2/i.test(options.global.navigator.userAgent)) ? 'KeyboardEvent' : 'UIEvents'
-
-knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress']
-
-knownEvents['MouseEvents'] = [
-  'click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover',
-  'mouseout', 'mouseenter', 'mouseleave']
-
-objectForEach(knownEvents, function (eventType, knownEventsForType) {
-  if (knownEventsForType.length) {
-    for (var 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')
-}
-
-// Workaround for an IE9 issue - https://github.com/SteveSanderson/knockout/issues/406
-var eventsThatMustBeRegisteredUsingAttachEvent = { 'propertychange': true }
-let jQueryEventAttachName
-
-export function registerEventHandler (element, eventType, handler, 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'
-    }
-    jQueryInstance(element)[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)
-
-    // 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)
-    })
-  } else {
-    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') }
-
-    // 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)
-
-  if (!options.useOnlyNativeEvents && jQueryInstance && !useClickWorkaround) {
-    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") }
-  } else if (useClickWorkaround && element.click) {
-    element.click()
-  } else if (typeof element.fireEvent !== 'undefined') {
-    element.fireEvent('on' + eventType)
-  } else {
-    throw new Error("Browser doesn't support triggering events")
-  }
-}
diff --git a/packages/tko.utils/src/dom/event.ts b/packages/tko.utils/src/dom/event.ts
new file mode 100644
index 00000000..0d660951
--- /dev/null
+++ b/packages/tko.utils/src/dom/event.ts
@@ -0,0 +1,101 @@
+//
+// DOM Events
+//
+
+import { objectForEach } from '../object';
+import { jQueryInstance } from '../jquery';
+import { ieVersion } from '../ie';
+import { catchFunctionErrors } from '../error';
+
+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)
+const knownEvents: {[evType: string]: string[]} = {},
+  knownEventTypesByEventName: {[evType: string]: string} = {};
+
+const keyEventTypeName = (options.global.navigator && /Firefox\/2/i.test(options.global.navigator.userAgent)) ? 'KeyboardEvent' : 'UIEvents';
+
+knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress'];
+
+knownEvents.MouseEvents = [
+  'click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover',
+  'mouseout', 'mouseenter', 'mouseleave'];
+
+objectForEach(knownEvents, (eventType, knownEventsForType) => {
+  if (knownEventsForType.length) {
+    for (let i = 0, j = knownEventsForType.length; i < j; i++) { knownEventTypesByEventName[knownEventsForType[i]] = eventType; }
+  }
+});
+
+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
+const eventsThatMustBeRegisteredUsingAttachEvent: {[type: string]: boolean} = { propertychange: true };
+let jQueryEventAttachName: any;
+
+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';
+    }
+    (jQueryInstance(element) as any)[jQueryEventAttachName](eventType, wrappedHandler);
+  } else if (!mustUseAttachEvent && typeof element.addEventListener === 'function') {
+    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, () => {
+      (element as any).detachEvent(attachEventName, attachEventHandler);
+    });
+  } else {
+    throw new Error("Browser doesn't support addEventListener or attachEvent");
+  }
+}
+
+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.
+  const useClickWorkaround = isClickOnCheckableElement(element, eventType);
+
+  if (!options.useOnlyNativeEvents && jQueryInstance && !useClickWorkaround) {
+    jQueryInstance(element).trigger(eventType);
+  } else if (typeof document.createEvent === 'function') {
+    if (typeof element.dispatchEvent === 'function') {
+      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 as any).fireEvent !== 'undefined') {
+    (element as any).fireEvent('on' + eventType);
+  } else {
+    throw new Error("Browser doesn't support triggering events");
+  }
+}
diff --git a/packages/tko.utils/src/dom/fixes.js b/packages/tko.utils/src/dom/fixes.ts
similarity index 68%
rename from packages/tko.utils/src/dom/fixes.js
rename to packages/tko.utils/src/dom/fixes.ts
index e99b7903..0db13c7e 100644
--- a/packages/tko.utils/src/dom/fixes.js
+++ 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.js b/packages/tko.utils/src/dom/html.ts
similarity index 56%
rename from packages/tko.utils/src/dom/html.js
rename to packages/tko.utils/src/dom/html.ts
index 09bade62..2bef2aa9 100644
--- a/packages/tko.utils/src/dom/html.js
+++ 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.js b/packages/tko.utils/src/dom/info.js
deleted file mode 100644
index a98c444e..00000000
--- a/packages/tko.utils/src/dom/info.js
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// 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
-  }
-  return !!node
-}
-
-export function domNodeIsAttachedToDocument (node) {
-  return domNodeIsContainedBy(node, node.ownerDocument.documentElement)
-}
-
-export function anyDomNodeIsAttachedToDocument (nodes) {
-  return !!arrayFirst(nodes, domNodeIsAttachedToDocument)
-}
-
-export function tagNameLower (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()
-}
-
-export function isDomElement (obj) {
-  if (window.HTMLElement) {
-    return obj instanceof HTMLElement
-  } else {
-    return obj && obj.tagName && obj.nodeType === 1
-  }
-}
-
-export function isDocumentFragment (obj) {
-  if (window.DocumentFragment) {
-    return obj instanceof DocumentFragment
-  } else {
-    return obj && obj.nodeType === 11
-  }
-}
diff --git a/packages/tko.utils/src/dom/info.ts b/packages/tko.utils/src/dom/info.ts
new file mode 100644
index 00000000..8e7cea36
--- /dev/null
+++ b/packages/tko.utils/src/dom/info.ts
@@ -0,0 +1,55 @@
+//
+// Information about the DOM
+//
+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 !!parentNode;
+}
+
+export function domNodeIsAttachedToDocument(node: Node) {
+  return domNodeIsContainedBy(node, node.ownerDocument.documentElement);
+}
+
+export function anyDomNodeIsAttachedToDocument(nodes: Node[]) {
+  return !!arrayFirst(nodes, domNodeIsAttachedToDocument);
+}
+
+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();
+}
+
+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;
+  }
+}
+
+export function isDocumentFragment(obj: any): obj is DocumentFragment {
+  if ((window as any).DocumentFragment) {
+    return obj instanceof DocumentFragment;
+  } else {
+    return obj && obj.nodeType === 11;
+  }
+}
diff --git a/packages/tko.utils/src/dom/manipulation.js b/packages/tko.utils/src/dom/manipulation.js
deleted file mode 100644
index b8049e2c..00000000
--- a/packages/tko.utils/src/dom/manipulation.js
+++ /dev/null
@@ -1,85 +0,0 @@
-//
-// 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'
-
-export function moveCleanedNodesToContainerElement (nodes) {
-    // 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
-
-  var container = templateDocument.createElement('div')
-  for (var i = 0, j = nodesArray.length; i < j; i++) {
-    container.appendChild(cleanNode(nodesArray[i]))
-  }
-  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)
-  }
-  return newNodesArray
-}
-
-export function setDomNodeChildren (domNode, childNodes) {
-  emptyDomNode(domNode)
-  if (childNodes) {
-    for (var i = 0, j = childNodes.length; i < j; i++) { domNode.appendChild(childNodes[i]) }
-  }
-}
-
-export function replaceDomNodes (nodeToReplaceOrNodeArray, newNodesArray) {
-  var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [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])
-    }
-  }
-}
-
-export function setElementName (element, name) {
-  element.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) {
-    try {
-      element.mergeAttributes(document.createElement("<input name='" + element.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 = '' }
-
-    // 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)])
-  } else {
-    innerTextNode.data = value
-  }
-
-  forceRefresh(element)
-}
-
-export function emptyDomNode (domNode) {
-  while (domNode.firstChild) {
-    removeNode(domNode.firstChild)
-  }
-}
diff --git a/packages/tko.utils/src/dom/manipulation.ts b/packages/tko.utils/src/dom/manipulation.ts
new file mode 100644
index 00000000..4e489b99
--- /dev/null
+++ b/packages/tko.utils/src/dom/manipulation.ts
@@ -0,0 +1,91 @@
+//
+// DOM manipulation
+//
+/* eslint no-empty: 0 */
+const {isArray} = Array;
+
+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.
+  const nodesArray = makeArray(nodes);
+  const templateDocument = (nodesArray[0] && nodesArray[0].ownerDocument) || document;
+
+  const container = templateDocument.createElement('div');
+  for (let i = 0, j = nodesArray.length; i < j; i++) {
+    container.appendChild(cleanNode(nodesArray[i]));
+  }
+  return container;
+}
+
+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;
+}
+
+export function setDomNodeChildren(domNode: Node, childNodes: ArrayLike<Node>) {
+  emptyDomNode(domNode);
+  if (childNodes) {
+    for (let i = 0, j = childNodes.length; i < j; i++) { domNode.appendChild(childNodes[i]); }
+  }
+}
+
+export function replaceDomNodes(nodeToReplaceOrNodeArray: Node[]|Node, newNodesArray: Node[]) {
+  const nodesToReplaceArray = !isArray(nodeToReplaceOrNodeArray) ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;
+  if (nodesToReplaceArray.length > 0) {
+    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: 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 && ieVersion <= 7) {
+    try {
+      (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"
+  }
+}
+
+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.
+  const innerTextNode = virtualElements.firstChild(element);
+  if (!innerTextNode || innerTextNode.nodeType !== 3 || virtualElements.nextSibling(innerTextNode)) {
+    virtualElements.setDomNodeChildren(element, [element.ownerDocument.createTextNode(value)]);
+  } else {
+    (innerTextNode as any).data = value;
+  }
+
+  forceRefresh(element);
+}
+
+export function emptyDomNode(domNode: Node) {
+  while (domNode.firstChild) {
+    removeNode(domNode.firstChild);
+  }
+}
diff --git a/packages/tko.utils/src/dom/selectExtensions.js b/packages/tko.utils/src/dom/selectExtensions.ts
similarity index 62%
rename from packages/tko.utils/src/dom/selectExtensions.js
rename to packages/tko.utils/src/dom/selectExtensions.ts
index 4d4e20de..b8fe27a1 100644
--- a/packages/tko.utils/src/dom/selectExtensions.js
+++ 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.js b/packages/tko.utils/src/dom/virtualElements.js
deleted file mode 100644
index 6d202ee9..00000000
--- a/packages/tko.utils/src/dom/virtualElements.js
+++ /dev/null
@@ -1,216 +0,0 @@
-/* eslint no-cond-assign: 0 */
-//
-// Virtual Elements
-//
-//
-// "Virtual elements" is an abstraction on top of the usual DOM API which understands the notion that comment nodes
-// may be used to represent hierarchy (in addition to the DOM's natural hierarchy).
-// If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state
-// of that virtual hierarchy
-//
-// The point of all this is to support containerless templates (e.g., <!-- ko foreach:someCollection -->blah<!-- /ko -->)
-// without having to scatter special cases all over the binding and templating code.
-
-// 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'
-
-var 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 function isStartComment (node) {
-  return (node.nodeType == 8) && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue)
-}
-
-export function isEndComment (node) {
-  return (node.nodeType == 8) && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue)
-}
-
-function isUnmatchedEndComment (node) {
-  return isEndComment(node) && !domData.get(node, matchedEndCommentDataKey)
-}
-
-const matchedEndCommentDataKey = '__ko_matchedEndComment__'
-
-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 }
-    }
-
-    children.push(currentNode)
-
-    if (isStartComment(currentNode)) { depth++ }
-  }
-  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)
-  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
-}
-
-function getUnbalancedChildTags (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
-  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)
-  }
-  return captureRemaining
-}
-
-export var allowedBindings = {}
-export var hasBindingValue = isStartComment
-
-export function childNodes (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 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 prepend (containerNode, nodeToPrepend) {
-  if (!isStartComment(containerNode)) {
-    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)
-  }
-}
-
-export function insertAfter (containerNode, nodeToInsert, insertAfterNode) {
-  if (!insertAfterNode) {
-    prepend(containerNode, nodeToInsert)
-  } else if (!isStartComment(containerNode)) {
-        // Insert after insertion point
-    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)
-  }
-}
-
-export function firstChild (node) {
-  if (!isStartComment(node)) {
-    if (node.firstChild && isEndComment(node.firstChild)) {
-      throw new Error('Found invalid end comment, as the first child of ' + node.outerHTML)
-    }
-    return node.firstChild
-  }
-  if (!node.nextSibling || isEndComment(node.nextSibling)) {
-    return null
-  }
-  return node.nextSibling
-}
-
-export function lastChild (node) {
-  let nextChild = firstChild(node)
-  let lastChildNode
-
-  do {
-    lastChildNode = nextChild
-  } while (nextChild = nextSibling(nextChild))
-
-  return lastChildNode
-}
-
-export function nextSibling (node) {
-  if (isStartComment(node)) {
-    node = getMatchingEndComment(node)
-  }
-
-  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)
-    }
-    return null
-  } else {
-    return node.nextSibling
-  }
-}
-
-export function previousSibling (node) {
-  var depth = 0
-  do {
-    if (node.nodeType === 8) {
-      if (isStartComment(node)) {
-        if (--depth === 0) {
-          return node
-        }
-      } else if (isEndComment(node)) {
-        depth++
-      }
-    } else {
-      if (depth === 0) { return node }
-    }
-  } while (node = node.previousSibling)
-}
-
-export function virtualNodeBindingValue (node) {
-  var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex)
-  return regexMatch ? regexMatch[1] : null
-}
-
-export function normaliseVirtualElementDomStructure (elementVerified) {
-    // 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 }
-
-    // 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
-  if (childNode) {
-    do {
-      if (childNode.nodeType === 1) {
-        var 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]) }
-          }
-        }
-      }
-    } while (childNode = childNode.nextSibling)
-  }
-}
diff --git a/packages/tko.utils/src/dom/virtualElements.ts b/packages/tko.utils/src/dom/virtualElements.ts
new file mode 100644
index 00000000..bbe16253
--- /dev/null
+++ b/packages/tko.utils/src/dom/virtualElements.ts
@@ -0,0 +1,248 @@
+/* eslint no-cond-assign: 0 */
+//
+// Virtual Elements
+//
+//
+// "Virtual elements" is an abstraction on top of the usual DOM API which understands the notion that comment nodes
+// may be used to represent hierarchy (in addition to the DOM's natural hierarchy).
+// If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state
+// of that virtual hierarchy
+//
+// The point of all this is to support containerless templates (e.g., <!-- ko foreach:someCollection -->blah<!-- /ko -->)
+// without having to scatter special cases all over the binding and templating code.
+
+// 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';
+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';
+
+const commentNodesHaveTextProperty = options.document && options.document.createComment('test').text === '<!--test-->';
+
+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: Node) {
+  return (node.nodeType === 8) && startCommentRegex.test(commentNodesHaveTextProperty ? (node as any).text : node.nodeValue);
+}
+
+export function isEndComment(node: Node) {
+  return (node.nodeType === 8) && endCommentRegex.test(commentNodesHaveTextProperty ? (node as any).text : node.nodeValue);
+}
+
+function isUnmatchedEndComment(node: Node) {
+  return isEndComment(node) && !domData.get(node, matchedEndCommentDataKey);
+}
+
+const matchedEndCommentDataKey = '__ko_matchedEndComment__';
+
+export function getVirtualChildren(startComment: Node, allowUnbalanced?: boolean) {
+  let currentNode: Node|null = startComment;
+  let depth = 1;
+  const children = [];
+
+  while (currentNode = currentNode.nextSibling) {
+    if (isEndComment(currentNode)) {
+      domData.set(currentNode, matchedEndCommentDataKey, true);
+      depth--;
+      if (depth === 0) { return children; }
+    }
+
+    children.push(currentNode);
+
+    if (isStartComment(currentNode)) { depth++; }
+  }
+  if (!allowUnbalanced) { throw new Error('Cannot find closing comment tag to match: ' + startComment.nodeValue); }
+  return null;
+}
+
+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
+}
+
+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 -->
+  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)) {
+        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;
+}
+
+export const allowedBindings = {};
+export const hasBindingValue = isStartComment;
+
+export function childNodes(node: Node) {
+  return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
+}
+
+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: 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: Node, nodeToPrepend: Node) {
+  if (!isStartComment(containerNode)) {
+    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)
+    if (containerNode.parentNode) {
+      containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
+    }
+  }
+}
+
+export function insertAfter(containerNode: Node, nodeToInsert: Node, insertAfterNode?: Node) {
+  if (!insertAfterNode) {
+    prepend(containerNode, nodeToInsert);
+  } else if (!isStartComment(containerNode)) {
+        // Insert after insertion point
+    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)
+    if (containerNode.parentNode) {
+      containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
+    }
+  }
+}
+
+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 ' + (isDomElement(node) ? node.outerHTML : node));
+    }
+    return node.firstChild;
+  }
+  if (!node.nextSibling || isEndComment(node.nextSibling)) {
+    return null;
+  }
+  return node.nextSibling;
+}
+
+export function lastChild(node: Node) {
+  let nextChild = firstChild(node);
+  let lastChildNode;
+
+  do {
+    lastChildNode = nextChild;
+  } while (nextChild = nextSibling(nextChild));
+
+  return lastChildNode;
+}
+
+export function nextSibling(node: Node|null) {
+  if (!node) {
+    return null;
+  }
+
+  if (isStartComment(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 ' + (isDomElement(node) ? node.outerHTML : node));
+    }
+    return null;
+  } else {
+    return node.nextSibling;
+  }
+}
+
+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;
+        }
+      } else if (isEndComment(node)) {
+        depth++;
+      }
+    } else {
+      if (depth === 0) { return node; }
+    }
+  } while (node = node.previousSibling);
+}
+
+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: 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; }
+
+    // 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.
+  let childNode = elementVerified.firstChild;
+  if (childNode) {
+    do {
+      if (childNode.nodeType === 1) {
+        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
+          const nodeToInsertBefore = childNode.nextSibling;
+          for (const unbalancedTag of unbalancedTags) {
+            if (nodeToInsertBefore) { elementVerified.insertBefore(unbalancedTag, nodeToInsertBefore); } else { elementVerified.appendChild(unbalancedTag); }
+          }
+        }
+      }
+    } while (childNode = childNode.nextSibling);
+  }
+}
diff --git a/packages/tko.utils/src/error.js b/packages/tko.utils/src/error.js
deleted file mode 100644
index 7e213d95..00000000
--- a/packages/tko.utils/src/error.js
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Error handling
-// ---
-//
-// The default onError handler is to re-throw.
-import options from './options.js'
-
-export function catchFunctionErrors (delegate) {
-  return options.onError ? function () {
-    try {
-      return delegate.apply(this, arguments)
-    } catch (e) {
-      options.onError(e)
-    }
-  } : delegate
-}
-
-export function deferError (error) {
-  safeSetTimeout(function () { options.onError(error) }, 0)
-}
-
-export function safeSetTimeout (handler, timeout) {
-  return setTimeout(catchFunctionErrors(handler), timeout)
-}
diff --git a/packages/tko.utils/src/error.ts b/packages/tko.utils/src/error.ts
new file mode 100644
index 00000000..a6081cd6
--- /dev/null
+++ b/packages/tko.utils/src/error.ts
@@ -0,0 +1,26 @@
+//
+// Error handling
+// ---
+//
+// The default onError handler is to re-throw.
+import options from './options.js';
+
+// 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);
+    } catch (e) {
+      options.onError(e);
+    }
+  }) as any : delegate;
+}
+
+export function deferError(error: Error) {
+  safeSetTimeout(() => options.onError(error), 0);
+}
+
+export function safeSetTimeout(handler: Function, timeout: number) {
+  return setTimeout(catchFunctionErrors(handler), timeout);
+}
diff --git a/packages/tko.utils/src/function.js b/packages/tko.utils/src/function.js
deleted file mode 100644
index 4ed93ee9..00000000
--- a/packages/tko.utils/src/function.js
+++ /dev/null
@@ -1,17 +0,0 @@
-
-function testOverwrite () {
-  try {
-    Object.defineProperty(function x () {}, 'length', {})
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-export const functionSupportsLengthOverwrite = testOverwrite()
-
-export function overwriteLengthPropertyIfSupported (fn, descriptor) {
-  if (functionSupportsLengthOverwrite) {
-    Object.defineProperty(fn, 'length', descriptor)
-  }
-}
diff --git a/packages/tko.utils/src/function.ts b/packages/tko.utils/src/function.ts
new file mode 100644
index 00000000..24c45acc
--- /dev/null
+++ b/packages/tko.utils/src/function.ts
@@ -0,0 +1,18 @@
+
+function testOverwrite() {
+  try {
+    Object.defineProperty(function x() {}, 'length', {});
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+export const functionSupportsLengthOverwrite = testOverwrite();
+
+// tslint:disable-next-line:ban-types
+export function overwriteLengthPropertyIfSupported(fn: Function, descriptor: PropertyDescriptor & ThisType<any>) {
+  if (functionSupportsLengthOverwrite) {
+    Object.defineProperty(fn, 'length', descriptor);
+  }
+}
diff --git a/packages/tko.utils/src/ie.js b/packages/tko.utils/src/ie.js
deleted file mode 100644
index 0616909f..00000000
--- a/packages/tko.utils/src/ie.js
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Detection and Workarounds for Internet Explorer
-//
-import options from './options'
-
-const ieVersion = options.document && (function () {
-  var version = 3, 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]
-    ) {}
-
-  if (!version) {
-    const userAgent = window.navigator.userAgent
-    // Detect IE 10/11
-    return ua.match(/MSIE ([^ ]+)/) || ua.match(/rv:([^ )]+)/)
-  }
-  return version > 4 ? version : undefined
-}())
-
-const isIe6 = ieVersion === 6
-const isIe7 = ieVersion === 7
-
-export { ieVersion, isIe6, isIe7 }
diff --git a/packages/tko.utils/src/ie.ts b/packages/tko.utils/src/ie.ts
new file mode 100644
index 00000000..9f4a2ffa
--- /dev/null
+++ b/packages/tko.utils/src/ie.ts
@@ -0,0 +1,27 @@
+//
+// Detection and Workarounds for Internet Explorer
+//
+import options from './options';
+
+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
+  do {
+    div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->';
+  }
+  while (iElems[0]);
+
+  if (!version) {
+    const userAgent = window.navigator.userAgent;
+    // Detect IE 10/11
+    return userAgent.match(/MSIE ([^ ]+)/) || userAgent.match(/rv:([^ )]+)/);
+  }
+  return version > 4 ? version : undefined;
+})();
+
+const isIe6 = ieVersion === 6;
+const isIe7 = ieVersion === 7;
+
+export { ieVersion, isIe6, isIe7 };
diff --git a/packages/tko.utils/src/index.js b/packages/tko.utils/src/index.js
deleted file mode 100644
index 19694760..00000000
--- a/packages/tko.utils/src/index.js
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-  tko.util
-  ===
-
-*/
-
-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'
-
-// 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'
-
-// 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'
-
-export {tasks, virtualElements, domData, memoization}
diff --git a/packages/tko.utils/src/index.ts b/packages/tko.utils/src/index.ts
new file mode 100644
index 00000000..8a5e6894
--- /dev/null
+++ b/packages/tko.utils/src/index.ts
@@ -0,0 +1,35 @@
+/*
+  tko.util
+  ===
+
+*/
+
+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';
+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';
+import * as virtualElements from './dom/virtualElements';
+import * as domData from './dom/data';
+
+export {tasks, virtualElements, domData, memoization};
diff --git a/packages/tko.utils/src/jquery.js b/packages/tko.utils/src/jquery.js
deleted file mode 100644
index 10f450fb..00000000
--- a/packages/tko.utils/src/jquery.js
+++ /dev/null
@@ -1,12 +0,0 @@
-//
-// jQuery
-//
-// TODO: deprecate in favour of options.$
-
-import options from './options'
-
-export var jQueryInstance = options.global && options.global.jQuery
-
-export function jQuerySetInstance (jquery) {
-  options.jQuery = jQueryInstance = jquery
-}
diff --git a/packages/tko.utils/src/jquery.ts b/packages/tko.utils/src/jquery.ts
new file mode 100644
index 00000000..7facd852
--- /dev/null
+++ b/packages/tko.utils/src/jquery.ts
@@ -0,0 +1,12 @@
+//
+// jQuery
+//
+// TODO: deprecate in favour of options.$
+
+import options from './options';
+
+export let jQueryInstance = options.jQuery;
+
+export function jQuerySetInstance(jquery: JQueryStatic) {
+  options.jQuery = jQueryInstance = jquery;
+}
diff --git a/packages/tko.utils/src/memoization.js b/packages/tko.utils/src/memoization.js
deleted file mode 100644
index 411c70da..00000000
--- a/packages/tko.utils/src/memoization.js
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// Memoization
-//
-import { arrayPushAll } from './array.js'
-
-var memos = {}
-
-function randomMax8HexChars () {
-  return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1)
-}
-
-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) }
-  }
-}
-
-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 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.") }
-  try {
-    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 parseMemoText (memoText) {
-  var match = memoText.match(/^\[ko_memo\:(.*?)\]$/)
-  return match ? match[1] : null
-}
diff --git a/packages/tko.utils/src/memoization.ts b/packages/tko.utils/src/memoization.ts
new file mode 100644
index 00000000..3ce57288
--- /dev/null
+++ b/packages/tko.utils/src/memoization.ts
@@ -0,0 +1,63 @@
+//
+// Memoization
+//
+import { arrayPushAll } from './array';
+
+// tslint:disable-next-line:ban-types
+type Memo = Function;
+interface IMemo { domNode: Node; memoId: string; }
+
+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 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: 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: 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]; }
+}
+
+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: string|null) {
+  const match = memoText && memoText.match(/^\[ko_memo\:(.*?)\]$/);
+  return match ? match[1] : null;
+}
diff --git a/packages/tko.utils/src/object.js b/packages/tko.utils/src/object.js
deleted file mode 100644
index 6331402a..00000000
--- a/packages/tko.utils/src/object.js
+++ /dev/null
@@ -1,63 +0,0 @@
-//
-// Object functions
-//
-
-export function hasOwnProperty(obj, propName) {
-  return Object.prototype.hasOwnProperty.call(obj, propName)
-}
-
-export function extend (target, source) {
-  if (source) {
-    for (var prop in source) {
-      if (hasOwnProperty(source, prop)) {
-        target[prop] = source[prop]
-      }
-    }
-  }
-  return target
-}
-
-export function objectForEach (obj, action) {
-  for (var prop in obj) {
-    if (hasOwnProperty(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) {
-    if (hasOwnProperty(source, prop)) {
-      target[prop] = mapping(source[prop], prop, source)
-    }
-  }
-  return target
-}
-export function getObjectOwnProperty (obj, propName) {
-  return hasOwnProperty(obj, propName) ? obj[propName] : undefined
-}
-
-export function clonePlainObjectDeep (obj, seen) {
-  if (!seen) { seen = [] }
-
-  if (!obj || typeof obj !== 'object' ||
-        obj.constructor !== Object ||
-        seen.indexOf(obj) !== -1) {
-    return obj
-  }
-
-    // Anything that makes it below is a plain object that has not yet
-    // been seen/cloned.
-  seen.push(obj)
-
-  var result = {}
-  for (var prop in obj) {
-    if (hasOwnProperty(obj, prop)) {
-      result[prop] = clonePlainObjectDeep(obj[prop], seen)
-    }
-  }
-  return result
-}
diff --git a/packages/tko.utils/src/object.ts b/packages/tko.utils/src/object.ts
new file mode 100644
index 00000000..5037fe41
--- /dev/null
+++ b/packages/tko.utils/src/object.ts
@@ -0,0 +1,64 @@
+//
+// Object functions
+//
+
+export function hasOwnProperty(obj: any, propName: string) {
+  return Object.prototype.hasOwnProperty.call(obj, propName) as boolean;
+}
+
+export function extend(target: any, source: any) {
+  if (source) {
+    for (const prop in source) {
+      if (hasOwnProperty(source, prop)) {
+        target[prop] = source[prop];
+      }
+    }
+  }
+  return target;
+}
+
+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]);
+    }
+  }
+}
+
+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);
+    }
+  }
+  return target;
+}
+export function getObjectOwnProperty<TSource>(obj: TSource, propName: keyof TSource) {
+  return hasOwnProperty(obj, propName) ? obj[propName] : undefined;
+}
+
+export function clonePlainObjectDeep(obj: any, seen?: any[]) {
+  if (!seen) { seen = []; }
+
+  if (!obj || typeof obj !== 'object' ||
+        obj.constructor !== Object ||
+        seen.indexOf(obj) !== -1) {
+    return obj;
+  }
+
+    // Anything that makes it below is a plain object that has not yet
+    // been seen/cloned.
+  seen.push(obj);
+
+  const result: any = {};
+  for (const prop in obj) {
+    if (hasOwnProperty(obj, prop)) {
+      result[prop] = clonePlainObjectDeep(obj[prop], seen);
+    }
+  }
+  return result;
+}
diff --git a/packages/tko.utils/src/options.js b/packages/tko.utils/src/options.js
deleted file mode 100644
index ccbeeccd..00000000
--- a/packages/tko.utils/src/options.js
+++ /dev/null
@@ -1,59 +0,0 @@
-//
-// This becomes ko.options
-// --
-//
-// This is the root 'options', which must be extended by others.
-
-var _global
-
-try { _global = window } catch (e) { _global = global }
-
-var options = {
-  deferUpdates: false,
-
-  useOnlyNativeEvents: false,
-
-  protoProperty: '__ko_proto__',
-
-    // Modify the default attribute from `data-bind`.
-  defaultBindingAttribute: 'data-bind',
-
-    // Enable/disable <!-- ko binding: ... -> style bindings
-  allowVirtualElements: true,
-
-    // Global variables that can be accessed from bindings.
-  bindingGlobals: _global,
-
-    // 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,
-
-  Promise: _global && _global.Promise,
-
-  taskScheduler: null,
-
-  debug: false,
-
-  global: _global,
-  document: _global.document,
-
-    // Filters for bindings
-    //   data-bind="expression | filter_1 | filter_2"
-  filters: {},
-
-  onError: function (e) { throw e },
-
-  set: function (name, value) {
-    options[name] = value
-  }
-}
-
-Object.defineProperty(options, '$', {
-  get: function () { return options.jQuery }
-})
-
-export default options
diff --git a/packages/tko.utils/src/options.ts b/packages/tko.utils/src/options.ts
new file mode 100644
index 00000000..ecffdc5b
--- /dev/null
+++ b/packages/tko.utils/src/options.ts
@@ -0,0 +1,87 @@
+//
+// This becomes ko.options
+// --
+//
+// This is the root 'options', which must be extended by others.
+
+// 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;
+}
+
+// tslint:disable-next-line:ban-types
+type TaskScheduler = (callback: Function) => any;
+const taskScheduler = null; // Workaround for typedef
+
+const options = {
+  deferUpdates: false,
+
+  useOnlyNativeEvents: false,
+
+  protoProperty: '__ko_proto__',
+
+  /**
+   * Modify the default attribute from `data-bind`.
+   */
+  defaultBindingAttribute: 'data-bind',
+
+  /**
+   * Enable/disable <!-- ko binding: ... -> style bindings
+   */
+  allowVirtualElements: true,
+
+  /**
+   * Global variables that can be accessed from bindings.
+   */
+  bindingGlobals: _global,
+
+  /**
+   * 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: jq,
+
+  Promise: promise,
+
+  taskScheduler: (taskScheduler as TaskScheduler|null),
+
+  debug: false,
+
+  global: _global,
+  document,
+
+  /**
+   * Filters for bindings
+   *   data-bind="expression | filter_1 | filter_2"
+   */
+  filters: {},
+
+  onError(e: Error) { throw e; },
+
+  set(name: string, value: any) {
+    (options as any)[name] = value;
+  },
+
+  $: jQuery
+};
+
+export default options;
diff --git a/packages/tko.utils/src/proto.js b/packages/tko.utils/src/proto.js
deleted file mode 100644
index 48c1ec6a..00000000
--- a/packages/tko.utils/src/proto.js
+++ /dev/null
@@ -1,16 +0,0 @@
-//
-// Prototype Functions
-//
-import { extend } from './object.js'
-import options from './options.js'
-
-var protoProperty = options.protoProperty
-
-export var canSetPrototype = ({ __proto__: [] } instanceof Array)
-
-export function setPrototypeOf (obj, proto) {
-  obj.__proto__ = proto
-  return obj
-}
-
-export var setPrototypeOfOrExtend = canSetPrototype ? setPrototypeOf : extend
diff --git a/packages/tko.utils/src/proto.ts b/packages/tko.utils/src/proto.ts
new file mode 100644
index 00000000..4f629213
--- /dev/null
+++ b/packages/tko.utils/src/proto.ts
@@ -0,0 +1,16 @@
+//
+// Prototype Functions
+//
+import { extend } from './object.js';
+import options from './options.js';
+
+const protoProperty = options.protoProperty;
+
+export const canSetPrototype = ({ __proto__: [] } instanceof Array);
+
+export function setPrototypeOf(obj: any, proto: any) {
+  obj.__proto__ = proto;
+  return obj;
+}
+
+export const setPrototypeOfOrExtend = canSetPrototype ? setPrototypeOf : extend;
diff --git a/packages/tko.utils/src/string.js b/packages/tko.utils/src/string.js
deleted file mode 100644
index 58b59a52..00000000
--- a/packages/tko.utils/src/string.js
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// 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 stringStartsWith (string, startsWith) {
-  string = string || ''
-  if (startsWith.length > string.length) { return false }
-  return string.substring(0, startsWith.length) === startsWith
-}
-
-export function parseJson (jsonString) {
-  if (typeof jsonString === 'string') {
-    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
-    }
-  }
-  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)
-}
diff --git a/packages/tko.utils/src/string.ts b/packages/tko.utils/src/string.ts
new file mode 100644
index 00000000..1fb16a4a
--- /dev/null
+++ b/packages/tko.utils/src/string.ts
@@ -0,0 +1,35 @@
+//
+// String (and JSON)
+//
+
+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(str: string, startsWith: string) {
+  str = str || '';
+  if (startsWith.length > str.length) { return false; }
+  return str.substring(0, startsWith.length) === startsWith;
+}
+
+export function parseJson(jsonString: string) {
+  if (typeof jsonString === 'string') {
+    jsonString = stringTrim(jsonString);
+    if (jsonString) {
+      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;
+}
+
+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.js b/packages/tko.utils/src/symbol.js
deleted file mode 100644
index 53668136..00000000
--- a/packages/tko.utils/src/symbol.js
+++ /dev/null
@@ -1,9 +0,0 @@
-//
-// ES6 Symbols
-//
-
-export var useSymbols = typeof Symbol === 'function'
-
-export function createSymbolOrString (identifier) {
-  return useSymbols ? Symbol(identifier) : identifier
-}
diff --git a/packages/tko.utils/src/symbol.ts b/packages/tko.utils/src/symbol.ts
new file mode 100644
index 00000000..01253c7b
--- /dev/null
+++ b/packages/tko.utils/src/symbol.ts
@@ -0,0 +1,9 @@
+//
+// ES6 Symbols
+//
+
+export const useSymbols = typeof Symbol === 'function';
+
+export function createSymbolOrString(identifier: any) {
+  return useSymbols ? Symbol(identifier) : identifier;
+}
diff --git a/packages/tko.utils/src/tasks.js b/packages/tko.utils/src/tasks.js
deleted file mode 100644
index dc1290b4..00000000
--- a/packages/tko.utils/src/tasks.js
+++ /dev/null
@@ -1,103 +0,0 @@
-//
-//  Tasks Micro-scheduler
-//  ===
-//
-/* eslint no-cond-assign: 0 */
-import options from './options'
-import { deferError } from './error.js'
-
-var taskQueue = [],
-  taskQueueLength = 0,
-  nextHandle = 1,
-  nextIndexToProcess = 0,
-  w = options.global
-
-if (w && w.MutationObserver && !(w.navigator && w.navigator.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)
-} 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)
-  }
-} else {
-  options.taskScheduler = function (callback) {
-    setTimeout(callback, 0)
-  }
-}
-
-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
-
-        // nextIndexToProcess keeps track of where we are in the queue; processTasks can be called recursively without issue
-    for (var 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
-          }
-          mark = taskQueueLength
-        }
-        try {
-          task()
-        } catch (ex) {
-          deferError(ex)
-        }
-      }
-    }
-  }
-}
-
-function scheduledProcess () {
-  processTasks()
-
-    // Reset the queue
-  nextIndexToProcess = taskQueueLength = taskQueue.length = 0
-}
-
-function scheduleTaskProcessing () {
-  options.taskScheduler(scheduledProcess)
-}
-
-export function schedule (func) {
-  if (!taskQueueLength) {
-    scheduleTaskProcessing()
-  }
-
-  taskQueue[taskQueueLength++] = func
-  return nextHandle++
-}
-
-export function cancel (handle) {
-  var index = handle - (nextHandle - taskQueueLength)
-  if (index >= nextIndexToProcess && index < taskQueueLength) {
-    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 {processTasks as runEarly}
diff --git a/packages/tko.utils/src/tasks.ts b/packages/tko.utils/src/tasks.ts
new file mode 100644
index 00000000..0dee9014
--- /dev/null
+++ b/packages/tko.utils/src/tasks.ts
@@ -0,0 +1,108 @@
+//
+//  Tasks Micro-scheduler
+//  ===
+//
+/* eslint no-cond-assign: 0 */
+import options from './options';
+import { deferError } from './error';
+
+// tslint:disable:ban-types
+type Task = Function;
+
+const taskQueue: Array<Task|null> = [], w = options.global;
+let taskQueueLength = 0,
+  nextHandle = 1,
+  nextIndexToProcess = 0;
+
+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 = ((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 = (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 = (callback: Function) => {
+    setTimeout(callback, 0);
+  };
+}
+
+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.
+    let mark = taskQueueLength, countMarks = 0;
+
+        // nextIndexToProcess keeps track of where we are in the queue; processTasks can be called recursively without issue
+    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;
+          }
+          mark = taskQueueLength;
+        }
+        try {
+          task();
+        } catch (ex) {
+          deferError(ex);
+        }
+      }
+    }
+  }
+}
+
+function scheduledProcess() {
+  processTasks();
+
+    // Reset the queue
+  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
+}
+
+function scheduleTaskProcessing() {
+  options.taskScheduler!(scheduledProcess);
+}
+
+export type TaskHandle = number;
+
+export function schedule(func: Function): TaskHandle {
+  if (!taskQueueLength) {
+    scheduleTaskProcessing();
+  }
+
+  taskQueue[taskQueueLength++] = func;
+  return nextHandle++;
+}
+
+export function cancel(handle: TaskHandle) {
+  const index = handle - (nextHandle - taskQueueLength);
+  if (index >= nextIndexToProcess && index < taskQueueLength) {
+    taskQueue[index] = null;
+  }
+}
+
+// For testing only: reset the queue and return the previous queue length
+export function resetForTesting() {
+  const length = taskQueueLength - nextIndexToProcess;
+  nextIndexToProcess = taskQueueLength = taskQueue.length = 0;
+  return length;
+}
+
+export {processTasks as runEarly};
diff --git a/tsconfig.json b/tsconfig.json
index ab16a324..e1b7c65d 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,8 +2,10 @@
   "compileOnSave": false,
   "compilerOptions": {
     "downlevelIteration": true,
-    "target": "ES3",
+    "target": "ES5",
+    "lib": [ "dom", "es5", "es2015.core", "es2015.collection", "es2015.promise", "es2015.symbol", "es2015.symbol.wellknown", "scripthost" ],
     "module": "ES2015",
+    "moduleResolution": "node",
     "allowJs": true,
     "importHelpers": true,
     "strict": true
diff --git a/tslint.json b/tslint.json
new file mode 100644
index 00000000..406fd033
--- /dev/null
+++ b/tslint.json
@@ -0,0 +1,46 @@
+{
+    "defaultSeverity": "error",
+    "extends": [
+        "tslint:recommended"
+    ],
+    "jsRules": {},
+    "rules": {
+        "arrow-parens": [true, "ban-single-arg-parens"],
+        "quotemark": [true, "single","avoid-template", "avoid-escape"],
+        "object-literal-sort-keys": false,
+        "ordered-imports": [
+            true,
+            {
+                "import-sources-order": "any",
+                "named-imports-order": "any"
+            }
+        ],
+        "member-ordering": false,
+        "max-classes-per-file": [true, 6],
+        "max-line-length": [true, 250],
+        "no-conditional-assignment": false,
+        "no-empty": false,
+        "one-variable-per-declaration": false,
+        "no-console": false,
+        "no-shadowed-variable": false,
+        "trailing-comma": false,
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            },
+            {
+                "call-signature": "onespace",
+                "index-signature": "onespace",
+                "parameter": "onespace",
+                "property-declaration": "onespace",
+                "variable-declaration": "onespace"
+            }
+        ]
+    },
+    "rulesDirectory": []
+}
\ No newline at end of file
diff --git a/yarn.lock b/yarn.lock
index 8dc9782f..9d9b7609 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -6,6 +6,10 @@
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/@comandeer/babel-plugin-banner/-/babel-plugin-banner-1.0.0.tgz#40bcce0bbee084b5b02545a33635d053c248356f"
 
+"@types/jquery@3.3.1":
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/@types/jquery/-/jquery-3.3.1.tgz#55758d44d422756d6329cbf54e6d41931d7ba28f"
+
 "@types/node@^7.0.18":
   version "7.0.46"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-7.0.46.tgz#c3dedd25558c676b3d6303e51799abb9c3f8f314"
@@ -119,6 +123,12 @@ ansi-styles@^3.1.0:
   dependencies:
     color-convert "^1.9.0"
 
+ansi-styles@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  dependencies:
+    color-convert "^1.9.0"
+
 anymatch@^1.3.0:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-1.3.2.tgz#553dcb8f91e3c889845dfdba34c77721b90b9d7a"
@@ -275,7 +285,7 @@ aws4@^1.2.1, aws4@^1.6.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.6.0.tgz#83ef5ca860b2b32e4a0deedee8c771b9db57471e"
 
-babel-code-frame@^6.16.0, babel-code-frame@^6.26.0:
+babel-code-frame@^6.16.0, babel-code-frame@^6.22.0, babel-code-frame@^6.26.0:
   version "6.26.0"
   resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.26.0.tgz#63fd43f7dc1e3bb7ce35947db8fe369a3f58c74b"
   dependencies:
@@ -771,6 +781,14 @@ chalk@^2.0.0, chalk@^2.1.0:
     escape-string-regexp "^1.0.5"
     supports-color "^4.0.0"
 
+chalk@^2.3.0:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.0.tgz#a060a297a6b57e15b61ca63ce84995daa0fe6e52"
+  dependencies:
+    ansi-styles "^3.2.1"
+    escape-string-regexp "^1.0.5"
+    supports-color "^5.3.0"
+
 check-error@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/check-error/-/check-error-1.0.2.tgz#574d312edd88bb5dd8912e9286dd6c0aed4aac82"
@@ -890,6 +908,10 @@ commander@2.11.0:
   version "2.11.0"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.11.0.tgz#157152fd1e7a6c8d98a5b715cf376df928004563"
 
+commander@^2.12.1:
+  version "2.15.1"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.15.1.tgz#df46e867d0fc2aec66a34662b406a9ccafff5b0f"
+
 commander@^2.9.0:
   version "2.12.2"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.12.2.tgz#0f5946c427ed9ec0d91a46bb9def53e54650e555"
@@ -1324,6 +1346,10 @@ diff@^3.1.0:
   version "3.4.0"
   resolved "https://registry.yarnpkg.com/diff/-/diff-3.4.0.tgz#b1d85507daf3964828de54b37d0d73ba67dda56c"
 
+diff@^3.2.0:
+  version "3.5.0"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-3.5.0.tgz#800c0dd1e0a8bfbc95835c202ad220fe317e5a12"
+
 doctrine@1.5.0, doctrine@^1.2.2:
   version "1.5.0"
   resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-1.5.0.tgz#379dce730f6166f76cefa4e6707a159b02c5a6fa"
@@ -2204,6 +2230,10 @@ has-flag@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-2.0.0.tgz#e8207af1cc7b30d446cc70b734b5e8be18f88d51"
 
+has-flag@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+
 has-unicode@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/has-unicode/-/has-unicode-2.0.1.tgz#e0e6fe6a28cf51138855e086d1691e771de2a8b9"
@@ -2636,6 +2666,13 @@ js-yaml@^3.5.1:
     argparse "^1.0.7"
     esprima "^4.0.0"
 
+js-yaml@^3.7.0:
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.11.0.tgz#597c1a8bd57152f26d622ce4117851a51f5ebaef"
+  dependencies:
+    argparse "^1.0.7"
+    esprima "^4.0.0"
+
 jsbn@~0.1.0:
   version "0.1.1"
   resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513"
@@ -3906,6 +3943,12 @@ resolve@^1.1.6, resolve@^1.1.7, resolve@^1.4.0:
   dependencies:
     path-parse "^1.0.5"
 
+resolve@^1.3.2:
+  version "1.7.1"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.7.1.tgz#aadd656374fd298aee895bc026b8297418677fd3"
+  dependencies:
+    path-parse "^1.0.5"
+
 restore-cursor@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541"
@@ -4406,6 +4449,12 @@ supports-color@^4.0.0, supports-color@^4.4.0:
   dependencies:
     has-flag "^2.0.0"
 
+supports-color@^5.3.0:
+  version "5.4.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.4.0.tgz#1c6b337402c2137605efe19f10fec390f6faab54"
+  dependencies:
+    has-flag "^3.0.0"
+
 table@^3.7.8:
   version "3.8.3"
   resolved "https://registry.yarnpkg.com/table/-/table-3.8.3.tgz#2bbc542f0fda9861a755d3947fefd8b3f513855f"
@@ -4553,10 +4602,37 @@ tryit@^1.0.1:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/tryit/-/tryit-1.0.3.tgz#393be730a9446fd1ead6da59a014308f36c289cb"
 
+tslib@1.9.0, tslib@^1.8.1:
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.0.tgz#e37a86fda8cbbaf23a057f473c9f4dc64e5fc2e8"
+
 tslib@^1.8.0:
   version "1.8.0"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.8.0.tgz#dc604ebad64bcbf696d613da6c954aa0e7ea1eb6"
 
+tslint@5.9.1:
+  version "5.9.1"
+  resolved "https://registry.yarnpkg.com/tslint/-/tslint-5.9.1.tgz#1255f87a3ff57eb0b0e1f0e610a8b4748046c9ae"
+  dependencies:
+    babel-code-frame "^6.22.0"
+    builtin-modules "^1.1.1"
+    chalk "^2.3.0"
+    commander "^2.12.1"
+    diff "^3.2.0"
+    glob "^7.1.1"
+    js-yaml "^3.7.0"
+    minimatch "^3.0.4"
+    resolve "^1.3.2"
+    semver "^5.3.0"
+    tslib "^1.8.0"
+    tsutils "^2.12.1"
+
+tsutils@^2.12.1:
+  version "2.26.1"
+  resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-2.26.1.tgz#9e4a0cb9ff173863f34c22a961969081270d1878"
+  dependencies:
+    tslib "^1.8.1"
+
 tunnel-agent@^0.6.0:
   version "0.6.0"
   resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd"