Added Gulp.js for compiling SCSS stylesheets

node_modules/es6-weak-map/.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = tab
+
+[{*.json,*.yml}]
+indent_style = space
+indent_size = 2

node_modules/es6-weak-map/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### [2.0.3](https://github.com/medikoo/es6-weak-map/compare/v2.0.2...v2.0.3) (2019-06-07)

node_modules/es6-weak-map/CHANGES

@@ -0,0 +1,45 @@
+v2.0.2  --  2017.03.15
+* Update dependencies
+
+v2.0.1  --  2015.10.02
+* Update to use es6-symbol at v3
+
+v2.0.0  --  2015.09.04
+* Relax native implementation detection, stringification of instance should returm
+  expected result (not necesarily prototype)
+
+v1.0.2  --  2015.05.07
+* Add "ponyfill" keyword to meta description. Fixes #7
+
+v1.0.1  --  2015.04.14
+* Fix isNativeImplemented, so it's not affected by #3619 V8 bug
+* Fix internal prototype resolution, in case where isNativeImplemented was true, and
+  native implementation was shadowed it got into stack overflow
+
+v1.0.0  --  2015.04.13
+* It's v0.1.3 republished as v1.0.0
+
+v0.1.4  --  2015.04.13
+* Republish v0.1.2 as v0.1.4 due to breaking changes
+  (v0.1.3 should have been published as next major)
+
+v0.1.3  --  2015.04.12
+* Update up to changes in specification (require new, remove clear method)
+* Improve native implementation validation
+* Configure lint scripts
+* Rename LICENCE to LICENSE
+
+v0.1.2  --  2014.09.01
+* Use internal random and unique id generator instead of external (time-uuid based).
+  Global uniqueness is not needed in scope of this module. Fixes #1
+
+v0.1.1  --  2014.05.15
+* Improve valid WeakMap detection
+
+v0.1.0  --  2014.04.29
+* Assure to depend only npm hosted dependencies
+* Update to use latest versions of dependencies
+* Use ES6 symbols internally
+
+v0.0.0  --  2013.10.24
+Initial (dev version)

node_modules/es6-weak-map/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2013-2018, Mariusz Nowak, @medikoo, medikoo.com
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

node_modules/es6-weak-map/README.md

