/**!
© 2019 Convergence Labs, Inc.
@version 0.1.0
@license MIT
*/
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define("CodeMirrorCollabExt", [], factory);
	else if(typeof exports === 'object')
		exports["CodeMirrorCollabExt"] = factory();
	else
		root["CodeMirrorCollabExt"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 4);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
/**
 * A helper class to aid in input validation.
 *
 * @internal
 */
var Validation = /** @class */ (function () {
    function Validation() {
    }
    Validation.assertString = function (val, name) {
        if (typeof val !== "string") {
            throw new Error(name + " must be a string but was: " + val);
        }
    };
    Validation.assertNumber = function (val, name) {
        if (typeof val !== "number") {
            throw new Error(name + " must be a number but was: " + val);
        }
    };
    Validation.assertDefined = function (val, name) {
        if (val === undefined || val === null) {
            throw new Error(name + " must be a defined but was: " + val);
        }
    };
    Validation.assertFunction = function (val, name) {
        if (typeof val !== "function") {
            throw new Error(name + " must be a function but was: " + typeof val);
        }
    };
    Validation.assertPosition = function (val, name) {
        Validation.assertDefined(val, name);
        if (typeof val.line !== "number" || typeof val.ch !== "number") {
            throw new Error(name + " must be an Object like {line: number, ch: number}: " + JSON.stringify(val));
        }
    };
    return Validation;
}());
exports.Validation = Validation;


/***/ }),
/* 1 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
/**
 * The RemoteCursor class represents a remote cursor in the CodeMirror
 * Editor. This class allows you to control the location and visibility
 * of the cursor.
 */
var RemoteCursor = /** @class */ (function () {
    /**
     * Creates a new RemoteCursor.
     *
     * @param delegate
     *   The underlying RemoteCursorWidget.
     *
     * @internal
     * @hidden
     */
    function RemoteCursor(delegate) {
        this._delegate = delegate;
    }
    /**
     * Gets the unique id of this cursor.
     *
     * @returns
     *   The unique id of this cursor.
     */
    RemoteCursor.prototype.getId = function () {
        return this._delegate.getId();
    };
    /**
     * Gets the position of the cursor.
     *
     * @returns
     *   The position of the cursor.
     */
    RemoteCursor.prototype.getPosition = function () {
        return this._delegate.getPosition();
    };
    /**
     * Sets the location of the cursor based on a CodeMirror Position.
     *
     * @param position
     *   The line / column position of the cursor.
     */
    RemoteCursor.prototype.setPosition = function (position) {
        this._delegate.setPosition(position);
    };
    /**
     * Sets the location of the cursor using a zero-based text index.
     *
     * @param index
     *   The index of the cursor.
     */
    RemoteCursor.prototype.setIndex = function (index) {
        this._delegate.setIndex(index);
    };
    /**
     * Shows the cursor if it is hidden.
     */
    RemoteCursor.prototype.show = function () {
        this._delegate.show();
    };
    /**
     * Hides the cursor if it is shown.
     */
    RemoteCursor.prototype.hide = function () {
        this._delegate.hide();
    };
    /**
     * Determines if the cursor has already been disposed. A cursor is disposed
     * when it has been permanently removed from the editor.
     *
     * @returns
     *   True if the cursor has been disposed, false otherwise.
     */
    RemoteCursor.prototype.isDisposed = function () {
        return this._delegate.isDisposed();
    };
    /**
     * Disposes of this cursor, removing it from the editor.
     */
    RemoteCursor.prototype.dispose = function () {
        this._delegate.dispose();
    };
    return RemoteCursor;
}());
exports.RemoteCursor = RemoteCursor;


/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
exports.__esModule = true;
var Validation_1 = __webpack_require__(0);
/**
 * The EditorContentManager facilitates listening to local content changes and
 * the playback of remote content changes into the editor.
 */
var EditorContentManager = /** @class */ (function () {
    /**
     * Constructs a new EditorContentManager using the supplied options.
     *
     * @param options
     *   The options that configure the EditorContentManager.
     */
    function EditorContentManager(options) {
        var _this = this;
        /**
         * A helper method to process local changes from CodeMirror. Before change
         * is used because the from and to positions from code mirror are relative
         * to the state of the document before the change in the "changes" event,
         * but the document has already been changed. So we use before changes to
         * calculate the from and to index before the document is changed. This
         * method then pushes the change data into a queue that will then be
         * picked up by the "change" event.
         *
         * @param editor
         *   The editor that the change originated from.
         * @param changeObj
         *   The object that specifies the change.
         *
         * @internal
         */
        this._onBeforeChange = function (editor, changeObj) {
            if (_this._suppress) {
                return;
            }
            var from = editor.indexFromPos(changeObj.from);
            var to = editor.indexFromPos(changeObj.to);
            var deleted = null;
            var inserted = null;
            // Code the from and to are the same for in inserts because the
            // insert happens "at" a specific index. The delete on the other
            // hand covers a non empty range.
            if (from !== to) {
                deleted = editor.getRange(changeObj.from, changeObj.to);
            }
            // If you insert a new line you will get ["", ""] in the 'text' property
            // so if the first element in the text array is non-empty or if you have
            // more than one element, you know you have an insert.
            if (changeObj.text[0] !== "" || changeObj.text.length > 1) {
                inserted = changeObj.text.join("\n");
            }
            _this._operationQueue.push({ from: from, to: to, inserted: inserted, deleted: deleted });
        };
        /**
         * A helper method to process local changes from CodeMirror.
         *
         * @param _
         *   The editor that the change originated from.
         * @param changes
         *   The array of changes.
         *
         * @private
         * @internal
         */
        this._onChanges = function (_, changes) {
            if (_this._suppress) {
                return;
            }
            changes.forEach(function (changeObj) {
                console.log("change(" + _this._options.id + ")", changeObj);
                var _a = _this._operationQueue.shift(), from = _a.from, to = _a.to, inserted = _a.inserted, deleted = _a.deleted;
                if (inserted !== null && deleted === null) {
                    _this._options.onInsert(from, inserted);
                }
                else if (inserted !== null && deleted !== null) {
                    _this._options.onReplace(from, to - from, inserted);
                }
                else if (inserted === null && deleted !== null) {
                    _this._options.onDelete(from, to - from);
                }
                else {
                    throw new Error("Unexpected change: " + JSON.stringify(changeObj));
                }
            });
        };
        this._options = __assign(__assign({}, EditorContentManager._DEFAULTS), options);
        Validation_1.Validation.assertDefined(this._options, "options");
        Validation_1.Validation.assertDefined(this._options.editor, "options.editor");
        Validation_1.Validation.assertFunction(this._options.onInsert, "options.onInsert");
        Validation_1.Validation.assertFunction(this._options.onReplace, "options.onReplace");
        Validation_1.Validation.assertFunction(this._options.onDelete, "options.onDelete");
        this._options.editor.on("beforeChange", this._onBeforeChange);
        this._options.editor.on("changes", this._onChanges);
        this._operationQueue = [];
    }
    /**
     * Inserts text into the editor.
     *
     * @param index
     *   The index to insert text at.
     * @param text
     *   The text to insert.
     */
    EditorContentManager.prototype.insert = function (index, text) {
        this._suppress = true;
        var from = this._options.editor.posFromIndex(index);
        this._options.editor.replaceRange(text, from, undefined, this._options.remoteOrigin);
        this._suppress = false;
    };
    /**
     * Replaces text in the editor.
     *
     * @param index
     *   The start index of the range to replace.
     * @param length
     *   The length of the  range to replace.
     * @param text
     *   The text to insert.
     */
    EditorContentManager.prototype.replace = function (index, length, text) {
        this._suppress = true;
        var from = this._options.editor.posFromIndex(index);
        var to = this._options.editor.posFromIndex(index + length);
        this._options.editor.replaceRange(text, from, to, this._options.remoteOrigin);
        this._suppress = false;
    };
    /**
     * Deletes text in the editor.
     *
     * @param index
     *   The start index of the range to remove.
     * @param length
     *   The length of the  range to remove.
     */
    EditorContentManager.prototype["delete"] = function (index, length) {
        this._suppress = true;
        var from = this._options.editor.posFromIndex(index);
        var to = this._options.editor.posFromIndex(index + length);
        this._options.editor.replaceRange("", from, to, this._options.remoteOrigin);
        this._suppress = false;
    };
    /**
     * Disposes of the content manager, freeing any resources.
     */
    EditorContentManager.prototype.dispose = function () {
        this._options.editor.off("beforeChange", this._onBeforeChange);
        this._options.editor.off("changes", this._onChanges);
    };
    /**
     * Option defaults.
     *
     * @internal
     */
    EditorContentManager._DEFAULTS = {
        onInsert: function () {
            // no-op
        },
        onReplace: function () {
            // no-op
        },
        onDelete: function () {
            // no-op
        },
        remoteOrigin: "remote"
    };
    return EditorContentManager;
}());
exports.EditorContentManager = EditorContentManager;


