Current Dev State

static/js/ketcher2/node_modules/fast-deep-equal/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Evgeny Poberezkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

static/js/ketcher2/node_modules/fast-deep-equal/README.md

@@ -0,0 +1,55 @@
+# fast-deep-equal
+The fastest deep equal
+
+[![Build Status](https://travis-ci.org/epoberezkin/fast-deep-equal.svg?branch=master)](https://travis-ci.org/epoberezkin/fast-deep-equal)
+[![npm version](https://badge.fury.io/js/fast-deep-equal.svg)](http://badge.fury.io/js/fast-deep-equal)
+[![Coverage Status](https://coveralls.io/repos/github/epoberezkin/fast-deep-equal/badge.svg?branch=master)](https://coveralls.io/github/epoberezkin/fast-deep-equal?branch=master)
+
+
+## Install
+
+```bash
+npm install fast-deep-equal
+```
+
+
+## Features
+
+- ES5 compatible
+- works in node.js (0.10+) and browsers (IE9+)
+- checks equality of Date and RegExp objects by value.
+
+
+## Usage
+
+```javascript
+var equal = require('fast-deep-equal');
+console.log(equal({foo: 'bar'}, {foo: 'bar'})); // true
+```
+
+
+## Performance benchmark
+
+```
+fast-deep-equal x 82,915 ops/sec ±0.63% (89 runs sampled)
+nano-equal x 50,506 ops/sec ±2.23% (86 runs sampled)
+shallow-equal-fuzzy x 14,873 ops/sec ±3.19% (83 runs sampled)
+underscore.isEqual x 16,055 ops/sec ±2.29% (85 runs sampled)
+lodash.isEqual x 10,740 ops/sec ±1.04% (89 runs sampled)
+deep-equal x 12,276 ops/sec ±2.44% (84 runs sampled)
+deep-eql x 10,565 ops/sec ±0.89% (90 runs sampled)
+assert.deepStrictEqual x 965 ops/sec ±2.99% (81 runs sampled)
+The fastest is fast-deep-equal
+```
+
+To run benchmark (requires node.js 6+):
+
+```bash
+npm install
+node benchmark
+```
+
+
+## License
+
+[MIT](https://github.com/epoberezkin/fast-deep-equal/blob/master/LICENSE)

static/js/ketcher2/node_modules/fast-deep-equal/benchmark/index.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const assertDeepStrictEqual = require('assert').deepStrictEqual;
+const tests = require('../spec/tests');
+const Benchmark = require('benchmark');
+const suite = new Benchmark.Suite;
+
+
+const equalPackages = {
+  'fast-deep-equal': require('../index'),
+  'nano-equal': true,
+  'shallow-equal-fuzzy': true,
+  'underscore.isEqual': require('underscore').isEqual,
+  'lodash.isEqual': require('lodash').isEqual,
+  'deep-equal': true,
+  'deep-eql': true,
+  'assert.deepStrictEqual': (a, b) => {
+    try { assertDeepStrictEqual(a, b); return true; }
+    catch(e) { return false; }
+  }
+};
+
+
+for (const equalName in equalPackages) {
+  let equalFunc = equalPackages[equalName];
+  if (equalFunc === true) equalFunc = require(equalName);
+
+  for (const testSuite of tests) {
+    for (const test of testSuite.tests) {
+      try {
+        if (equalFunc(test.value1, test.value2) !== test.equal)
+          console.error('different result', equalName, testSuite.description, test.description);
+      } catch(e) {
+        console.error(equalName, testSuite.description, test.description, e);
+      }
+    }
+  }
+
+  suite.add(equalName, function() {
+    for (const testSuite of tests) {
+      for (const test of testSuite.tests) {
+        if (test.description != 'pseudo array and equivalent array are not equal')
+          equalFunc(test.value1, test.value2);
+      }
+    }
+  });
+}
+
+console.log();
+
+suite
+  .on('cycle', (event) => console.log(String(event.target)))
+  .on('complete', function () {
+    console.log('The fastest is ' + this.filter('fastest').map('name'));
+  })
+  .run({async: true});

static/js/ketcher2/node_modules/fast-deep-equal/index.js

@@ -0,0 +1,43 @@
+'use strict';
+
+module.exports = function equal(a, b) {
+  if (a === b) return true;
+
+  var arrA = Array.isArray(a)
+    , arrB = Array.isArray(b)
+    , i;
+
+  if (arrA && arrB) {
+    if (a.length != b.length) return false;
+    for (i = 0; i < a.length; i++)
+      if (!equal(a[i], b[i])) return false;
+    return true;
+  }
+
+  if (arrA != arrB) return false;
+
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    var keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return false;
+
+    var dateA = a instanceof Date
+      , dateB = b instanceof Date;
+    if (dateA && dateB) return a.getTime() == b.getTime();
+    if (dateA != dateB) return false;
+
+    var regexpA = a instanceof RegExp
+      , regexpB = b instanceof RegExp;
+    if (regexpA && regexpB) return a.toString() == b.toString();
+    if (regexpA != regexpB) return false;
+
+    for (i = 0; i < keys.length; i++)
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+    for (i = 0; i < keys.length; i++)
+      if(!equal(a[keys[i]], b[keys[i]])) return false;
+
+    return true;
+  }
+
+  return false;
+};

static/js/ketcher2/node_modules/fast-deep-equal/package.json

@@ -0,0 +1,78 @@
+{
+  "_from": "fast-deep-equal@^1.0.0",
+  "_id": "fast-deep-equal@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-liVqO8l1WV6zbYLpkp0GDYk0Of8=",
+  "_location": "/fast-deep-equal",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "fast-deep-equal@^1.0.0",
+    "name": "fast-deep-equal",
+    "escapedName": "fast-deep-equal",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/ajv"
+  ],
+  "_resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.0.0.tgz",
+  "_shasum": "96256a3bc975595eb36d82e9929d060d893439ff",
+  "_spec": "fast-deep-equal@^1.0.0",
+  "_where": "/home/manfred/enviPath/ketcher2/ketcher/node_modules/ajv",
+  "author": {
+    "name": "Evgeny Poberezkin"
+  },
+  "bugs": {
+    "url": "https://github.com/epoberezkin/fast-deep-equal/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Fast deep equal",
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "coveralls": "^2.13.1",
+    "deep-eql": "^2.0.2",
+    "deep-equal": "^1.0.1",
+    "eslint": "^4.0.0",
+    "lodash": "^4.17.4",
+    "mocha": "^3.4.2",
+    "nano-equal": "^1.0.1",
+    "nyc": "^11.0.2",
+    "pre-commit": "^1.2.2",
+    "shallow-equal-fuzzy": "0.0.2",
+    "underscore": "^1.8.3"
+  },
+  "homepage": "https://github.com/epoberezkin/fast-deep-equal#readme",
+  "keywords": [
+    "fast",
+    "equal",
+    "deep-equal"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "fast-deep-equal",
+  "nyc": {
+    "exclude": [
+      "**/spec/**",
+      "node_modules"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/epoberezkin/fast-deep-equal.git"
+  },
+  "scripts": {
+    "eslint": "eslint *.js benchmark spec",
+    "test": "npm run eslint && npm run test-cov",
+    "test-cov": "nyc npm run test-spec",
+    "test-spec": "mocha spec/*.spec.js -R spec"
+  },
+  "version": "1.0.0"
+}

static/js/ketcher2/node_modules/fast-deep-equal/spec/index.spec.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var equal = require('../index');
+var tests = require('./tests');
+var assert = require('assert');
+
+
+describe('equal', function() {
+  tests.forEach(function (suite) {
+    describe(suite.description, function() {
+      suite.tests.forEach(function (test) {
+        it(test.description, function() {
+          assert.strictEqual(equal(test.value1, test.value2), test.equal);
+        });
+      });
+    });
+  });
+});

static/js/ketcher2/node_modules/fast-deep-equal/spec/tests.js

@@ -0,0 +1,320 @@
+'use strict';
+
+module.exports = [
+  {
+    description: 'scalars',
+    tests: [
+      {
+        description: 'equal numbers',
+        value1: 1,
+        value2: 1,
+        equal: true
+      },
+      {
+        description: 'not equal numbers',
+        value1: 1,
+        value2: 2,
+        equal: false
+      },
+      {
+        description: 'number and array are not equal',
+        value1: 1,
+        value2: [],
+        equal: false
+      },
+      {
+        description: '0 and null are not equal',
+        value1: 0,
+        value2: null,
+        equal: false
+      },
+      {
+        description: 'equal strings',
+        value1: 'a',
+        value2: 'a',
+        equal: true
+      },
+      {
+        description: 'not equal strings',
+        value1: 'a',
+        value2: 'b',
+        equal: false
+      },
+      {
+        description: 'empty string and null are not equal',
+        value1: '',
+        value2: null,
+        equal: false
+      },
+      {
+        description: 'null is equal to null',
+        value1: null,
+        value2: null,
+        equal: true
+      },
+      {
+        description: 'equal booleans (true)',
+        value1: true,
+        value2: true,
+        equal: true
+      },
+      {
+        description: 'equal booleans (false)',
+        value1: false,
+        value2: false,
+        equal: true
+      },
+      {
+        description: 'not equal booleans',
+        value1: true,
+        value2: false,
+        equal: false
+      },
+      {
+        description: '1 and true are not equal',
+        value1: 1,
+        value2: true,
+        equal: false
+      },
+      {
+        description: '0 and false are not equal',
+        value1: 0,
+        value2: false,
+        equal: false
+      }
+    ]
+  },
+
+  {
+    description: 'objects',
+    tests: [
+      {
+        description: 'empty objects are equal',
+        value1: {},
+        value2: {},
+        equal: true
+      },
+      {
+        description: 'equal objects (same properties "order")',
+        value1: {a: 1, b: '2'},
+        value2: {a: 1, b: '2'},
+        equal: true
+      },
+      {
+        description: 'equal objects (different properties "order")',
+        value1: {a: 1, b: '2'},
+        value2: {b: '2', a: 1},
+        equal: true
+      },
+      {
+        description: 'not equal objects (extra property)',
+        value1: {a: 1, b: '2'},
+        value2: {a: 1, b: '2', c: []},
+        equal: false
+      },
+      {
+        description: 'not equal objects (different properties)',
+        value1: {a: 1, b: '2', c: 3},
+        value2: {a: 1, b: '2', d: 3},
+        equal: false
+      },
+      {
+        description: 'not equal objects (different properties)',
+        value1: {a: 1, b: '2', c: 3},
+        value2: {a: 1, b: '2', d: 3},
+        equal: false
+      },
+      {
+        description: 'equal objects (same sub-properties)',
+        value1: { a: [ { b: 'c' } ] },
+        value2: { a: [ { b: 'c' } ] },
+        equal: true
+      },
+      {
+        description: 'not equal objects (different sub-property value)',
+        value1: { a: [ { b: 'c' } ] },
+        value2: { a: [ { b: 'd' } ] },
+        equal: false
+      },
+      {
+        description: 'not equal objects (different sub-property)',
+        value1: { a: [ { b: 'c' } ] },
+        value2: { a: [ { c: 'c' } ] },
+        equal: false
+      },
+      {
+        description: 'empty array and empty object are not equal',
+        value1: {},
+        value2: [],
+        equal: false
+      },
+      {
+        description: 'object with extra undefined properties are not equal #1',
+        value1: {},
+        value2: {foo: undefined},
+        equal: false
+      },
+      {
+        description: 'object with extra undefined properties are not equal #2',
+        value1: {foo: undefined},
+        value2: {},
+        equal: false
+      },
+      {
+        description: 'object with extra undefined properties are not equal #3',
+        value1: {foo: undefined},
+        value2: {bar: undefined},
+        equal: false
+      }
+    ]
+  },
+
+  {
+    description: 'arrays',
+    tests: [
+      {
+        description: 'two empty arrays are equal',
+        value1: [],
+        value2: [],
+        equal: true
+      },
+      {
+        description: 'equal arrays',
+        value1: [1, 2, 3],
+        value2: [1, 2, 3],
+        equal: true
+      },
+      {
+        description: 'not equal arrays (different item)',
+        value1: [1, 2, 3],
+        value2: [1, 2, 4],
+        equal: false
+      },
+      {
+        description: 'not equal arrays (different length)',
+        value1: [1, 2, 3],
+        value2: [1, 2],
+        equal: false
+      },
+      {
+        description: 'equal arrays of objects',
+        value1: [{a: 'a'}, {b: 'b'}],
+        value2: [{a: 'a'}, {b: 'b'}],
+        equal: true
+      },
+      {
+        description: 'not equal arrays of objects',
+        value1: [{a: 'a'}, {b: 'b'}],
+        value2: [{a: 'a'}, {b: 'c'}],
+        equal: false
+      },
+      {
+        description: 'pseudo array and equivalent array are not equal',
+        value1: {'0': 0, '1': 1, length: 2},
+        value2: [0, 1],
+        equal: false
+      }
+    ]
+  },
+  {
+    description: 'Date objects',
+    tests: [
+      {
+        description: 'equal date objects',
+        value1: new Date('2017-06-16T21:36:48.362Z'),
+        value2: new Date('2017-06-16T21:36:48.362Z'),
+        equal: true
+      },
+      {
+        description: 'not equal date objects',
+        value1: new Date('2017-06-16T21:36:48.362Z'),
+        value2: new Date('2017-01-01T00:00:00.000Z'),
+        equal: false
+      },
+      {
+        description: 'date and string are not equal',
+        value1: new Date('2017-06-16T21:36:48.362Z'),
+        value2: '2017-06-16T21:36:48.362Z',
+        equal: false
+      },
+      {
+        description: 'date and object are not equal',
+        value1: new Date('2017-06-16T21:36:48.362Z'),
+        value2: {},
+        equal: false
+      }
+    ]
+  },
+  {
+    description: 'RegExp objects',
+    tests: [
+      {
+        description: 'equal RegExp objects',
+        value1: /foo/,
+        value2: /foo/,
+        equal: true
+      },
+      {
+        description: 'not equal RegExp objects (different pattern)',
+        value1: /foo/,
+        value2: /bar/,
+        equal: false
+      },
+      {
+        description: 'not equal RegExp objects (different flags)',
+        value1: /foo/,
+        value2: /foo/i,
+        equal: false
+      },
+      {
+        description: 'RegExp and string are not equal',
+        value1: /foo/,
+        value2: 'foo',
+        equal: false
+      },
+      {
+        description: 'RegExp and object are not equal',
+        value1: /foo/,
+        value2: {},
+        equal: false
+      }
+    ]
+  },
+  {
+    description: 'sample objects',
+    tests: [
+      {
+        description: 'big object',
+        value1: {
+          prop1: 'value1',
+          prop2: 'value2',
+          prop3: 'value3',
+          prop4: {
+            subProp1: 'sub value1',
+            subProp2: {
+              subSubProp1: 'sub sub value1',
+              subSubProp2: [1, 2, {prop2: 1, prop: 2}, 4, 5]
+            }
+          },
+          prop5: 1000,
+          prop6: new Date(2016, 2, 10)
+        },
+        value2: {
+          prop5: 1000,
+          prop3: 'value3',
+          prop1: 'value1',
+          prop2: 'value2',
+          prop6: new Date('2016/03/10'),
+          prop4: {
+            subProp2: {
+              subSubProp1: 'sub sub value1',
+              subSubProp2: [1, 2, {prop2: 1, prop: 2}, 4, 5]
+            },
+            subProp1: 'sub value1'
+          }
+        },
+        equal: true
+      }
+    ]
+  }
+];