Current Dev State

static/js/ketcher2/node_modules/make-error/README.md

@@ -0,0 +1,111 @@
+# make-error [![Build Status](https://img.shields.io/travis/JsCommunity/make-error/master.svg)](http://travis-ci.org/JsCommunity/make-error)
+
+> Make your own error types!
+
+
+## Features
+
+- Compatible Node & browsers
+- `instanceof` support
+- `error.name` & `error.stack` support
+- compatible with [CSP](https://en.wikipedia.org/wiki/Content_Security_Policy) (i.e. no `eval()`)
+
+## Installation
+
+### Node & [Browserify](http://browserify.org/)/[Webpack](https://webpack.js.org/)
+
+Installation of the [npm package](https://npmjs.org/package/make-error):
+
+```
+> npm install --save make-error
+```
+
+Then require the package:
+
+```javascript
+var makeError = require('make-error');
+```
+
+### Browser
+
+You can directly use the build provided at [unpkg.com](https://unpkg.com):
+
+```html
+<script src="https://unpkg.com/make-error@1/dist/make-error.js"></script>
+```
+
+## Usage
+
+### Basic named error
+
+```javascript
+var CustomError = makeError('CustomError')
+
+// Parameters are forwarded to the super class (here Error).
+throw new CustomError('a message')
+```
+
+### Advanced error class
+
+```javascript
+function CustomError (customValue) {
+  CustomError.super.call(this, 'custom error message')
+
+  this.customValue = customValue
+}
+makeError(CustomError)
+
+// Feel free to extend the prototype.
+CustomError.prototype.myMethod = function CustomError$myMethod () {
+  console.log('CustomError.myMethod (%s, %s)', this.code, this.message)
+}
+
+//-----
+
+try {
+  throw new CustomError(42)
+} catch (error) {
+  error.myMethod()
+}
+```
+
+### Specialized error
+
+```javascript
+var SpecializedError = makeError('SpecializedError', CustomError);
+
+throw new SpecializedError(42);
+```
+
+### Inheritance
+
+> Best for ES2015+.
+
+```javascript
+import {BaseError} from 'make-error'
+
+class CustomError extends BaseError {
+  constructor () {
+    super('custom error message')
+  }
+}
+```
+
+## Related
+
+- [make-error-cause](https://www.npmjs.com/package/make-error-cause): Make your own error types, with a cause!
+
+## Contributions
+
+Contributions are *very* welcomed, either on the documentation or on
+the code.
+
+You may:
+
+- report any [issue](https://github.com/JsCommunity/make-error/issues)
+  you've encountered;
+- fork and create a pull request.
+
+## License
+
+ISC © [Julien Fontanet](http://julien.isonoe.net)

static/js/ketcher2/node_modules/make-error/dist/make-error.js

@@ -0,0 +1 @@
+!function(f){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=f();else if("function"==typeof define&&define.amd)define([],f);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).makeError=f()}}(function(){return function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a="function"==typeof require&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n||e)},l,l.exports,e,t,n,r)}return n[o].exports}for(var i="function"==typeof require&&require,o=0;o<r.length;o++)s(r[o]);return s}({1:[function(require,module,exports){"use strict";function BaseError(message){message&&defineProperty(this,"message",{configurable:!0,value:message,writable:!0});var cname=this.constructor.name;cname&&cname!==this.name&&defineProperty(this,"name",{configurable:!0,value:cname,writable:!0}),captureStackTrace(this,this.constructor)}function makeError(constructor,super_){if(null==super_||super_===Error)super_=BaseError;else if("function"!=typeof super_)throw new TypeError("super_ should be a function");var name;if("string"==typeof constructor)name=constructor,constructor=function(){super_.apply(this,arguments)},setFunctionName&&(setFunctionName(constructor,name),name=null);else if("function"!=typeof constructor)throw new TypeError("constructor should be either a string or a function");constructor.super_=constructor.super=super_;var properties={constructor:{configurable:!0,value:constructor,writable:!0}};return null!=name&&(properties.name={configurable:!0,value:name,writable:!0}),constructor.prototype=Object.create(super_.prototype,properties),constructor}var defineProperty=Object.defineProperty,captureStackTrace=Error.captureStackTrace;captureStackTrace||(captureStackTrace=function(error){var container=new Error;defineProperty(error,"stack",{configurable:!0,get:function(){var stack=container.stack;return defineProperty(this,"stack",{value:stack}),stack},set:function(stack){defineProperty(error,"stack",{configurable:!0,value:stack,writable:!0})}})}),BaseError.prototype=Object.create(Error.prototype,{constructor:{configurable:!0,value:BaseError,writable:!0}});var setFunctionName=function(){function setFunctionName(fn,name){return defineProperty(fn,"name",{configurable:!0,value:name})}try{var f=function(){};if(setFunctionName(f,"foo"),"foo"===f.name)return setFunctionName}catch(_){}}();(module.exports=makeError).BaseError=BaseError},{}]},{},[1])(1)});

static/js/ketcher2/node_modules/make-error/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Create a new error constructor instance.
+ */
+declare function makeError(name: string): makeError.Constructor<makeError.BaseError>;
+
+/**
+ * Set the constructor prototype to `BaseError`.
+ */
+declare function makeError<T extends Error>(super_: { new (...args: any[]): T }): makeError.Constructor<T & makeError.BaseError>;
+
+/**
+ * Create a specialized error instance.
+ */
+declare function makeError<T extends Error>(name: string | Function, super_: { new (...args: any[]): T }): makeError.Constructor<T>;
+
+declare module makeError {
+  /**
+   * Use with ES2015+ inheritance.
+   */
+  export class BaseError implements Error {
+    message: string;
+    name: string;
+    stack: string;
+
+    constructor(message?: string);
+  }
+
+  export interface Constructor <T> {
+    new (message?: string): T
+    super_: any
+    prototype: T
+  }
+}
+
+export = makeError;

