first commit

node_modules/math-interval-parser/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Dmitry Semigradsky <semigradskyd@gmail.com> (https://github.com/Semigradsky)
+
+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.

node_modules/math-interval-parser/README.md

@@ -0,0 +1,50 @@
+# Math interval parser
+[![Build Status](https://travis-ci.org/Semigradsky/math-interval-parser.svg)](https://travis-ci.org/Semigradsky/math-interval-parser) [![Dependency Status](https://david-dm.org/Semigradsky/math-interval-parser.svg)](https://david-dm.org/Semigradsky/math-interval-parser) [![Coverage Status](https://coveralls.io/repos/Semigradsky/math-interval-parser/badge.svg)](https://coveralls.io/r/Semigradsky/math-interval-parser)
+
+> Parse math interval. Notation is accepted as part of [ISO 31-11](http://en.wikipedia.org/wiki/ISO_31-11).
+
+
+## Install
+
+```sh
+$ npm install --save math-interval-parser
+```
+
+
+## Usage
+
+```js
+import intervalParse from 'math-interval-parser';
+// or `var intervalParse = require('math-interval-parser').default;
+
+intervalParse('(-10,20.2]'); // or intervalParse(']-10,20.2]');
+//=> {
+//=>     from: {
+//=>         value: -10,
+//=>         included: false,
+//=>     },
+//=>     to: {
+//=>         value: 20.2,
+//=>         included: true
+//=>     }
+//=> }
+
+intervalParse('[1e3,)'); // or intervalParse('[1e3,Infinity)');
+//=> {
+//=>     from: {
+//=>         value: 1000,
+//=>         included: true,
+//=>     },
+//=>     to: {
+//=>         value: Infinity,
+//=>         included: false
+//=>     }
+//=> }
+```
+
+See tests for more details.
+
+
+## License
+
+MIT © Dmitry Semigradsky

node_modules/math-interval-parser/dts-bundle.js

@@ -0,0 +1,7 @@
+var dts = require('dts-bundle');
+var path = require('path');
+
+dts.bundle({
+    name: 'math-interval-parser',
+    main: path.join('lib', 'index.d.ts')
+});

node_modules/math-interval-parser/lib/index.d.ts

@@ -0,0 +1,11 @@
+export interface MathInterval {
+    from: {
+        value: number;
+        included: boolean;
+    };
+    to: {
+        value: number;
+        included: boolean;
+    };
+}
+export default function entry(str: string): (MathInterval | null);

node_modules/math-interval-parser/lib/index.js

@@ -0,0 +1,65 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+var patternParts = {
+    value: '[-+]?(?:Infinity|[[0-9]*\\.?\\d*(?:[eE][-+]?\\d+)?)',
+    leftBrace: '[\\(\\]\\[]',
+    delimeter: ',',
+    rightBrace: '[\\)\\]\\[]',
+};
+var PATTERN = new RegExp("(" + patternParts.leftBrace + ")" +
+    ("(" + patternParts.value + ")?") +
+    ("(" + patternParts.delimeter + ")?") +
+    ("(" + patternParts.value + ")?") +
+    ("(" + patternParts.rightBrace + ")"));
+function execPattern(str) {
+    var match = PATTERN.exec(str);
+    if (!match) {
+        return null;
+    }
+    var _ = match[0], leftBrace = match[1], fromValue = match[2], delimeter = match[3], toValue = match[4], rightBrace = match[5];
+    return {
+        leftBrace: leftBrace,
+        fromValue: fromValue,
+        delimeter: delimeter,
+        toValue: toValue,
+        rightBrace: rightBrace,
+    };
+}
+function parse(str) {
+    var match = execPattern(str);
+    if (!match) {
+        return null;
+    }
+    return {
+        from: {
+            value: match.fromValue !== undefined ?
+                +match.fromValue :
+                -Infinity,
+            included: match.leftBrace === '['
+        },
+        to: {
+            value: match.toValue !== undefined ?
+                +match.toValue :
+                (match.delimeter ?
+                    +Infinity :
+                    match.fromValue !== undefined ?
+                        +match.fromValue :
+                        NaN),
+            included: match.rightBrace === ']'
+        }
+    };
+}
+function check(interval) {
+    if (interval.from.value === interval.to.value) {
+        return interval.from.included && interval.to.included;
+    }
+    return Math.min(interval.from.value, interval.to.value) === interval.from.value;
+}
+function entry(str) {
+    var interval = parse(str);
+    if (!interval || !check(interval)) {
+        return null;
+    }
+    return interval;
+}
+exports.default = entry;

node_modules/math-interval-parser/lib/math-interval-parser.d.ts

@@ -0,0 +1,16 @@
+// Generated by dts-bundle v0.7.3
+
+declare module 'math-interval-parser' {
+    export interface MathInterval {
+        from: {
+            value: number;
+            included: boolean;
+        };
+        to: {
+            value: number;
+            included: boolean;
+        };
+    }
+    export default function entry(str: string): (MathInterval | null);
+}
+

node_modules/math-interval-parser/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "math-interval-parser",
+  "version": "2.0.1",
+  "description": "Parse math interval",
+  "license": "MIT",
+  "repository": "Semigradsky/math-interval-parser",
+  "author": {
+    "name": "Dmitry Semigradsky",
+    "email": "semigradskyd@gmail.com",
+    "url": "https://github.com/Semigradsky"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha --reporter spec",
+    "init": "npm i",
+    "lint": "tslint src/index.ts",
+    "build": "tsc && node dts-bundle.js",
+    "coveralls": "istanbul cover _mocha --report lcovonly -- -R spec && cat ./coverage/lcov.info | coveralls && rm -rf ./coverage"
+  },
+  "main": "lib/index.js",
+  "typescript": {
+    "definition": "lib/math-interval-parser.d.ts"
+  },
+  "keywords": [
+    "mathematics",
+    "interval",
+    "math",
+    "parse",
+    "parsing"
+  ],
+  "devDependencies": {
+    "coveralls": "^3.0.2",
+    "dts-bundle": "~0.7",
+    "istanbul": "^0.3.13",
+    "mocha": "^5.2.0",
+    "mocha-lcov-reporter": "^1.3.0",
+    "tslint": "^5.11.0",
+    "typescript": "2.*"
+  }
+}

node_modules/math-interval-parser/test.js

@@ -0,0 +1,101 @@
+'use strict';
+
+var assert = require('assert');
+var parseInterval = require('./').default;
+
+describe('Parser', function () {
+
+	describe('should return null if', function () {
+
+		it('input is invalid', function () {
+			assert.equal(null, parseInterval('INVALID INPUT'));
+			assert.equal(null, parseInterval('1,2'));
+			assert.equal(null, parseInterval('[]'));
+			assert.equal(null, parseInterval(']['));
+		});
+
+		it('left value more than right value', function () {
+			assert.equal(null, parseInterval('[2,-2]'));
+			assert.equal(null, parseInterval('[Infinity,-2]'));
+			assert.equal(null, parseInterval('[1,-Infinity]'));
+		});
+
+		it('value equals, but not included to interval', function () {
+			assert.equal(null, parseInterval('[2,2)'));
+			assert.equal(null, parseInterval('(2,2]'));
+			assert.equal(null, parseInterval('[2,2['));
+			assert.equal(null, parseInterval(']2,2]'));
+			assert.equal(null, parseInterval('(2,2)'));
+			assert.equal(null, parseInterval(']2,2['));
+			assert.equal(null, parseInterval('(2)'));
+			assert.equal(null, parseInterval(']2['));
+			assert.equal(null, parseInterval('(Infinity,Infinity]'));
+		});
+
+	});
+
+	describe('should right work', function () {
+
+		it('in full form', function () {
+			assert.deepEqual({
+				from: {
+					value: -10,
+					included: true
+				},
+				to: {
+					value: 10,
+					included: false
+				}
+			}, parseInterval('[-10,10)'));
+		});
+
+		it('in not full form', function () {
+			assert.deepEqual({
+				from: {
+					value: 10,
+					included: true
+				},
+				to: {
+					value: 10,
+					included: true
+				}
+			}, parseInterval('[10]'));
+
+			assert.deepEqual({
+				from: {
+					value: 10,
+					included: true
+				},
+				to: {
+					value: Infinity,
+					included: true
+				}
+			}, parseInterval('[10,]'));
+
+			assert.deepEqual({
+				from: {
+					value: -Infinity,
+					included: true
+				},
+				to: {
+					value: 10,
+					included: true
+				}
+			}, parseInterval('[,10]'));
+
+			assert.deepEqual({
+				from: {
+					value: -Infinity,
+					included: true
+				},
+				to: {
+					value: Infinity,
+					included: true
+				}
+			}, parseInterval('[,]'));
+
+		});
+
+	});
+
+});