@@ -0,0 +1,78 @@
+[![Build status][nix-build-image]][nix-build-url]
+[![Windows status][win-build-image]][win-build-url]
+![Transpilation status][transpilation-image]
+[![npm version][npm-image]][npm-url]
+
+# es6-weak-map
+
+## WeakMap collection as specified in ECMAScript6
+
+_Roughly inspired by Mark Miller's and Kris Kowal's [WeakMap implementation](https://github.com/drses/weak-map)_.
+
+Differences are:
+
+-   Assumes compliant ES5 environment (no weird ES3 workarounds or hacks)
+-   Well modularized CJS style
+-   Based on one solution.
+
+### Limitations
+
+-   Will fail on non extensible objects provided as keys
+
+### Installation
+
+    $ npm install es6-weak-map
+
+To port it to Browser or any other (non CJS) environment, use your favorite CJS bundler. No favorite yet? Try: [Browserify](http://browserify.org/), [Webmake](https://github.com/medikoo/modules-webmake) or [Webpack](http://webpack.github.io/)
+
+### Usage
+
+If you want to make sure your environment implements `WeakMap`, do:
+
+```javascript
+require("es6-weak-map/implement");
+```
+
+If you'd like to use native version when it exists and fallback to polyfill if it doesn't, but without implementing `WeakMap` on global scope, do:
+
+```javascript
+var WeakMap = require("es6-weak-map");
+```
+
+If you strictly want to use polyfill even if native `WeakMap` exists, do:
+
+```javascript
+var WeakMap = require("es6-weak-map/polyfill");
+```
+
+#### API
+
+Best is to refer to [specification](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-weakmap-objects). Still if you want quick look, follow example:
+
+```javascript
+var WeakMap = require("es6-weak-map");
+
+var map = new WeakMap();
+var obj = {};
+
+map.set(obj, "foo"); // map
+map.get(obj); // 'foo'
+map.has(obj); // true
+map.delete(obj); // true
+map.get(obj); // undefined
+map.has(obj); // false
+map.set(obj, "bar"); // map
+map.has(obj); // false
+```
+
+## Tests
+
+    $ npm test
+
+[nix-build-image]: https://semaphoreci.com/api/v1/medikoo-org/es6-weak-map/branches/master/shields_badge.svg
+[nix-build-url]: https://semaphoreci.com/medikoo-org/es6-weak-map
+[win-build-image]: https://ci.appveyor.com/api/projects/status/1c73c57pg4s6lwmu?svg=true
+[win-build-url]: https://ci.appveyor.com/project/medikoo/es6-weak-map
+[transpilation-image]: https://img.shields.io/badge/transpilation-free-brightgreen.svg
+[npm-image]: https://img.shields.io/npm/v/es6-weak-map.svg
+[npm-url]: https://www.npmjs.com/package/es6-weak-map

node_modules/es6-weak-map/implement.js

@@ -0,0 +1,11 @@
+"use strict";
+
+if (!require("./is-implemented")()) {
+	Object.defineProperty(require("es5-ext/global"), "WeakMap",
+		{
+			value: require("./polyfill"),
+			configurable: true,
+			enumerable: false,
+			writable: true
+		});
+}

node_modules/es6-weak-map/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./is-implemented")() ? WeakMap : require("./polyfill");

node_modules/es6-weak-map/is-implemented.js

@@ -0,0 +1,21 @@
+"use strict";
+
+module.exports = function () {
+	var weakMap, obj;
+
+	if (typeof WeakMap !== "function") return false;
+	try {
+		// WebKit doesn't support arguments and crashes
+		weakMap = new WeakMap([[obj = {}, "one"], [{}, "two"], [{}, "three"]]);
+	} catch (e) {
+		return false;
+	}
+	if (String(weakMap) !== "[object WeakMap]") return false;
+	if (typeof weakMap.set !== "function") return false;
+	if (weakMap.set({}, 1) !== weakMap) return false;
+	if (typeof weakMap.delete !== "function") return false;
+	if (typeof weakMap.has !== "function") return false;
+	if (weakMap.get(obj) !== "one") return false;
+
+	return true;
+};

node_modules/es6-weak-map/is-native-implemented.js

@@ -0,0 +1,8 @@
+// Exports true if environment provides native `WeakMap` implementation, whatever that is.
+
+"use strict";
+
+module.exports = (function () {
+	if (typeof WeakMap !== "function") return false;
+	return Object.prototype.toString.call(new WeakMap()) === "[object WeakMap]";
+}());

node_modules/es6-weak-map/is-weak-map.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var toStringTagSymbol = require("es6-symbol").toStringTag
+
+  , objToString = Object.prototype.toString
+  , id = "[object WeakMap]"
+  , Global = typeof WeakMap === "undefined" ? null : WeakMap;
+
+module.exports = function (value) {
+	return (value && ((Global && (value instanceof Global)) ||
+			(objToString.call(value) === id) || (value[toStringTagSymbol] === "WeakMap"))) ||
+			false;
+};

node_modules/es6-weak-map/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "es6-weak-map",
+  "version": "2.0.3",
+  "description": "ECMAScript6 WeakMap polyfill",
+  "author": "Mariusz Nowak <medyk@medikoo.com> (http://www.medikoo.com/)",
+  "keywords": [
+    "map",
+    "weakmap",
+    "collection",
+    "es6",
+    "harmony",
+    "list",
+    "hash",
+    "gc",
+    "ponyfill"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/medikoo/es6-weak-map.git"
+  },
+  "dependencies": {
+    "d": "1",
+    "es5-ext": "^0.10.46",
+    "es6-iterator": "^2.0.3",
+    "es6-symbol": "^3.1.1"
+  },
+  "devDependencies": {
+    "eslint": "^5.5",
+    "eslint-config-medikoo-es5": "^1.7",
+    "tad": "^0.2.8"
+  },
+  "eslintConfig": {
+    "extends": "medikoo-es5",
+    "root": true,
+    "globals": {
+      "WeakMap": true
+    }
+  },
+  "scripts": {
+    "lint": "eslint --ignore-path=.gitignore .",
+    "test": "node ./node_modules/tad/bin/tad"
+  },
+  "license": "ISC"
+}

node_modules/es6-weak-map/polyfill.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var isValue           = require("es5-ext/object/is-value")
+  , setPrototypeOf    = require("es5-ext/object/set-prototype-of")
+  , object            = require("es5-ext/object/valid-object")
+  , ensureValue       = require("es5-ext/object/valid-value")
+  , randomUniq        = require("es5-ext/string/random-uniq")
+  , d                 = require("d")
+  , getIterator       = require("es6-iterator/get")
+  , forOf             = require("es6-iterator/for-of")
+  , toStringTagSymbol = require("es6-symbol").toStringTag
+  , isNative          = require("./is-native-implemented")
+
+  , isArray = Array.isArray, defineProperty = Object.defineProperty
+  , objHasOwnProperty = Object.prototype.hasOwnProperty, getPrototypeOf = Object.getPrototypeOf
+  , WeakMapPoly;
+
+module.exports = WeakMapPoly = function (/* Iterable*/) {
+	var iterable = arguments[0], self;
+
+	if (!(this instanceof WeakMapPoly)) throw new TypeError("Constructor requires 'new'");
+	self = isNative && setPrototypeOf && (WeakMap !== WeakMapPoly)
+		? setPrototypeOf(new WeakMap(), getPrototypeOf(this)) : this;
+
+	if (isValue(iterable)) {
+		if (!isArray(iterable)) iterable = getIterator(iterable);
+	}
+	defineProperty(self, "__weakMapData__", d("c", "$weakMap$" + randomUniq()));
+	if (!iterable) return self;
+	forOf(iterable, function (val) {
+		ensureValue(val);
+		self.set(val[0], val[1]);
+	});
+	return self;
+};
+
+if (isNative) {
+	if (setPrototypeOf) setPrototypeOf(WeakMapPoly, WeakMap);
+	WeakMapPoly.prototype = Object.create(WeakMap.prototype, { constructor: d(WeakMapPoly) });
+}
+
+Object.defineProperties(WeakMapPoly.prototype, {
+	delete: d(function (key) {
+		if (objHasOwnProperty.call(object(key), this.__weakMapData__)) {
+			delete key[this.__weakMapData__];
+			return true;
+		}
+		return false;
+	}),
+	get: d(function (key) {
+		if (!objHasOwnProperty.call(object(key), this.__weakMapData__)) return undefined;
+		return key[this.__weakMapData__];
+	}),
+	has: d(function (key) {
+		return objHasOwnProperty.call(object(key), this.__weakMapData__);
+	}),
+	set: d(function (key, value) {
+		defineProperty(object(key), this.__weakMapData__, d("c", value));
+		return this;
+	}),
+	toString: d(function () {
+		return "[object WeakMap]";
+	})
+});
+defineProperty(WeakMapPoly.prototype, toStringTagSymbol, d("c", "WeakMap"));

node_modules/es6-weak-map/test/implement.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (t, a) {
+	a(typeof WeakMap, "function");
+};

node_modules/es6-weak-map/test/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = function (T, a) {
+	var obj = {};
+
+	a((new T([[obj, "foo"]])).get(obj), "foo");
+};

node_modules/es6-weak-map/test/is-implemented.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var globalObj = require("es5-ext/global")
+  , polyfill  = require("../polyfill");
+
+module.exports = function (t, a) {
+	var cache;
+
+	a(typeof t(), "boolean");
+	cache = globalObj.WeakMap;
+	globalObj.WeakMap = polyfill;
+	a(t(), true);
+	if (cache === undefined) delete globalObj.WeakMap;
+	else globalObj.WeakMap = cache;
+};

node_modules/es6-weak-map/test/is-native-implemented.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (t, a) {
+	a(typeof t, "boolean");
+};

node_modules/es6-weak-map/test/is-weak-map.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var WeakMapPoly = require("../polyfill");
+
+module.exports = function (t, a) {
+	a(t(undefined), false, "Undefined");
+	a(t(null), false, "Null");
+	a(t(true), false, "Primitive");
+	a(t("raz"), false, "String");
+	a(t({}), false, "Object");
+	a(t([]), false, "Array");
+	if (typeof WeakMap !== "undefined") {
+		a(t(new WeakMap()), true, "Native");
+	}
+	a(t(new WeakMapPoly()), true, "Polyfill");
+};

node_modules/es6-weak-map/test/polyfill.js

@@ -0,0 +1,23 @@
+"use strict";
+
+module.exports = function (T, a) {
+	var obj1 = {}, obj2 = {}, obj3 = {}, arr = [[obj1, "raz"], [obj2, "dwa"]], map = new T(arr);
+
+	a(map instanceof T, true, "WeakMap");
+	a(map.has(obj1), true, "Has: true");
+	a(map.get(obj1), "raz", "Get: contains");
+	a(map.has(obj3), false, "Has: false");
+	a(map.get(obj3), undefined, "Get: doesn't contain");
+	a(map.set(obj3, "trzy"), map, "Set: return");
+	a(map.has(obj3), true, "Add");
+	a(map.delete({}), false, "Delete: false");
+
+	a(map.delete(obj1), true, "Delete: true");
+	a(map.get(obj1), undefined, "Get: after delete");
+	a(map.has(obj1), false, "Has: after delete");
+
+	a.h1("Empty initialization");
+	map = new T();
+	map.set(obj1, "bar");
+	a(map.get(obj1), "bar");
+};

node_modules/es6-weak-map/test/valid-weak-map.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var WeakMapPoly = require("../polyfill");
+
+module.exports = function (t, a) {
+	var map;
+
+	a.throws(function () {
+		t(undefined);
+	}, TypeError, "Undefined");
+	a.throws(function () {
+		t(null);
+	}, TypeError, "Null");
+	a.throws(function () {
+		t(true);
+	}, TypeError, "Primitive");
+	a.throws(function () {
+		t("raz");
+	}, TypeError, "String");
+	a.throws(function () {
+		t({});
+	}, TypeError, "Object");
+	a.throws(function () {
+		t([]);
+	}, TypeError, "Array");
+	if (typeof WeakMap !== "undefined") {
+		map = new WeakMap();
+		a(t(map), map, "Native");
+	}
+	map = new WeakMapPoly();
+	a(t(map), map, "Polyfill");
+};

node_modules/es6-weak-map/valid-weak-map.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var isWeakMap = require("./is-weak-map");
+
+module.exports = function (value) {
+	if (!isWeakMap(value)) throw new TypeError(value + " is not a WeakMap");
+	return value;
+};