static/js/ketcher2/node_modules/make-error/index.js

@@ -0,0 +1,142 @@
+// ISC @ Julien Fontanet
+
+'use strict'
+
+// ===================================================================
+
+var defineProperty = Object.defineProperty
+
+// -------------------------------------------------------------------
+
+var captureStackTrace = Error.captureStackTrace
+if (!captureStackTrace) {
+  captureStackTrace = function captureStackTrace (error) {
+    var container = new Error()
+
+    defineProperty(error, 'stack', {
+      configurable: true,
+      get: function getStack () {
+        var stack = container.stack
+
+        // Replace property with value for faster future accesses.
+        defineProperty(this, 'stack', {
+          value: stack
+        })
+
+        return stack
+      },
+      set: function setStack (stack) {
+        defineProperty(error, 'stack', {
+          configurable: true,
+          value: stack,
+          writable: true
+        })
+      }
+    })
+  }
+}
+
+// -------------------------------------------------------------------
+
+function BaseError (message) {
+  if (message) {
+    defineProperty(this, 'message', {
+      configurable: true,
+      value: message,
+      writable: true
+    })
+  }
+
+  var cname = this.constructor.name
+  if (
+    cname &&
+    cname !== this.name
+  ) {
+    defineProperty(this, 'name', {
+      configurable: true,
+      value: cname,
+      writable: true
+    })
+  }
+
+  captureStackTrace(this, this.constructor)
+}
+
+BaseError.prototype = Object.create(Error.prototype, {
+  // See: https://github.com/JsCommunity/make-error/issues/4
+  constructor: {
+    configurable: true,
+    value: BaseError,
+    writable: true
+  }
+})
+
+// -------------------------------------------------------------------
+
+// Sets the name of a function if possible (depends of the JS engine).
+var setFunctionName = (function () {
+  function setFunctionName (fn, name) {
+    return defineProperty(fn, 'name', {
+      configurable: true,
+      value: name
+    })
+  }
+  try {
+    var f = function () {}
+    setFunctionName(f, 'foo')
+    if (f.name === 'foo') {
+      return setFunctionName
+    }
+  } catch (_) {}
+})()
+
+// -------------------------------------------------------------------
+
+function makeError (constructor, super_) {
+  if (super_ == null || super_ === Error) {
+    super_ = BaseError
+  } else if (typeof super_ !== 'function') {
+    throw new TypeError('super_ should be a function')
+  }
+
+  var name
+  if (typeof constructor === 'string') {
+    name = constructor
+    constructor = function () { super_.apply(this, arguments) }
+
+    // If the name can be set, do it once and for all.
+    if (setFunctionName) {
+      setFunctionName(constructor, name)
+      name = null
+    }
+  } else if (typeof constructor !== 'function') {
+    throw new TypeError('constructor should be either a string or a function')
+  }
+
+  // Also register the super constructor also as `constructor.super_` just
+  // like Node's `util.inherits()`.
+  constructor.super_ = constructor['super'] = super_
+
+  var properties = {
+    constructor: {
+      configurable: true,
+      value: constructor,
+      writable: true
+    }
+  }
+
+  // If the name could not be set on the constructor, set it on the
+  // prototype.
+  if (name != null) {
+    properties.name = {
+      configurable: true,
+      value: name,
+      writable: true
+    }
+  }
+  constructor.prototype = Object.create(super_.prototype, properties)
+
+  return constructor
+}
+exports = module.exports = makeError
+exports.BaseError = BaseError

static/js/ketcher2/node_modules/make-error/package.json

@@ -0,0 +1,77 @@
+{
+  "_from": "make-error@^1.2.0",
+  "_id": "make-error@1.3.0",
+  "_inBundle": false,
+  "_integrity": "sha1-Uq06M5zPEM5itAQLcI/nByRLi5Y=",
+  "_location": "/make-error",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "make-error@^1.2.0",
+    "name": "make-error",
+    "escapedName": "make-error",
+    "rawSpec": "^1.2.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.2.0"
+  },
+  "_requiredBy": [
+    "/make-error-cause"
+  ],
+  "_resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.0.tgz",
+  "_shasum": "52ad3a339ccf10ce62b4040b708fe707244b8b96",
+  "_spec": "make-error@^1.2.0",
+  "_where": "/home/manfred/enviPath/ketcher2/ketcher/node_modules/make-error-cause",
+  "author": {
+    "name": "Julien Fontanet",
+    "email": "julien.fontanet@isonoe.net"
+  },
+  "bugs": {
+    "url": "https://github.com/JsCommunity/make-error/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Make your own error types!",
+  "devDependencies": {
+    "browserify": "^14.3.0",
+    "husky": "^0.13.3",
+    "jest": "^20.0.3",
+    "standard": "^10.0.2",
+    "uglify-js": "^3.0.10"
+  },
+  "files": [
+    "dist/",
+    "index.js",
+    "index.d.ts"
+  ],
+  "homepage": "https://github.com/JsCommunity/make-error",
+  "keywords": [
+    "create",
+    "custom",
+    "derive",
+    "error",
+    "errors",
+    "extend",
+    "extending",
+    "extension",
+    "factory",
+    "inherit",
+    "make",
+    "subclass"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "name": "make-error",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/JsCommunity/make-error.git"
+  },
+  "scripts": {
+    "commitmsg": "yarn test",
+    "dev-test": "jest --watch",
+    "prepublish": "mkdir -p dist && browserify -s makeError index.js | uglifyjs -c > dist/make-error.js",
+    "pretest": "standard",
+    "test": "jest"
+  },
+  "version": "1.3.0"
+}