/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
exports.__esModule = true;
var tinycolor_1 = __webpack_require__(8);
var Validation_1 = __webpack_require__(0);
var RemoteSelection = /** @class */ (function () {
    /**
     * Constructs a new remote selection.
     *
     * @internal
     */
    function RemoteSelection(codeEditor, id, classId, color, onDisposed) {
        this._editor = codeEditor;
        this._id = id;
        this._className = "codemirror-remote-selection-" + classId;
        this._styleElement = RemoteSelection._addDynamicStyleElement(this._className, color);
        this._onDisposed = onDisposed;
    }
    /**
     * A helper method to add a style tag to the head of the document that will
     * style the color of the selection. CodeMirror only allows setting the
     * class name of decorations, so we can not set a style property directly.
     * This method will create, add, and return the style tag for this element.
     *
     * @param className
     *   The className to use as the css selector.
     * @param color
     *   The color to set for the selection.
     * @returns
     *   The style element that was added to the document head.
     *
     * @private
     * @internal
     */
    RemoteSelection._addDynamicStyleElement = function (className, color) {
        Validation_1.Validation.assertString(className, "className");
        Validation_1.Validation.assertString(color, "color");
        var rgbaColor = new tinycolor_1.TinyColor(color).setAlpha(0.3).toRgbString();
        var css = ("." + className + " {\n         background-color: " + rgbaColor + ";\n       }").trim();
        var styleElement = document.createElement("style");
        styleElement.innerText = css;
        document.head.appendChild(styleElement);
        return styleElement;
    };
    /**
     * A helper method to ensure the start position is before the end position.
     *
     * @param start
     *   The current start position.
     * @param end
     *   The current end position.
     * @return
     *   An object containing the correctly ordered start and end positions.
     *
     * @private
     * @internal
     */
    RemoteSelection._swapIfNeeded = function (start, end) {
        if (start.line < end.line || (start.line === end.line && start.ch <= end.ch)) {
            return { start: start, end: end };
        }
        else {
            return { start: end, end: start };
        }
    };
    /**
     * Gets the userland id of this selection.
     */
    RemoteSelection.prototype.getId = function () {
        return this._id;
    };
    /**
     * Gets the start position of the selection.
     *
     * @returns
     *   The start position of the selection.
     */
    RemoteSelection.prototype.getStartPosition = function () {
        return __assign({}, this._startPosition);
    };
    /**
     * Gets the start position of the selection.
     *
     * @returns
     *   The start position of the selection.
     */
    RemoteSelection.prototype.getEndPosition = function () {
        return __assign({}, this._endPosition);
    };
    /**
     * Sets the selection using zero-based text indices.
     *
     * @param start
     *   The start index to set the selection to.
     * @param end
     *   The end index to set the selection to.
     */
    RemoteSelection.prototype.setIndices = function (start, end) {
        var startPosition = this._editor.posFromIndex(start);
        var endPosition = this._editor.posFromIndex(end);
        this.setPositions(startPosition, endPosition);
    };
    /**
     * Sets the selection using CodeMirrors's line / ch coordinate system.
     *
     * @param start
     *   The start position to set the selection to.
     * @param end
     *   The end position to set the selection to.
     */
    RemoteSelection.prototype.setPositions = function (start, end) {
        // this._decorations = this._editor.deltaDecorations(this._decorations, []);
        var ordered = RemoteSelection._swapIfNeeded(start, end);
        this._startPosition = ordered.start;
        this._endPosition = ordered.end;
        this._render();
    };
    /**
     * Makes the selection visible if it is hidden.
     */
    RemoteSelection.prototype.show = function () {
        this._render();
    };
    /**
     * Makes the selection hidden if it is visible.
     */
    RemoteSelection.prototype.hide = function () {
        if (this._marker) {
            this._marker.clear();
        }
    };
    /**
     * Determines if the selection has been permanently removed from the editor.
     *
     * @returns
     *   True if the selection has been disposed, false otherwise.
     */
    RemoteSelection.prototype.isDisposed = function () {
        return this._disposed;
    };
    /**
     * Permanently removes the selection from the editor.
     */
    RemoteSelection.prototype.dispose = function () {
        if (!this._disposed) {
            this._styleElement.parentElement.removeChild(this._styleElement);
            this.hide();
            this._disposed = true;
            this._onDisposed();
        }
    };
    /**
     * A helper method that actually renders the selection as a marker within
     * the CodeMirror Editor.
     *
     * @private
     * @internal
     */
    RemoteSelection.prototype._render = function () {
        if (this._marker) {
            this._marker.clear();
        }
        this._marker = this._editor.markText(this._startPosition, this._endPosition, {
            className: this._className
        });
    };
    return RemoteSelection;
}());
exports.RemoteSelection = RemoteSelection;


/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

