Current Dev State

static/js/ketcher2/node_modules/classnames/CONTRIBUTING.md

@@ -0,0 +1,21 @@
+# Contributing
+
+Thanks for your interest in classNames. Issues, PRs and suggestions welcome :)
+
+Before working on a PR, please consider the following:
+
+* Speed is a serious concern for this package as it is likely to be called a
+significant number of times in any project that uses it. As such, new features
+will only be accepted if they improve (or at least do not negatively impact)
+performance.
+* To demonstrate performance differences please set up a
+[JSPerf](http://jsperf.com) test and link to it from your issue / PR.
+* Tests must be added for any change or new feature before it will be accepted.
+
+A benchmark utilitiy is included so that changes may be tested against the
+current published version. To run the benchmarks, `npm install` in the
+`./benchmarks` directory then run `npm run benchmarks` in the package root.
+
+Please be aware though that local benchmarks are just a smoke-signal; they will
+run in the v8 version that your node/iojs uses, while classNames is _most_
+often run across a wide variety of browsers and browser versions.

static/js/ketcher2/node_modules/classnames/HISTORY.md

@@ -0,0 +1,81 @@
+# Changelog
+
+## v2.2.5 / 2016-05-02
+
+* Improved performance of `dedupe` variant even further, thanks [Andres Suarez](https://github.com/zertosh)
+
+## v2.2.4 / 2016-04-25
+
+* Improved performance of `dedupe` variant by about 2x, thanks [Bartosz Gościński](https://github.com/bgoscinski)
+
+## v2.2.3 / 2016-01-05
+
+* Updated `bind` variant to use `[].join(' ')` as per the main script in 2.2.2
+
+## v2.2.2 / 2016-01-04
+
+* Switched from string concatenation to `[].join(' ')` for a slight performance gain in the main function.
+
+## v2.2.1 / 2015-11-26
+
+* Add deps parameter to the AMD module, fixes an issue using the Dojo loader, thanks [Chris Jordan](https://github.com/flipperkid)
+
+## v2.2.0 / 2015-10-18
+
+* added a new `bind` variant for use with [css-modules](https://github.com/css-modules/css-modules) and similar abstractions, thanks to [Kirill Yakovenko](https://github.com/blia)
+
+## v2.1.5 / 2015-09-30
+
+* reverted a new usage of `Object.keys` in `dedupe.js` that slipped through in the last release
+
+## v2.1.4 / 2015-09-30
+
+* new case added to benchmarks
+* safer `hasOwnProperty` check
+* AMD module is now named, so you can do the following:
+
+```
+define(["classnames"], function (classNames) {
+  var style = classNames("foo", "bar");
+  // ...
+});
+```
+
+## v2.1.3 / 2015-07-02
+
+* updated UMD wrapper to support AMD and CommonJS on the same pacge
+
+## v2.1.2 / 2015-05-28
+
+* added a proper UMD wrapper
+
+## v2.1.1 / 2015-05-06
+
+* minor performance improvement thanks to type caching
+* improved benchmarking and results output
+
+## v2.1.0 / 2015-05-05
+
+* added alternate `dedupe` version of classNames, which is slower (10x) but ensures that if a class is added then overridden by a falsy value in a subsequent argument, it is excluded from the result.
+
+## v2.0.0 / 2015-05-03
+
+* performance improvement; switched to `Array.isArray` for type detection, which is much faster in modern browsers. A polyfill is now required for IE8 support, see the Readme for details.
+
+## v1.2.2 / 2015-04-28
+
+* license comment updates to simiplify certain build scenarios
+
+## v1.2.1 / 2015-04-22
+
+* added safe exporting for requireJS usage
+* clarified Bower usage and instructions
+
+## v1.2.0 / 2015-03-17
+
+* added comprehensive support for array arguments, including nested arrays
+* simplified code slightly
+
+## Previous
+
+Please see the git history for the details of previous versions.

static/js/ketcher2/node_modules/classnames/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jed Watson
+
+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/classnames/README.md

@@ -0,0 +1,188 @@
+Classnames
+===========
+
+[![Version](http://img.shields.io/npm/v/classnames.svg)](https://www.npmjs.org/package/classnames)
+[![Build Status](https://travis-ci.org/JedWatson/classnames.svg?branch=master)](https://travis-ci.org/JedWatson/classnames)
+
+A simple javascript utility for conditionally joining classNames together.
+
+Install with npm or Bower.
+
+```sh
+npm install classnames
+```
+
+Use with node.js, browserify or webpack:
+
+```js
+var classNames = require('classnames');
+classNames('foo', 'bar'); // => 'foo bar'
+```
+
+Alternatively, you can simply include `index.js` on your page with a standalone `<script>` tag and it will export a global `classNames` method, or define the module if you are using RequireJS.
+
+### Project philosophy
+
+We take the stability and performance of this package seriously, because it is run millions of times a day in browsers all around the world. Updates are thoroughly reviewed for performance impacts before being released, and we have a comprehensive test suite.
+
+Classnames follows the [SemVer](http://semver.org/) standard for versioning.
+
+There is also a [Changelog](https://github.com/JedWatson/classnames/blob/master/HISTORY.md).
+
+## Usage
+
+The `classNames` function takes any number of arguments which can be a string or object.
+The argument `'foo'` is short for `{ foo: true }`. If the value of the key is falsy, it won't be included in the output.
+
+```js
+classNames('foo', 'bar'); // => 'foo bar'
+classNames('foo', { bar: true }); // => 'foo bar'
+classNames({ 'foo-bar': true }); // => 'foo-bar'
+classNames({ 'foo-bar': false }); // => ''
+classNames({ foo: true }, { bar: true }); // => 'foo bar'
+classNames({ foo: true, bar: true }); // => 'foo bar'
+
+// lots of arguments of various types
+classNames('foo', { bar: true, duck: false }, 'baz', { quux: true }); // => 'foo bar baz quux'
+
+// other falsy values are just ignored
+classNames(null, false, 'bar', undefined, 0, 1, { baz: null }, ''); // => 'bar 1'
+```
+
+Arrays will be recursively flattened as per the rules above:
+
+```js
+var arr = ['b', { c: true, d: false }];
+classNames('a', arr); // => 'a b c'
+```
+
+### Dynamic class names with ES2015
+
+If you're in an environment that supports [computed keys](http://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer) (available in ES2015 and Babel) you can use dynamic class names:
+
+```js
+let buttonType = 'primary';
+classNames({ [`btn-${buttonType}`]: true });
+```
+
+### Usage with React.js
+
+This package is the official replacement for `classSet`, which was originally shipped in the React.js Addons bundle.
+
+One of its primary use cases is to make dynamic and conditional className props simpler to work with (especially more so than conditional string manipulation). So where you may have the following code to generate a `className` prop for a `<button>` in React:
+
+```js
+var Button = React.createClass({
+  // ...
+  render () {
+    var btnClass = 'btn';
+    if (this.state.isPressed) btnClass += ' btn-pressed';
+    else if (this.state.isHovered) btnClass += ' btn-over';
+    return <button className={btnClass}>{this.props.label}</button>;
+  }
+});
+```
+
+You can express the conditional classes more simply as an object:
+
+```js
+var classNames = require('classnames');
+
+var Button = React.createClass({
+  // ...
+  render () {
+    var btnClass = classNames({
+      'btn': true,
+      'btn-pressed': this.state.isPressed,
+      'btn-over': !this.state.isPressed && this.state.isHovered
+    });
+    return <button className={btnClass}>{this.props.label}</button>;
+  }
+});
+```
+
+Because you can mix together object, array and string arguments, supporting optional className props is also simpler as only truthy arguments get included in the result:
+
+```js
+var btnClass = classNames('btn', this.props.className, {
+  'btn-pressed': this.state.isPressed,
+  'btn-over': !this.state.isPressed && this.state.isHovered
+});
+```
+
+
+### Alternate `dedupe` version
+
+There is an alternate version of `classNames` available which correctly dedupes classes and ensures that falsy classes specified in later arguments are excluded from the result set.
+
+This version is slower (about 5x) so it is offered as an opt-in.
+
+To use the dedupe version with node, browserify or webpack:
+
+```js
+var classNames = require('classnames/dedupe');
+
+classNames('foo', 'foo', 'bar'); // => 'foo bar'
+classNames('foo', { foo: false, bar: true }); // => 'bar'
+```
+
+For standalone (global / AMD) use, include `dedupe.js` in a `<script>` tag on your page.
+
+
+### Alternate `bind` version (for [css-modules](https://github.com/css-modules/css-modules))
+
+If you are using [css-modules](https://github.com/css-modules/css-modules), or a similar approach to abstract class "names" and the real `className` values that are actually output to the DOM, you may want to use the `bind` variant.
+
+_Note that in ES2015 environments, it may be better to use the "dynamic class names" approach documented above._
+
+```js
+var classNames = require('classnames/bind');
+
+var styles = {
+  foo: 'abc',
+  bar: 'def',
+  baz: 'xyz'
+};
+
+var cx = classNames.bind(styles);
+
+var className = cx('foo', ['bar'], { baz: true }); // => "abc def xyz"
+```
+
+Real-world example:
+
+```js
+/* components/submit-button.js */
+import { Component } from 'react';
+import classNames from 'classnames/bind';
+import styles from './submit-button.css';
+
+let cx = classNames.bind(styles);
+
+export default class SubmitButton extends Component {
+  render () {
+    let text = this.props.store.submissionInProgress ? 'Processing...' : 'Submit';
+    let className = cx({
+      base: true,
+      inProgress: this.props.store.submissionInProgress,
+      error: this.props.store.errorOccurred,
+      disabled: this.props.form.valid,
+    });
+    return <button className={className}>{text}</button>;
+  }
+};
+
+```
+
+
+## Polyfills needed to support older browsers
+
+#### `classNames >=2.0.0`
+
+`Array.isArray`: see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) for details about unsupported older browsers (e.g. <= IE8) and a simple polyfill.
+
+`Object.keys`: see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys) for details about unsupported older browsers (e.g. <= IE8) and a simple polyfill. This is only used in `dedupe.js`.
+
+## License
+
+[MIT](LICENSE). Copyright (c) 2016 Jed Watson.

static/js/ketcher2/node_modules/classnames/bind.js

@@ -0,0 +1,48 @@
+/*!
+  Copyright (c) 2016 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var hasOwn = {}.hasOwnProperty;
+
+	function classNames () {
+		var classes = [];
+
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			if (!arg) continue;
+
+			var argType = typeof arg;
+
+			if (argType === 'string' || argType === 'number') {
+				classes.push(this && this[arg] || arg);
+			} else if (Array.isArray(arg)) {
+				classes.push(classNames.apply(this, arg));
+			} else if (argType === 'object') {
+				for (var key in arg) {
+					if (hasOwn.call(arg, key) && arg[key]) {
+						classes.push(this && this[key] || key);
+					}
+				}
+			}
+		}
+
+		return classes.join(' ');
+	}
+
+	if (typeof module !== 'undefined' && module.exports) {
+		module.exports = classNames;
+	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
+		// register as 'classnames', consistent with npm package name
+		define('classnames', [], function () {
+			return classNames;
+		});
+	} else {
+		window.classNames = classNames;
+	}
+}());

static/js/ketcher2/node_modules/classnames/bower.json

@@ -0,0 +1,37 @@
+{
+  "name": "classnames",
+  "version": "2.2.5",
+  "description": "A simple utility for conditionally joining classNames together",
+  "main": [
+    "index.js",
+    "bind.js",
+    "dedupe.js"
+  ],
+  "homepage": "https://github.com/JedWatson/classnames",
+  "authors": [
+    "Jed Watson"
+  ],
+  "moduleType": [
+    "amd",
+    "globals",
+    "node"
+  ],
+  "keywords": [
+    "react",
+    "css",
+    "classes",
+    "classname",
+    "classnames",
+    "util",
+    "utility"
+  ],
+  "license": "MIT",
+  "ignore": [
+    ".editorconfig",
+    ".gitignore",
+    "gulpfile.js",
+    "package.json",
+    "node_modules",
+    "tests.js"
+  ]
+}

static/js/ketcher2/node_modules/classnames/dedupe.js

@@ -0,0 +1,109 @@
+/*!
+  Copyright (c) 2016 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var classNames = (function () {
+		// don't inherit from Object so we can skip hasOwnProperty check later
+		// http://stackoverflow.com/questions/15518328/creating-js-object-with-object-createnull#answer-21079232
+		function StorageObject() {}
+		StorageObject.prototype = Object.create(null);
+
+		function _parseArray (resultSet, array) {
+			var length = array.length;
+
+			for (var i = 0; i < length; ++i) {
+				_parse(resultSet, array[i]);
+			}
+		}
+
+		var hasOwn = {}.hasOwnProperty;
+
+		function _parseNumber (resultSet, num) {
+			resultSet[num] = true;
+		}
+
+		function _parseObject (resultSet, object) {
+			for (var k in object) {
+				if (hasOwn.call(object, k)) {
+					// set value to false instead of deleting it to avoid changing object structure
+					// https://www.smashingmagazine.com/2012/11/writing-fast-memory-efficient-javascript/#de-referencing-misconceptions
+					resultSet[k] = !!object[k];
+				}
+			}
+		}
+
+		var SPACE = /\s+/;
+		function _parseString (resultSet, str) {
+			var array = str.split(SPACE);
+			var length = array.length;
+
+			for (var i = 0; i < length; ++i) {
+				resultSet[array[i]] = true;
+			}
+		}
+
+		function _parse (resultSet, arg) {
+			if (!arg) return;
+			var argType = typeof arg;
+
+			// 'foo bar'
+			if (argType === 'string') {
+				_parseString(resultSet, arg);
+
+			// ['foo', 'bar', ...]
+			} else if (Array.isArray(arg)) {
+				_parseArray(resultSet, arg);
+
+			// { 'foo': true, ... }
+			} else if (argType === 'object') {
+				_parseObject(resultSet, arg);
+
+			// '130'
+			} else if (argType === 'number') {
+				_parseNumber(resultSet, arg);
+			}
+		}
+
+		function _classNames () {
+			// don't leak arguments
+			// https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
+			var len = arguments.length;
+			var args = Array(len);
+			for (var i = 0; i < len; i++) {
+				args[i] = arguments[i];
+			}
+
+			var classSet = new StorageObject();
+			_parseArray(classSet, args);
+
+			var list = [];
+
+			for (var k in classSet) {
+				if (classSet[k]) {
+					list.push(k)
+				}
+			}
+
+			return list.join(' ');
+		}
+
+		return _classNames;
+	})();
+
+	if (typeof module !== 'undefined' && module.exports) {
+		module.exports = classNames;
+	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
+		// register as 'classnames', consistent with npm package name
+		define('classnames', [], function () {
+			return classNames;
+		});
+	} else {
+		window.classNames = classNames;
+	}
+}());

static/js/ketcher2/node_modules/classnames/index.js

@@ -0,0 +1,48 @@
+/*!
+  Copyright (c) 2016 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var hasOwn = {}.hasOwnProperty;
+
+	function classNames () {
+		var classes = [];
+
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			if (!arg) continue;
+
+			var argType = typeof arg;
+
+			if (argType === 'string' || argType === 'number') {
+				classes.push(arg);
+			} else if (Array.isArray(arg)) {
+				classes.push(classNames.apply(null, arg));
+			} else if (argType === 'object') {
+				for (var key in arg) {
+					if (hasOwn.call(arg, key) && arg[key]) {
+						classes.push(key);
+					}
+				}
+			}
+		}
+
+		return classes.join(' ');
+	}
+
+	if (typeof module !== 'undefined' && module.exports) {
+		module.exports = classNames;
+	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
+		// register as 'classnames', consistent with npm package name
+		define('classnames', [], function () {
+			return classNames;
+		});
+	} else {
+		window.classNames = classNames;
+	}
+}());

static/js/ketcher2/node_modules/classnames/package.json

@@ -0,0 +1,61 @@
+{
+  "_from": "classnames@2.2.5",
+  "_id": "classnames@2.2.5",
+  "_inBundle": false,
+  "_integrity": "sha1-+zgB1FNGdknvNgPH1hoCvRKb3m0=",
+  "_location": "/classnames",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "classnames@2.2.5",
+    "name": "classnames",
+    "escapedName": "classnames",
+    "rawSpec": "2.2.5",
+    "saveSpec": null,
+    "fetchSpec": "2.2.5"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmjs.org/classnames/-/classnames-2.2.5.tgz",
+  "_shasum": "fb3801d453467649ef3603c7d61a02bd129bde6d",
+  "_spec": "classnames@2.2.5",
+  "_where": "/home/manfred/enviPath/ketcher2/ketcher",
+  "author": {
+    "name": "Jed Watson"
+  },
+  "bugs": {
+    "url": "https://github.com/JedWatson/classnames/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "A simple utility for conditionally joining classNames together",
+  "devDependencies": {
+    "benchmark": "^1.0.0",
+    "mocha": "^2.1.0"
+  },
+  "homepage": "https://github.com/JedWatson/classnames#readme",
+  "keywords": [
+    "react",
+    "css",
+    "classes",
+    "classname",
+    "classnames",
+    "util",
+    "utility"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "classnames",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JedWatson/classnames.git"
+  },
+  "scripts": {
+    "benchmarks": "node ./benchmarks/run",
+    "test": "npm run unit",
+    "unit": "mocha tests/*.js"
+  },
+  "version": "2.2.5"
+}