diff --git a/README.md b/README.md
index efba4db..1229b68 100644
--- a/README.md
+++ b/README.md
@@ -40,17 +40,20 @@ console.log(JSON.stringify(patched));
 ### patch
 
 ```js
-var b = jiff.patch(patch, a);
+var b = jiff.patch(patch, a [, options]);
 ```
 
 Given an rfc6902 JSON Patch, apply it to `a` and return a new patched JSON object/array/value.  Patching is atomic, and is performed on a clone of `a`.  Thus, if patching fails mid-patch, `a` will still be in a consistent state.
 
+* `options`
+    * `options.findContext : function(index, array, context) -> number`: **Experimental** function to be called before each change to an array.  It is passed the array and index of the change, *and* a patch context (see [`options.makeContext` below](#diff)).  It should return an adjusted index at which the change will actually be applied. This allows for smart patching of arrays that may have changed since the patch was created.
+
 Throws [InvalidPatchOperationError](#invalidpatchoperationerror) and [TestFailedError](#testfailederror).
 
 ### patchInPlace
 
 ```js
-a = jiff.patchInPlace(patch, a);
+a = jiff.patchInPlace(patch, a [, options]);
 ```
 
 Given an rfc6902 JSON Patch, apply it directly to `a`, *mutating `a`*.
@@ -64,12 +67,18 @@ Throws [InvalidPatchOperationError](#invalidpatchoperationerror) and [TestFailed
 ### diff
 
 ```js
-var patch = jiff.diff(a, b [, hashFunction]);
+var patch = jiff.diff(a, b [, hashFunction | options]);
 ```
 
-Computes and returns a JSON Patch from `a` to `b`: `a` and `b` must be valid JSON objects/arrays/values of the same type. If `patch` is applied to `a`, it will yield `b`.
+Computes and returns a JSON Patch from `a` to `b`: `a` and `b` must be valid JSON objects/arrays/values. If `patch` is applied to `a`, it will yield `b`.
+
+The optional third parameter can be *either* an `options` object (preferably) or a function (deprecated: allowed backward compatibility).
 
-If provided, the optional `hashFunction` will be used to recognize when two objects are the same.  If not provided, `JSON.stringify` will be used.
+* `options`:
+	* `options.hash : function(x) -> string|number`: used to recognize when two objects are the same.  If not provided, `JSON.stringify` will be used for objects and arrays, and simply returns `x` for all other primitive values.
+	* `options.makeContext : function(index, array) -> *`: **Experimental** function that will be called for each item added or removed from an array.  It can return *any* legal JSON value or undefined, which if not `null` or undefined, will be fed directly to the `findContext` function provided to [`jiff.patch`](#patch).
+	* `options.invertible : boolean`: by default, jiff generates patches containing extra `test` operations to ensure they are invertible via [`jiff.inverse`](#inverse).  When `options.invertible === false` will omit the extra `test` operations. This will result in smaller patches, but they will not be invertible.
+* `hashFunction(x) -> string|number`: same as `options.hash` above
 
 While jiff's patch algorithm handles all the JSON Patch operations required by rfc6902, the diff algorithm currently does not generate `move`, or `copy` operations, only `add`, `remove`, and `replace`.
 
@@ -84,7 +93,7 @@ Compute an inverse patch.  Applying the inverse of a patch will undo the effect
 Due to the current JSON Patch format defined in rfc6902, not all patches can be inverted.  To be invertible, a patch must have the following characteristics:
 
 1. Each `remove` and `replace` operation must be preceded by a `test` operation that verifies the `value` at the `path` being removed/replaced.
-2. The patch must *not* contain any `copy` operations.  Read [this discussion](https://github.com/cujojs/jiff/issues/9) to understand why `copy` operations are not (yet) invertible. You can achieve the same effect by using `add` instead of `copy`, albeit potentially at the cost of data size.
+2. The patch must *not* contain any `copy` operations.  Read [this discussion](https://github.com/cujojs/jiff/issues/9) to understand why `copy` operations are not (yet) invertible. You can achieve the same effect by using `add` instead of `copy`, albeit potentially at the cost of increased patch size.
 
 ### clone
 
@@ -94,8 +103,51 @@ var b = jiff.clone(a);
 
 Creates a deep copy of `a`, which must be a valid JSON object/array/value.
 
+**NOTE:** In jiff <= 0.6.x, `jiff.clone` incorrectly caused some ISO Date-formatted strings (eg `"2014-12-03T11:40:16.816Z"`) to be turned into `Date` objects.  Thus, a clone *might not end up as an exact copy*.
+
+As of 0.7.0 `jiff.clone` creates exact copies.
+
+If you have code that depended on that hidden deserialization, *it will break*.  Date deserialization is now the responsibility of the party who parsed the JSON string from which the original object/array/etc. (ie, the one passed to `jiff.clone`) was created.
+
+### Patch context
+
+As of v0.2, `jiff.diff` and `jiff.patch` support [patch contexts](http://en.wikipedia.org/wiki/Diff#Context_format), an extra bit of information carried with each patch operation.  Patch contexts allow smarter patching, especially in the case of arrays, where items may have moved and thus their indices changed.
+
+Using patch contexts can greatly improve patch accuracy for arrays, at the cost of increasing the size of patches.
+
+Patch contexts are entirely opt-in. To use them, you must provide a pair of closely related functions: `makeContext` and `findContext`.  An API for creating default `makeContext` and `findContext` functions is provided in [`jiff/lib/context`](#jifflibcontext), or you can implement your own.
+
+When you supply the optional `makeContext` function to `jiff.diff`, it will be used to generated a context for each change to an array.
+
+Likewise, when you supply the optional `findContext` function to `jiff.patch` (or `jiff.patchInPlace`), it will be used to find adjusted array indices where patches should actually be applied.
+
+The context is opaque, and jiff itself will not attempt to inspect or interpret it: `jiff.diff` will simply add whatever is returned by `makeContext` to patch operations, and `jiff.patch` will simply hand it to `findContext` when it sees a context in a patch operation.
+
+
 ## Experimental APIs
 
+These APIs are still considered experimental, signatures may change.
+
+### jiff/lib/context
+
+```js
+var context = require('jiff/lib/context');
+
+// Create a makeContext function that can be passed to jiff.diff
+var makeContext = context.makeContext(size);
+
+// Create a findContext function that can be passed to jiff.patch
+var findContext = context.makeContextFinder(equals);
+```
+
+Provides simple, but effective default implementations of `makeContext` and `findContext` functions that can be passed to `jiff.diff` and `jiff.patch` to take advantage of smarter array patching.
+
+`context.makeContext(size)` *returns* a function that can be passed as `options.makeContext` to `jiff.diff`.
+	* `size: number` is the number of array items before and after each change to include in the patch.
+
+`context.makeContextFinder(equals)` *returns* a function that can be passed as `options.findContext` to `jiff.patch`.
+	* `equals: function(a, b) -> boolean` a function to compare two array items, must return truthy when `a` and `b` are equal, falsy otherwise.
+
 ### jiff/lib/rebase
 
 ```js
@@ -117,9 +169,9 @@ var [p2c, p1c] = commute(p1, p2);
 ```
 
 Given two patches `p1` and `p2`, which are intended to be applied in the order `p1` then `p2`, transform them so that they can be safely applied in the order `p2c` and then `p1c`.
- 
+
  Commutation is currently *highly experimental*.  It works for patch operations whose path refers to a common array ancestor by transforming array indices.  Operations that share a common object ancestor are simply swapped for now, which is likely not the right thing in most cases!
- 
+
  Commutation does attempt to detect operations that cannot be commuted, and in such cases, will throw a `TypeError`.
 
 ## Errors
diff --git a/bower.json b/bower.json
index 4e3aaba..c680673 100644
--- a/bower.json
+++ b/bower.json
@@ -1,7 +1,7 @@
 {
   "name": "jiff",
   "main": "jiff.js",
-  "version": "0.5.5",
+  "version": "0.7.2",
   "authors": [
     "Brian Cavalier <brian@hovercraftstudios.com>"
   ],
diff --git a/jiff.js b/jiff.js
index 4a1da3a..65669e7 100644
--- a/jiff.js
+++ b/jiff.js
@@ -3,6 +3,7 @@
 /** @author John Hann */
 
 var lcs = require('./lib/lcs');
+var array = require('./lib/array');
 var patch = require('./lib/jsonPatch');
 var inverse = require('./lib/inverse');
 var jsonPointer = require('./lib/jsonPointer');
@@ -19,24 +20,61 @@ exports.InvalidPatchOperationError = require('./lib/InvalidPatchOperationError')
 exports.TestFailedError = require('./lib/TestFailedError');
 exports.PatchNotInvertibleError = require('./lib/PatchNotInvertibleError');
 
+var isValidObject = patch.isValidObject;
+var defaultHash = patch.defaultHash;
+
 /**
  * Compute a JSON Patch representing the differences between a and b.
- * @param {object|array|string|number} a
- * @param {object|array|string|number} b
- * @param {function} hasher hashing function that will be used to
- *  recognize identical objects
+ * @param {object|array|string|number|null} a
+ * @param {object|array|string|number|null} b
+ * @param {?function|?object} options if a function, see options.hash
+ * @param {?function(x:*):String|Number} options.hash used to hash array items
+ *  in order to recognize identical objects, defaults to JSON.stringify
+ * @param {?function(index:Number, array:Array):object} options.makeContext
+ *  used to generate patch context. If not provided, context will not be generated
  * @returns {array} JSON Patch such that patch(diff(a, b), a) ~ b
  */
-function diff(a, b, hasher) {
-	var hash = typeof hasher === 'function' ? hasher : defaultHash;
-	var state = { patch: [], hash: hash };
+function diff(a, b, options) {
+	return appendChanges(a, b, '', initState(options, [])).patch;
+}
 
-	return appendChanges(a, b, '', state).patch.reverse();
+/**
+ * Create initial diff state from the provided options
+ * @param {?function|?object} options @see diff options above
+ * @param {array} patch an empty or existing JSON Patch array into which
+ *  the diff should generate new patch operations
+ * @returns {object} initialized diff state
+ */
+function initState(options, patch) {
+	if(typeof options === 'object') {
+		return {
+			patch: patch,
+			hash: orElse(isFunction, options.hash, defaultHash),
+			makeContext: orElse(isFunction, options.makeContext, defaultContext),
+			invertible: !(options.invertible === false)
+		};
+	} else {
+		return {
+			patch: patch,
+			hash: orElse(isFunction, options, defaultHash),
+			makeContext: defaultContext,
+			invertible: true
+		};
+	}
 }
 
+/**
+ * Given two JSON values (object, array, number, string, etc.), find their
+ * differences and append them to the diff state
+ * @param {object|array|string|number|null} a
+ * @param {object|array|string|number|null} b
+ * @param {string} path
+ * @param {object} state
+ * @returns {Object} updated diff state
+ */
 function appendChanges(a, b, path, state) {
 	if(Array.isArray(a) && Array.isArray(b)) {
-		return appendListChanges(a, b, path, state);
+		return appendArrayChanges(a, b, path, state);
 	}
 
 	if(isValidObject(a) && isValidObject(b)) {
@@ -46,62 +84,108 @@ function appendChanges(a, b, path, state) {
 	return appendValueChanges(a, b, path, state);
 }
 
+/**
+ * Given two objects, find their differences and append them to the diff state
+ * @param {object} o1
+ * @param {object} o2
+ * @param {string} path
+ * @param {object} state
+ * @returns {Object} updated diff state
+ */
 function appendObjectChanges(o1, o2, path, state) {
-	state = Object.keys(o2).reduceRight(function(state, key) {
+	var keys = Object.keys(o2);
+	var patch = state.patch;
+	var i, key;
+
+	for(i=keys.length-1; i>=0; --i) {
+		key = keys[i];
 		var keyPath = path + '/' + encodeSegment(key);
-		if(key in o1) {
+		if(o1[key] !== void 0) {
 			appendChanges(o1[key], o2[key], keyPath, state);
 		} else {
-			state.patch.push({ op: 'add', path: keyPath, value: o2[key] });
+			patch.push({ op: 'add', path: keyPath, value: o2[key] });
 		}
+	}
 
-		return state;
-	}, state);
-
-	return Object.keys(o1).reduceRight(function(state, key) {
-		if(!(key in o2)) {
+	keys = Object.keys(o1);
+	for(i=keys.length-1; i>=0; --i) {
+		key = keys[i];
+		if(o2[key] === void 0) {
 			var p = path + '/' + encodeSegment(key);
-			// remove.value is for monomorphism, not strictly necessary
-			state.patch.push({ op: 'remove', path: p, value: void 0 });
-			state.patch.push({ op: 'test',   path: p, value: o1[key] });
-
+			if(state.invertible) {
+				patch.push({ op: 'test', path: p, value: o1[key] });
+			}
+			patch.push({ op: 'remove', path: p });
 		}
+	}
 
-		return state;
-	}, state);
+	return state;
 }
 
-function appendListChanges(a1, a2, path, state) {
-	var a1hash = a1.map(state.hash);
-	var a2hash = a2.map(state.hash);
+/**
+ * Given two arrays, find their differences and append them to the diff state
+ * @param {array} a1
+ * @param {array} a2
+ * @param {string} path
+ * @param {object} state
+ * @returns {Object} updated diff state
+ */
+function appendArrayChanges(a1, a2, path, state) {
+	var a1hash = array.map(state.hash, a1);
+	var a2hash = array.map(state.hash, a2);
 
 	var lcsMatrix = lcs.compare(a1hash, a2hash);
 
 	return lcsToJsonPatch(a1, a2, path, state, lcsMatrix);
 }
 
+/**
+ * Transform an lcsMatrix into JSON Patch operations and append
+ * them to state.patch, recursing into array elements as necessary
+ * @param {array} a1
+ * @param {array} a2
+ * @param {string} path
+ * @param {object} state
+ * @param {object} lcsMatrix
+ * @returns {object} new state with JSON Patch operations added based
+ *  on the provided lcsMatrix
+ */
 function lcsToJsonPatch(a1, a2, path, state, lcsMatrix) {
+	var offset = 0;
 	return lcs.reduce(function(state, op, i, j) {
-		var last, p;
-		if (op == lcs.REMOVE) {
-			p = path + '/' + j;
+		var last, context;
+		var patch = state.patch;
+		var p = path + '/' + (j + offset);
 
+		if (op === lcs.REMOVE) {
 			// Coalesce adjacent remove + add into replace
-			last = state.patch[state.patch.length-1];
+			last = patch[patch.length-1];
+			context = state.makeContext(j, a1);
+
+			if(state.invertible) {
+				patch.push({ op: 'test', path: p, value: a1[j], context: context });
+			}
+
 			if(last !== void 0 && last.op === 'add' && last.path === p) {
 				last.op = 'replace';
+				last.context = context;
 			} else {
-				state.patch.push({ op: 'remove', path: p, value: void 0 });
+				patch.push({ op: 'remove', path: p, context: context });
 			}
-			state.patch.push({ op: 'test', path: p, value: a1[j] });
 
-		} else if (op == lcs.ADD) {
+			offset -= 1;
+
+		} else if (op === lcs.ADD) {
 			// See https://tools.ietf.org/html/rfc6902#section-4.1
 			// May use either index===length *or* '-' to indicate appending to array
-			state.patch.push({ op: 'add', path: path + '/' + j, value: a2[i] });
+			patch.push({ op: 'add', path: p, value: a2[i],
+				context: state.makeContext(j, a1)
+			});
+
+			offset += 1;
 
 		} else {
-			appendChanges(a1[j], a2[i], path + '/' + j, state);
+			appendChanges(a1[j], a2[i], p, state);
 		}
 
 		return state;
@@ -109,19 +193,48 @@ function lcsToJsonPatch(a1, a2, path, state, lcsMatrix) {
 	}, state, lcsMatrix);
 }
 
+/**
+ * Given two number|string|null values, if they differ, append to diff state
+ * @param {string|number|null} a
+ * @param {string|number|null} b
+ * @param {string} path
+ * @param {object} state
+ * @returns {object} updated diff state
+ */
 function appendValueChanges(a, b, path, state) {
 	if(a !== b) {
+		if(state.invertible) {
+			state.patch.push({ op: 'test', path: path, value: a });
+		}
+
 		state.patch.push({ op: 'replace', path: path, value: b });
-		state.patch.push({ op: 'test',    path: path, value: a });
 	}
 
 	return state;
 }
 
-function defaultHash(x) {
-	return JSON.stringify(x);
+/**
+ * @param {function} predicate
+ * @param {*} x
+ * @param {*} y
+ * @returns {*} x if predicate(x) is truthy, otherwise y
+ */
+function orElse(predicate, x, y) {
+	return predicate(x) ? x : y;
 }
 
-function isValidObject (x) {
-	return x !== null && typeof x === 'object';
+/**
+ * Default patch context generator
+ * @returns {undefined} undefined context
+ */
+function defaultContext() {
+	return void 0;
+}
+
+/**
+ * @param {*} x
+ * @returns {boolean} true if x is a function, false otherwise
+ */
+function isFunction(x) {
+	return typeof x === 'function';
 }
diff --git a/lib/array.js b/lib/array.js
new file mode 100644
index 0000000..0898b84
--- /dev/null
+++ b/lib/array.js
@@ -0,0 +1,54 @@
+/** @license MIT License (c) copyright 2010-2014 original author or authors */
+/** @author Brian Cavalier */
+/** @author John Hann */
+
+exports.cons = cons;
+exports.tail = tail;
+exports.map = map;
+
+/**
+ * Prepend x to a, without mutating a. Faster than a.unshift(x)
+ * @param {*} x
+ * @param {Array} a array-like
+ * @returns {Array} new Array with x prepended
+ */
+function cons(x, a) {
+	var l = a.length;
+	var b = new Array(l+1);
+	b[0] = x;
+	for(var i=0; i<l; ++i) {
+		b[i+1] = a[i];
+	}
+
+	return b;
+}
+
+/**
+ * Create a new Array containing all elements in a, except the first.
+ *  Faster than a.slice(1)
+ * @param {Array} a array-like
+ * @returns {Array} new Array, the equivalent of a.slice(1)
+ */
+function tail(a) {
+	var l = a.length-1;
+	var b = new Array(l);
+	for(var i=0; i<l; ++i) {
+		b[i] = a[i+1];
+	}
+
+	return b;
+}
+
+/**
+ * Map any array-like. Faster than Array.prototype.map
+ * @param {function} f
+ * @param {Array} a array-like
+ * @returns {Array} new Array mapped by f
+ */
+function map(f, a) {
+	var b = new Array(a.length);
+	for(var i=0; i< a.length; ++i) {
+		b[i] = f(a[i]);
+	}
+	return b;
+}
\ No newline at end of file
diff --git a/lib/clone.js b/lib/clone.js
index 52f7234..2c18fa3 100644
--- a/lib/clone.js
+++ b/lib/clone.js
@@ -1,32 +1,49 @@
-var jsonDateRx = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)(Z|([+\-])(\d{2}):(\d{2}))$/;
+/** @license MIT License (c) copyright 2010-2014 original author or authors */
+/** @author Brian Cavalier */
+/** @author John Hann */
 
 /**
- * Create a deep copy of x which must be a value JSON object/array/value
- * @param {object|array|string|number} x object/array/value to clone
- * @returns {object|array|string|number} clone of x
+ * Create a deep copy of x which must be a legal JSON object/array/value
+ * @param {object|array|string|number|null} x object/array/value to clone
+ * @returns {object|array|string|number|null} clone of x
  */
-module.exports = function clone(x) {
-	return JSON.parse(JSON.stringify(x), dateReviver);
-};
+module.exports = clone;
 
-/**
- * Deserialize dates from JSON
- * @param _
- * @param {*} value ISO date string
- * @returns {*|Date} returns parsed Date, or value if value is not a
- *  valid ISO date string
- */
-function dateReviver(_, value) {
-	var match;
-
-	if (typeof value === 'string') {
-		match = jsonDateRx.exec(value);
-		if (match) {
-			return new Date(Date.UTC(
-					+match[1], +match[2] - 1, +match[3], +match[4], +match[5], +match[6])
-			);
-		}
+function clone(x) {
+	if(x == null || typeof x !== 'object') {
+		return x;
+	}
+
+	if (x instanceof String || x instanceof Number || x instanceof Boolean) {
+		return x.valueOf();
+	}
+
+	if(Array.isArray(x)) {
+		return cloneArray(x);
+	}
+
+	return cloneObject(x);
+}
+
+function cloneArray (x) {
+	var l = x.length;
+	var y = new Array(l);
+
+	for (var i = 0; i < l; ++i) {
+		y[i] = clone(x[i]);
+	}
+
+	return y;
+}
+
+function cloneObject (x) {
+	var keys = Object.keys(x);
+	var y = {};
+
+	for (var k, i = 0, l = keys.length; i < l; ++i) {
+		k = keys[i];
+		y[k] = clone(x[k]);
 	}
 
-	return value;
-}
\ No newline at end of file
+	return y;
+}
diff --git a/lib/commutePaths.js b/lib/commutePaths.js
index 4741ced..5766b1b 100644
--- a/lib/commutePaths.js
+++ b/lib/commutePaths.js
@@ -1,7 +1,5 @@
 var jsonPointer = require('./jsonPointer');
 
-var arrayIndexRx = /^(0|[1-9]\d*)$/;
-
 /**
  * commute the patch sequence a,b to b,a
  * @param {object} a patch operation
@@ -66,7 +64,8 @@ function commuteArrayPaths(a, left, b, right) {
 }
 
 function isArrayPath(left, right, index) {
-	return arrayIndexRx.test(left[index]) && arrayIndexRx.test(right[index]);
+	return jsonPointer.isValidArrayIndex(left[index])
+		&& jsonPointer.isValidArrayIndex(right[index]);
 }
 
 /**
diff --git a/lib/context.js b/lib/context.js
new file mode 100644
index 0000000..7f34419
--- /dev/null
+++ b/lib/context.js
@@ -0,0 +1,107 @@
+exports.findPosition = findPosition;
+exports.matchContext = matchContext;
+exports.makeContextFinder = makeContextFinder;
+exports.makeContext = makeContext;
+
+/**
+ * Creates a findContext function that expects a context
+ * { before: [...], after: [...] } containing some number of items before
+ * and after the change.  Uses the provided equals function to compare
+ * array itesm and find the best fit position in the array to
+ * apply the patch.  Uses a similar algorithm to GNU patch.
+ * @param {function(a:*, b:*):boolean} equals return truthy if a and b are equal
+ * @returns {Function} a findContext function that can be passed to jiff.patch
+ */
+function makeContextFinder(equals) {
+	return function(index, array, context) {
+		return findPosition(equals, index, array, context);
+	};
+}
+
+/**
+ * Creates a makeContext function that will generate patch contexts
+ * { before: [...], after: [...] } containing `size` number of items
+ * before and after the change.
+ * @param {number} size max number of items before/after the change to include
+ * @returns {Function} a makeContext function that can be passed to jiff.diff
+ */
+function makeContext(size) {
+	return function (index, array) {
+		return {
+			before: array.slice(Math.max(0, index - size), index),
+			after: array.slice(Math.min(array.length, index + 1), index + size + 1)
+		};
+	};
+}
+
+// TODO: Include removed items in the patch context when patch is a remove
+
+function findPosition (equals, start, array, context) {
+	var index;
+	var before = context.before;
+	var blen = before.length;
+	var bmax = 0;
+	var after = context.after;
+	var amax = after.length;
+
+	while(amax > 0 || bmax < blen) {
+		index = findPositionWith(equals, array, start,
+			before.slice(bmax),
+			after.slice(0, amax));
+
+		if(index >= 0) {
+			return index;
+		}
+
+		bmax = Math.min(blen, bmax+1);
+		amax = Math.max(0, amax-1);
+	}
+
+	return start;
+}
+
+function findPositionWith(equals, array, start, before, after, patch) {
+	var blen = before.length;
+	var b = start-blen;
+
+	var found = false;
+	var i = b;
+
+	while(i >= 0 && !found) {
+		found = matchContext(equals, array, i, i+blen+1, before, after);
+		if(found) {
+			return i + blen;
+		}
+
+		--i;
+	}
+
+	i = start;
+	while(i < array.length && !found) {
+		found = matchContext(equals, array, i-blen, i+1, before, after);
+		if(found) {
+			return i;
+		}
+
+		++i;
+	}
+
+	return -1;
+}
+
+function matchContext(equals, array, b, a, before, after) {
+	var i, l;
+	for(i=0, l=before.length; i<l; ++i) {
+		if(!equals(before[i], array[b+i])) {
+			return false;
+		}
+	}
+
+	for(i=0, l=after.length; i<l; ++i) {
+		if(!equals(after[i], array[a+i])) {
+			return false;
+		}
+	}
+
+	return true;
+}
diff --git a/lib/jsonPatch.js b/lib/jsonPatch.js
index bdefbfd..e42f492 100644
--- a/lib/jsonPatch.js
+++ b/lib/jsonPatch.js
@@ -9,31 +9,60 @@ var InvalidPatchOperationError = require('./InvalidPatchOperationError');
 exports.apply = patch;
 exports.applyInPlace = patchInPlace;
 exports.clone = clone;
+exports.isValidObject = isValidObject;
+exports.defaultHash = defaultHash;
+
+var defaultOptions = {};
 
 /**
  * Apply the supplied JSON Patch to x
  * @param {array} changes JSON Patch
  * @param {object|array|string|number} x object/array/value to patch
+ * @param {object} options
+ * @param {function(index:Number, array:Array, context:object):Number} options.findContext
+ *  function used adjust array indexes for smarty/fuzzy patching, for
+ *  patches containing context
  * @returns {object|array|string|number} patched version of x. If x is
  *  an array or object, it will be mutated and returned. Otherwise, if
  *  x is a value, the new value will be returned.
  */
-function patch(changes, x) {
-	return patchInPlace(changes, clone(x));
+function patch(changes, x, options) {
+	return patchInPlace(changes, clone(x), options);
 }
 
-function patchInPlace(changes, x) {
+function patchInPlace(changes, x, options) {
+	if(!options) {
+		options = defaultOptions;
+	}
+
 	// TODO: Consider throwing if changes is not an array
 	if(!Array.isArray(changes)) {
 		return x;
 	}
 
-	return changes.reduce(function(x, change) {
-		var patch = patches[change.op];
+	var patch, p;
+	for(var i=0; i<changes.length; ++i) {
+		p = changes[i];
+		patch = patches[p.op];
+
 		if(patch === void 0) {
-			throw new InvalidPatchOperationError('invalid op ' + change.op);
+			throw new InvalidPatchOperationError('invalid op ' + JSON.stringify(p));
 		}
 
-		return patch.apply(x, change);
-	}, x);
+		x = patch.apply(x, p, options);
+	}
+
+	return x;
+}
+
+function defaultHash(x) {
+	return isValidObject(x) || isArray(x) ? JSON.stringify(x) : x;
+}
+
+function isValidObject (x) {
+	return x !== null && Object.prototype.toString.call(x) === '[object Object]';
+}
+
+function isArray (x) {
+	return Object.prototype.toString.call(x) === '[object Array]';
 }
diff --git a/lib/jsonPointer.js b/lib/jsonPointer.js
index 5d3b976..74095fe 100644
--- a/lib/jsonPointer.js
+++ b/lib/jsonPointer.js
@@ -12,6 +12,7 @@ exports.contains = contains;
 exports.encodeSegment = encodeSegment;
 exports.decodeSegment = decodeSegment;
 exports.parseArrayIndex = parseArrayIndex;
+exports.isValidArrayIndex = isValidArrayIndex;
 
 // http://tools.ietf.org/html/rfc6901#page-2
 var separator = '/';
@@ -30,9 +31,15 @@ var encodedEscapeRx = /~0/g;
  * return undefined, instead.
  * @param {object|array} x object or array in which to search
  * @param {string} path JSON Pointer string (encoded)
+ * @param {?function(index:Number, array:Array, context:object):Number} findContext
+ *  optional function used adjust array indexes for smarty/fuzzy patching, for
+ *  patches containing context.  If provided, context MUST also be provided.
+ * @param {?{before:Array, after:Array}} context optional patch context for
+ *  findContext to use to adjust array indices.  If provided, findContext MUST
+ *  also be provided.
  * @returns {{target:object|array|number|string, key:string}|undefined}
  */
-function find(x, path) {
+function find(x, path, findContext, context) {
 	if(typeof path !== 'string') {
 		return;
 	}
@@ -47,6 +54,7 @@ function find(x, path) {
 	}
 
 	var parent = x, key;
+	var hasContext = context !== void 0;
 
 	_parse(path, function(segment) {
 		// hm... this seems like it should be if(typeof x === 'undefined')
@@ -55,9 +63,17 @@ function find(x, path) {
 			parent = null;
 			return false;
 		}
-		key = segment;
+
+		if(Array.isArray(x)) {
+			key = hasContext
+				? findIndex(findContext, parseArrayIndex(segment), x, context)
+				: segment === '-' ? segment : parseArrayIndex(segment);
+		} else {
+			key = segment;
+		}
+
 		parent = x;
-		x = x[segment];
+		x = x[key];
 	});
 
 	return parent === null
@@ -104,29 +120,43 @@ function encodeSegment(s) {
 	return s.replace(escapeRx, encodedEscape).replace(separatorRx, encodedSeparator);
 }
 
+var arrayIndexRx = /^(0|[1-9]\d*)$/;
+
 /**
- * Split a JSON Pointer into path segments
- * @param {string} path JSON Pointer string (encoded)
- * @returns {Array}
+ * Return true if s is a valid JSON Pointer array index
+ * @param {String} s
+ * @returns {boolean}
  */
-function split(path) {
-	if(path[0] === separator) {
-		path = path.slice(1);
-	}
-
-	return path.split(separator);
+function isValidArrayIndex(s) {
+	return arrayIndexRx.test(s);
 }
 
-var arrayIndexRx = /^(0|[1-9]\d*)$/;
-
 /**
  * Safely parse a string into a number >= 0. Does not check for decimal numbers
  * @param {string} s numeric string
  * @returns {number} number >= 0
  */
 function parseArrayIndex (s) {
-	if(!arrayIndexRx.test(s)) {
-		throw new SyntaxError('invalid array index ' + s);
+	if(isValidArrayIndex(s)) {
+		return +s;
 	}
-	return +s;
+
+	throw new SyntaxError('invalid array index ' + s);
 }
+
+function findIndex (findContext, start, array, context) {
+	var index = start;
+
+	if(index < 0) {
+		throw new Error('array index out of bounds ' + index);
+	}
+
+	if(context !== void 0 && typeof findContext === 'function') {
+		index = findContext(start, array, context);
+		if(index < 0) {
+			throw new Error('could not find patch context ' + context);
+		}
+	}
+
+	return index;
+}
\ No newline at end of file
diff --git a/lib/lcs.js b/lib/lcs.js
index 838c740..2ee1f0a 100644
--- a/lib/lcs.js
+++ b/lib/lcs.js
@@ -11,8 +11,6 @@ exports.REMOVE = REMOVE = RIGHT = -1;
 exports.ADD    = ADD    = DOWN  =  1;
 exports.EQUAL  = SKIP   = 0;
 
-var skip = { value: 1, type: SKIP };
-
 /**
  * Create an lcs comparison matrix describing the differences
  * between two array-like sequences
@@ -52,7 +50,7 @@ function compare(a, b) {
  * @param {function(result:*, type:number, i:number, j:number)} f
  *  reducer function, where:
  *  - result is the current reduce value,
- *  - type is the type of change: ADD, REMOVE, or EQUAL
+ *  - type is the type of change: ADD, REMOVE, or SKIP
  *  - i is the index of the change location in b
  *  - j is the index of the change location in a
  * @param {*} r initial value
diff --git a/lib/patches.js b/lib/patches.js
index e7e07f9..64dd161 100644
--- a/lib/patches.js
+++ b/lib/patches.js
@@ -3,6 +3,8 @@ var clone = require('./clone');
 var deepEquals = require('./deepEquals');
 var commutePaths = require('./commutePaths');
 
+var array = require('./array');
+
 var TestFailedError = require('./TestFailedError');
 var InvalidPatchOperationError = require('./InvalidPatchOperationError');
 var PatchNotInvertibleError = require('./PatchNotInvertibleError');
@@ -53,11 +55,20 @@ exports.copy = {
  * @throws {TestFailedError} if the test operation fails
  */
 
-function applyTest(x, test) {
-	var pointer = find(x, test.path);
-	var target = pointer.key === void 0 ? pointer.target : pointer.target[pointer.key];
+function applyTest(x, test, options) {
+	var pointer = find(x, test.path, options.findContext, test.context);
+	var target = pointer.target;
+	var index, value;
+
+	if(Array.isArray(target)) {
+		index = parseArrayIndex(pointer.key);
+		//index = findIndex(options.findContext, index, target, test.context);
+		value = target[index];
+	} else {
+		value = pointer.key === void 0 ? pointer.target : pointer.target[pointer.key];
+	}
 
-	if(!deepEquals(target, test.value)) {
+	if(!deepEquals(value, test.value)) {
 		throw new TestFailedError('test failed ' + JSON.stringify(test));
 	}
 
@@ -92,15 +103,18 @@ function commuteTest(test, b) {
  * @param {object|array} x
  * @param {object} change add operation
  */
-function applyAdd(x, change) {
-	var pointer = find(x, change.path);
+function applyAdd(x, change, options) {
+	var pointer = find(x, change.path, options.findContext, change.context);
 
 	if(notFound(pointer)) {
 		throw new InvalidPatchOperationError('path does not exist ' + change.path);
 	}
 
-	var val = typeof change.value === 'object'
-		? clone(change.value) : change.value;
+	if(change.value === void 0) {
+		throw new InvalidPatchOperationError('missing value');
+	}
+
+	var val = clone(change.value);
 
 	// If pointer refers to whole document, replace whole document
 	if(pointer.key === void 0) {
@@ -113,19 +127,15 @@ function applyAdd(x, change) {
 
 function _add(pointer, value) {
 	var target = pointer.target;
-	var index;
 
 	if(Array.isArray(target)) {
 		// '-' indicates 'append' to array
 		if(pointer.key === '-') {
 			target.push(value);
+		} else if (pointer.key > target.length) {
+			throw new InvalidPatchOperationError('target of add outside of array bounds')
 		} else {
-			index = parseArrayIndex(pointer.key);
-			if(index < 0 || index > target.length) {
-				throw new InvalidPatchOperationError('array index out of bounds ' + index);
-			}
-
-			target.splice(index, 0, value);
+			target.splice(pointer.key, 0, value);
 		}
 	} else if(isValidObject(target)) {
 		target[pointer.key] = value;
@@ -135,17 +145,15 @@ function _add(pointer, value) {
 }
 
 function invertAdd(pr, add) {
-	pr.push({
-		op: 'test',
-		path: add.path,
-		value: add.value
-	});
-
-	pr.push({
-		op: 'remove',
-		path: add.path
-	});
-
+	var context = add.context;
+	if(context !== void 0) {
+		context = {
+			before: context.before,
+			after: array.cons(add.value, context.after)
+		}
+	}
+	pr.push({ op: 'test', path: add.path, value: add.value, context: context });
+	pr.push({ op: 'remove', path: add.path, context: context });
 	return 1;
 }
 
@@ -162,15 +170,18 @@ function commuteAddOrCopy(add, b) {
  * @param {object|array} x
  * @param {object} change replace operation
  */
-function applyReplace(x, change) {
-	var pointer = find(x, change.path);
+function applyReplace(x, change, options) {
+	var pointer = find(x, change.path, options.findContext, change.context);
 
 	if(notFound(pointer) || missingValue(pointer)) {
 		throw new InvalidPatchOperationError('path does not exist ' + change.path);
 	}
 
-	var value = typeof change.value === 'object'
-		? clone(change.value) : change.value;
+	if(change.value === void 0) {
+		throw new InvalidPatchOperationError('missing value');
+	}
+
+	var value = clone(change.value);
 
 	// If pointer refers to whole document, replace whole document
 	if(pointer.key === void 0) {
@@ -188,24 +199,22 @@ function applyReplace(x, change) {
 	return x;
 }
 
-function invertReplace(pr, c, i, context) {
-	var prev = context[i-1];
+function invertReplace(pr, c, i, patch) {
+	var prev = patch[i-1];
 	if(prev === void 0 || prev.op !== 'test' || prev.path !== c.path) {
 		throw new PatchNotInvertibleError('cannot invert replace w/o test');
 	}
 
-	pr.push({
-		op: 'test',
-		path: prev.path,
-		value: c.value
-	});
-
-	pr.push({
-		op: 'replace',
-		path: prev.path,
-		value: prev.value
-	});
+	var context = prev.context;
+	if(context !== void 0) {
+		context = {
+			before: context.before,
+			after: array.cons(prev.value, array.tail(context.after))
+		}
+	}
 
+	pr.push({ op: 'test', path: prev.path, value: c.value });
+	pr.push({ op: 'replace', path: prev.path, value: prev.value });
 	return 2;
 }
 
@@ -226,8 +235,8 @@ function commuteReplace(replace, b) {
  * @param {object|array} x
  * @param {object} change remove operation
  */
-function applyRemove(x, change) {
-	var pointer = find(x, change.path);
+function applyRemove(x, change, options) {
+	var pointer = find(x, change.path, options.findContext, change.context);
 
 	// key must exist for remove
 	if(notFound(pointer) || pointer.target[pointer.key] === void 0) {
@@ -256,18 +265,21 @@ function _remove (pointer) {
 	}
 }
 
-function invertRemove(pr, c, i, context) {
-	var prev = context[i-1];
+function invertRemove(pr, c, i, patch) {
+	var prev = patch[i-1];
 	if(prev === void 0 || prev.op !== 'test' || prev.path !== c.path) {
 		throw new PatchNotInvertibleError('cannot invert remove w/o test');
 	}
 
-	pr.push({
-		op: 'add',
-		path: prev.path,
-		value: prev.value
-	});
+	var context = prev.context;
+	if(context !== void 0) {
+		context = {
+			before: context.before,
+			after: array.tail(context.after)
+		}
+	}
 
+	pr.push({ op: 'add', path: prev.path, value: prev.value, context: context });
 	return 2;
 }
 
@@ -284,25 +296,22 @@ function commuteRemove(remove, b) {
  * @param {object|array} x
  * @param {object} change move operation
  */
-function applyMove(x, change) {
+function applyMove(x, change, options) {
 	if(jsonPointer.contains(change.path, change.from)) {
 		throw new InvalidPatchOperationError('move.from cannot be ancestor of move.path');
 	}
 
-	var pto = find(x, change.path);
-	var pfrom = find(x, change.from);
+	var pto = find(x, change.path, options.findContext, change.context);
+	var pfrom = find(x, change.from, options.findContext, change.fromContext);
 
 	_add(pto, _remove(pfrom));
 	return x;
 }
 
 function invertMove(pr, c) {
-	pr.push({
-		op: 'move',
-		path: c.from,
-		from: c.path
-	});
-
+	pr.push({ op: 'move',
+		path: c.from, context: c.fromContext,
+		from: c.path, fromContext: c.context });
 	return 1;
 }
 
@@ -319,11 +328,24 @@ function commuteMove(move, b) {
  * @param {object|array} x
  * @param {object} change copy operation
  */
-function applyCopy(x, change) {
-	var pto = find(x, change.path, true);
-	var pfrom = find(x, change.from);
+function applyCopy(x, change, options) {
+	var pto = find(x, change.path, options.findContext, change.context);
+	var pfrom = find(x, change.from, options.findContext, change.fromContext);
+
+	if(notFound(pfrom) || missingValue(pfrom)) {
+		throw new InvalidPatchOperationError('copy.from must exist');
+	}
+
+	var target = pfrom.target;
+	var value;
 
-	_add(pto, clone(pfrom.target[pfrom.key]));
+	if(Array.isArray(target)) {
+		value = target[parseArrayIndex(pfrom.key)];
+	} else {
+		value = target[pfrom.key];
+	}
+
+	_add(pto, clone(value));
 	return x;
 }
 
@@ -334,7 +356,8 @@ function applyCopy(x, change) {
 // However, that's not correct.  It violates the involution:
 // invert(invert(p)) ~= p.  For example:
 // invert(copy) -> remove
-// invert(remove) -> add (DOH! this should be copy!)
+// invert(remove) -> add
+// thus: invert(invert(copy)) -> add (DOH! this should be copy!)
 
 function notInvertible(_, c) {
 	throw new PatchNotInvertibleError('cannot invert ' + c.op);
@@ -348,7 +371,6 @@ function missingValue(pointer) {
 	return pointer.key !== void 0 && pointer.target[pointer.key] === void 0;
 }
 
-
 /**
  * Return true if x is a non-null object
  * @param {*} x
diff --git a/package.json b/package.json
index 4b61d2e..ffeaabf 100644
--- a/package.json
+++ b/package.json
@@ -1,8 +1,9 @@
 {
   "name": "jiff",
-  "version": "0.5.5",
+  "version": "0.7.3",
   "description": "JSON diff and patch based on rfc6902",
   "main": "jiff",
+  "jsdelivr": "./jiff.js",
   "scripts": {
     "test": "buster-test -e node"
   },
@@ -17,9 +18,10 @@
   "author": "brian@hovercraftstudios.com",
   "license": "MIT",
   "devDependencies": {
-    "jshint": "~2",
     "buster": "~0.7",
-    "gent": "0.6.2"
+    "gent": "0.6.2",
+    "jshint": "~2",
+    "json-patch-test-suite": "^1.0.1"
   },
   "repository": {
     "type": "git",
diff --git a/perf/diff.js b/perf/diff.js
new file mode 100644
index 0000000..a41becf
--- /dev/null
+++ b/perf/diff.js
@@ -0,0 +1,51 @@
+var jiff = require('../jiff');
+var json = require('gent/generator/json');
+
+
+var n = 4;
+var o = json.object(8);
+var a = makeArray(o, 1, 1000);
+
+test(a);
+
+var start = Date.now();
+for(var i=0; i<n; ++i) {
+	test(a);
+}
+console.log((Date.now() - start) / n);
+
+function test(array) {
+	return testPatch(testDiff(array), array);
+}
+
+function testDiff(array) {
+	return jiff.diff(array, modify(array), byId);
+}
+
+function testPatch (patch, array) {
+	return jiff.patch(patch, array);
+}
+
+function modify(array) {
+	var a2 = array.slice();
+	a2.splice(Math.floor(a2.length/2), Math.min(10, a2.length));
+	return a2.concat(makeArray(o, array.length+1, 2));
+}
+
+function makeArray(o, id, n) {
+	var a = new Array(n);
+	for(var i=0; i<n; ++i) {
+		a[i] = getObject(o, id++);
+	}
+	return a;
+}
+
+function getObject(o, id) {
+	var x = o.next().value;
+	x.id = id;
+	return JSON.parse(JSON.stringify(x));
+}
+
+function byId(x) {
+	return x.id || JSON.stringify(x);
+}
\ No newline at end of file
diff --git a/test/jiff-test.js b/test/jiff-test.js
index 7bef8bf..14fd84a 100644
--- a/test/jiff-test.js
+++ b/test/jiff-test.js
@@ -1,6 +1,7 @@
 var buster = require('buster');
 require('gent/test-adapter/buster');
 var assert = buster.referee.assert;
+var refute = buster.referee.refute;
 var gent = require('gent');
 var json = require('gent/generator/json');
 var deepEquals = require('../lib/deepEquals');
@@ -49,6 +50,38 @@ buster.testCase('jiff', {
 				json.array(1, json.object()),
 				json.array(1, json.object())
 			);
+		},
+
+		'for arrays of arrays': function() {
+			assert(deepEqualAfterDiffPatch()(
+				[['a'],['b'],['c']],
+				[['b']]
+			));
+
+			assert(deepEqualAfterDiffPatch()(
+				[['a']],
+				[['b']]
+			));
+
+			assert(deepEqualAfterDiffPatch()(
+				[['a'],['b'],['c']],
+				[['d']]
+			));
+
+			assert(deepEqualAfterDiffPatch()(
+				[['b']],
+				[['a'],['b'],['c']]
+			));
+
+			assert(deepEqualAfterDiffPatch()(
+				[['d']],
+				[['a'],['b'],['c']]
+			));
+
+			assert.claim(deepEqualAfterDiffPatch(),
+				json.array(1, json.array()),
+				json.array(1, json.array())
+			);
 		}
 	},
 
@@ -59,6 +92,68 @@ buster.testCase('jiff', {
 				assert.equals(patch[0].op, 'add');
 				assert(patch[0].path === '/-' || patch[0].path === '/0');
 				assert.same(patch[0].value, 1);
+			},
+			'with default hash function': {
+				'primitives as elements': {
+					'should generate an empty patch when elements are equal': function() {
+						var patch = jiff.diff([1,'a',true], [1,'a',true]);
+						assert.equals(patch.length, 0);
+					}
+				},
+				'arrays as elements': {
+					'should generate an empty patch when elements are equal': function() {
+						var patch = jiff.diff([['a'],['b'],['c']], [['a'],['b'],['c']]);
+						assert.equals(patch.length, 0);
+					}
+				},
+				'objects as elements': {
+					'object keys with consistent order': {
+						'should generate an empty patch when elements are equal': function() {
+							var patch = jiff.diff([{a:'a',b:'b',c:'c'}], [{a:'a',b:'b',c:'c'}]);
+							assert.equals(patch.length, 0);
+						}
+					},
+					'object keys with inconsistent order': {
+						'should generate a non empty patch even though elements are equal': function() {
+							var patch = jiff.diff([{b:'b',c:'c',a:'a'}], [{a:'a',b:'b',c:'c'}]);
+							refute.equals(patch.length, 0);
+						}
+					}
+				}
+			}
+		},
+
+		'invertible': {
+			'when false': {
+				'should not generate extra test ops for array remove': function() {
+					var patch = jiff.diff([1,2,3], [1,3], { invertible: false });
+					assert.equals(patch.length, 1);
+					assert.equals(patch[0].op, 'remove');
+				},
+
+				'should not generate extra test ops for object remove': function() {
+					var patch = jiff.diff({ foo: 1 }, {}, { invertible: false });
+					assert.equals(patch.length, 1);
+					assert.equals(patch[0].op, 'remove');
+				},
+
+				'should not generate extra test ops for replace': function() {
+					var patch = jiff.diff({ foo: 1 }, { foo: 2 }, { invertible: false });
+					assert.equals(patch.length, 1);
+					assert.equals(patch[0].op, 'replace');
+				}
+			}
+		},
+
+		'on mixed types': {
+			'should generate replace': function() {
+				var a = { 'test': ['x'] };
+				var b = { 'test': { 'a': "x" } };
+
+				var patch = jiff.diff(a, b, { invertible: false });
+				assert.equals(patch.length, 1);
+				assert.equals(patch[0].op, 'replace');
+				assert.equals(b, jiff.patch(patch, a));
 			}
 		}
 	}
diff --git a/test/json-patch-tests-test.js b/test/json-patch-tests-test.js
index 23f381a..62fc60a 100644
--- a/test/json-patch-tests-test.js
+++ b/test/json-patch-tests-test.js
@@ -4,8 +4,8 @@ var deepEquals = require('../lib/deepEquals');
 
 var jsonPatch = require('../lib/jsonPatch');
 
-var specTests = require('./json-patch-tests/spec_tests.json');
-var tests = require('./json-patch-tests/tests.json');
+var specTests = require('json-patch-test-suite/spec_tests.json');
+var tests = require('json-patch-test-suite/tests.json');
 
 buster.testCase('json-patch-tests', {
 	'spec_tests.json': jsonToBuster(specTests),
diff --git a/test/json-patch-tests/README.md b/test/json-patch-tests/README.md
deleted file mode 100644
index 2ec7aa1..0000000
--- a/test/json-patch-tests/README.md
+++ /dev/null
@@ -1,50 +0,0 @@
-JSON Patch Tests
-================
-
-These are test cases for implementations of the [IETF JSON Patch
-draft](http://tools.ietf.org/html/draft-ietf-appsawg-json-patch).
-
-
-Test Format
------------
-
-Each test file is a JSON document that contains an array of test records. A
-test record is an object with the following members:
-
-- doc: The JSON document to test against
-- patch: The patch(es) to apply
-- expected: The expected resulting document, OR
-- error: A string describing an expected error
-- comment: A string describing the test
-- disabled: True if the test should be skipped
-
-All fields except 'doc' and 'patch' are optional. Test records consisting only
-of a comment are also OK.
-
-These tests are not complete, or even correct - help welcome!
-
-
-Credits
--------
-
-The seed test set was adapted from Byron Ruth's
-[jsonpatch-js](https://github.com/bruth/jsonpatch-js/blob/master/test.js) and
-extended by [Mike McCabe](https://github.com/mikemccabe).
-
-
-License
--------
-
-   Copyright 2012 The Authors
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
\ No newline at end of file
diff --git a/test/json-patch-tests/spec_tests.json b/test/json-patch-tests/spec_tests.json
deleted file mode 100644
index 8380915..0000000
--- a/test/json-patch-tests/spec_tests.json
+++ /dev/null
@@ -1,232 +0,0 @@
-[
-  {
-    "comment": "4.1. add with missing object",
-    "doc": { "q": { "bar": 2 } },
-    "patch": [ {"op": "add", "path": "/a/b", "value": 1} ],
-    "error":
-       "path /a does not exist -- missing objects are not created recursively"
-  },
-
-  {
-    "comment": "A.1.  Adding an Object Member",
-    "doc": {
-  "foo": "bar"
-},
-    "patch": [
-  { "op": "add", "path": "/baz", "value": "qux" }
-],
-    "expected": {
-  "baz": "qux",
-  "foo": "bar"
-}
-  },
-
-  {
-    "comment": "A.2.  Adding an Array Element",
-    "doc": {
-  "foo": [ "bar", "baz" ]
-},
-    "patch": [
-  { "op": "add", "path": "/foo/1", "value": "qux" }
-],
-    "expected": {
-  "foo": [ "bar", "qux", "baz" ]
-}
-  },
-
-  {
-    "comment": "A.3.  Removing an Object Member",
-    "doc": {
-  "baz": "qux",
-  "foo": "bar"
-},
-    "patch": [
-  { "op": "remove", "path": "/baz" }
-],
-    "expected": {
-  "foo": "bar"
-}
-  },
-
-  {
-    "comment": "A.4.  Removing an Array Element",
-    "doc": {
-  "foo": [ "bar", "qux", "baz" ]
-},
-    "patch": [
-  { "op": "remove", "path": "/foo/1" }
-],
-    "expected": {
-  "foo": [ "bar", "baz" ]
-}
-  },
-
-  {
-    "comment": "A.5.  Replacing a Value",
-    "doc": {
-  "baz": "qux",
-  "foo": "bar"
-},
-    "patch": [
-  { "op": "replace", "path": "/baz", "value": "boo" }
-],
-    "expected": {
-  "baz": "boo",
-  "foo": "bar"
-}
-  },
-
-  {
-    "comment": "A.6.  Moving a Value",
-    "doc": {
-  "foo": {
-    "bar": "baz",
-    "waldo": "fred"
-  },
-  "qux": {
-    "corge": "grault"
-  }
-},
-    "patch": [
-  { "op": "move", "from": "/foo/waldo", "path": "/qux/thud" }
-],
-    "expected": {
-  "foo": {
-    "bar": "baz"
-  },
-  "qux": {
-    "corge": "grault",
-    "thud": "fred"
-  }
-}
-  },
-
-  {
-    "comment": "A.7.  Moving an Array Element",
-    "doc": {
-  "foo": [ "all", "grass", "cows", "eat" ]
-},
-    "patch": [
-  { "op": "move", "from": "/foo/1", "path": "/foo/3" }
-],
-    "expected": {
-  "foo": [ "all", "cows", "eat", "grass" ]
-}
-
-  },
-
-  {
-    "comment": "A.8.  Testing a Value: Success",
-    "doc": {
-  "baz": "qux",
-  "foo": [ "a", 2, "c" ]
-},
-    "patch": [
-  { "op": "test", "path": "/baz", "value": "qux" },
-  { "op": "test", "path": "/foo/1", "value": 2 }
-],
-    "expected": {
-     "baz": "qux",
-     "foo": [ "a", 2, "c" ]
-    }
-  },
-
-  {
-    "comment": "A.9.  Testing a Value: Error",
-    "doc": {
-  "baz": "qux"
-},
-    "patch": [
-  { "op": "test", "path": "/baz", "value": "bar" }
-],
-    "error": "string not equivalent"
-  },
-
-  {
-    "comment": "A.10.  Adding a nested Member Object",
-    "doc": {
-  "foo": "bar"
-},
-    "patch": [
-  { "op": "add", "path": "/child", "value": { "grandchild": { } } }
-],
-    "expected": {
-  "foo": "bar",
-  "child": {
-    "grandchild": {
-    }
-  }
-}
-  },
-
-  {
-    "comment": "A.11.  Ignoring Unrecognized Elements",
-    "doc": {
-  "foo":"bar"
-},
-    "patch": [
-  { "op": "add", "path": "/baz", "value": "qux", "xyz": 123 }
-],
-    "expected": {
-  "foo":"bar",
-  "baz":"qux"
-}
-  },
-
- {
-    "comment": "A.12.  Adding to a Non-existant Target",
-    "doc": {
-  "foo": "bar"
-},
-    "patch": [
-  { "op": "add", "path": "/baz/bat", "value": "qux" }
-],
-    "error": "add to a non-existant target"
-  },
-
- {
-    "comment": "A.13 Invalid JSON Patch Document",
-    "doc": {
-     "foo": "bar"
-    },
-    "patch": [
-  { "op": "add", "path": "/baz", "value": "qux", "op": "remove" }
-],
-    "error": "operation has two 'op' members"
-  },
-
-  {
-    "comment": "A.14. ~ Escape Ordering",
-    "doc": {
-       "/": 9,
-       "~1": 10
-    },
-    "patch": [{"op": "test", "path": "/~01", "value": 10}],
-    "expected": {
-       "/": 9,
-       "~1": 10
-    }
-  },
-
-  {
-    "comment": "A.15. Comparing Strings and Numbers",
-    "doc": {
-       "/": 9,
-       "~1": 10
-    },
-    "patch": [{"op": "test", "path": "/~01", "value": "10"}],
-    "error": "number is not equal to string"
-  },
-
-  {
-    "comment": "A.16. Adding an Array Value",
-    "doc": {
-       "foo": ["bar"]
-    },
-    "patch": [{ "op": "add", "path": "/foo/-", "value": ["abc", "def"] }],
-    "expected": {
-      "foo": ["bar", ["abc", "def"]]
-    }
-  }
-
-]
diff --git a/test/json-patch-tests/tests.json b/test/json-patch-tests/tests.json
deleted file mode 100644
index e604d1c..0000000
--- a/test/json-patch-tests/tests.json
+++ /dev/null
@@ -1,303 +0,0 @@
-[
-    { "comment": "empty list, empty docs",
-      "doc": {},
-      "patch": [],
-      "expected": {} },
-
-    { "comment": "empty patch list",
-      "doc": {"foo": 1},
-      "patch": [],
-      "expected": {"foo": 1} },
-
-    { "comment": "rearrangements OK?",
-      "doc": {"foo": 1, "bar": 2},
-      "patch": [],
-      "expected": {"bar":2, "foo": 1} },
-
-    { "comment": "rearrangements OK?  How about one level down ... array",
-      "doc": [{"foo": 1, "bar": 2}],
-      "patch": [],
-      "expected": [{"bar":2, "foo": 1}] },
-
-    { "comment": "rearrangements OK?  How about one level down...",
-      "doc": {"foo":{"foo": 1, "bar": 2}},
-      "patch": [],
-      "expected": {"foo":{"bar":2, "foo": 1}} },
-
-    { "comment": "add replaces any existing field",
-      "doc": {"foo": null},
-      "patch": [{"op": "add", "path": "/foo", "value":1}],
-      "expected": {"foo": 1} },
-
-    { "comment": "toplevel array",
-      "doc": [],
-      "patch": [{"op": "add", "path": "/0", "value": "foo"}],
-      "expected": ["foo"] },
-
-    { "comment": "toplevel array, no change",
-      "doc": ["foo"],
-      "patch": [],
-      "expected": ["foo"] },
-
-    { "comment": "toplevel object, numeric string",
-      "doc": {},
-      "patch": [{"op": "add", "path": "/foo", "value": "1"}],
-      "expected": {"foo":"1"} },
-
-    { "comment": "toplevel object, integer",
-      "doc": {},
-      "patch": [{"op": "add", "path": "/foo", "value": 1}],
-      "expected": {"foo":1} },
-
-    { "comment": "Toplevel scalar values OK?",
-      "doc": "foo",
-      "patch": [{"op": "replace", "path": "", "value": "bar"}],
-      "expected": "bar",
-      "disabled": true },
-
-    { "comment": "Add, / target",
-      "doc": {},
-      "patch": [ {"op": "add", "path": "/", "value":1 } ],
-      "expected": {"":1} },
-
-    { "comment": "Add composite value at top level",
-      "doc": {"foo": 1},
-      "patch": [{"op": "add", "path": "/bar", "value": [1, 2]}],
-      "expected": {"foo": 1, "bar": [1, 2]} },
-
-    { "comment": "Add into composite value",
-      "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
-      "patch": [{"op": "add", "path": "/baz/0/foo", "value": "world"}],
-      "expected": {"foo": 1, "baz": [{"qux": "hello", "foo": "world"}]} },
-
-    { "doc": {"bar": [1, 2]},
-      "patch": [{"op": "add", "path": "/bar/8", "value": "5"}],
-      "error": "Out of bounds (upper)" },
-
-    { "doc": {"bar": [1, 2]},
-      "patch": [{"op": "add", "path": "/bar/-1", "value": "5"}],
-      "error": "Out of bounds (lower)" },
-
-    { "doc": {"foo": 1},
-      "patch": [{"op": "add", "path": "/bar", "value": true}],
-      "expected": {"foo": 1, "bar": true} },
-
-    { "doc": {"foo": 1},
-      "patch": [{"op": "add", "path": "/bar", "value": false}],
-      "expected": {"foo": 1, "bar": false} },
-
-    { "doc": {"foo": 1},
-      "patch": [{"op": "add", "path": "/bar", "value": null}],
-      "expected": {"foo": 1, "bar": null} },
-
-    { "comment": "0 can be an array index or object element name",
-      "doc": {"foo": 1},
-      "patch": [{"op": "add", "path": "/0", "value": "bar"}],
-      "expected": {"foo": 1, "0": "bar" } },
-
-    { "doc": ["foo"],
-      "patch": [{"op": "add", "path": "/1", "value": "bar"}],
-      "expected": ["foo", "bar"] },
-
-    { "doc": ["foo", "sil"],
-      "patch": [{"op": "add", "path": "/1", "value": "bar"}],
-      "expected": ["foo", "bar", "sil"] },
-
-    { "doc": ["foo", "sil"],
-      "patch": [{"op": "add", "path": "/0", "value": "bar"}],
-      "expected": ["bar", "foo", "sil"] },
-
-    { "doc": ["foo", "sil"],
-      "patch": [{"op":"add", "path": "/2", "value": "bar"}],
-      "expected": ["foo", "sil", "bar"] },
-
-    { "comment": "test against implementation-specific numeric parsing",
-      "doc": {"1e0": "foo"},
-      "patch": [{"op": "test", "path": "/1e0", "value": "foo"}],
-      "expected": {"1e0": "foo"} },
-
-    { "comment": "test with bad number should fail",
-      "doc": ["foo", "bar"],
-      "patch": [{"op": "test", "path": "/1e0", "value": "bar"}],
-      "error": "test op shouldn't get array element 1" },
-
-    { "doc": ["foo", "sil"],
-      "patch": [{"op": "add", "path": "/bar", "value": 42}],
-      "error": "Object operation on array target" },
-
-    { "doc": ["foo", "sil"],
-      "patch": [{"op": "add", "path": "/1", "value": ["bar", "baz"]}],
-      "expected": ["foo", ["bar", "baz"], "sil"],
-      "comment": "value in array add not flattened" },
-
-    { "doc": {"foo": 1, "bar": [1, 2, 3, 4]},
-      "patch": [{"op": "remove", "path": "/bar"}],
-      "expected": {"foo": 1} },
-
-    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
-      "patch": [{"op": "remove", "path": "/baz/0/qux"}],
-      "expected": {"foo": 1, "baz": [{}]} },
-
-    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
-      "patch": [{"op": "replace", "path": "/foo", "value": [1, 2, 3, 4]}],
-      "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]} },
-
-    { "doc": {"foo": [1, 2, 3, 4], "baz": [{"qux": "hello"}]},
-      "patch": [{"op": "replace", "path": "/baz/0/qux", "value": "world"}],
-      "expected": {"foo": [1, 2, 3, 4], "baz": [{"qux": "world"}]} },
-
-    { "doc": ["foo"],
-      "patch": [{"op": "replace", "path": "/0", "value": "bar"}],
-      "expected": ["bar"] },
-
-    { "doc": [""],
-      "patch": [{"op": "replace", "path": "/0", "value": 0}],
-      "expected": [0] },
-
-    { "doc": [""],
-      "patch": [{"op": "replace", "path": "/0", "value": true}],
-      "expected": [true] },
-
-    { "doc": [""],
-      "patch": [{"op": "replace", "path": "/0", "value": false}],
-      "expected": [false] },
-
-    { "doc": [""],
-      "patch": [{"op": "replace", "path": "/0", "value": null}],
-      "expected": [null] },
-
-    { "doc": ["foo", "sil"],
-      "patch": [{"op": "replace", "path": "/1", "value": ["bar", "baz"]}],
-      "expected": ["foo", ["bar", "baz"]],
-      "comment": "value in array replace not flattened" },
-
-    { "comment": "replace whole document",
-      "doc": {"foo": "bar"},
-      "patch": [{"op": "replace", "path": "", "value": {"baz": "qux"}}],
-      "expected": {"baz": "qux"} },
-
-    { "comment": "spurious patch properties",
-      "doc": {"foo": 1},
-      "patch": [{"op": "test", "path": "/foo", "value": 1, "spurious": 1}],
-      "expected": {"foo": 1} },
-
-    { "doc": {"foo": null},
-      "patch": [{"op": "test", "path": "/foo", "value": null}],
-      "comment": "null value should still be valid obj property" },
-
-    { "doc": {"foo": {"foo": 1, "bar": 2}},
-      "patch": [{"op": "test", "path": "/foo", "value": {"bar": 2, "foo": 1}}],
-      "comment": "test should pass despite rearrangement" },
-
-    { "doc": {"foo": [{"foo": 1, "bar": 2}]},
-      "patch": [{"op": "test", "path": "/foo", "value": [{"bar": 2, "foo": 1}]}],
-      "comment": "test should pass despite (nested) rearrangement" },
-
-    { "doc": {"foo": {"bar": [1, 2, 5, 4]}},
-      "patch": [{"op": "test", "path": "/foo", "value": {"bar": [1, 2, 5, 4]}}],
-      "comment": "test should pass - no error" },
-
-    { "doc": {"foo": {"bar": [1, 2, 5, 4]}},
-      "patch": [{"op": "test", "path": "/foo", "value": [1, 2]}],
-      "error": "test op should fail" },
-
-    { "comment": "Whole document",
-      "doc": { "foo": 1 },
-      "patch": [{"op": "test", "path": "", "value": {"foo": 1}}],
-      "disabled": true },
-
-    { "comment": "Empty-string element",
-      "doc": { "": 1 },
-      "patch": [{"op": "test", "path": "/", "value": 1}] },
-
-    { "doc": {
-            "foo": ["bar", "baz"],
-            "": 0,
-            "a/b": 1,
-            "c%d": 2,
-            "e^f": 3,
-            "g|h": 4,
-            "i\\j": 5,
-            "k\"l": 6,
-            " ": 7,
-            "m~n": 8
-            },
-      "patch": [{"op": "test", "path": "/foo", "value": ["bar", "baz"]},
-                {"op": "test", "path": "/foo/0", "value": "bar"},
-                {"op": "test", "path": "/", "value": 0},
-                {"op": "test", "path": "/a~1b", "value": 1},
-                {"op": "test", "path": "/c%d", "value": 2},
-                {"op": "test", "path": "/e^f", "value": 3},
-                {"op": "test", "path": "/g|h", "value": 4},
-                {"op": "test", "path":  "/i\\j", "value": 5},
-                {"op": "test", "path": "/k\"l", "value": 6},
-                {"op": "test", "path": "/ ", "value": 7},
-                {"op": "test", "path": "/m~0n", "value": 8}] },
-
-    { "comment": "Move to same location has no effect",
-      "doc": {"foo": 1},
-      "patch": [{"op": "move", "from": "/foo", "path": "/foo"}],
-      "expected": {"foo": 1} },
-
-    { "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
-      "patch": [{"op": "move", "from": "/foo", "path": "/bar"}],
-      "expected": {"baz": [{"qux": "hello"}], "bar": 1} },
-
-    { "doc": {"baz": [{"qux": "hello"}], "bar": 1},
-      "patch": [{"op": "move", "from": "/baz/0/qux", "path": "/baz/1"}],
-      "expected": {"baz": [{}, "hello"], "bar": 1} },
-
-    { "doc": {"baz": [{"qux": "hello"}], "bar": 1},
-      "patch": [{"op": "copy", "from": "/baz/0", "path": "/boo"}],
-      "expected": {"baz":[{"qux":"hello"}],"bar":1,"boo":{"qux":"hello"}} },
-
-    { "comment": "replacing the root of the document is possible with add",
-      "doc": {"foo": "bar"},
-      "patch": [{"op": "add", "path": "", "value": {"baz": "qux"}}],
-      "expected": {"baz":"qux"}},
-
-    { "comment": "Adding to \"/-\" adds to the end of the array",
-      "doc": [ 1, 2 ],
-      "patch": [ { "op": "add", "path": "/-", "value": { "foo": [ "bar", "baz" ] } } ],
-      "expected": [ 1, 2, { "foo": [ "bar", "baz" ] } ]},
-
-    { "comment": "Adding to \"/-\" adds to the end of the array, even n levels down",
-      "doc": [ 1, 2, [ 3, [ 4, 5 ] ] ],
-      "patch": [ { "op": "add", "path": "/2/1/-", "value": { "foo": [ "bar", "baz" ] } } ],
-      "expected": [ 1, 2, [ 3, [ 4, 5, { "foo": [ "bar", "baz" ] } ] ] ]},
-
-    { "comment": "test remove with bad number should fail",
-      "doc": {"foo": 1, "baz": [{"qux": "hello"}]},
-      "patch": [{"op": "remove", "path": "/baz/1e0/qux"}],
-      "error": "remove op shouldn't remove from array with bad number" },
-
-    { "comment": "test remove on array",
-      "doc": [1, 2, 3, 4],
-      "patch": [{"op": "remove", "path": "/0"}],
-      "expected": [2, 3, 4] },
-
-    { "comment": "test remove with bad index should fail",
-      "doc": [1, 2, 3, 4],
-      "patch": [{"op": "remove", "path": "/1e0"}],
-      "error": "remove op shouldn't remove from array with bad number" },
-
-    { "comment": "test replace with bad number should fail",
-      "doc": [""],
-      "patch": [{"op": "replace", "path": "/1e0", "value": false}],
-      "error": "replace op shouldn't replace in array with bad number" },
-
-    { "comment": "test copy with bad number should fail",
-      "doc": {"baz": [1,2,3], "bar": 1},
-      "patch": [{"op": "copy", "from": "/baz/1e0", "path": "/boo"}],
-      "error": "copy op shouldn't work with bad number" },
-
-    { "comment": "test move with bad number should fail",
-      "doc": {"foo": 1, "baz": [1,2,3,4]},
-      "patch": [{"op": "move", "from": "/baz/1e0", "path": "/foo"}],
-      "error": "move op shouldn't work with bad number" },
-
-    { "comment": "test add with bad number should fail",
-      "doc": ["foo", "sil"],
-      "patch": [{"op": "add", "path": "/1e0", "value": "bar"}],
-      "error": "add op shouldn't add to array with bad number" }
-]
diff --git a/test/jsonPatch-test.js b/test/jsonPatch-test.js
index af21205..b0981e9 100644
--- a/test/jsonPatch-test.js
+++ b/test/jsonPatch-test.js
@@ -21,6 +21,24 @@ buster.testCase('jsonPatch', {
 			assert.equals(result.value, 1);
 		},
 
+		'should replace String': function() {
+			var a = { value: 0 };
+			var result = jsonPatch.apply([{ op: 'add', path: '/value', value: new String("value") }], a);
+			assert.equals(result.value, "value");
+		},
+
+		'should replace Number': function() {
+			var a = { value: 0 };
+			var result = jsonPatch.apply([{ op: 'add', path: '/value', value: new Number(1) }], a);
+			assert.equals(result.value, 1);
+		},
+
+		'should replace Boolean': function() {
+			var a = { value: 0 };
+			var result = jsonPatch.apply([{ op: 'add', path: '/value', value: new Boolean(true) }], a);
+			assert.equals(result.value, true);
+		},
+
 		'should throw': {
 			'when path is invalid': function() {
 				assert.exception(function() {
@@ -129,6 +147,12 @@ buster.testCase('jsonPatch', {
 			assert.equals(result.x.value, 1);
 			assert.equals(result.y.value, 1);
 			refute.same(result.x, result.y);
+		},
+
+		'should not allow copying from non-existent path': function() {
+			assert.exception(function() {
+				jsonPatch.apply([{ op: 'copy', from: '/y/z', path: '/x' }], {});
+			});
 		}
 	},