function __export(m) {
    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
exports.__esModule = true;
__export(__webpack_require__(5));
__export(__webpack_require__(1));
__export(__webpack_require__(3));
__export(__webpack_require__(7));
__export(__webpack_require__(2));


/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
exports.__esModule = true;
var RemoteCursor_1 = __webpack_require__(1);
var RemoteCursorWidget_1 = __webpack_require__(6);
var Validation_1 = __webpack_require__(0);
/**
 * The RemoteCursorManager class is responsible for creating and managing a
 * set of indicators that show where remote users's cursors are located when
 * using CodeMirror in a collaborative editing context.  The RemoteCursorManager
 * leverages CodeMirror's Widget concept to add cursor nodes to the editor.
 */
var RemoteCursorManager = /** @class */ (function () {
    /**
     * Creates a new RemoteCursorManager with the supplied options.
     *
     * @param options
     *   The options that will configure the RemoteCursorManager behavior.
     */
    function RemoteCursorManager(options) {
        if (typeof options !== "object") {
            throw new Error("'options' is a required parameter and must be an object.");
        }
        // Override the defaults.
        options = __assign(__assign({}, RemoteCursorManager.DEFAULT_OPTIONS), options);
        if (options.editor === undefined || options.editor === null) {
            throw new Error("options.editor must be defined but was: " + options.editor);
        }
        this._options = options;
        this._cursorWidgets = new Map();
        this._nextWidgetId = 0;
    }
    /**
     * Adds a new remote cursor to the editor.
     *
     * @param id
     *   A unique id that will be used to reference this cursor.
     * @param color
     *   The css color that the cursor and tooltip should be rendered in.
     * @param label
     *   An optional label for the tooltip. If tooltips are enabled.
     *
     * @returns
     *   The remote cursor widget that will be added to the editor.
     */
    RemoteCursorManager.prototype.addCursor = function (id, color, label) {
        var _this = this;
        Validation_1.Validation.assertString(id, "id");
        Validation_1.Validation.assertString(color, "color");
        if (this._options.tooltips && typeof "label" !== "string") {
            throw new Error("'label' is required when tooltips are enabled.");
        }
        var widgetId = "" + this._nextWidgetId++;
        var tooltipDurationMs = this._options.tooltipDuration * 1000;
        var cursorWidget = new RemoteCursorWidget_1.RemoteCursorWidget(this._options.editor, widgetId, color, label, this._options.tooltips, tooltipDurationMs, function () { return _this.removeCursor(id); });
        this._cursorWidgets.set(id, cursorWidget);
        return new RemoteCursor_1.RemoteCursor(cursorWidget);
    };
    /**
     * Removes the remote cursor from the editor.
     *
     * @param id
     *   The unique id of the cursor to remove.
     */
    RemoteCursorManager.prototype.removeCursor = function (id) {
        Validation_1.Validation.assertString(id, "id");
        var remoteCursorWidget = this._getCursor(id);
        if (!remoteCursorWidget.isDisposed()) {
            remoteCursorWidget.dispose();
        }
        this._cursorWidgets["delete"](id);
    };
    /**
     * Updates the location of the specified remote cursor using a CodeMirror
     * Position object.
     *
     * @param id
     *   The unique id of the cursor to remove.
     * @param position
     *   The location of the cursor to set.
     */
    RemoteCursorManager.prototype.setCursorPosition = function (id, position) {
        Validation_1.Validation.assertString(id, "id");
        var remoteCursorWidget = this._getCursor(id);
        remoteCursorWidget.setPosition(position);
    };
    /**
     * Updates the location of the specified remote cursor based on a zero-based
     * text index.
     *
     * @param id
     *   The unique id of the cursor to remove.
     * @param index
     *   The location of the cursor to set.
     */
    RemoteCursorManager.prototype.setCursorIndex = function (id, index) {
        Validation_1.Validation.assertString(id, "id");
        var remoteCursorWidget = this._getCursor(id);
        remoteCursorWidget.setIndex(index);
    };
    /**
     * Shows the specified cursor. Note the cursor may be scrolled out of view.
     *
     * @param id
     *   The unique id of the cursor to show.
     */
    RemoteCursorManager.prototype.showCursor = function (id) {
        Validation_1.Validation.assertString(id, "id");
        var remoteCursorWidget = this._getCursor(id);
        remoteCursorWidget.show();
    };
    /**
     * Hides the specified cursor.
     *
     * @param id
     *   The unique id of the cursor to show.
     */
    RemoteCursorManager.prototype.hideCursor = function (id) {
        Validation_1.Validation.assertString(id, "id");
        var remoteCursorWidget = this._getCursor(id);
        remoteCursorWidget.hide();
    };
    /**
     * A helper method that gets a cursor by id, or throws an exception.
     * @internal
     */
    RemoteCursorManager.prototype._getCursor = function (id) {
        if (!this._cursorWidgets.has(id)) {
            throw new Error("No such cursor: " + id);
        }
        return this._cursorWidgets.get(id);
    };
    /**
     * The default values for optional parameters.
     * @internal
     */
    RemoteCursorManager.DEFAULT_OPTIONS = { tooltips: true, tooltipDuration: 1 };
    return RemoteCursorManager;
}());
exports.RemoteCursorManager = RemoteCursorManager;


/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var EditorContentManager_1 = __webpack_require__(2);
var Validation_1 = __webpack_require__(0);
/**
 * This class creates the cursor and tooltip nodes and adds them
 * to CodeMirror as a widget.
 *
 * @internal
 */
var RemoteCursorWidget = /** @class */ (function () {
    function RemoteCursorWidget(codeEditor, widgetId, color, label, tooltipEnabled, tooltipDuration, onDisposed) {
        var _this = this;
        this._updateTooltipPosition = function () {
            var distanceFromTop = _this._domNode.offsetTop - _this._editor.getScrollInfo().top;
            if (distanceFromTop - _this._tooltipNode.offsetHeight < 5) {
                _this._tooltipNode.style.top = _this._tooltipNode.offsetHeight - 5 + "px";
            }
            else {
                _this._tooltipNode.style.top = "-" + _this._tooltipNode.offsetHeight + "px";
            }
            _this._tooltipNode.style.left = "0";
        };
        this._onInsert = function (index, text) {
            var currentIndex = _this._index;
            if (index <= currentIndex) {
                var newIndex = currentIndex + text.length;
                var position = _this._editor.posFromIndex(newIndex);
                _this._updatePosition(position);
            }
        };
        this._onReplace = function (index, length, text) {
            var currentIndex = _this._index;
            if (index <= currentIndex) {
                var newIndex = (currentIndex - Math.min(currentIndex - index, length)) + text.length;
                var position = _this._editor.posFromIndex(newIndex);
                _this._updatePosition(position);
            }
        };
        this._onDelete = function (index, length) {
            var currentIndex = _this._index;
            if (index <= currentIndex) {
                var newIndex = currentIndex - Math.min(currentIndex - index, length);
                var position = _this._editor.posFromIndex(newIndex);
                _this._updatePosition(position);
            }
        };
        this._editor = codeEditor;
        this._tooltipDuration = tooltipDuration;
        this._id = "codemirror-remote-cursor-" + widgetId;
        // Create the main node for the cursor element.
        this._domNode = document.createElement("div");
        this._domNode.className = "codemirror-remote-cursor";
        this._domNode.style.background = color;
        this._editor.addWidget({ line: 0, ch: 0 }, this._domNode, false);
        // Create the tooltip element if the tooltip is enabled.
        if (tooltipEnabled) {
            this._tooltipNode = document.createElement("div");
            this._tooltipNode.className = "codemirror-remote-cursor-tooltip";
            this._tooltipNode.style.background = color;
            this._tooltipNode.innerHTML = label;
            this._domNode.appendChild(this._tooltipNode);
            // we only need to listen to scroll positions to update the
            // tooltip location on scrolling.
            this._editor.on("scroll", this._updateTooltipPosition);
        }
        else {
            this._tooltipNode = null;
        }
        this._contentManager = new EditorContentManager_1.EditorContentManager({
            editor: this._editor,
            onInsert: this._onInsert,
            onReplace: this._onReplace,
            onDelete: this._onDelete,
            id: "remote-cursor-" + widgetId
        });
        this._index = 0;
        this._position = { line: 0, ch: 0 };
        this._hideTimer = null;
        this._onDisposed = onDisposed;
        this._disposed = false;
    }
    RemoteCursorWidget.prototype.hide = function () {
        this._domNode.style.display = "none";
    };
    RemoteCursorWidget.prototype.show = function () {
        this._domNode.style.display = "inherit";
    };
    RemoteCursorWidget.prototype.setIndex = function (index) {
        Validation_1.Validation.assertNumber(index, "index");
        var position = this._editor.posFromIndex(index);
        this.setPosition(position);
    };
    RemoteCursorWidget.prototype.setPosition = function (position) {
        var _this = this;
        Validation_1.Validation.assertPosition(position, "position");
        this._updatePosition(position);
        if (this._tooltipNode !== null) {
            setTimeout(function () { return _this._showTooltip(); }, 0);
        }
    };
    RemoteCursorWidget.prototype.isDisposed = function () {
        return this._disposed;
    };
    RemoteCursorWidget.prototype.dispose = function () {
        if (this._disposed) {
            return;
        }
        this._editor.off("scroll", this._updateTooltipPosition);
        this._contentManager.dispose();
        this._disposed = true;
        this._onDisposed();
    };
    RemoteCursorWidget.prototype.getId = function () {
        return this._id;
    };
    RemoteCursorWidget.prototype.getPosition = function () {
        return this._position;
    };
    RemoteCursorWidget.prototype._updatePosition = function (position) {
        var cursorCoords = this._editor.cursorCoords(position, "local");
        var height = cursorCoords.bottom - cursorCoords.top;
        this._domNode.style.height = height + "px";
        this._domNode.style.left = cursorCoords.left + "px";
        this._domNode.style.top = cursorCoords.top + "px";
        this._index = this._editor.indexFromPos(position);
        this._position = position;
        console.log(this._index, this._position);
    };
    RemoteCursorWidget.prototype._showTooltip = function () {
        var _this = this;
        this._updateTooltipPosition();
        if (this._hideTimer !== null) {
            clearTimeout(this._hideTimer);
        }
        else {
            this._setTooltipVisible(true);
        }
        this._hideTimer = setTimeout(function () {
            _this._setTooltipVisible(false);
            _this._hideTimer = null;
        }, this._tooltipDuration);
    };
    RemoteCursorWidget.prototype._setTooltipVisible = function (visible) {
        if (visible) {
            this._tooltipNode.style.opacity = "1.0";
        }
        else {
            this._tooltipNode.style.opacity = "0";
        }
    };
    return RemoteCursorWidget;
}());
exports.RemoteCursorWidget = RemoteCursorWidget;


/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

exports.__esModule = true;
var RemoteSelection_1 = __webpack_require__(3);
var Validation_1 = __webpack_require__(0);
/**
 * The RemoteSelectionManager renders remote users selections into the
 * editor using the editor's built-in TextMarker mechanism.
 */
var RemoteSelectionManager = /** @class */ (function () {
    /**
     * Creates a new RemoteSelectionManager with the specified options.
     *
     * @param options
     *   Ths options that configure the RemoteSelectionManager.
     */
    function RemoteSelectionManager(options) {
        Validation_1.Validation.assertDefined(options, "options");
        this._remoteSelections = new Map();
        this._options = options;
        this._nextClassId = 0;
    }
    /**
     * Adds a new remote selection with a unique id and the specified color.
     *
     * @param id
     *   The unique id of the selection.
     * @param color
     *   The color to render the selection with.
     */
    RemoteSelectionManager.prototype.addSelection = function (id, color) {
        var _this = this;
        var onDisposed = function () {
            _this.removeSelection(id);
        };
        var selection = new RemoteSelection_1.RemoteSelection(this._options.editor, id, this._nextClassId++, color, onDisposed);
        this._remoteSelections.set(id, selection);
        return selection;
    };
    /**
     * Removes an existing remote selection from the editor.
     *
     * @param id
     *   The unique id of the selection.
     */
    RemoteSelectionManager.prototype.removeSelection = function (id) {
        var remoteSelection = this._getSelection(id);
        if (!remoteSelection.isDisposed()) {
            remoteSelection.dispose();
        }
    };
    /**
     * Sets the selection using zero-based text indices.
     *
     * @param id
     *   The unique id of the selection.
     * @param start
     *   The starting index of the selection.
     * @param end
     *   The ending index of the selection.
     */
    RemoteSelectionManager.prototype.setSelectionIndices = function (id, start, end) {
        var remoteSelection = this._getSelection(id);
        remoteSelection.setIndices(start, end);
    };
    /**
     * Sets the selection using the CodeMirror Editor's Position
     * (line numbers and characters) location concept.
     *
     * @param id
     *   The unique id of the selection.
     * @param start
     *   The starting position of the selection.
     * @param end
     *   The ending position of the selection.
     */
    RemoteSelectionManager.prototype.setSelectionPositions = function (id, start, end) {
        var remoteSelection = this._getSelection(id);
        remoteSelection.setPositions(start, end);
    };
    /**
     * Shows the specified selection, if it is currently hidden.
     *
     * @param id
     *   The unique id of the selection.
     */
    RemoteSelectionManager.prototype.showSelection = function (id) {
        var remoteSelection = this._getSelection(id);
        remoteSelection.show();
    };
    /**
     * Hides the specified selection, if it is currently shown.
     *
     * @param id
     *   The unique id of the selection.
     */
    RemoteSelectionManager.prototype.hideSelection = function (id) {
        var remoteSelection = this._getSelection(id);
        remoteSelection.hide();
    };
    /**
     * A helper method that gets a cursor by id, or throws an exception.
     * @internal
     */
    RemoteSelectionManager.prototype._getSelection = function (id) {
        if (!this._remoteSelections.has(id)) {
            throw new Error("No such selection: " + id);
        }
        return this._remoteSelections.get(id);
    };
    return RemoteSelectionManager;
}());
exports.RemoteSelectionManager = RemoteSelectionManager;


/***/ }),
/* 8 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/util.js
function bound01(n, max) {
    if (isOnePointZero(n)) {
        n = '100%';
    }
    var processPercent = isPercentage(n);
    n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
    if (processPercent) {
        n = parseInt(String(n * max), 10) / 100;
    }
    if (Math.abs(n - max) < 0.000001) {
        return 1;
    }
    if (max === 360) {
        n = (n < 0 ? (n % max) + max : n % max) / parseFloat(String(max));
    }
    else {
        n = (n % max) / parseFloat(String(max));
    }
    return n;
}
function clamp01(val) {
    return Math.min(1, Math.max(0, val));
}
function isOnePointZero(n) {
    return typeof n === 'string' && n.includes('.') && parseFloat(n) === 1;
}
function isPercentage(n) {
    return typeof n === 'string' && n.includes('%');
}
function boundAlpha(a) {
    a = parseFloat(a);
    if (isNaN(a) || a < 0 || a > 1) {
        a = 1;
    }
    return a;
}
function convertToPercentage(n) {
    if (n <= 1) {
        return Number(n) * 100 + "%";
    }
    return n;
}
function pad2(c) {
    return c.length === 1 ? '0' + c : String(c);
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/conversion.js

function rgbToRgb(r, g, b) {
    return {
        r: bound01(r, 255) * 255,
        g: bound01(g, 255) * 255,
        b: bound01(b, 255) * 255,
    };
}
function rgbToHsl(r, g, b) {
    r = bound01(r, 255);
    g = bound01(g, 255);
    b = bound01(b, 255);
    var max = Math.max(r, g, b);
    var min = Math.min(r, g, b);
    var h = 0;
    var s = 0;
    var l = (max + min) / 2;
    if (max === min) {
        s = 0;
        h = 0;
    }
    else {
        var d = max - min;
        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
        switch (max) {
            case r:
                h = ((g - b) / d) + (g < b ? 6 : 0);
                break;
            case g:
                h = ((b - r) / d) + 2;
                break;
            case b:
                h = ((r - g) / d) + 4;
                break;
            default:
                break;
        }
        h /= 6;
    }
    return { h: h, s: s, l: l };
}
function hslToRgb(h, s, l) {
    var r;
    var g;
    var b;
    h = bound01(h, 360);
    s = bound01(s, 100);
    l = bound01(l, 100);
    function hue2rgb(p, q, t) {
        if (t < 0) {
            t += 1;
        }
        if (t > 1) {
            t -= 1;
        }
        if (t < 1 / 6) {
            return p + ((q - p) * (6 * t));
        }
        if (t < 1 / 2) {
            return q;
        }
        if (t < 2 / 3) {
            return p + ((q - p) * ((2 / 3) - t) * 6);
        }
        return p;
    }
    if (s === 0) {
        g = l;
        b = l;
        r = l;
    }
    else {
        var q = l < 0.5 ? (l * (1 + s)) : (l + s - (l * s));
        var p = (2 * l) - q;
        r = hue2rgb(p, q, h + (1 / 3));
        g = hue2rgb(p, q, h);
        b = hue2rgb(p, q, h - (1 / 3));
    }
    return { r: r * 255, g: g * 255, b: b * 255 };
}
function rgbToHsv(r, g, b) {
    r = bound01(r, 255);
    g = bound01(g, 255);
    b = bound01(b, 255);
    var max = Math.max(r, g, b);
    var min = Math.min(r, g, b);
    var h = 0;
    var v = max;
    var d = max - min;
    var s = max === 0 ? 0 : d / max;
    if (max === min) {
        h = 0;
    }
    else {
        switch (max) {
            case r:
                h = ((g - b) / d) + (g < b ? 6 : 0);
                break;
            case g:
                h = ((b - r) / d) + 2;
                break;
            case b:
                h = ((r - g) / d) + 4;
                break;
            default:
                break;
        }
        h /= 6;
    }
    return { h: h, s: s, v: v };
}
function hsvToRgb(h, s, v) {
    h = bound01(h, 360) * 6;
    s = bound01(s, 100);
    v = bound01(v, 100);
    var i = Math.floor(h);
    var f = h - i;
    var p = v * (1 - s);
    var q = v * (1 - (f * s));
    var t = v * (1 - ((1 - f) * s));
    var mod = i % 6;
    var r = [v, q, p, p, t, v][mod];
    var g = [t, v, v, q, p, p][mod];
    var b = [p, p, t, v, v, q][mod];
    return { r: r * 255, g: g * 255, b: b * 255 };
}
function rgbToHex(r, g, b, allow3Char) {
    var hex = [
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b).toString(16)),
    ];
    if (allow3Char &&
        hex[0].charAt(0) === hex[0].charAt(1) &&
        hex[1].charAt(0) === hex[1].charAt(1) &&
        hex[2].charAt(0) === hex[2].charAt(1)) {
        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
    }
    return hex.join('');
}
function rgbaToHex(r, g, b, a, allow4Char) {
    var hex = [
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b).toString(16)),
        pad2(convertDecimalToHex(a)),
    ];
    if (allow4Char &&
        hex[0].charAt(0) === hex[0].charAt(1) &&
        hex[1].charAt(0) === hex[1].charAt(1) &&
        hex[2].charAt(0) === hex[2].charAt(1) &&
        hex[3].charAt(0) === hex[3].charAt(1)) {
        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
    }
    return hex.join('');
}
function rgbaToArgbHex(r, g, b, a) {
    var hex = [
        pad2(convertDecimalToHex(a)),
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b).toString(16)),
    ];
    return hex.join('');
}
function convertDecimalToHex(d) {
    return Math.round(parseFloat(d) * 255).toString(16);
}
function convertHexToDecimal(h) {
    return parseIntFromHex(h) / 255;
}
function parseIntFromHex(val) {
    return parseInt(val, 16);
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/css-color-names.js
var names = {
    aliceblue: '#f0f8ff',
    antiquewhite: '#faebd7',
    aqua: '#00ffff',
    aquamarine: '#7fffd4',
    azure: '#f0ffff',
    beige: '#f5f5dc',
    bisque: '#ffe4c4',
    black: '#000000',
    blanchedalmond: '#ffebcd',
    blue: '#0000ff',
    blueviolet: '#8a2be2',
    brown: '#a52a2a',
    burlywood: '#deb887',
    cadetblue: '#5f9ea0',
    chartreuse: '#7fff00',
    chocolate: '#d2691e',
    coral: '#ff7f50',
    cornflowerblue: '#6495ed',
    cornsilk: '#fff8dc',
    crimson: '#dc143c',
    cyan: '#00ffff',
    darkblue: '#00008b',
    darkcyan: '#008b8b',
    darkgoldenrod: '#b8860b',
    darkgray: '#a9a9a9',
    darkgreen: '#006400',
    darkgrey: '#a9a9a9',
    darkkhaki: '#bdb76b',
    darkmagenta: '#8b008b',
    darkolivegreen: '#556b2f',
    darkorange: '#ff8c00',
    darkorchid: '#9932cc',
    darkred: '#8b0000',
    darksalmon: '#e9967a',
    darkseagreen: '#8fbc8f',
    darkslateblue: '#483d8b',
    darkslategray: '#2f4f4f',
    darkslategrey: '#2f4f4f',
    darkturquoise: '#00ced1',
    darkviolet: '#9400d3',
    deeppink: '#ff1493',
    deepskyblue: '#00bfff',
    dimgray: '#696969',
    dimgrey: '#696969',
    dodgerblue: '#1e90ff',
    firebrick: '#b22222',
    floralwhite: '#fffaf0',
    forestgreen: '#228b22',
    fuchsia: '#ff00ff',
    gainsboro: '#dcdcdc',
    ghostwhite: '#f8f8ff',
    gold: '#ffd700',
    goldenrod: '#daa520',
    gray: '#808080',
    green: '#008000',
    greenyellow: '#adff2f',
    grey: '#808080',
    honeydew: '#f0fff0',
    hotpink: '#ff69b4',
    indianred: '#cd5c5c',
    indigo: '#4b0082',
    ivory: '#fffff0',
    khaki: '#f0e68c',
    lavender: '#e6e6fa',
    lavenderblush: '#fff0f5',
    lawngreen: '#7cfc00',
    lemonchiffon: '#fffacd',
    lightblue: '#add8e6',
    lightcoral: '#f08080',
    lightcyan: '#e0ffff',
    lightgoldenrodyellow: '#fafad2',
    lightgray: '#d3d3d3',
    lightgreen: '#90ee90',
    lightgrey: '#d3d3d3',
    lightpink: '#ffb6c1',
    lightsalmon: '#ffa07a',
    lightseagreen: '#20b2aa',
    lightskyblue: '#87cefa',
    lightslategray: '#778899',
    lightslategrey: '#778899',
    lightsteelblue: '#b0c4de',
    lightyellow: '#ffffe0',
    lime: '#00ff00',
    limegreen: '#32cd32',
    linen: '#faf0e6',
    magenta: '#ff00ff',
    maroon: '#800000',
    mediumaquamarine: '#66cdaa',
    mediumblue: '#0000cd',
    mediumorchid: '#ba55d3',
    mediumpurple: '#9370db',
    mediumseagreen: '#3cb371',
    mediumslateblue: '#7b68ee',
    mediumspringgreen: '#00fa9a',
    mediumturquoise: '#48d1cc',
    mediumvioletred: '#c71585',
    midnightblue: '#191970',
    mintcream: '#f5fffa',
    mistyrose: '#ffe4e1',
    moccasin: '#ffe4b5',
    navajowhite: '#ffdead',
    navy: '#000080',
    oldlace: '#fdf5e6',
    olive: '#808000',
    olivedrab: '#6b8e23',
    orange: '#ffa500',
    orangered: '#ff4500',
    orchid: '#da70d6',
    palegoldenrod: '#eee8aa',
    palegreen: '#98fb98',
    paleturquoise: '#afeeee',
    palevioletred: '#db7093',
    papayawhip: '#ffefd5',
    peachpuff: '#ffdab9',
    peru: '#cd853f',
    pink: '#ffc0cb',
    plum: '#dda0dd',
    powderblue: '#b0e0e6',
    purple: '#800080',
    rebeccapurple: '#663399',
    red: '#ff0000',
    rosybrown: '#bc8f8f',
    royalblue: '#4169e1',
    saddlebrown: '#8b4513',
    salmon: '#fa8072',
    sandybrown: '#f4a460',
    seagreen: '#2e8b57',
    seashell: '#fff5ee',
    sienna: '#a0522d',
    silver: '#c0c0c0',
    skyblue: '#87ceeb',
    slateblue: '#6a5acd',
    slategray: '#708090',
    slategrey: '#708090',
    snow: '#fffafa',
    springgreen: '#00ff7f',
    steelblue: '#4682b4',
    tan: '#d2b48c',
    teal: '#008080',
    thistle: '#d8bfd8',
    tomato: '#ff6347',
    turquoise: '#40e0d0',
    violet: '#ee82ee',
    wheat: '#f5deb3',
    white: '#ffffff',
    whitesmoke: '#f5f5f5',
    yellow: '#ffff00',
    yellowgreen: '#9acd32',
};

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/format-input.js



function inputToRGB(color) {
    var rgb = { r: 0, g: 0, b: 0 };
    var a = 1;
    var s = null;
    var v = null;
    var l = null;
    var ok = false;
    var format = false;
    if (typeof color === 'string') {
        color = stringInputToObject(color);
    }
    if (typeof color === 'object') {
        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
            rgb = rgbToRgb(color.r, color.g, color.b);
            ok = true;
            format = String(color.r).substr(-1) === '%' ? 'prgb' : 'rgb';
        }
        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
            s = convertToPercentage(color.s);
            v = convertToPercentage(color.v);
            rgb = hsvToRgb(color.h, s, v);
            ok = true;
            format = 'hsv';
        }
        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
            s = convertToPercentage(color.s);
            l = convertToPercentage(color.l);
            rgb = hslToRgb(color.h, s, l);
            ok = true;
            format = 'hsl';
        }
        if (Object.prototype.hasOwnProperty.call(color, 'a')) {
            a = color.a;
        }
    }
    a = boundAlpha(a);
    return {
        ok: ok,
        format: color.format || format,
        r: Math.min(255, Math.max(rgb.r, 0)),
        g: Math.min(255, Math.max(rgb.g, 0)),
        b: Math.min(255, Math.max(rgb.b, 0)),
        a: a,
    };
}
var CSS_INTEGER = '[-\\+]?\\d+%?';
var CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?';
var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
var matchers = {
    CSS_UNIT: new RegExp(CSS_UNIT),
    rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
    rgba: new RegExp('rgba' + PERMISSIVE_MATCH4),
    hsl: new RegExp('hsl' + PERMISSIVE_MATCH3),
    hsla: new RegExp('hsla' + PERMISSIVE_MATCH4),
    hsv: new RegExp('hsv' + PERMISSIVE_MATCH3),
    hsva: new RegExp('hsva' + PERMISSIVE_MATCH4),
    hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
    hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
    hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
    hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
};
function stringInputToObject(color) {
    color = color.trim().toLowerCase();
    if (color.length === 0) {
        return false;
    }
    var named = false;
    if (names[color]) {
        color = names[color];
        named = true;
    }
    else if (color === 'transparent') {
        return { r: 0, g: 0, b: 0, a: 0, format: 'name' };
    }
    var match = matchers.rgb.exec(color);
    if (match) {
        return { r: match[1], g: match[2], b: match[3] };
    }
    match = matchers.rgba.exec(color);
    if (match) {
        return { r: match[1], g: match[2], b: match[3], a: match[4] };
    }
    match = matchers.hsl.exec(color);
    if (match) {
        return { h: match[1], s: match[2], l: match[3] };
    }
    match = matchers.hsla.exec(color);
    if (match) {
        return { h: match[1], s: match[2], l: match[3], a: match[4] };
    }
    match = matchers.hsv.exec(color);
    if (match) {
        return { h: match[1], s: match[2], v: match[3] };
    }
    match = matchers.hsva.exec(color);
    if (match) {
        return { h: match[1], s: match[2], v: match[3], a: match[4] };
    }
    match = matchers.hex8.exec(color);
    if (match) {
        return {
            r: parseIntFromHex(match[1]),
            g: parseIntFromHex(match[2]),
            b: parseIntFromHex(match[3]),
            a: convertHexToDecimal(match[4]),
            format: named ? 'name' : 'hex8',
        };
    }
    match = matchers.hex6.exec(color);
    if (match) {
        return {
            r: parseIntFromHex(match[1]),
            g: parseIntFromHex(match[2]),
            b: parseIntFromHex(match[3]),
            format: named ? 'name' : 'hex',
        };
    }
    match = matchers.hex4.exec(color);
    if (match) {
        return {
            r: parseIntFromHex(match[1] + match[1]),
            g: parseIntFromHex(match[2] + match[2]),
            b: parseIntFromHex(match[3] + match[3]),
            a: convertHexToDecimal(match[4] + match[4]),
            format: named ? 'name' : 'hex8',
        };
    }
    match = matchers.hex3.exec(color);
    if (match) {
        return {
            r: parseIntFromHex(match[1] + match[1]),
            g: parseIntFromHex(match[2] + match[2]),
            b: parseIntFromHex(match[3] + match[3]),
            format: named ? 'name' : 'hex',
        };
    }
    return false;
}
function isValidCSSUnit(color) {
    return Boolean(matchers.CSS_UNIT.exec(String(color)));
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/index.js




var es_TinyColor = (function () {
    function TinyColor(color, opts) {
        if (color === void 0) { color = ''; }
        if (opts === void 0) { opts = {}; }
        if (color instanceof TinyColor) {
            return color;
        }
        this.originalInput = color;
        var rgb = inputToRGB(color);
        this.originalInput = color;
        this.r = rgb.r;
        this.g = rgb.g;
        this.b = rgb.b;
        this.a = rgb.a;
        this.roundA = Math.round(100 * this.a) / 100;
        this.format = opts.format || rgb.format;
        this.gradientType = opts.gradientType;
        if (this.r < 1) {
            this.r = Math.round(this.r);
        }
        if (this.g < 1) {
            this.g = Math.round(this.g);
        }
        if (this.b < 1) {
            this.b = Math.round(this.b);
        }
        this.isValid = rgb.ok;
    }
    TinyColor.prototype.isDark = function () {
        return this.getBrightness() < 128;
    };
    TinyColor.prototype.isLight = function () {
        return !this.isDark();
    };
    TinyColor.prototype.getBrightness = function () {
        var rgb = this.toRgb();
        return ((rgb.r * 299) + (rgb.g * 587) + (rgb.b * 114)) / 1000;
    };
    TinyColor.prototype.getLuminance = function () {
        var rgb = this.toRgb();
        var R;
        var G;
        var B;
        var RsRGB = rgb.r / 255;
        var GsRGB = rgb.g / 255;
        var BsRGB = rgb.b / 255;
        if (RsRGB <= 0.03928) {
            R = RsRGB / 12.92;
        }
        else {
            R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
        }
        if (GsRGB <= 0.03928) {
            G = GsRGB / 12.92;
        }
        else {
            G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
        }
        if (BsRGB <= 0.03928) {
            B = BsRGB / 12.92;
        }
        else {
            B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
        }
        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
    };
    TinyColor.prototype.getAlpha = function () {
        return this.a;
    };
    TinyColor.prototype.setAlpha = function (alpha) {
        this.a = boundAlpha(alpha);
        this.roundA = Math.round(100 * this.a) / 100;
        return this;
    };
    TinyColor.prototype.toHsv = function () {
        var hsv = rgbToHsv(this.r, this.g, this.b);
        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
    };
    TinyColor.prototype.toHsvString = function () {
        var hsv = rgbToHsv(this.r, this.g, this.b);
        var h = Math.round(hsv.h * 360);
        var s = Math.round(hsv.s * 100);
        var v = Math.round(hsv.v * 100);
        return this.a === 1 ? "hsv(" + h + ", " + s + "%, " + v + "%)" : "hsva(" + h + ", " + s + "%, " + v + "%, " + this.roundA + ")";
    };
    TinyColor.prototype.toHsl = function () {
        var hsl = rgbToHsl(this.r, this.g, this.b);
        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
    };
    TinyColor.prototype.toHslString = function () {
        var hsl = rgbToHsl(this.r, this.g, this.b);
        var h = Math.round(hsl.h * 360);
        var s = Math.round(hsl.s * 100);
        var l = Math.round(hsl.l * 100);
        return this.a === 1 ? "hsl(" + h + ", " + s + "%, " + l + "%)" : "hsla(" + h + ", " + s + "%, " + l + "%, " + this.roundA + ")";
    };
    TinyColor.prototype.toHex = function (allow3Char) {
        if (allow3Char === void 0) { allow3Char = false; }
        return rgbToHex(this.r, this.g, this.b, allow3Char);
    };
    TinyColor.prototype.toHexString = function (allow3Char) {
        if (allow3Char === void 0) { allow3Char = false; }
        return '#' + this.toHex(allow3Char);
    };
    TinyColor.prototype.toHex8 = function (allow4Char) {
        if (allow4Char === void 0) { allow4Char = false; }
        return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
    };
    TinyColor.prototype.toHex8String = function (allow4Char) {
        if (allow4Char === void 0) { allow4Char = false; }
        return '#' + this.toHex8(allow4Char);
    };
    TinyColor.prototype.toRgb = function () {
        return {
            r: Math.round(this.r),
            g: Math.round(this.g),
            b: Math.round(this.b),
            a: this.a,
        };
    };
    TinyColor.prototype.toRgbString = function () {
        var r = Math.round(this.r);
        var g = Math.round(this.g);
        var b = Math.round(this.b);
        return this.a === 1 ? "rgb(" + r + ", " + g + ", " + b + ")" : "rgba(" + r + ", " + g + ", " + b + ", " + this.roundA + ")";
    };
    TinyColor.prototype.toPercentageRgb = function () {
        var fmt = function (x) { return Math.round(bound01(x, 255) * 100) + "%"; };
        return {
            r: fmt(this.r),
            g: fmt(this.g),
            b: fmt(this.b),
            a: this.a,
        };
    };
    TinyColor.prototype.toPercentageRgbString = function () {
        var rnd = function (x) { return Math.round(bound01(x, 255) * 100); };
        return this.a === 1 ?
            "rgb(" + rnd(this.r) + "%, " + rnd(this.g) + "%, " + rnd(this.b) + "%)" :
            "rgba(" + rnd(this.r) + "%, " + rnd(this.g) + "%, " + rnd(this.b) + "%, " + this.roundA + ")";
    };
    TinyColor.prototype.toName = function () {
        if (this.a === 0) {
            return 'transparent';
        }
        if (this.a < 1) {
            return false;
        }
        var hex = '#' + rgbToHex(this.r, this.g, this.b, false);
        for (var _i = 0, _a = Object.keys(names); _i < _a.length; _i++) {
            var key = _a[_i];
            if (names[key] === hex) {
                return key;
            }
        }
        return false;
    };
    TinyColor.prototype.toString = function (format) {
        var formatSet = Boolean(format);
        format = format || this.format;
        var formattedString = false;
        var hasAlpha = this.a < 1 && this.a >= 0;
        var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith('hex') || format === 'name');
        if (needsAlphaFormat) {
            if (format === 'name' && this.a === 0) {
                return this.toName();
            }
            return this.toRgbString();
        }
        if (format === 'rgb') {
            formattedString = this.toRgbString();
        }
        if (format === 'prgb') {
            formattedString = this.toPercentageRgbString();
        }
        if (format === 'hex' || format === 'hex6') {
            formattedString = this.toHexString();
        }
        if (format === 'hex3') {
            formattedString = this.toHexString(true);
        }
        if (format === 'hex4') {
            formattedString = this.toHex8String(true);
        }
        if (format === 'hex8') {
            formattedString = this.toHex8String();
        }
        if (format === 'name') {
            formattedString = this.toName();
        }
        if (format === 'hsl') {
            formattedString = this.toHslString();
        }
        if (format === 'hsv') {
            formattedString = this.toHsvString();
        }
        return formattedString || this.toHexString();
    };
    TinyColor.prototype.clone = function () {
        return new TinyColor(this.toString());
    };
    TinyColor.prototype.lighten = function (amount) {
        if (amount === void 0) { amount = 10; }
        var hsl = this.toHsl();
        hsl.l += amount / 100;
        hsl.l = clamp01(hsl.l);
        return new TinyColor(hsl);
    };
    TinyColor.prototype.brighten = function (amount) {
        if (amount === void 0) { amount = 10; }
        var rgb = this.toRgb();
        rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
        rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
        rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
        return new TinyColor(rgb);
    };
    TinyColor.prototype.darken = function (amount) {
        if (amount === void 0) { amount = 10; }
        var hsl = this.toHsl();
        hsl.l -= amount / 100;
        hsl.l = clamp01(hsl.l);
        return new TinyColor(hsl);
    };
    TinyColor.prototype.tint = function (amount) {
        if (amount === void 0) { amount = 10; }
        return this.mix('white', amount);
    };
    TinyColor.prototype.shade = function (amount) {
        if (amount === void 0) { amount = 10; }
        return this.mix('black', amount);
    };
    TinyColor.prototype.desaturate = function (amount) {
        if (amount === void 0) { amount = 10; }
        var hsl = this.toHsl();
        hsl.s -= amount / 100;
        hsl.s = clamp01(hsl.s);
        return new TinyColor(hsl);
    };
    TinyColor.prototype.saturate = function (amount) {
        if (amount === void 0) { amount = 10; }
        var hsl = this.toHsl();
        hsl.s += amount / 100;
        hsl.s = clamp01(hsl.s);
        return new TinyColor(hsl);
    };
    TinyColor.prototype.greyscale = function () {
        return this.desaturate(100);
    };
    TinyColor.prototype.spin = function (amount) {
        var hsl = this.toHsl();
        var hue = (hsl.h + amount) % 360;
        hsl.h = hue < 0 ? 360 + hue : hue;
        return new TinyColor(hsl);
    };
    TinyColor.prototype.mix = function (color, amount) {
        if (amount === void 0) { amount = 50; }
        var rgb1 = this.toRgb();
        var rgb2 = new TinyColor(color).toRgb();
        var p = amount / 100;
        var rgba = {
            r: ((rgb2.r - rgb1.r) * p) + rgb1.r,
            g: ((rgb2.g - rgb1.g) * p) + rgb1.g,
            b: ((rgb2.b - rgb1.b) * p) + rgb1.b,
            a: ((rgb2.a - rgb1.a) * p) + rgb1.a,
        };
        return new TinyColor(rgba);
    };
    TinyColor.prototype.analogous = function (results, slices) {
        if (results === void 0) { results = 6; }
        if (slices === void 0) { slices = 30; }
        var hsl = this.toHsl();
        var part = 360 / slices;
        var ret = [this];
        for (hsl.h = (hsl.h - ((part * results) >> 1) + 720) % 360; --results;) {
            hsl.h = (hsl.h + part) % 360;
            ret.push(new TinyColor(hsl));
        }
        return ret;
    };
    TinyColor.prototype.complement = function () {
        var hsl = this.toHsl();
        hsl.h = (hsl.h + 180) % 360;
        return new TinyColor(hsl);
    };
    TinyColor.prototype.monochromatic = function (results) {
        if (results === void 0) { results = 6; }
        var hsv = this.toHsv();
        var h = hsv.h;
        var s = hsv.s;
        var v = hsv.v;
        var res = [];
        var modification = 1 / results;
        while (results--) {
            res.push(new TinyColor({ h: h, s: s, v: v }));
            v = (v + modification) % 1;
        }
        return res;
    };
    TinyColor.prototype.splitcomplement = function () {
        var hsl = this.toHsl();
        var h = hsl.h;
        return [
            this,
            new TinyColor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),
            new TinyColor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l }),
        ];
    };
    TinyColor.prototype.triad = function () {
        return this.polyad(3);
    };
    TinyColor.prototype.tetrad = function () {
        return this.polyad(4);
    };
    TinyColor.prototype.polyad = function (n) {
        var hsl = this.toHsl();
        var h = hsl.h;
        var result = [this];
        var increment = 360 / n;
        for (var i = 1; i < n; i++) {
            result.push(new TinyColor({ h: (h + (i * increment)) % 360, s: hsl.s, l: hsl.l }));
        }
        return result;
    };
    TinyColor.prototype.equals = function (color) {
        return this.toRgbString() === new TinyColor(color).toRgbString();
    };
    return TinyColor;
}());

function tinycolor(color, opts) {
    if (color === void 0) { color = ''; }
    if (opts === void 0) { opts = {}; }
    return new es_TinyColor(color, opts);
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/readability.js

function readability(color1, color2) {
    var c1 = new es_TinyColor(color1);
    var c2 = new es_TinyColor(color2);
    return ((Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) /
        (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05));
}
function isReadable(color1, color2, wcag2) {
    if (wcag2 === void 0) { wcag2 = { level: 'AA', size: 'small' }; }
    var readabilityLevel = readability(color1, color2);
    switch ((wcag2.level || 'AA') + (wcag2.size || 'small')) {
        case 'AAsmall':
        case 'AAAlarge':
            return readabilityLevel >= 4.5;
        case 'AAlarge':
            return readabilityLevel >= 3;
        case 'AAAsmall':
            return readabilityLevel >= 7;
        default:
            return false;
    }
}
function mostReadable(baseColor, colorList, args) {
    if (args === void 0) { args = { includeFallbackColors: false, level: 'AA', size: 'small' }; }
    var bestColor = null;
    var bestScore = 0;
    var includeFallbackColors = args.includeFallbackColors, level = args.level, size = args.size;
    for (var _i = 0, colorList_1 = colorList; _i < colorList_1.length; _i++) {
        var color = colorList_1[_i];
        var score = readability(baseColor, color);
        if (score > bestScore) {
            bestScore = score;
            bestColor = new es_TinyColor(color);
        }
    }
    if (isReadable(baseColor, bestColor, { level: level, size: size }) || !includeFallbackColors) {
        return bestColor;
    }
    args.includeFallbackColors = false;
    return mostReadable(baseColor, ['#fff', '#000'], args);
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/to-ms-filter.js


function toMsFilter(firstColor, secondColor) {
    var color = new es_TinyColor(firstColor);
    var hex8String = '#' + rgbaToArgbHex(color.r, color.g, color.b, color.a);
    var secondHex8String = hex8String;
    var gradientType = color.gradientType ? 'GradientType = 1, ' : '';
    if (secondColor) {
        var s = new es_TinyColor(secondColor);
        secondHex8String = '#' + rgbaToArgbHex(s.r, s.g, s.b, s.a);
    }
    return "progid:DXImageTransform.Microsoft.gradient(" + gradientType + "startColorstr=" + hex8String + ",endColorstr=" + secondHex8String + ")";
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/from-ratio.js


function fromRatio(ratio, opts) {
    var newColor = {
        r: convertToPercentage(ratio.r),
        g: convertToPercentage(ratio.g),
        b: convertToPercentage(ratio.b),
    };
    if (ratio.a !== undefined) {
        newColor.a = Number(ratio.a);
    }
    return new es_TinyColor(newColor, opts);
}
function legacyRandom() {
    return new es_TinyColor({
        r: Math.random(),
        g: Math.random(),
        b: Math.random(),
    });
}

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/random.js

function random(options) {
    if (options === void 0) { options = {}; }
    if (options.count !== undefined && options.count !== null) {
        var totalColors = options.count;
        var colors = [];
        options.count = undefined;
        while (totalColors > colors.length) {
            options.count = null;
            if (options.seed) {
                options.seed += 1;
            }
            colors.push(random(options));
        }
        options.count = totalColors;
        return colors;
    }
    var h = pickHue(options.hue, options.seed);
    var s = pickSaturation(h, options);
    var v = pickBrightness(h, s, options);
    var res = { h: h, s: s, v: v };
    if (options.alpha !== undefined) {
        res.a = options.alpha;
    }
    return new es_TinyColor(res);
}
function pickHue(hue, seed) {
    var hueRange = getHueRange(hue);
    var res = randomWithin(hueRange, seed);
    if (res < 0) {
        res = 360 + res;
    }
    return res;
}
function pickSaturation(hue, options) {
    if (options.hue === 'monochrome') {
        return 0;
    }
    if (options.luminosity === 'random') {
        return randomWithin([0, 100], options.seed);
    }
    var saturationRange = getColorInfo(hue).saturationRange;
    var sMin = saturationRange[0];
    var sMax = saturationRange[1];
    switch (options.luminosity) {
        case 'bright':
            sMin = 55;
            break;
        case 'dark':
            sMin = sMax - 10;
            break;
        case 'light':
            sMax = 55;
            break;
        default:
            break;
    }
    return randomWithin([sMin, sMax], options.seed);
}
function pickBrightness(H, S, options) {
    var bMin = getMinimumBrightness(H, S);
    var bMax = 100;
    switch (options.luminosity) {
        case 'dark':
            bMax = bMin + 20;
            break;
        case 'light':
            bMin = (bMax + bMin) / 2;
            break;
        case 'random':
            bMin = 0;
            bMax = 100;
            break;
        default:
            break;
    }
    return randomWithin([bMin, bMax], options.seed);
}
function getMinimumBrightness(H, S) {
    var lowerBounds = getColorInfo(H).lowerBounds;
    for (var i = 0; i < lowerBounds.length - 1; i++) {
        var s1 = lowerBounds[i][0];
        var v1 = lowerBounds[i][1];
        var s2 = lowerBounds[i + 1][0];
        var v2 = lowerBounds[i + 1][1];
        if (S >= s1 && S <= s2) {
            var m = (v2 - v1) / (s2 - s1);
            var b = v1 - (m * s1);
            return (m * S) + b;
        }
    }
    return 0;
}
function getHueRange(colorInput) {
    var num = parseInt(colorInput, 10);
    if (!Number.isNaN(num) && num < 360 && num > 0) {
        return [num, num];
    }
    if (typeof colorInput === 'string') {
        var namedColor = bounds.find(function (n) { return n.name === colorInput; });
        if (namedColor) {
            var color = defineColor(namedColor);
            if (color.hueRange) {
                return color.hueRange;
            }
        }
        var parsed = new es_TinyColor(colorInput);
        if (parsed.isValid) {
            var hue = parsed.toHsv().h;
            return [hue, hue];
        }
    }
    return [0, 360];
}
function getColorInfo(hue) {
    if (hue >= 334 && hue <= 360) {
        hue -= 360;
    }
    for (var _i = 0, bounds_1 = bounds; _i < bounds_1.length; _i++) {
        var bound = bounds_1[_i];
        var color = defineColor(bound);
        if (color.hueRange && hue >= color.hueRange[0] && hue <= color.hueRange[1]) {
            return color;
        }
    }
    throw Error('Color not found');
}
function randomWithin(range, seed) {
    if (seed === undefined) {
        return Math.floor(range[0] + (Math.random() * (range[1] + 1 - range[0])));
    }
    var max = range[1] || 1;
    var min = range[0] || 0;
    seed = ((seed * 9301) + 49297) % 233280;
    var rnd = seed / 233280.0;
    return Math.floor(min + (rnd * (max - min)));
}
function defineColor(bound) {
    var sMin = bound.lowerBounds[0][0];
    var sMax = bound.lowerBounds[bound.lowerBounds.length - 1][0];
    var bMin = bound.lowerBounds[bound.lowerBounds.length - 1][1];
    var bMax = bound.lowerBounds[0][1];
    return {
        name: bound.name,
        hueRange: bound.hueRange,
        lowerBounds: bound.lowerBounds,
        saturationRange: [sMin, sMax],
        brightnessRange: [bMin, bMax],
    };
}
var bounds = [
    {
        name: 'monochrome',
        hueRange: null,
        lowerBounds: [[0, 0], [100, 0]],
    },
    {
        name: 'red',
        hueRange: [-26, 18],
        lowerBounds: [
            [20, 100],
            [30, 92],
            [40, 89],
            [50, 85],
            [60, 78],
            [70, 70],
            [80, 60],
            [90, 55],
            [100, 50],
        ],
    },
    {
        name: 'orange',
        hueRange: [19, 46],
        lowerBounds: [[20, 100], [30, 93], [40, 88], [50, 86], [60, 85], [70, 70], [100, 70]],
    },
    {
        name: 'yellow',
        hueRange: [47, 62],
        lowerBounds: [[25, 100], [40, 94], [50, 89], [60, 86], [70, 84], [80, 82], [90, 80], [100, 75]],
    },
    {
        name: 'green',
        hueRange: [63, 178],
        lowerBounds: [[30, 100], [40, 90], [50, 85], [60, 81], [70, 74], [80, 64], [90, 50], [100, 40]],
    },
    {
        name: 'blue',
        hueRange: [179, 257],
        lowerBounds: [
            [20, 100],
            [30, 86],
            [40, 80],
            [50, 74],
            [60, 60],
            [70, 52],
            [80, 44],
            [90, 39],
            [100, 35],
        ],
    },
    {
        name: 'purple',
        hueRange: [258, 282],
        lowerBounds: [
            [20, 100],
            [30, 87],
            [40, 79],
            [50, 70],
            [60, 65],
            [70, 59],
            [80, 52],
            [90, 45],
            [100, 42],
        ],
    },
    {
        name: 'pink',
        hueRange: [283, 334],
        lowerBounds: [[20, 100], [30, 90], [40, 86], [60, 84], [80, 80], [90, 75], [100, 73]],
    },
];

// CONCATENATED MODULE: ./node_modules/@ctrl/tinycolor/dist/es/public_api.js
/* concated harmony reexport TinyColor */__webpack_require__.d(__webpack_exports__, "TinyColor", function() { return es_TinyColor; });
/* concated harmony reexport tinycolor */__webpack_require__.d(__webpack_exports__, "tinycolor", function() { return tinycolor; });
/* concated harmony reexport names */__webpack_require__.d(__webpack_exports__, "names", function() { return names; });
/* concated harmony reexport readability */__webpack_require__.d(__webpack_exports__, "readability", function() { return readability; });
/* concated harmony reexport isReadable */__webpack_require__.d(__webpack_exports__, "isReadable", function() { return isReadable; });
/* concated harmony reexport mostReadable */__webpack_require__.d(__webpack_exports__, "mostReadable", function() { return mostReadable; });
/* concated harmony reexport toMsFilter */__webpack_require__.d(__webpack_exports__, "toMsFilter", function() { return toMsFilter; });
/* concated harmony reexport fromRatio */__webpack_require__.d(__webpack_exports__, "fromRatio", function() { return fromRatio; });
/* concated harmony reexport legacyRandom */__webpack_require__.d(__webpack_exports__, "legacyRandom", function() { return legacyRandom; });
/* concated harmony reexport inputToRGB */__webpack_require__.d(__webpack_exports__, "inputToRGB", function() { return inputToRGB; });
/* concated harmony reexport stringInputToObject */__webpack_require__.d(__webpack_exports__, "stringInputToObject", function() { return stringInputToObject; });
/* concated harmony reexport isValidCSSUnit */__webpack_require__.d(__webpack_exports__, "isValidCSSUnit", function() { return isValidCSSUnit; });
/* concated harmony reexport random */__webpack_require__.d(__webpack_exports__, "random", function() { return random; });
/* concated harmony reexport bounds */__webpack_require__.d(__webpack_exports__, "bounds", function() { return bounds; });








/* harmony default export */ var public_api = __webpack_exports__["default"] = (tinycolor);


/***/ })
/******/ ]);
});