@aws-solutions-constructs/core 2.78.0 → 2.79.0

package/node_modules/deep-diff/Readme.md

@@ -0,0 +1,239 @@
+# deep-diff
+
+[![CircleCI](https://circleci.com/gh/flitbit/diff.svg?style=svg)](https://circleci.com/gh/flitbit/diff)
+
+[![NPM](https://nodei.co/npm/deep-diff.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/deep-diff/)
+
+**deep-diff** is a javascript/node.js module providing utility functions for determining the structural differences between objects and includes some utilities for applying differences across objects.
+
+## Install
+
+```bash
+npm install deep-diff
+```
+
+Possible v1.0.0 incompatabilities:
+
+* elements in arrays are now processed in reverse order, which fixes a few nagging bugs but may break some users
+  * If your code relied on the order in which the differences were reported then your code will break. If you consider an object graph to be a big tree, then `deep-diff` does a [pre-order traversal of the object graph](https://en.wikipedia.org/wiki/Tree_traversal), however, when it encounters an array, the array is processed from the end towards the front, with each element recursively processed in-order during further descent.
+
+## Features
+
+* Get the structural differences between two objects.
+* Observe the structural differences between two objects.
+* When structural differences represent change, apply change from one object to another.
+* When structural differences represent change, selectively apply change from one object to another.
+
+## Installation
+
+```bash
+npm install deep-diff
+```
+
+### Importing
+
+#### nodejs
+
+```javascript
+var diff = require('deep-diff')
+// or:
+// const diff = require('deep-diff');
+// const { diff } = require('deep-diff');
+// or:
+// const DeepDiff = require('deep-diff');
+// const { DeepDiff } = require('deep-diff');
+// es6+:
+// import diff from 'deep-diff';
+// import { diff } from 'deep-diff';
+// es6+:
+// import DeepDiff from 'deep-diff';
+// import { DeepDiff } from 'deep-diff';
+```
+
+#### browser
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/deep-diff@1/dist/deep-diff.min.js"></script>
+```
+
+> In a browser, `deep-diff` defines a global variable `DeepDiff`. If there is a conflict in the global namespace you can restore the conflicting definition and assign `deep-diff` to another variable like this: `var deep = DeepDiff.noConflict();`.
+
+## Simple Examples
+
+In order to describe differences, change revolves around an `origin` object. For consistency, the `origin` object is always the operand on the `left-hand-side` of operations. The `comparand`, which may contain changes, is always on the `right-hand-side` of operations.
+
+``` javascript
+var diff = require('deep-diff').diff;
+
+var lhs = {
+  name: 'my object',
+  description: 'it\'s an object!',
+  details: {
+    it: 'has',
+    an: 'array',
+    with: ['a', 'few', 'elements']
+  }
+};
+
+var rhs = {
+  name: 'updated object',
+  description: 'it\'s an object!',
+  details: {
+    it: 'has',
+    an: 'array',
+    with: ['a', 'few', 'more', 'elements', { than: 'before' }]
+  }
+};
+
+var differences = diff(lhs, rhs);
+```
+
+*v 0.2.0 and above* The code snippet above would result in the following structure describing the differences:
+
+``` javascript
+[ { kind: 'E',
+    path: [ 'name' ],
+    lhs: 'my object',
+    rhs: 'updated object' },
+  { kind: 'E',
+    path: [ 'details', 'with', 2 ],
+    lhs: 'elements',
+    rhs: 'more' },
+  { kind: 'A',
+    path: [ 'details', 'with' ],
+    index: 3,
+    item: { kind: 'N', rhs: 'elements' } },
+  { kind: 'A',
+    path: [ 'details', 'with' ],
+    index: 4,
+    item: { kind: 'N', rhs: { than: 'before' } } } ]
+```
+
+### Differences
+
+Differences are reported as one or more change records. Change records have the following structure:
+
+* `kind` - indicates the kind of change; will be one of the following:
+  * `N` - indicates a newly added property/element
+  * `D` - indicates a property/element was deleted
+  * `E` - indicates a property/element was edited
+  * `A` - indicates a change occurred within an array
+* `path` - the property path (from the left-hand-side root)
+* `lhs` - the value on the left-hand-side of the comparison (undefined if kind === 'N')
+* `rhs` - the value on the right-hand-side of the comparison (undefined if kind === 'D')
+* `index` - when kind === 'A', indicates the array index where the change occurred
+* `item` - when kind === 'A', contains a nested change record indicating the change that occurred at the array index
+
+Change records are generated for all structural differences between `origin` and `comparand`. The methods only consider an object's own properties and array elements; those inherited from an object's prototype chain are not considered.
+
+Changes to arrays are recorded simplistically. We care most about the shape of the structure; therefore we don't take the time to determine if an object moved from one slot in the array to another. Instead, we only record the structural
+differences. If the structural differences are applied from the `comparand` to the `origin` then the two objects will compare as "deep equal" using most `isEqual` implementations such as found in [lodash](https://github.com/bestiejs/lodash) or [underscore](http://underscorejs.org/).
+
+### Changes
+
+When two objects differ, you can observe the differences as they are calculated and selectively apply those changes to the origin object (left-hand-side).
+
+``` javascript
+var observableDiff = require('deep-diff').observableDiff;
+var applyChange = require('deep-diff').applyChange;
+
+var lhs = {
+  name: 'my object',
+  description: 'it\'s an object!',
+  details: {
+    it: 'has',
+    an: 'array',
+    with: ['a', 'few', 'elements']
+  }
+};
+
+var rhs = {
+  name: 'updated object',
+  description: 'it\'s an object!',
+  details: {
+    it: 'has',
+    an: 'array',
+    with: ['a', 'few', 'more', 'elements', { than: 'before' }]
+};
+
+observableDiff(lhs, rhs, function (d) {
+  // Apply all changes except to the name property...
+  if (d.path[d.path.length - 1] !== 'name') {
+    applyChange(lhs, rhs, d);
+  }
+});
+```
+
+## API Documentation
+
+A standard import of `var diff = require('deep-diff')` is assumed in all of the code examples. The import results in an object having the following public properties:
+
+* `diff(lhs, rhs, prefilter, acc)` &mdash; calculates the differences between two objects, optionally prefiltering elements for comparison, and optionally using the specified accumulator.
+* `observableDiff(lhs, rhs, observer, prefilter)` &mdash; calculates the differences between two objects and reports each to an observer function, optionally, prefiltering elements for comparison.
+* `applyDiff(target, source, filter)` &mdash; applies any structural differences from a source object to a target object, optionally filtering each difference.
+* `applyChange(target, source, change)` &mdash; applies a single change record to a target object. NOTE: `source` is unused and may be removed.
+* `revertChange(target, source, change)` reverts a single change record to a target object. NOTE: `source` is unused and may be removed.
+
+### `diff`
+
+The `diff` function calculates the difference between two objects.
+
+#### Arguments
+
+* `lhs` - the left-hand operand; the origin object.
+* `rhs` - the right-hand operand; the object being compared structurally with the origin object.
+* `prefilter` - an optional function that determines whether difference analysis should continue down the object graph.
+* `acc` - an optional accumulator/array (requirement is that it have a `push` function). Each difference is pushed to the specified accumulator.
+
+Returns either an array of changes or, if there are no changes, `undefined`. This was originally chosen so the result would be pass a truthy test:
+
+```javascript
+var changes = diff(obja, objb);
+if (changes) {
+  // do something with the changes.
+}
+```
+
+#### Pre-filtering Object Properties
+
+The `prefilter`'s signature should be `function(path, key)` and it should return a truthy value for any `path`-`key` combination that should be filtered. If filtered, the difference analysis does no further analysis of on the identified object-property path.
+
+```javascript
+const diff = require('deep-diff');
+const assert = require('assert');
+
+const data = {
+  issue: 126,
+  submittedBy: 'abuzarhamza',
+  title: 'readme.md need some additional example prefilter',
+  posts: [
+    {
+      date: '2018-04-16',
+      text: `additional example for prefilter for deep-diff would be great.
+      https://stackoverflow.com/questions/38364639/pre-filter-condition-deep-diff-node-js`
+    }
+  ]
+};
+
+const clone = JSON.parse(JSON.stringify(data));
+clone.title = 'README.MD needs additional example illustrating how to prefilter';
+clone.disposition = 'completed';
+
+const two = diff(data, clone);
+const none = diff(data, clone,
+  (path, key) => path.length === 0 && ~['title', 'disposition'].indexOf(key)
+);
+
+assert.equal(two.length, 2, 'should reflect two differences');
+assert.ok(typeof none === 'undefined', 'should reflect no differences');
+```
+
+## Contributing
+
+When contributing, keep in mind that it is an objective of `deep-diff` to have no package dependencies. This may change in the future, but for now, no-dependencies.
+
+Please run the unit tests before submitting your PR: `npm test`. Hopefully your PR includes additional unit tests to illustrate your change/modification!
+
+When you run `npm test`, linting will be performed and any linting errors will fail the tests... this includes code formatting.
+
+> Thanks to all those who have contributed so far!

package/node_modules/deep-diff/dist/deep-diff.min.js

@@ -0,0 +1 @@
+!function(e,t){var n=function(e){var l=["N","E","A","D"];function t(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}function n(e,t){Object.defineProperty(this,"kind",{value:e,enumerable:!0}),t&&t.length&&Object.defineProperty(this,"path",{value:t,enumerable:!0})}function D(e,t,n){D.super_.call(this,"E",e),Object.defineProperty(this,"lhs",{value:t,enumerable:!0}),Object.defineProperty(this,"rhs",{value:n,enumerable:!0})}function k(e,t){k.super_.call(this,"N",e),Object.defineProperty(this,"rhs",{value:t,enumerable:!0})}function j(e,t){j.super_.call(this,"D",e),Object.defineProperty(this,"lhs",{value:t,enumerable:!0})}function O(e,t,n){O.super_.call(this,"A",e),Object.defineProperty(this,"index",{value:t,enumerable:!0}),Object.defineProperty(this,"item",{value:n,enumerable:!0})}function f(e,t,n){var r=e.slice((n||t)+1||e.length);return e.length=t<0?e.length+t:t,e.push.apply(e,r),e}function w(e){var t=typeof e;return"object"!==t?t:e===Math?"math":null===e?"null":Array.isArray(e)?"array":"[object Date]"===Object.prototype.toString.call(e)?"date":"function"==typeof e.toString&&/^\/.*\//.test(e.toString())?"regexp":"object"}function u(e){var t=0;if(0===e.length)return t;for(var n=0;n<e.length;n++){var r=e.charCodeAt(n);t=(t<<5)-t+r,t&=t}return t}function x(e){var t=0,n=w(e);if("array"===n){e.forEach(function(e){t+=x(e)});var r="[type: array, hash: "+t+"]";return t+u(r)}if("object"===n){for(var a in e)if(e.hasOwnProperty(a)){var i="[ type: object, key: "+a+", value hash: "+x(e[a])+"]";t+=u(i)}return t}var l="[ type: "+n+" ; value: "+e+"]";return t+u(l)}function A(e,t,n,r,a,i,l,f){n=n||[],l=l||[];var u=(a=a||[]).slice(0);if(null!=i){if(r){if("function"==typeof r&&r(u,i))return;if("object"==typeof r){if(r.prefilter&&r.prefilter(u,i))return;if(r.normalize){var o=r.normalize(u,i,e,t);o&&(e=o[0],t=o[1])}}}u.push(i)}"regexp"===w(e)&&"regexp"===w(t)&&(e=e.toString(),t=t.toString());var h,s,p,c,d=typeof e,v=typeof t,b="undefined"!==d||l&&0<l.length&&l[l.length-1].lhs&&Object.getOwnPropertyDescriptor(l[l.length-1].lhs,i),g="undefined"!==v||l&&0<l.length&&l[l.length-1].rhs&&Object.getOwnPropertyDescriptor(l[l.length-1].rhs,i);if(!b&&g)n.push(new k(u,t));else if(!g&&b)n.push(new j(u,e));else if(w(e)!==w(t))n.push(new D(u,e,t));else if("date"===w(e)&&e-t!=0)n.push(new D(u,e,t));else if("object"===d&&null!==e&&null!==t){for(h=l.length-1;-1<h;--h)if(l[h].lhs===e){c=!0;break}if(c)e!==t&&n.push(new D(u,e,t));else{if(l.push({lhs:e,rhs:t}),Array.isArray(e)){for(f&&(e.sort(function(e,t){return x(e)-x(t)}),t.sort(function(e,t){return x(e)-x(t)})),h=t.length-1,s=e.length-1;s<h;)n.push(new O(u,h,new k(void 0,t[h--])));for(;h<s;)n.push(new O(u,s,new j(void 0,e[s--])));for(;0<=h;--h)A(e[h],t[h],n,r,u,h,l,f)}else{var y=Object.keys(e),m=Object.keys(t);for(h=0;h<y.length;++h)p=y[h],0<=(c=m.indexOf(p))?(A(e[p],t[p],n,r,u,p,l,f),m[c]=null):A(e[p],void 0,n,r,u,p,l,f);for(h=0;h<m.length;++h)(p=m[h])&&A(void 0,t[p],n,r,u,p,l,f)}l.length=l.length-1}}else e!==t&&("number"===d&&isNaN(e)&&isNaN(t)||n.push(new D(u,e,t)))}function o(e,t,n,r,a){var i=[];if(A(e,t,i,r,null,null,null,a),n)for(var l=0;l<i.length;++l)n(i[l]);return i}function r(e,t,n,r){var a=r?function(e){e&&r.push(e)}:void 0,i=o(e,t,a,n);return r||(i.length?i:void 0)}function a(e,t,n){if(void 0===n&&t&&~l.indexOf(t.kind)&&(n=t),e&&n&&n.kind){for(var r=e,a=-1,i=n.path?n.path.length-1:0;++a<i;)void 0===r[n.path[a]]&&(r[n.path[a]]=void 0!==n.path[a+1]&&"number"==typeof n.path[a+1]?[]:{}),r=r[n.path[a]];switch(n.kind){case"A":n.path&&void 0===r[n.path[a]]&&(r[n.path[a]]=[]),function e(t,n,r){if(r.path&&r.path.length){var a,i=t[n],l=r.path.length-1;for(a=0;a<l;a++)i=i[r.path[a]];switch(r.kind){case"A":e(i[r.path[a]],r.index,r.item);break;case"D":delete i[r.path[a]];break;case"E":case"N":i[r.path[a]]=r.rhs}}else switch(r.kind){case"A":e(t[n],r.index,r.item);break;case"D":t=f(t,n);break;case"E":case"N":t[n]=r.rhs}return t}(n.path?r[n.path[a]]:r,n.index,n.item);break;case"D":delete r[n.path[a]];break;case"E":case"N":r[n.path[a]]=n.rhs}}}t(D,n),t(k,n),t(j,n),t(O,n),Object.defineProperties(r,{diff:{value:r,enumerable:!0},orderIndependentDiff:{value:function(e,t,n,r){var a=r?function(e){e&&r.push(e)}:void 0,i=o(e,t,a,n,!0);return r||(i.length?i:void 0)},enumerable:!0},observableDiff:{value:o,enumerable:!0},orderIndependentObservableDiff:{value:function(e,t,n,r,a,i,l){return A(e,t,n,r,a,i,l,!0)},enumerable:!0},orderIndepHash:{value:x,enumerable:!0},applyDiff:{value:function(t,n,r){t&&n&&o(t,n,function(e){r&&!r(t,n,e)||a(t,n,e)})},enumerable:!0},applyChange:{value:a,enumerable:!0},revertChange:{value:function(e,t,n){if(e&&t&&n&&n.kind){var r,a,i=e;for(a=n.path.length-1,r=0;r<a;r++)void 0===i[n.path[r]]&&(i[n.path[r]]={}),i=i[n.path[r]];switch(n.kind){case"A":!function e(t,n,r){if(r.path&&r.path.length){var a,i=t[n],l=r.path.length-1;for(a=0;a<l;a++)i=i[r.path[a]];switch(r.kind){case"A":e(i[r.path[a]],r.index,r.item);break;case"D":case"E":i[r.path[a]]=r.lhs;break;case"N":delete i[r.path[a]]}}else switch(r.kind){case"A":e(t[n],r.index,r.item);break;case"D":case"E":t[n]=r.lhs;break;case"N":t=f(t,n)}return t}(i[n.path[r]],n.index,n.item);break;case"D":case"E":i[n.path[r]]=n.lhs;break;case"N":delete i[n.path[r]]}}},enumerable:!0},isConflict:{value:function(){return"undefined"!=typeof $conflict},enumerable:!0}}),r.DeepDiff=r,e&&(e.DeepDiff=r);return r}(e);if("function"==typeof define&&define.amd)define("DeepDiff",function(){return n});else if("object"==typeof exports||"object"==typeof navigator&&navigator.product.match(/ReactNative/i))module.exports=n;else{var r=e.DeepDiff;n.noConflict=function(){return e.DeepDiff===n&&(e.DeepDiff=r),n},e.DeepDiff=n}}(this);

package/node_modules/deep-diff/dist/deep-diff.min.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js"],"names":["root","factory","deepDiff","validKinds","inherits","ctor","superCtor","super_","prototype","Object","create","constructor","value","enumerable","writable","configurable","Diff","kind","path","defineProperty","this","length","DiffEdit","origin","call","DiffNew","DiffDeleted","DiffArray","index","item","arrayRemove","arr","from","to","rest","slice","push","apply","realTypeOf","subject","type","Math","Array","isArray","toString","test","hashThisString","string","hash","i","char","charCodeAt","getOrderIndependentHash","object","accum","forEach","arrayString","key","hasOwnProperty","keyValueString","stringToHash","lhs","rhs","changes","prefilter","stack","orderIndependent","currentPath","normalize","alt","j","k","other","ltype","rtype","ldefined","getOwnPropertyDescriptor","rdefined","sort","a","b","undefined","akeys","keys","pkeys","indexOf","isNaN","observableDiff","observer","accumulateDiff","difference","applyChange","target","source","change","it","last","applyArrayChange","u","defineProperties","diff","orderIndependentDiff","orderIndependentObservableDiff","orderIndepHash","applyDiff","filter","revertChange","revertArrayChange","isConflict","$conflict","DeepDiff","define","amd","exports","navigator","product","match","module","_deepdiff","noConflict"],"mappings":"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"}

package/node_modules/deep-diff/examples/apply-diff-from-any.js

@@ -0,0 +1,39 @@
+/*jshint indent:2, laxcomma:true, laxbreak:true*/
+var util = require('util')
+, diff = require('..')
+, data = require('./practice-data')
+;
+
+var cycle = -1
+, i
+, len = data.length
+, prior = {}
+, comparand
+, records
+, ch
+;
+
+var applyEachChange = function (ch) {
+        diff.applyChange(prior, comparand, ch);
+      };
+
+while (++cycle < 10) {
+  i = -1;
+  while (++i < len) {
+
+    comparand = data[i];
+
+    // get the difference...
+    records = diff(prior, comparand);
+
+    // round-trip serialize to prune the underlying types...
+    var serialized = JSON.stringify(records);
+    var desierialized = JSON.parse(serialized);
+
+    if (desierialized) {
+      desierialized.forEach(applyEachChange);
+
+      prior = comparand;
+    }
+  }
+}

package/node_modules/deep-diff/examples/array-change.js

@@ -0,0 +1,45 @@
+/*jshint indent:2, laxcomma:true, laxbreak:true*/
+var util = require('util');
+var expect = require('expect.js');
+var deep = require('..');
+
+var lhs = {
+  'id': 'Release',
+  'phases': [{
+    'id': 'Phase1',
+    'tasks': [
+      { 'id': 'Task1' },
+      { 'id': 'Task2' }
+    ]
+  }, {
+    'id': 'Phase2',
+    'tasks': [
+      { 'id': 'Task3' }
+    ]
+  }]
+};
+var rhs = {
+  'id': 'Release',
+  'phases': [{
+    // E: Phase1 -> Phase2
+    'id': 'Phase2',
+    'tasks': [
+      { 'id': 'Task3' }
+    ]
+  }, {
+    'id': 'Phase1',
+    'tasks': [
+      { 'id': 'Task1' },
+      { 'id': 'Task2' }
+    ]
+  }]
+};
+
+var diff = deep.diff(lhs, rhs);
+console.log(util.inspect(diff, false, 9)); // eslint-disable-line no-console
+
+deep.applyDiff(lhs, rhs);
+console.log(util.inspect(lhs, false, 9)); // eslint-disable-line no-console
+
+expect(lhs).to.be.eql(rhs);
+

package/node_modules/deep-diff/examples/capture_change_apply_elsewhere.js

@@ -0,0 +1,53 @@
+/*jshint indent:2, laxcomma:true, laxbreak:true*/
+var util = require('util')
+, assert = require('assert')
+, diff = require('..')
+, data = require('./practice-data')
+;
+
+var i = Math.floor(Math.random() * data.length) + 1;
+var j = Math.floor(Math.random() * data.length) + 1;
+
+while (j === i) {
+  j = Math.floor(Math.random() * data.length) + 1;
+}
+
+var source = data[i];
+var comparand = data[j];
+
+// source and comparand are different objects
+assert.notEqual(source, comparand);
+
+// source and comparand have differences in their structure
+assert.notDeepEqual(source, comparand);
+
+// record the differences between source and comparand
+var changes = diff(source, comparand);
+
+// apply the changes to the source
+changes.forEach(function (change) {
+  diff.applyChange(source, true, change);
+});
+
+// source and copmarand are now deep equal
+assert.deepEqual(source, comparand);
+
+// Simulate serializing to a remote copy of the object (we've already go a copy, copy the changes)...
+
+var remote = JSON.parse(JSON.stringify(source));
+var remoteChanges = JSON.parse(JSON.stringify(changes));
+
+// source and remote are different objects
+assert.notEqual(source, remote);
+
+// changes and remote changes are different objects
+assert.notEqual(changes, remoteChanges);
+
+// remote and comparand are different objects
+assert.notEqual(remote, comparand);
+
+remoteChanges.forEach(function (change) {
+  diff.applyChange(remote, true, change);
+});
+
+assert.deepEqual(remote, comparand);

package/node_modules/deep-diff/examples/diff-ignoring-fun.js

@@ -0,0 +1,88 @@
+/*jshint indent:2, laxcomma:true, laxbreak:true*/
+var util = require('util')
+, deep   = require('..')
+;
+
+function duckWalk() {
+  util.log('right step, left-step, waddle');
+}
+
+function quadrapedWalk() {
+  util.log('right hind-step, right fore-step, left hind-step, left fore-step');
+}
+
+var duck = {
+  legs: 2,
+  walk: duckWalk
+};
+
+var dog = {
+  legs: 4,
+  walk: quadrapedWalk
+};
+
+var diff = deep.diff(duck, dog);
+
+// The differences will include the legs, and walk.
+util.log('Differences:\r\n' + util.inspect(diff, false, 9));
+
+
+// To ignore behavioral differences (functions); use observableDiff and your own accumulator:
+
+var observed = [];
+deep.observableDiff(duck, dog, function (d) {
+  if (d && d.lhs && typeof d.lhs !== 'function') {
+    observed.push(d);
+  }
+});
+
+util.log('Observed without recording functions:\r\n' + util.inspect(observed, false, 9));
+
+util.log(util.inspect(dog, false, 9) + ' walking: ');
+dog.walk();
+
+// The purpose of the observableDiff fn is to allow you to observe and apply differences
+// that make sense in your scenario...
+
+// We'll make the dog act like a duck...
+deep.observableDiff(dog, duck, function (d) {
+  deep.applyChange(dog, duck, d);
+});
+
+util.log(util.inspect(dog, false, 9) + ' walking: ');
+dog.walk();
+
+// Now there are no differences between the duck and the dog:
+if (deep.diff(duck, dog)) {
+  util.log("Ooops, that prior statement seems to be wrong! (but it won't be)");
+}
+
+// Now assign an "equivalent" walk function...
+dog.walk = function duckWalk() {
+  util.log('right step, left-step, waddle');
+};
+
+if (diff = deep.diff(duck, dog)) {
+  // The dog's walk function is an equivalent, but different duckWalk function.
+  util.log('Hrmm, the dog walks differently: ' + util.inspect(diff, false, 9));
+}
+
+// Use the observableDiff fn to ingore based on behavioral equivalence...
+
+observed = [];
+deep.observableDiff(duck, dog, function (d) {
+  // if the change is a function, only record it if the text of the fns differ:
+  if (d && typeof d.lhs === 'function' && typeof d.rhs === 'function') {
+    var leftFnText = d.lhs.toString();
+    var rightFnText = d.rhs.toString();
+    if (leftFnText !== rightFnText) {
+      observed.push(d);
+    }
+  } else {
+    observed.push(d);
+  }
+});
+
+if (observed.length === 0) {
+  util.log('Yay!, we detected that the walk functions are equivalent');
+}

package/node_modules/deep-diff/examples/diff-scenarios.js

@@ -0,0 +1,49 @@
+var util = require('util'),
+expect   = require('expect.js'),
+eql      = require('deep-equal'),
+deep     = require('..')
+extend   = util._extend;
+diff     = deep.diff,
+apply    = deep.applyDiff;
+
+function f0() {};
+function f1() {};
+
+var one = { it: 'be one', changed: false, with: { nested: 'data'}, f: f1};
+var two = { it: 'be two', updated: true, changed: true, with: {nested: 'data', and: 'other', plus: one} };
+var circ = {};
+var other = { it: 'be other', numero: 34.29, changed: [ { it: 'is the same' }, 13.3, 'get some' ], with: {nested: 'reference', plus: circ} };
+var circular = extend(circ, { it: 'be circ', updated: false, changed: [ { it: 'is not same' }, 13.3, 'get some!', {extra: 'stuff'}], with: { nested: 'reference', circular: other } });
+
+util.log(util.inspect(diff(one, two), false, 99));
+util.log(util.inspect(diff(two, one), false, 99));
+
+util.log(util.inspect(diff(other, circular), false, 99));
+
+var clone = extend({}, one);
+apply(clone, two);
+util.log(util.inspect(clone, false, 99));
+
+expect(eql(clone, two)).to.be(true);
+expect(eql(clone, one)).to.be(false);
+
+clone = extend({}, circular);
+apply(clone, other);
+util.log(util.inspect(clone, false, 99));
+expect(eql(clone, other)).to.be(true);
+expect(eql(clone, circular)).to.be(false);
+
+
+var array = { name: 'array two levels deep', item: { arr: ['it', { has: 'data' }]}};
+var arrayChange = { name: 'array change two levels deep', item: { arr: ['it', { changes: 'data' }]}};
+
+util.log(util.inspect(diff(array, arrayChange), false, 99));
+clone = extend({}, array);
+apply(clone, arrayChange);
+util.log(util.inspect(clone, false, 99));
+expect(eql(clone, arrayChange)).to.be(true);
+
+var one_prop = { one: 'property' };
+var d = diff(one_prop, {});
+expect(d.length).to.be(1);
+

package/node_modules/deep-diff/examples/example1.js

@@ -0,0 +1,41 @@
+var util = require('util')
+, deep   = require('..')
+;
+
+var lhs = {
+	name: 'my object',
+	description: 'it\'s an object!',
+	details: {
+		it: 'has',
+		an: 'array',
+		with: ['a', 'few', 'elements']
+	}
+};
+
+var rhs = {
+	name: 'updated object',
+	description: 'it\'s an object!',
+	details: {
+		it: 'has',
+		an: 'array',
+		with: ['a', 'few', 'more', 'elements', { than: 'before' }]
+	}
+};
+
+var differences = deep.diff(lhs, rhs);
+
+// Print the differences to the console...
+util.log(util.inspect(differences, false, 99));
+
+deep.observableDiff(lhs, rhs, function (d) {
+	// Apply all changes except those to the 'name' property...
+	if (d.path.length !== 1 || d.path.join('.') !== 'name') {
+		deep.applyChange(lhs, rhs, d);
+	}
+}, function (path, key) {
+	var p = (path && path.length) ? path.join('/') : '<no-path>'
+	util.log('prefilter: path = ' + p + ' key = ' + key);
+}
+);
+
+console.log(util.inspect(lhs, false, 99));

package/node_modules/deep-diff/examples/issue-111.js

@@ -0,0 +1,6 @@
+var diff = require('../');
+
+
+var differences = diff(undefined, undefined);
+// eslint-disable-next-line no-console
+console.log(differences);

package/node_modules/deep-diff/examples/issue-113-1.js

@@ -0,0 +1,14 @@
+const { log, inspect } = require('util');
+const assert = require('assert');
+const diff = require('../');
+
+const o1 = {};
+const o2 = {};
+o1.foo = o1;
+o2.foo = o2;
+
+assert.notEqual(o1, o2, 'not same object');
+assert.notEqual(o1.foo, o2.foo, 'not same object');
+
+const differences = diff(o1, o2);
+log(inspect(differences, false, 9));

package/node_modules/deep-diff/examples/issue-113-2.js

@@ -0,0 +1,11 @@
+const { log, inspect } = require('util');
+const diff = require('../');
+
+var o1 = {};
+var o2 = {};
+o1.foo = o1;
+o2.foo = {foo: o2};
+const differences = diff(o1, o2);
+
+log(inspect(differences, false, 9));
+

package/node_modules/deep-diff/examples/issue-115.js

@@ -0,0 +1,17 @@
+var diff = require('../');
+var expect = require('expect.js');
+
+var thing1 = 'this';
+var thing2 = 'that';
+var thing3 = 'other';
+var thing4 = 'another';
+
+var oldArray = [thing1, thing2, thing3, thing4];
+var newArray = [thing1, thing2];
+
+diff.observableDiff(oldArray, newArray,
+  function (d) {
+    diff.applyChange(oldArray, d);
+  });
+
+expect(oldArray).to.eql(newArray);

package/node_modules/deep-diff/examples/issue-124.js

@@ -0,0 +1,8 @@
+var diff = require('../');
+
+var left = { key: [ {A: 0, B: 1}, {A: 2, B: 3} ] };
+var right = { key: [ {A: 9, B: 1}, {A: 2, B: 3} ] };
+
+var differences = diff(left, right);
+// eslint-disable-next-line no-console
+console.log(differences);