diff --git a/packages/mindplot/src/components/ActionDispatcher.js b/packages/mindplot/src/components/ActionDispatcher.js
index ed0ffc14..f33917de 100644
--- a/packages/mindplot/src/components/ActionDispatcher.js
+++ b/packages/mindplot/src/components/ActionDispatcher.js
@@ -1,4 +1,4 @@
-/* eslint-disable no-unused-vars */
+/* eslint-disable class-methods-use-this */
 /*
  *    Copyright [2015] [wisemapping]
  *
@@ -19,89 +19,88 @@
 import { $assert } from '@wisemapping/core-js';
 import Events from './Events';
 
-// noinspection JSUnusedLocalSymbols
-const ActionDispatcher = new Class({
-  Implements: [Events],
-  initialize(commandContext) {
+class ActionDispatcher extends Events {
+  constructor(commandContext) {
     $assert(commandContext, 'commandContext can not be null');
-  },
+    super();
+  }
 
   addRelationship(model, mindmap) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   addTopics(models, parentTopicId) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   deleteEntities(topicsIds, relIds) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   dragTopic(topicId, position, order, parentTopic) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   moveTopic(topicId, position) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   moveControlPoint(ctrlPoint, point) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeFontFamilyToTopic(topicIds, fontFamily) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeFontStyleToTopic(topicsIds) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeFontColorToTopic(topicsIds, color) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeFontSizeToTopic(topicsIds, size) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeBackgroundColorToTopic(topicsIds, color) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeBorderColorToTopic(topicsIds, color) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeShapeTypeToTopic(topicsIds, shapeType) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeFontWeightToTopic(topicsIds) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeTextToTopic(topicsIds, text) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   shrinkBranch(topicsIds, collapse) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   addFeatureToTopic(topicId, type, attributes) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   changeFeatureToTopic(topicId, featureId, attributes) {
     throw new Error('method must be implemented.');
-  },
+  }
 
   removeFeatureFromTopic(topicId, featureId) {
     throw new Error('method must be implemented.');
-  },
-});
+  }
+}
 
 ActionDispatcher.setInstance = (dispatcher) => {
   ActionDispatcher._instance = dispatcher;
diff --git a/packages/mindplot/src/components/CommandContext.js b/packages/mindplot/src/components/CommandContext.js
new file mode 100644
index 00000000..3062294d
--- /dev/null
+++ b/packages/mindplot/src/components/CommandContext.js
@@ -0,0 +1,115 @@
+/*
+ *    Copyright [2015] [wisemapping]
+ *
+ *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+ *   It is basically the Apache License, Version 2.0 (the "License") plus the
+ *   "powered by wisemapping" text requirement on every single page;
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the license at
+ *
+ *       http://www.wisemapping.org/license
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+import { $assert } from "@wisemapping/core-js";
+
+class CommandContext {
+    constructor(designer) {
+        $assert(designer, 'designer can not be null');
+        this._designer = designer;
+    }
+
+    /** */
+    findTopics(topicsIds) {
+        $assert($defined(topicsIds), 'topicsIds can not be null');
+        if (!(topicsIds instanceof Array)) {
+            topicsIds = [topicsIds];
+        }
+
+        const designerTopics = this._designer.getModel().getTopics();
+        const result = designerTopics.filter((topic) => topicsIds.contains(topic.getId()));
+
+        if (result.length !== topicsIds.length) {
+            const ids = designerTopics.map((topic) => topic.getId());
+            $assert(
+                result.length === topicsIds.length,
+                `Could not find topic. Result:${result
+                } Filter Criteria:${topicsIds
+                } Current Topics: [${ids
+                }]`,
+            );
+        }
+        return result;
+    }
+
+    /** */
+    deleteTopic(topic) {
+        this._designer.removeTopic(topic);
+    }
+
+    /** */
+    createTopic(model) {
+        $assert(model, 'model can not be null');
+        return this._designer.nodeModelToNodeGraph(model);
+    }
+
+    /** */
+    createModel() {
+        const mindmap = this._designer.getMindmap();
+        return mindmap.createNode(NodeModel.MAIN_TOPIC_TYPE);
+    }
+
+    /** */
+    addTopic(topic) {
+        const mindmap = this._designer.getMindmap();
+        return mindmap.addBranch(topic.getModel());
+    }
+
+    /** */
+    connect(childTopic, parentTopic) {
+        childTopic.connectTo(parentTopic, this._designer._workspace);
+    }
+
+    /** */
+    disconnect(topic) {
+        topic.disconnect(this._designer._workspace);
+    }
+
+    /** */
+    addRelationship(model) {
+        $assert(model, 'model cannot be null');
+        return this._designer.addRelationship(model);
+    }
+
+    /** */
+    deleteRelationship(relationship) {
+        this._designer.deleteRelationship(relationship);
+    }
+
+    /** */
+    findRelationships(relIds) {
+        $assert($defined(relIds), 'relId can not be null');
+        if (!(relIds instanceof Array)) {
+            relIds = [relIds];
+        }
+
+        const designerRel = this._designer.getModel().getRelationships();
+        return designerRel.filter((rel) => relIds.contains(rel.getId()));
+    }
+
+    /** */
+    moveTopic(topic, position) {
+        $assert(topic, 'topic cannot be null');
+        $assert(position, 'position cannot be null');
+        EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
+            node: topic.getModel(),
+            position,
+        });
+    }
+}
+// eslint-disable-next-line import/prefer-default-export
+export default CommandContext;
diff --git a/packages/mindplot/src/components/Designer.js b/packages/mindplot/src/components/Designer.js
index 42191529..04999bea 100644
--- a/packages/mindplot/src/components/Designer.js
+++ b/packages/mindplot/src/components/Designer.js
@@ -15,12 +15,15 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-import { $assert } from '@wisemapping/core-js';
+import { $assert, $defined } from '@wisemapping/core-js';
+import $ from '@libraries/jquery-2.1.0';
+import _ from '@libraries/underscore-min';
 
 import Events from './Events';
 import Messages from './Messages';
+import StandaloneActionDispatcher from './StandaloneActionDispatcher';
 
-import { StandaloneActionDispatcher, CommandContext } from './StandaloneActionDispatcher';
+import CommandContext from './CommandContext';
 import ActionDispatcher from './ActionDispatcher';
 
 import DesignerModel from './DesignerModel';
@@ -45,987 +48,974 @@ import LayoutManager from './layout/LayoutManager';
 
 import INodeModel, { TopicShape } from './model/INodeModel';
 
-const Designer = new Class(
-  /** @lends Designer */ {
-    Extends: Events,
-    /**
-         * @constructs
-         * @param {Object} options
-         * @param {HTMLElement} divElement
-         * @extends mindplot.Events
-         */
-    initialize(options, divElement) {
-      $assert(options, 'options must be defined');
-      $assert(options.zoom, 'zoom must be defined');
-      $assert(options.size, 'size must be defined');
-      $assert(divElement, 'divElement must be defined');
+class Designer extends Events {
+  constructor(options, divElement) {
+    $assert(options, 'options must be defined');
+    $assert(options.zoom, 'zoom must be defined');
+    $assert(options.size, 'size must be defined');
+    $assert(divElement, 'divElement must be defined');
+    super();
 
-      // Set up i18n location ...
-      Messages.init(options.locale);
+    // Set up i18n location ...
+    Messages.init(options.locale);
 
-      this._options = options;
+    this._options = options;
 
-      // Set full div elem render area ...
-      divElement.css(options.size);
+    // Set full div elem render area ...
+    divElement.css(options.size);
 
-      // Dispatcher manager ...
-      const commandContext = new CommandContext(this);
-      this._actionDispatcher = new StandaloneActionDispatcher(commandContext);
+    // Dispatcher manager ...
+    const commandContext = new CommandContext(this);
+    this._actionDispatcher = new StandaloneActionDispatcher(commandContext);
 
-      const me = this;
-      this._actionDispatcher.addEvent('modelUpdate', (event) => {
-        me.fireEvent('modelUpdate', event);
-      });
+    const me = this;
+    this._actionDispatcher.addEvent('modelUpdate', (event) => {
+      me.fireEvent('modelUpdate', event);
+    });
 
-      ActionDispatcher.setInstance(this._actionDispatcher);
-      this._model = new DesignerModel(options);
+    ActionDispatcher.setInstance(this._actionDispatcher);
+    this._model = new DesignerModel(options);
 
-      // Init Screen manager..
-      const screenManager = new ScreenManager(divElement);
-      this._workspace = new Workspace(screenManager, this._model.getZoom());
+    // Init Screen manager..
+    const screenManager = new ScreenManager(divElement);
+    this._workspace = new Workspace(screenManager, this._model.getZoom());
 
-      // Init layout manager ...
-      this._eventBussDispatcher = new EventBusDispatcher(this.getModel());
+    // Init layout manager ...
+    this._eventBussDispatcher = new EventBusDispatcher(this.getModel());
 
-      // Register events
-      if (!this.isReadOnly()) {
-        // Register mouse events ...
-        this._registerMouseEvents();
+    // Register events
+    if (!this.isReadOnly()) {
+      // Register mouse events ...
+      this._registerMouseEvents();
 
-        // Register keyboard events ...
-        DesignerKeyboard.register(this);
+      // Register keyboard events ...
+      DesignerKeyboard.register(this);
 
-        this._dragManager = this._buildDragManager(this._workspace);
-      }
-      this._registerWheelEvents();
+      this._dragManager = this._buildDragManager(this._workspace);
+    }
+    this._registerWheelEvents();
 
-      this._relPivot = new RelationshipPivot(this._workspace, this);
+    this._relPivot = new RelationshipPivot(this._workspace, this);
 
-      // Set editor working area ...
-      this.setViewPort(options.viewPort);
+    // Set editor working area ...
+    this.setViewPort(options.viewPort);
 
-      TopicEventDispatcher.configure(this.isReadOnly());
-      this._clipboard = [];
-    },
+    TopicEventDispatcher.configure(this.isReadOnly());
+    this._clipboard = [];
+  }
 
-    /**
-         * @private
-         */
-    _registerWheelEvents() {
-      const zoomFactor = 1.006;
-      const me = this;
-      // Zoom In and Zoom Out must active event
-      $(document).on('mousewheel', (event) => {
-        if (event.deltaY > 0) {
-          me.zoomIn(zoomFactor);
-        } else {
-          me.zoomOut(zoomFactor);
-        }
-        event.preventDefault();
-      });
-    },
-
-    /**
-         * @param {String} type the event type
-         * @param {Function} listener
-         * forwards to the TopicEventDispatcher or the parent Events class, depending on the type
-         */
-    addEvent(type, listener) {
-      if (type === TopicEvent.EDIT || type === TopicEvent.CLICK) {
-        const editor = TopicEventDispatcher.getInstance();
-        editor.addEvent(type, listener);
+  /**
+       * @private
+       */
+  _registerWheelEvents() {
+    const zoomFactor = 1.006;
+    const me = this;
+    // Zoom In and Zoom Out must active event
+    $(document).on('mousewheel', (event) => {
+      if (event.deltaY > 0) {
+        me.zoomIn(zoomFactor);
       } else {
-        this.parent(type, listener);
+        me.zoomOut(zoomFactor);
       }
-    },
+      event.preventDefault();
+    });
+  }
 
-    /**
-         * @private
-         */
-    _registerMouseEvents() {
-      const workspace = this._workspace;
-      const screenManager = workspace.getScreenManager();
-      const me = this;
-      // Initialize workspace event listeners.
-      screenManager.addEvent('update', () => {
-        // Topic must be set to his original state. All editors must be closed.
-        const topics = me.getModel().getTopics();
-        _.each(topics, (object) => {
-          object.closeEditors();
-        });
+  /**
+       * @param {String} type the event type
+       * @param {Function} listener
+       * forwards to the TopicEventDispatcher or the parent Events class, depending on the type
+       */
+  addEvent(type, listener) {
+    if (type === TopicEvent.EDIT || type === TopicEvent.CLICK) {
+      const editor = TopicEventDispatcher.getInstance();
+      editor.addEvent(type, listener);
+    } else {
+      super.addEvent(type, listener);
+    }
+  }
 
-        // Clean some selected nodes on event ..
-        if (me._cleanScreen) me._cleanScreen();
+  /**
+       * @private
+       */
+  _registerMouseEvents() {
+    const workspace = this._workspace;
+    const screenManager = workspace.getScreenManager();
+    const me = this;
+    // Initialize workspace event listeners.
+    screenManager.addEvent('update', () => {
+      // Topic must be set to his original state. All editors must be closed.
+      const topics = me.getModel().getTopics();
+      _.each(topics, (object) => {
+        object.closeEditors();
       });
 
-      // Deselect on click ...
-      screenManager.addEvent('click', (event) => {
-        me.onObjectFocusEvent(null, event);
-      });
+      // Clean some selected nodes on event ..
+      if (me._cleanScreen) me._cleanScreen();
+    });
 
-      // Create nodes on double click...
-      screenManager.addEvent('dblclick', (event) => {
-        if (workspace.isWorkspaceEventsEnabled()) {
-          const mousePos = screenManager.getWorkspaceMousePosition(event);
-          const centralTopic = me.getModel().getCentralTopic();
-          const model = me._createChildModel(centralTopic, mousePos);
-          this._actionDispatcher.addTopics([model], [centralTopic.getId()]);
-        }
-      });
+    // Deselect on click ...
+    screenManager.addEvent('click', (event) => {
+      me.onObjectFocusEvent(null, event);
+    });
 
-      // Register mouse drag and drop event ...
-      function noopHandler(evt) {
-        evt.stopPropagation();
-        evt.preventDefault();
+    // Create nodes on double click...
+    screenManager.addEvent('dblclick', (event) => {
+      if (workspace.isWorkspaceEventsEnabled()) {
+        const mousePos = screenManager.getWorkspaceMousePosition(event);
+        const centralTopic = me.getModel().getCentralTopic();
+        const model = me._createChildModel(centralTopic, mousePos);
+        this._actionDispatcher.addTopics([model], [centralTopic.getId()]);
       }
-    },
+    });
 
-    /**
-         * @private
-         * @param {mindplot.Workspace} workspace
-         * @return {mindplot.DragManager} the new dragManager for the workspace with events
-         * registered
-         */
-    _buildDragManager(workspace) {
-      const designerModel = this.getModel();
-      const dragConnector = new DragConnector(designerModel, this._workspace);
-      const dragManager = new DragManager(workspace, this._eventBussDispatcher);
-      const topics = designerModel.getTopics();
+    // Register mouse drag and drop event ...
+    function noopHandler(evt) {
+      evt.stopPropagation();
+      evt.preventDefault();
+    }
+  }
 
-      dragManager.addEvent('startdragging', () => {
-        // Enable all mouse events.
-        for (let i = 0; i < topics.length; i++) {
-          topics[i].setMouseEventsEnabled(false);
-        }
-      });
+  /**
+       * @private
+       * @param {mindplot.Workspace} workspace
+       * @return {mindplot.DragManager} the new dragManager for the workspace with events
+       * registered
+       */
+  _buildDragManager(workspace) {
+    const designerModel = this.getModel();
+    const dragConnector = new DragConnector(designerModel, this._workspace);
+    const dragManager = new DragManager(workspace, this._eventBussDispatcher);
+    const topics = designerModel.getTopics();
 
-      dragManager.addEvent('dragging', (event, dragTopic) => {
-        dragTopic.updateFreeLayout(event);
-        if (!dragTopic.isFreeLayoutOn(event)) {
-          // The node is being drag. Is the connection still valid ?
-          dragConnector.checkConnection(dragTopic);
+    dragManager.addEvent('startdragging', () => {
+      // Enable all mouse events.
+      for (let i = 0; i < topics.length; i++) {
+        topics[i].setMouseEventsEnabled(false);
+      }
+    });
 
-          if (!dragTopic.isVisible() && dragTopic.isConnected()) {
-            dragTopic.setVisibility(true);
-          }
-        }
-      });
+    dragManager.addEvent('dragging', (event, dragTopic) => {
+      dragTopic.updateFreeLayout(event);
+      if (!dragTopic.isFreeLayoutOn(event)) {
+        // The node is being drag. Is the connection still valid ?
+        dragConnector.checkConnection(dragTopic);
 
-      dragManager.addEvent('enddragging', (event, dragTopic) => {
-        for (let i = 0; i < topics.length; i++) {
-          topics[i].setMouseEventsEnabled(true);
-        }
-        dragTopic.applyChanges(workspace);
-      });
-
-      return dragManager;
-    },
-
-    /**
-         * @param {{width:Number, height:Number}} size
-         * sets width and height of the workspace
-         */
-    setViewPort(size) {
-      this._workspace.setViewPort(size);
-      const model = this.getModel();
-      this._workspace.setZoom(model.getZoom(), true);
-    },
-
-    /**
-         * @private
-         * @param {mindplot.model.NodeModel} model
-         * @param {Boolean} readOnly
-         * @return {mindplot.CentralTopic|mindplot.MainTopic} the topic to the given model,
-         * connected, added to the drag manager, with events registered - complying type & read mode
-         */
-    _buildNodeGraph(model, readOnly) {
-      // Create node graph ...
-      const topic = create(model, { readOnly });
-      this.getModel().addTopic(topic);
-      const me = this;
-      // Add Topic events ...
-      if (!readOnly) {
-        // If a node had gained focus, clean the rest of the nodes ...
-        topic.addEvent('mousedown', (event) => {
-          me.onObjectFocusEvent(topic, event);
-        });
-
-        // Register node listeners ...
-        if (topic.getType() !== INodeModel.CENTRAL_TOPIC_TYPE) {
-          // Central Topic doesn't support to be dragged
-          this._dragManager.add(topic);
+        if (!dragTopic.isVisible() && dragTopic.isConnected()) {
+          dragTopic.setVisibility(true);
         }
       }
+    });
 
-      // Connect Topic ...
-      const isConnected = model.isConnected();
-      if (isConnected) {
-        // Improve this ...
-        const targetTopicModel = model.getParent();
-        let targetTopic = null;
-
-        const topics = this.getModel().getTopics();
-        for (let i = 0; i < topics.length; i++) {
-          const t = topics[i];
-          if (t.getModel() === targetTopicModel) {
-            targetTopic = t;
-            // Disconnect the node. It will be connected again later ...
-            model.disconnect();
-            break;
-          }
-        }
-        $assert(targetTopic, 'Could not find a topic to connect');
-        topic.connectTo(targetTopic, this._workspace);
+    dragManager.addEvent('enddragging', (event, dragTopic) => {
+      for (let i = 0; i < topics.length; i++) {
+        topics[i].setMouseEventsEnabled(true);
       }
+      dragTopic.applyChanges(workspace);
+    });
 
-      topic.addEvent('ontblur', () => {
-        const topics = me.getModel().filterSelectedTopics();
-        const rels = me.getModel().filterSelectedRelationships();
+    return dragManager;
+  }
 
-        if (topics.length === 0 || rels.length === 0) {
-          me.fireEvent('onblur');
-        }
+  /**
+       * @param {{width:Number, height:Number}} size
+       * sets width and height of the workspace
+       */
+  setViewPort(size) {
+    this._workspace.setViewPort(size);
+    const model = this.getModel();
+    this._workspace.setZoom(model.getZoom(), true);
+  }
+
+  /**
+       * @private
+       * @param {mindplot.model.NodeModel} model
+       * @param {Boolean} readOnly
+       * @return {mindplot.CentralTopic|mindplot.MainTopic} the topic to the given model,
+       * connected, added to the drag manager, with events registered - complying type & read mode
+       */
+  _buildNodeGraph(model, readOnly) {
+    // Create node graph ...
+    const topic = create(model, { readOnly });
+    this.getModel().addTopic(topic);
+    const me = this;
+    // Add Topic events ...
+    if (!readOnly) {
+      // If a node had gained focus, clean the rest of the nodes ...
+      topic.addEvent('mousedown', (event) => {
+        me.onObjectFocusEvent(topic, event);
       });
 
-      topic.addEvent('ontfocus', () => {
-        const topics = me.getModel().filterSelectedTopics();
-        const rels = me.getModel().filterSelectedRelationships();
-
-        if (topics.length === 1 || rels.length === 1) {
-          me.fireEvent('onfocus');
-        }
-      });
-
-      return topic;
-    },
-
-    /**
-         * @param {?mindplot.Topic} currentObject
-         * @param {Event=} event
-         * sets focus to the given currentObject and removes it from any other objects if not
-         * triggered with Ctrl pressed
-         */
-    onObjectFocusEvent(currentObject, event) {
-      // Close node editors ..
-      const topics = this.getModel().getTopics();
-      _.each(topics, (topic) => {
-        topic.closeEditors();
-      });
-
-      const model = this.getModel();
-      const objects = model.getEntities();
-      _.each(objects, (object) => {
-        // Disable all nodes on focus but not the current if Ctrl key isn't being pressed
-        if (!$defined(event) || (!event.ctrlKey && !event.metaKey)) {
-          if (object.isOnFocus() && object !== currentObject) {
-            object.setOnFocus(false);
-          }
-        }
-      });
-    },
-
-    /** sets focus to all model entities, i.e. relationships and topics */
-    selectAll() {
-      const model = this.getModel();
-      const objects = model.getEntities();
-      _.each(objects, (object) => {
-        object.setOnFocus(true);
-      });
-    },
-
-    /** removes focus from all model entities, i.e. relationships and topics */
-    deselectAll() {
-      const objects = this.getModel().getEntities();
-      _.each(objects, (object) => {
-        object.setOnFocus(false);
-      });
-    },
-
-    /**
-         * Set the zoom of the map
-         * @param {Number} zoom number between 0.3 and 1.9
-         */
-    setZoom(zoom) {
-      if (zoom > 1.9 || zoom < 0.3) {
-        $notify($msg('ZOOM_IN_ERROR'));
-        return;
-      }
-      this.getModel().setZoom(zoom);
-      this._workspace.setZoom(zoom);
-    },
-
-    /**
-         * @param {Number=} factor
-         * zoom out by the given factor, or 1.2, if undefined
-         */
-    zoomOut(factor) {
-      if (!factor) {
-        factor = 1.2;
-      }
-
-      const model = this.getModel();
-      const scale = model.getZoom() * factor;
-      if (scale <= 1.9) {
-        model.setZoom(scale);
-        this._workspace.setZoom(scale);
-      } else {
-        $notify($msg('ZOOM_ERROR'));
-      }
-    },
-
-    /**
-         * @param {Number=} factor
-         * zoom in by the given factor, or 1.2, if undefined
-         */
-    zoomIn(factor) {
-      if (!factor) factor = 1.2;
-
-      const model = this.getModel();
-      const scale = model.getZoom() / factor;
-
-      if (scale >= 0.3) {
-        model.setZoom(scale);
-        this._workspace.setZoom(scale);
-      } else {
-        $notify($msg('ZOOM_ERROR'));
-      }
-    },
-
-    /** copy selected topics to a private clipboard */
-    copyToClipboard() {
-      let topics = this.getModel().filterSelectedTopics();
-      if (topics.length <= 0) {
-        // If there are more than one node selected,
-        $notify($msg('AT_LEAST_ONE_TOPIC_MUST_BE_SELECTED'));
-        return;
-      }
-
-      // Exclude central topic ..
-      topics = topics.filter((topic) => !topic.isCentralTopic());
-
-      this._clipboard = topics.map((topic) => {
-        const nodeModel = topic.getModel().deepCopy();
-
-        // Change position to make the new topic evident...
-        const pos = nodeModel.getPosition();
-        nodeModel.setPosition(pos.x + 60 * Math.sign(pos.x), pos.y + 30);
-
-        return nodeModel;
-      });
-
-      $notify($msg('SELECTION_COPIED_TO_CLIPBOARD'));
-    },
-
-    /** paste clipboard contents to the mindmap */
-    pasteClipboard() {
-      if (this._clipboard.length === 0) {
-        $notify($msg('CLIPBOARD_IS_EMPTY'));
-        return;
-      }
-      this._actionDispatcher.addTopics(this._clipboard);
-      this._clipboard = [];
-    },
-
-    /** @return {mindplot.DesignerModel} model */
-    getModel() {
-      return this._model;
-    },
-
-    /** collapse the subtree of the selected topic */
-    shrinkSelectedBranch() {
-      const nodes = this.getModel().filterSelectedTopics();
-      if (nodes.length <= 0 || nodes.length !== 1) {
-        // If there are more than one node selected,
-        $notify($msg('ONLY_ONE_TOPIC_MUST_BE_SELECTED_COLLAPSE'));
-        return;
-      }
-      // Execute event ...
-      const topic = nodes[0];
+      // Register node listeners ...
       if (topic.getType() !== INodeModel.CENTRAL_TOPIC_TYPE) {
-        this._actionDispatcher.shrinkBranch([topic.getId()], !topic.areChildrenShrunken());
+        // Central Topic doesn't support to be dragged
+        this._dragManager.add(topic);
       }
-    },
+    }
 
-    /** create a NodeModel for the selected node's child and add it via the ActionDispatcher */
-    createChildForSelectedNode() {
-      const nodes = this.getModel().filterSelectedTopics();
-      if (nodes.length <= 0) {
-        // If there are more than one node selected,
-        $notify($msg('ONE_TOPIC_MUST_BE_SELECTED'));
-        return;
-      }
-      if (nodes.length !== 1) {
-        // If there are more than one node selected,
-        $notify($msg('ONLY_ONE_TOPIC_MUST_BE_SELECTED'));
-        return;
-      }
+    // Connect Topic ...
+    const isConnected = model.isConnected();
+    if (isConnected) {
+      // Improve this ...
+      const targetTopicModel = model.getParent();
+      let targetTopic = null;
 
-      // Add new node ...
-      const parentTopic = nodes[0];
-      const parentTopicId = parentTopic.getId();
-      const childModel = this._createChildModel(parentTopic);
-
-      // Execute event ...
-      this._actionDispatcher.addTopics([childModel], [parentTopicId]);
-    },
-
-    /**
-         * @private
-         */
-    _copyNodeProps(sourceModel, targetModel) {
-      // I don't copy the font size if the target is the source is the central topic.
-      if (sourceModel.getType() !== INodeModel.CENTRAL_TOPIC_TYPE) {
-        const fontSize = sourceModel.getFontSize();
-        if (fontSize) {
-          targetModel.setFontSize(fontSize);
+      const topics = this.getModel().getTopics();
+      for (let i = 0; i < topics.length; i++) {
+        const t = topics[i];
+        if (t.getModel() === targetTopicModel) {
+          targetTopic = t;
+          // Disconnect the node. It will be connected again later ...
+          model.disconnect();
+          break;
         }
       }
+      $assert(targetTopic, 'Could not find a topic to connect');
+      topic.connectTo(targetTopic, this._workspace);
+    }
 
-      const fontFamily = sourceModel.getFontFamily();
-      if (fontFamily) {
-        targetModel.setFontFamily(fontFamily);
+    topic.addEvent('ontblur', () => {
+      const topics = me.getModel().filterSelectedTopics();
+      const rels = me.getModel().filterSelectedRelationships();
+
+      if (topics.length === 0 || rels.length === 0) {
+        me.fireEvent('onblur');
       }
+    });
 
-      const fontColor = sourceModel.getFontColor();
-      if (fontColor) {
-        targetModel.setFontColor(fontColor);
+    topic.addEvent('ontfocus', () => {
+      const topics = me.getModel().filterSelectedTopics();
+      const rels = me.getModel().filterSelectedRelationships();
+
+      if (topics.length === 1 || rels.length === 1) {
+        me.fireEvent('onfocus');
       }
+    });
 
-      const fontWeight = sourceModel.getFontWeight();
-      if (fontWeight) {
-        targetModel.setFontWeight(fontWeight);
-      }
+    return topic;
+  }
 
-      const fontStyle = sourceModel.getFontStyle();
-      if (fontStyle) {
-        targetModel.setFontStyle(fontStyle);
-      }
+  /**
+       * @param {?mindplot.Topic} currentObject
+       * @param {Event=} event
+       * sets focus to the given currentObject and removes it from any other objects if not
+       * triggered with Ctrl pressed
+       */
+  onObjectFocusEvent(currentObject, event) {
+    // Close node editors ..
+    const topics = this.getModel().getTopics();
+    _.each(topics, (topic) => {
+      topic.closeEditors();
+    });
 
-      const shape = sourceModel.getShapeType();
-      if (shape) {
-        targetModel.setShapeType(shape);
-      }
-
-      const borderColor = sourceModel.getBorderColor();
-      if (borderColor) {
-        targetModel.setBorderColor(borderColor);
-      }
-
-      const backgroundColor = sourceModel.getBackgroundColor();
-      if (backgroundColor) {
-        targetModel.setBackgroundColor(backgroundColor);
-      }
-    },
-
-    /**
-         * @private
-         * @param {mindplot.Topic} topic the parent topic of the child to create the NodeModel for
-         * @param {web2d.Point} mousePos the mouse position
-         * @return {mindplot.NodeModel} the node model for the new child
-         */
-    _createChildModel(topic, mousePos) {
-      // Create a new node ...
-      const parentModel = topic.getModel();
-      const mindmap = parentModel.getMindmap();
-      const childModel = mindmap.createNode();
-
-      // Create a new node ...
-      const layoutManager = this._eventBussDispatcher.getLayoutManager();
-      const result = layoutManager.predict(topic.getId(), null, mousePos);
-      childModel.setOrder(result.order);
-
-      const { position } = result;
-      childModel.setPosition(position.x, position.y);
-
-      this._copyNodeProps(parentModel, childModel);
-
-      return childModel;
-    },
-
-    /**
-         * @param {Events} event
-         * @param {mindplot.model.NodeModel} model
-         * @todo not used
-         */
-    addDraggedNode(event, model) {
-      $assert(event, 'event can not be null');
-      $assert(model, 'model can not be null');
-
-      // Position far from the visual area ...
-      model.setPosition(1000, 1000);
-
-      this._actionDispatcher.addTopics([model]);
-      const topic = this.getModel().findTopicById(model.getId());
-
-      // Simulate a mouse down event to start the dragging ...
-      topic.fireEvent('mousedown', event);
-    },
-
-    /**
-         * creates a sibling or child node of the selected node, if the selected node is the
-         * central topic
-         */
-    createSiblingForSelectedNode() {
-      const nodes = this.getModel().filterSelectedTopics();
-      if (nodes.length <= 0) {
-        // If there are no nodes selected,
-        $notify($msg('ONE_TOPIC_MUST_BE_SELECTED'));
-        return;
-      }
-      if (nodes.length > 1) {
-        // If there are more than one node selected,
-        $notify($msg('ONLY_ONE_TOPIC_MUST_BE_SELECTED'));
-        return;
-      }
-
-      const topic = nodes[0];
-      if (!topic.getOutgoingConnectedTopic()) {
-        // Central topic and isolated topics ....
-        // Central topic doesn't have siblings ...
-        this.createChildForSelectedNode();
-      } else {
-        const parentTopic = topic.getOutgoingConnectedTopic();
-        const siblingModel = this._createSiblingModel(topic);
-
-        // Hack: if parent is central topic, add node below not on opposite side.
-        // This should be done in the layout
-        if (parentTopic.getType() === INodeModel.CENTRAL_TOPIC_TYPE) {
-          siblingModel.setOrder(topic.getOrder() + 2);
+    const model = this.getModel();
+    const objects = model.getEntities();
+    _.each(objects, (object) => {
+      // Disable all nodes on focus but not the current if Ctrl key isn't being pressed
+      if (!$defined(event) || (!event.ctrlKey && !event.metaKey)) {
+        if (object.isOnFocus() && object !== currentObject) {
+          object.setOnFocus(false);
         }
-
-        const parentTopicId = parentTopic.getId();
-        this._actionDispatcher.addTopics([siblingModel], [parentTopicId]);
       }
-    },
+    });
+  }
 
-    /**
-         * @private
-         * @param {mindplot.Topic} topic the topic to create the sibling to
-         * @return {mindplot.NodeModel} the node model of the sibling
-         */
-    _createSiblingModel(topic) {
-      let result = null;
-      let model = null;
+  /** sets focus to all model entities, i.e. relationships and topics */
+  selectAll() {
+    const model = this.getModel();
+    const objects = model.getEntities();
+    _.each(objects, (object) => {
+      object.setOnFocus(true);
+    });
+  }
+
+  /** removes focus from all model entities, i.e. relationships and topics */
+  deselectAll() {
+    const objects = this.getModel().getEntities();
+    _.each(objects, (object) => {
+      object.setOnFocus(false);
+    });
+  }
+
+  /**
+       * Set the zoom of the map
+       * @param {Number} zoom number between 0.3 and 1.9
+       */
+  setZoom(zoom) {
+    if (zoom > 1.9 || zoom < 0.3) {
+      $notify($msg('ZOOM_IN_ERROR'));
+      return;
+    }
+    this.getModel().setZoom(zoom);
+    this._workspace.setZoom(zoom);
+  }
+
+  /**
+       * @param {Number=} factor
+       * zoom out by the given factor, or 1.2, if undefined
+       */
+  zoomOut(factor) {
+    if (!factor) {
+      factor = 1.2;
+    }
+
+    const model = this.getModel();
+    const scale = model.getZoom() * factor;
+    if (scale <= 1.9) {
+      model.setZoom(scale);
+      this._workspace.setZoom(scale);
+    } else {
+      $notify($msg('ZOOM_ERROR'));
+    }
+  }
+
+  /**
+       * @param {Number=} factor
+       * zoom in by the given factor, or 1.2, if undefined
+       */
+  zoomIn(factor) {
+    if (!factor) factor = 1.2;
+
+    const model = this.getModel();
+    const scale = model.getZoom() / factor;
+
+    if (scale >= 0.3) {
+      model.setZoom(scale);
+      this._workspace.setZoom(scale);
+    } else {
+      $notify($msg('ZOOM_ERROR'));
+    }
+  }
+
+  /** copy selected topics to a private clipboard */
+  copyToClipboard() {
+    let topics = this.getModel().filterSelectedTopics();
+    if (topics.length <= 0) {
+      // If there are more than one node selected,
+      $notify($msg('AT_LEAST_ONE_TOPIC_MUST_BE_SELECTED'));
+      return;
+    }
+
+    // Exclude central topic ..
+    topics = topics.filter((topic) => !topic.isCentralTopic());
+
+    this._clipboard = topics.map((topic) => {
+      const nodeModel = topic.getModel().deepCopy();
+
+      // Change position to make the new topic evident...
+      const pos = nodeModel.getPosition();
+      nodeModel.setPosition(pos.x + 60 * Math.sign(pos.x), pos.y + 30);
+
+      return nodeModel;
+    });
+
+    $notify($msg('SELECTION_COPIED_TO_CLIPBOARD'));
+  }
+
+  /** paste clipboard contents to the mindmap */
+  pasteClipboard() {
+    if (this._clipboard.length === 0) {
+      $notify($msg('CLIPBOARD_IS_EMPTY'));
+      return;
+    }
+    this._actionDispatcher.addTopics(this._clipboard);
+    this._clipboard = [];
+  }
+
+  /** @return {mindplot.DesignerModel} model */
+  getModel() {
+    return this._model;
+  }
+
+  /** collapse the subtree of the selected topic */
+  shrinkSelectedBranch() {
+    const nodes = this.getModel().filterSelectedTopics();
+    if (nodes.length <= 0 || nodes.length !== 1) {
+      // If there are more than one node selected,
+      $notify($msg('ONLY_ONE_TOPIC_MUST_BE_SELECTED_COLLAPSE'));
+      return;
+    }
+    // Execute event ...
+    const topic = nodes[0];
+    if (topic.getType() !== INodeModel.CENTRAL_TOPIC_TYPE) {
+      this._actionDispatcher.shrinkBranch([topic.getId()], !topic.areChildrenShrunken());
+    }
+  }
+
+  /** create a NodeModel for the selected node's child and add it via the ActionDispatcher */
+  createChildForSelectedNode() {
+    const nodes = this.getModel().filterSelectedTopics();
+    if (nodes.length <= 0) {
+      // If there are more than one node selected,
+      $notify($msg('ONE_TOPIC_MUST_BE_SELECTED'));
+      return;
+    }
+    if (nodes.length !== 1) {
+      // If there are more than one node selected,
+      $notify($msg('ONLY_ONE_TOPIC_MUST_BE_SELECTED'));
+      return;
+    }
+
+    // Add new node ...
+    const parentTopic = nodes[0];
+    const parentTopicId = parentTopic.getId();
+    const childModel = this._createChildModel(parentTopic);
+
+    // Execute event ...
+    this._actionDispatcher.addTopics([childModel], [parentTopicId]);
+  }
+
+  /**
+       * @private
+       */
+  _copyNodeProps(sourceModel, targetModel) {
+    // I don't copy the font size if the target is the source is the central topic.
+    if (sourceModel.getType() !== INodeModel.CENTRAL_TOPIC_TYPE) {
+      const fontSize = sourceModel.getFontSize();
+      if (fontSize) {
+        targetModel.setFontSize(fontSize);
+      }
+    }
+
+    const fontFamily = sourceModel.getFontFamily();
+    if (fontFamily) {
+      targetModel.setFontFamily(fontFamily);
+    }
+
+    const fontColor = sourceModel.getFontColor();
+    if (fontColor) {
+      targetModel.setFontColor(fontColor);
+    }
+
+    const fontWeight = sourceModel.getFontWeight();
+    if (fontWeight) {
+      targetModel.setFontWeight(fontWeight);
+    }
+
+    const fontStyle = sourceModel.getFontStyle();
+    if (fontStyle) {
+      targetModel.setFontStyle(fontStyle);
+    }
+
+    const shape = sourceModel.getShapeType();
+    if (shape) {
+      targetModel.setShapeType(shape);
+    }
+
+    const borderColor = sourceModel.getBorderColor();
+    if (borderColor) {
+      targetModel.setBorderColor(borderColor);
+    }
+
+    const backgroundColor = sourceModel.getBackgroundColor();
+    if (backgroundColor) {
+      targetModel.setBackgroundColor(backgroundColor);
+    }
+  }
+
+  /**
+       * @private
+       * @param {mindplot.Topic} topic the parent topic of the child to create the NodeModel for
+       * @param {web2d.Point} mousePos the mouse position
+       * @return {mindplot.NodeModel} the node model for the new child
+       */
+  _createChildModel(topic, mousePos) {
+    // Create a new node ...
+    const parentModel = topic.getModel();
+    const mindmap = parentModel.getMindmap();
+    const childModel = mindmap.createNode();
+
+    // Create a new node ...
+    const layoutManager = this._eventBussDispatcher.getLayoutManager();
+    const result = layoutManager.predict(topic.getId(), null, mousePos);
+    childModel.setOrder(result.order);
+
+    const { position } = result;
+    childModel.setPosition(position.x, position.y);
+
+    this._copyNodeProps(parentModel, childModel);
+
+    return childModel;
+  }
+
+  addDraggedNode(event, model) {
+    $assert(event, 'event can not be null');
+    $assert(model, 'model can not be null');
+
+    // Position far from the visual area ...
+    model.setPosition(1000, 1000);
+
+    this._actionDispatcher.addTopics([model]);
+    const topic = this.getModel().findTopicById(model.getId());
+
+    // Simulate a mouse down event to start the dragging ...
+    topic.fireEvent('mousedown', event);
+  }
+
+  /**
+       * creates a sibling or child node of the selected node, if the selected node is the
+       * central topic
+       */
+  createSiblingForSelectedNode() {
+    const nodes = this.getModel().filterSelectedTopics();
+    if (nodes.length <= 0) {
+      // If there are no nodes selected,
+      $notify($msg('ONE_TOPIC_MUST_BE_SELECTED'));
+      return;
+    }
+    if (nodes.length > 1) {
+      // If there are more than one node selected,
+      $notify($msg('ONLY_ONE_TOPIC_MUST_BE_SELECTED'));
+      return;
+    }
+
+    const topic = nodes[0];
+    if (!topic.getOutgoingConnectedTopic()) {
+      // Central topic and isolated topics ....
+      // Central topic doesn't have siblings ...
+      this.createChildForSelectedNode();
+    } else {
       const parentTopic = topic.getOutgoingConnectedTopic();
-      if (parentTopic != null) {
-        // Create a new node ...
-        model = topic.getModel();
-        const mindmap = model.getMindmap();
-        result = mindmap.createNode();
+      const siblingModel = this._createSiblingModel(topic);
 
-        // Create a new node ...
-        const order = topic.getOrder() + 1;
-        result.setOrder(order);
-        result.setPosition(10, 10); // Set a dummy position ...
+      // Hack: if parent is central topic, add node below not on opposite side.
+      // This should be done in the layout
+      if (parentTopic.getType() === INodeModel.CENTRAL_TOPIC_TYPE) {
+        siblingModel.setOrder(topic.getOrder() + 2);
       }
 
-      this._copyNodeProps(model, result);
+      const parentTopicId = parentTopic.getId();
+      this._actionDispatcher.addTopics([siblingModel], [parentTopicId]);
+    }
+  }
 
-      return result;
-    },
+  /**
+       * @private
+       * @param {mindplot.Topic} topic the topic to create the sibling to
+       * @return {mindplot.NodeModel} the node model of the sibling
+       */
+  _createSiblingModel(topic) {
+    let result = null;
+    let model = null;
+    const parentTopic = topic.getOutgoingConnectedTopic();
+    if (parentTopic != null) {
+      // Create a new node ...
+      model = topic.getModel();
+      const mindmap = model.getMindmap();
+      result = mindmap.createNode();
 
-    /**
-         * @param {Event} event
-         */
-    showRelPivot(event) {
-      const nodes = this.getModel().filterSelectedTopics();
-      if (nodes.length <= 0) {
-        // This could not happen ...
-        $notify($msg('RELATIONSHIP_COULD_NOT_BE_CREATED'));
-        return;
+      // Create a new node ...
+      const order = topic.getOrder() + 1;
+      result.setOrder(order);
+      result.setPosition(10, 10); // Set a dummy position ...
+    }
+
+    this._copyNodeProps(model, result);
+
+    return result;
+  }
+
+  /**
+       * @param {Event} event
+       */
+  showRelPivot(event) {
+    const nodes = this.getModel().filterSelectedTopics();
+    if (nodes.length <= 0) {
+      // This could not happen ...
+      $notify($msg('RELATIONSHIP_COULD_NOT_BE_CREATED'));
+      return;
+    }
+
+    // Current mouse position ....
+    const screen = this._workspace.getScreenManager();
+    const pos = screen.getWorkspaceMousePosition(event);
+
+    // create a connection ...
+    this._relPivot.start(nodes[0], pos);
+  }
+
+  /** @return {{zoom:Number}} the zoom */
+  getMindmapProperties() {
+    const model = this.getModel();
+    return { zoom: model.getZoom() };
+  }
+
+  /**
+       * @param {mindplot.Mindmap} mindmapModel
+       * @throws will throw an error if mindmapModel is null or undefined
+       */
+  loadMap(mindmapModel) {
+    $assert(mindmapModel, 'mindmapModel can not be null');
+    this._mindmap = mindmapModel;
+
+    // Init layout manager ...
+    const size = { width: 25, height: 25 };
+    const layoutManager = new LayoutManager(mindmapModel.getCentralTopic().getId(), size);
+    const me = this;
+    layoutManager.addEvent('change', (event) => {
+      const id = event.getId();
+      const topic = me.getModel().findTopicById(id);
+      topic.setPosition(event.getPosition());
+      topic.setOrder(event.getOrder());
+    });
+    this._eventBussDispatcher.setLayoutManager(layoutManager);
+
+    // Building node graph ...
+    const branches = mindmapModel.getBranches();
+    for (let i = 0; i < branches.length; i++) {
+      // NodeModel -> NodeGraph ...
+      const nodeModel = branches[i];
+      const nodeGraph = this.nodeModelToNodeGraph(nodeModel);
+
+      // Update shrink render state...
+      nodeGraph.setBranchVisibility(true);
+    }
+
+    const relationships = mindmapModel.getRelationships();
+    for (let j = 0; j < relationships.length; j++) {
+      this._relationshipModelToRelationship(relationships[j]);
+    }
+
+    // Place the focus on the Central Topic
+    const centralTopic = this.getModel().getCentralTopic();
+    this.goToNode(centralTopic);
+
+    // Finally, sort the map ...
+    EventBus.instance.fireEvent(EventBus.events.DoLayout);
+
+    this.fireEvent('loadSuccess');
+  }
+
+  /** */
+  getMindmap() {
+    return this._mindmap;
+  }
+
+  /** */
+  undo() {
+    // @Todo: This is a hack...
+    this._actionDispatcher._actionRunner.undo();
+  }
+
+  /** */
+  redo() {
+    this._actionDispatcher._actionRunner.redo();
+  }
+
+  /** */
+  isReadOnly() {
+    return this._options.readOnly;
+  }
+
+  /**
+       * @param {mindplot.model.NodeModel} nodeModel
+       * @return {mindplot.Topic} the topic (extends mindplot.NodeGraph) created to the model
+       */
+  nodeModelToNodeGraph(nodeModel) {
+    $assert(nodeModel, 'Node model can not be null');
+    let children = nodeModel.getChildren().slice();
+    children = children.sort((a, b) => a.getOrder() - b.getOrder());
+
+    const nodeGraph = this._buildNodeGraph(nodeModel, this.isReadOnly());
+    nodeGraph.setVisibility(false);
+
+    this._workspace.append(nodeGraph);
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if ($defined(child)) this.nodeModelToNodeGraph(child);
+    }
+
+    return nodeGraph;
+  }
+
+  /**
+       * @private
+       * @param {mindplot.model.RelationshipModel} model
+       * @return {mindplot.Relationship} the relationship created to the model
+       * @throws will throw an error if model is null or undefined
+       */
+  _relationshipModelToRelationship(model) {
+    $assert(model, 'Node model can not be null');
+
+    const result = this._buildRelationshipShape(model);
+
+    const sourceTopic = result.getSourceTopic();
+    sourceTopic.addRelationship(result);
+
+    const targetTopic = result.getTargetTopic();
+    targetTopic.addRelationship(result);
+
+    result.setVisibility(sourceTopic.isVisible() && targetTopic.isVisible());
+
+    this._workspace.append(result);
+    return result;
+  }
+
+  /**
+       * @param {mindplot.model.RelationshipModel} model
+       * @return {mindplot.Relationship} the relationship added to the mindmap
+       */
+  addRelationship(model) {
+    const mindmap = this.getMindmap();
+    mindmap.addRelationship(model);
+    return this._relationshipModelToRelationship(model);
+  }
+
+  /**
+       * deletes the relationship from the linked topics, DesignerModel, Workspace and Mindmap
+       * @param {mindplot.Relationship} rel the relationship to delete
+       */
+  deleteRelationship(rel) {
+    const sourceTopic = rel.getSourceTopic();
+    sourceTopic.deleteRelationship(rel);
+
+    const targetTopic = rel.getTargetTopic();
+    targetTopic.deleteRelationship(rel);
+
+    this.getModel().removeRelationship(rel);
+    this._workspace.removeChild(rel);
+
+    const mindmap = this.getMindmap();
+    mindmap.deleteRelationship(rel.getModel());
+  }
+
+  /**
+       * @private
+       * @param {mindplot.model.RelationshipModel} model
+       * @return {mindplot.Relationship} the new relationship with events registered
+       * @throws will throw an error if the target topic cannot be found
+       */
+  _buildRelationshipShape(model) {
+    const dmodel = this.getModel();
+
+    const sourceTopicId = model.getFromNode();
+    const sourceTopic = dmodel.findTopicById(sourceTopicId);
+
+    const targetTopicId = model.getToNode();
+    const targetTopic = dmodel.findTopicById(targetTopicId);
+    $assert(
+      targetTopic,
+      `targetTopic could not be found:${targetTopicId}${dmodel
+        .getTopics()
+        .map((e) => e.getId())}`,
+    );
+
+    // Build relationship line ....
+    const result = new Relationship(sourceTopic, targetTopic, model);
+    const me = this;
+
+    result.addEvent('ontblur', () => {
+      const topics = me.getModel().filterSelectedTopics();
+      const rels = me.getModel().filterSelectedRelationships();
+
+      if (topics.length === 0 || rels.length === 0) {
+        me.fireEvent('onblur');
+      }
+    });
+
+    result.addEvent('ontfocus', () => {
+      const topics = me.getModel().filterSelectedTopics();
+      const rels = me.getModel().filterSelectedRelationships();
+
+      if (topics.length === 1 || rels.length === 1) {
+        me.fireEvent('onfocus');
+      }
+    });
+
+    // Append it to the workspace ...
+    dmodel.addRelationship(result);
+
+    return result;
+  }
+
+  /**
+       * @param {mindplot.Topic} node the topic to remove
+       * removes the given topic and its children from Workspace, DesignerModel and NodeModel
+       */
+  removeTopic(node) {
+    if (!node.isCentralTopic()) {
+      const parent = node._parent;
+      node.disconnect(this._workspace);
+
+      // remove children
+      while (node.getChildren().length > 0) {
+        this.removeTopic(node.getChildren()[0]);
       }
 
-      // Current mouse position ....
-      const screen = this._workspace.getScreenManager();
-      const pos = screen.getWorkspaceMousePosition(event);
+      this._workspace.removeChild(node);
+      this.getModel().removeTopic(node);
 
-      // create a connection ...
-      this._relPivot.start(nodes[0], pos);
-    },
+      // Delete this node from the model...
+      const model = node.getModel();
+      model.deleteNode();
 
-    /** @return {{zoom:Number}} the zoom */
-    getMindmapProperties() {
-      const model = this.getModel();
-      return { zoom: model.getZoom() };
-    },
+      if ($defined(parent)) {
+        this.goToNode(parent);
+      }
+    }
+  }
 
-    /**
-         * @param {mindplot.Mindmap} mindmapModel
-         * @throws will throw an error if mindmapModel is null or undefined
-         */
-    loadMap(mindmapModel) {
-      $assert(mindmapModel, 'mindmapModel can not be null');
-      this._mindmap = mindmapModel;
+  /**
+       * @private
+       */
+  _resetEdition() {
+    const screenManager = this._workspace.getScreenManager();
+    screenManager.fireEvent('update');
+    screenManager.fireEvent('mouseup');
+    this._relPivot.dispose();
+  }
 
-      // Init layout manager ...
-      const size = { width: 25, height: 25 };
-      const layoutManager = new LayoutManager(mindmapModel.getCentralTopic().getId(), size);
-      const me = this;
-      layoutManager.addEvent('change', (event) => {
-        const id = event.getId();
-        const topic = me.getModel().findTopicById(id);
-        topic.setPosition(event.getPosition());
-        topic.setOrder(event.getOrder());
+  /** */
+  deleteSelectedEntities() {
+    // Is there some action in progress ?.
+    this._resetEdition();
+
+    const topics = this.getModel().filterSelectedTopics();
+    const relation = this.getModel().filterSelectedRelationships();
+    if (topics.length <= 0 && relation.length <= 0) {
+      // If there are more than one node selected,
+      $notify($msg('ENTITIES_COULD_NOT_BE_DELETED'));
+      return;
+    }
+    if (topics.length === 1 && topics[0].isCentralTopic()) {
+      $notify($msg('CENTRAL_TOPIC_CAN_NOT_BE_DELETED'));
+      return;
+    }
+
+    // If the central topic has been selected, I must filter ir
+    const topicIds = topics
+      .filter((topic) => !topic.isCentralTopic())
+      .map((topic) => topic.getId());
+
+    const relIds = relation.map((rel) => rel.getId());
+
+    // Finally delete the topics ...
+    if (topicIds.length > 0 || relIds.length > 0) {
+      this._actionDispatcher.deleteEntities(topicIds, relIds);
+    }
+  }
+
+  /** */
+  changeFontFamily(font) {
+    const topicsIds = this.getModel().filterTopicsIds();
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeFontFamilyToTopic(topicsIds, font);
+    }
+  }
+
+  /** */
+  changeFontStyle() {
+    const topicsIds = this.getModel().filterTopicsIds();
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeFontStyleToTopic(topicsIds);
+    }
+  }
+
+  /** */
+  changeFontColor(color) {
+    $assert(color, 'color can not be null');
+
+    const topicsIds = this.getModel().filterTopicsIds();
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeFontColorToTopic(topicsIds, color);
+    }
+  }
+
+  /** */
+  changeBackgroundColor(color) {
+    const validateFunc = (topic) => topic.getShapeType() !== TopicShape.LINE;
+    const validateError = 'Color can not be set to line topics.';
+
+    const topicsIds = this.getModel().filterTopicsIds(validateFunc, validateError);
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeBackgroundColorToTopic(topicsIds, color);
+    }
+  }
+
+  /** */
+  changeBorderColor(color) {
+    const validateFunc = (topic) => topic.getShapeType() !== TopicShape.LINE;
+    const validateError = 'Color can not be set to line topics.';
+    const topicsIds = this.getModel().filterTopicsIds(validateFunc, validateError);
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeBorderColorToTopic(topicsIds, color);
+    }
+  }
+
+  /** */
+  changeFontSize(size) {
+    const topicsIds = this.getModel().filterTopicsIds();
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeFontSizeToTopic(topicsIds, size);
+    }
+  }
+
+  /** */
+  changeTopicShape(shape) {
+    const validateFunc = (topic) => !(topic.getType() === INodeModel.CENTRAL_TOPIC_TYPE && shape === TopicShape.LINE
+    );
+
+    const validateError = 'Central Topic shape can not be changed to line figure.';
+    const topicsIds = this.getModel().filterTopicsIds(validateFunc, validateError);
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeShapeTypeToTopic(topicsIds, shape);
+    }
+  }
+
+  /** */
+  changeFontWeight() {
+    const topicsIds = this.getModel().filterTopicsIds();
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.changeFontWeightToTopic(topicsIds);
+    }
+  }
+
+  /** */
+  addIconType(iconType) {
+    const topicsIds = this.getModel().filterTopicsIds();
+    if (topicsIds.length > 0) {
+      this._actionDispatcher.addFeatureToTopic(topicsIds[0], TopicFeature.Icon.id, {
+        id: iconType,
       });
-      this._eventBussDispatcher.setLayoutManager(layoutManager);
+    }
+  }
 
-      // Building node graph ...
-      const branches = mindmapModel.getBranches();
-      for (let i = 0; i < branches.length; i++) {
-        // NodeModel -> NodeGraph ...
-        const nodeModel = branches[i];
-        const nodeGraph = this.nodeModelToNodeGraph(nodeModel);
+  /**
+       * lets the selected topic open the link editor where the user can define or modify an
+       * existing link
+       */
+  addLink() {
+    const model = this.getModel();
+    const topic = model.selectedTopic();
+    if (topic) {
+      topic.showLinkEditor();
+      this.onObjectFocusEvent();
+    }
+  }
 
-        // Update shrink render state...
-        nodeGraph.setBranchVisibility(true);
-      }
+  /** */
+  addNote() {
+    const model = this.getModel();
+    const topic = model.selectedTopic();
+    if (topic) {
+      topic.showNoteEditor();
+      this.onObjectFocusEvent();
+    }
+  }
 
-      const relationships = mindmapModel.getRelationships();
-      for (let j = 0; j < relationships.length; j++) {
-        this._relationshipModelToRelationship(relationships[j]);
-      }
+  /**
+       * @param {mindplot.Topic} node
+       * sets the focus to the given node
+       */
+  goToNode(node) {
+    node.setOnFocus(true);
+    this.onObjectFocusEvent(node);
+  }
 
-      // Place the focus on the Central Topic
-      const centralTopic = this.getModel().getCentralTopic();
-      this.goToNode(centralTopic);
-
-      // Finally, sort the map ...
-      EventBus.instance.fireEvent(EventBus.events.DoLayout);
-
-      this.fireEvent('loadSuccess');
-    },
-
-    /** */
-    getMindmap() {
-      return this._mindmap;
-    },
-
-    /** */
-    undo() {
-      // @Todo: This is a hack...
-      this._actionDispatcher._actionRunner.undo();
-    },
-
-    /** */
-    redo() {
-      this._actionDispatcher._actionRunner.redo();
-    },
-
-    /** */
-    isReadOnly() {
-      return this._options.readOnly;
-    },
-
-    /**
-         * @param {mindplot.model.NodeModel} nodeModel
-         * @return {mindplot.Topic} the topic (extends mindplot.NodeGraph) created to the model
-         */
-    nodeModelToNodeGraph(nodeModel) {
-      $assert(nodeModel, 'Node model can not be null');
-      let children = nodeModel.getChildren().slice();
-      children = children.sort((a, b) => a.getOrder() - b.getOrder());
-
-      const nodeGraph = this._buildNodeGraph(nodeModel, this.isReadOnly());
-      nodeGraph.setVisibility(false);
-
-      this._workspace.append(nodeGraph);
-      for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        if ($defined(child)) this.nodeModelToNodeGraph(child);
-      }
-
-      return nodeGraph;
-    },
-
-    /**
-         * @private
-         * @param {mindplot.model.RelationshipModel} model
-         * @return {mindplot.Relationship} the relationship created to the model
-         * @throws will throw an error if model is null or undefined
-         */
-    _relationshipModelToRelationship(model) {
-      $assert(model, 'Node model can not be null');
-
-      const result = this._buildRelationshipShape(model);
-
-      const sourceTopic = result.getSourceTopic();
-      sourceTopic.addRelationship(result);
-
-      const targetTopic = result.getTargetTopic();
-      targetTopic.addRelationship(result);
-
-      result.setVisibility(sourceTopic.isVisible() && targetTopic.isVisible());
-
-      this._workspace.append(result);
-      return result;
-    },
-
-    /**
-         * @param {mindplot.model.RelationshipModel} model
-         * @return {mindplot.Relationship} the relationship added to the mindmap
-         */
-    addRelationship(model) {
-      const mindmap = this.getMindmap();
-      mindmap.addRelationship(model);
-      return this._relationshipModelToRelationship(model);
-    },
-
-    /**
-         * deletes the relationship from the linked topics, DesignerModel, Workspace and Mindmap
-         * @param {mindplot.Relationship} rel the relationship to delete
-         */
-    deleteRelationship(rel) {
-      const sourceTopic = rel.getSourceTopic();
-      sourceTopic.deleteRelationship(rel);
-
-      const targetTopic = rel.getTargetTopic();
-      targetTopic.deleteRelationship(rel);
-
-      this.getModel().removeRelationship(rel);
-      this._workspace.removeChild(rel);
-
-      const mindmap = this.getMindmap();
-      mindmap.deleteRelationship(rel.getModel());
-    },
-
-    /**
-         * @private
-         * @param {mindplot.model.RelationshipModel} model
-         * @return {mindplot.Relationship} the new relationship with events registered
-         * @throws will throw an error if the target topic cannot be found
-         */
-    _buildRelationshipShape(model) {
-      const dmodel = this.getModel();
-
-      const sourceTopicId = model.getFromNode();
-      const sourceTopic = dmodel.findTopicById(sourceTopicId);
-
-      const targetTopicId = model.getToNode();
-      const targetTopic = dmodel.findTopicById(targetTopicId);
-      $assert(
-        targetTopic,
-        `targetTopic could not be found:${targetTopicId}${dmodel
-          .getTopics()
-          .map((e) => e.getId())}`,
-      );
-
-      // Build relationship line ....
-      const result = new Relationship(sourceTopic, targetTopic, model);
-      const me = this;
-
-      result.addEvent('ontblur', () => {
-        const topics = me.getModel().filterSelectedTopics();
-        const rels = me.getModel().filterSelectedRelationships();
-
-        if (topics.length === 0 || rels.length === 0) {
-          me.fireEvent('onblur');
-        }
-      });
-
-      result.addEvent('ontfocus', () => {
-        const topics = me.getModel().filterSelectedTopics();
-        const rels = me.getModel().filterSelectedRelationships();
-
-        if (topics.length === 1 || rels.length === 1) {
-          me.fireEvent('onfocus');
-        }
-      });
-
-      // Append it to the workspace ...
-      dmodel.addRelationship(result);
-
-      return result;
-    },
-
-    /**
-         * @param {mindplot.Topic} node the topic to remove
-         * removes the given topic and its children from Workspace, DesignerModel and NodeModel
-         */
-    removeTopic(node) {
-      if (!node.isCentralTopic()) {
-        const parent = node._parent;
-        node.disconnect(this._workspace);
-
-        // remove children
-        while (node.getChildren().length > 0) {
-          this.removeTopic(node.getChildren()[0]);
-        }
-
-        this._workspace.removeChild(node);
-        this.getModel().removeTopic(node);
-
-        // Delete this node from the model...
-        const model = node.getModel();
-        model.deleteNode();
-
-        if ($defined(parent)) {
-          this.goToNode(parent);
-        }
-      }
-    },
-
-    /**
-         * @private
-         */
-    _resetEdition() {
-      const screenManager = this._workspace.getScreenManager();
-      screenManager.fireEvent('update');
-      screenManager.fireEvent('mouseup');
-      this._relPivot.dispose();
-    },
-
-    /** */
-    deleteSelectedEntities() {
-      // Is there some action in progress ?.
-      this._resetEdition();
-
-      const topics = this.getModel().filterSelectedTopics();
-      const relation = this.getModel().filterSelectedRelationships();
-      if (topics.length <= 0 && relation.length <= 0) {
-        // If there are more than one node selected,
-        $notify($msg('ENTITIES_COULD_NOT_BE_DELETED'));
-        return;
-      }
-      if (topics.length === 1 && topics[0].isCentralTopic()) {
-        $notify($msg('CENTRAL_TOPIC_CAN_NOT_BE_DELETED'));
-        return;
-      }
-
-      // If the central topic has been selected, I must filter ir
-      const topicIds = topics
-        .filter((topic) => !topic.isCentralTopic())
-        .map((topic) => topic.getId());
-
-      const relIds = relation.map((rel) => rel.getId());
-
-      // Finally delete the topics ...
-      if (topicIds.length > 0 || relIds.length > 0) {
-        this._actionDispatcher.deleteEntities(topicIds, relIds);
-      }
-    },
-
-    /** */
-    changeFontFamily(font) {
-      const topicsIds = this.getModel().filterTopicsIds();
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeFontFamilyToTopic(topicsIds, font);
-      }
-    },
-
-    /** */
-    changeFontStyle() {
-      const topicsIds = this.getModel().filterTopicsIds();
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeFontStyleToTopic(topicsIds);
-      }
-    },
-
-    /** */
-    changeFontColor(color) {
-      $assert(color, 'color can not be null');
-
-      const topicsIds = this.getModel().filterTopicsIds();
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeFontColorToTopic(topicsIds, color);
-      }
-    },
-
-    /** */
-    changeBackgroundColor(color) {
-      const validateFunc = (topic) => topic.getShapeType() !== TopicShape.LINE;
-      const validateError = 'Color can not be set to line topics.';
-
-      const topicsIds = this.getModel().filterTopicsIds(validateFunc, validateError);
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeBackgroundColorToTopic(topicsIds, color);
-      }
-    },
-
-    /** */
-    changeBorderColor(color) {
-      const validateFunc = (topic) => topic.getShapeType() !== TopicShape.LINE;
-      const validateError = 'Color can not be set to line topics.';
-      const topicsIds = this.getModel().filterTopicsIds(validateFunc, validateError);
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeBorderColorToTopic(topicsIds, color);
-      }
-    },
-
-    /** */
-    changeFontSize(size) {
-      const topicsIds = this.getModel().filterTopicsIds();
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeFontSizeToTopic(topicsIds, size);
-      }
-    },
-
-    /** */
-    changeTopicShape(shape) {
-      const validateFunc = (topic) => !(topic.getType() === INodeModel.CENTRAL_TOPIC_TYPE && shape === TopicShape.LINE
-      );
-
-      const validateError = 'Central Topic shape can not be changed to line figure.';
-      const topicsIds = this.getModel().filterTopicsIds(validateFunc, validateError);
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeShapeTypeToTopic(topicsIds, shape);
-      }
-    },
-
-    /** */
-    changeFontWeight() {
-      const topicsIds = this.getModel().filterTopicsIds();
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.changeFontWeightToTopic(topicsIds);
-      }
-    },
-
-    /** */
-    addIconType(iconType) {
-      const topicsIds = this.getModel().filterTopicsIds();
-      if (topicsIds.length > 0) {
-        this._actionDispatcher.addFeatureToTopic(topicsIds[0], TopicFeature.Icon.id, {
-          id: iconType,
-        });
-      }
-    },
-
-    /**
-         * lets the selected topic open the link editor where the user can define or modify an
-         * existing link
-         */
-    addLink() {
-      const model = this.getModel();
-      const topic = model.selectedTopic();
-      if (topic) {
-        topic.showLinkEditor();
-        this.onObjectFocusEvent();
-      }
-    },
-
-    /** */
-    addNote() {
-      const model = this.getModel();
-      const topic = model.selectedTopic();
-      if (topic) {
-        topic.showNoteEditor();
-        this.onObjectFocusEvent();
-      }
-    },
-
-    /**
-         * @param {mindplot.Topic} node
-         * sets the focus to the given node
-         */
-    goToNode(node) {
-      node.setOnFocus(true);
-      this.onObjectFocusEvent(node);
-    },
-
-    /** @return {mindplot.Workspace} */
-    getWorkSpace() {
-      return this._workspace;
-    },
-  },
-);
+  /** @return {mindplot.Workspace} */
+  getWorkSpace() {
+    return this._workspace;
+  }
+}
 
 export default Designer;
diff --git a/packages/mindplot/src/components/DesignerKeyboard.js b/packages/mindplot/src/components/DesignerKeyboard.js
index 35816de6..4089bdc3 100644
--- a/packages/mindplot/src/components/DesignerKeyboard.js
+++ b/packages/mindplot/src/components/DesignerKeyboard.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import Keyboard from './Keyboard';
 
 const DesignerKeyboard = new Class({
diff --git a/packages/mindplot/src/components/DesignerModel.js b/packages/mindplot/src/components/DesignerModel.js
index 11289985..04678dcd 100644
--- a/packages/mindplot/src/components/DesignerModel.js
+++ b/packages/mindplot/src/components/DesignerModel.js
@@ -15,51 +15,42 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import Events from './Events';
 
-const DesignerModel = new Class(/** @lends DesignerModel */{
-  Implements: [Events],
-  /**
-     * @implements {mindplot.Events}
-     * @constructs
-     * @param {{readOnly: Boolean, zoom: Number, saveOnLoad: Boolean, size: {width: Number,
-     * height: Number}, viewPort: {width: Number, height: Number}, container: String,
-     * persistenceManager: String, mapId: String, locale: String}} options
-     * options loaded from json config
-     * @see {@link ConfigParameters.md}
-     * @see {@link editor.html}
-     */
-  initialize(options) {
+class DesignerModel extends Events {
+  constructor(options) {
+    super();
     this._zoom = options.zoom;
     this._topics = [];
     this._relationships = [];
-  },
+  }
 
   /** @return {Number} zoom between 0.3 (largest text) and 1.9 */
   getZoom() {
     return this._zoom;
-  },
+  }
 
   /** @param {Number} zoom number between 0.3 and 1.9 to set the zoom to */
   setZoom(zoom) {
     this._zoom = zoom;
-  },
+  }
 
   /** @return {@link mindplot.Topic[]} all topics */
   getTopics() {
     return this._topics;
-  },
+  }
 
   /** @return {mindplot.Relationship[]} all relationships */
   getRelationships() {
     return this._relationships;
-  },
+  }
 
   /** @return {mindplot.CentralTopic} the central topic */
   getCentralTopic() {
     const topics = this.getTopics();
     return topics[0];
-  },
+  }
 
   /** @return {mindplot.Topic[]} selected topics */
   filterSelectedTopics() {
@@ -70,7 +61,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
       }
     }
     return result;
-  },
+  }
 
   /**
      * @return {mindplot.Relationship[]} selected relationships
@@ -83,7 +74,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
       }
     }
     return result;
-  },
+  }
 
   /**
      * @return {Array.<mindplot.Relationship, mindplot.Topic>} all topics and relationships
@@ -92,7 +83,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
     const result = [].append(this._topics);
     result.append(this._relationships);
     return result;
-  },
+  }
 
   /**
      * removes occurrences of the given topic from the topic array
@@ -101,7 +92,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
   removeTopic(topic) {
     $assert(topic, 'topic can not be null');
     this._topics.erase(topic);
-  },
+  }
 
   /**
      * removes occurrences of the given relationship from the relationship array
@@ -110,7 +101,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
   removeRelationship(rel) {
     $assert(rel, 'rel can not be null');
     this._relationships.erase(rel);
-  },
+  }
 
   /**
      * adds the given topic to the topic array
@@ -122,7 +113,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
     $assert(topic, 'topic can not be null');
     $assert(typeof topic.getId() === 'number', `id is not a number:${topic.getId()}`);
     this._topics.push(topic);
-  },
+  }
 
   /**
      * adds the given relationship to the relationship array
@@ -132,7 +123,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
   addRelationship(rel) {
     $assert(rel, 'rel can not be null');
     this._relationships.push(rel);
-  },
+  }
 
   /**
      * @param {Function=} validate a function to validate nodes
@@ -158,7 +149,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
       }
     }
     return result;
-  },
+  }
 
   /**
      * @return {mindplot.Topic} the first selected topic if one or more are found by the
@@ -167,7 +158,7 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
   selectedTopic() {
     const topics = this.filterSelectedTopics();
     return (topics.length > 0) ? topics[0] : null;
-  },
+  }
 
   /**
      * @param {String} id the id of the topic to be retrieved
@@ -177,13 +168,13 @@ const DesignerModel = new Class(/** @lends DesignerModel */{
     let result = null;
     for (let i = 0; i < this._topics.length; i++) {
       const topic = this._topics[i];
-      if (topic.getId() == id) {
+      if (topic.getId() === id) {
         result = topic;
         break;
       }
     }
     return result;
-  },
-});
+  }
+}
 
 export default DesignerModel;
diff --git a/packages/mindplot/src/components/DesignerUndoManager.js b/packages/mindplot/src/components/DesignerUndoManager.js
index 15f06754..d6b425ff 100644
--- a/packages/mindplot/src/components/DesignerUndoManager.js
+++ b/packages/mindplot/src/components/DesignerUndoManager.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 
 const DesignerUndoManager = new Class({
   initialize(fireChange) {
diff --git a/packages/mindplot/src/components/DragConnector.js b/packages/mindplot/src/components/DragConnector.js
index da539906..e65402ab 100644
--- a/packages/mindplot/src/components/DragConnector.js
+++ b/packages/mindplot/src/components/DragConnector.js
@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-
+import { $assert } from '@wisemapping/core-js';
 const DragConnector = new Class({
   initialize(designerModel, workspace) {
     $assert(designerModel, 'designerModel can not be null');
diff --git a/packages/mindplot/src/components/DragManager.js b/packages/mindplot/src/components/DragManager.js
index 9d9cbdca..b4a587ae 100644
--- a/packages/mindplot/src/components/DragManager.js
+++ b/packages/mindplot/src/components/DragManager.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import DragTopic from './DragTopic';
 
 const DragManager = new Class({
diff --git a/packages/mindplot/src/components/DragPivot.js b/packages/mindplot/src/components/DragPivot.js
index 5ce7ff4c..215e5fae 100644
--- a/packages/mindplot/src/components/DragPivot.js
+++ b/packages/mindplot/src/components/DragPivot.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import web2d from '@wisemapping/web2d';
 
 import DragTopicConfig from './DragTopicConfig';
diff --git a/packages/mindplot/src/components/DragTopic.js b/packages/mindplot/src/components/DragTopic.js
index f011df0a..dc59a3aa 100644
--- a/packages/mindplot/src/components/DragTopic.js
+++ b/packages/mindplot/src/components/DragTopic.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import web2d from '@wisemapping/web2d';
 
 import ActionDispatcher from './ActionDispatcher';
diff --git a/packages/mindplot/src/components/Events.js b/packages/mindplot/src/components/Events.js
index dbad7a59..9d0c96a8 100644
--- a/packages/mindplot/src/components/Events.js
+++ b/packages/mindplot/src/components/Events.js
@@ -1,20 +1,41 @@
-const Events = new Class({
-  $events: {},
+/*
+ *    Copyright [2015] [wisemapping]
+ *
+ *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
+ *   It is basically the Apache License, Version 2.0 (the "License") plus the
+ *   "powered by wisemapping" text requirement on every single page;
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the license at
+ *
+ *       http://www.wisemapping.org/license
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+import _ from '@libraries/underscore-min';
 
-  _removeOn(string) {
+class Events {
+  constructor() {
+    this.$events = {};
+  }
+
+  static _removeOn(string) {
     return string.replace(/^on([A-Z])/, (full, first) => first.toLowerCase());
-  },
+  }
 
   addEvent(type, fn, internal) {
-    type = this._removeOn(type);
+    type = Events._removeOn(type);
 
     this.$events[type] = (this.$events[type] || []).include(fn);
     if (internal) fn.internal = true;
     return this;
-  },
+  }
 
   fireEvent(type, args, delay) {
-    type = this._removeOn(type);
+    type = Events._removeOn(type);
     const events = this.$events[type];
     if (!events) return this;
     args = Array.isArray(args) ? args : [args];
@@ -27,17 +48,17 @@ const Events = new Class({
       this,
     );
     return this;
-  },
+  }
 
   removeEvent(type, fn) {
-    type = this._removeOn(type);
+    type = Events._removeOn(type);
     const events = this.$events[type];
     if (events && !fn.internal) {
       const index = events.indexOf(fn);
-      if (index != -1) events.splice(index, 1);
+      if (index !== -1) events.splice(index, 1);
     }
     return this;
-  },
-});
+  }
+}
 
 export default Events;
diff --git a/packages/mindplot/src/components/IconGroup.js b/packages/mindplot/src/components/IconGroup.js
index 48b0477e..6c819dda 100644
--- a/packages/mindplot/src/components/IconGroup.js
+++ b/packages/mindplot/src/components/IconGroup.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import web2d from '@wisemapping/web2d';
 
 import Icon from './Icon';
diff --git a/packages/mindplot/src/components/Keyboard.js b/packages/mindplot/src/components/Keyboard.js
index 0ae86470..d360d83e 100644
--- a/packages/mindplot/src/components/Keyboard.js
+++ b/packages/mindplot/src/components/Keyboard.js
@@ -16,11 +16,8 @@
  *   limitations under the License.
  */
 
-const Keyboard = new Class({
-
-  initialize() {
-  },
-
+class Keyboard {
+  // eslint-disable-next-line class-methods-use-this
   addShortcut(shortcuts, callback) {
     if (!$.isArray(shortcuts)) {
       shortcuts = [shortcuts];
@@ -28,8 +25,7 @@ const Keyboard = new Class({
     _.each(shortcuts, (shortcut) => {
       $(document).bind('keydown', shortcut, callback);
     });
-  },
-
-});
+  }
+}
 
 export default Keyboard;
diff --git a/packages/mindplot/src/components/LinkIcon.js b/packages/mindplot/src/components/LinkIcon.js
index ad484edf..27c02d36 100644
--- a/packages/mindplot/src/components/LinkIcon.js
+++ b/packages/mindplot/src/components/LinkIcon.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import Icon from './Icon';
 import LinkIconTooltip from './widget/LinkIconTooltip';
 
diff --git a/packages/mindplot/src/components/MainTopic.js b/packages/mindplot/src/components/MainTopic.js
index 9f2da86c..74a40c62 100644
--- a/packages/mindplot/src/components/MainTopic.js
+++ b/packages/mindplot/src/components/MainTopic.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import web2d from '@wisemapping/web2d';
 
 import Topic from './Topic';
diff --git a/packages/mindplot/src/components/NodeGraph.js b/packages/mindplot/src/components/NodeGraph.js
index 003b9d69..f38aa96a 100644
--- a/packages/mindplot/src/components/NodeGraph.js
+++ b/packages/mindplot/src/components/NodeGraph.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import TopicConfig from './TopicConfig';
 import DragTopic from './DragTopic';
 
diff --git a/packages/mindplot/src/components/NodeGraphUtils.js b/packages/mindplot/src/components/NodeGraphUtils.js
index 3b466eb3..30ec6aa2 100644
--- a/packages/mindplot/src/components/NodeGraphUtils.js
+++ b/packages/mindplot/src/components/NodeGraphUtils.js
@@ -1,3 +1,5 @@
+import { $assert } from '@wisemapping/core-js';
+
 import CentralTopic from './CentralTopic';
 import MainTopic from './MainTopic';
 import INodeModel from './model/INodeModel';
diff --git a/packages/mindplot/src/components/NoteIcon.js b/packages/mindplot/src/components/NoteIcon.js
index 2a42ea62..79fd89a0 100644
--- a/packages/mindplot/src/components/NoteIcon.js
+++ b/packages/mindplot/src/components/NoteIcon.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import Icon from './Icon';
 import FloatingTip from './widget/FloatingTip';
 
diff --git a/packages/mindplot/src/components/Relationship.js b/packages/mindplot/src/components/Relationship.js
index d0d233b7..abb0ddd3 100644
--- a/packages/mindplot/src/components/Relationship.js
+++ b/packages/mindplot/src/components/Relationship.js
@@ -16,6 +16,7 @@
  *   limitations under the License.
  */
 import web2d from '@wisemapping/web2d';
+import { $assert, $defined } from '@wisemapping/core-js';
 
 import ConnectionLine from './ConnectionLine';
 import ControlPoint from './ControlPoint';
diff --git a/packages/mindplot/src/components/RestPersistenceManager.js b/packages/mindplot/src/components/RestPersistenceManager.js
index e3a8cfda..e2ffc9f9 100644
--- a/packages/mindplot/src/components/RestPersistenceManager.js
+++ b/packages/mindplot/src/components/RestPersistenceManager.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import PersistenceManager from './PersistenceManager';
 
 const RESTPersistenceManager = new Class({
diff --git a/packages/mindplot/src/components/StandaloneActionDispatcher.js b/packages/mindplot/src/components/StandaloneActionDispatcher.js
index 740e4f5c..bb62b7a1 100644
--- a/packages/mindplot/src/components/StandaloneActionDispatcher.js
+++ b/packages/mindplot/src/components/StandaloneActionDispatcher.js
@@ -30,345 +30,238 @@ import ChangeFeatureToTopicCommand from './commands/ChangeFeatureToTopicCommand'
 import NodeModel from './model/NodeModel';
 import EventBus from './layout/EventBus';
 
-const StandaloneActionDispatcher = new Class(
-  /** @lends StandaloneActionDispatcher */ {
-    Extends: ActionDispatcher,
-    /**
-         * @extends mindplot.ActionDispatcher
-         * @constructs
-         * @param {mindplot.CommandContext} commandContext
-         */
-    initialize(commandContext) {
-      this.parent(commandContext);
-      this._actionRunner = new DesignerActionRunner(commandContext, this);
-    },
+class StandaloneActionDispatcher extends ActionDispatcher {
+  constructor(commandContext) {
+    super(commandContext);
+    this._actionRunner = new DesignerActionRunner(commandContext, this);
+  }
 
-    /** */
-    addTopics(models, parentTopicsId) {
-      const command = new AddTopicCommand(models, parentTopicsId);
-      this.execute(command);
-    },
+  /** */
+  addTopics(models, parentTopicsId) {
+    const command = new AddTopicCommand(models, parentTopicsId);
+    this.execute(command);
+  }
 
-    /** */
-    addRelationship(model) {
-      const command = new AddRelationshipCommand(model);
-      this.execute(command);
-    },
+  /** */
+  addRelationship(model) {
+    const command = new AddRelationshipCommand(model);
+    this.execute(command);
+  }
 
-    /** */
-    deleteEntities(topicsIds, relIds) {
-      const command = new DeleteCommand(topicsIds, relIds);
-      this.execute(command);
-    },
+  /** */
+  deleteEntities(topicsIds, relIds) {
+    const command = new DeleteCommand(topicsIds, relIds);
+    this.execute(command);
+  }
 
-    /** */
-    dragTopic(topicId, position, order, parentTopic) {
-      const command = new DragTopicCommand(topicId, position, order, parentTopic);
-      this.execute(command);
-    },
+  /** */
+  dragTopic(topicId, position, order, parentTopic) {
+    const command = new DragTopicCommand(topicId, position, order, parentTopic);
+    this.execute(command);
+  }
 
-    /** */
-    moveTopic(topicId, position) {
-      $assert($defined(topicId), 'topicsId can not be null');
-      $assert($defined(position), 'position can not be null');
+  /** */
+  moveTopic(topicId, position) {
+    $assert($defined(topicId), 'topicsId can not be null');
+    $assert($defined(position), 'position can not be null');
 
-      const commandFunc = (topic, value) => {
-        const result = topic.getPosition();
-        EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
-          node: topic.getModel(),
-          position: value,
-        });
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicId, position);
-      this.execute(command);
-    },
-
-    /** */
-    moveControlPoint(ctrlPoint, point) {
-      const command = new MoveControlPointCommand(ctrlPoint, point);
-      this.execute(command);
-    },
-
-    /** */
-    changeFontStyleToTopic(topicsIds) {
-      const commandFunc = (topic) => {
-        const result = topic.getFontStyle();
-        const style = result === 'italic' ? 'normal' : 'italic';
-        topic.setFontStyle(style, true);
-        return result;
-      };
-      const command = new GenericFunctionCommand(commandFunc, topicsIds);
-      this.execute(command);
-    },
-
-    /** */
-    changeTextToTopic(topicsIds, text) {
-      $assert($defined(topicsIds), 'topicsIds can not be null');
-
-      const commandFunc = (topic, value) => {
-        const result = topic.getText();
-        topic.setText(value);
-        return result;
-      };
-      commandFunc.commandType = 'changeTextToTopic';
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, text);
-      this.execute(command);
-    },
-
-    /** */
-    changeFontFamilyToTopic(topicIds, fontFamily) {
-      $assert(topicIds, 'topicIds can not be null');
-      $assert(fontFamily, 'fontFamily can not be null');
-
-      const commandFunc = (topic, fontFamily) => {
-        const result = topic.getFontFamily();
-        topic.setFontFamily(fontFamily, true);
-
-        topic._adjustShapes();
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicIds, fontFamily);
-      this.execute(command);
-    },
-
-    /** */
-    changeFontColorToTopic(topicsIds, color) {
-      $assert(topicsIds, 'topicIds can not be null');
-      $assert(color, 'color can not be null');
-
-      const commandFunc = (topic, color) => {
-        const result = topic.getFontColor();
-        topic.setFontColor(color, true);
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
-      command.discardDuplicated = 'fontColorCommandId';
-      this.execute(command);
-    },
-
-    /** */
-    changeBackgroundColorToTopic(topicsIds, color) {
-      $assert(topicsIds, 'topicIds can not be null');
-      $assert(color, 'color can not be null');
-
-      const commandFunc = (topic, color) => {
-        const result = topic.getBackgroundColor();
-        topic.setBackgroundColor(color);
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
-      command.discardDuplicated = 'backColor';
-      this.execute(command);
-    },
-
-    /** */
-    changeBorderColorToTopic(topicsIds, color) {
-      $assert(topicsIds, 'topicIds can not be null');
-      $assert(color, 'topicIds can not be null');
-
-      const commandFunc = (topic, color) => {
-        const result = topic.getBorderColor();
-        topic.setBorderColor(color);
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
-      command.discardDuplicated = 'borderColorCommandId';
-      this.execute(command);
-    },
-
-    /** */
-    changeFontSizeToTopic(topicsIds, size) {
-      $assert(topicsIds, 'topicIds can not be null');
-      $assert(size, 'size can not be null');
-
-      const commandFunc = (topic, size) => {
-        const result = topic.getFontSize();
-        topic.setFontSize(size, true);
-
-        topic._adjustShapes();
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, size);
-      this.execute(command);
-    },
-
-    /** */
-    changeShapeTypeToTopic(topicsIds, shapeType) {
-      $assert(topicsIds, 'topicsIds can not be null');
-      $assert(shapeType, 'shapeType can not be null');
-
-      const commandFunc = (topic, shapeType) => {
-        const result = topic.getShapeType();
-        topic.setShapeType(shapeType, true);
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, shapeType);
-      this.execute(command);
-    },
-
-    /** */
-    changeFontWeightToTopic(topicsIds) {
-      $assert(topicsIds, 'topicsIds can not be null');
-
-      const commandFunc = (topic) => {
-        const result = topic.getFontWeight();
-        const weight = result === 'bold' ? 'normal' : 'bold';
-        topic.setFontWeight(weight, true);
-
-        topic._adjustShapes();
-        return result;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds);
-      this.execute(command);
-    },
-
-    /** */
-    shrinkBranch(topicsIds, collapse) {
-      $assert(topicsIds, 'topicsIds can not be null');
-
-      const commandFunc = (topic, isShrink) => {
-        topic.setChildrenShrunken(isShrink);
-        return !isShrink;
-      };
-
-      const command = new GenericFunctionCommand(commandFunc, topicsIds, collapse);
-      this.execute(command, false);
-    },
-
-    /** */
-    addFeatureToTopic(topicId, featureType, attributes) {
-      const command = new AddFeatureToTopicCommand(topicId, featureType, attributes);
-      this.execute(command);
-    },
-
-    /** */
-    changeFeatureToTopic(topicId, featureId, attributes) {
-      const command = new ChangeFeatureToTopicCommand(topicId, featureId, attributes);
-      this.execute(command);
-    },
-
-    /** */
-    removeFeatureFromTopic(topicId, featureId) {
-      const command = new RemoveFeatureFromTopicCommand(topicId, featureId);
-      this.execute(command);
-    },
-
-    /** */
-    execute(command) {
-      this._actionRunner.execute(command);
-    },
-  },
-);
-
-const CommandContext = new Class(
-  /** @lends CommandContext */ {
-    /**
-         * @constructs
-         * @param {mindplot.Designer} designer
-         */
-    initialize(designer) {
-      $assert(designer, 'designer can not be null');
-      this._designer = designer;
-    },
-
-    /** */
-    findTopics(topicsIds) {
-      $assert($defined(topicsIds), 'topicsIds can not be null');
-      if (!(topicsIds instanceof Array)) {
-        topicsIds = [topicsIds];
-      }
-
-      const designerTopics = this._designer.getModel().getTopics();
-      const result = designerTopics.filter((topic) => topicsIds.contains(topic.getId()));
-
-      if (result.length !== topicsIds.length) {
-        const ids = designerTopics.map((topic) => topic.getId());
-        $assert(
-          result.length === topicsIds.length,
-          `Could not find topic. Result:${result
-          }, Filter Criteria:${topicsIds
-          }, Current Topics: [${ids
-          }]`,
-        );
-      }
-      return result;
-    },
-
-    /** */
-    deleteTopic(topic) {
-      this._designer.removeTopic(topic);
-    },
-
-    /** */
-    createTopic(model) {
-      $assert(model, 'model can not be null');
-      return this._designer.nodeModelToNodeGraph(model);
-    },
-
-    /** */
-    createModel() {
-      const mindmap = this._designer.getMindmap();
-      return mindmap.createNode(NodeModel.MAIN_TOPIC_TYPE);
-    },
-
-    /** */
-    addTopic(topic) {
-      const mindmap = this._designer.getMindmap();
-      return mindmap.addBranch(topic.getModel());
-    },
-
-    /** */
-    connect(childTopic, parentTopic) {
-      childTopic.connectTo(parentTopic, this._designer._workspace);
-    },
-
-    /** */
-    disconnect(topic) {
-      topic.disconnect(this._designer._workspace);
-    },
-
-    /** */
-    addRelationship(model) {
-      $assert(model, 'model cannot be null');
-      return this._designer.addRelationship(model);
-    },
-
-    /** */
-    deleteRelationship(relationship) {
-      this._designer.deleteRelationship(relationship);
-    },
-
-    /** */
-    findRelationships(relIds) {
-      $assert($defined(relIds), 'relId can not be null');
-      if (!(relIds instanceof Array)) {
-        relIds = [relIds];
-      }
-
-      const designerRel = this._designer.getModel().getRelationships();
-      return designerRel.filter((rel) => relIds.contains(rel.getId()));
-    },
-
-    /** */
-    moveTopic(topic, position) {
-      $assert(topic, 'topic cannot be null');
-      $assert(position, 'position cannot be null');
+    const commandFunc = (topic, value) => {
+      const result = topic.getPosition();
       EventBus.instance.fireEvent(EventBus.events.NodeMoveEvent, {
         node: topic.getModel(),
-        position,
+        position: value,
       });
-    },
-  },
-);
+      return result;
+    };
 
-export { StandaloneActionDispatcher, CommandContext };
+    const command = new GenericFunctionCommand(commandFunc, topicId, position);
+    this.execute(command);
+  }
+
+  /** */
+  moveControlPoint(ctrlPoint, point) {
+    const command = new MoveControlPointCommand(ctrlPoint, point);
+    this.execute(command);
+  }
+
+  /** */
+  changeFontStyleToTopic(topicsIds) {
+    const commandFunc = (topic) => {
+      const result = topic.getFontStyle();
+      const style = result === 'italic' ? 'normal' : 'italic';
+      topic.setFontStyle(style, true);
+      return result;
+    };
+    const command = new GenericFunctionCommand(commandFunc, topicsIds);
+    this.execute(command);
+  }
+
+  /** */
+  changeTextToTopic(topicsIds, text) {
+    $assert($defined(topicsIds), 'topicsIds can not be null');
+
+    const commandFunc = (topic, value) => {
+      const result = topic.getText();
+      topic.setText(value);
+      return result;
+    };
+    commandFunc.commandType = 'changeTextToTopic';
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, text);
+    this.execute(command);
+  }
+
+  /** */
+  changeFontFamilyToTopic(topicIds, fontFamily) {
+    $assert(topicIds, 'topicIds can not be null');
+    $assert(fontFamily, 'fontFamily can not be null');
+
+    const commandFunc = (topic, fontFamily) => {
+      const result = topic.getFontFamily();
+      topic.setFontFamily(fontFamily, true);
+
+      topic._adjustShapes();
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicIds, fontFamily);
+    this.execute(command);
+  }
+
+  /** */
+  changeFontColorToTopic(topicsIds, color) {
+    $assert(topicsIds, 'topicIds can not be null');
+    $assert(color, 'color can not be null');
+
+    const commandFunc = (topic, color) => {
+      const result = topic.getFontColor();
+      topic.setFontColor(color, true);
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
+    command.discardDuplicated = 'fontColorCommandId';
+    this.execute(command);
+  }
+
+  /** */
+  changeBackgroundColorToTopic(topicsIds, color) {
+    $assert(topicsIds, 'topicIds can not be null');
+    $assert(color, 'color can not be null');
+
+    const commandFunc = (topic, color) => {
+      const result = topic.getBackgroundColor();
+      topic.setBackgroundColor(color);
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
+    command.discardDuplicated = 'backColor';
+    this.execute(command);
+  }
+
+  /** */
+  changeBorderColorToTopic(topicsIds, color) {
+    $assert(topicsIds, 'topicIds can not be null');
+    $assert(color, 'topicIds can not be null');
+
+    const commandFunc = (topic, color) => {
+      const result = topic.getBorderColor();
+      topic.setBorderColor(color);
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, color);
+    command.discardDuplicated = 'borderColorCommandId';
+    this.execute(command);
+  }
+
+  /** */
+  changeFontSizeToTopic(topicsIds, size) {
+    $assert(topicsIds, 'topicIds can not be null');
+    $assert(size, 'size can not be null');
+
+    const commandFunc = (topic, size) => {
+      const result = topic.getFontSize();
+      topic.setFontSize(size, true);
+
+      topic._adjustShapes();
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, size);
+    this.execute(command);
+  }
+
+  /** */
+  changeShapeTypeToTopic(topicsIds, shapeType) {
+    $assert(topicsIds, 'topicsIds can not be null');
+    $assert(shapeType, 'shapeType can not be null');
+
+    const commandFunc = (topic, shapeType) => {
+      const result = topic.getShapeType();
+      topic.setShapeType(shapeType, true);
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, shapeType);
+    this.execute(command);
+  }
+
+  /** */
+  changeFontWeightToTopic(topicsIds) {
+    $assert(topicsIds, 'topicsIds can not be null');
+
+    const commandFunc = (topic) => {
+      const result = topic.getFontWeight();
+      const weight = result === 'bold' ? 'normal' : 'bold';
+      topic.setFontWeight(weight, true);
+
+      topic._adjustShapes();
+      return result;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds);
+    this.execute(command);
+  }
+
+  /** */
+  shrinkBranch(topicsIds, collapse) {
+    $assert(topicsIds, 'topicsIds can not be null');
+
+    const commandFunc = (topic, isShrink) => {
+      topic.setChildrenShrunken(isShrink);
+      return !isShrink;
+    };
+
+    const command = new GenericFunctionCommand(commandFunc, topicsIds, collapse);
+    this.execute(command, false);
+  }
+
+  /** */
+  addFeatureToTopic(topicId, featureType, attributes) {
+    const command = new AddFeatureToTopicCommand(topicId, featureType, attributes);
+    this.execute(command);
+  }
+
+  /** */
+  changeFeatureToTopic(topicId, featureId, attributes) {
+    const command = new ChangeFeatureToTopicCommand(topicId, featureId, attributes);
+    this.execute(command);
+  }
+
+  /** */
+  removeFeatureFromTopic(topicId, featureId) {
+    const command = new RemoveFeatureFromTopicCommand(topicId, featureId);
+    this.execute(command);
+  }
+
+  /** */
+  execute(command) {
+    this._actionRunner.execute(command);
+  }
+}
+
+
+
+export default StandaloneActionDispatcher ;
diff --git a/packages/mindplot/src/components/TextEditor.js b/packages/mindplot/src/components/TextEditor.js
index 2b54422d..6b792554 100644
--- a/packages/mindplot/src/components/TextEditor.js
+++ b/packages/mindplot/src/components/TextEditor.js
@@ -12,8 +12,8 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $defined } from '@wisemapping/core-js';
 import web2d from '@wisemapping/web2d';
-
 import ActionDispatcher from './ActionDispatcher';
 
 // FIXME: Not used!
diff --git a/packages/mindplot/src/components/Topic.js b/packages/mindplot/src/components/Topic.js
index 252d38d0..5c7b6074 100644
--- a/packages/mindplot/src/components/Topic.js
+++ b/packages/mindplot/src/components/Topic.js
@@ -15,6 +15,8 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
+import { _ } from '@libraries/underscore-min';
 import web2d from '@wisemapping/web2d';
 
 import NodeGraph from './NodeGraph';
@@ -192,7 +194,7 @@ const Topic = new Class(
           return model.getImageSize();
         };
 
-        result.setPosition = function () {};
+        result.setPosition = function () { };
       } else if (shapeType === TopicShape.ELLIPSE) {
         result = new web2d.Rect(0.9, attributes);
       } else if (shapeType === TopicShape.ROUNDED_RECT) {
@@ -213,11 +215,11 @@ const Topic = new Class(
           return this.size;
         };
 
-        result.setPosition = function () {};
+        result.setPosition = function () { };
 
-        result.setFill = function () {};
+        result.setFill = function () { };
 
-        result.setStroke = function () {};
+        result.setStroke = function () { };
       } else {
         $assert(false, `Unsupported figure shapeType:${shapeType}`);
       }
@@ -644,7 +646,7 @@ const Topic = new Class(
           let value = true;
           if (
             (event.metaKey && Browser.Platform.mac)
-                        || (event.ctrlKey && !Browser.Platform.mac)
+            || (event.ctrlKey && !Browser.Platform.mac)
           ) {
             value = !me.isOnFocus();
             event.stopPropagation();
@@ -969,8 +971,8 @@ const Topic = new Class(
         const sourceParent = sourceTopic.getModel().getParent();
         relationship.setVisibility(
           value
-                        && (targetParent == null || !targetParent.areChildrenShrunken())
-                        && (sourceParent == null || !sourceParent.areChildrenShrunken()),
+          && (targetParent == null || !targetParent.areChildrenShrunken())
+          && (sourceParent == null || !sourceParent.areChildrenShrunken()),
         );
       });
     },
diff --git a/packages/mindplot/src/components/TopicEventDispatcher.js b/packages/mindplot/src/components/TopicEventDispatcher.js
index a31273b1..1e0a1e72 100644
--- a/packages/mindplot/src/components/TopicEventDispatcher.js
+++ b/packages/mindplot/src/components/TopicEventDispatcher.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import Events from './Events';
 import MultilineTextEditor from './MultilineTextEditor';
 import { TopicShape } from './model/INodeModel';
diff --git a/packages/mindplot/src/components/TopicFeature.js b/packages/mindplot/src/components/TopicFeature.js
index 758173a1..28782a66 100644
--- a/packages/mindplot/src/components/TopicFeature.js
+++ b/packages/mindplot/src/components/TopicFeature.js
@@ -16,7 +16,7 @@
  *   limitations under the License.
  */
 
-/** */
+import { $assert } from '@wisemapping/core-js';
 import IconModel from './model/IconModel';
 import ImageIcon from './ImageIcon';
 import LinkModel from './model/LinkModel';
diff --git a/packages/mindplot/src/components/TopicStyle.js b/packages/mindplot/src/components/TopicStyle.js
index 7db56086..6a87b41b 100644
--- a/packages/mindplot/src/components/TopicStyle.js
+++ b/packages/mindplot/src/components/TopicStyle.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import { TopicShape } from './model/INodeModel';
 
 const TopicStyle = new Class({});
diff --git a/packages/mindplot/src/components/Workspace.js b/packages/mindplot/src/components/Workspace.js
index 80d8d672..f73ea34d 100644
--- a/packages/mindplot/src/components/Workspace.js
+++ b/packages/mindplot/src/components/Workspace.js
@@ -15,7 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-import { $assert } from '@wisemapping/core-js';
+import { $assert, $defined } from '@wisemapping/core-js';
 import web2d from '@wisemapping/web2d';
 
 class Workspace {
diff --git a/packages/mindplot/src/components/header.js b/packages/mindplot/src/components/header.js
deleted file mode 100644
index e7b9b5f7..00000000
--- a/packages/mindplot/src/components/header.js
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- *    Copyright [2015] [wisemapping]
- *
- *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
- *   It is basically the Apache License, Version 2.0 (the "License") plus the
- *   "powered by wisemapping" text requirement on every single page;
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the license at
- *
- *       http://www.wisemapping.org/license
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-const mindplot = {};
-mindplot.util = {};
-mindplot.commands = {};
-mindplot.layout = {};
-mindplot.layout.boards = {};
-mindplot.layout.boards.original = {};
-mindplot.widget = {};
-mindplot.model = {};
-mindplot.collaboration = {};
-mindplot.collaboration.framework = {};
-mindplot.persistence = {};
-
-mindplot.layout = {};
-
-Class.Mutators.Static = function (items) {
-  this.extend(items);
-};
diff --git a/packages/mindplot/src/components/index.js b/packages/mindplot/src/components/index.js
deleted file mode 100644
index b6b417ed..00000000
--- a/packages/mindplot/src/components/index.js
+++ /dev/null
@@ -1,95 +0,0 @@
-import actionDispatcher from './ActionDispatcher';
-import actionIcon from './ActionIcon';
-import centralTopic from './CentralTopic';
-import command from './Command';
-import connectionLine from './ConnectionLine';
-import controlPoint from './ControlPoint';
-import designer from './Designer';
-import designerActionRunner from './DesignerActionRunner';
-import designerKeyboard from './DesignerKeyboard';
-import designerModal from './DesignerModel';
-import designerUndoManager from './DesignerUndoManager';
-import dragConnector from './DragConnector';
-import dragManager from './DragManager';
-import dragPivot from './DragPivot';
-import dragTopic from './DragTopic';
-import editorOptions from './EditorOptions';
-import editorProperties from './EditorProperties';
-import events from './Events';
-import footer from './footer';
-import header from './header';
-import icon from './Icon';
-import iconGroup from './IconGroup';
-import imageIcon from './ImageIcon';
-import keyboard from './Keyboard';
-import linkIcon from './LinkIcon';
-import localSorageManager from './LocalStorageManager';
-import mainTopic from './MainTopic';
-import messages from './Messages';
-import multilineTextEditor from './MultilineTextEditor';
-import nodeGraph from './NodeGraph';
-import noteIcon from './NoteIcon';
-import options from './Options';
-import persistenceManager from './PersistenceManager';
-import relationship from './Relationship';
-import relationshipPivot from './RelationshipPivot';
-import resetPersistenceManager from './RestPersistenceManager';
-import screenManager from './ScreenManager';
-import shrinkConnector from './ShrinkConnector';
-import standaloneActionDispatcher from './StandaloneActionDispatcher';
-import textEditor from './TextEditor';
-import textEditorFactory from './TextEditorFactory';
-import topic from './Topic';
-import topicEventDispatcher from './TopicEventDispatcher';
-import topicFeature from './TopicFeature';
-import topicStyle from './TopicStyle';
-import workspace from './Workspace';
-
-export default {
-  ActionDispatcher: actionDispatcher,
-  ActionIcon: actionIcon,
-  CentralTopic: centralTopic,
-  Command: command,
-  ConnectionLine: connectionLine,
-  ControlPoint: controlPoint,
-  Designer: designer,
-  DesignerActionRunner: designerActionRunner,
-  DesignerKeyboard: designerKeyboard,
-  DesignerModel: designerModal,
-  DesignerUndoManager: designerUndoManager,
-  DragConnector: dragConnector,
-  DragManager: dragManager,
-  DragPivot: dragPivot,
-  DragTopic: dragTopic,
-  EditorOptions: editorOptions,
-  EditorProperties: editorProperties,
-  Events: events,
-  Footer: footer,
-  Header: header,
-  Icon: icon,
-  IconGroup: iconGroup,
-  ImageIcon: imageIcon,
-  Keyboard: keyboard,
-  LinkIcon: linkIcon,
-  LocalStorageManager: localSorageManager,
-  MainTopic: mainTopic,
-  Messages: messages,
-  MultilineTextEditor: multilineTextEditor,
-  NodeGraph: nodeGraph,
-  NoteIcon: noteIcon,
-  Options: options,
-  PersistenceManager: persistenceManager,
-  Relationship: relationship,
-  RelationshipPivot: relationshipPivot,
-  RestPersistenceManager: resetPersistenceManager,
-  ScreenManager: screenManager,
-  ShrinkConnector: shrinkConnector,
-  StandaloneActionDispatcher: standaloneActionDispatcher,
-  TextEditor: textEditor,
-  TextEditorFactory: textEditorFactory,
-  Topic: topic,
-  TopicEventDispatcher: topicEventDispatcher,
-  TopicFeature: topicFeature,
-  TopicStyle: topicStyle,
-  Workspace: workspace,
-};
diff --git a/packages/mindplot/src/components/layout/BalancedSorter.js b/packages/mindplot/src/components/layout/BalancedSorter.js
index 867915bd..3e7608b5 100644
--- a/packages/mindplot/src/components/layout/BalancedSorter.js
+++ b/packages/mindplot/src/components/layout/BalancedSorter.js
@@ -15,6 +15,8 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import _ from '@libraries/underscore-min';
+import { $assert, $defined } from '@wisemapping/core-js';
 import AbstractBasicSorter from './AbstractBasicSorter';
 
 const BalancedSorter = new Class(
diff --git a/packages/mindplot/src/components/layout/ChangeEvent.js b/packages/mindplot/src/components/layout/ChangeEvent.js
index 5f55ee10..ebb0fb61 100644
--- a/packages/mindplot/src/components/layout/ChangeEvent.js
+++ b/packages/mindplot/src/components/layout/ChangeEvent.js
@@ -15,34 +15,30 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 
-const ChangeEvent = new Class(/** @lends ChangeEvent */{
-  /**
-     * @constructs
-     * @param {} id
-     * @throws will throw an error if the given id is not/cannot be converted to a numerical value
-     */
-  initialize(id) {
-    $assert(!isNaN(id), 'id can not be null');
+class ChangeEvent {
+  constructor(id) {
+    $assert(!Number.isNaN(id), 'id can not be null');
     this._id = id;
     this._position = null;
     this._order = null;
-  },
+  }
 
   /** @return id */
   getId() {
     return this._id;
-  },
+  }
 
   /** @return order */
   getOrder() {
     return this._order;
-  },
+  }
 
   /** @return position */
   getPosition() {
     return this._position;
-  },
+  }
 
   /**
      * @param {} value the order to set
@@ -50,21 +46,21 @@ const ChangeEvent = new Class(/** @lends ChangeEvent */{
      * value
      */
   setOrder(value) {
-    $assert(!isNaN(value), 'value can not be null');
+    $assert(!Number.isNaN(value), 'value can not be null');
     this._order = value;
-  },
+  }
 
   /** @param {} value
      *  @throws will throw an error if the value is null or undefined */
   setPosition(value) {
     $assert(value, 'value can not be null');
     this._position = value;
-  },
+  }
 
   /** @return {String} order and position */
   toString() {
     return `[order:${this.getOrder()}, position: {${this.getPosition().x},${this.getPosition().y}}]`;
-  },
-});
+  }
+}
 
 export default ChangeEvent;
diff --git a/packages/mindplot/src/components/layout/EventBus.js b/packages/mindplot/src/components/layout/EventBus.js
index 17a890b9..8837abbf 100644
--- a/packages/mindplot/src/components/layout/EventBus.js
+++ b/packages/mindplot/src/components/layout/EventBus.js
@@ -17,15 +17,8 @@
  */
 import Events from '../Events';
 
-const EventBus = new Class(/** @lends EventBus */{
-  Implements: Events,
-  /**
-     * @constructs
-     * @implements mindplot.Events
-     */
-  initialize() {
-  },
-});
+class EventBus extends Events {
+}
 
 /**
  * Enum for events
diff --git a/packages/mindplot/src/components/layout/GridSorter.js b/packages/mindplot/src/components/layout/GridSorter.js
index 6c9e962e..657de416 100644
--- a/packages/mindplot/src/components/layout/GridSorter.js
+++ b/packages/mindplot/src/components/layout/GridSorter.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert } from '@wisemapping/core-js';
 import AbstractBasicSorter from './AbstractBasicSorter';
 
 /**
diff --git a/packages/mindplot/src/components/layout/LayoutManager.js b/packages/mindplot/src/components/layout/LayoutManager.js
index 240d7566..37f4e519 100644
--- a/packages/mindplot/src/components/layout/LayoutManager.js
+++ b/packages/mindplot/src/components/layout/LayoutManager.js
@@ -15,274 +15,269 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import _ from '@libraries/underscore-min';
+import $ from '@libraries/jquery-2.1.0';
+import { $assert, $defined } from '@wisemapping/core-js';
 import Events from '../Events';
 import RootedTreeSet from './RootedTreeSet';
 import OriginalLayout from './OriginalLayout';
 import ChangeEvent from './ChangeEvent';
 
-const LayoutManager = new Class(
-  /** @lends LayoutManager */ {
-    Extends: Events,
-    /**
-         * @constructs
-         * @extends mindplot.Events
-         * @param {} rootNodeId
-         * @param {} rootSize
-         * @throws will throw an error if the root node id is null or undefined
-         * @throws will throw an error if the root size is null
-         */
-    initialize(rootNodeId, rootSize) {
-      $assert($defined(rootNodeId), 'rootNodeId can not be null');
-      $assert(rootSize, 'rootSize can not be null');
-      var position = position || { x: 0, y: 0 };
+class LayoutManager extends Events {
+  constructor(rootNodeId, rootSize) {
+    super();
+    $assert($defined(rootNodeId), 'rootNodeId can not be null');
+    $assert(rootSize, 'rootSize can not be null');
+    var position = position || { x: 0, y: 0 };
 
-      this._treeSet = new RootedTreeSet();
-      this._layout = new OriginalLayout(this._treeSet);
+    this._treeSet = new RootedTreeSet();
+    this._layout = new OriginalLayout(this._treeSet);
 
-      const rootNode = this._layout.createNode(rootNodeId, rootSize, position, 'root');
-      this._treeSet.setRoot(rootNode);
-      this._events = [];
-    },
+    const rootNode = this._layout.createNode(rootNodeId, rootSize, position, 'root');
+    this._treeSet.setRoot(rootNode);
+    this._events = [];
+  }
 
-    /**
-         * @param id
-         * @param size
-         * @throws will throw an error if id is null or undefined
-         */
-    updateNodeSize(id, size) {
-      $assert($defined(id), 'id can not be null');
+  /**
+       * @param id
+       * @param size
+       * @throws will throw an error if id is null or undefined
+       */
+  updateNodeSize(id, size) {
+    $assert($defined(id), 'id can not be null');
 
-      const node = this._treeSet.find(id);
-      node.setSize(size);
-    },
+    const node = this._treeSet.find(id);
+    node.setSize(size);
+  }
 
-    /**
-         * @param id
-         * @param value
-         * @throws will throw an error if id is null or undefined
-         * @throws will throw an error if value is null or undefined
-         * @return this
-         */
-    updateShrinkState(id, value) {
-      $assert($defined(id), 'id can not be null');
-      $assert($defined(value), 'value can not be null');
+  /**
+       * @param id
+       * @param value
+       * @throws will throw an error if id is null or undefined
+       * @throws will throw an error if value is null or undefined
+       * @return this
+       */
+  updateShrinkState(id, value) {
+    $assert($defined(id), 'id can not be null');
+    $assert($defined(value), 'value can not be null');
 
-      const node = this._treeSet.find(id);
-      node.setShrunken(value);
+    const node = this._treeSet.find(id);
+    node.setShrunken(value);
 
-      return this;
-    },
+    return this;
+  }
 
-    /**
-         * @param id
-         * @return {@link RootedTreeSet}.find(id)
-         */
-    find(id) {
-      return this._treeSet.find(id);
-    },
+  /**
+       * @param id
+       * @return {@link RootedTreeSet}.find(id)
+       */
+  find(id) {
+    return this._treeSet.find(id);
+  }
 
-    /**
-         * @param id
-         * @param position
-         * @throws will throw an error if id is null or undefined
-         * @throws will throw an error if position is null or undefined
-         * @throws will throw an error if the position's x property is null or undefined
-         * @throws will throw an error if the position's y property is null or undefined
-         */
-    moveNode(id, position) {
-      $assert($defined(id), 'id cannot be null');
-      $assert($defined(position), 'position cannot be null');
-      $assert($defined(position.x), 'x can not be null');
-      $assert($defined(position.y), 'y can not be null');
+  /**
+       * @param id
+       * @param position
+       * @throws will throw an error if id is null or undefined
+       * @throws will throw an error if position is null or undefined
+       * @throws will throw an error if the position's x property is null or undefined
+       * @throws will throw an error if the position's y property is null or undefined
+       */
+  moveNode(id, position) {
+    $assert($defined(id), 'id cannot be null');
+    $assert($defined(position), 'position cannot be null');
+    $assert($defined(position.x), 'x can not be null');
+    $assert($defined(position.y), 'y can not be null');
 
-      const node = this._treeSet.find(id);
-      // @Todo: this should not be here. This is broking the isolated node support...
-      //        node.setFree(true);
-      //        node.setFreeDisplacement({x:position.x - node.getPosition().x, y:position.y - node.getPosition().y});
-      node.setPosition(position);
-    },
+    const node = this._treeSet.find(id);
+    // @Todo: this should not be here. This is broking the isolated node support...
+    //        node.setFree(true);
+    //        node.setFreeDisplacement({x:position.x - node.getPosition().x, y:position.y - node.getPosition().y});
+    node.setPosition(position);
+  }
 
-    /**
-         * @param parentId
-         * @param childId
-         * @param order
-         * @throws will throw an error if parentId is null or undefined
-         * @throws will throw an error if childId is null or undefined
-         * @throws will throw an error if order is null or undefined
-         * @return this
-         */
-    connectNode(parentId, childId, order) {
-      $assert($defined(parentId), 'parentId cannot be null');
-      $assert($defined(childId), 'childId cannot be null');
-      $assert($defined(order), 'order cannot be null');
+  /**
+       * @param parentId
+       * @param childId
+       * @param order
+       * @throws will throw an error if parentId is null or undefined
+       * @throws will throw an error if childId is null or undefined
+       * @throws will throw an error if order is null or undefined
+       * @return this
+       */
+  connectNode(parentId, childId, order) {
+    $assert($defined(parentId), 'parentId cannot be null');
+    $assert($defined(childId), 'childId cannot be null');
+    $assert($defined(order), 'order cannot be null');
 
-      this._layout.connectNode(parentId, childId, order);
+    this._layout.connectNode(parentId, childId, order);
 
-      return this;
-    },
+    return this;
+  }
 
-    /**
-         * @param id
-         * @throws will throw an error if id is null or undefined
-         * @return this
-         */
-    disconnectNode(id) {
-      $assert($defined(id), 'id can not be null');
-      this._layout.disconnectNode(id);
+  /**
+       * @param id
+       * @throws will throw an error if id is null or undefined
+       * @return this
+       */
+  disconnectNode(id) {
+    $assert($defined(id), 'id can not be null');
+    this._layout.disconnectNode(id);
 
-      return this;
-    },
+    return this;
+  }
 
-    /**
-         * @param id
-         * @param size
-         * @param position
-         * @throws will throw an error if id is null or undefined
-         * @return this
-         */
-    addNode(id, size, position) {
-      $assert($defined(id), 'id can not be null');
-      const result = this._layout.createNode(id, size, position, 'topic');
-      this._treeSet.add(result);
+  /**
+       * @param id
+       * @param size
+       * @param position
+       * @throws will throw an error if id is null or undefined
+       * @return this
+       */
+  addNode(id, size, position) {
+    $assert($defined(id), 'id can not be null');
+    const result = this._layout.createNode(id, size, position, 'topic');
+    this._treeSet.add(result);
 
-      return this;
-    },
+    return this;
+  }
 
-    /**
-         * removes a node and its connection to parent if existing
-         * @param id
-         * @throws will throw an error if id is null or undefined
-         * @return this
-         */
-    removeNode(id) {
-      $assert($defined(id), 'id can not be null');
-      const node = this._treeSet.find(id);
+  /**
+       * removes a node and its connection to parent if existing
+       * @param id
+       * @throws will throw an error if id is null or undefined
+       * @return this
+       */
+  removeNode(id) {
+    $assert($defined(id), 'id can not be null');
+    const node = this._treeSet.find(id);
 
-      // Is It connected ?
-      if (this._treeSet.getParent(node)) {
-        this.disconnectNode(id);
-      }
+    // Is It connected ?
+    if (this._treeSet.getParent(node)) {
+      this.disconnectNode(id);
+    }
 
-      // Remove the all the branch ...
-      this._treeSet.remove(id);
+    // Remove the all the branch ...
+    this._treeSet.remove(id);
 
-      return this;
-    },
+    return this;
+  }
 
-    /**
-         * @param {Number} parentId
-         * @param {Number=} nodeId
-         * @param {String=} position the position to use as mindplot.layout.Node.properties position
-         * property as '(x,y)'
-         * @param {Boolean=} free true specifies free node positioning
-         * @throws will throw an error if parentId is null or undefined
-         */
-    predict(parentId, nodeId, position, free) {
-      $assert($defined(parentId), 'parentId can not be null');
+  /**
+       * @param {Number} parentId
+       * @param {Number=} nodeId
+       * @param {String=} position the position to use as mindplot.layout.Node.properties position
+       * property as '(x,y)'
+       * @param {Boolean=} free true specifies free node positioning
+       * @throws will throw an error if parentId is null or undefined
+       */
+  predict(parentId, nodeId, position, free) {
+    $assert($defined(parentId), 'parentId can not be null');
 
-      const parent = this._treeSet.find(parentId);
-      const node = nodeId ? this._treeSet.find(nodeId) : null;
-      const sorter = parent.getSorter();
+    const parent = this._treeSet.find(parentId);
+    const node = nodeId ? this._treeSet.find(nodeId) : null;
+    const sorter = parent.getSorter();
 
-      const result = sorter.predict(this._treeSet, parent, node, position, free);
-      return { order: result[0], position: result[1] };
-    },
+    const result = sorter.predict(this._treeSet, parent, node, position, free);
+    return { order: result[0], position: result[1] };
+  }
 
-    /**
-         * logs dump to console
-         */
-    dump() {
-      console.log(this._treeSet.dump());
-    },
+  /**
+       * logs dump to console
+       */
+  dump() {
+    console.log(this._treeSet.dump());
+  }
 
-    /**
-         * @param containerId
-         * @param {width:Number, height:Number} size
-         * @throws will throw an error if containerId is null or undefined
-         * @return canvas
-         */
-    plot(containerId, size) {
-      // this method is only used from tests that include Raphael
-      if (!global.Raphael) {
-        console.warn('Raphael.js not found, exiting plot()');
-        return null;
-      }
-      $assert(containerId, 'containerId cannot be null');
-      size = size || { width: 200, height: 200 };
-      const squaresize = 10;
-      const canvas = global.Raphael(containerId, size.width, size.height);
-      canvas.drawGrid(
-        0,
-        0,
-        size.width,
-        size.height,
-        size.width / squaresize,
-        size.height / squaresize,
-      );
-      this._treeSet.plot(canvas);
+  /**
+       * @param containerId
+       * @param {width:Number, height:Number} size
+       * @throws will throw an error if containerId is null or undefined
+       * @return canvas
+       */
+  plot(containerId, size) {
+    // this method is only used from tests that include Raphael
+    if (!global.Raphael) {
+      console.warn('Raphael.js not found, exiting plot()');
+      return null;
+    }
+    $assert(containerId, 'containerId cannot be null');
+    size = size || { width: 200, height: 200 };
+    const squaresize = 10;
+    const canvas = global.Raphael(containerId, size.width, size.height);
+    canvas.drawGrid(
+      0,
+      0,
+      size.width,
+      size.height,
+      size.width / squaresize,
+      size.height / squaresize,
+    );
+    this._treeSet.plot(canvas);
 
-      return canvas;
-    },
+    return canvas;
+  }
 
-    /**
-         * initializes the layout to be updated
-         * @param fireEvents
-         * @return this
-         */
-    layout(fireEvents) {
-      // File repositioning ...
-      this._layout.layout();
+  /**
+       * initializes the layout to be updated
+       * @param fireEvents
+       * @return this
+       */
+  layout(fireEvents) {
+    // File repositioning ...
+    this._layout.layout();
 
-      // Collect changes ...
-      this._collectChanges();
+    // Collect changes ...
+    this._collectChanges();
 
-      if ($(fireEvents).length > 0 || fireEvents) {
-        this._flushEvents();
-      }
+    if ($(fireEvents).length > 0 || fireEvents) {
+      this._flushEvents();
+    }
 
-      return this;
-    },
+    return this;
+  }
 
-    _flushEvents() {
-      _.each(
-        this._events,
-        function (event) {
-          this.fireEvent('change', event);
-        },
-        this,
-      );
-      this._events = [];
-    },
+  _flushEvents() {
+    _.each(
+      this._events,
+      function (event) {
+        this.fireEvent('change', event);
+      },
+      this,
+    );
+    this._events = [];
+  }
 
-    _collectChanges(nodes) {
-      if (!nodes) nodes = this._treeSet.getTreeRoots();
+  _collectChanges(nodes) {
+    if (!nodes) { 
+      nodes = this._treeSet.getTreeRoots(); 
+    }
 
-      _.each(
-        nodes,
-        function (node) {
-          if (node.hasOrderChanged() || node.hasPositionChanged()) {
-            // Find or create a event ...
-            const id = node.getId();
-            let event = this._events.some((event) => event.id == id);
-            if (!event) {
-              event = new ChangeEvent(id);
-            }
-
-            // Update nodes ...
-            event.setOrder(node.getOrder());
-            event.setPosition(node.getPosition());
-
-            node.resetPositionState();
-            node.resetOrderState();
-            node.resetFreeState();
-            this._events.push(event);
+    _.each(
+      nodes,
+      function (node) {
+        if (node.hasOrderChanged() || node.hasPositionChanged()) {
+          // Find or create a event ...
+          const id = node.getId();
+          let event = this._events.some((event) => event.id == id);
+          if (!event) {
+            event = new ChangeEvent(id);
           }
-          this._collectChanges(this._treeSet.getChildren(node));
-        },
-        this,
-      );
-    },
-  },
-);
+
+          // Update nodes ...
+          event.setOrder(node.getOrder());
+          event.setPosition(node.getPosition());
+
+          node.resetPositionState();
+          node.resetOrderState();
+          node.resetFreeState();
+          this._events.push(event);
+        }
+        this._collectChanges(this._treeSet.getChildren(node));
+      },
+      this,
+    );
+  }
+}
 
 export default LayoutManager;
diff --git a/packages/mindplot/src/components/layout/Node.js b/packages/mindplot/src/components/layout/Node.js
index ae40e0bc..3fba43cb 100644
--- a/packages/mindplot/src/components/layout/Node.js
+++ b/packages/mindplot/src/components/layout/Node.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 
 const Node = new Class(
   /** @lends Node */ {
@@ -30,7 +31,7 @@ const Node = new Class(
          * @throws will throw an error if sorter is null or undefined
          */
     initialize(id, size, position, sorter) {
-      $assert(typeof id === 'number' && isFinite(id), 'id can not be null');
+      $assert(typeof id === 'number' && Number.isFinite(id), 'id can not be null');
       $assert(size, 'size can not be null');
       $assert(position, 'position can not be null');
       $assert(sorter, 'sorter can not be null');
@@ -82,7 +83,7 @@ const Node = new Class(
     /** */
     setOrder(order) {
       $assert(
-        typeof order === 'number' && isFinite(order),
+        typeof order === 'number' && Number.isFinite(order),
         `Order can not be null. Value:${order}`,
       );
       this._setProperty('order', order);
@@ -199,7 +200,7 @@ const Node = new Class(
       }
 
       // Only update if the property has changed ...
-      if (JSON.stringify(prop.value) != JSON.stringify(value)) {
+      if (JSON.stringify(prop.value) !== JSON.stringify(value)) {
         prop.oldValue = prop.value;
         prop.value = value;
         prop.hasChanged = true;
diff --git a/packages/mindplot/src/components/layout/OriginalLayout.js b/packages/mindplot/src/components/layout/OriginalLayout.js
index ee62054d..2bdb1e17 100644
--- a/packages/mindplot/src/components/layout/OriginalLayout.js
+++ b/packages/mindplot/src/components/layout/OriginalLayout.js
@@ -15,265 +15,261 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-
+import _ from '@libraries/underscore-min';
+import { $assert, $defined } from '@wisemapping/core-js';
 import Node from './Node';
 import SymmetricSorter from './SymmetricSorter';
 import BalancedSorter from './BalancedSorter';
 
-const OriginalLayout = new Class(
-  /** @lends OriginalLayout */ {
-    /**
-         * @constructs
-         * @param treeSet
-         */
-    initialize(treeSet) {
-      this._treeSet = treeSet;
-    },
-
-    /** */
-    createNode(id, size, position, type) {
-      $assert($defined(id), 'id can not be null');
-      $assert(size, 'size can not be null');
-      $assert(position, 'position can not be null');
-      $assert(type, 'type can not be null');
-
-      const strategy = type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
-      return new Node(id, size, position, strategy);
-    },
-
-    /** */
-    connectNode(parentId, childId, order) {
-      const parent = this._treeSet.find(parentId);
-      const child = this._treeSet.find(childId);
-
-      // Insert the new node ...
-      const sorter = parent.getSorter();
-      sorter.insert(this._treeSet, parent, child, order);
-
-      // Connect the new node ...
-      this._treeSet.connect(parentId, childId);
-
-      // Fire a basic validation ...
-      sorter.verify(this._treeSet, parent);
-    },
-
-    /** */
-    disconnectNode(nodeId) {
-      const node = this._treeSet.find(nodeId);
-      const parent = this._treeSet.getParent(node);
-      $assert(parent, 'Node already disconnected');
-
-      // Make it fixed
-      node.setFree(false);
-      node.resetFreeDisplacement();
-
-      // Remove from children list.
-      const sorter = parent.getSorter();
-      sorter.detach(this._treeSet, node);
-
-      // Disconnect the new node ...
-      this._treeSet.disconnect(nodeId);
-
-      // Fire a basic validation ...
-      parent.getSorter().verify(this._treeSet, parent);
-    },
-
-    /** */
-    layout() {
-      const roots = this._treeSet.getTreeRoots();
-      _.each(
-        roots,
-        function (node) {
-          // Calculate all node heights ...
-          const sorter = node.getSorter();
-
-          const heightById = sorter.computeChildrenIdByHeights(this._treeSet, node);
-
-          this._layoutChildren(node, heightById);
-
-          this._fixOverlapping(node, heightById);
-        },
-        this,
-      );
-    },
-
-    _layoutChildren(node, heightById) {
-      const nodeId = node.getId();
-      const children = this._treeSet.getChildren(node);
-      const parent = this._treeSet.getParent(node);
-      const childrenOrderMoved = children.some((child) => child.hasOrderChanged());
-      const childrenSizeChanged = children.some((child) => child.hasSizeChanged());
-
-      // If ether any of the nodes has been changed of position or the height of the children is not
-      // the same, children nodes must be repositioned ....
-      const newBranchHeight = heightById[nodeId];
-
-      const parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
-      const heightChanged = node._branchHeight != newBranchHeight;
-      node._heightChanged = heightChanged || parentHeightChanged;
-
-      if (childrenOrderMoved || childrenSizeChanged || heightChanged || parentHeightChanged) {
-        const sorter = node.getSorter();
-        const offsetById = sorter.computeOffsets(this._treeSet, node);
-        const parentPosition = node.getPosition();
-        const me = this;
-        _.each(children, (child) => {
-          const offset = offsetById[child.getId()];
-
-          const childFreeDisplacement = child.getFreeDisplacement();
-          const direction = node.getSorter().getChildDirection(me._treeSet, child);
-
-          if (
-            (direction > 0 && childFreeDisplacement.x < 0)
-                        || (direction < 0 && childFreeDisplacement.x > 0)
-          ) {
-            child.resetFreeDisplacement();
-            child.setFreeDisplacement({
-              x: -childFreeDisplacement.x,
-              y: childFreeDisplacement.y,
-            });
-          }
-
-          offset.x += child.getFreeDisplacement().x;
-          offset.y += child.getFreeDisplacement().y;
-
-          const parentX = parentPosition.x;
-          const parentY = parentPosition.y;
-
-          const newPos = {
-            x: parentX + offset.x,
-            y: parentY + offset.y + me._calculateAlignOffset(node, child, heightById),
-          };
-          me._treeSet.updateBranchPosition(child, newPos);
-        });
-
-        node._branchHeight = newBranchHeight;
-      }
-
-      // Continue reordering the children nodes ...
-      _.each(
-        children,
-        function (child) {
-          this._layoutChildren(child, heightById);
-        },
-        this,
-      );
-    },
-
-    _calculateAlignOffset(node, child, heightById) {
-      if (child.isFree()) {
-        return 0;
-      }
-
-      let offset = 0;
-
-      const nodeHeight = node.getSize().height;
-      const childHeight = child.getSize().height;
-
-      if (
-        this._treeSet.isStartOfSubBranch(child)
-                && this._branchIsTaller(child, heightById)
-      ) {
-        if (this._treeSet.hasSinglePathToSingleLeaf(child)) {
-          offset = heightById[child.getId()] / 2
-                        - (childHeight + child.getSorter()._getVerticalPadding() * 2) / 2;
-        } else {
-          offset = this._treeSet.isLeaf(child) ? 0 : -(childHeight - nodeHeight) / 2;
-        }
-      } else if (nodeHeight > childHeight) {
-        if (this._treeSet.getSiblings(child).length > 0) {
-          offset = 0;
-        } else {
-          offset = nodeHeight / 2 - childHeight / 2;
-        }
-      } else if (childHeight > nodeHeight) {
-        if (this._treeSet.getSiblings(child).length > 0) {
-          offset = 0;
-        } else {
-          offset = -(childHeight / 2 - nodeHeight / 2);
-        }
-      }
-
-      return offset;
-    },
-
-    _branchIsTaller(node, heightById) {
-      return (
-        heightById[node.getId()]
-                > node.getSize().height + node.getSorter()._getVerticalPadding() * 2
-      );
-    },
-
-    _fixOverlapping(node, heightById) {
-      const children = this._treeSet.getChildren(node);
-
-      if (node.isFree()) {
-        this._shiftBranches(node, heightById);
-      }
-
-      _.each(
-        children,
-        function (child) {
-          this._fixOverlapping(child, heightById);
-        },
-        this,
-      );
-    },
-
-    _shiftBranches(node, heightById) {
-      const shiftedBranches = [node];
-
-      const siblingsToShift = this._treeSet.getSiblingsInVerticalDirection(
-        node,
-        node.getFreeDisplacement().y,
-      );
-      let last = node;
-      _.each(
-        siblingsToShift,
-        function (sibling) {
-          const overlappingOccurs = shiftedBranches.some(function (shiftedBranch) {
-            return this._branchesOverlap(shiftedBranch, sibling, heightById);
-          }, this);
-
-          if (!sibling.isFree() || overlappingOccurs) {
-            const sAmount = node.getFreeDisplacement().y;
-            this._treeSet.shiftBranchPosition(sibling, 0, sAmount);
-            shiftedBranches.push(sibling);
-          }
-        },
-        this,
-      );
-
-      const branchesToShift = this._treeSet
-        .getBranchesInVerticalDirection(node, node.getFreeDisplacement().y)
-        .filter((branch) => !shiftedBranches.contains(branch));
-
-      _.each(
-        branchesToShift,
-        function (branch) {
-          const bAmount = node.getFreeDisplacement().y;
-          this._treeSet.shiftBranchPosition(branch, 0, bAmount);
-          shiftedBranches.push(branch);
-          last = branch;
-        },
-        this,
-      );
-    },
-
-    _branchesOverlap(branchA, branchB, heightById) {
-      // a branch doesn't really overlap with itself
-      if (branchA == branchB) {
-        return false;
-      }
-
-      const topA = branchA.getPosition().y - heightById[branchA.getId()] / 2;
-      const bottomA = branchA.getPosition().y + heightById[branchA.getId()] / 2;
-      const topB = branchB.getPosition().y - heightById[branchB.getId()] / 2;
-      const bottomB = branchB.getPosition().y + heightById[branchB.getId()] / 2;
-
-      return !(topA >= bottomB || bottomA <= topB);
-    },
+const OriginalLayout = new Class({
+  initialize(treeSet) {
+    this._treeSet = treeSet;
   },
+
+  /** */
+  createNode(id, size, position, type) {
+    $assert($defined(id), 'id can not be null');
+    $assert(size, 'size can not be null');
+    $assert(position, 'position can not be null');
+    $assert(type, 'type can not be null');
+
+    const strategy = type === 'root' ? OriginalLayout.BALANCED_SORTER : OriginalLayout.SYMMETRIC_SORTER;
+    return new Node(id, size, position, strategy);
+  },
+
+  /** */
+  connectNode(parentId, childId, order) {
+    const parent = this._treeSet.find(parentId);
+    const child = this._treeSet.find(childId);
+
+    // Insert the new node ...
+    const sorter = parent.getSorter();
+    sorter.insert(this._treeSet, parent, child, order);
+
+    // Connect the new node ...
+    this._treeSet.connect(parentId, childId);
+
+    // Fire a basic validation ...
+    sorter.verify(this._treeSet, parent);
+  },
+
+  /** */
+  disconnectNode(nodeId) {
+    const node = this._treeSet.find(nodeId);
+    const parent = this._treeSet.getParent(node);
+    $assert(parent, 'Node already disconnected');
+
+    // Make it fixed
+    node.setFree(false);
+    node.resetFreeDisplacement();
+
+    // Remove from children list.
+    const sorter = parent.getSorter();
+    sorter.detach(this._treeSet, node);
+
+    // Disconnect the new node ...
+    this._treeSet.disconnect(nodeId);
+
+    // Fire a basic validation ...
+    parent.getSorter().verify(this._treeSet, parent);
+  },
+
+  /** */
+  layout() {
+    const roots = this._treeSet.getTreeRoots();
+    _.each(
+      roots,
+      function (node) {
+        // Calculate all node heights ...
+        const sorter = node.getSorter();
+
+        const heightById = sorter.computeChildrenIdByHeights(this._treeSet, node);
+
+        this._layoutChildren(node, heightById);
+
+        this._fixOverlapping(node, heightById);
+      },
+      this,
+    );
+  },
+
+  _layoutChildren(node, heightById) {
+    const nodeId = node.getId();
+    const children = this._treeSet.getChildren(node);
+    const parent = this._treeSet.getParent(node);
+    const childrenOrderMoved = children.some((child) => child.hasOrderChanged());
+    const childrenSizeChanged = children.some((child) => child.hasSizeChanged());
+
+    // If ether any of the nodes has been changed of position or the height of the children is not
+    // the same, children nodes must be repositioned ....
+    const newBranchHeight = heightById[nodeId];
+
+    const parentHeightChanged = $defined(parent) ? parent._heightChanged : false;
+    const heightChanged = node._branchHeight !== newBranchHeight;
+    node._heightChanged = heightChanged || parentHeightChanged;
+
+    if (childrenOrderMoved || childrenSizeChanged || heightChanged || parentHeightChanged) {
+      const sorter = node.getSorter();
+      const offsetById = sorter.computeOffsets(this._treeSet, node);
+      const parentPosition = node.getPosition();
+      const me = this;
+      _.each(children, (child) => {
+        const offset = offsetById[child.getId()];
+
+        const childFreeDisplacement = child.getFreeDisplacement();
+        const direction = node.getSorter().getChildDirection(me._treeSet, child);
+
+        if (
+          (direction > 0 && childFreeDisplacement.x < 0)
+          || (direction < 0 && childFreeDisplacement.x > 0)
+        ) {
+          child.resetFreeDisplacement();
+          child.setFreeDisplacement({
+            x: -childFreeDisplacement.x,
+            y: childFreeDisplacement.y,
+          });
+        }
+
+        offset.x += child.getFreeDisplacement().x;
+        offset.y += child.getFreeDisplacement().y;
+
+        const parentX = parentPosition.x;
+        const parentY = parentPosition.y;
+
+        const newPos = {
+          x: parentX + offset.x,
+          y: parentY + offset.y + me._calculateAlignOffset(node, child, heightById),
+        };
+        me._treeSet.updateBranchPosition(child, newPos);
+      });
+
+      node._branchHeight = newBranchHeight;
+    }
+
+    // Continue reordering the children nodes ...
+    _.each(
+      children,
+      function (child) {
+        this._layoutChildren(child, heightById);
+      },
+      this,
+    );
+  },
+
+  _calculateAlignOffset(node, child, heightById) {
+    if (child.isFree()) {
+      return 0;
+    }
+
+    let offset = 0;
+
+    const nodeHeight = node.getSize().height;
+    const childHeight = child.getSize().height;
+
+    if (
+      this._treeSet.isStartOfSubBranch(child)
+      && this._branchIsTaller(child, heightById)
+    ) {
+      if (this._treeSet.hasSinglePathToSingleLeaf(child)) {
+        offset = heightById[child.getId()] / 2
+          - (childHeight + child.getSorter()._getVerticalPadding() * 2) / 2;
+      } else {
+        offset = this._treeSet.isLeaf(child) ? 0 : -(childHeight - nodeHeight) / 2;
+      }
+    } else if (nodeHeight > childHeight) {
+      if (this._treeSet.getSiblings(child).length > 0) {
+        offset = 0;
+      } else {
+        offset = nodeHeight / 2 - childHeight / 2;
+      }
+    } else if (childHeight > nodeHeight) {
+      if (this._treeSet.getSiblings(child).length > 0) {
+        offset = 0;
+      } else {
+        offset = -(childHeight / 2 - nodeHeight / 2);
+      }
+    }
+
+    return offset;
+  },
+
+  _branchIsTaller(node, heightById) {
+    return (
+      heightById[node.getId()]
+      > node.getSize().height + node.getSorter()._getVerticalPadding() * 2
+    );
+  },
+
+  _fixOverlapping(node, heightById) {
+    const children = this._treeSet.getChildren(node);
+
+    if (node.isFree()) {
+      this._shiftBranches(node, heightById);
+    }
+
+    _.each(
+      children,
+      function (child) {
+        this._fixOverlapping(child, heightById);
+      },
+      this,
+    );
+  },
+
+  _shiftBranches(node, heightById) {
+    const shiftedBranches = [node];
+
+    const siblingsToShift = this._treeSet.getSiblingsInVerticalDirection(
+      node,
+      node.getFreeDisplacement().y,
+    );
+    let last = node;
+    _.each(
+      siblingsToShift,
+      function (sibling) {
+        const overlappingOccurs = shiftedBranches.some(function (shiftedBranch) {
+          return this._branchesOverlap(shiftedBranch, sibling, heightById);
+        }, this);
+
+        if (!sibling.isFree() || overlappingOccurs) {
+          const sAmount = node.getFreeDisplacement().y;
+          this._treeSet.shiftBranchPosition(sibling, 0, sAmount);
+          shiftedBranches.push(sibling);
+        }
+      },
+      this,
+    );
+
+    const branchesToShift = this._treeSet
+      .getBranchesInVerticalDirection(node, node.getFreeDisplacement().y)
+      .filter((branch) => !shiftedBranches.contains(branch));
+
+    _.each(
+      branchesToShift,
+      function (branch) {
+        const bAmount = node.getFreeDisplacement().y;
+        this._treeSet.shiftBranchPosition(branch, 0, bAmount);
+        shiftedBranches.push(branch);
+        last = branch;
+      },
+      this,
+    );
+  },
+
+  _branchesOverlap(branchA, branchB, heightById) {
+    // a branch doesn't really overlap with itself
+    if (branchA === branchB) {
+      return false;
+    }
+
+    const topA = branchA.getPosition().y - heightById[branchA.getId()] / 2;
+    const bottomA = branchA.getPosition().y + heightById[branchA.getId()] / 2;
+    const topB = branchB.getPosition().y - heightById[branchB.getId()] / 2;
+    const bottomB = branchB.getPosition().y + heightById[branchB.getId()] / 2;
+
+    return !(topA >= bottomB || bottomA <= topB);
+  },
+},
 );
 
 /**
diff --git a/packages/mindplot/src/components/layout/RootedTreeSet.js b/packages/mindplot/src/components/layout/RootedTreeSet.js
index b144e848..b2d5e86f 100644
--- a/packages/mindplot/src/components/layout/RootedTreeSet.js
+++ b/packages/mindplot/src/components/layout/RootedTreeSet.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 
 const RootedTreeSet = new Class(
   /** @lends RootedTreeSet */ {
diff --git a/packages/mindplot/src/components/layout/SymmetricSorter.js b/packages/mindplot/src/components/layout/SymmetricSorter.js
index 590b2c2d..1054ba8c 100644
--- a/packages/mindplot/src/components/layout/SymmetricSorter.js
+++ b/packages/mindplot/src/components/layout/SymmetricSorter.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import AbstractBasicSorter from './AbstractBasicSorter';
 
 const SymmetricSorter = new Class(
diff --git a/packages/mindplot/src/components/layout/index.js b/packages/mindplot/src/components/layout/index.js
deleted file mode 100644
index 3071d189..00000000
--- a/packages/mindplot/src/components/layout/index.js
+++ /dev/null
@@ -1,27 +0,0 @@
-import abstractBasicSorter from './AbstractBasicSorter';
-import balancedSorter from './BalancedSorter';
-import changeEvent from './ChangeEvent';
-import childrenSorterStrategy from './ChildrenSorterStrategy';
-import eventBus from './EventBus';
-import eventBusDispatcher from './EventBusDispatcher';
-import gridSorter from './GridSorter';
-import layoutManager from './LayoutManager';
-import node from './Node';
-import originalLayout from './OriginalLayout';
-import rootedTreeSet from './RootedTreeSet';
-import symmetricSorter from './SymmetricSorter';
-
-export default {
-  AbstractBasicSorter: abstractBasicSorter,
-  BalancedSorter: balancedSorter,
-  ChangeEvent: changeEvent,
-  ChildrenSorterStrategy: childrenSorterStrategy,
-  EventBus: eventBus,
-  EventBusDispatcher: eventBusDispatcher,
-  GridSorter: gridSorter,
-  LayoutManager: layoutManager,
-  Node: node,
-  OriginalLayout: originalLayout,
-  RootedTreeSet: rootedTreeSet,
-  SymmetricSorter: symmetricSorter,
-};
diff --git a/packages/mindplot/src/components/libraries/hotkeys/jquery.hotkeys.js b/packages/mindplot/src/components/libraries/hotkeys/jquery.hotkeys.js
deleted file mode 100644
index 72fa7f1c..00000000
--- a/packages/mindplot/src/components/libraries/hotkeys/jquery.hotkeys.js
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * jQuery Hotkeys Plugin
- * Copyright 2010, John Resig
- * Dual licensed under the MIT or GPL Version 2 licenses.
- *
- * Based upon the plugin by Tzury Bar Yochay:
- * http://github.com/tzuryby/hotkeys
- *
- * Original idea by:
- * Binny V A, http://www.openjs.com/scripts/events/keyboard_shortcuts/
-*/
-
-/*
- * One small change is: now keys are passed by object { keys: '...' }
- * Might be useful, when you want to pass some other data to your handler
- */
-
-(function (jQuery) {
-  jQuery.hotkeys = {
-    version: '0.8',
-
-    specialKeys: {
-      8: 'backspace',
-      9: 'tab',
-      10: 'return',
-      13: 'enter',
-      16: 'shift',
-      17: 'ctrl',
-      18: 'alt',
-      19: 'pause',
-      20: 'capslock',
-      27: 'esc',
-      32: 'space',
-      33: 'pageup',
-      34: 'pagedown',
-      35: 'end',
-      36: 'home',
-      37: 'left',
-      38: 'up',
-      39: 'right',
-      40: 'down',
-      45: 'insert',
-      46: 'del',
-      96: '0',
-      97: '1',
-      98: '2',
-      99: '3',
-      100: '4',
-      101: '5',
-      102: '6',
-      103: '7',
-      104: '8',
-      105: '9',
-      106: '*',
-      107: '+',
-      109: '-',
-      110: '.',
-      111: '/',
-      112: 'f1',
-      113: 'f2',
-      114: 'f3',
-      115: 'f4',
-      116: 'f5',
-      117: 'f6',
-      118: 'f7',
-      119: 'f8',
-      120: 'f9',
-      121: 'f10',
-      122: 'f11',
-      123: 'f12',
-      144: 'numlock',
-      145: 'scroll',
-      186: ';',
-      191: '/',
-      220: '\\',
-      222: "'",
-      224: 'meta',
-    },
-
-    shiftNums: {
-      '`': '~',
-      1: '!',
-      2: '@',
-      3: '#',
-      4: '$',
-      5: '%',
-      6: '^',
-      7: '&',
-      8: '*',
-      9: '(',
-      0: ')',
-      '-': '_',
-      '=': '+',
-      ';': ': ',
-      "'": '"',
-      ',': '<',
-      '.': '>',
-      '/': '?',
-      '\\': '|',
-    },
-  };
-
-  function keyHandler(handleObj) {
-    if (typeof handleObj.data === 'string') {
-      handleObj.data = { keys: handleObj.data };
-    }
-
-    // Only care when a possible input has been specified
-    if (!handleObj.data || !handleObj.data.keys || typeof handleObj.data.keys !== 'string') {
-      return;
-    }
-
-    const origHandler = handleObj.handler;
-    const keys = handleObj.data.keys.toLowerCase().split(' ');
-    const textAcceptingInputTypes = ['text', 'password', 'number', 'email', 'url', 'range', 'date', 'month', 'week', 'time', 'datetime', 'datetime-local', 'search', 'color', 'tel'];
-
-    handleObj.handler = function (event) {
-      // Don't fire in text-accepting inputs that we didn't directly bind to
-      if (this !== event.target && (/textarea|select/i.test(event.target.nodeName)
-				|| jQuery.inArray(event.target.type, textAcceptingInputTypes) > -1)) {
-        return;
-      }
-
-      const special = jQuery.hotkeys.specialKeys[event.keyCode];
-      const character = String.fromCharCode(event.which).toLowerCase();
-      let modif = ''; const
-        possible = {};
-
-      // check combinations (alt|ctrl|shift+anything)
-      if (event.altKey && special !== 'alt') {
-        modif += 'alt+';
-      }
-
-      if (event.ctrlKey && special !== 'ctrl') {
-        modif += 'ctrl+';
-      }
-
-      // TODO: Need to make sure this works consistently across platforms
-      if (event.metaKey && !event.ctrlKey && special !== 'meta') {
-        modif += 'meta+';
-      }
-
-      if (event.shiftKey && special !== 'shift') {
-        modif += 'shift+';
-      }
-
-      if (special) {
-        possible[modif + special] = true;
-      }
-
-      if (character) {
-        possible[modif + character] = true;
-        possible[modif + jQuery.hotkeys.shiftNums[character]] = true;
-
-        // "$" can be triggered as "Shift+4" or "Shift+$" or just "$"
-        if (modif === 'shift+') {
-          possible[jQuery.hotkeys.shiftNums[character]] = true;
-        }
-      }
-
-      for (let i = 0, l = keys.length; i < l; i++) {
-        if (possible[keys[i]]) {
-          return origHandler.apply(this, arguments);
-        }
-      }
-    };
-  }
-
-  jQuery.each(['keydown', 'keyup', 'keypress'], function () {
-    jQuery.event.special[this] = { add: keyHandler };
-  });
-}(this.jQuery));
diff --git a/packages/mindplot/src/components/libraries/jquery/jquery-2.1.0.js b/packages/mindplot/src/components/libraries/jquery/jquery-2.1.0.js
deleted file mode 100644
index 37257b61..00000000
--- a/packages/mindplot/src/components/libraries/jquery/jquery-2.1.0.js
+++ /dev/null
@@ -1,8861 +0,0 @@
-/*!
- * jQuery JavaScript Library v2.1.0
- * http://jquery.com/
- *
- * Includes Sizzle.js
- * http://sizzlejs.com/
- *
- * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
- * Released under the MIT license
- * http://jquery.org/license
- *
- * Date: 2014-01-23T21:10Z
- */
-
-(function (global, factory) {
-  if (typeof module === 'object' && typeof module.exports === 'object') {
-    // For CommonJS and CommonJS-like environments where a proper window is present,
-    // execute the factory and get jQuery
-    // For environments that do not inherently posses a window with a document
-    // (such as Node.js), expose a jQuery-making factory as module.exports
-    // This accentuates the need for the creation of a real window
-    // e.g. var jQuery = require("jquery")(window);
-    // See ticket #14549 for more info
-    module.exports = global.document
-      ? factory(global, true)
-      : function (w) {
-        if (!w.document) {
-          throw new Error('jQuery requires a window with a document');
-        }
-        return factory(w);
-      };
-  } else {
-    factory(global);
-  }
-
-// Pass this if window is not defined yet
-}(typeof window !== 'undefined' ? window : this, (window, noGlobal) => {
-// Can't do this because several apps including ASP.NET trace
-  // the stack via arguments.caller.callee and Firefox dies if
-  // you try to trace through "use strict" call chains. (#13335)
-  // Support: Firefox 18+
-  //
-
-  const arr = [];
-
-  const { slice } = arr;
-
-  const { concat } = arr;
-
-  const { push } = arr;
-
-  const { indexOf } = arr;
-
-  const class2type = {};
-
-  const { toString } = class2type;
-
-  const hasOwn = class2type.hasOwnProperty;
-
-  const { trim } = '';
-
-  const support = {};
-
-  const
-    // Use the correct document accordingly with window argument (sandbox)
-    { document } = window;
-
-  const version = '2.1.0';
-
-  // Define a local copy of jQuery
-  var jQuery = function (selector, context) {
-    // The jQuery object is actually just the init constructor 'enhanced'
-    // Need init if jQuery is called (just allow error to be thrown if not included)
-    return new jQuery.fn.init(selector, context);
-  };
-
-  // Matches dashed string for camelizing
-  const rmsPrefix = /^-ms-/;
-  const rdashAlpha = /-([\da-z])/gi;
-
-  // Used by jQuery.camelCase as callback to replace()
-  const fcamelCase = function (all, letter) {
-    return letter.toUpperCase();
-  };
-
-  jQuery.fn = jQuery.prototype = {
-    // The current version of jQuery being used
-    jquery: version,
-
-    constructor: jQuery,
-
-    // Start with an empty selector
-    selector: '',
-
-    // The default length of a jQuery object is 0
-    length: 0,
-
-    toArray() {
-      return slice.call(this);
-    },
-
-    // Get the Nth element in the matched element set OR
-    // Get the whole matched element set as a clean array
-    get(num) {
-      return num != null
-
-      // Return a 'clean' array
-        ? (num < 0 ? this[num + this.length] : this[num])
-
-      // Return just the object
-        : slice.call(this);
-    },
-
-    // Take an array of elements and push it onto the stack
-    // (returning the new matched element set)
-    pushStack(elems) {
-      // Build a new jQuery matched element set
-      const ret = jQuery.merge(this.constructor(), elems);
-
-      // Add the old object onto the stack (as a reference)
-      ret.prevObject = this;
-      ret.context = this.context;
-
-      // Return the newly-formed element set
-      return ret;
-    },
-
-    // Execute a callback for every element in the matched set.
-    // (You can seed the arguments with an array of args, but this is
-    // only used internally.)
-    each(callback, args) {
-      return jQuery.each(this, callback, args);
-    },
-
-    map(callback) {
-      return this.pushStack(jQuery.map(this, (elem, i) => callback.call(elem, i, elem)));
-    },
-
-    slice() {
-      return this.pushStack(slice.apply(this, arguments));
-    },
-
-    first() {
-      return this.eq(0);
-    },
-
-    last() {
-      return this.eq(-1);
-    },
-
-    eq(i) {
-      const len = this.length;
-      const j = +i + (i < 0 ? len : 0);
-      return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
-    },
-
-    end() {
-      return this.prevObject || this.constructor(null);
-    },
-
-    // For internal use only.
-    // Behaves like an Array's method, not like a jQuery method.
-    push,
-    sort: arr.sort,
-    splice: arr.splice,
-  };
-
-  jQuery.extend = jQuery.fn.extend = function () {
-    let options; let name; let src; let copy; let copyIsArray; let clone;
-    let target = arguments[0] || {};
-    let i = 1;
-    const { length } = arguments;
-    let deep = false;
-
-    // Handle a deep copy situation
-    if (typeof target === 'boolean') {
-      deep = target;
-
-      // skip the boolean and the target
-      target = arguments[i] || {};
-      i++;
-    }
-
-    // Handle case when target is a string or something (possible in deep copy)
-    if (typeof target !== 'object' && !jQuery.isFunction(target)) {
-      target = {};
-    }
-
-    // extend jQuery itself if only one argument is passed
-    if (i === length) {
-      target = this;
-      i--;
-    }
-
-    for (; i < length; i++) {
-      // Only deal with non-null/undefined values
-      if ((options = arguments[i]) != null) {
-        // Extend the base object
-        for (name in options) {
-          src = target[name];
-          copy = options[name];
-
-          // Prevent never-ending loop
-          if (target === copy) {
-            continue;
-          }
-
-          // Recurse if we're merging plain objects or arrays
-          if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
-            if (copyIsArray) {
-              copyIsArray = false;
-              clone = src && jQuery.isArray(src) ? src : [];
-            } else {
-              clone = src && jQuery.isPlainObject(src) ? src : {};
-            }
-
-            // Never move original objects, clone them
-            target[name] = jQuery.extend(deep, clone, copy);
-
-            // Don't bring in undefined values
-          } else if (copy !== undefined) {
-            target[name] = copy;
-          }
-        }
-      }
-    }
-
-    // Return the modified object
-    return target;
-  };
-
-  jQuery.extend({
-    // Unique for each copy of jQuery on the page
-    expando: `jQuery${(version + Math.random()).replace(/\D/g, '')}`,
-
-    // Assume jQuery is ready without the ready module
-    isReady: true,
-
-    error(msg) {
-      throw new Error(msg);
-    },
-
-    noop() {},
-
-    // See test/unit/core.js for details concerning isFunction.
-    // Since version 1.3, DOM methods and functions like alert
-    // aren't supported. They return false on IE (#2968).
-    isFunction(obj) {
-      return jQuery.type(obj) === 'function';
-    },
-
-    isArray: Array.isArray,
-
-    isWindow(obj) {
-      return obj != null && obj === obj.window;
-    },
-
-    isNumeric(obj) {
-      // parseFloat NaNs numeric-cast false positives (null|true|false|"")
-      // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
-      // subtraction forces infinities to NaN
-      return obj - parseFloat(obj) >= 0;
-    },
-
-    isPlainObject(obj) {
-      // Not plain objects:
-      // - Any object or value whose internal [[Class]] property is not "[object Object]"
-      // - DOM nodes
-      // - window
-      if (jQuery.type(obj) !== 'object' || obj.nodeType || jQuery.isWindow(obj)) {
-        return false;
-      }
-
-      // Support: Firefox <20
-      // The try/catch suppresses exceptions thrown when attempting to access
-      // the "constructor" property of certain host objects, ie. |window.location|
-      // https://bugzilla.mozilla.org/show_bug.cgi?id=814622
-      try {
-        if (obj.constructor
-					&& !hasOwn.call(obj.constructor.prototype, 'isPrototypeOf')) {
-          return false;
-        }
-      } catch (e) {
-        return false;
-      }
-
-      // If the function hasn't returned already, we're confident that
-      // |obj| is a plain object, created by {} or constructed with new Object
-      return true;
-    },
-
-    isEmptyObject(obj) {
-      let name;
-      for (name in obj) {
-        return false;
-      }
-      return true;
-    },
-
-    type(obj) {
-      if (obj == null) {
-        return `${obj}`;
-      }
-      // Support: Android < 4.0, iOS < 6 (functionish RegExp)
-      return typeof obj === 'object' || typeof obj === 'function'
-        ? class2type[toString.call(obj)] || 'object'
-        : typeof obj;
-    },
-
-    // Evaluates a script in a global context
-    globalEval(code) {
-      let script;
-      const indirect = eval;
-
-      code = jQuery.trim(code);
-
-      if (code) {
-        // If the code includes a valid, prologue position
-        // strict mode pragma, execute code by injecting a
-        // script tag into the document.
-        if (code.indexOf('use strict') === 1) {
-          script = document.createElement('script');
-          script.text = code;
-          document.head.appendChild(script).parentNode.removeChild(script);
-        } else {
-          // Otherwise, avoid the DOM node creation, insertion
-          // and removal by using an indirect global eval
-          indirect(code);
-        }
-      }
-    },
-
-    // Convert dashed to camelCase; used by the css and data modules
-    // Microsoft forgot to hump their vendor prefix (#9572)
-    camelCase(string) {
-      return string.replace(rmsPrefix, 'ms-').replace(rdashAlpha, fcamelCase);
-    },
-
-    nodeName(elem, name) {
-      return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
-    },
-
-    // args is for internal usage only
-    each(obj, callback, args) {
-      let value;
-      let i = 0;
-      const { length } = obj;
-      const isArray = isArraylike(obj);
-
-      if (args) {
-        if (isArray) {
-          for (; i < length; i++) {
-            value = callback.apply(obj[i], args);
-
-            if (value === false) {
-              break;
-            }
-          }
-        } else {
-          for (i in obj) {
-            value = callback.apply(obj[i], args);
-
-            if (value === false) {
-              break;
-            }
-          }
-        }
-
-        // A special, fast, case for the most common use of each
-      } else if (isArray) {
-        for (; i < length; i++) {
-          value = callback.call(obj[i], i, obj[i]);
-
-          if (value === false) {
-            break;
-          }
-        }
-      } else {
-        for (i in obj) {
-          value = callback.call(obj[i], i, obj[i]);
-
-          if (value === false) {
-            break;
-          }
-        }
-      }
-
-      return obj;
-    },
-
-    trim(text) {
-      return text == null ? '' : trim.call(text);
-    },
-
-    // results is for internal usage only
-    makeArray(arr, results) {
-      const ret = results || [];
-
-      if (arr != null) {
-        if (isArraylike(Object(arr))) {
-          jQuery.merge(ret,
-            typeof arr === 'string'
-              ? [arr] : arr);
-        } else {
-          push.call(ret, arr);
-        }
-      }
-
-      return ret;
-    },
-
-    inArray(elem, arr, i) {
-      return arr == null ? -1 : indexOf.call(arr, elem, i);
-    },
-
-    merge(first, second) {
-      const len = +second.length;
-      let j = 0;
-      let i = first.length;
-
-      for (; j < len; j++) {
-        first[i++] = second[j];
-      }
-
-      first.length = i;
-
-      return first;
-    },
-
-    grep(elems, callback, invert) {
-      let callbackInverse;
-      const matches = [];
-      let i = 0;
-      const { length } = elems;
-      const callbackExpect = !invert;
-
-      // Go through the array, only saving the items
-      // that pass the validator function
-      for (; i < length; i++) {
-        callbackInverse = !callback(elems[i], i);
-        if (callbackInverse !== callbackExpect) {
-          matches.push(elems[i]);
-        }
-      }
-
-      return matches;
-    },
-
-    // arg is for internal usage only
-    map(elems, callback, arg) {
-      let value;
-      let i = 0;
-      const { length } = elems;
-      const isArray = isArraylike(elems);
-      const ret = [];
-
-      // Go through the array, translating each of the items to their new values
-      if (isArray) {
-        for (; i < length; i++) {
-          value = callback(elems[i], i, arg);
-
-          if (value != null) {
-            ret.push(value);
-          }
-        }
-
-        // Go through every key on the object,
-      } else {
-        for (i in elems) {
-          value = callback(elems[i], i, arg);
-
-          if (value != null) {
-            ret.push(value);
-          }
-        }
-      }
-
-      // Flatten any nested arrays
-      return concat.apply([], ret);
-    },
-
-    // A global GUID counter for objects
-    guid: 1,
-
-    // Bind a function to a context, optionally partially applying any
-    // arguments.
-    proxy(fn, context) {
-      let tmp; let args; let
-        proxy;
-
-      if (typeof context === 'string') {
-        tmp = fn[context];
-        context = fn;
-        fn = tmp;
-      }
-
-      // Quick check to determine if target is callable, in the spec
-      // this throws a TypeError, but we will just return undefined.
-      if (!jQuery.isFunction(fn)) {
-        return undefined;
-      }
-
-      // Simulated bind
-      args = slice.call(arguments, 2);
-      proxy = function () {
-        return fn.apply(context || this, args.concat(slice.call(arguments)));
-      };
-
-      // Set the guid of unique handler to the same of original handler, so it can be removed
-      proxy.guid = fn.guid = fn.guid || jQuery.guid++;
-
-      return proxy;
-    },
-
-    now: Date.now,
-
-    // jQuery.support is not used in Core but other projects attach their
-    // properties to it so it needs to exist.
-    support,
-  });
-
-  // Populate the class2type map
-  jQuery.each('Boolean Number String Function Array Date RegExp Object Error'.split(' '), (i, name) => {
-    class2type[`[object ${name}]`] = name.toLowerCase();
-  });
-
-  function isArraylike(obj) {
-    const { length } = obj;
-    const type = jQuery.type(obj);
-
-    if (type === 'function' || jQuery.isWindow(obj)) {
-      return false;
-    }
-
-    if (obj.nodeType === 1 && length) {
-      return true;
-    }
-
-    return type === 'array' || length === 0
-		|| typeof length === 'number' && length > 0 && (length - 1) in obj;
-  }
-  const Sizzle =
-/*!
- * Sizzle CSS Selector Engine v1.10.16
- * http://sizzlejs.com/
- *
- * Copyright 2013 jQuery Foundation, Inc. and other contributors
- * Released under the MIT license
- * http://jquery.org/license
- *
- * Date: 2014-01-13
- */
-(function (window) {
-  let i;
-  let support;
-  let Expr;
-  let getText;
-  let isXML;
-  let compile;
-  let outermostContext;
-  let sortInput;
-  let hasDuplicate;
-
-  // Local document vars
-  let setDocument;
-  let document;
-  let docElem;
-  let documentIsHTML;
-  let rbuggyQSA;
-  let rbuggyMatches;
-  let matches;
-  let contains;
-
-  // Instance-specific data
-  const expando = `sizzle${-(new Date())}`;
-  const preferredDoc = window.document;
-  let dirruns = 0;
-  let done = 0;
-  const classCache = createCache();
-  const tokenCache = createCache();
-  const compilerCache = createCache();
-  let sortOrder = function (a, b) {
-    if (a === b) {
-      hasDuplicate = true;
-    }
-    return 0;
-  };
-
-  // General-purpose constants
-  const strundefined = typeof undefined;
-  const MAX_NEGATIVE = 1 << 31;
-
-  // Instance methods
-  const hasOwn = ({}).hasOwnProperty;
-  let arr = [];
-  const { pop } = arr;
-  const push_native = arr.push;
-  let { push } = arr;
-  const { slice } = arr;
-  // Use a stripped-down indexOf if we can't use a native one
-  const indexOf = arr.indexOf || function (elem) {
-    let i = 0;
-    const len = this.length;
-    for (; i < len; i++) {
-      if (this[i] === elem) {
-        return i;
-      }
-    }
-    return -1;
-  };
-
-  const booleans = 'checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped';
-
-  // Regular expressions
-
-  // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
-  const whitespace = '[\\x20\\t\\r\\n\\f]';
-  // http://www.w3.org/TR/css3-syntax/#characters
-  const characterEncoding = '(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+';
-
-  // Loosely modeled on CSS identifier characters
-  // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
-  // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
-  const identifier = characterEncoding.replace('w', 'w#');
-
-  // Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
-  const attributes = `\\[${whitespace}*(${characterEncoding})${whitespace
-		 }*(?:([*^$|!~]?=)${whitespace}*(?:(['"])((?:\\\\.|[^\\\\])*?)\\3|(${identifier})|)|)${whitespace}*\\]`;
-
-  // Prefer arguments quoted,
-  //   then not containing pseudos/brackets,
-  //   then attribute selectors/non-parenthetical expressions,
-  //   then anything else
-  // These preferences are here to reduce the number of selectors
-  //   needing tokenize in the PSEUDO preFilter
-  const pseudos = `:(${characterEncoding})(?:\\(((['"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|${attributes.replace(3, 8)})*)|.*)\\)|)`;
-
-  // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
-  const rtrim = new RegExp(`^${whitespace}+|((?:^|[^\\\\])(?:\\\\.)*)${whitespace}+$`, 'g');
-
-  const rcomma = new RegExp(`^${whitespace}*,${whitespace}*`);
-  const rcombinators = new RegExp(`^${whitespace}*([>+~]|${whitespace})${whitespace}*`);
-
-  const rattributeQuotes = new RegExp(`=${whitespace}*([^\\]'"]*?)${whitespace}*\\]`, 'g');
-
-  const rpseudo = new RegExp(pseudos);
-  const ridentifier = new RegExp(`^${identifier}$`);
-
-  const matchExpr = {
-    ID: new RegExp(`^#(${characterEncoding})`),
-    CLASS: new RegExp(`^\\.(${characterEncoding})`),
-    TAG: new RegExp(`^(${characterEncoding.replace('w', 'w*')})`),
-    ATTR: new RegExp(`^${attributes}`),
-    PSEUDO: new RegExp(`^${pseudos}`),
-    CHILD: new RegExp(`^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(${whitespace
-			 }*(even|odd|(([+-]|)(\\d*)n|)${whitespace}*(?:([+-]|)${whitespace
-			 }*(\\d+)|))${whitespace}*\\)|)`, 'i'),
-    bool: new RegExp(`^(?:${booleans})$`, 'i'),
-    // For use in libraries implementing .is()
-    // We use this for POS matching in `select`
-    needsContext: new RegExp(`^${whitespace}*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(${
-			 whitespace}*((?:-\\d)?\\d*)${whitespace}*\\)|)(?=[^-]|$)`, 'i'),
-  };
-
-  const rinputs = /^(?:input|select|textarea|button)$/i;
-  const rheader = /^h\d$/i;
-
-  const rnative = /^[^{]+\{\s*\[native \w/;
-
-  // Easily-parseable/retrievable ID or TAG or CLASS selectors
-  const rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/;
-
-  const rsibling = /[+~]/;
-  const rescape = /'|\\/g;
-
-  // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
-  const runescape = new RegExp(`\\\\([\\da-f]{1,6}${whitespace}?|(${whitespace})|.)`, 'ig');
-  const funescape = function (_, escaped, escapedWhitespace) {
-    const high = `0x${escaped}` - 0x10000;
-    // NaN means non-codepoint
-    // Support: Firefox
-    // Workaround erroneous numeric interpretation of +"0x"
-    return high !== high || escapedWhitespace
-      ? escaped
-      : high < 0
-      // BMP codepoint
-        ? String.fromCharCode(high + 0x10000)
-      // Supplemental Plane codepoint (surrogate pair)
-        : String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
-  };
-
-  // Optimize for push.apply( _, NodeList )
-  try {
-    push.apply(
-      (arr = slice.call(preferredDoc.childNodes)),
-      preferredDoc.childNodes,
-    );
-    // Support: Android<4.0
-    // Detect silently failing push.apply
-    arr[preferredDoc.childNodes.length].nodeType;
-  } catch (e) {
-    push = {
-      apply: arr.length
-
-      // Leverage slice if possible
-        ? function (target, els) {
-          push_native.apply(target, slice.call(els));
-        }
-
-      // Support: IE<9
-      // Otherwise append directly
-        : function (target, els) {
-          let j = target.length;
-          let i = 0;
-          // Can't trust NodeList.length
-          while ((target[j++] = els[i++])) {}
-          target.length = j - 1;
-        },
-    };
-  }
-
-  function Sizzle(selector, context, results, seed) {
-    let match; let elem; let m; let nodeType;
-    // QSA vars
-    let i; let groups; let old; let nid; let newContext; let
-      newSelector;
-
-    if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
-      setDocument(context);
-    }
-
-    context = context || document;
-    results = results || [];
-
-    if (!selector || typeof selector !== 'string') {
-      return results;
-    }
-
-    if ((nodeType = context.nodeType) !== 1 && nodeType !== 9) {
-      return [];
-    }
-
-    if (documentIsHTML && !seed) {
-      // Shortcuts
-      if ((match = rquickExpr.exec(selector))) {
-        // Speed-up: Sizzle("#ID")
-        if ((m = match[1])) {
-          if (nodeType === 9) {
-            elem = context.getElementById(m);
-            // Check parentNode to catch when Blackberry 4.6 returns
-            // nodes that are no longer in the document (jQuery #6963)
-            if (elem && elem.parentNode) {
-              // Handle the case where IE, Opera, and Webkit return items
-              // by name instead of ID
-              if (elem.id === m) {
-                results.push(elem);
-                return results;
-              }
-            } else {
-              return results;
-            }
-          } else {
-            // Context is not a document
-            if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m))
-						&& contains(context, elem) && elem.id === m) {
-              results.push(elem);
-              return results;
-            }
-          }
-
-          // Speed-up: Sizzle("TAG")
-        } else if (match[2]) {
-          push.apply(results, context.getElementsByTagName(selector));
-          return results;
-
-          // Speed-up: Sizzle(".CLASS")
-        } else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
-          push.apply(results, context.getElementsByClassName(m));
-          return results;
-        }
-      }
-
-      // QSA path
-      if (support.qsa && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
-        nid = old = expando;
-        newContext = context;
-        newSelector = nodeType === 9 && selector;
-
-        // qSA works strangely on Element-rooted queries
-        // We can work around this by specifying an extra ID on the root
-        // and working up from there (Thanks to Andrew Dupont for the technique)
-        // IE 8 doesn't work on object elements
-        if (nodeType === 1 && context.nodeName.toLowerCase() !== 'object') {
-          groups = tokenize(selector);
-
-          if ((old = context.getAttribute('id'))) {
-            nid = old.replace(rescape, '\\$&');
-          } else {
-            context.setAttribute('id', nid);
-          }
-          nid = `[id='${nid}'] `;
-
-          i = groups.length;
-          while (i--) {
-            groups[i] = nid + toSelector(groups[i]);
-          }
-          newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
-          newSelector = groups.join(',');
-        }
-
-        if (newSelector) {
-          try {
-            push.apply(results,
-              newContext.querySelectorAll(newSelector));
-            return results;
-          } catch (qsaError) {
-          } finally {
-            if (!old) {
-              context.removeAttribute('id');
-            }
-          }
-        }
-      }
-    }
-
-    // All others
-    return select(selector.replace(rtrim, '$1'), context, results, seed);
-  }
-
-  /**
- * Create key-value caches of limited size
- * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
- *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
- *	deleting the oldest entry
- */
-  function createCache() {
-    const keys = [];
-
-    function cache(key, value) {
-      // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
-      if (keys.push(`${key} `) > Expr.cacheLength) {
-        // Only keep the most recent entries
-        delete cache[keys.shift()];
-      }
-      return (cache[`${key} `] = value);
-    }
-    return cache;
-  }
-
-  /**
- * Mark a function for special use by Sizzle
- * @param {Function} fn The function to mark
- */
-  function markFunction(fn) {
-    fn[expando] = true;
-    return fn;
-  }
-
-  /**
- * Support testing using an element
- * @param {Function} fn Passed the created div and expects a boolean result
- */
-  function assert(fn) {
-    let div = document.createElement('div');
-
-    try {
-      return !!fn(div);
-    } catch (e) {
-      return false;
-    } finally {
-      // Remove from its parent by default
-      if (div.parentNode) {
-        div.parentNode.removeChild(div);
-      }
-      // release memory in IE
-      div = null;
-    }
-  }
-
-  /**
- * Adds the same handler for all of the specified attrs
- * @param {String} attrs Pipe-separated list of attributes
- * @param {Function} handler The method that will be applied
- */
-  function addHandle(attrs, handler) {
-    const arr = attrs.split('|');
-    let i = attrs.length;
-
-    while (i--) {
-      Expr.attrHandle[arr[i]] = handler;
-    }
-  }
-
-  /**
- * Checks document order of two siblings
- * @param {Element} a
- * @param {Element} b
- * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
- */
-  function siblingCheck(a, b) {
-    let cur = b && a;
-    const diff = cur && a.nodeType === 1 && b.nodeType === 1
-			&& (~b.sourceIndex || MAX_NEGATIVE)
-			- (~a.sourceIndex || MAX_NEGATIVE);
-
-    // Use IE sourceIndex if available on both nodes
-    if (diff) {
-      return diff;
-    }
-
-    // Check if b follows a
-    if (cur) {
-      while ((cur = cur.nextSibling)) {
-        if (cur === b) {
-          return -1;
-        }
-      }
-    }
-
-    return a ? 1 : -1;
-  }
-
-  /**
- * Returns a function to use in pseudos for input types
- * @param {String} type
- */
-  function createInputPseudo(type) {
-    return function (elem) {
-      const name = elem.nodeName.toLowerCase();
-      return name === 'input' && elem.type === type;
-    };
-  }
-
-  /**
- * Returns a function to use in pseudos for buttons
- * @param {String} type
- */
-  function createButtonPseudo(type) {
-    return function (elem) {
-      const name = elem.nodeName.toLowerCase();
-      return (name === 'input' || name === 'button') && elem.type === type;
-    };
-  }
-
-  /**
- * Returns a function to use in pseudos for positionals
- * @param {Function} fn
- */
-  function createPositionalPseudo(fn) {
-    return markFunction((argument) => {
-      argument = +argument;
-      return markFunction((seed, matches) => {
-        let j;
-        const matchIndexes = fn([], seed.length, argument);
-        let i = matchIndexes.length;
-
-        // Match elements found at the specified indexes
-        while (i--) {
-          if (seed[(j = matchIndexes[i])]) {
-            seed[j] = !(matches[j] = seed[j]);
-          }
-        }
-      });
-    });
-  }
-
-  /**
- * Checks a node for validity as a Sizzle context
- * @param {Element|Object=} context
- * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
- */
-  function testContext(context) {
-    return context && typeof context.getElementsByTagName !== strundefined && context;
-  }
-
-  // Expose support vars for convenience
-  support = Sizzle.support = {};
-
-  /**
- * Detects XML nodes
- * @param {Element|Object} elem An element or a document
- * @returns {Boolean} True iff elem is a non-HTML XML node
- */
-  isXML = Sizzle.isXML = function (elem) {
-    // documentElement is verified for cases where it doesn't yet exist
-    // (such as loading iframes in IE - #4833)
-    const documentElement = elem && (elem.ownerDocument || elem).documentElement;
-    return documentElement ? documentElement.nodeName !== 'HTML' : false;
-  };
-
-  /**
- * Sets document-related variables once based on the current document
- * @param {Element|Object} [doc] An element or document object to use to set the document
- * @returns {Object} Returns the current document
- */
-  setDocument = Sizzle.setDocument = function (node) {
-    let hasCompare;
-    const doc = node ? node.ownerDocument || node : preferredDoc;
-    const parent = doc.defaultView;
-
-    // If no document and documentElement is available, return
-    if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
-      return document;
-    }
-
-    // Set our document
-    document = doc;
-    docElem = doc.documentElement;
-
-    // Support tests
-    documentIsHTML = !isXML(doc);
-
-    // Support: IE>8
-    // If iframe document is assigned to "document" variable and if iframe has been reloaded,
-    // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
-    // IE6-8 do not support the defaultView property so parent will be undefined
-    if (parent && parent !== parent.top) {
-      // IE11 does not have attachEvent, so all must suffer
-      if (parent.addEventListener) {
-        parent.addEventListener('unload', () => {
-          setDocument();
-        }, false);
-      } else if (parent.attachEvent) {
-        parent.attachEvent('onunload', () => {
-          setDocument();
-        });
-      }
-    }
-
-    /* Attributes
-	---------------------------------------------------------------------- */
-
-    // Support: IE<8
-    // Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
-    support.attributes = assert((div) => {
-      div.className = 'i';
-      return !div.getAttribute('className');
-    });
-
-    /* getElement(s)By*
-	---------------------------------------------------------------------- */
-
-    // Check if getElementsByTagName("*") returns only elements
-    support.getElementsByTagName = assert((div) => {
-      div.appendChild(doc.createComment(''));
-      return !div.getElementsByTagName('*').length;
-    });
-
-    // Check if getElementsByClassName can be trusted
-    support.getElementsByClassName = rnative.test(doc.getElementsByClassName) && assert((div) => {
-      div.innerHTML = "<div class='a'></div><div class='a i'></div>";
-
-      // Support: Safari<4
-      // Catch class over-caching
-      div.firstChild.className = 'i';
-      // Support: Opera<10
-      // Catch gEBCN failure to find non-leading classes
-      return div.getElementsByClassName('i').length === 2;
-    });
-
-    // Support: IE<10
-    // Check if getElementById returns elements by name
-    // The broken getElementById methods don't pick up programatically-set names,
-    // so use a roundabout getElementsByName test
-    support.getById = assert((div) => {
-      docElem.appendChild(div).id = expando;
-      return !doc.getElementsByName || !doc.getElementsByName(expando).length;
-    });
-
-    // ID find and filter
-    if (support.getById) {
-      Expr.find.ID = function (id, context) {
-        if (typeof context.getElementById !== strundefined && documentIsHTML) {
-          const m = context.getElementById(id);
-          // Check parentNode to catch when Blackberry 4.6 returns
-          // nodes that are no longer in the document #6963
-          return m && m.parentNode ? [m] : [];
-        }
-      };
-      Expr.filter.ID = function (id) {
-        const attrId = id.replace(runescape, funescape);
-        return function (elem) {
-          return elem.getAttribute('id') === attrId;
-        };
-      };
-    } else {
-      // Support: IE6/7
-      // getElementById is not reliable as a find shortcut
-      delete Expr.find.ID;
-
-      Expr.filter.ID = function (id) {
-        const attrId = id.replace(runescape, funescape);
-        return function (elem) {
-          const node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode('id');
-          return node && node.value === attrId;
-        };
-      };
-    }
-
-    // Tag
-    Expr.find.TAG = support.getElementsByTagName
-      ? function (tag, context) {
-        if (typeof context.getElementsByTagName !== strundefined) {
-          return context.getElementsByTagName(tag);
-        }
-      }
-      : function (tag, context) {
-        let elem;
-        const tmp = [];
-        let i = 0;
-        const results = context.getElementsByTagName(tag);
-
-        // Filter out possible comments
-        if (tag === '*') {
-          while ((elem = results[i++])) {
-            if (elem.nodeType === 1) {
-              tmp.push(elem);
-            }
-          }
-
-          return tmp;
-        }
-        return results;
-      };
-
-    // Class
-    Expr.find.CLASS = support.getElementsByClassName && function (className, context) {
-      if (typeof context.getElementsByClassName !== strundefined && documentIsHTML) {
-        return context.getElementsByClassName(className);
-      }
-    };
-
-    /* QSA/matchesSelector
-	---------------------------------------------------------------------- */
-
-    // QSA and matchesSelector support
-
-    // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
-    rbuggyMatches = [];
-
-    // qSa(:focus) reports false when true (Chrome 21)
-    // We allow this because of a bug in IE8/9 that throws an error
-    // whenever `document.activeElement` is accessed on an iframe
-    // So, we allow :focus to pass through QSA all the time to avoid the IE error
-    // See http://bugs.jquery.com/ticket/13378
-    rbuggyQSA = [];
-
-    if ((support.qsa = rnative.test(doc.querySelectorAll))) {
-      // Build QSA regex
-      // Regex strategy adopted from Diego Perini
-      assert((div) => {
-        // Select is set to empty string on purpose
-        // This is to test IE's treatment of not explicitly
-        // setting a boolean content attribute,
-        // since its presence should be enough
-        // http://bugs.jquery.com/ticket/12359
-        div.innerHTML = "<select t=''><option selected=''></option></select>";
-
-        // Support: IE8, Opera 10-12
-        // Nothing should be selected when empty strings follow ^= or $= or *=
-        if (div.querySelectorAll("[t^='']").length) {
-          rbuggyQSA.push(`[*^$]=${whitespace}*(?:''|"")`);
-        }
-
-        // Support: IE8
-        // Boolean attributes and "value" are not treated correctly
-        if (!div.querySelectorAll('[selected]').length) {
-          rbuggyQSA.push(`\\[${whitespace}*(?:value|${booleans})`);
-        }
-
-        // Webkit/Opera - :checked should return selected option elements
-        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
-        // IE8 throws error here and will not see later tests
-        if (!div.querySelectorAll(':checked').length) {
-          rbuggyQSA.push(':checked');
-        }
-      });
-
-      assert((div) => {
-        // Support: Windows 8 Native Apps
-        // The type and name attributes are restricted during .innerHTML assignment
-        const input = doc.createElement('input');
-        input.setAttribute('type', 'hidden');
-        div.appendChild(input).setAttribute('name', 'D');
-
-        // Support: IE8
-        // Enforce case-sensitivity of name attribute
-        if (div.querySelectorAll('[name=d]').length) {
-          rbuggyQSA.push(`name${whitespace}*[*^$|!~]?=`);
-        }
-
-        // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
-        // IE8 throws error here and will not see later tests
-        if (!div.querySelectorAll(':enabled').length) {
-          rbuggyQSA.push(':enabled', ':disabled');
-        }
-
-        // Opera 10-11 does not throw on post-comma invalid pseudos
-        div.querySelectorAll('*,:x');
-        rbuggyQSA.push(',.*:');
-      });
-    }
-
-    if ((support.matchesSelector = rnative.test((matches = docElem.webkitMatchesSelector
-		|| docElem.mozMatchesSelector
-		|| docElem.oMatchesSelector
-		|| docElem.msMatchesSelector)))) {
-      assert((div) => {
-        // Check to see if it's possible to do matchesSelector
-        // on a disconnected node (IE 9)
-        support.disconnectedMatch = matches.call(div, 'div');
-
-        // This should fail with an exception
-        // Gecko does not error, returns false instead
-        matches.call(div, "[s!='']:x");
-        rbuggyMatches.push('!=', pseudos);
-      });
-    }
-
-    rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join('|'));
-    rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join('|'));
-
-    /* Contains
-	---------------------------------------------------------------------- */
-    hasCompare = rnative.test(docElem.compareDocumentPosition);
-
-    // Element contains another
-    // Purposefully does not implement inclusive descendent
-    // As in, an element does not contain itself
-    contains = hasCompare || rnative.test(docElem.contains)
-      ? function (a, b) {
-        const adown = a.nodeType === 9 ? a.documentElement : a;
-        const bup = b && b.parentNode;
-        return a === bup || !!(bup && bup.nodeType === 1 && (
-          adown.contains
-            ? adown.contains(bup)
-            : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
-        ));
-      }
-      : function (a, b) {
-        if (b) {
-          while ((b = b.parentNode)) {
-            if (b === a) {
-              return true;
-            }
-          }
-        }
-        return false;
-      };
-
-    /* Sorting
-	---------------------------------------------------------------------- */
-
-    // Document order sorting
-    sortOrder = hasCompare
-      ? function (a, b) {
-        // Flag for duplicate removal
-        if (a === b) {
-          hasDuplicate = true;
-          return 0;
-        }
-
-        // Sort on method existence if only one input has compareDocumentPosition
-        let compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
-        if (compare) {
-          return compare;
-        }
-
-        // Calculate position if both inputs belong to the same document
-        compare = (a.ownerDocument || a) === (b.ownerDocument || b)
-          ? a.compareDocumentPosition(b)
-
-        // Otherwise we know they are disconnected
-          : 1;
-
-        // Disconnected nodes
-        if (compare & 1
-			|| (!support.sortDetached && b.compareDocumentPosition(a) === compare)) {
-          // Choose the first element that is related to our preferred document
-          if (a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
-            return -1;
-          }
-          if (b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
-            return 1;
-          }
-
-          // Maintain original order
-          return sortInput
-            ? (indexOf.call(sortInput, a) - indexOf.call(sortInput, b))
-            : 0;
-        }
-
-        return compare & 4 ? -1 : 1;
-      }
-      : function (a, b) {
-        // Exit early if the nodes are identical
-        if (a === b) {
-          hasDuplicate = true;
-          return 0;
-        }
-
-        let cur;
-        let i = 0;
-        const aup = a.parentNode;
-        const bup = b.parentNode;
-        const ap = [a];
-        const bp = [b];
-
-        // Parentless nodes are either documents or disconnected
-        if (!aup || !bup) {
-          return a === doc ? -1
-            : b === doc ? 1
-              : aup ? -1
-                : bup ? 1
-                  : sortInput
-                    ? (indexOf.call(sortInput, a) - indexOf.call(sortInput, b))
-                    : 0;
-
-          // If the nodes are siblings, we can do a quick check
-        } if (aup === bup) {
-          return siblingCheck(a, b);
-        }
-
-        // Otherwise we need full lists of their ancestors for comparison
-        cur = a;
-        while ((cur = cur.parentNode)) {
-          ap.unshift(cur);
-        }
-        cur = b;
-        while ((cur = cur.parentNode)) {
-          bp.unshift(cur);
-        }
-
-        // Walk down the tree looking for a discrepancy
-        while (ap[i] === bp[i]) {
-          i++;
-        }
-
-        return i
-        // Do a sibling check if the nodes have a common ancestor
-          ? siblingCheck(ap[i], bp[i])
-
-        // Otherwise nodes in our document sort first
-          : ap[i] === preferredDoc ? -1
-            : bp[i] === preferredDoc ? 1
-              : 0;
-      };
-
-    return doc;
-  };
-
-  Sizzle.matches = function (expr, elements) {
-    return Sizzle(expr, null, null, elements);
-  };
-
-  Sizzle.matchesSelector = function (elem, expr) {
-    // Set document vars if needed
-    if ((elem.ownerDocument || elem) !== document) {
-      setDocument(elem);
-    }
-
-    // Make sure that attribute selectors are quoted
-    expr = expr.replace(rattributeQuotes, "='$1']");
-
-    if (support.matchesSelector && documentIsHTML
-		&& (!rbuggyMatches || !rbuggyMatches.test(expr))
-		&& (!rbuggyQSA || !rbuggyQSA.test(expr))) {
-      try {
-        const ret = matches.call(elem, expr);
-
-        // IE 9's matchesSelector returns false on disconnected nodes
-        if (ret || support.disconnectedMatch
-					// As well, disconnected nodes are said to be in a document
-					// fragment in IE 9
-					|| elem.document && elem.document.nodeType !== 11) {
-          return ret;
-        }
-      } catch (e) {}
-    }
-
-    return Sizzle(expr, document, null, [elem]).length > 0;
-  };
-
-  Sizzle.contains = function (context, elem) {
-    // Set document vars if needed
-    if ((context.ownerDocument || context) !== document) {
-      setDocument(context);
-    }
-    return contains(context, elem);
-  };
-
-  Sizzle.attr = function (elem, name) {
-    // Set document vars if needed
-    if ((elem.ownerDocument || elem) !== document) {
-      setDocument(elem);
-    }
-
-    const fn = Expr.attrHandle[name.toLowerCase()];
-    // Don't get fooled by Object.prototype properties (jQuery #13807)
-    let val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase())
-      ? fn(elem, name, !documentIsHTML)
-      : undefined;
-
-    return val !== undefined
-      ? val
-      : support.attributes || !documentIsHTML
-        ? elem.getAttribute(name)
-        : (val = elem.getAttributeNode(name)) && val.specified
-          ? val.value
-          : null;
-  };
-
-  Sizzle.error = function (msg) {
-    throw new Error(`Syntax error, unrecognized expression: ${msg}`);
-  };
-
-  /**
- * Document sorting and removing duplicates
- * @param {ArrayLike} results
- */
-  Sizzle.uniqueSort = function (results) {
-    let elem;
-    const duplicates = [];
-    let j = 0;
-    let i = 0;
-
-    // Unless we *know* we can detect duplicates, assume their presence
-    hasDuplicate = !support.detectDuplicates;
-    sortInput = !support.sortStable && results.slice(0);
-    results.sort(sortOrder);
-
-    if (hasDuplicate) {
-      while ((elem = results[i++])) {
-        if (elem === results[i]) {
-          j = duplicates.push(i);
-        }
-      }
-      while (j--) {
-        results.splice(duplicates[j], 1);
-      }
-    }
-
-    // Clear input after sorting to release objects
-    // See https://github.com/jquery/sizzle/pull/225
-    sortInput = null;
-
-    return results;
-  };
-
-  /**
- * Utility function for retrieving the text value of an array of DOM nodes
- * @param {Array|Element} elem
- */
-  getText = Sizzle.getText = function (elem) {
-    let node;
-    let ret = '';
-    let i = 0;
-    const { nodeType } = elem;
-
-    if (!nodeType) {
-      // If no nodeType, this is expected to be an array
-      while ((node = elem[i++])) {
-        // Do not traverse comment nodes
-        ret += getText(node);
-      }
-    } else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
-      // Use textContent for elements
-      // innerText usage removed for consistency of new lines (jQuery #11153)
-      if (typeof elem.textContent === 'string') {
-        return elem.textContent;
-      }
-      // Traverse its children
-      for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
-        ret += getText(elem);
-      }
-    } else if (nodeType === 3 || nodeType === 4) {
-      return elem.nodeValue;
-    }
-    // Do not include comment or processing instruction nodes
-
-    return ret;
-  };
-
-  Expr = Sizzle.selectors = {
-
-    // Can be adjusted by the user
-    cacheLength: 50,
-
-    createPseudo: markFunction,
-
-    match: matchExpr,
-
-    attrHandle: {},
-
-    find: {},
-
-    relative: {
-      '>': { dir: 'parentNode', first: true },
-      ' ': { dir: 'parentNode' },
-      '+': { dir: 'previousSibling', first: true },
-      '~': { dir: 'previousSibling' },
-    },
-
-    preFilter: {
-      ATTR(match) {
-        match[1] = match[1].replace(runescape, funescape);
-
-        // Move the given value to match[3] whether quoted or unquoted
-        match[3] = (match[4] || match[5] || '').replace(runescape, funescape);
-
-        if (match[2] === '~=') {
-          match[3] = ` ${match[3]} `;
-        }
-
-        return match.slice(0, 4);
-      },
-
-      CHILD(match) {
-        /* matches from matchExpr["CHILD"]
-				1 type (only|nth|...)
-				2 what (child|of-type)
-				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
-				4 xn-component of xn+y argument ([+-]?\d*n|)
-				5 sign of xn-component
-				6 x of xn-component
-				7 sign of y-component
-				8 y of y-component
-			*/
-        match[1] = match[1].toLowerCase();
-
-        if (match[1].slice(0, 3) === 'nth') {
-          // nth-* requires argument
-          if (!match[3]) {
-            Sizzle.error(match[0]);
-          }
-
-          // numeric x and y parameters for Expr.filter.CHILD
-          // remember that false/true cast respectively to 0/1
-          match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === 'even' || match[3] === 'odd'));
-          match[5] = +((match[7] + match[8]) || match[3] === 'odd');
-
-          // other types prohibit arguments
-        } else if (match[3]) {
-          Sizzle.error(match[0]);
-        }
-
-        return match;
-      },
-
-      PSEUDO(match) {
-        let excess;
-        const unquoted = !match[5] && match[2];
-
-        if (matchExpr.CHILD.test(match[0])) {
-          return null;
-        }
-
-        // Accept quoted arguments as-is
-        if (match[3] && match[4] !== undefined) {
-          match[2] = match[4];
-
-          // Strip excess characters from unquoted arguments
-        } else if (unquoted && rpseudo.test(unquoted)
-				// Get excess from tokenize (recursively)
-				&& (excess = tokenize(unquoted, true))
-				// advance to the next closing parenthesis
-				&& (excess = unquoted.indexOf(')', unquoted.length - excess) - unquoted.length)) {
-          // excess is a negative index
-          match[0] = match[0].slice(0, excess);
-          match[2] = unquoted.slice(0, excess);
-        }
-
-        // Return only captures needed by the pseudo filter method (type and argument)
-        return match.slice(0, 3);
-      },
-    },
-
-    filter: {
-
-      TAG(nodeNameSelector) {
-        const nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
-        return nodeNameSelector === '*'
-          ? function () { return true; }
-          : function (elem) {
-            return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
-          };
-      },
-
-      CLASS(className) {
-        let pattern = classCache[`${className} `];
-
-        return pattern
-				|| (pattern = new RegExp(`(^|${whitespace})${className}(${whitespace}|$)`))
-				&& classCache(className, (elem) => pattern.test(typeof elem.className === 'string' && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute('class') || ''));
-      },
-
-      ATTR(name, operator, check) {
-        return function (elem) {
-          let result = Sizzle.attr(elem, name);
-
-          if (result == null) {
-            return operator === '!=';
-          }
-          if (!operator) {
-            return true;
-          }
-
-          result += '';
-
-          return operator === '=' ? result === check
-            : operator === '!=' ? result !== check
-              : operator === '^=' ? check && result.indexOf(check) === 0
-                : operator === '*=' ? check && result.indexOf(check) > -1
-                  : operator === '$=' ? check && result.slice(-check.length) === check
-                    : operator === '~=' ? (` ${result} `).indexOf(check) > -1
-                      : operator === '|=' ? result === check || result.slice(0, check.length + 1) === `${check}-`
-                        : false;
-        };
-      },
-
-      CHILD(type, what, argument, first, last) {
-        const simple = type.slice(0, 3) !== 'nth';
-        const forward = type.slice(-4) !== 'last';
-        const ofType = what === 'of-type';
-
-        return first === 1 && last === 0
-
-        // Shortcut for :nth-*(n)
-          ? function (elem) {
-            return !!elem.parentNode;
-          }
-
-          : function (elem, context, xml) {
-            let cache; let outerCache; let node; let diff; let nodeIndex; let start;
-            let dir = simple !== forward ? 'nextSibling' : 'previousSibling';
-            const parent = elem.parentNode;
-            const name = ofType && elem.nodeName.toLowerCase();
-            const useCache = !xml && !ofType;
-
-            if (parent) {
-              // :(first|last|only)-(child|of-type)
-              if (simple) {
-                while (dir) {
-                  node = elem;
-                  while ((node = node[dir])) {
-                    if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
-                      return false;
-                    }
-                  }
-                  // Reverse direction for :only-* (if we haven't yet done so)
-                  start = dir = type === 'only' && !start && 'nextSibling';
-                }
-                return true;
-              }
-
-              start = [forward ? parent.firstChild : parent.lastChild];
-
-              // non-xml :nth-child(...) stores cache data on `parent`
-              if (forward && useCache) {
-                // Seek `elem` from a previously-cached index
-                outerCache = parent[expando] || (parent[expando] = {});
-                cache = outerCache[type] || [];
-                nodeIndex = cache[0] === dirruns && cache[1];
-                diff = cache[0] === dirruns && cache[2];
-                node = nodeIndex && parent.childNodes[nodeIndex];
-
-                while ((node = ++nodeIndex && node && node[dir]
-
-								// Fallback to seeking `elem` from the start
-								|| (diff = nodeIndex = 0) || start.pop())) {
-                  // When found, cache indexes on `parent` and break
-                  if (node.nodeType === 1 && ++diff && node === elem) {
-                    outerCache[type] = [dirruns, nodeIndex, diff];
-                    break;
-                  }
-                }
-
-                // Use previously-cached element index if available
-              } else if (useCache && (cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns) {
-                diff = cache[1];
-
-                // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
-              } else {
-                // Use the same loop as above to seek `elem` from the start
-                while ((node = ++nodeIndex && node && node[dir]
-								|| (diff = nodeIndex = 0) || start.pop())) {
-                  if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
-                    // Cache the index of each encountered element
-                    if (useCache) {
-                      (node[expando] || (node[expando] = {}))[type] = [dirruns, diff];
-                    }
-
-                    if (node === elem) {
-                      break;
-                    }
-                  }
-                }
-              }
-
-              // Incorporate the offset, then check against cycle size
-              diff -= last;
-              return diff === first || (diff % first === 0 && diff / first >= 0);
-            }
-          };
-      },
-
-      PSEUDO(pseudo, argument) {
-        // pseudo-class names are case-insensitive
-        // http://www.w3.org/TR/selectors/#pseudo-classes
-        // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
-        // Remember that setFilters inherits from pseudos
-        let args;
-        const fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()]
-					|| Sizzle.error(`unsupported pseudo: ${pseudo}`);
-
-        // The user may use createPseudo to indicate that
-        // arguments are needed to create the filter function
-        // just as Sizzle does
-        if (fn[expando]) {
-          return fn(argument);
-        }
-
-        // But maintain support for old signatures
-        if (fn.length > 1) {
-          args = [pseudo, pseudo, '', argument];
-          return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase())
-            ? markFunction((seed, matches) => {
-              let idx;
-              const matched = fn(seed, argument);
-              let i = matched.length;
-              while (i--) {
-                idx = indexOf.call(seed, matched[i]);
-                seed[idx] = !(matches[idx] = matched[i]);
-              }
-            })
-            : function (elem) {
-              return fn(elem, 0, args);
-            };
-        }
-
-        return fn;
-      },
-    },
-
-    pseudos: {
-      // Potentially complex pseudos
-      not: markFunction((selector) => {
-        // Trim the selector passed to compile
-        // to avoid treating leading and trailing
-        // spaces as combinators
-        const input = [];
-        const results = [];
-        const matcher = compile(selector.replace(rtrim, '$1'));
-
-        return matcher[expando]
-          ? markFunction((seed, matches, context, xml) => {
-            let elem;
-            const unmatched = matcher(seed, null, xml, []);
-            let i = seed.length;
-
-            // Match elements unmatched by `matcher`
-            while (i--) {
-              if ((elem = unmatched[i])) {
-                seed[i] = !(matches[i] = elem);
-              }
-            }
-          })
-          : function (elem, context, xml) {
-            input[0] = elem;
-            matcher(input, null, xml, results);
-            return !results.pop();
-          };
-      }),
-
-      has: markFunction((selector) => function (elem) {
-        return Sizzle(selector, elem).length > 0;
-      }),
-
-      contains: markFunction((text) => function (elem) {
-        return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
-      }),
-
-      // "Whether an element is represented by a :lang() selector
-      // is based solely on the element's language value
-      // being equal to the identifier C,
-      // or beginning with the identifier C immediately followed by "-".
-      // The matching of C against the element's language value is performed case-insensitively.
-      // The identifier C does not have to be a valid language name."
-      // http://www.w3.org/TR/selectors/#lang-pseudo
-      lang: markFunction((lang) => {
-        // lang value must be a valid identifier
-        if (!ridentifier.test(lang || '')) {
-          Sizzle.error(`unsupported lang: ${lang}`);
-        }
-        lang = lang.replace(runescape, funescape).toLowerCase();
-        return function (elem) {
-          let elemLang;
-          do {
-            if ((elemLang = documentIsHTML
-              ? elem.lang
-              : elem.getAttribute('xml:lang') || elem.getAttribute('lang'))) {
-              elemLang = elemLang.toLowerCase();
-              return elemLang === lang || elemLang.indexOf(`${lang}-`) === 0;
-            }
-          } while ((elem = elem.parentNode) && elem.nodeType === 1);
-          return false;
-        };
-      }),
-
-      // Miscellaneous
-      target(elem) {
-        const hash = window.location && window.location.hash;
-        return hash && hash.slice(1) === elem.id;
-      },
-
-      root(elem) {
-        return elem === docElem;
-      },
-
-      focus(elem) {
-        return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
-      },
-
-      // Boolean properties
-      enabled(elem) {
-        return elem.disabled === false;
-      },
-
-      disabled(elem) {
-        return elem.disabled === true;
-      },
-
-      checked(elem) {
-        // In CSS3, :checked should return both checked and selected elements
-        // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
-        const nodeName = elem.nodeName.toLowerCase();
-        return (nodeName === 'input' && !!elem.checked) || (nodeName === 'option' && !!elem.selected);
-      },
-
-      selected(elem) {
-        // Accessing this property makes selected-by-default
-        // options in Safari work properly
-        if (elem.parentNode) {
-          elem.parentNode.selectedIndex;
-        }
-
-        return elem.selected === true;
-      },
-
-      // Contents
-      empty(elem) {
-        // http://www.w3.org/TR/selectors/#empty-pseudo
-        // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
-        //   but not by others (comment: 8; processing instruction: 7; etc.)
-        // nodeType < 6 works because attributes (2) do not appear as children
-        for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
-          if (elem.nodeType < 6) {
-            return false;
-          }
-        }
-        return true;
-      },
-
-      parent(elem) {
-        return !Expr.pseudos.empty(elem);
-      },
-
-      // Element/input types
-      header(elem) {
-        return rheader.test(elem.nodeName);
-      },
-
-      input(elem) {
-        return rinputs.test(elem.nodeName);
-      },
-
-      button(elem) {
-        const name = elem.nodeName.toLowerCase();
-        return name === 'input' && elem.type === 'button' || name === 'button';
-      },
-
-      text(elem) {
-        let attr;
-        return elem.nodeName.toLowerCase() === 'input'
-				&& elem.type === 'text'
-
-				// Support: IE<8
-				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
-				&& ((attr = elem.getAttribute('type')) == null || attr.toLowerCase() === 'text');
-      },
-
-      // Position-in-collection
-      first: createPositionalPseudo(() => [0]),
-
-      last: createPositionalPseudo((matchIndexes, length) => [length - 1]),
-
-      eq: createPositionalPseudo((matchIndexes, length, argument) => [argument < 0 ? argument + length : argument]),
-
-      even: createPositionalPseudo((matchIndexes, length) => {
-        let i = 0;
-        for (; i < length; i += 2) {
-          matchIndexes.push(i);
-        }
-        return matchIndexes;
-      }),
-
-      odd: createPositionalPseudo((matchIndexes, length) => {
-        let i = 1;
-        for (; i < length; i += 2) {
-          matchIndexes.push(i);
-        }
-        return matchIndexes;
-      }),
-
-      lt: createPositionalPseudo((matchIndexes, length, argument) => {
-        let i = argument < 0 ? argument + length : argument;
-        for (; --i >= 0;) {
-          matchIndexes.push(i);
-        }
-        return matchIndexes;
-      }),
-
-      gt: createPositionalPseudo((matchIndexes, length, argument) => {
-        let i = argument < 0 ? argument + length : argument;
-        for (; ++i < length;) {
-          matchIndexes.push(i);
-        }
-        return matchIndexes;
-      }),
-    },
-  };
-
-  Expr.pseudos.nth = Expr.pseudos.eq;
-
-  // Add button/input type pseudos
-  for (i in {
-    radio: true, checkbox: true, file: true, password: true, image: true,
-  }) {
-    Expr.pseudos[i] = createInputPseudo(i);
-  }
-  for (i in { submit: true, reset: true }) {
-    Expr.pseudos[i] = createButtonPseudo(i);
-  }
-
-  // Easy API for creating new setFilters
-  function setFilters() {}
-  setFilters.prototype = Expr.filters = Expr.pseudos;
-  Expr.setFilters = new setFilters();
-
-  function tokenize(selector, parseOnly) {
-    let matched; let match; let tokens; let type;
-    let soFar; let groups; let preFilters;
-    const cached = tokenCache[`${selector} `];
-
-    if (cached) {
-      return parseOnly ? 0 : cached.slice(0);
-    }
-
-    soFar = selector;
-    groups = [];
-    preFilters = Expr.preFilter;
-
-    while (soFar) {
-      // Comma and first run
-      if (!matched || (match = rcomma.exec(soFar))) {
-        if (match) {
-          // Don't consume trailing commas as valid
-          soFar = soFar.slice(match[0].length) || soFar;
-        }
-        groups.push((tokens = []));
-      }
-
-      matched = false;
-
-      // Combinators
-      if ((match = rcombinators.exec(soFar))) {
-        matched = match.shift();
-        tokens.push({
-          value: matched,
-          // Cast descendant combinators to space
-          type: match[0].replace(rtrim, ' '),
-        });
-        soFar = soFar.slice(matched.length);
-      }
-
-      // Filters
-      for (type in Expr.filter) {
-        if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type]
-				|| (match = preFilters[type](match)))) {
-          matched = match.shift();
-          tokens.push({
-            value: matched,
-            type,
-            matches: match,
-          });
-          soFar = soFar.slice(matched.length);
-        }
-      }
-
-      if (!matched) {
-        break;
-      }
-    }
-
-    // Return the length of the invalid excess
-    // if we're just parsing
-    // Otherwise, throw an error or return tokens
-    return parseOnly
-      ? soFar.length
-      : soFar
-        ? Sizzle.error(selector)
-      // Cache the tokens
-        : tokenCache(selector, groups).slice(0);
-  }
-
-  function toSelector(tokens) {
-    let i = 0;
-    const len = tokens.length;
-    let selector = '';
-    for (; i < len; i++) {
-      selector += tokens[i].value;
-    }
-    return selector;
-  }
-
-  function addCombinator(matcher, combinator, base) {
-    const { dir } = combinator;
-    const checkNonElements = base && dir === 'parentNode';
-    const doneName = done++;
-
-    return combinator.first
-    // Check against closest ancestor/preceding element
-      ? function (elem, context, xml) {
-        while ((elem = elem[dir])) {
-          if (elem.nodeType === 1 || checkNonElements) {
-            return matcher(elem, context, xml);
-          }
-        }
-      }
-
-    // Check against all ancestor/preceding elements
-      : function (elem, context, xml) {
-        let oldCache; let outerCache;
-        const newCache = [dirruns, doneName];
-
-        // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
-        if (xml) {
-          while ((elem = elem[dir])) {
-            if (elem.nodeType === 1 || checkNonElements) {
-              if (matcher(elem, context, xml)) {
-                return true;
-              }
-            }
-          }
-        } else {
-          while ((elem = elem[dir])) {
-            if (elem.nodeType === 1 || checkNonElements) {
-              outerCache = elem[expando] || (elem[expando] = {});
-              if ((oldCache = outerCache[dir])
-							&& oldCache[0] === dirruns && oldCache[1] === doneName) {
-                // Assign to newCache so results back-propagate to previous elements
-                return (newCache[2] = oldCache[2]);
-              }
-              // Reuse newcache so results back-propagate to previous elements
-              outerCache[dir] = newCache;
-
-              // A match means we're done; a fail means we have to keep checking
-              if ((newCache[2] = matcher(elem, context, xml))) {
-                return true;
-              }
-            }
-          }
-        }
-      };
-  }
-
-  function elementMatcher(matchers) {
-    return matchers.length > 1
-      ? function (elem, context, xml) {
-        let i = matchers.length;
-        while (i--) {
-          if (!matchers[i](elem, context, xml)) {
-            return false;
-          }
-        }
-        return true;
-      }
-      : matchers[0];
-  }
-
-  function condense(unmatched, map, filter, context, xml) {
-    let elem;
-    const newUnmatched = [];
-    let i = 0;
-    const len = unmatched.length;
-    const mapped = map != null;
-
-    for (; i < len; i++) {
-      if ((elem = unmatched[i])) {
-        if (!filter || filter(elem, context, xml)) {
-          newUnmatched.push(elem);
-          if (mapped) {
-            map.push(i);
-          }
-        }
-      }
-    }
-
-    return newUnmatched;
-  }
-
-  function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
-    if (postFilter && !postFilter[expando]) {
-      postFilter = setMatcher(postFilter);
-    }
-    if (postFinder && !postFinder[expando]) {
-      postFinder = setMatcher(postFinder, postSelector);
-    }
-    return markFunction((seed, results, context, xml) => {
-      let temp; let i; let elem;
-      const preMap = [];
-      const postMap = [];
-      const preexisting = results.length;
-
-      // Get initial elements from seed or context
-      const elems = seed || multipleContexts(selector || '*', context.nodeType ? [context] : context, []);
-
-      // Prefilter to get matcher input, preserving a map for seed-results synchronization
-      const matcherIn = preFilter && (seed || !selector)
-        ? condense(elems, preMap, preFilter, context, xml)
-        : elems;
-
-      let matcherOut = matcher
-      // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
-        ? postFinder || (seed ? preFilter : preexisting || postFilter)
-
-        // ...intermediate processing is necessary
-          ? []
-
-        // ...otherwise use results directly
-          : results
-        : matcherIn;
-
-      // Find primary matches
-      if (matcher) {
-        matcher(matcherIn, matcherOut, context, xml);
-      }
-
-      // Apply postFilter
-      if (postFilter) {
-        temp = condense(matcherOut, postMap);
-        postFilter(temp, [], context, xml);
-
-        // Un-match failing elements by moving them back to matcherIn
-        i = temp.length;
-        while (i--) {
-          if ((elem = temp[i])) {
-            matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
-          }
-        }
-      }
-
-      if (seed) {
-        if (postFinder || preFilter) {
-          if (postFinder) {
-            // Get the final matcherOut by condensing this intermediate into postFinder contexts
-            temp = [];
-            i = matcherOut.length;
-            while (i--) {
-              if ((elem = matcherOut[i])) {
-                // Restore matcherIn since elem is not yet a final match
-                temp.push((matcherIn[i] = elem));
-              }
-            }
-            postFinder(null, (matcherOut = []), temp, xml);
-          }
-
-          // Move matched elements from seed to results to keep them synchronized
-          i = matcherOut.length;
-          while (i--) {
-            if ((elem = matcherOut[i])
-						&& (temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1) {
-              seed[temp] = !(results[temp] = elem);
-            }
-          }
-        }
-
-        // Add elements to results, through postFinder if defined
-      } else {
-        matcherOut = condense(
-          matcherOut === results
-            ? matcherOut.splice(preexisting, matcherOut.length)
-            : matcherOut,
-        );
-        if (postFinder) {
-          postFinder(null, results, matcherOut, xml);
-        } else {
-          push.apply(results, matcherOut);
-        }
-      }
-    });
-  }
-
-  function matcherFromTokens(tokens) {
-    let checkContext; let matcher; let j;
-    const len = tokens.length;
-    const leadingRelative = Expr.relative[tokens[0].type];
-    const implicitRelative = leadingRelative || Expr.relative[' '];
-    let i = leadingRelative ? 1 : 0;
-
-    // The foundational matcher ensures that elements are reachable from top-level context(s)
-    const matchContext = addCombinator((elem) => elem === checkContext, implicitRelative, true);
-    const matchAnyContext = addCombinator((elem) => indexOf.call(checkContext, elem) > -1, implicitRelative, true);
-    let matchers = [function (elem, context, xml) {
-      return (!leadingRelative && (xml || context !== outermostContext)) || (
-        (checkContext = context).nodeType
-          ? matchContext(elem, context, xml)
-          : matchAnyContext(elem, context, xml));
-    }];
-
-    for (; i < len; i++) {
-      if ((matcher = Expr.relative[tokens[i].type])) {
-        matchers = [addCombinator(elementMatcher(matchers), matcher)];
-      } else {
-        matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
-
-        // Return special upon seeing a positional matcher
-        if (matcher[expando]) {
-          // Find the next relative operator (if any) for proper handling
-          j = ++i;
-          for (; j < len; j++) {
-            if (Expr.relative[tokens[j].type]) {
-              break;
-            }
-          }
-          return setMatcher(
-            i > 1 && elementMatcher(matchers),
-            i > 1 && toSelector(
-              // If the preceding token was a descendant combinator, insert an implicit any-element `*`
-              tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === ' ' ? '*' : '' }),
-            ).replace(rtrim, '$1'),
-            matcher,
-            i < j && matcherFromTokens(tokens.slice(i, j)),
-            j < len && matcherFromTokens((tokens = tokens.slice(j))),
-            j < len && toSelector(tokens),
-          );
-        }
-        matchers.push(matcher);
-      }
-    }
-
-    return elementMatcher(matchers);
-  }
-
-  function matcherFromGroupMatchers(elementMatchers, setMatchers) {
-    const bySet = setMatchers.length > 0;
-    const byElement = elementMatchers.length > 0;
-    const superMatcher = function (seed, context, xml, results, outermost) {
-      let elem; let j; let matcher;
-      let matchedCount = 0;
-      let i = '0';
-      const unmatched = seed && [];
-      let setMatched = [];
-      const contextBackup = outermostContext;
-      // We must always have either seed elements or outermost context
-      const elems = seed || byElement && Expr.find.TAG('*', outermost);
-      // Use integer dirruns iff this is the outermost matcher
-      const dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
-      const len = elems.length;
-
-      if (outermost) {
-        outermostContext = context !== document && context;
-      }
-
-      // Add elements passing elementMatchers directly to results
-      // Keep `i` a string if there are no elements so `matchedCount` will be "00" below
-      // Support: IE<9, Safari
-      // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
-      for (; i !== len && (elem = elems[i]) != null; i++) {
-        if (byElement && elem) {
-          j = 0;
-          while ((matcher = elementMatchers[j++])) {
-            if (matcher(elem, context, xml)) {
-              results.push(elem);
-              break;
-            }
-          }
-          if (outermost) {
-            dirruns = dirrunsUnique;
-          }
-        }
-
-        // Track unmatched elements for set filters
-        if (bySet) {
-          // They will have gone through all possible matchers
-          if ((elem = !matcher && elem)) {
-            matchedCount--;
-          }
-
-          // Lengthen the array for every element, matched or not
-          if (seed) {
-            unmatched.push(elem);
-          }
-        }
-      }
-
-      // Apply set filters to unmatched elements
-      matchedCount += i;
-      if (bySet && i !== matchedCount) {
-        j = 0;
-        while ((matcher = setMatchers[j++])) {
-          matcher(unmatched, setMatched, context, xml);
-        }
-
-        if (seed) {
-          // Reintegrate element matches to eliminate the need for sorting
-          if (matchedCount > 0) {
-            while (i--) {
-              if (!(unmatched[i] || setMatched[i])) {
-                setMatched[i] = pop.call(results);
-              }
-            }
-          }
-
-          // Discard index placeholder values to get only actual matches
-          setMatched = condense(setMatched);
-        }
-
-        // Add matches to results
-        push.apply(results, setMatched);
-
-        // Seedless set matches succeeding multiple successful matchers stipulate sorting
-        if (outermost && !seed && setMatched.length > 0
-					&& (matchedCount + setMatchers.length) > 1) {
-          Sizzle.uniqueSort(results);
-        }
-      }
-
-      // Override manipulation of globals by nested matchers
-      if (outermost) {
-        dirruns = dirrunsUnique;
-        outermostContext = contextBackup;
-      }
-
-      return unmatched;
-    };
-
-    return bySet
-      ? markFunction(superMatcher)
-      : superMatcher;
-  }
-
-  compile = Sizzle.compile = function (selector, group /* Internal Use Only */) {
-    let i;
-    const setMatchers = [];
-    const elementMatchers = [];
-    let cached = compilerCache[`${selector} `];
-
-    if (!cached) {
-      // Generate a function of recursive functions that can be used to check each element
-      if (!group) {
-        group = tokenize(selector);
-      }
-      i = group.length;
-      while (i--) {
-        cached = matcherFromTokens(group[i]);
-        if (cached[expando]) {
-          setMatchers.push(cached);
-        } else {
-          elementMatchers.push(cached);
-        }
-      }
-
-      // Cache the compiled function
-      cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
-    }
-    return cached;
-  };
-
-  function multipleContexts(selector, contexts, results) {
-    let i = 0;
-    const len = contexts.length;
-    for (; i < len; i++) {
-      Sizzle(selector, contexts[i], results);
-    }
-    return results;
-  }
-
-  function select(selector, context, results, seed) {
-    let i; let tokens; let token; let type; let find;
-    const match = tokenize(selector);
-
-    if (!seed) {
-      // Try to minimize operations if there is only one group
-      if (match.length === 1) {
-        // Take a shortcut and set the context if the root selector is an ID
-        tokens = match[0] = match[0].slice(0);
-        if (tokens.length > 2 && (token = tokens[0]).type === 'ID'
-					&& support.getById && context.nodeType === 9 && documentIsHTML
-					&& Expr.relative[tokens[1].type]) {
-          context = (Expr.find.ID(token.matches[0].replace(runescape, funescape), context) || [])[0];
-          if (!context) {
-            return results;
-          }
-          selector = selector.slice(tokens.shift().value.length);
-        }
-
-        // Fetch a seed set for right-to-left matching
-        i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
-        while (i--) {
-          token = tokens[i];
-
-          // Abort if we hit a combinator
-          if (Expr.relative[(type = token.type)]) {
-            break;
-          }
-          if ((find = Expr.find[type])) {
-            // Search, expanding context for leading sibling combinators
-            if ((seed = find(
-              token.matches[0].replace(runescape, funescape),
-              rsibling.test(tokens[0].type) && testContext(context.parentNode) || context,
-            ))) {
-              // If seed is empty or no tokens remain, we can return early
-              tokens.splice(i, 1);
-              selector = seed.length && toSelector(tokens);
-              if (!selector) {
-                push.apply(results, seed);
-                return results;
-              }
-
-              break;
-            }
-          }
-        }
-      }
-    }
-
-    // Compile and execute a filtering function
-    // Provide `match` to avoid retokenization if we modified the selector above
-    compile(selector, match)(
-      seed,
-      context,
-      !documentIsHTML,
-      results,
-      rsibling.test(selector) && testContext(context.parentNode) || context,
-    );
-    return results;
-  }
-
-  // One-time assignments
-
-  // Sort stability
-  support.sortStable = expando.split('').sort(sortOrder).join('') === expando;
-
-  // Support: Chrome<14
-  // Always assume duplicates if they aren't passed to the comparison function
-  support.detectDuplicates = !!hasDuplicate;
-
-  // Initialize against the default document
-  setDocument();
-
-  // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
-  // Detached nodes confoundingly follow *each other*
-  support.sortDetached = assert((div1) =>
-    // Should return 1, but returns 4 (following)
-    div1.compareDocumentPosition(document.createElement('div')) & 1);
-
-  // Support: IE<8
-  // Prevent attribute/property "interpolation"
-  // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
-  if (!assert((div) => {
-    div.innerHTML = "<a href='#'></a>";
-    return div.firstChild.getAttribute('href') === '#';
-  })) {
-    addHandle('type|href|height|width', (elem, name, isXML) => {
-      if (!isXML) {
-        return elem.getAttribute(name, name.toLowerCase() === 'type' ? 1 : 2);
-      }
-    });
-  }
-
-  // Support: IE<9
-  // Use defaultValue in place of getAttribute("value")
-  if (!support.attributes || !assert((div) => {
-    div.innerHTML = '<input/>';
-    div.firstChild.setAttribute('value', '');
-    return div.firstChild.getAttribute('value') === '';
-  })) {
-    addHandle('value', (elem, name, isXML) => {
-      if (!isXML && elem.nodeName.toLowerCase() === 'input') {
-        return elem.defaultValue;
-      }
-    });
-  }
-
-  // Support: IE<9
-  // Use getAttributeNode to fetch booleans when getAttribute lies
-  if (!assert((div) => div.getAttribute('disabled') == null)) {
-    addHandle(booleans, (elem, name, isXML) => {
-      let val;
-      if (!isXML) {
-        return elem[name] === true ? name.toLowerCase()
-          : (val = elem.getAttributeNode(name)) && val.specified
-            ? val.value
-            : null;
-      }
-    });
-  }
-
-  return Sizzle;
-}(window));
-
-  jQuery.find = Sizzle;
-  jQuery.expr = Sizzle.selectors;
-  jQuery.expr[':'] = jQuery.expr.pseudos;
-  jQuery.unique = Sizzle.uniqueSort;
-  jQuery.text = Sizzle.getText;
-  jQuery.isXMLDoc = Sizzle.isXML;
-  jQuery.contains = Sizzle.contains;
-
-  const rneedsContext = jQuery.expr.match.needsContext;
-
-  const rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
-
-  const risSimple = /^.[^:#\[\.,]*$/;
-
-  // Implement the identical functionality for filter and not
-  function winnow(elements, qualifier, not) {
-    if (jQuery.isFunction(qualifier)) {
-      return jQuery.grep(elements, (elem, i) =>
-        /* jshint -W018 */
-        !!qualifier.call(elem, i, elem) !== not);
-    }
-
-    if (qualifier.nodeType) {
-      return jQuery.grep(elements, (elem) => (elem === qualifier) !== not);
-    }
-
-    if (typeof qualifier === 'string') {
-      if (risSimple.test(qualifier)) {
-        return jQuery.filter(qualifier, elements, not);
-      }
-
-      qualifier = jQuery.filter(qualifier, elements);
-    }
-
-    return jQuery.grep(elements, (elem) => (indexOf.call(qualifier, elem) >= 0) !== not);
-  }
-
-  jQuery.filter = function (expr, elems, not) {
-    const elem = elems[0];
-
-    if (not) {
-      expr = `:not(${expr})`;
-    }
-
-    return elems.length === 1 && elem.nodeType === 1
-      ? jQuery.find.matchesSelector(elem, expr) ? [elem] : []
-      : jQuery.find.matches(expr, jQuery.grep(elems, (elem) => elem.nodeType === 1));
-  };
-
-  jQuery.fn.extend({
-    find(selector) {
-      let i;
-      const len = this.length;
-      let ret = [];
-      const self = this;
-
-      if (typeof selector !== 'string') {
-        return this.pushStack(jQuery(selector).filter(function () {
-          for (i = 0; i < len; i++) {
-            if (jQuery.contains(self[i], this)) {
-              return true;
-            }
-          }
-        }));
-      }
-
-      for (i = 0; i < len; i++) {
-        jQuery.find(selector, self[i], ret);
-      }
-
-      // Needed because $( selector, context ) becomes $( context ).find( selector )
-      ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
-      ret.selector = this.selector ? `${this.selector} ${selector}` : selector;
-      return ret;
-    },
-    filter(selector) {
-      return this.pushStack(winnow(this, selector || [], false));
-    },
-    not(selector) {
-      return this.pushStack(winnow(this, selector || [], true));
-    },
-    is(selector) {
-      return !!winnow(
-        this,
-
-        // If this is a positional/relative selector, check membership in the returned set
-        // so $("p:first").is("p:last") won't return true for a doc with two "p".
-        typeof selector === 'string' && rneedsContext.test(selector)
-          ? jQuery(selector)
-          : selector || [],
-        false,
-      ).length;
-    },
-  });
-
-  // Initialize a jQuery object
-
-  // A central reference to the root jQuery(document)
-  let rootjQuery;
-
-  // A simple way to check for HTML strings
-  // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
-  // Strict HTML recognition (#11290: must start with <)
-  const rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/;
-
-  const init = jQuery.fn.init = function (selector, context) {
-    let match; let
-      elem;
-
-    // HANDLE: $(""), $(null), $(undefined), $(false)
-    if (!selector) {
-      return this;
-    }
-
-    // Handle HTML strings
-    if (typeof selector === 'string') {
-      if (selector[0] === '<' && selector[selector.length - 1] === '>' && selector.length >= 3) {
-        // Assume that strings that start and end with <> are HTML and skip the regex check
-        match = [null, selector, null];
-      } else {
-        match = rquickExpr.exec(selector);
-      }
-
-      // Match html or make sure no context is specified for #id
-      if (match && (match[1] || !context)) {
-        // HANDLE: $(html) -> $(array)
-        if (match[1]) {
-          context = context instanceof jQuery ? context[0] : context;
-
-          // scripts is true for back-compat
-          // Intentionally let the error be thrown if parseHTML is not present
-          jQuery.merge(this, jQuery.parseHTML(
-            match[1],
-            context && context.nodeType ? context.ownerDocument || context : document,
-            true,
-          ));
-
-          // HANDLE: $(html, props)
-          if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
-            for (match in context) {
-              // Properties of context are called as methods if possible
-              if (jQuery.isFunction(this[match])) {
-                this[match](context[match]);
-
-                // ...and otherwise set as attributes
-              } else {
-                this.attr(match, context[match]);
-              }
-            }
-          }
-
-          return this;
-
-          // HANDLE: $(#id)
-        }
-        elem = document.getElementById(match[2]);
-
-        // Check parentNode to catch when Blackberry 4.6 returns
-        // nodes that are no longer in the document #6963
-        if (elem && elem.parentNode) {
-          // Inject the element directly into the jQuery object
-          this.length = 1;
-          this[0] = elem;
-        }
-
-        this.context = document;
-        this.selector = selector;
-        return this;
-
-        // HANDLE: $(expr, $(...))
-      } if (!context || context.jquery) {
-        return (context || rootjQuery).find(selector);
-
-        // HANDLE: $(expr, context)
-        // (which is just equivalent to: $(context).find(expr)
-      }
-      return this.constructor(context).find(selector);
-
-      // HANDLE: $(DOMElement)
-    } if (selector.nodeType) {
-      this.context = this[0] = selector;
-      this.length = 1;
-      return this;
-
-      // HANDLE: $(function)
-      // Shortcut for document ready
-    } if (jQuery.isFunction(selector)) {
-      return typeof rootjQuery.ready !== 'undefined'
-        ? rootjQuery.ready(selector)
-      // Execute immediately if ready is not present
-        : selector(jQuery);
-    }
-
-    if (selector.selector !== undefined) {
-      this.selector = selector.selector;
-      this.context = selector.context;
-    }
-
-    return jQuery.makeArray(selector, this);
-  };
-
-  // Give the init function the jQuery prototype for later instantiation
-  init.prototype = jQuery.fn;
-
-  // Initialize central reference
-  rootjQuery = jQuery(document);
-
-  const rparentsprev = /^(?:parents|prev(?:Until|All))/;
-  // methods guaranteed to produce a unique set when starting from a unique set
-  const guaranteedUnique = {
-    children: true,
-    contents: true,
-    next: true,
-    prev: true,
-  };
-
-  jQuery.extend({
-    dir(elem, dir, until) {
-      const matched = [];
-      const truncate = until !== undefined;
-
-      while ((elem = elem[dir]) && elem.nodeType !== 9) {
-        if (elem.nodeType === 1) {
-          if (truncate && jQuery(elem).is(until)) {
-            break;
-          }
-          matched.push(elem);
-        }
-      }
-      return matched;
-    },
-
-    sibling(n, elem) {
-      const matched = [];
-
-      for (; n; n = n.nextSibling) {
-        if (n.nodeType === 1 && n !== elem) {
-          matched.push(n);
-        }
-      }
-
-      return matched;
-    },
-  });
-
-  jQuery.fn.extend({
-    has(target) {
-      const targets = jQuery(target, this);
-      const l = targets.length;
-
-      return this.filter(function () {
-        let i = 0;
-        for (; i < l; i++) {
-          if (jQuery.contains(this, targets[i])) {
-            return true;
-          }
-        }
-      });
-    },
-
-    closest(selectors, context) {
-      let cur;
-      let i = 0;
-      const l = this.length;
-      const matched = [];
-      const pos = rneedsContext.test(selectors) || typeof selectors !== 'string'
-        ? jQuery(selectors, context || this.context)
-        : 0;
-
-      for (; i < l; i++) {
-        for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
-          // Always skip document fragments
-          if (cur.nodeType < 11 && (pos
-            ? pos.index(cur) > -1
-
-          // Don't pass non-elements to Sizzle
-            : cur.nodeType === 1
-						&& jQuery.find.matchesSelector(cur, selectors))) {
-            matched.push(cur);
-            break;
-          }
-        }
-      }
-
-      return this.pushStack(matched.length > 1 ? jQuery.unique(matched) : matched);
-    },
-
-    // Determine the position of an element within
-    // the matched set of elements
-    index(elem) {
-      // No argument, return index in parent
-      if (!elem) {
-        return (this[0] && this[0].parentNode) ? this.first().prevAll().length : -1;
-      }
-
-      // index in selector
-      if (typeof elem === 'string') {
-        return indexOf.call(jQuery(elem), this[0]);
-      }
-
-      // Locate the position of the desired element
-      return indexOf.call(this,
-
-        // If it receives a jQuery object, the first element is used
-        elem.jquery ? elem[0] : elem);
-    },
-
-    add(selector, context) {
-      return this.pushStack(
-        jQuery.unique(
-          jQuery.merge(this.get(), jQuery(selector, context)),
-        ),
-      );
-    },
-
-    addBack(selector) {
-      return this.add(selector == null
-        ? this.prevObject : this.prevObject.filter(selector));
-    },
-  });
-
-  function sibling(cur, dir) {
-    while ((cur = cur[dir]) && cur.nodeType !== 1) {}
-    return cur;
-  }
-
-  jQuery.each({
-    parent(elem) {
-      const parent = elem.parentNode;
-      return parent && parent.nodeType !== 11 ? parent : null;
-    },
-    parents(elem) {
-      return jQuery.dir(elem, 'parentNode');
-    },
-    parentsUntil(elem, i, until) {
-      return jQuery.dir(elem, 'parentNode', until);
-    },
-    next(elem) {
-      return sibling(elem, 'nextSibling');
-    },
-    prev(elem) {
-      return sibling(elem, 'previousSibling');
-    },
-    nextAll(elem) {
-      return jQuery.dir(elem, 'nextSibling');
-    },
-    prevAll(elem) {
-      return jQuery.dir(elem, 'previousSibling');
-    },
-    nextUntil(elem, i, until) {
-      return jQuery.dir(elem, 'nextSibling', until);
-    },
-    prevUntil(elem, i, until) {
-      return jQuery.dir(elem, 'previousSibling', until);
-    },
-    siblings(elem) {
-      return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
-    },
-    children(elem) {
-      return jQuery.sibling(elem.firstChild);
-    },
-    contents(elem) {
-      return elem.contentDocument || jQuery.merge([], elem.childNodes);
-    },
-  }, (name, fn) => {
-    jQuery.fn[name] = function (until, selector) {
-      let matched = jQuery.map(this, fn, until);
-
-      if (name.slice(-5) !== 'Until') {
-        selector = until;
-      }
-
-      if (selector && typeof selector === 'string') {
-        matched = jQuery.filter(selector, matched);
-      }
-
-      if (this.length > 1) {
-        // Remove duplicates
-        if (!guaranteedUnique[name]) {
-          jQuery.unique(matched);
-        }
-
-        // Reverse order for parents* and prev-derivatives
-        if (rparentsprev.test(name)) {
-          matched.reverse();
-        }
-      }
-
-      return this.pushStack(matched);
-    };
-  });
-  const rnotwhite = (/\S+/g);
-
-  // String to Object options format cache
-  const optionsCache = {};
-
-  // Convert String-formatted options into Object-formatted ones and store in cache
-  function createOptions(options) {
-    const object = optionsCache[options] = {};
-    jQuery.each(options.match(rnotwhite) || [], (_, flag) => {
-      object[flag] = true;
-    });
-    return object;
-  }
-
-  /*
- * Create a callback list using the following parameters:
- *
- *	options: an optional list of space-separated options that will change how
- *			the callback list behaves or a more traditional option object
- *
- * By default a callback list will act like an event callback list and can be
- * "fired" multiple times.
- *
- * Possible options:
- *
- *	once:			will ensure the callback list can only be fired once (like a Deferred)
- *
- *	memory:			will keep track of previous values and will call any callback added
- *					after the list has been fired right away with the latest "memorized"
- *					values (like a Deferred)
- *
- *	unique:			will ensure a callback can only be added once (no duplicate in the list)
- *
- *	stopOnFalse:	interrupt callings when a callback returns false
- *
- */
-  jQuery.Callbacks = function (options) {
-    // Convert options from String-formatted to Object-formatted if needed
-    // (we check in cache first)
-    options = typeof options === 'string'
-      ? (optionsCache[options] || createOptions(options))
-      : jQuery.extend({}, options);
-
-    let // Last fire value (for non-forgettable lists)
-      memory;
-    // Flag to know if list was already fired
-    let fired;
-    // Flag to know if list is currently firing
-    let firing;
-    // First callback to fire (used internally by add and fireWith)
-    let firingStart;
-    // End of the loop when firing
-    let firingLength;
-    // Index of currently firing callback (modified by remove if needed)
-    let firingIndex;
-    // Actual callback list
-    let list = [];
-    // Stack of fire calls for repeatable lists
-    let stack = !options.once && [];
-    // Fire callbacks
-    var fire = function (data) {
-      memory = options.memory && data;
-      fired = true;
-      firingIndex = firingStart || 0;
-      firingStart = 0;
-      firingLength = list.length;
-      firing = true;
-      for (; list && firingIndex < firingLength; firingIndex++) {
-        if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
-          memory = false; // To prevent further calls using add
-          break;
-        }
-      }
-      firing = false;
-      if (list) {
-        if (stack) {
-          if (stack.length) {
-            fire(stack.shift());
-          }
-        } else if (memory) {
-          list = [];
-        } else {
-          self.disable();
-        }
-      }
-    };
-    // Actual Callbacks object
-    var self = {
-      // Add a callback or a collection of callbacks to the list
-      add() {
-        if (list) {
-          // First, we save the current length
-          const start = list.length;
-          (function add(args) {
-            jQuery.each(args, (_, arg) => {
-              const type = jQuery.type(arg);
-              if (type === 'function') {
-                if (!options.unique || !self.has(arg)) {
-                  list.push(arg);
-                }
-              } else if (arg && arg.length && type !== 'string') {
-                // Inspect recursively
-                add(arg);
-              }
-            });
-          }(arguments));
-          // Do we need to add the callbacks to the
-          // current firing batch?
-          if (firing) {
-            firingLength = list.length;
-            // With memory, if we're not firing then
-            // we should call right away
-          } else if (memory) {
-            firingStart = start;
-            fire(memory);
-          }
-        }
-        return this;
-      },
-      // Remove a callback from the list
-      remove() {
-        if (list) {
-          jQuery.each(arguments, (_, arg) => {
-            let index;
-            while ((index = jQuery.inArray(arg, list, index)) > -1) {
-              list.splice(index, 1);
-              // Handle firing indexes
-              if (firing) {
-                if (index <= firingLength) {
-                  firingLength--;
-                }
-                if (index <= firingIndex) {
-                  firingIndex--;
-                }
-              }
-            }
-          });
-        }
-        return this;
-      },
-      // Check if a given callback is in the list.
-      // If no argument is given, return whether or not list has callbacks attached.
-      has(fn) {
-        return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length);
-      },
-      // Remove all callbacks from the list
-      empty() {
-        list = [];
-        firingLength = 0;
-        return this;
-      },
-      // Have the list do nothing anymore
-      disable() {
-        list = stack = memory = undefined;
-        return this;
-      },
-      // Is it disabled?
-      disabled() {
-        return !list;
-      },
-      // Lock the list in its current state
-      lock() {
-        stack = undefined;
-        if (!memory) {
-          self.disable();
-        }
-        return this;
-      },
-      // Is it locked?
-      locked() {
-        return !stack;
-      },
-      // Call all callbacks with the given context and arguments
-      fireWith(context, args) {
-        if (list && (!fired || stack)) {
-          args = args || [];
-          args = [context, args.slice ? args.slice() : args];
-          if (firing) {
-            stack.push(args);
-          } else {
-            fire(args);
-          }
-        }
-        return this;
-      },
-      // Call all the callbacks with the given arguments
-      fire() {
-        self.fireWith(this, arguments);
-        return this;
-      },
-      // To know if the callbacks have already been called at least once
-      fired() {
-        return !!fired;
-      },
-    };
-
-    return self;
-  };
-
-  jQuery.extend({
-
-    Deferred(func) {
-      const tuples = [
-        // action, add listener, listener list, final state
-        ['resolve', 'done', jQuery.Callbacks('once memory'), 'resolved'],
-        ['reject', 'fail', jQuery.Callbacks('once memory'), 'rejected'],
-        ['notify', 'progress', jQuery.Callbacks('memory')],
-      ];
-      let state = 'pending';
-      var promise = {
-        state() {
-          return state;
-        },
-        always() {
-          deferred.done(arguments).fail(arguments);
-          return this;
-        },
-        then(/* fnDone, fnFail, fnProgress */) {
-          let fns = arguments;
-          return jQuery.Deferred((newDefer) => {
-            jQuery.each(tuples, (i, tuple) => {
-              const fn = jQuery.isFunction(fns[i]) && fns[i];
-              // deferred[ done | fail | progress ] for forwarding actions to newDefer
-              deferred[tuple[1]](function () {
-                const returned = fn && fn.apply(this, arguments);
-                if (returned && jQuery.isFunction(returned.promise)) {
-                  returned.promise()
-                    .done(newDefer.resolve)
-                    .fail(newDefer.reject)
-                    .progress(newDefer.notify);
-                } else {
-                  newDefer[`${tuple[0]}With`](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments);
-                }
-              });
-            });
-            fns = null;
-          }).promise();
-        },
-        // Get a promise for this deferred
-        // If obj is provided, the promise aspect is added to the object
-        promise(obj) {
-          return obj != null ? jQuery.extend(obj, promise) : promise;
-        },
-      };
-      var deferred = {};
-
-      // Keep pipe for back-compat
-      promise.pipe = promise.then;
-
-      // Add list-specific methods
-      jQuery.each(tuples, (i, tuple) => {
-        const list = tuple[2];
-        const stateString = tuple[3];
-
-        // promise[ done | fail | progress ] = list.add
-        promise[tuple[1]] = list.add;
-
-        // Handle state
-        if (stateString) {
-          list.add(() => {
-            // state = [ resolved | rejected ]
-            state = stateString;
-
-            // [ reject_list | resolve_list ].disable; progress_list.lock
-          }, tuples[i ^ 1][2].disable, tuples[2][2].lock);
-        }
-
-        // deferred[ resolve | reject | notify ]
-        deferred[tuple[0]] = function () {
-          deferred[`${tuple[0]}With`](this === deferred ? promise : this, arguments);
-          return this;
-        };
-        deferred[`${tuple[0]}With`] = list.fireWith;
-      });
-
-      // Make the deferred a promise
-      promise.promise(deferred);
-
-      // Call given func if any
-      if (func) {
-        func.call(deferred, deferred);
-      }
-
-      // All done!
-      return deferred;
-    },
-
-    // Deferred helper
-    when(subordinate /* , ..., subordinateN */) {
-      let i = 0;
-      const resolveValues = slice.call(arguments);
-      const { length } = resolveValues;
-
-      // the count of uncompleted subordinates
-      let remaining = length !== 1 || (subordinate && jQuery.isFunction(subordinate.promise)) ? length : 0;
-
-      // the master Deferred. If resolveValues consist of only a single Deferred, just use that.
-      const deferred = remaining === 1 ? subordinate : jQuery.Deferred();
-
-      // Update function for both resolve and progress values
-      const updateFunc = function (i, contexts, values) {
-        return function (value) {
-          contexts[i] = this;
-          values[i] = arguments.length > 1 ? slice.call(arguments) : value;
-          if (values === progressValues) {
-            deferred.notifyWith(contexts, values);
-          } else if (!(--remaining)) {
-            deferred.resolveWith(contexts, values);
-          }
-        };
-      };
-
-      let progressValues; let progressContexts; let
-        resolveContexts;
-
-      // add listeners to Deferred subordinates; treat others as resolved
-      if (length > 1) {
-        progressValues = new Array(length);
-        progressContexts = new Array(length);
-        resolveContexts = new Array(length);
-        for (; i < length; i++) {
-          if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
-            resolveValues[i].promise()
-              .done(updateFunc(i, resolveContexts, resolveValues))
-              .fail(deferred.reject)
-              .progress(updateFunc(i, progressContexts, progressValues));
-          } else {
-            --remaining;
-          }
-        }
-      }
-
-      // if we're not waiting on anything, resolve the master
-      if (!remaining) {
-        deferred.resolveWith(resolveContexts, resolveValues);
-      }
-
-      return deferred.promise();
-    },
-  });
-
-  // The deferred used on DOM ready
-  let readyList;
-
-  jQuery.fn.ready = function (fn) {
-    // Add the callback
-    jQuery.ready.promise().done(fn);
-
-    return this;
-  };
-
-  jQuery.extend({
-    // Is the DOM ready to be used? Set to true once it occurs.
-    isReady: false,
-
-    // A counter to track how many items to wait for before
-    // the ready event fires. See #6781
-    readyWait: 1,
-
-    // Hold (or release) the ready event
-    holdReady(hold) {
-      if (hold) {
-        jQuery.readyWait++;
-      } else {
-        jQuery.ready(true);
-      }
-    },
-
-    // Handle when the DOM is ready
-    ready(wait) {
-      // Abort if there are pending holds or we're already ready
-      if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
-        return;
-      }
-
-      // Remember that the DOM is ready
-      jQuery.isReady = true;
-
-      // If a normal DOM Ready event fired, decrement, and wait if need be
-      if (wait !== true && --jQuery.readyWait > 0) {
-        return;
-      }
-
-      // If there are functions bound, to execute
-      readyList.resolveWith(document, [jQuery]);
-
-      // Trigger any bound ready events
-      if (jQuery.fn.trigger) {
-        jQuery(document).trigger('ready').off('ready');
-      }
-    },
-  });
-
-  /**
- * The ready event handler and self cleanup method
- */
-  function completed() {
-    document.removeEventListener('DOMContentLoaded', completed, false);
-    window.removeEventListener('load', completed, false);
-    jQuery.ready();
-  }
-
-  jQuery.ready.promise = function (obj) {
-    if (!readyList) {
-      readyList = jQuery.Deferred();
-
-      // Catch cases where $(document).ready() is called after the browser event has already occurred.
-      // we once tried to use readyState "interactive" here, but it caused issues like the one
-      // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
-      if (document.readyState === 'complete') {
-        // Handle it asynchronously to allow scripts the opportunity to delay ready
-        setTimeout(jQuery.ready);
-      } else {
-        // Use the handy event callback
-        document.addEventListener('DOMContentLoaded', completed, false);
-
-        // A fallback to window.onload, that will always work
-        window.addEventListener('load', completed, false);
-      }
-    }
-    return readyList.promise(obj);
-  };
-
-  // Kick off the DOM ready check even if the user does not
-  jQuery.ready.promise();
-
-  // Multifunctional method to get and set values of a collection
-  // The value/s can optionally be executed if it's a function
-  const access = jQuery.access = function (elems, fn, key, value, chainable, emptyGet, raw) {
-    let i = 0;
-    const len = elems.length;
-    let bulk = key == null;
-
-    // Sets many values
-    if (jQuery.type(key) === 'object') {
-      chainable = true;
-      for (i in key) {
-        jQuery.access(elems, fn, i, key[i], true, emptyGet, raw);
-      }
-
-      // Sets one value
-    } else if (value !== undefined) {
-      chainable = true;
-
-      if (!jQuery.isFunction(value)) {
-        raw = true;
-      }
-
-      if (bulk) {
-        // Bulk operations run against the entire set
-        if (raw) {
-          fn.call(elems, value);
-          fn = null;
-
-          // ...except when executing function values
-        } else {
-          bulk = fn;
-          fn = function (elem, key, value) {
-            return bulk.call(jQuery(elem), value);
-          };
-        }
-      }
-
-      if (fn) {
-        for (; i < len; i++) {
-          fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
-        }
-      }
-    }
-
-    return chainable
-      ? elems
-
-    // Gets
-      : bulk
-        ? fn.call(elems)
-        : len ? fn(elems[0], key) : emptyGet;
-  };
-
-  /**
- * Determines whether an object can have data
- */
-  jQuery.acceptData = function (owner) {
-    // Accepts only:
-    //  - Node
-    //    - Node.ELEMENT_NODE
-    //    - Node.DOCUMENT_NODE
-    //  - Object
-    //    - Any
-    /* jshint -W018 */
-    return owner.nodeType === 1 || owner.nodeType === 9 || !(+owner.nodeType);
-  };
-
-  function Data() {
-    // Support: Android < 4,
-    // Old WebKit does not have Object.preventExtensions/freeze method,
-    // return new empty object instead with no [[set]] accessor
-    Object.defineProperty(this.cache = {}, 0, {
-      get() {
-        return {};
-      },
-    });
-
-    this.expando = jQuery.expando + Math.random();
-  }
-
-  Data.uid = 1;
-  Data.accepts = jQuery.acceptData;
-
-  Data.prototype = {
-    key(owner) {
-      // We can accept data for non-element nodes in modern browsers,
-      // but we should not, see #8335.
-      // Always return the key for a frozen object.
-      if (!Data.accepts(owner)) {
-        return 0;
-      }
-
-      const descriptor = {};
-      // Check if the owner object already has a cache key
-      let unlock = owner[this.expando];
-
-      // If not, create one
-      if (!unlock) {
-        unlock = Data.uid++;
-
-        // Secure it in a non-enumerable, non-writable property
-        try {
-          descriptor[this.expando] = { value: unlock };
-          Object.defineProperties(owner, descriptor);
-
-          // Support: Android < 4
-          // Fallback to a less secure definition
-        } catch (e) {
-          descriptor[this.expando] = unlock;
-          jQuery.extend(owner, descriptor);
-        }
-      }
-
-      // Ensure the cache object
-      if (!this.cache[unlock]) {
-        this.cache[unlock] = {};
-      }
-
-      return unlock;
-    },
-    set(owner, data, value) {
-      let prop;
-      // There may be an unlock assigned to this node,
-      // if there is no entry for this "owner", create one inline
-      // and set the unlock as though an owner entry had always existed
-      const unlock = this.key(owner);
-      const cache = this.cache[unlock];
-
-      // Handle: [ owner, key, value ] args
-      if (typeof data === 'string') {
-        cache[data] = value;
-
-        // Handle: [ owner, { properties } ] args
-      } else {
-        // Fresh assignments by object are shallow copied
-        if (jQuery.isEmptyObject(cache)) {
-          jQuery.extend(this.cache[unlock], data);
-          // Otherwise, copy the properties one-by-one to the cache object
-        } else {
-          for (prop in data) {
-            cache[prop] = data[prop];
-          }
-        }
-      }
-      return cache;
-    },
-    get(owner, key) {
-      // Either a valid cache is found, or will be created.
-      // New caches will be created and the unlock returned,
-      // allowing direct access to the newly created
-      // empty data object. A valid owner object must be provided.
-      const cache = this.cache[this.key(owner)];
-
-      return key === undefined
-        ? cache : cache[key];
-    },
-    access(owner, key, value) {
-      let stored;
-      // In cases where either:
-      //
-      //   1. No key was specified
-      //   2. A string key was specified, but no value provided
-      //
-      // Take the "read" path and allow the get method to determine
-      // which value to return, respectively either:
-      //
-      //   1. The entire cache object
-      //   2. The data stored at the key
-      //
-      if (key === undefined
-				|| ((key && typeof key === 'string') && value === undefined)) {
-        stored = this.get(owner, key);
-
-        return stored !== undefined
-          ? stored : this.get(owner, jQuery.camelCase(key));
-      }
-
-      // [*]When the key is not a string, or both a key and value
-      // are specified, set or extend (existing objects) with either:
-      //
-      //   1. An object of properties
-      //   2. A key and value
-      //
-      this.set(owner, key, value);
-
-      // Since the "set" path can have two possible entry points
-      // return the expected data based on which path was taken[*]
-      return value !== undefined ? value : key;
-    },
-    remove(owner, key) {
-      let i; let name; let camel;
-      const unlock = this.key(owner);
-      const cache = this.cache[unlock];
-
-      if (key === undefined) {
-        this.cache[unlock] = {};
-      } else {
-        // Support array or space separated string of keys
-        if (jQuery.isArray(key)) {
-          // If "name" is an array of keys...
-          // When data is initially created, via ("key", "val") signature,
-          // keys will be converted to camelCase.
-          // Since there is no way to tell _how_ a key was added, remove
-          // both plain key and camelCase key. #12786
-          // This will only penalize the array argument path.
-          name = key.concat(key.map(jQuery.camelCase));
-        } else {
-          camel = jQuery.camelCase(key);
-          // Try the string as a key before any manipulation
-          if (key in cache) {
-            name = [key, camel];
-          } else {
-            // If a key with the spaces exists, use it.
-            // Otherwise, create an array by matching non-whitespace
-            name = camel;
-            name = name in cache
-              ? [name] : (name.match(rnotwhite) || []);
-          }
-        }
-
-        i = name.length;
-        while (i--) {
-          delete cache[name[i]];
-        }
-      }
-    },
-    hasData(owner) {
-      return !jQuery.isEmptyObject(
-        this.cache[owner[this.expando]] || {},
-      );
-    },
-    discard(owner) {
-      if (owner[this.expando]) {
-        delete this.cache[owner[this.expando]];
-      }
-    },
-  };
-  const data_priv = new Data();
-
-  const data_user = new Data();
-
-  /*
-	Implementation Summary
-
-	1. Enforce API surface and semantic compatibility with 1.9.x branch
-	2. Improve the module's maintainability by reducing the storage
-		paths to a single mechanism.
-	3. Use the same single mechanism to support "private" and "user" data.
-	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
-	5. Avoid exposing implementation details on user objects (eg. expando properties)
-	6. Provide a clear path for implementation upgrade to WeakMap in 2014
-*/
-  const rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/;
-  const rmultiDash = /([A-Z])/g;
-
-  function dataAttr(elem, key, data) {
-    let name;
-
-    // If nothing was found internally, try to fetch any
-    // data from the HTML5 data-* attribute
-    if (data === undefined && elem.nodeType === 1) {
-      name = `data-${key.replace(rmultiDash, '-$1').toLowerCase()}`;
-      data = elem.getAttribute(name);
-
-      if (typeof data === 'string') {
-        try {
-          data = data === 'true' ? true
-            : data === 'false' ? false
-              : data === 'null' ? null
-              // Only convert to a number if it doesn't change the string
-                : `${+data}` === data ? +data
-                  : rbrace.test(data) ? jQuery.parseJSON(data)
-                    : data;
-        } catch (e) {}
-
-        // Make sure we set the data so it isn't changed later
-        data_user.set(elem, key, data);
-      } else {
-        data = undefined;
-      }
-    }
-    return data;
-  }
-
-  jQuery.extend({
-    hasData(elem) {
-      return data_user.hasData(elem) || data_priv.hasData(elem);
-    },
-
-    data(elem, name, data) {
-      return data_user.access(elem, name, data);
-    },
-
-    removeData(elem, name) {
-      data_user.remove(elem, name);
-    },
-
-    // TODO: Now that all calls to _data and _removeData have been replaced
-    // with direct calls to data_priv methods, these can be deprecated.
-    _data(elem, name, data) {
-      return data_priv.access(elem, name, data);
-    },
-
-    _removeData(elem, name) {
-      data_priv.remove(elem, name);
-    },
-  });
-
-  jQuery.fn.extend({
-    data(key, value) {
-      let i; let name; let data;
-      const elem = this[0];
-      const attrs = elem && elem.attributes;
-
-      // Gets all values
-      if (key === undefined) {
-        if (this.length) {
-          data = data_user.get(elem);
-
-          if (elem.nodeType === 1 && !data_priv.get(elem, 'hasDataAttrs')) {
-            i = attrs.length;
-            while (i--) {
-              name = attrs[i].name;
-
-              if (name.indexOf('data-') === 0) {
-                name = jQuery.camelCase(name.slice(5));
-                dataAttr(elem, name, data[name]);
-              }
-            }
-            data_priv.set(elem, 'hasDataAttrs', true);
-          }
-        }
-
-        return data;
-      }
-
-      // Sets multiple values
-      if (typeof key === 'object') {
-        return this.each(function () {
-          data_user.set(this, key);
-        });
-      }
-
-      return access(this, function (value) {
-        let data;
-        const camelKey = jQuery.camelCase(key);
-
-        // The calling jQuery object (element matches) is not empty
-        // (and therefore has an element appears at this[ 0 ]) and the
-        // `value` parameter was not undefined. An empty jQuery object
-        // will result in `undefined` for elem = this[ 0 ] which will
-        // throw an exception if an attempt to read a data cache is made.
-        if (elem && value === undefined) {
-          // Attempt to get data from the cache
-          // with the key as-is
-          data = data_user.get(elem, key);
-          if (data !== undefined) {
-            return data;
-          }
-
-          // Attempt to get data from the cache
-          // with the key camelized
-          data = data_user.get(elem, camelKey);
-          if (data !== undefined) {
-            return data;
-          }
-
-          // Attempt to "discover" the data in
-          // HTML5 custom data-* attrs
-          data = dataAttr(elem, camelKey, undefined);
-          if (data !== undefined) {
-            return data;
-          }
-
-          // We tried really hard, but the data doesn't exist.
-          return;
-        }
-
-        // Set the data...
-        this.each(function () {
-          // First, attempt to store a copy or reference of any
-          // data that might've been store with a camelCased key.
-          const data = data_user.get(this, camelKey);
-
-          // For HTML5 data-* attribute interop, we have to
-          // store property names with dashes in a camelCase form.
-          // This might not apply to all properties...*
-          data_user.set(this, camelKey, value);
-
-          // *... In the case of properties that might _actually_
-          // have dashes, we need to also store a copy of that
-          // unchanged property.
-          if (key.indexOf('-') !== -1 && data !== undefined) {
-            data_user.set(this, key, value);
-          }
-        });
-      }, null, value, arguments.length > 1, null, true);
-    },
-
-    removeData(key) {
-      return this.each(function () {
-        data_user.remove(this, key);
-      });
-    },
-  });
-
-  jQuery.extend({
-    queue(elem, type, data) {
-      let queue;
-
-      if (elem) {
-        type = `${type || 'fx'}queue`;
-        queue = data_priv.get(elem, type);
-
-        // Speed up dequeue by getting out quickly if this is just a lookup
-        if (data) {
-          if (!queue || jQuery.isArray(data)) {
-            queue = data_priv.access(elem, type, jQuery.makeArray(data));
-          } else {
-            queue.push(data);
-          }
-        }
-        return queue || [];
-      }
-    },
-
-    dequeue(elem, type) {
-      type = type || 'fx';
-
-      const queue = jQuery.queue(elem, type);
-      let startLength = queue.length;
-      let fn = queue.shift();
-      const hooks = jQuery._queueHooks(elem, type);
-      const next = function () {
-        jQuery.dequeue(elem, type);
-      };
-
-      // If the fx queue is dequeued, always remove the progress sentinel
-      if (fn === 'inprogress') {
-        fn = queue.shift();
-        startLength--;
-      }
-
-      if (fn) {
-        // Add a progress sentinel to prevent the fx queue from being
-        // automatically dequeued
-        if (type === 'fx') {
-          queue.unshift('inprogress');
-        }
-
-        // clear up the last queue stop function
-        delete hooks.stop;
-        fn.call(elem, next, hooks);
-      }
-
-      if (!startLength && hooks) {
-        hooks.empty.fire();
-      }
-    },
-
-    // not intended for public consumption - generates a queueHooks object, or returns the current one
-    _queueHooks(elem, type) {
-      const key = `${type}queueHooks`;
-      return data_priv.get(elem, key) || data_priv.access(elem, key, {
-        empty: jQuery.Callbacks('once memory').add(() => {
-          data_priv.remove(elem, [`${type}queue`, key]);
-        }),
-      });
-    },
-  });
-
-  jQuery.fn.extend({
-    queue(type, data) {
-      let setter = 2;
-
-      if (typeof type !== 'string') {
-        data = type;
-        type = 'fx';
-        setter--;
-      }
-
-      if (arguments.length < setter) {
-        return jQuery.queue(this[0], type);
-      }
-
-      return data === undefined
-        ? this
-        : this.each(function () {
-          const queue = jQuery.queue(this, type, data);
-
-          // ensure a hooks for this queue
-          jQuery._queueHooks(this, type);
-
-          if (type === 'fx' && queue[0] !== 'inprogress') {
-            jQuery.dequeue(this, type);
-          }
-        });
-    },
-    dequeue(type) {
-      return this.each(function () {
-        jQuery.dequeue(this, type);
-      });
-    },
-    clearQueue(type) {
-      return this.queue(type || 'fx', []);
-    },
-    // Get a promise resolved when queues of a certain type
-    // are emptied (fx is the type by default)
-    promise(type, obj) {
-      let tmp;
-      let count = 1;
-      const defer = jQuery.Deferred();
-      const elements = this;
-      let i = this.length;
-      const resolve = function () {
-        if (!(--count)) {
-          defer.resolveWith(elements, [elements]);
-        }
-      };
-
-      if (typeof type !== 'string') {
-        obj = type;
-        type = undefined;
-      }
-      type = type || 'fx';
-
-      while (i--) {
-        tmp = data_priv.get(elements[i], `${type}queueHooks`);
-        if (tmp && tmp.empty) {
-          count++;
-          tmp.empty.add(resolve);
-        }
-      }
-      resolve();
-      return defer.promise(obj);
-    },
-  });
-  const pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
-
-  const cssExpand = ['Top', 'Right', 'Bottom', 'Left'];
-
-  const isHidden = function (elem, el) {
-    // isHidden might be called from jQuery#filter function;
-    // in that case, element will be second argument
-    elem = el || elem;
-    return jQuery.css(elem, 'display') === 'none' || !jQuery.contains(elem.ownerDocument, elem);
-  };
-
-  const rcheckableType = (/^(?:checkbox|radio)$/i);
-
-  (function () {
-    const fragment = document.createDocumentFragment();
-    const div = fragment.appendChild(document.createElement('div'));
-
-    // #11217 - WebKit loses check when the name is after the checked attribute
-    div.innerHTML = "<input type='radio' checked='checked' name='t'/>";
-
-    // Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
-    // old WebKit doesn't clone checked state correctly in fragments
-    support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
-
-    // Make sure textarea (and checkbox) defaultValue is properly cloned
-    // Support: IE9-IE11+
-    div.innerHTML = '<textarea>x</textarea>';
-    support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
-  }());
-  const strundefined = typeof undefined;
-
-  support.focusinBubbles = 'onfocusin' in window;
-
-  const
-    rkeyEvent = /^key/;
-  const rmouseEvent = /^(?:mouse|contextmenu)|click/;
-  const rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
-  const rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
-
-  function returnTrue() {
-    return true;
-  }
-
-  function returnFalse() {
-    return false;
-  }
-
-  function safeActiveElement() {
-    try {
-      return document.activeElement;
-    } catch (err) { }
-  }
-
-  /*
- * Helper functions for managing events -- not part of the public interface.
- * Props to Dean Edwards' addEvent library for many of the ideas.
- */
-  jQuery.event = {
-
-    global: {},
-
-    add(elem, types, handler, data, selector) {
-      let handleObjIn; let eventHandle; let tmp;
-      let events; let t; let handleObj;
-      let special; let handlers; let type; let namespaces; let origType;
-      const elemData = data_priv.get(elem);
-
-      // Don't attach events to noData or text/comment nodes (but allow plain objects)
-      if (!elemData) {
-        return;
-      }
-
-      // Caller can pass in an object of custom data in lieu of the handler
-      if (handler.handler) {
-        handleObjIn = handler;
-        handler = handleObjIn.handler;
-        selector = handleObjIn.selector;
-      }
-
-      // Make sure that the handler has a unique ID, used to find/remove it later
-      if (!handler.guid) {
-        handler.guid = jQuery.guid++;
-      }
-
-      // Init the element's event structure and main handler, if this is the first
-      if (!(events = elemData.events)) {
-        events = elemData.events = {};
-      }
-      if (!(eventHandle = elemData.handle)) {
-        eventHandle = elemData.handle = function (e) {
-          // Discard the second event of a jQuery.event.trigger() and
-          // when an event is called after a page has unloaded
-          return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type
-            ? jQuery.event.dispatch.apply(elem, arguments) : undefined;
-        };
-      }
-
-      // Handle multiple events separated by a space
-      types = (types || '').match(rnotwhite) || [''];
-      t = types.length;
-      while (t--) {
-        tmp = rtypenamespace.exec(types[t]) || [];
-        type = origType = tmp[1];
-        namespaces = (tmp[2] || '').split('.').sort();
-
-        // There *must* be a type, no attaching namespace-only handlers
-        if (!type) {
-          continue;
-        }
-
-        // If event changes its type, use the special event handlers for the changed type
-        special = jQuery.event.special[type] || {};
-
-        // If selector defined, determine special event api type, otherwise given type
-        type = (selector ? special.delegateType : special.bindType) || type;
-
-        // Update special based on newly reset type
-        special = jQuery.event.special[type] || {};
-
-        // handleObj is passed to all event handlers
-        handleObj = jQuery.extend({
-          type,
-          origType,
-          data,
-          handler,
-          guid: handler.guid,
-          selector,
-          needsContext: selector && jQuery.expr.match.needsContext.test(selector),
-          namespace: namespaces.join('.'),
-        }, handleObjIn);
-
-        // Init the event handler queue if we're the first
-        if (!(handlers = events[type])) {
-          handlers = events[type] = [];
-          handlers.delegateCount = 0;
-
-          // Only use addEventListener if the special events handler returns false
-          if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
-            if (elem.addEventListener) {
-              elem.addEventListener(type, eventHandle, false);
-            }
-          }
-        }
-
-        if (special.add) {
-          special.add.call(elem, handleObj);
-
-          if (!handleObj.handler.guid) {
-            handleObj.handler.guid = handler.guid;
-          }
-        }
-
-        // Add to the element's handler list, delegates in front
-        if (selector) {
-          handlers.splice(handlers.delegateCount++, 0, handleObj);
-        } else {
-          handlers.push(handleObj);
-        }
-
-        // Keep track of which events have ever been used, for event optimization
-        jQuery.event.global[type] = true;
-      }
-    },
-
-    // Detach an event or set of events from an element
-    remove(elem, types, handler, selector, mappedTypes) {
-      let j; let origCount; let tmp;
-      let events; let t; let handleObj;
-      let special; let handlers; let type; let namespaces; let origType;
-      const elemData = data_priv.hasData(elem) && data_priv.get(elem);
-
-      if (!elemData || !(events = elemData.events)) {
-        return;
-      }
-
-      // Once for each type.namespace in types; type may be omitted
-      types = (types || '').match(rnotwhite) || [''];
-      t = types.length;
-      while (t--) {
-        tmp = rtypenamespace.exec(types[t]) || [];
-        type = origType = tmp[1];
-        namespaces = (tmp[2] || '').split('.').sort();
-
-        // Unbind all events (on this namespace, if provided) for the element
-        if (!type) {
-          for (type in events) {
-            jQuery.event.remove(elem, type + types[t], handler, selector, true);
-          }
-          continue;
-        }
-
-        special = jQuery.event.special[type] || {};
-        type = (selector ? special.delegateType : special.bindType) || type;
-        handlers = events[type] || [];
-        tmp = tmp[2] && new RegExp(`(^|\\.)${namespaces.join('\\.(?:.*\\.|)')}(\\.|$)`);
-
-        // Remove matching events
-        origCount = j = handlers.length;
-        while (j--) {
-          handleObj = handlers[j];
-
-          if ((mappedTypes || origType === handleObj.origType)
-					&& (!handler || handler.guid === handleObj.guid)
-					&& (!tmp || tmp.test(handleObj.namespace))
-					&& (!selector || selector === handleObj.selector || selector === '**' && handleObj.selector)) {
-            handlers.splice(j, 1);
-
-            if (handleObj.selector) {
-              handlers.delegateCount--;
-            }
-            if (special.remove) {
-              special.remove.call(elem, handleObj);
-            }
-          }
-        }
-
-        // Remove generic event handler if we removed something and no more handlers exist
-        // (avoids potential for endless recursion during removal of special event handlers)
-        if (origCount && !handlers.length) {
-          if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
-            jQuery.removeEvent(elem, type, elemData.handle);
-          }
-
-          delete events[type];
-        }
-      }
-
-      // Remove the expando if it's no longer used
-      if (jQuery.isEmptyObject(events)) {
-        delete elemData.handle;
-        data_priv.remove(elem, 'events');
-      }
-    },
-
-    trigger(event, data, elem, onlyHandlers) {
-      let i; let cur; let tmp; let bubbleType; let ontype; let handle; let special;
-      const eventPath = [elem || document];
-      let type = hasOwn.call(event, 'type') ? event.type : event;
-      let namespaces = hasOwn.call(event, 'namespace') ? event.namespace.split('.') : [];
-
-      cur = tmp = elem = elem || document;
-
-      // Don't do events on text and comment nodes
-      if (elem.nodeType === 3 || elem.nodeType === 8) {
-        return;
-      }
-
-      // focus/blur morphs to focusin/out; ensure we're not firing them right now
-      if (rfocusMorph.test(type + jQuery.event.triggered)) {
-        return;
-      }
-
-      if (type.indexOf('.') >= 0) {
-        // Namespaced trigger; create a regexp to match event type in handle()
-        namespaces = type.split('.');
-        type = namespaces.shift();
-        namespaces.sort();
-      }
-      ontype = type.indexOf(':') < 0 && `on${type}`;
-
-      // Caller can pass in a jQuery.Event object, Object, or just an event type string
-      event = event[jQuery.expando]
-        ? event
-        : new jQuery.Event(type, typeof event === 'object' && event);
-
-      // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
-      event.isTrigger = onlyHandlers ? 2 : 3;
-      event.namespace = namespaces.join('.');
-      event.namespace_re = event.namespace
-        ? new RegExp(`(^|\\.)${namespaces.join('\\.(?:.*\\.|)')}(\\.|$)`)
-        : null;
-
-      // Clean up the event in case it is being reused
-      event.result = undefined;
-      if (!event.target) {
-        event.target = elem;
-      }
-
-      // Clone any incoming data and prepend the event, creating the handler arg list
-      data = data == null
-        ? [event]
-        : jQuery.makeArray(data, [event]);
-
-      // Allow special events to draw outside the lines
-      special = jQuery.event.special[type] || {};
-      if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
-        return;
-      }
-
-      // Determine event propagation path in advance, per W3C events spec (#9951)
-      // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
-      if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
-        bubbleType = special.delegateType || type;
-        if (!rfocusMorph.test(bubbleType + type)) {
-          cur = cur.parentNode;
-        }
-        for (; cur; cur = cur.parentNode) {
-          eventPath.push(cur);
-          tmp = cur;
-        }
-
-        // Only add window if we got to document (e.g., not plain obj or detached DOM)
-        if (tmp === (elem.ownerDocument || document)) {
-          eventPath.push(tmp.defaultView || tmp.parentWindow || window);
-        }
-      }
-
-      // Fire handlers on the event path
-      i = 0;
-      while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
-        event.type = i > 1
-          ? bubbleType
-          : special.bindType || type;
-
-        // jQuery handler
-        handle = (data_priv.get(cur, 'events') || {})[event.type] && data_priv.get(cur, 'handle');
-        if (handle) {
-          handle.apply(cur, data);
-        }
-
-        // Native handler
-        handle = ontype && cur[ontype];
-        if (handle && handle.apply && jQuery.acceptData(cur)) {
-          event.result = handle.apply(cur, data);
-          if (event.result === false) {
-            event.preventDefault();
-          }
-        }
-      }
-      event.type = type;
-
-      // If nobody prevented the default action, do it now
-      if (!onlyHandlers && !event.isDefaultPrevented()) {
-        if ((!special._default || special._default.apply(eventPath.pop(), data) === false)
-				&& jQuery.acceptData(elem)) {
-          // Call a native DOM method on the target with the same name name as the event.
-          // Don't do default actions on window, that's where global variables be (#6170)
-          if (ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem)) {
-            // Don't re-trigger an onFOO event when we call its FOO() method
-            tmp = elem[ontype];
-
-            if (tmp) {
-              elem[ontype] = null;
-            }
-
-            // Prevent re-triggering of the same event, since we already bubbled it above
-            jQuery.event.triggered = type;
-            elem[type]();
-            jQuery.event.triggered = undefined;
-
-            if (tmp) {
-              elem[ontype] = tmp;
-            }
-          }
-        }
-      }
-
-      return event.result;
-    },
-
-    dispatch(event) {
-      // Make a writable jQuery.Event from the native event object
-      event = jQuery.event.fix(event);
-
-      let i; let j; let ret; let matched; let handleObj;
-      let handlerQueue = [];
-      const args = slice.call(arguments);
-      const handlers = (data_priv.get(this, 'events') || {})[event.type] || [];
-      const special = jQuery.event.special[event.type] || {};
-
-      // Use the fix-ed jQuery.Event rather than the (read-only) native event
-      args[0] = event;
-      event.delegateTarget = this;
-
-      // Call the preDispatch hook for the mapped type, and let it bail if desired
-      if (special.preDispatch && special.preDispatch.call(this, event) === false) {
-        return;
-      }
-
-      // Determine handlers
-      handlerQueue = jQuery.event.handlers.call(this, event, handlers);
-
-      // Run delegates first; they may want to stop propagation beneath us
-      i = 0;
-      while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
-        event.currentTarget = matched.elem;
-
-        j = 0;
-        while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
-          // Triggered event must either 1) have no namespace, or
-          // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
-          if (!event.namespace_re || event.namespace_re.test(handleObj.namespace)) {
-            event.handleObj = handleObj;
-            event.data = handleObj.data;
-
-            ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler)
-              .apply(matched.elem, args);
-
-            if (ret !== undefined) {
-              if ((event.result = ret) === false) {
-                event.preventDefault();
-                event.stopPropagation();
-              }
-            }
-          }
-        }
-      }
-
-      // Call the postDispatch hook for the mapped type
-      if (special.postDispatch) {
-        special.postDispatch.call(this, event);
-      }
-
-      return event.result;
-    },
-
-    handlers(event, handlers) {
-      let i; let matches; let sel; let handleObj;
-      const handlerQueue = [];
-      const { delegateCount } = handlers;
-      let cur = event.target;
-
-      // Find delegate handlers
-      // Black-hole SVG <use> instance trees (#13180)
-      // Avoid non-left-click bubbling in Firefox (#3861)
-      if (delegateCount && cur.nodeType && (!event.button || event.type !== 'click')) {
-        for (; cur !== this; cur = cur.parentNode || this) {
-          // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
-          if (cur.disabled !== true || event.type !== 'click') {
-            matches = [];
-            for (i = 0; i < delegateCount; i++) {
-              handleObj = handlers[i];
-
-              // Don't conflict with Object.prototype properties (#13203)
-              sel = `${handleObj.selector} `;
-
-              if (matches[sel] === undefined) {
-                matches[sel] = handleObj.needsContext
-                  ? jQuery(sel, this).index(cur) >= 0
-                  : jQuery.find(sel, this, null, [cur]).length;
-              }
-              if (matches[sel]) {
-                matches.push(handleObj);
-              }
-            }
-            if (matches.length) {
-              handlerQueue.push({ elem: cur, handlers: matches });
-            }
-          }
-        }
-      }
-
-      // Add the remaining (directly-bound) handlers
-      if (delegateCount < handlers.length) {
-        handlerQueue.push({ elem: this, handlers: handlers.slice(delegateCount) });
-      }
-
-      return handlerQueue;
-    },
-
-    // Includes some event props shared by KeyEvent and MouseEvent
-    props: 'altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which'.split(' '),
-
-    fixHooks: {},
-
-    keyHooks: {
-      props: 'char charCode key keyCode'.split(' '),
-      filter(event, original) {
-        // Add which for key events
-        if (event.which == null) {
-          event.which = original.charCode != null ? original.charCode : original.keyCode;
-        }
-
-        return event;
-      },
-    },
-
-    mouseHooks: {
-      props: 'button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement'.split(' '),
-      filter(event, original) {
-        let eventDoc; let doc; let body;
-        const { button } = original;
-
-        // Calculate pageX/Y if missing and clientX/Y available
-        if (event.pageX == null && original.clientX != null) {
-          eventDoc = event.target.ownerDocument || document;
-          doc = eventDoc.documentElement;
-          body = eventDoc.body;
-
-          event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
-          event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
-        }
-
-        // Add which for click: 1 === left; 2 === middle; 3 === right
-        // Note: button is not normalized, so don't use it
-        if (!event.which && button !== undefined) {
-          event.which = (button & 1 ? 1 : (button & 2 ? 3 : (button & 4 ? 2 : 0)));
-        }
-
-        return event;
-      },
-    },
-
-    fix(event) {
-      if (event[jQuery.expando]) {
-        return event;
-      }
-
-      // Create a writable copy of the event object and normalize some properties
-      let i; let prop; let copy;
-      const { type } = event;
-      const originalEvent = event;
-      let fixHook = this.fixHooks[type];
-
-      if (!fixHook) {
-        this.fixHooks[type] = fixHook =				rmouseEvent.test(type) ? this.mouseHooks
-          : rkeyEvent.test(type) ? this.keyHooks
-            : {};
-      }
-      copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;
-
-      event = new jQuery.Event(originalEvent);
-
-      i = copy.length;
-      while (i--) {
-        prop = copy[i];
-        event[prop] = originalEvent[prop];
-      }
-
-      // Support: Cordova 2.5 (WebKit) (#13255)
-      // All events should have a target; Cordova deviceready doesn't
-      if (!event.target) {
-        event.target = document;
-      }
-
-      // Support: Safari 6.0+, Chrome < 28
-      // Target should not be a text node (#504, #13143)
-      if (event.target.nodeType === 3) {
-        event.target = event.target.parentNode;
-      }
-
-      return fixHook.filter ? fixHook.filter(event, originalEvent) : event;
-    },
-
-    special: {
-      load: {
-        // Prevent triggered image.load events from bubbling to window.load
-        noBubble: true,
-      },
-      focus: {
-        // Fire native event if possible so blur/focus sequence is correct
-        trigger() {
-          if (this !== safeActiveElement() && this.focus) {
-            this.focus();
-            return false;
-          }
-        },
-        delegateType: 'focusin',
-      },
-      blur: {
-        trigger() {
-          if (this === safeActiveElement() && this.blur) {
-            this.blur();
-            return false;
-          }
-        },
-        delegateType: 'focusout',
-      },
-      click: {
-        // For checkbox, fire native event so checked state will be right
-        trigger() {
-          if (this.type === 'checkbox' && this.click && jQuery.nodeName(this, 'input')) {
-            this.click();
-            return false;
-          }
-        },
-
-        // For cross-browser consistency, don't fire native .click() on links
-        _default(event) {
-          return jQuery.nodeName(event.target, 'a');
-        },
-      },
-
-      beforeunload: {
-        postDispatch(event) {
-          // Support: Firefox 20+
-          // Firefox doesn't alert if the returnValue field is not set.
-          if (event.result !== undefined) {
-            event.originalEvent.returnValue = event.result;
-          }
-        },
-      },
-    },
-
-    simulate(type, elem, event, bubble) {
-      // Piggyback on a donor event to simulate a different one.
-      // Fake originalEvent to avoid donor's stopPropagation, but if the
-      // simulated event prevents default then we do the same on the donor.
-      const e = jQuery.extend(
-        new jQuery.Event(),
-        event,
-        {
-          type,
-          isSimulated: true,
-          originalEvent: {},
-        },
-      );
-      if (bubble) {
-        jQuery.event.trigger(e, null, elem);
-      } else {
-        jQuery.event.dispatch.call(elem, e);
-      }
-      if (e.isDefaultPrevented()) {
-        event.preventDefault();
-      }
-    },
-  };
-
-  jQuery.removeEvent = function (elem, type, handle) {
-    if (elem.removeEventListener) {
-      elem.removeEventListener(type, handle, false);
-    }
-  };
-
-  jQuery.Event = function (src, props) {
-    // Allow instantiation without the 'new' keyword
-    if (!(this instanceof jQuery.Event)) {
-      return new jQuery.Event(src, props);
-    }
-
-    // Event object
-    if (src && src.type) {
-      this.originalEvent = src;
-      this.type = src.type;
-
-      // Events bubbling up the document may have been marked as prevented
-      // by a handler lower down the tree; reflect the correct value.
-      this.isDefaultPrevented = src.defaultPrevented
-				// Support: Android < 4.0
-				|| src.defaultPrevented === undefined
-				&& src.getPreventDefault && src.getPreventDefault()
-        ? returnTrue
-        : returnFalse;
-
-      // Event type
-    } else {
-      this.type = src;
-    }
-
-    // Put explicitly provided properties onto the event object
-    if (props) {
-      jQuery.extend(this, props);
-    }
-
-    // Create a timestamp if incoming event doesn't have one
-    this.timeStamp = src && src.timeStamp || jQuery.now();
-
-    // Mark it as fixed
-    this[jQuery.expando] = true;
-  };
-
-  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
-  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
-  jQuery.Event.prototype = {
-    isDefaultPrevented: returnFalse,
-    isPropagationStopped: returnFalse,
-    isImmediatePropagationStopped: returnFalse,
-
-    preventDefault() {
-      const e = this.originalEvent;
-
-      this.isDefaultPrevented = returnTrue;
-
-      if (e && e.preventDefault) {
-        e.preventDefault();
-      }
-    },
-    stopPropagation() {
-      const e = this.originalEvent;
-
-      this.isPropagationStopped = returnTrue;
-
-      if (e && e.stopPropagation) {
-        e.stopPropagation();
-      }
-    },
-    stopImmediatePropagation() {
-      this.isImmediatePropagationStopped = returnTrue;
-      this.stopPropagation();
-    },
-  };
-
-  // Create mouseenter/leave events using mouseover/out and event-time checks
-  // Support: Chrome 15+
-  jQuery.each({
-    mouseenter: 'mouseover',
-    mouseleave: 'mouseout',
-  }, (orig, fix) => {
-    jQuery.event.special[orig] = {
-      delegateType: fix,
-      bindType: fix,
-
-      handle(event) {
-        let ret;
-        const target = this;
-        const related = event.relatedTarget;
-        const { handleObj } = event;
-
-        // For mousenter/leave call the handler if related is outside the target.
-        // NB: No relatedTarget if the mouse left/entered the browser window
-        if (!related || (related !== target && !jQuery.contains(target, related))) {
-          event.type = handleObj.origType;
-          ret = handleObj.handler.apply(this, arguments);
-          event.type = fix;
-        }
-        return ret;
-      },
-    };
-  });
-
-  // Create "bubbling" focus and blur events
-  // Support: Firefox, Chrome, Safari
-  if (!support.focusinBubbles) {
-    jQuery.each({ focus: 'focusin', blur: 'focusout' }, (orig, fix) => {
-      // Attach a single capturing handler on the document while someone wants focusin/focusout
-      const handler = function (event) {
-        jQuery.event.simulate(fix, event.target, jQuery.event.fix(event), true);
-      };
-
-      jQuery.event.special[fix] = {
-        setup() {
-          const doc = this.ownerDocument || this;
-          const attaches = data_priv.access(doc, fix);
-
-          if (!attaches) {
-            doc.addEventListener(orig, handler, true);
-          }
-          data_priv.access(doc, fix, (attaches || 0) + 1);
-        },
-        teardown() {
-          const doc = this.ownerDocument || this;
-          const attaches = data_priv.access(doc, fix) - 1;
-
-          if (!attaches) {
-            doc.removeEventListener(orig, handler, true);
-            data_priv.remove(doc, fix);
-          } else {
-            data_priv.access(doc, fix, attaches);
-          }
-        },
-      };
-    });
-  }
-
-  jQuery.fn.extend({
-
-    on(types, selector, data, fn, /* INTERNAL */ one) {
-      let origFn; let
-        type;
-
-      // Types can be a map of types/handlers
-      if (typeof types === 'object') {
-        // ( types-Object, selector, data )
-        if (typeof selector !== 'string') {
-          // ( types-Object, data )
-          data = data || selector;
-          selector = undefined;
-        }
-        for (type in types) {
-          this.on(type, selector, data, types[type], one);
-        }
-        return this;
-      }
-
-      if (data == null && fn == null) {
-        // ( types, fn )
-        fn = selector;
-        data = selector = undefined;
-      } else if (fn == null) {
-        if (typeof selector === 'string') {
-          // ( types, selector, fn )
-          fn = data;
-          data = undefined;
-        } else {
-          // ( types, data, fn )
-          fn = data;
-          data = selector;
-          selector = undefined;
-        }
-      }
-      if (fn === false) {
-        fn = returnFalse;
-      } else if (!fn) {
-        return this;
-      }
-
-      if (one === 1) {
-        origFn = fn;
-        fn = function (event) {
-          // Can use an empty set, since event contains the info
-          jQuery().off(event);
-          return origFn.apply(this, arguments);
-        };
-        // Use same guid so caller can remove using origFn
-        fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
-      }
-      return this.each(function () {
-        jQuery.event.add(this, types, fn, data, selector);
-      });
-    },
-    one(types, selector, data, fn) {
-      return this.on(types, selector, data, fn, 1);
-    },
-    off(types, selector, fn) {
-      let handleObj; let
-        type;
-      if (types && types.preventDefault && types.handleObj) {
-        // ( event )  dispatched jQuery.Event
-        handleObj = types.handleObj;
-        jQuery(types.delegateTarget).off(
-          handleObj.namespace ? `${handleObj.origType}.${handleObj.namespace}` : handleObj.origType,
-          handleObj.selector,
-          handleObj.handler,
-        );
-        return this;
-      }
-      if (typeof types === 'object') {
-        // ( types-object [, selector] )
-        for (type in types) {
-          this.off(type, selector, types[type]);
-        }
-        return this;
-      }
-      if (selector === false || typeof selector === 'function') {
-        // ( types [, fn] )
-        fn = selector;
-        selector = undefined;
-      }
-      if (fn === false) {
-        fn = returnFalse;
-      }
-      return this.each(function () {
-        jQuery.event.remove(this, types, fn, selector);
-      });
-    },
-
-    trigger(type, data) {
-      return this.each(function () {
-        jQuery.event.trigger(type, data, this);
-      });
-    },
-    triggerHandler(type, data) {
-      const elem = this[0];
-      if (elem) {
-        return jQuery.event.trigger(type, data, elem, true);
-      }
-    },
-  });
-
-  const
-    rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi;
-  const rtagName = /<([\w:]+)/;
-  const rhtml = /<|&#?\w+;/;
-  const rnoInnerhtml = /<(?:script|style|link)/i;
-  // checked="checked" or checked
-  const rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i;
-  const rscriptType = /^$|\/(?:java|ecma)script/i;
-  const rscriptTypeMasked = /^true\/(.*)/;
-  const rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
-
-  // We have to close these tags to support XHTML (#13200)
-  const wrapMap = {
-
-    // Support: IE 9
-    option: [1, "<select multiple='multiple'>", '</select>'],
-
-    thead: [1, '<table>', '</table>'],
-    col: [2, '<table><colgroup>', '</colgroup></table>'],
-    tr: [2, '<table><tbody>', '</tbody></table>'],
-    td: [3, '<table><tbody><tr>', '</tr></tbody></table>'],
-
-    _default: [0, '', ''],
-  };
-
-  // Support: IE 9
-  wrapMap.optgroup = wrapMap.option;
-
-  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
-  wrapMap.th = wrapMap.td;
-
-  // Support: 1.x compatibility
-  // Manipulating tables requires a tbody
-  function manipulationTarget(elem, content) {
-    return jQuery.nodeName(elem, 'table')
-		&& jQuery.nodeName(content.nodeType !== 11 ? content : content.firstChild, 'tr')
-
-      ? elem.getElementsByTagName('tbody')[0]
-			|| elem.appendChild(elem.ownerDocument.createElement('tbody'))
-      : elem;
-  }
-
-  // Replace/restore the type attribute of script elements for safe DOM manipulation
-  function disableScript(elem) {
-    elem.type = `${elem.getAttribute('type') !== null}/${elem.type}`;
-    return elem;
-  }
-  function restoreScript(elem) {
-    const match = rscriptTypeMasked.exec(elem.type);
-
-    if (match) {
-      elem.type = match[1];
-    } else {
-      elem.removeAttribute('type');
-    }
-
-    return elem;
-  }
-
-  // Mark scripts as having already been evaluated
-  function setGlobalEval(elems, refElements) {
-    let i = 0;
-    const l = elems.length;
-
-    for (; i < l; i++) {
-      data_priv.set(
-        elems[i], 'globalEval', !refElements || data_priv.get(refElements[i], 'globalEval'),
-      );
-    }
-  }
-
-  function cloneCopyEvent(src, dest) {
-    let i; let l; let type; let pdataOld; let pdataCur; let udataOld; let udataCur; let
-      events;
-
-    if (dest.nodeType !== 1) {
-      return;
-    }
-
-    // 1. Copy private data: events, handlers, etc.
-    if (data_priv.hasData(src)) {
-      pdataOld = data_priv.access(src);
-      pdataCur = data_priv.set(dest, pdataOld);
-      events = pdataOld.events;
-
-      if (events) {
-        delete pdataCur.handle;
-        pdataCur.events = {};
-
-        for (type in events) {
-          for (i = 0, l = events[type].length; i < l; i++) {
-            jQuery.event.add(dest, type, events[type][i]);
-          }
-        }
-      }
-    }
-
-    // 2. Copy user data
-    if (data_user.hasData(src)) {
-      udataOld = data_user.access(src);
-      udataCur = jQuery.extend({}, udataOld);
-
-      data_user.set(dest, udataCur);
-    }
-  }
-
-  function getAll(context, tag) {
-    const ret = context.getElementsByTagName ? context.getElementsByTagName(tag || '*')
-      : context.querySelectorAll ? context.querySelectorAll(tag || '*')
-        : [];
-
-    return tag === undefined || tag && jQuery.nodeName(context, tag)
-      ? jQuery.merge([context], ret)
-      : ret;
-  }
-
-  // Support: IE >= 9
-  function fixInput(src, dest) {
-    const nodeName = dest.nodeName.toLowerCase();
-
-    // Fails to persist the checked state of a cloned checkbox or radio button.
-    if (nodeName === 'input' && rcheckableType.test(src.type)) {
-      dest.checked = src.checked;
-
-      // Fails to return the selected option to the default selected state when cloning options
-    } else if (nodeName === 'input' || nodeName === 'textarea') {
-      dest.defaultValue = src.defaultValue;
-    }
-  }
-
-  jQuery.extend({
-    clone(elem, dataAndEvents, deepDataAndEvents) {
-      let i; let l; let srcElements; let destElements;
-      const clone = elem.cloneNode(true);
-      const inPage = jQuery.contains(elem.ownerDocument, elem);
-
-      // Support: IE >= 9
-      // Fix Cloning issues
-      if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11)
-				&& !jQuery.isXMLDoc(elem)) {
-        // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
-        destElements = getAll(clone);
-        srcElements = getAll(elem);
-
-        for (i = 0, l = srcElements.length; i < l; i++) {
-          fixInput(srcElements[i], destElements[i]);
-        }
-      }
-
-      // Copy the events from the original to the clone
-      if (dataAndEvents) {
-        if (deepDataAndEvents) {
-          srcElements = srcElements || getAll(elem);
-          destElements = destElements || getAll(clone);
-
-          for (i = 0, l = srcElements.length; i < l; i++) {
-            cloneCopyEvent(srcElements[i], destElements[i]);
-          }
-        } else {
-          cloneCopyEvent(elem, clone);
-        }
-      }
-
-      // Preserve script evaluation history
-      destElements = getAll(clone, 'script');
-      if (destElements.length > 0) {
-        setGlobalEval(destElements, !inPage && getAll(elem, 'script'));
-      }
-
-      // Return the cloned set
-      return clone;
-    },
-
-    buildFragment(elems, context, scripts, selection) {
-      let elem; let tmp; let tag; let wrap; let contains; let j;
-      const fragment = context.createDocumentFragment();
-      const nodes = [];
-      let i = 0;
-      const l = elems.length;
-
-      for (; i < l; i++) {
-        elem = elems[i];
-
-        if (elem || elem === 0) {
-          // Add nodes directly
-          if (jQuery.type(elem) === 'object') {
-            // Support: QtWebKit
-            // jQuery.merge because push.apply(_, arraylike) throws
-            jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
-
-            // Convert non-html into a text node
-          } else if (!rhtml.test(elem)) {
-            nodes.push(context.createTextNode(elem));
-
-            // Convert html into DOM nodes
-          } else {
-            tmp = tmp || fragment.appendChild(context.createElement('div'));
-
-            // Deserialize a standard representation
-            tag = (rtagName.exec(elem) || ['', ''])[1].toLowerCase();
-            wrap = wrapMap[tag] || wrapMap._default;
-            tmp.innerHTML = wrap[1] + elem.replace(rxhtmlTag, '<$1></$2>') + wrap[2];
-
-            // Descend through wrappers to the right content
-            j = wrap[0];
-            while (j--) {
-              tmp = tmp.lastChild;
-            }
-
-            // Support: QtWebKit
-            // jQuery.merge because push.apply(_, arraylike) throws
-            jQuery.merge(nodes, tmp.childNodes);
-
-            // Remember the top-level container
-            tmp = fragment.firstChild;
-
-            // Fixes #12346
-            // Support: Webkit, IE
-            tmp.textContent = '';
-          }
-        }
-      }
-
-      // Remove wrapper from fragment
-      fragment.textContent = '';
-
-      i = 0;
-      while ((elem = nodes[i++])) {
-        // #4087 - If origin and destination elements are the same, and this is
-        // that element, do not do anything
-        if (selection && jQuery.inArray(elem, selection) !== -1) {
-          continue;
-        }
-
-        contains = jQuery.contains(elem.ownerDocument, elem);
-
-        // Append to fragment
-        tmp = getAll(fragment.appendChild(elem), 'script');
-
-        // Preserve script evaluation history
-        if (contains) {
-          setGlobalEval(tmp);
-        }
-
-        // Capture executables
-        if (scripts) {
-          j = 0;
-          while ((elem = tmp[j++])) {
-            if (rscriptType.test(elem.type || '')) {
-              scripts.push(elem);
-            }
-          }
-        }
-      }
-
-      return fragment;
-    },
-
-    cleanData(elems) {
-      let data; let elem; let events; let type; let key; let j;
-      const { special } = jQuery.event;
-      let i = 0;
-
-      for (; (elem = elems[i]) !== undefined; i++) {
-        if (jQuery.acceptData(elem)) {
-          key = elem[data_priv.expando];
-
-          if (key && (data = data_priv.cache[key])) {
-            events = Object.keys(data.events || {});
-            if (events.length) {
-              for (j = 0; (type = events[j]) !== undefined; j++) {
-                if (special[type]) {
-                  jQuery.event.remove(elem, type);
-
-                  // This is a shortcut to avoid jQuery.event.remove's overhead
-                } else {
-                  jQuery.removeEvent(elem, type, data.handle);
-                }
-              }
-            }
-            if (data_priv.cache[key]) {
-              // Discard any remaining `private` data
-              delete data_priv.cache[key];
-            }
-          }
-        }
-        // Discard any remaining `user` data
-        delete data_user.cache[elem[data_user.expando]];
-      }
-    },
-  });
-
-  jQuery.fn.extend({
-    text(value) {
-      return access(this, function (value) {
-        return value === undefined
-          ? jQuery.text(this)
-          : this.empty().each(function () {
-            if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
-              this.textContent = value;
-            }
-          });
-      }, null, value, arguments.length);
-    },
-
-    append() {
-      return this.domManip(arguments, function (elem) {
-        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
-          const target = manipulationTarget(this, elem);
-          target.appendChild(elem);
-        }
-      });
-    },
-
-    prepend() {
-      return this.domManip(arguments, function (elem) {
-        if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
-          const target = manipulationTarget(this, elem);
-          target.insertBefore(elem, target.firstChild);
-        }
-      });
-    },
-
-    before() {
-      return this.domManip(arguments, function (elem) {
-        if (this.parentNode) {
-          this.parentNode.insertBefore(elem, this);
-        }
-      });
-    },
-
-    after() {
-      return this.domManip(arguments, function (elem) {
-        if (this.parentNode) {
-          this.parentNode.insertBefore(elem, this.nextSibling);
-        }
-      });
-    },
-
-    remove(selector, keepData /* Internal Use Only */) {
-      let elem;
-      const elems = selector ? jQuery.filter(selector, this) : this;
-      let i = 0;
-
-      for (; (elem = elems[i]) != null; i++) {
-        if (!keepData && elem.nodeType === 1) {
-          jQuery.cleanData(getAll(elem));
-        }
-
-        if (elem.parentNode) {
-          if (keepData && jQuery.contains(elem.ownerDocument, elem)) {
-            setGlobalEval(getAll(elem, 'script'));
-          }
-          elem.parentNode.removeChild(elem);
-        }
-      }
-
-      return this;
-    },
-
-    empty() {
-      let elem;
-      let i = 0;
-
-      for (; (elem = this[i]) != null; i++) {
-        if (elem.nodeType === 1) {
-          // Prevent memory leaks
-          jQuery.cleanData(getAll(elem, false));
-
-          // Remove any remaining nodes
-          elem.textContent = '';
-        }
-      }
-
-      return this;
-    },
-
-    clone(dataAndEvents, deepDataAndEvents) {
-      dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
-      deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
-
-      return this.map(function () {
-        return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
-      });
-    },
-
-    html(value) {
-      return access(this, function (value) {
-        let elem = this[0] || {};
-        let i = 0;
-        const l = this.length;
-
-        if (value === undefined && elem.nodeType === 1) {
-          return elem.innerHTML;
-        }
-
-        // See if we can take a shortcut and just use innerHTML
-        if (typeof value === 'string' && !rnoInnerhtml.test(value)
-				&& !wrapMap[(rtagName.exec(value) || ['', ''])[1].toLowerCase()]) {
-          value = value.replace(rxhtmlTag, '<$1></$2>');
-
-          try {
-            for (; i < l; i++) {
-              elem = this[i] || {};
-
-              // Remove element nodes and prevent memory leaks
-              if (elem.nodeType === 1) {
-                jQuery.cleanData(getAll(elem, false));
-                elem.innerHTML = value;
-              }
-            }
-
-            elem = 0;
-
-            // If using innerHTML throws an exception, use the fallback method
-          } catch (e) {}
-        }
-
-        if (elem) {
-          this.empty().append(value);
-        }
-      }, null, value, arguments.length);
-    },
-
-    replaceWith() {
-      let arg = arguments[0];
-
-      // Make the changes, replacing each context element with the new content
-      this.domManip(arguments, function (elem) {
-        arg = this.parentNode;
-
-        jQuery.cleanData(getAll(this));
-
-        if (arg) {
-          arg.replaceChild(elem, this);
-        }
-      });
-
-      // Force removal if there was no new content (e.g., from empty arguments)
-      return arg && (arg.length || arg.nodeType) ? this : this.remove();
-    },
-
-    detach(selector) {
-      return this.remove(selector, true);
-    },
-
-    domManip(args, callback) {
-      // Flatten any nested arrays
-      args = concat.apply([], args);
-
-      let fragment; let first; let scripts; let hasScripts; let node; let doc;
-      let i = 0;
-      const l = this.length;
-      const set = this;
-      const iNoClone = l - 1;
-      const value = args[0];
-      const isFunction = jQuery.isFunction(value);
-
-      // We can't cloneNode fragments that contain checked, in WebKit
-      if (isFunction
-				|| (l > 1 && typeof value === 'string'
-					&& !support.checkClone && rchecked.test(value))) {
-        return this.each(function (index) {
-          const self = set.eq(index);
-          if (isFunction) {
-            args[0] = value.call(this, index, self.html());
-          }
-          self.domManip(args, callback);
-        });
-      }
-
-      if (l) {
-        fragment = jQuery.buildFragment(args, this[0].ownerDocument, false, this);
-        first = fragment.firstChild;
-
-        if (fragment.childNodes.length === 1) {
-          fragment = first;
-        }
-
-        if (first) {
-          scripts = jQuery.map(getAll(fragment, 'script'), disableScript);
-          hasScripts = scripts.length;
-
-          // Use the original fragment for the last item instead of the first because it can end up
-          // being emptied incorrectly in certain situations (#8070).
-          for (; i < l; i++) {
-            node = fragment;
-
-            if (i !== iNoClone) {
-              node = jQuery.clone(node, true, true);
-
-              // Keep references to cloned scripts for later restoration
-              if (hasScripts) {
-                // Support: QtWebKit
-                // jQuery.merge because push.apply(_, arraylike) throws
-                jQuery.merge(scripts, getAll(node, 'script'));
-              }
-            }
-
-            callback.call(this[i], node, i);
-          }
-
-          if (hasScripts) {
-            doc = scripts[scripts.length - 1].ownerDocument;
-
-            // Reenable scripts
-            jQuery.map(scripts, restoreScript);
-
-            // Evaluate executable scripts on first document insertion
-            for (i = 0; i < hasScripts; i++) {
-              node = scripts[i];
-              if (rscriptType.test(node.type || '')
-							&& !data_priv.access(node, 'globalEval') && jQuery.contains(doc, node)) {
-                if (node.src) {
-                  // Optional AJAX dependency, but won't run scripts if not present
-                  if (jQuery._evalUrl) {
-                    jQuery._evalUrl(node.src);
-                  }
-                } else {
-                  jQuery.globalEval(node.textContent.replace(rcleanScript, ''));
-                }
-              }
-            }
-          }
-        }
-      }
-
-      return this;
-    },
-  });
-
-  jQuery.each({
-    appendTo: 'append',
-    prependTo: 'prepend',
-    insertBefore: 'before',
-    insertAfter: 'after',
-    replaceAll: 'replaceWith',
-  }, (name, original) => {
-    jQuery.fn[name] = function (selector) {
-      let elems;
-      const ret = [];
-      const insert = jQuery(selector);
-      const last = insert.length - 1;
-      let i = 0;
-
-      for (; i <= last; i++) {
-        elems = i === last ? this : this.clone(true);
-        jQuery(insert[i])[original](elems);
-
-        // Support: QtWebKit
-        // .get() because push.apply(_, arraylike) throws
-        push.apply(ret, elems.get());
-      }
-
-      return this.pushStack(ret);
-    };
-  });
-
-  let iframe;
-  const elemdisplay = {};
-
-  /**
- * Retrieve the actual display of a element
- * @param {String} name nodeName of the element
- * @param {Object} doc Document object
- */
-  // Called only from within defaultDisplay
-  function actualDisplay(name, doc) {
-    const elem = jQuery(doc.createElement(name)).appendTo(doc.body);
-
-    // getDefaultComputedStyle might be reliably used only on attached element
-    const display = window.getDefaultComputedStyle
-
-    // Use of this method is a temporary fix (more like optmization) until something better comes along,
-    // since it was removed from specification and supported only in FF
-      ? window.getDefaultComputedStyle(elem[0]).display : jQuery.css(elem[0], 'display');
-
-    // We don't have any data stored on the element,
-    // so use "detach" method as fast way to get rid of the element
-    elem.detach();
-
-    return display;
-  }
-
-  /**
- * Try to determine the default display value of an element
- * @param {String} nodeName
- */
-  function defaultDisplay(nodeName) {
-    let doc = document;
-    let display = elemdisplay[nodeName];
-
-    if (!display) {
-      display = actualDisplay(nodeName, doc);
-
-      // If the simple way fails, read from inside an iframe
-      if (display === 'none' || !display) {
-        // Use the already-created iframe if possible
-        iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")).appendTo(doc.documentElement);
-
-        // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
-        doc = iframe[0].contentDocument;
-
-        // Support: IE
-        doc.write();
-        doc.close();
-
-        display = actualDisplay(nodeName, doc);
-        iframe.detach();
-      }
-
-      // Store the correct default display
-      elemdisplay[nodeName] = display;
-    }
-
-    return display;
-  }
-  const rmargin = (/^margin/);
-
-  const rnumnonpx = new RegExp(`^(${pnum})(?!px)[a-z%]+$`, 'i');
-
-  const getStyles = function (elem) {
-    return elem.ownerDocument.defaultView.getComputedStyle(elem, null);
-  };
-
-  function curCSS(elem, name, computed) {
-    let width; let minWidth; let maxWidth; let ret;
-    const { style } = elem;
-
-    computed = computed || getStyles(elem);
-
-    // Support: IE9
-    // getPropertyValue is only needed for .css('filter') in IE9, see #12537
-    if (computed) {
-      ret = computed.getPropertyValue(name) || computed[name];
-    }
-
-    if (computed) {
-      if (ret === '' && !jQuery.contains(elem.ownerDocument, elem)) {
-        ret = jQuery.style(elem, name);
-      }
-
-      // Support: iOS < 6
-      // A tribute to the "awesome hack by Dean Edwards"
-      // iOS < 6 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
-      // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
-      if (rnumnonpx.test(ret) && rmargin.test(name)) {
-        // Remember the original values
-        width = style.width;
-        minWidth = style.minWidth;
-        maxWidth = style.maxWidth;
-
-        // Put in the new values to get a computed value out
-        style.minWidth = style.maxWidth = style.width = ret;
-        ret = computed.width;
-
-        // Revert the changed values
-        style.width = width;
-        style.minWidth = minWidth;
-        style.maxWidth = maxWidth;
-      }
-    }
-
-    return ret !== undefined
-    // Support: IE
-    // IE returns zIndex value as an integer.
-      ? `${ret}`
-      : ret;
-  }
-
-  function addGetHookIf(conditionFn, hookFn) {
-    // Define the hook, we'll check on the first run if it's really needed.
-    return {
-      get() {
-        if (conditionFn()) {
-          // Hook not needed (or it's not possible to use it due to missing dependency),
-          // remove it.
-          // Since there are no other hooks for marginRight, remove the whole object.
-          delete this.get;
-          return;
-        }
-
-        // Hook needed; redefine it so that the support test is not executed again.
-
-        return (this.get = hookFn).apply(this, arguments);
-      },
-    };
-  }
-
-  (function () {
-    let pixelPositionVal; let boxSizingReliableVal;
-    // Support: Firefox, Android 2.3 (Prefixed box-sizing versions).
-    const divReset = 'padding:0;margin:0;border:0;display:block;-webkit-box-sizing:content-box;'
-			+ '-moz-box-sizing:content-box;box-sizing:content-box';
-    const docElem = document.documentElement;
-    const container = document.createElement('div');
-    const div = document.createElement('div');
-
-    div.style.backgroundClip = 'content-box';
-    div.cloneNode(true).style.backgroundClip = '';
-    support.clearCloneStyle = div.style.backgroundClip === 'content-box';
-
-    container.style.cssText = 'border:0;width:0;height:0;position:absolute;top:0;left:-9999px;'
-		+ 'margin-top:1px';
-    container.appendChild(div);
-
-    // Executing both pixelPosition & boxSizingReliable tests require only one layout
-    // so they're executed at the same time to save the second computation.
-    function computePixelPositionAndBoxSizingReliable() {
-      // Support: Firefox, Android 2.3 (Prefixed box-sizing versions).
-      div.style.cssText = '-webkit-box-sizing:border-box;-moz-box-sizing:border-box;'
-			+ 'box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;'
-			+ 'position:absolute;top:1%';
-      docElem.appendChild(container);
-
-      const divStyle = window.getComputedStyle(div, null);
-      pixelPositionVal = divStyle.top !== '1%';
-      boxSizingReliableVal = divStyle.width === '4px';
-
-      docElem.removeChild(container);
-    }
-
-    // Use window.getComputedStyle because jsdom on node.js will break without it.
-    if (window.getComputedStyle) {
-      jQuery.extend(support, {
-        pixelPosition() {
-          // This test is executed only once but we still do memoizing
-          // since we can use the boxSizingReliable pre-computing.
-          // No need to check if the test was already performed, though.
-          computePixelPositionAndBoxSizingReliable();
-          return pixelPositionVal;
-        },
-        boxSizingReliable() {
-          if (boxSizingReliableVal == null) {
-            computePixelPositionAndBoxSizingReliable();
-          }
-          return boxSizingReliableVal;
-        },
-        reliableMarginRight() {
-          // Support: Android 2.3
-          // Check if div with explicit width and no margin-right incorrectly
-          // gets computed margin-right based on width of container. (#3333)
-          // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
-          // This support function is only executed once so no memoizing is needed.
-          let ret;
-          const marginDiv = div.appendChild(document.createElement('div'));
-          marginDiv.style.cssText = div.style.cssText = divReset;
-          marginDiv.style.marginRight = marginDiv.style.width = '0';
-          div.style.width = '1px';
-          docElem.appendChild(container);
-
-          ret = !parseFloat(window.getComputedStyle(marginDiv, null).marginRight);
-
-          docElem.removeChild(container);
-
-          // Clean up the div for other support tests.
-          div.innerHTML = '';
-
-          return ret;
-        },
-      });
-    }
-  }());
-
-  // A method for quickly swapping in/out CSS properties to get correct calculations.
-  jQuery.swap = function (elem, options, callback, args) {
-    let ret; let name;
-    const old = {};
-
-    // Remember the old values, and insert the new ones
-    for (name in options) {
-      old[name] = elem.style[name];
-      elem.style[name] = options[name];
-    }
-
-    ret = callback.apply(elem, args || []);
-
-    // Revert the old values
-    for (name in options) {
-      elem.style[name] = old[name];
-    }
-
-    return ret;
-  };
-
-  const
-    // swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
-    // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
-    rdisplayswap = /^(none|table(?!-c[ea]).+)/;
-  const rnumsplit = new RegExp(`^(${pnum})(.*)$`, 'i');
-  const rrelNum = new RegExp(`^([+-])=(${pnum})`, 'i');
-
-  const cssShow = { position: 'absolute', visibility: 'hidden', display: 'block' };
-  const cssNormalTransform = {
-    letterSpacing: 0,
-    fontWeight: 400,
-  };
-
-  const cssPrefixes = ['Webkit', 'O', 'Moz', 'ms'];
-
-  // return a css property mapped to a potentially vendor prefixed property
-  function vendorPropName(style, name) {
-    // shortcut for names that are not vendor prefixed
-    if (name in style) {
-      return name;
-    }
-
-    // check for vendor prefixed names
-    const capName = name[0].toUpperCase() + name.slice(1);
-    const origName = name;
-    let i = cssPrefixes.length;
-
-    while (i--) {
-      name = cssPrefixes[i] + capName;
-      if (name in style) {
-        return name;
-      }
-    }
-
-    return origName;
-  }
-
-  function setPositiveNumber(elem, value, subtract) {
-    const matches = rnumsplit.exec(value);
-    return matches
-    // Guard against undefined "subtract", e.g., when used as in cssHooks
-      ? Math.max(0, matches[1] - (subtract || 0)) + (matches[2] || 'px')
-      : value;
-  }
-
-  function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
-    let i = extra === (isBorderBox ? 'border' : 'content')
-    // If we already have the right measurement, avoid augmentation
-      ? 4
-    // Otherwise initialize for horizontal or vertical properties
-      : name === 'width' ? 1 : 0;
-
-    let val = 0;
-
-    for (; i < 4; i += 2) {
-      // both box models exclude margin, so add it if we want it
-      if (extra === 'margin') {
-        val += jQuery.css(elem, extra + cssExpand[i], true, styles);
-      }
-
-      if (isBorderBox) {
-        // border-box includes padding, so remove it if we want content
-        if (extra === 'content') {
-          val -= jQuery.css(elem, `padding${cssExpand[i]}`, true, styles);
-        }
-
-        // at this point, extra isn't border nor margin, so remove border
-        if (extra !== 'margin') {
-          val -= jQuery.css(elem, `border${cssExpand[i]}Width`, true, styles);
-        }
-      } else {
-        // at this point, extra isn't content, so add padding
-        val += jQuery.css(elem, `padding${cssExpand[i]}`, true, styles);
-
-        // at this point, extra isn't content nor padding, so add border
-        if (extra !== 'padding') {
-          val += jQuery.css(elem, `border${cssExpand[i]}Width`, true, styles);
-        }
-      }
-    }
-
-    return val;
-  }
-
-  function getWidthOrHeight(elem, name, extra) {
-    // Start with offset property, which is equivalent to the border-box value
-    let valueIsBorderBox = true;
-    let val = name === 'width' ? elem.offsetWidth : elem.offsetHeight;
-    const styles = getStyles(elem);
-    const isBorderBox = jQuery.css(elem, 'boxSizing', false, styles) === 'border-box';
-
-    // some non-html elements return undefined for offsetWidth, so check for null/undefined
-    // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
-    // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
-    if (val <= 0 || val == null) {
-      // Fall back to computed then uncomputed css if necessary
-      val = curCSS(elem, name, styles);
-      if (val < 0 || val == null) {
-        val = elem.style[name];
-      }
-
-      // Computed unit is not pixels. Stop here and return.
-      if (rnumnonpx.test(val)) {
-        return val;
-      }
-
-      // we need the check for style in case a browser which returns unreliable values
-      // for getComputedStyle silently falls back to the reliable elem.style
-      valueIsBorderBox = isBorderBox
-			&& (support.boxSizingReliable() || val === elem.style[name]);
-
-      // Normalize "", auto, and prepare for extra
-      val = parseFloat(val) || 0;
-    }
-
-    // use the active box-sizing model to add/subtract irrelevant styles
-    return `${val
-		+ augmentWidthOrHeight(
-		  elem,
-		  name,
-		  extra || (isBorderBox ? 'border' : 'content'),
-		  valueIsBorderBox,
-		  styles,
-		)
-	  }px`;
-  }
-
-  function showHide(elements, show) {
-    let display; let elem; let hidden;
-    const values = [];
-    let index = 0;
-    const { length } = elements;
-
-    for (; index < length; index++) {
-      elem = elements[index];
-      if (!elem.style) {
-        continue;
-      }
-
-      values[index] = data_priv.get(elem, 'olddisplay');
-      display = elem.style.display;
-      if (show) {
-        // Reset the inline display of this element to learn if it is
-        // being hidden by cascaded rules or not
-        if (!values[index] && display === 'none') {
-          elem.style.display = '';
-        }
-
-        // Set elements which have been overridden with display: none
-        // in a stylesheet to whatever the default browser style is
-        // for such an element
-        if (elem.style.display === '' && isHidden(elem)) {
-          values[index] = data_priv.access(elem, 'olddisplay', defaultDisplay(elem.nodeName));
-        }
-      } else if (!values[index]) {
-        hidden = isHidden(elem);
-
-        if (display && display !== 'none' || !hidden) {
-          data_priv.set(elem, 'olddisplay', hidden ? display : jQuery.css(elem, 'display'));
-        }
-      }
-    }
-
-    // Set the display of most of the elements in a second loop
-    // to avoid the constant reflow
-    for (index = 0; index < length; index++) {
-      elem = elements[index];
-      if (!elem.style) {
-        continue;
-      }
-      if (!show || elem.style.display === 'none' || elem.style.display === '') {
-        elem.style.display = show ? values[index] || '' : 'none';
-      }
-    }
-
-    return elements;
-  }
-
-  jQuery.extend({
-    // Add in style property hooks for overriding the default
-    // behavior of getting and setting a style property
-    cssHooks: {
-      opacity: {
-        get(elem, computed) {
-          if (computed) {
-            // We should always get a number back from opacity
-            const ret = curCSS(elem, 'opacity');
-            return ret === '' ? '1' : ret;
-          }
-        },
-      },
-    },
-
-    // Don't automatically add "px" to these possibly-unitless properties
-    cssNumber: {
-      columnCount: true,
-      fillOpacity: true,
-      fontWeight: true,
-      lineHeight: true,
-      opacity: true,
-      order: true,
-      orphans: true,
-      widows: true,
-      zIndex: true,
-      zoom: true,
-    },
-
-    // Add in properties whose names you wish to fix before
-    // setting or getting the value
-    cssProps: {
-      // normalize float css property
-      float: 'cssFloat',
-    },
-
-    // Get and set the style property on a DOM Node
-    style(elem, name, value, extra) {
-      // Don't set styles on text and comment nodes
-      if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
-        return;
-      }
-
-      // Make sure that we're working with the right name
-      let ret; let type; let hooks;
-      const origName = jQuery.camelCase(name);
-      const { style } = elem;
-
-      name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(style, origName));
-
-      // gets hook for the prefixed version
-      // followed by the unprefixed version
-      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
-
-      // Check if we're setting a value
-      if (value !== undefined) {
-        type = typeof value;
-
-        // convert relative number strings (+= or -=) to relative numbers. #7345
-        if (type === 'string' && (ret = rrelNum.exec(value))) {
-          value = (ret[1] + 1) * ret[2] + parseFloat(jQuery.css(elem, name));
-          // Fixes bug #9237
-          type = 'number';
-        }
-
-        // Make sure that null and NaN values aren't set. See: #7116
-        if (value == null || value !== value) {
-          return;
-        }
-
-        // If a number was passed in, add 'px' to the (except for certain CSS properties)
-        if (type === 'number' && !jQuery.cssNumber[origName]) {
-          value += 'px';
-        }
-
-        // Fixes #8908, it can be done more correctly by specifying setters in cssHooks,
-        // but it would mean to define eight (for every problematic property) identical functions
-        if (!support.clearCloneStyle && value === '' && name.indexOf('background') === 0) {
-          style[name] = 'inherit';
-        }
-
-        // If a hook was provided, use that value, otherwise just set the specified value
-        if (!hooks || !('set' in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
-          // Support: Chrome, Safari
-          // Setting style to blank string required to delete "style: x !important;"
-          style[name] = '';
-          style[name] = value;
-        }
-      } else {
-        // If a hook was provided get the non-computed value from there
-        if (hooks && 'get' in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
-          return ret;
-        }
-
-        // Otherwise just get the value from the style object
-        return style[name];
-      }
-    },
-
-    css(elem, name, extra, styles) {
-      let val; let num; let hooks;
-      const origName = jQuery.camelCase(name);
-
-      // Make sure that we're working with the right name
-      name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(elem.style, origName));
-
-      // gets hook for the prefixed version
-      // followed by the unprefixed version
-      hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
-
-      // If a hook was provided get the computed value from there
-      if (hooks && 'get' in hooks) {
-        val = hooks.get(elem, true, extra);
-      }
-
-      // Otherwise, if a way to get the computed value exists, use that
-      if (val === undefined) {
-        val = curCSS(elem, name, styles);
-      }
-
-      // convert "normal" to computed value
-      if (val === 'normal' && name in cssNormalTransform) {
-        val = cssNormalTransform[name];
-      }
-
-      // Return, converting to number if forced or a qualifier was provided and val looks numeric
-      if (extra === '' || extra) {
-        num = parseFloat(val);
-        return extra === true || jQuery.isNumeric(num) ? num || 0 : val;
-      }
-      return val;
-    },
-  });
-
-  jQuery.each(['height', 'width'], (i, name) => {
-    jQuery.cssHooks[name] = {
-      get(elem, computed, extra) {
-        if (computed) {
-          // certain elements can have dimension info if we invisibly show them
-          // however, it must have a current display style that would benefit from this
-          return elem.offsetWidth === 0 && rdisplayswap.test(jQuery.css(elem, 'display'))
-            ? jQuery.swap(elem, cssShow, () => getWidthOrHeight(elem, name, extra))
-            : getWidthOrHeight(elem, name, extra);
-        }
-      },
-
-      set(elem, value, extra) {
-        const styles = extra && getStyles(elem);
-        return setPositiveNumber(elem, value, extra
-          ? augmentWidthOrHeight(
-            elem,
-            name,
-            extra,
-            jQuery.css(elem, 'boxSizing', false, styles) === 'border-box',
-            styles,
-          ) : 0);
-      },
-    };
-  });
-
-  // Support: Android 2.3
-  jQuery.cssHooks.marginRight = addGetHookIf(support.reliableMarginRight,
-    (elem, computed) => {
-      if (computed) {
-        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
-        // Work around by temporarily setting element display to inline-block
-        return jQuery.swap(elem, { display: 'inline-block' },
-          curCSS, [elem, 'marginRight']);
-      }
-    });
-
-  // These hooks are used by animate to expand properties
-  jQuery.each({
-    margin: '',
-    padding: '',
-    border: 'Width',
-  }, (prefix, suffix) => {
-    jQuery.cssHooks[prefix + suffix] = {
-      expand(value) {
-        let i = 0;
-        const expanded = {};
-
-        // assumes a single number if not a string
-        const parts = typeof value === 'string' ? value.split(' ') : [value];
-
-        for (; i < 4; i++) {
-          expanded[prefix + cssExpand[i] + suffix] =					parts[i] || parts[i - 2] || parts[0];
-        }
-
-        return expanded;
-      },
-    };
-
-    if (!rmargin.test(prefix)) {
-      jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
-    }
-  });
-
-  jQuery.fn.extend({
-    css(name, value) {
-      return access(this, (elem, name, value) => {
-        let styles; let len;
-        const map = {};
-        let i = 0;
-
-        if (jQuery.isArray(name)) {
-          styles = getStyles(elem);
-          len = name.length;
-
-          for (; i < len; i++) {
-            map[name[i]] = jQuery.css(elem, name[i], false, styles);
-          }
-
-          return map;
-        }
-
-        return value !== undefined
-          ? jQuery.style(elem, name, value)
-          : jQuery.css(elem, name);
-      }, name, value, arguments.length > 1);
-    },
-    show() {
-      return showHide(this, true);
-    },
-    hide() {
-      return showHide(this);
-    },
-    toggle(state) {
-      if (typeof state === 'boolean') {
-        return state ? this.show() : this.hide();
-      }
-
-      return this.each(function () {
-        if (isHidden(this)) {
-          jQuery(this).show();
-        } else {
-          jQuery(this).hide();
-        }
-      });
-    },
-  });
-
-  function Tween(elem, options, prop, end, easing) {
-    return new Tween.prototype.init(elem, options, prop, end, easing);
-  }
-  jQuery.Tween = Tween;
-
-  Tween.prototype = {
-    constructor: Tween,
-    init(elem, options, prop, end, easing, unit) {
-      this.elem = elem;
-      this.prop = prop;
-      this.easing = easing || 'swing';
-      this.options = options;
-      this.start = this.now = this.cur();
-      this.end = end;
-      this.unit = unit || (jQuery.cssNumber[prop] ? '' : 'px');
-    },
-    cur() {
-      const hooks = Tween.propHooks[this.prop];
-
-      return hooks && hooks.get
-        ? hooks.get(this)
-        : Tween.propHooks._default.get(this);
-    },
-    run(percent) {
-      let eased;
-      const hooks = Tween.propHooks[this.prop];
-
-      if (this.options.duration) {
-        this.pos = eased = jQuery.easing[this.easing](
-          percent, this.options.duration * percent, 0, 1, this.options.duration,
-        );
-      } else {
-        this.pos = eased = percent;
-      }
-      this.now = (this.end - this.start) * eased + this.start;
-
-      if (this.options.step) {
-        this.options.step.call(this.elem, this.now, this);
-      }
-
-      if (hooks && hooks.set) {
-        hooks.set(this);
-      } else {
-        Tween.propHooks._default.set(this);
-      }
-      return this;
-    },
-  };
-
-  Tween.prototype.init.prototype = Tween.prototype;
-
-  Tween.propHooks = {
-    _default: {
-      get(tween) {
-        let result;
-
-        if (tween.elem[tween.prop] != null
-				&& (!tween.elem.style || tween.elem.style[tween.prop] == null)) {
-          return tween.elem[tween.prop];
-        }
-
-        // passing an empty string as a 3rd parameter to .css will automatically
-        // attempt a parseFloat and fallback to a string if the parse fails
-        // so, simple values such as "10px" are parsed to Float.
-        // complex values such as "rotate(1rad)" are returned as is.
-        result = jQuery.css(tween.elem, tween.prop, '');
-        // Empty strings, null, undefined and "auto" are converted to 0.
-        return !result || result === 'auto' ? 0 : result;
-      },
-      set(tween) {
-        // use step hook for back compat - use cssHook if its there - use .style if its
-        // available and use plain properties where available
-        if (jQuery.fx.step[tween.prop]) {
-          jQuery.fx.step[tween.prop](tween);
-        } else if (tween.elem.style && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {
-          jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
-        } else {
-          tween.elem[tween.prop] = tween.now;
-        }
-      },
-    },
-  };
-
-  // Support: IE9
-  // Panic based approach to setting things on disconnected nodes
-
-  Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
-    set(tween) {
-      if (tween.elem.nodeType && tween.elem.parentNode) {
-        tween.elem[tween.prop] = tween.now;
-      }
-    },
-  };
-
-  jQuery.easing = {
-    linear(p) {
-      return p;
-    },
-    swing(p) {
-      return 0.5 - Math.cos(p * Math.PI) / 2;
-    },
-  };
-
-  jQuery.fx = Tween.prototype.init;
-
-  // Back Compat <1.8 extension point
-  jQuery.fx.step = {};
-
-  let
-    fxNow; let timerId;
-  const rfxtypes = /^(?:toggle|show|hide)$/;
-  const rfxnum = new RegExp(`^(?:([+-])=|)(${pnum})([a-z%]*)$`, 'i');
-  const rrun = /queueHooks$/;
-  const animationPrefilters = [defaultPrefilter];
-  const tweeners = {
-    '*': [function (prop, value) {
-      const tween = this.createTween(prop, value);
-      const target = tween.cur();
-      let parts = rfxnum.exec(value);
-      let unit = parts && parts[3] || (jQuery.cssNumber[prop] ? '' : 'px');
-
-      // Starting value computation is required for potential unit mismatches
-      let start = (jQuery.cssNumber[prop] || unit !== 'px' && +target)
-					&& rfxnum.exec(jQuery.css(tween.elem, prop));
-      let scale = 1;
-      let maxIterations = 20;
-
-      if (start && start[3] !== unit) {
-        // Trust units reported by jQuery.css
-        unit = unit || start[3];
-
-        // Make sure we update the tween properties later on
-        parts = parts || [];
-
-        // Iteratively approximate from a nonzero starting point
-        start = +target || 1;
-
-        do {
-          // If previous iteration zeroed out, double until we get *something*
-          // Use a string for doubling factor so we don't accidentally see scale as unchanged below
-          scale = scale || '.5';
-
-          // Adjust and apply
-          start /= scale;
-          jQuery.style(tween.elem, prop, start + unit);
-
-          // Update scale, tolerating zero or NaN from tween.cur()
-          // And breaking the loop if scale is unchanged or perfect, or if we've just had enough
-        } while (scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations);
-      }
-
-      // Update tween properties
-      if (parts) {
-        start = tween.start = +start || +target || 0;
-        tween.unit = unit;
-        // If a +=/-= token was provided, we're doing a relative animation
-        tween.end = parts[1]
-          ? start + (parts[1] + 1) * parts[2]
-          : +parts[2];
-      }
-
-      return tween;
-    }],
-  };
-
-  // Animations created synchronously will run synchronously
-  function createFxNow() {
-    setTimeout(() => {
-      fxNow = undefined;
-    });
-    return (fxNow = jQuery.now());
-  }
-
-  // Generate parameters to create a standard animation
-  function genFx(type, includeWidth) {
-    let which;
-    let i = 0;
-    const attrs = { height: type };
-
-    // if we include width, step value is 1 to do all cssExpand values,
-    // if we don't include width, step value is 2 to skip over Left and Right
-    includeWidth = includeWidth ? 1 : 0;
-    for (; i < 4; i += 2 - includeWidth) {
-      which = cssExpand[i];
-      attrs[`margin${which}`] = attrs[`padding${which}`] = type;
-    }
-
-    if (includeWidth) {
-      attrs.opacity = attrs.width = type;
-    }
-
-    return attrs;
-  }
-
-  function createTween(value, prop, animation) {
-    let tween;
-    const collection = (tweeners[prop] || []).concat(tweeners['*']);
-    let index = 0;
-    const { length } = collection;
-    for (; index < length; index++) {
-      if ((tween = collection[index].call(animation, prop, value))) {
-        // we're done with this property
-        return tween;
-      }
-    }
-  }
-
-  function defaultPrefilter(elem, props, opts) {
-    /* jshint validthis: true */
-    let prop; let value; let toggle; let tween; let hooks; let oldfire; let display;
-    const anim = this;
-    const orig = {};
-    const { style } = elem;
-    let hidden = elem.nodeType && isHidden(elem);
-    let dataShow = data_priv.get(elem, 'fxshow');
-
-    // handle queue: false promises
-    if (!opts.queue) {
-      hooks = jQuery._queueHooks(elem, 'fx');
-      if (hooks.unqueued == null) {
-        hooks.unqueued = 0;
-        oldfire = hooks.empty.fire;
-        hooks.empty.fire = function () {
-          if (!hooks.unqueued) {
-            oldfire();
-          }
-        };
-      }
-      hooks.unqueued++;
-
-      anim.always(() => {
-        // doing this makes sure that the complete handler will be called
-        // before this completes
-        anim.always(() => {
-          hooks.unqueued--;
-          if (!jQuery.queue(elem, 'fx').length) {
-            hooks.empty.fire();
-          }
-        });
-      });
-    }
-
-    // height/width overflow pass
-    if (elem.nodeType === 1 && ('height' in props || 'width' in props)) {
-      // Make sure that nothing sneaks out
-      // Record all 3 overflow attributes because IE9-10 do not
-      // change the overflow attribute when overflowX and
-      // overflowY are set to the same value
-      opts.overflow = [style.overflow, style.overflowX, style.overflowY];
-
-      // Set display property to inline-block for height/width
-      // animations on inline elements that are having width/height animated
-      display = jQuery.css(elem, 'display');
-      // Get default display if display is currently "none"
-      if (display === 'none') {
-        display = defaultDisplay(elem.nodeName);
-      }
-      if (display === 'inline'
-				&& jQuery.css(elem, 'float') === 'none') {
-        style.display = 'inline-block';
-      }
-    }
-
-    if (opts.overflow) {
-      style.overflow = 'hidden';
-      anim.always(() => {
-        style.overflow = opts.overflow[0];
-        style.overflowX = opts.overflow[1];
-        style.overflowY = opts.overflow[2];
-      });
-    }
-
-    // show/hide pass
-    for (prop in props) {
-      value = props[prop];
-      if (rfxtypes.exec(value)) {
-        delete props[prop];
-        toggle = toggle || value === 'toggle';
-        if (value === (hidden ? 'hide' : 'show')) {
-          // If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden
-          if (value === 'show' && dataShow && dataShow[prop] !== undefined) {
-            hidden = true;
-          } else {
-            continue;
-          }
-        }
-        orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
-      }
-    }
-
-    if (!jQuery.isEmptyObject(orig)) {
-      if (dataShow) {
-        if ('hidden' in dataShow) {
-          hidden = dataShow.hidden;
-        }
-      } else {
-        dataShow = data_priv.access(elem, 'fxshow', {});
-      }
-
-      // store state if its toggle - enables .stop().toggle() to "reverse"
-      if (toggle) {
-        dataShow.hidden = !hidden;
-      }
-      if (hidden) {
-        jQuery(elem).show();
-      } else {
-        anim.done(() => {
-          jQuery(elem).hide();
-        });
-      }
-      anim.done(() => {
-        let prop;
-
-        data_priv.remove(elem, 'fxshow');
-        for (prop in orig) {
-          jQuery.style(elem, prop, orig[prop]);
-        }
-      });
-      for (prop in orig) {
-        tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
-
-        if (!(prop in dataShow)) {
-          dataShow[prop] = tween.start;
-          if (hidden) {
-            tween.end = tween.start;
-            tween.start = prop === 'width' || prop === 'height' ? 1 : 0;
-          }
-        }
-      }
-    }
-  }
-
-  function propFilter(props, specialEasing) {
-    let index; let name; let easing; let value; let
-      hooks;
-
-    // camelCase, specialEasing and expand cssHook pass
-    for (index in props) {
-      name = jQuery.camelCase(index);
-      easing = specialEasing[name];
-      value = props[index];
-      if (jQuery.isArray(value)) {
-        easing = value[1];
-        value = props[index] = value[0];
-      }
-
-      if (index !== name) {
-        props[name] = value;
-        delete props[index];
-      }
-
-      hooks = jQuery.cssHooks[name];
-      if (hooks && 'expand' in hooks) {
-        value = hooks.expand(value);
-        delete props[name];
-
-        // not quite $.extend, this wont overwrite keys already present.
-        // also - reusing 'index' from above because we have the correct "name"
-        for (index in value) {
-          if (!(index in props)) {
-            props[index] = value[index];
-            specialEasing[index] = easing;
-          }
-        }
-      } else {
-        specialEasing[name] = easing;
-      }
-    }
-  }
-
-  function Animation(elem, properties, options) {
-    let result;
-    let stopped;
-    let index = 0;
-    const { length } = animationPrefilters;
-    const deferred = jQuery.Deferred().always(() => {
-      // don't match elem in the :animated selector
-      delete tick.elem;
-    });
-    var tick = function () {
-      if (stopped) {
-        return false;
-      }
-      const currentTime = fxNow || createFxNow();
-      const remaining = Math.max(0, animation.startTime + animation.duration - currentTime);
-      // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
-      const temp = remaining / animation.duration || 0;
-      const percent = 1 - temp;
-      let index = 0;
-      const { length } = animation.tweens;
-
-      for (; index < length; index++) {
-        animation.tweens[index].run(percent);
-      }
-
-      deferred.notifyWith(elem, [animation, percent, remaining]);
-
-      if (percent < 1 && length) {
-        return remaining;
-      }
-      deferred.resolveWith(elem, [animation]);
-      return false;
-    };
-    var animation = deferred.promise({
-      elem,
-      props: jQuery.extend({}, properties),
-      opts: jQuery.extend(true, { specialEasing: {} }, options),
-      originalProperties: properties,
-      originalOptions: options,
-      startTime: fxNow || createFxNow(),
-      duration: options.duration,
-      tweens: [],
-      createTween(prop, end) {
-        const tween = jQuery.Tween(elem, animation.opts, prop, end,
-          animation.opts.specialEasing[prop] || animation.opts.easing);
-        animation.tweens.push(tween);
-        return tween;
-      },
-      stop(gotoEnd) {
-        let index = 0;
-        // if we are going to the end, we want to run all the tweens
-        // otherwise we skip this part
-        const length = gotoEnd ? animation.tweens.length : 0;
-        if (stopped) {
-          return this;
-        }
-        stopped = true;
-        for (; index < length; index++) {
-          animation.tweens[index].run(1);
-        }
-
-        // resolve when we played the last frame
-        // otherwise, reject
-        if (gotoEnd) {
-          deferred.resolveWith(elem, [animation, gotoEnd]);
-        } else {
-          deferred.rejectWith(elem, [animation, gotoEnd]);
-        }
-        return this;
-      },
-    });
-    const { props } = animation;
-
-    propFilter(props, animation.opts.specialEasing);
-
-    for (; index < length; index++) {
-      result = animationPrefilters[index].call(animation, elem, props, animation.opts);
-      if (result) {
-        return result;
-      }
-    }
-
-    jQuery.map(props, createTween, animation);
-
-    if (jQuery.isFunction(animation.opts.start)) {
-      animation.opts.start.call(elem, animation);
-    }
-
-    jQuery.fx.timer(
-      jQuery.extend(tick, {
-        elem,
-        anim: animation,
-        queue: animation.opts.queue,
-      }),
-    );
-
-    // attach callbacks from options
-    return animation.progress(animation.opts.progress)
-      .done(animation.opts.done, animation.opts.complete)
-      .fail(animation.opts.fail)
-      .always(animation.opts.always);
-  }
-
-  jQuery.Animation = jQuery.extend(Animation, {
-
-    tweener(props, callback) {
-      if (jQuery.isFunction(props)) {
-        callback = props;
-        props = ['*'];
-      } else {
-        props = props.split(' ');
-      }
-
-      let prop;
-      let index = 0;
-      const { length } = props;
-
-      for (; index < length; index++) {
-        prop = props[index];
-        tweeners[prop] = tweeners[prop] || [];
-        tweeners[prop].unshift(callback);
-      }
-    },
-
-    prefilter(callback, prepend) {
-      if (prepend) {
-        animationPrefilters.unshift(callback);
-      } else {
-        animationPrefilters.push(callback);
-      }
-    },
-  });
-
-  jQuery.speed = function (speed, easing, fn) {
-    const opt = speed && typeof speed === 'object' ? jQuery.extend({}, speed) : {
-      complete: fn || !fn && easing
-			|| jQuery.isFunction(speed) && speed,
-      duration: speed,
-      easing: fn && easing || easing && !jQuery.isFunction(easing) && easing,
-    };
-
-    opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === 'number' ? opt.duration
-      : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
-
-    // normalize opt.queue - true/undefined/null -> "fx"
-    if (opt.queue == null || opt.queue === true) {
-      opt.queue = 'fx';
-    }
-
-    // Queueing
-    opt.old = opt.complete;
-
-    opt.complete = function () {
-      if (jQuery.isFunction(opt.old)) {
-        opt.old.call(this);
-      }
-
-      if (opt.queue) {
-        jQuery.dequeue(this, opt.queue);
-      }
-    };
-
-    return opt;
-  };
-
-  jQuery.fn.extend({
-    fadeTo(speed, to, easing, callback) {
-      // show any hidden elements after setting opacity to 0
-      return this.filter(isHidden).css('opacity', 0).show()
-
-      // animate to the value specified
-        .end()
-        .animate({ opacity: to }, speed, easing, callback);
-    },
-    animate(prop, speed, easing, callback) {
-      const empty = jQuery.isEmptyObject(prop);
-      const optall = jQuery.speed(speed, easing, callback);
-      const doAnimation = function () {
-        // Operate on a copy of prop so per-property easing won't be lost
-        const anim = Animation(this, jQuery.extend({}, prop), optall);
-
-        // Empty animations, or finishing resolves immediately
-        if (empty || data_priv.get(this, 'finish')) {
-          anim.stop(true);
-        }
-      };
-      doAnimation.finish = doAnimation;
-
-      return empty || optall.queue === false
-        ? this.each(doAnimation)
-        : this.queue(optall.queue, doAnimation);
-    },
-    stop(type, clearQueue, gotoEnd) {
-      const stopQueue = function (hooks) {
-        const { stop } = hooks;
-        delete hooks.stop;
-        stop(gotoEnd);
-      };
-
-      if (typeof type !== 'string') {
-        gotoEnd = clearQueue;
-        clearQueue = type;
-        type = undefined;
-      }
-      if (clearQueue && type !== false) {
-        this.queue(type || 'fx', []);
-      }
-
-      return this.each(function () {
-        let dequeue = true;
-        let index = type != null && `${type}queueHooks`;
-        const { timers } = jQuery;
-        const data = data_priv.get(this);
-
-        if (index) {
-          if (data[index] && data[index].stop) {
-            stopQueue(data[index]);
-          }
-        } else {
-          for (index in data) {
-            if (data[index] && data[index].stop && rrun.test(index)) {
-              stopQueue(data[index]);
-            }
-          }
-        }
-
-        for (index = timers.length; index--;) {
-          if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
-            timers[index].anim.stop(gotoEnd);
-            dequeue = false;
-            timers.splice(index, 1);
-          }
-        }
-
-        // start the next in the queue if the last step wasn't forced
-        // timers currently will call their complete callbacks, which will dequeue
-        // but only if they were gotoEnd
-        if (dequeue || !gotoEnd) {
-          jQuery.dequeue(this, type);
-        }
-      });
-    },
-    finish(type) {
-      if (type !== false) {
-        type = type || 'fx';
-      }
-      return this.each(function () {
-        let index;
-        const data = data_priv.get(this);
-        const queue = data[`${type}queue`];
-        const hooks = data[`${type}queueHooks`];
-        const { timers } = jQuery;
-        const length = queue ? queue.length : 0;
-
-        // enable finishing flag on private data
-        data.finish = true;
-
-        // empty the queue first
-        jQuery.queue(this, type, []);
-
-        if (hooks && hooks.stop) {
-          hooks.stop.call(this, true);
-        }
-
-        // look for any active animations, and finish them
-        for (index = timers.length; index--;) {
-          if (timers[index].elem === this && timers[index].queue === type) {
-            timers[index].anim.stop(true);
-            timers.splice(index, 1);
-          }
-        }
-
-        // look for any animations in the old queue and finish them
-        for (index = 0; index < length; index++) {
-          if (queue[index] && queue[index].finish) {
-            queue[index].finish.call(this);
-          }
-        }
-
-        // turn off finishing flag
-        delete data.finish;
-      });
-    },
-  });
-
-  jQuery.each(['toggle', 'show', 'hide'], (i, name) => {
-    const cssFn = jQuery.fn[name];
-    jQuery.fn[name] = function (speed, easing, callback) {
-      return speed == null || typeof speed === 'boolean'
-        ? cssFn.apply(this, arguments)
-        : this.animate(genFx(name, true), speed, easing, callback);
-    };
-  });
-
-  // Generate shortcuts for custom animations
-  jQuery.each({
-    slideDown: genFx('show'),
-    slideUp: genFx('hide'),
-    slideToggle: genFx('toggle'),
-    fadeIn: { opacity: 'show' },
-    fadeOut: { opacity: 'hide' },
-    fadeToggle: { opacity: 'toggle' },
-  }, (name, props) => {
-    jQuery.fn[name] = function (speed, easing, callback) {
-      return this.animate(props, speed, easing, callback);
-    };
-  });
-
-  jQuery.timers = [];
-  jQuery.fx.tick = function () {
-    let timer;
-    let i = 0;
-    const { timers } = jQuery;
-
-    fxNow = jQuery.now();
-
-    for (; i < timers.length; i++) {
-      timer = timers[i];
-      // Checks the timer has not already been removed
-      if (!timer() && timers[i] === timer) {
-        timers.splice(i--, 1);
-      }
-    }
-
-    if (!timers.length) {
-      jQuery.fx.stop();
-    }
-    fxNow = undefined;
-  };
-
-  jQuery.fx.timer = function (timer) {
-    jQuery.timers.push(timer);
-    if (timer()) {
-      jQuery.fx.start();
-    } else {
-      jQuery.timers.pop();
-    }
-  };
-
-  jQuery.fx.interval = 13;
-
-  jQuery.fx.start = function () {
-    if (!timerId) {
-      timerId = setInterval(jQuery.fx.tick, jQuery.fx.interval);
-    }
-  };
-
-  jQuery.fx.stop = function () {
-    clearInterval(timerId);
-    timerId = null;
-  };
-
-  jQuery.fx.speeds = {
-    slow: 600,
-    fast: 200,
-    // Default speed
-    _default: 400,
-  };
-
-  // Based off of the plugin by Clint Helfers, with permission.
-  // http://blindsignals.com/index.php/2009/07/jquery-delay/
-  jQuery.fn.delay = function (time, type) {
-    time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
-    type = type || 'fx';
-
-    return this.queue(type, (next, hooks) => {
-      const timeout = setTimeout(next, time);
-      hooks.stop = function () {
-        clearTimeout(timeout);
-      };
-    });
-  };
-
-  (function () {
-    let input = document.createElement('input');
-    const select = document.createElement('select');
-    const opt = select.appendChild(document.createElement('option'));
-
-    input.type = 'checkbox';
-
-    // Support: iOS 5.1, Android 4.x, Android 2.3
-    // Check the default checkbox/radio value ("" on old WebKit; "on" elsewhere)
-    support.checkOn = input.value !== '';
-
-    // Must access the parent to make an option select properly
-    // Support: IE9, IE10
-    support.optSelected = opt.selected;
-
-    // Make sure that the options inside disabled selects aren't marked as disabled
-    // (WebKit marks them as disabled)
-    select.disabled = true;
-    support.optDisabled = !opt.disabled;
-
-    // Check if an input maintains its value after becoming a radio
-    // Support: IE9, IE10
-    input = document.createElement('input');
-    input.value = 't';
-    input.type = 'radio';
-    support.radioValue = input.value === 't';
-  }());
-
-  let nodeHook; let boolHook;
-  const { attrHandle } = jQuery.expr;
-
-  jQuery.fn.extend({
-    attr(name, value) {
-      return access(this, jQuery.attr, name, value, arguments.length > 1);
-    },
-
-    removeAttr(name) {
-      return this.each(function () {
-        jQuery.removeAttr(this, name);
-      });
-    },
-  });
-
-  jQuery.extend({
-    attr(elem, name, value) {
-      let hooks; let ret;
-      const nType = elem.nodeType;
-
-      // don't get/set attributes on text, comment and attribute nodes
-      if (!elem || nType === 3 || nType === 8 || nType === 2) {
-        return;
-      }
-
-      // Fallback to prop when attributes are not supported
-      if (typeof elem.getAttribute === strundefined) {
-        return jQuery.prop(elem, name, value);
-      }
-
-      // All attributes are lowercase
-      // Grab necessary hook if one is defined
-      if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
-        name = name.toLowerCase();
-        hooks = jQuery.attrHooks[name]
-				|| (jQuery.expr.match.bool.test(name) ? boolHook : nodeHook);
-      }
-
-      if (value !== undefined) {
-        if (value === null) {
-          jQuery.removeAttr(elem, name);
-        } else if (hooks && 'set' in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
-          return ret;
-        } else {
-          elem.setAttribute(name, `${value}`);
-          return value;
-        }
-      } else if (hooks && 'get' in hooks && (ret = hooks.get(elem, name)) !== null) {
-        return ret;
-      } else {
-        ret = jQuery.find.attr(elem, name);
-
-        // Non-existent attributes return null, we normalize to undefined
-        return ret == null
-          ? undefined
-          : ret;
-      }
-    },
-
-    removeAttr(elem, value) {
-      let name; let propName;
-      let i = 0;
-      const attrNames = value && value.match(rnotwhite);
-
-      if (attrNames && elem.nodeType === 1) {
-        while ((name = attrNames[i++])) {
-          propName = jQuery.propFix[name] || name;
-
-          // Boolean attributes get special treatment (#10870)
-          if (jQuery.expr.match.bool.test(name)) {
-            // Set corresponding property to false
-            elem[propName] = false;
-          }
-
-          elem.removeAttribute(name);
-        }
-      }
-    },
-
-    attrHooks: {
-      type: {
-        set(elem, value) {
-          if (!support.radioValue && value === 'radio'
-					&& jQuery.nodeName(elem, 'input')) {
-            // Setting the type on a radio button after the value resets the value in IE6-9
-            // Reset value to default in case type is set after value during creation
-            const val = elem.value;
-            elem.setAttribute('type', value);
-            if (val) {
-              elem.value = val;
-            }
-            return value;
-          }
-        },
-      },
-    },
-  });
-
-  // Hooks for boolean attributes
-  boolHook = {
-    set(elem, value, name) {
-      if (value === false) {
-        // Remove boolean attributes when set to false
-        jQuery.removeAttr(elem, name);
-      } else {
-        elem.setAttribute(name, name);
-      }
-      return name;
-    },
-  };
-  jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), (i, name) => {
-    const getter = attrHandle[name] || jQuery.find.attr;
-
-    attrHandle[name] = function (elem, name, isXML) {
-      let ret; let
-        handle;
-      if (!isXML) {
-        // Avoid an infinite loop by temporarily removing this function from the getter
-        handle = attrHandle[name];
-        attrHandle[name] = ret;
-        ret = getter(elem, name, isXML) != null
-          ? name.toLowerCase()
-          : null;
-        attrHandle[name] = handle;
-      }
-      return ret;
-    };
-  });
-
-  const rfocusable = /^(?:input|select|textarea|button)$/i;
-
-  jQuery.fn.extend({
-    prop(name, value) {
-      return access(this, jQuery.prop, name, value, arguments.length > 1);
-    },
-
-    removeProp(name) {
-      return this.each(function () {
-        delete this[jQuery.propFix[name] || name];
-      });
-    },
-  });
-
-  jQuery.extend({
-    propFix: {
-      for: 'htmlFor',
-      class: 'className',
-    },
-
-    prop(elem, name, value) {
-      let ret; let hooks; let notxml;
-      const nType = elem.nodeType;
-
-      // don't get/set properties on text, comment and attribute nodes
-      if (!elem || nType === 3 || nType === 8 || nType === 2) {
-        return;
-      }
-
-      notxml = nType !== 1 || !jQuery.isXMLDoc(elem);
-
-      if (notxml) {
-        // Fix name and attach hooks
-        name = jQuery.propFix[name] || name;
-        hooks = jQuery.propHooks[name];
-      }
-
-      if (value !== undefined) {
-        return hooks && 'set' in hooks && (ret = hooks.set(elem, value, name)) !== undefined
-          ? ret
-          : (elem[name] = value);
-      }
-      return hooks && 'get' in hooks && (ret = hooks.get(elem, name)) !== null
-        ? ret
-        : elem[name];
-    },
-
-    propHooks: {
-      tabIndex: {
-        get(elem) {
-          return elem.hasAttribute('tabindex') || rfocusable.test(elem.nodeName) || elem.href
-            ? elem.tabIndex
-            : -1;
-        },
-      },
-    },
-  });
-
-  // Support: IE9+
-  // Selectedness for an option in an optgroup can be inaccurate
-  if (!support.optSelected) {
-    jQuery.propHooks.selected = {
-      get(elem) {
-        const parent = elem.parentNode;
-        if (parent && parent.parentNode) {
-          parent.parentNode.selectedIndex;
-        }
-        return null;
-      },
-    };
-  }
-
-  jQuery.each([
-    'tabIndex',
-    'readOnly',
-    'maxLength',
-    'cellSpacing',
-    'cellPadding',
-    'rowSpan',
-    'colSpan',
-    'useMap',
-    'frameBorder',
-    'contentEditable',
-  ], function () {
-    jQuery.propFix[this.toLowerCase()] = this;
-  });
-
-  const rclass = /[\t\r\n\f]/g;
-
-  jQuery.fn.extend({
-    addClass(value) {
-      let classes; let elem; let cur; let clazz; let j; let finalValue;
-      const proceed = typeof value === 'string' && value;
-      let i = 0;
-      const len = this.length;
-
-      if (jQuery.isFunction(value)) {
-        return this.each(function (j) {
-          jQuery(this).addClass(value.call(this, j, this.className));
-        });
-      }
-
-      if (proceed) {
-        // The disjunction here is for better compressibility (see removeClass)
-        classes = (value || '').match(rnotwhite) || [];
-
-        for (; i < len; i++) {
-          elem = this[i];
-          cur = elem.nodeType === 1 && (elem.className
-            ? (` ${elem.className} `).replace(rclass, ' ')
-            : ' '
-          );
-
-          if (cur) {
-            j = 0;
-            while ((clazz = classes[j++])) {
-              if (cur.indexOf(` ${clazz} `) < 0) {
-                cur += `${clazz} `;
-              }
-            }
-
-            // only assign if different to avoid unneeded rendering.
-            finalValue = jQuery.trim(cur);
-            if (elem.className !== finalValue) {
-              elem.className = finalValue;
-            }
-          }
-        }
-      }
-
-      return this;
-    },
-
-    removeClass(value) {
-      let classes; let elem; let cur; let clazz; let j; let finalValue;
-      const proceed = arguments.length === 0 || typeof value === 'string' && value;
-      let i = 0;
-      const len = this.length;
-
-      if (jQuery.isFunction(value)) {
-        return this.each(function (j) {
-          jQuery(this).removeClass(value.call(this, j, this.className));
-        });
-      }
-      if (proceed) {
-        classes = (value || '').match(rnotwhite) || [];
-
-        for (; i < len; i++) {
-          elem = this[i];
-          // This expression is here for better compressibility (see addClass)
-          cur = elem.nodeType === 1 && (elem.className
-            ? (` ${elem.className} `).replace(rclass, ' ')
-            : ''
-          );
-
-          if (cur) {
-            j = 0;
-            while ((clazz = classes[j++])) {
-              // Remove *all* instances
-              while (cur.indexOf(` ${clazz} `) >= 0) {
-                cur = cur.replace(` ${clazz} `, ' ');
-              }
-            }
-
-            // only assign if different to avoid unneeded rendering.
-            finalValue = value ? jQuery.trim(cur) : '';
-            if (elem.className !== finalValue) {
-              elem.className = finalValue;
-            }
-          }
-        }
-      }
-
-      return this;
-    },
-
-    toggleClass(value, stateVal) {
-      const type = typeof value;
-
-      if (typeof stateVal === 'boolean' && type === 'string') {
-        return stateVal ? this.addClass(value) : this.removeClass(value);
-      }
-
-      if (jQuery.isFunction(value)) {
-        return this.each(function (i) {
-          jQuery(this).toggleClass(value.call(this, i, this.className, stateVal), stateVal);
-        });
-      }
-
-      return this.each(function () {
-        if (type === 'string') {
-          // toggle individual class names
-          let className;
-          let i = 0;
-          const self = jQuery(this);
-          const classNames = value.match(rnotwhite) || [];
-
-          while ((className = classNames[i++])) {
-            // check each className given, space separated list
-            if (self.hasClass(className)) {
-              self.removeClass(className);
-            } else {
-              self.addClass(className);
-            }
-          }
-
-          // Toggle whole class name
-        } else if (type === strundefined || type === 'boolean') {
-          if (this.className) {
-            // store className if set
-            data_priv.set(this, '__className__', this.className);
-          }
-
-          // If the element has a class name or if we're passed "false",
-          // then remove the whole classname (if there was one, the above saved it).
-          // Otherwise bring back whatever was previously saved (if anything),
-          // falling back to the empty string if nothing was stored.
-          this.className = this.className || value === false ? '' : data_priv.get(this, '__className__') || '';
-        }
-      });
-    },
-
-    hasClass(selector) {
-      const className = ` ${selector} `;
-      let i = 0;
-      const l = this.length;
-      for (; i < l; i++) {
-        if (this[i].nodeType === 1 && (` ${this[i].className} `).replace(rclass, ' ').indexOf(className) >= 0) {
-          return true;
-        }
-      }
-
-      return false;
-    },
-  });
-
-  const rreturn = /\r/g;
-
-  jQuery.fn.extend({
-    val(value) {
-      let hooks; let ret; let isFunction;
-      const elem = this[0];
-
-      if (!arguments.length) {
-        if (elem) {
-          hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
-
-          if (hooks && 'get' in hooks && (ret = hooks.get(elem, 'value')) !== undefined) {
-            return ret;
-          }
-
-          ret = elem.value;
-
-          return typeof ret === 'string'
-          // handle most common string cases
-            ? ret.replace(rreturn, '')
-          // handle cases where value is null/undef or number
-            : ret == null ? '' : ret;
-        }
-
-        return;
-      }
-
-      isFunction = jQuery.isFunction(value);
-
-      return this.each(function (i) {
-        let val;
-
-        if (this.nodeType !== 1) {
-          return;
-        }
-
-        if (isFunction) {
-          val = value.call(this, i, jQuery(this).val());
-        } else {
-          val = value;
-        }
-
-        // Treat null/undefined as ""; convert numbers to string
-        if (val == null) {
-          val = '';
-        } else if (typeof val === 'number') {
-          val += '';
-        } else if (jQuery.isArray(val)) {
-          val = jQuery.map(val, (value) => (value == null ? '' : `${value}`));
-        }
-
-        hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
-
-        // If set returns undefined, fall back to normal setting
-        if (!hooks || !('set' in hooks) || hooks.set(this, val, 'value') === undefined) {
-          this.value = val;
-        }
-      });
-    },
-  });
-
-  jQuery.extend({
-    valHooks: {
-      select: {
-        get(elem) {
-          let value; let option;
-          const { options } = elem;
-          const index = elem.selectedIndex;
-          const one = elem.type === 'select-one' || index < 0;
-          const values = one ? null : [];
-          const max = one ? index + 1 : options.length;
-          let i = index < 0
-            ? max
-            : one ? index : 0;
-
-          // Loop through all the selected options
-          for (; i < max; i++) {
-            option = options[i];
-
-            // IE6-9 doesn't update selected after form reset (#2551)
-            if ((option.selected || i === index)
-							// Don't return options that are disabled or in a disabled optgroup
-							&& (support.optDisabled ? !option.disabled : option.getAttribute('disabled') === null)
-							&& (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, 'optgroup'))) {
-              // Get the specific value for the option
-              value = jQuery(option).val();
-
-              // We don't need an array for one selects
-              if (one) {
-                return value;
-              }
-
-              // Multi-Selects return an array
-              values.push(value);
-            }
-          }
-
-          return values;
-        },
-
-        set(elem, value) {
-          let optionSet; let option;
-          const { options } = elem;
-          const values = jQuery.makeArray(value);
-          let i = options.length;
-
-          while (i--) {
-            option = options[i];
-            if ((option.selected = jQuery.inArray(jQuery(option).val(), values) >= 0)) {
-              optionSet = true;
-            }
-          }
-
-          // force browsers to behave consistently when non-matching value is set
-          if (!optionSet) {
-            elem.selectedIndex = -1;
-          }
-          return values;
-        },
-      },
-    },
-  });
-
-  // Radios and checkboxes getter/setter
-  jQuery.each(['radio', 'checkbox'], function () {
-    jQuery.valHooks[this] = {
-      set(elem, value) {
-        if (jQuery.isArray(value)) {
-          return (elem.checked = jQuery.inArray(jQuery(elem).val(), value) >= 0);
-        }
-      },
-    };
-    if (!support.checkOn) {
-      jQuery.valHooks[this].get = function (elem) {
-        // Support: Webkit
-        // "" is returned instead of "on" if a value isn't specified
-        return elem.getAttribute('value') === null ? 'on' : elem.value;
-      };
-    }
-  });
-
-  // Return jQuery for attributes-only inclusion
-
-  jQuery.each(('blur focus focusin focusout load resize scroll unload click dblclick '
-	+ 'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave '
-	+ 'change select submit keydown keypress keyup error contextmenu').split(' '), (i, name) => {
-    // Handle event binding
-    jQuery.fn[name] = function (data, fn) {
-      return arguments.length > 0
-        ? this.on(name, null, data, fn)
-        : this.trigger(name);
-    };
-  });
-
-  jQuery.fn.extend({
-    hover(fnOver, fnOut) {
-      return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
-    },
-
-    bind(types, data, fn) {
-      return this.on(types, null, data, fn);
-    },
-    unbind(types, fn) {
-      return this.off(types, null, fn);
-    },
-
-    delegate(selector, types, data, fn) {
-      return this.on(types, selector, data, fn);
-    },
-    undelegate(selector, types, fn) {
-      // ( namespace ) or ( selector, types [, fn] )
-      return arguments.length === 1 ? this.off(selector, '**') : this.off(types, selector || '**', fn);
-    },
-  });
-
-  let nonce = jQuery.now();
-
-  const rquery = (/\?/);
-
-  // Support: Android 2.3
-  // Workaround failure to string-cast null input
-  jQuery.parseJSON = function (data) {
-    return JSON.parse(`${data}`);
-  };
-
-  // Cross-browser xml parsing
-  jQuery.parseXML = function (data) {
-    let xml; let
-      tmp;
-    if (!data || typeof data !== 'string') {
-      return null;
-    }
-
-    // Support: IE9
-    try {
-      tmp = new DOMParser();
-      xml = tmp.parseFromString(data, 'text/xml');
-    } catch (e) {
-      xml = undefined;
-    }
-
-    if (!xml || xml.getElementsByTagName('parsererror').length) {
-      jQuery.error(`Invalid XML: ${data}`);
-    }
-    return xml;
-  };
-
-  let
-    // Document location
-    ajaxLocParts;
-  let ajaxLocation;
-
-  const rhash = /#.*$/;
-  const rts = /([?&])_=[^&]*/;
-  const rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg;
-  // #7653, #8125, #8152: local protocol detection
-  const rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/;
-  const rnoContent = /^(?:GET|HEAD)$/;
-  const rprotocol = /^\/\//;
-  const rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/;
-
-  /* Prefilters
-	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
-	 * 2) These are called:
-	 *    - BEFORE asking for a transport
-	 *    - AFTER param serialization (s.data is a string if s.processData is true)
-	 * 3) key is the dataType
-	 * 4) the catchall symbol "*" can be used
-	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
-	 */
-  const prefilters = {};
-
-  /* Transports bindings
-	 * 1) key is the dataType
-	 * 2) the catchall symbol "*" can be used
-	 * 3) selection will start with transport dataType and THEN go to "*" if needed
-	 */
-  const transports = {};
-
-  // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
-  const allTypes = '*/'.concat('*');
-
-  // #8138, IE may throw an exception when accessing
-  // a field from window.location if document.domain has been set
-  try {
-    ajaxLocation = location.href;
-  } catch (e) {
-    // Use the href attribute of an A element
-    // since IE will modify it given document.location
-    ajaxLocation = document.createElement('a');
-    ajaxLocation.href = '';
-    ajaxLocation = ajaxLocation.href;
-  }
-
-  // Segment location into parts
-  ajaxLocParts = rurl.exec(ajaxLocation.toLowerCase()) || [];
-
-  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
-  function addToPrefiltersOrTransports(structure) {
-    // dataTypeExpression is optional and defaults to "*"
-    return function (dataTypeExpression, func) {
-      if (typeof dataTypeExpression !== 'string') {
-        func = dataTypeExpression;
-        dataTypeExpression = '*';
-      }
-
-      let dataType;
-      let i = 0;
-      const dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || [];
-
-      if (jQuery.isFunction(func)) {
-        // For each dataType in the dataTypeExpression
-        while ((dataType = dataTypes[i++])) {
-          // Prepend if requested
-          if (dataType[0] === '+') {
-            dataType = dataType.slice(1) || '*';
-            (structure[dataType] = structure[dataType] || []).unshift(func);
-
-            // Otherwise append
-          } else {
-            (structure[dataType] = structure[dataType] || []).push(func);
-          }
-        }
-      }
-    };
-  }
-
-  // Base inspection function for prefilters and transports
-  function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
-    const inspected = {};
-    const seekingTransport = (structure === transports);
-
-    function inspect(dataType) {
-      let selected;
-      inspected[dataType] = true;
-      jQuery.each(structure[dataType] || [], (_, prefilterOrFactory) => {
-        const dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
-        if (typeof dataTypeOrTransport === 'string' && !seekingTransport && !inspected[dataTypeOrTransport]) {
-          options.dataTypes.unshift(dataTypeOrTransport);
-          inspect(dataTypeOrTransport);
-          return false;
-        } if (seekingTransport) {
-          return !(selected = dataTypeOrTransport);
-        }
-      });
-      return selected;
-    }
-
-    return inspect(options.dataTypes[0]) || !inspected['*'] && inspect('*');
-  }
-
-  // A special extend for ajax options
-  // that takes "flat" options (not to be deep extended)
-  // Fixes #9887
-  function ajaxExtend(target, src) {
-    let key; let deep;
-    const flatOptions = jQuery.ajaxSettings.flatOptions || {};
-
-    for (key in src) {
-      if (src[key] !== undefined) {
-        (flatOptions[key] ? target : (deep || (deep = {})))[key] = src[key];
-      }
-    }
-    if (deep) {
-      jQuery.extend(true, target, deep);
-    }
-
-    return target;
-  }
-
-  /* Handles responses to an ajax request:
- * - finds the right dataType (mediates between content-type and expected dataType)
- * - returns the corresponding response
- */
-  function ajaxHandleResponses(s, jqXHR, responses) {
-    let ct; let type; let finalDataType; let firstDataType;
-    const { contents } = s;
-    const { dataTypes } = s;
-
-    // Remove auto dataType and get content-type in the process
-    while (dataTypes[0] === '*') {
-      dataTypes.shift();
-      if (ct === undefined) {
-        ct = s.mimeType || jqXHR.getResponseHeader('Content-Type');
-      }
-    }
-
-    // Check if we're dealing with a known content-type
-    if (ct) {
-      for (type in contents) {
-        if (contents[type] && contents[type].test(ct)) {
-          dataTypes.unshift(type);
-          break;
-        }
-      }
-    }
-
-    // Check to see if we have a response for the expected dataType
-    if (dataTypes[0] in responses) {
-      finalDataType = dataTypes[0];
-    } else {
-      // Try convertible dataTypes
-      for (type in responses) {
-        if (!dataTypes[0] || s.converters[`${type} ${dataTypes[0]}`]) {
-          finalDataType = type;
-          break;
-        }
-        if (!firstDataType) {
-          firstDataType = type;
-        }
-      }
-      // Or just use first one
-      finalDataType = finalDataType || firstDataType;
-    }
-
-    // If we found a dataType
-    // We add the dataType to the list if needed
-    // and return the corresponding response
-    if (finalDataType) {
-      if (finalDataType !== dataTypes[0]) {
-        dataTypes.unshift(finalDataType);
-      }
-      return responses[finalDataType];
-    }
-  }
-
-  /* Chain conversions given the request and the original response
- * Also sets the responseXXX fields on the jqXHR instance
- */
-  function ajaxConvert(s, response, jqXHR, isSuccess) {
-    let conv2; let current; let conv; let tmp; let prev;
-    const converters = {};
-    // Work with a copy of dataTypes in case we need to modify it for conversion
-    const dataTypes = s.dataTypes.slice();
-
-    // Create converters map with lowercased keys
-    if (dataTypes[1]) {
-      for (conv in s.converters) {
-        converters[conv.toLowerCase()] = s.converters[conv];
-      }
-    }
-
-    current = dataTypes.shift();
-
-    // Convert to each sequential dataType
-    while (current) {
-      if (s.responseFields[current]) {
-        jqXHR[s.responseFields[current]] = response;
-      }
-
-      // Apply the dataFilter if provided
-      if (!prev && isSuccess && s.dataFilter) {
-        response = s.dataFilter(response, s.dataType);
-      }
-
-      prev = current;
-      current = dataTypes.shift();
-
-      if (current) {
-        // There's only work to do if current dataType is non-auto
-        if (current === '*') {
-          current = prev;
-
-          // Convert response if prev dataType is non-auto and differs from current
-        } else if (prev !== '*' && prev !== current) {
-          // Seek a direct converter
-          conv = converters[`${prev} ${current}`] || converters[`* ${current}`];
-
-          // If none found, seek a pair
-          if (!conv) {
-            for (conv2 in converters) {
-              // If conv2 outputs current
-              tmp = conv2.split(' ');
-              if (tmp[1] === current) {
-                // If prev can be converted to accepted input
-                conv = converters[`${prev} ${tmp[0]}`]
-								|| converters[`* ${tmp[0]}`];
-                if (conv) {
-                  // Condense equivalence converters
-                  if (conv === true) {
-                    conv = converters[conv2];
-
-                    // Otherwise, insert the intermediate dataType
-                  } else if (converters[conv2] !== true) {
-                    current = tmp[0];
-                    dataTypes.unshift(tmp[1]);
-                  }
-                  break;
-                }
-              }
-            }
-          }
-
-          // Apply converter (if not an equivalence)
-          if (conv !== true) {
-            // Unless errors are allowed to bubble, catch and return them
-            if (conv && s.throws) {
-              response = conv(response);
-            } else {
-              try {
-                response = conv(response);
-              } catch (e) {
-                return { state: 'parsererror', error: conv ? e : `No conversion from ${prev} to ${current}` };
-              }
-            }
-          }
-        }
-      }
-    }
-
-    return { state: 'success', data: response };
-  }
-
-  jQuery.extend({
-
-    // Counter for holding the number of active queries
-    active: 0,
-
-    // Last-Modified header cache for next request
-    lastModified: {},
-    etag: {},
-
-    ajaxSettings: {
-      url: ajaxLocation,
-      type: 'GET',
-      isLocal: rlocalProtocol.test(ajaxLocParts[1]),
-      global: true,
-      processData: true,
-      async: true,
-      contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
-      /*
-		timeout: 0,
-		data: null,
-		dataType: null,
-		username: null,
-		password: null,
-		cache: null,
-		throws: false,
-		traditional: false,
-		headers: {},
-		*/
-
-      accepts: {
-        '*': allTypes,
-        text: 'text/plain',
-        html: 'text/html',
-        xml: 'application/xml, text/xml',
-        json: 'application/json, text/javascript',
-      },
-
-      contents: {
-        xml: /xml/,
-        html: /html/,
-        json: /json/,
-      },
-
-      responseFields: {
-        xml: 'responseXML',
-        text: 'responseText',
-        json: 'responseJSON',
-      },
-
-      // Data converters
-      // Keys separate source (or catchall "*") and destination types with a single space
-      converters: {
-
-        // Convert anything to text
-        '* text': String,
-
-        // Text to html (true = no transformation)
-        'text html': true,
-
-        // Evaluate text as a json expression
-        'text json': jQuery.parseJSON,
-
-        // Parse text as xml
-        'text xml': jQuery.parseXML,
-      },
-
-      // For options that shouldn't be deep extended:
-      // you can add your own custom options here if
-      // and when you create one that shouldn't be
-      // deep extended (see ajaxExtend)
-      flatOptions: {
-        url: true,
-        context: true,
-      },
-    },
-
-    // Creates a full fledged settings object into target
-    // with both ajaxSettings and settings fields.
-    // If target is omitted, writes into ajaxSettings.
-    ajaxSetup(target, settings) {
-      return settings
-
-      // Building a settings object
-        ? ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings)
-
-      // Extending ajaxSettings
-        : ajaxExtend(jQuery.ajaxSettings, target);
-    },
-
-    ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
-    ajaxTransport: addToPrefiltersOrTransports(transports),
-
-    // Main method
-    ajax(url, options) {
-      // If url is an object, simulate pre-1.5 signature
-      if (typeof url === 'object') {
-        options = url;
-        url = undefined;
-      }
-
-      // Force options to be an object
-      options = options || {};
-
-      let transport;
-      // URL without anti-cache param
-      let cacheURL;
-      // Response headers
-      let responseHeadersString;
-      let responseHeaders;
-      // timeout handle
-      let timeoutTimer;
-      // Cross-domain detection vars
-      let parts;
-      // To know if global events are to be dispatched
-      let fireGlobals;
-      // Loop variable
-      let i;
-      // Create the final options object
-      const s = jQuery.ajaxSetup({}, options);
-      // Callbacks context
-      const callbackContext = s.context || s;
-      // Context for global events is callbackContext if it is a DOM node or jQuery collection
-      const globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery)
-        ? jQuery(callbackContext)
-        : jQuery.event;
-      // Deferreds
-      const deferred = jQuery.Deferred();
-      const completeDeferred = jQuery.Callbacks('once memory');
-      // Status-dependent callbacks
-      let statusCode = s.statusCode || {};
-      // Headers (they are sent all at once)
-      const requestHeaders = {};
-      const requestHeadersNames = {};
-      // The jqXHR state
-      let state = 0;
-      // Default abort message
-      let strAbort = 'canceled';
-      // Fake xhr
-      var jqXHR = {
-        readyState: 0,
-
-        // Builds headers hashtable if needed
-        getResponseHeader(key) {
-          let match;
-          if (state === 2) {
-            if (!responseHeaders) {
-              responseHeaders = {};
-              while ((match = rheaders.exec(responseHeadersString))) {
-                responseHeaders[match[1].toLowerCase()] = match[2];
-              }
-            }
-            match = responseHeaders[key.toLowerCase()];
-          }
-          return match == null ? null : match;
-        },
-
-        // Raw string
-        getAllResponseHeaders() {
-          return state === 2 ? responseHeadersString : null;
-        },
-
-        // Caches the header
-        setRequestHeader(name, value) {
-          const lname = name.toLowerCase();
-          if (!state) {
-            name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
-            requestHeaders[name] = value;
-          }
-          return this;
-        },
-
-        // Overrides response content-type header
-        overrideMimeType(type) {
-          if (!state) {
-            s.mimeType = type;
-          }
-          return this;
-        },
-
-        // Status-dependent callbacks
-        statusCode(map) {
-          let code;
-          if (map) {
-            if (state < 2) {
-              for (code in map) {
-                // Lazy-add the new callback in a way that preserves old ones
-                statusCode[code] = [statusCode[code], map[code]];
-              }
-            } else {
-              // Execute the appropriate callbacks
-              jqXHR.always(map[jqXHR.status]);
-            }
-          }
-          return this;
-        },
-
-        // Cancel the request
-        abort(statusText) {
-          const finalText = statusText || strAbort;
-          if (transport) {
-            transport.abort(finalText);
-          }
-          done(0, finalText);
-          return this;
-        },
-      };
-
-      // Attach deferreds
-      deferred.promise(jqXHR).complete = completeDeferred.add;
-      jqXHR.success = jqXHR.done;
-      jqXHR.error = jqXHR.fail;
-
-      // Remove hash character (#7531: and string promotion)
-      // Add protocol if not provided (prefilters might expect it)
-      // Handle falsy url in the settings object (#10093: consistency with old signature)
-      // We also use the url parameter if available
-      s.url = (`${url || s.url || ajaxLocation}`).replace(rhash, '')
-        .replace(rprotocol, `${ajaxLocParts[1]}//`);
-
-      // Alias method option to type as per ticket #12004
-      s.type = options.method || options.type || s.method || s.type;
-
-      // Extract dataTypes list
-      s.dataTypes = jQuery.trim(s.dataType || '*').toLowerCase().match(rnotwhite) || [''];
-
-      // A cross-domain request is in order when we have a protocol:host:port mismatch
-      if (s.crossDomain == null) {
-        parts = rurl.exec(s.url.toLowerCase());
-        s.crossDomain = !!(parts
-				&& (parts[1] !== ajaxLocParts[1] || parts[2] !== ajaxLocParts[2]
-					|| (parts[3] || (parts[1] === 'http:' ? '80' : '443'))
-						!== (ajaxLocParts[3] || (ajaxLocParts[1] === 'http:' ? '80' : '443')))
-        );
-      }
-
-      // Convert data if not already a string
-      if (s.data && s.processData && typeof s.data !== 'string') {
-        s.data = jQuery.param(s.data, s.traditional);
-      }
-
-      // Apply prefilters
-      inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
-
-      // If request was aborted inside a prefilter, stop there
-      if (state === 2) {
-        return jqXHR;
-      }
-
-      // We can fire global events as of now if asked to
-      fireGlobals = s.global;
-
-      // Watch for a new set of requests
-      if (fireGlobals && jQuery.active++ === 0) {
-        jQuery.event.trigger('ajaxStart');
-      }
-
-      // Uppercase the type
-      s.type = s.type.toUpperCase();
-
-      // Determine if request has content
-      s.hasContent = !rnoContent.test(s.type);
-
-      // Save the URL in case we're toying with the If-Modified-Since
-      // and/or If-None-Match header later on
-      cacheURL = s.url;
-
-      // More options handling for requests with no content
-      if (!s.hasContent) {
-        // If data is available, append data to url
-        if (s.data) {
-          cacheURL = (s.url += (rquery.test(cacheURL) ? '&' : '?') + s.data);
-          // #9682: remove data so that it's not used in an eventual retry
-          delete s.data;
-        }
-
-        // Add anti-cache in url if needed
-        if (s.cache === false) {
-          s.url = rts.test(cacheURL)
-
-          // If there is already a '_' parameter, set its value
-            ? cacheURL.replace(rts, `$1_=${nonce++}`)
-
-          // Otherwise add one to the end
-            : `${cacheURL + (rquery.test(cacheURL) ? '&' : '?')}_=${nonce++}`;
-        }
-      }
-
-      // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
-      if (s.ifModified) {
-        if (jQuery.lastModified[cacheURL]) {
-          jqXHR.setRequestHeader('If-Modified-Since', jQuery.lastModified[cacheURL]);
-        }
-        if (jQuery.etag[cacheURL]) {
-          jqXHR.setRequestHeader('If-None-Match', jQuery.etag[cacheURL]);
-        }
-      }
-
-      // Set the correct header, if data is being sent
-      if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
-        jqXHR.setRequestHeader('Content-Type', s.contentType);
-      }
-
-      // Set the Accepts header for the server, depending on the dataType
-      jqXHR.setRequestHeader(
-        'Accept',
-        s.dataTypes[0] && s.accepts[s.dataTypes[0]]
-          ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== '*' ? `, ${allTypes}; q=0.01` : '')
-          : s.accepts['*'],
-      );
-
-      // Check for headers option
-      for (i in s.headers) {
-        jqXHR.setRequestHeader(i, s.headers[i]);
-      }
-
-      // Allow custom headers/mimetypes and early abort
-      if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {
-        // Abort if not done already and return
-        return jqXHR.abort();
-      }
-
-      // aborting is no longer a cancellation
-      strAbort = 'abort';
-
-      // Install callbacks on deferreds
-      for (i in { success: 1, error: 1, complete: 1 }) {
-        jqXHR[i](s[i]);
-      }
-
-      // Get transport
-      transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
-
-      // If no transport, we auto-abort
-      if (!transport) {
-        done(-1, 'No Transport');
-      } else {
-        jqXHR.readyState = 1;
-
-        // Send global event
-        if (fireGlobals) {
-          globalEventContext.trigger('ajaxSend', [jqXHR, s]);
-        }
-        // Timeout
-        if (s.async && s.timeout > 0) {
-          timeoutTimer = setTimeout(() => {
-            jqXHR.abort('timeout');
-          }, s.timeout);
-        }
-
-        try {
-          state = 1;
-          transport.send(requestHeaders, done);
-        } catch (e) {
-          // Propagate exception as error if not done
-          if (state < 2) {
-            done(-1, e);
-            // Simply rethrow otherwise
-          } else {
-            throw e;
-          }
-        }
-      }
-
-      // Callback for when everything is done
-      function done(status, nativeStatusText, responses, headers) {
-        let isSuccess; let success; let error; let response; let modified;
-        let statusText = nativeStatusText;
-
-        // Called once
-        if (state === 2) {
-          return;
-        }
-
-        // State is "done" now
-        state = 2;
-
-        // Clear timeout if it exists
-        if (timeoutTimer) {
-          clearTimeout(timeoutTimer);
-        }
-
-        // Dereference transport for early garbage collection
-        // (no matter how long the jqXHR object will be used)
-        transport = undefined;
-
-        // Cache response headers
-        responseHeadersString = headers || '';
-
-        // Set readyState
-        jqXHR.readyState = status > 0 ? 4 : 0;
-
-        // Determine if successful
-        isSuccess = status >= 200 && status < 300 || status === 304;
-
-        // Get response data
-        if (responses) {
-          response = ajaxHandleResponses(s, jqXHR, responses);
-        }
-
-        // Convert no matter what (that way responseXXX fields are always set)
-        response = ajaxConvert(s, response, jqXHR, isSuccess);
-
-        // If successful, handle type chaining
-        if (isSuccess) {
-          // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
-          if (s.ifModified) {
-            modified = jqXHR.getResponseHeader('Last-Modified');
-            if (modified) {
-              jQuery.lastModified[cacheURL] = modified;
-            }
-            modified = jqXHR.getResponseHeader('etag');
-            if (modified) {
-              jQuery.etag[cacheURL] = modified;
-            }
-          }
-
-          // if no content
-          if (status === 204 || s.type === 'HEAD') {
-            statusText = 'nocontent';
-
-            // if not modified
-          } else if (status === 304) {
-            statusText = 'notmodified';
-
-            // If we have data, let's convert it
-          } else {
-            statusText = response.state;
-            success = response.data;
-            error = response.error;
-            isSuccess = !error;
-          }
-        } else {
-          // We extract error from statusText
-          // then normalize statusText and status for non-aborts
-          error = statusText;
-          if (status || !statusText) {
-            statusText = 'error';
-            if (status < 0) {
-              status = 0;
-            }
-          }
-        }
-
-        // Set data for the fake xhr object
-        jqXHR.status = status;
-        jqXHR.statusText = `${nativeStatusText || statusText}`;
-
-        // Success/Error
-        if (isSuccess) {
-          deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
-        } else {
-          deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
-        }
-
-        // Status-dependent callbacks
-        jqXHR.statusCode(statusCode);
-        statusCode = undefined;
-
-        if (fireGlobals) {
-          globalEventContext.trigger(isSuccess ? 'ajaxSuccess' : 'ajaxError',
-            [jqXHR, s, isSuccess ? success : error]);
-        }
-
-        // Complete
-        completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
-
-        if (fireGlobals) {
-          globalEventContext.trigger('ajaxComplete', [jqXHR, s]);
-          // Handle the global AJAX counter
-          if (!(--jQuery.active)) {
-            jQuery.event.trigger('ajaxStop');
-          }
-        }
-      }
-
-      return jqXHR;
-    },
-
-    getJSON(url, data, callback) {
-      return jQuery.get(url, data, callback, 'json');
-    },
-
-    getScript(url, callback) {
-      return jQuery.get(url, undefined, callback, 'script');
-    },
-  });
-
-  jQuery.each(['get', 'post'], (i, method) => {
-    jQuery[method] = function (url, data, callback, type) {
-      // shift arguments if data argument was omitted
-      if (jQuery.isFunction(data)) {
-        type = type || callback;
-        callback = data;
-        data = undefined;
-      }
-
-      return jQuery.ajax({
-        url,
-        type: method,
-        dataType: type,
-        data,
-        success: callback,
-      });
-    };
-  });
-
-  // Attach a bunch of functions for handling common AJAX events
-  jQuery.each(['ajaxStart', 'ajaxStop', 'ajaxComplete', 'ajaxError', 'ajaxSuccess', 'ajaxSend'], (i, type) => {
-    jQuery.fn[type] = function (fn) {
-      return this.on(type, fn);
-    };
-  });
-
-  jQuery._evalUrl = function (url) {
-    return jQuery.ajax({
-      url,
-      type: 'GET',
-      dataType: 'script',
-      async: false,
-      global: false,
-      throws: true,
-    });
-  };
-
-  jQuery.fn.extend({
-    wrapAll(html) {
-      let wrap;
-
-      if (jQuery.isFunction(html)) {
-        return this.each(function (i) {
-          jQuery(this).wrapAll(html.call(this, i));
-        });
-      }
-
-      if (this[0]) {
-        // The elements to wrap the target around
-        wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
-
-        if (this[0].parentNode) {
-          wrap.insertBefore(this[0]);
-        }
-
-        wrap.map(function () {
-          let elem = this;
-
-          while (elem.firstElementChild) {
-            elem = elem.firstElementChild;
-          }
-
-          return elem;
-        }).append(this);
-      }
-
-      return this;
-    },
-
-    wrapInner(html) {
-      if (jQuery.isFunction(html)) {
-        return this.each(function (i) {
-          jQuery(this).wrapInner(html.call(this, i));
-        });
-      }
-
-      return this.each(function () {
-        const self = jQuery(this);
-        const contents = self.contents();
-
-        if (contents.length) {
-          contents.wrapAll(html);
-        } else {
-          self.append(html);
-        }
-      });
-    },
-
-    wrap(html) {
-      const isFunction = jQuery.isFunction(html);
-
-      return this.each(function (i) {
-        jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
-      });
-    },
-
-    unwrap() {
-      return this.parent().each(function () {
-        if (!jQuery.nodeName(this, 'body')) {
-          jQuery(this).replaceWith(this.childNodes);
-        }
-      }).end();
-    },
-  });
-
-  jQuery.expr.filters.hidden = function (elem) {
-    // Support: Opera <= 12.12
-    // Opera reports offsetWidths and offsetHeights less than zero on some elements
-    return elem.offsetWidth <= 0 && elem.offsetHeight <= 0;
-  };
-  jQuery.expr.filters.visible = function (elem) {
-    return !jQuery.expr.filters.hidden(elem);
-  };
-
-  const r20 = /%20/g;
-  const rbracket = /\[\]$/;
-  const rCRLF = /\r?\n/g;
-  const rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i;
-  const rsubmittable = /^(?:input|select|textarea|keygen)/i;
-
-  function buildParams(prefix, obj, traditional, add) {
-    let name;
-
-    if (jQuery.isArray(obj)) {
-      // Serialize array item.
-      jQuery.each(obj, (i, v) => {
-        if (traditional || rbracket.test(prefix)) {
-          // Treat each array item as a scalar.
-          add(prefix, v);
-        } else {
-          // Item is non-scalar (array or object), encode its numeric index.
-          buildParams(`${prefix}[${typeof v === 'object' ? i : ''}]`, v, traditional, add);
-        }
-      });
-    } else if (!traditional && jQuery.type(obj) === 'object') {
-      // Serialize object item.
-      for (name in obj) {
-        buildParams(`${prefix}[${name}]`, obj[name], traditional, add);
-      }
-    } else {
-      // Serialize scalar item.
-      add(prefix, obj);
-    }
-  }
-
-  // Serialize an array of form elements or a set of
-  // key/values into a query string
-  jQuery.param = function (a, traditional) {
-    let prefix;
-    const s = [];
-    const add = function (key, value) {
-      // If value is a function, invoke it and return its value
-      value = jQuery.isFunction(value) ? value() : (value == null ? '' : value);
-      s[s.length] = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-    };
-
-    // Set traditional to true for jQuery <= 1.3.2 behavior.
-    if (traditional === undefined) {
-      traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
-    }
-
-    // If an array was passed in, assume that it is an array of form elements.
-    if (jQuery.isArray(a) || (a.jquery && !jQuery.isPlainObject(a))) {
-      // Serialize the form elements
-      jQuery.each(a, function () {
-        add(this.name, this.value);
-      });
-    } else {
-      // If traditional, encode the "old" way (the way 1.3.2 or older
-      // did it), otherwise encode params recursively.
-      for (prefix in a) {
-        buildParams(prefix, a[prefix], traditional, add);
-      }
-    }
-
-    // Return the resulting serialization
-    return s.join('&').replace(r20, '+');
-  };
-
-  jQuery.fn.extend({
-    serialize() {
-      return jQuery.param(this.serializeArray());
-    },
-    serializeArray() {
-      return this.map(function () {
-        // Can add propHook for "elements" to filter or add form elements
-        const elements = jQuery.prop(this, 'elements');
-        return elements ? jQuery.makeArray(elements) : this;
-      })
-        .filter(function () {
-          const { type } = this;
-
-          // Use .is( ":disabled" ) so that fieldset[disabled] works
-          return this.name && !jQuery(this).is(':disabled')
-				&& rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type)
-				&& (this.checked || !rcheckableType.test(type));
-        })
-        .map(function (i, elem) {
-          const val = jQuery(this).val();
-
-          return val == null
-            ? null
-            : jQuery.isArray(val)
-              ? jQuery.map(val, (val) => ({ name: elem.name, value: val.replace(rCRLF, '\r\n') }))
-              : { name: elem.name, value: val.replace(rCRLF, '\r\n') };
-        }).get();
-    },
-  });
-
-  jQuery.ajaxSettings.xhr = function () {
-    try {
-      return new XMLHttpRequest();
-    } catch (e) {}
-  };
-
-  let xhrId = 0;
-  const xhrCallbacks = {};
-  const xhrSuccessStatus = {
-    // file protocol always yields status code 0, assume 200
-    0: 200,
-    // Support: IE9
-    // #1450: sometimes IE returns 1223 when it should be 204
-    1223: 204,
-  };
-  let xhrSupported = jQuery.ajaxSettings.xhr();
-
-  // Support: IE9
-  // Open requests must be manually aborted on unload (#5280)
-  if (window.ActiveXObject) {
-    jQuery(window).on('unload', () => {
-      for (const key in xhrCallbacks) {
-        xhrCallbacks[key]();
-      }
-    });
-  }
-
-  support.cors = !!xhrSupported && ('withCredentials' in xhrSupported);
-  support.ajax = xhrSupported = !!xhrSupported;
-
-  jQuery.ajaxTransport((options) => {
-    let callback;
-
-    // Cross domain only allowed if supported through XMLHttpRequest
-    if (support.cors || xhrSupported && !options.crossDomain) {
-      return {
-        send(headers, complete) {
-          let i;
-          const xhr = options.xhr();
-          const id = ++xhrId;
-
-          xhr.open(options.type, options.url, options.async, options.username, options.password);
-
-          // Apply custom fields if provided
-          if (options.xhrFields) {
-            for (i in options.xhrFields) {
-              xhr[i] = options.xhrFields[i];
-            }
-          }
-
-          // Override mime type if needed
-          if (options.mimeType && xhr.overrideMimeType) {
-            xhr.overrideMimeType(options.mimeType);
-          }
-
-          // X-Requested-With header
-          // For cross-domain requests, seeing as conditions for a preflight are
-          // akin to a jigsaw puzzle, we simply never set it to be sure.
-          // (it can always be set on a per-request basis or even using ajaxSetup)
-          // For same-domain requests, won't change header if already provided.
-          if (!options.crossDomain && !headers['X-Requested-With']) {
-            headers['X-Requested-With'] = 'XMLHttpRequest';
-          }
-
-          // Set headers
-          for (i in headers) {
-            xhr.setRequestHeader(i, headers[i]);
-          }
-
-          // Callback
-          callback = function (type) {
-            return function () {
-              if (callback) {
-                delete xhrCallbacks[id];
-                callback = xhr.onload = xhr.onerror = null;
-
-                if (type === 'abort') {
-                  xhr.abort();
-                } else if (type === 'error') {
-                  complete(
-                    // file: protocol always yields status 0; see #8605, #14207
-                    xhr.status,
-                    xhr.statusText,
-                  );
-                } else {
-                  complete(
-                    xhrSuccessStatus[xhr.status] || xhr.status,
-                    xhr.statusText,
-                    // Support: IE9
-                    // Accessing binary-data responseText throws an exception
-                    // (#11426)
-                    typeof xhr.responseText === 'string' ? {
-                      text: xhr.responseText,
-                    } : undefined,
-                    xhr.getAllResponseHeaders(),
-                  );
-                }
-              }
-            };
-          };
-
-          // Listen to events
-          xhr.onload = callback();
-          xhr.onerror = callback('error');
-
-          // Create the abort callback
-          callback = xhrCallbacks[id] = callback('abort');
-
-          // Do send the request
-          // This may raise an exception which is actually
-          // handled in jQuery.ajax (so no try/catch here)
-          xhr.send(options.hasContent && options.data || null);
-        },
-
-        abort() {
-          if (callback) {
-            callback();
-          }
-        },
-      };
-    }
-  });
-
-  // Install script dataType
-  jQuery.ajaxSetup({
-    accepts: {
-      script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript',
-    },
-    contents: {
-      script: /(?:java|ecma)script/,
-    },
-    converters: {
-      'text script': function (text) {
-        jQuery.globalEval(text);
-        return text;
-      },
-    },
-  });
-
-  // Handle cache's special case and crossDomain
-  jQuery.ajaxPrefilter('script', (s) => {
-    if (s.cache === undefined) {
-      s.cache = false;
-    }
-    if (s.crossDomain) {
-      s.type = 'GET';
-    }
-  });
-
-  // Bind script tag hack transport
-  jQuery.ajaxTransport('script', (s) => {
-    // This transport only deals with cross domain requests
-    if (s.crossDomain) {
-      let script; let
-        callback;
-      return {
-        send(_, complete) {
-          script = jQuery('<script>').prop({
-            async: true,
-            charset: s.scriptCharset,
-            src: s.url,
-          }).on(
-            'load error',
-            callback = function (evt) {
-              script.remove();
-              callback = null;
-              if (evt) {
-                complete(evt.type === 'error' ? 404 : 200, evt.type);
-              }
-            },
-          );
-          document.head.appendChild(script[0]);
-        },
-        abort() {
-          if (callback) {
-            callback();
-          }
-        },
-      };
-    }
-  });
-
-  const oldCallbacks = [];
-  const rjsonp = /(=)\?(?=&|$)|\?\?/;
-
-  // Default jsonp settings
-  jQuery.ajaxSetup({
-    jsonp: 'callback',
-    jsonpCallback() {
-      const callback = oldCallbacks.pop() || (`${jQuery.expando}_${nonce++}`);
-      this[callback] = true;
-      return callback;
-    },
-  });
-
-  // Detect, normalize options and install callbacks for jsonp requests
-  jQuery.ajaxPrefilter('json jsonp', (s, originalSettings, jqXHR) => {
-    let callbackName; let overwritten; let responseContainer;
-    const jsonProp = s.jsonp !== false && (rjsonp.test(s.url)
-      ? 'url'
-      : typeof s.data === 'string' && !(s.contentType || '').indexOf('application/x-www-form-urlencoded') && rjsonp.test(s.data) && 'data'
-    );
-
-    // Handle iff the expected data type is "jsonp" or we have a parameter to set
-    if (jsonProp || s.dataTypes[0] === 'jsonp') {
-      // Get callback name, remembering preexisting value associated with it
-      callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback)
-        ? s.jsonpCallback()
-        : s.jsonpCallback;
-
-      // Insert callback into url or form data
-      if (jsonProp) {
-        s[jsonProp] = s[jsonProp].replace(rjsonp, `$1${callbackName}`);
-      } else if (s.jsonp !== false) {
-        s.url += `${(rquery.test(s.url) ? '&' : '?') + s.jsonp}=${callbackName}`;
-      }
-
-      // Use data converter to retrieve json after script execution
-      s.converters['script json'] = function () {
-        if (!responseContainer) {
-          jQuery.error(`${callbackName} was not called`);
-        }
-        return responseContainer[0];
-      };
-
-      // force json dataType
-      s.dataTypes[0] = 'json';
-
-      // Install callback
-      overwritten = window[callbackName];
-      window[callbackName] = function () {
-        responseContainer = arguments;
-      };
-
-      // Clean-up function (fires after converters)
-      jqXHR.always(() => {
-        // Restore preexisting value
-        window[callbackName] = overwritten;
-
-        // Save back as free
-        if (s[callbackName]) {
-          // make sure that re-using the options doesn't screw things around
-          s.jsonpCallback = originalSettings.jsonpCallback;
-
-          // save the callback name for future use
-          oldCallbacks.push(callbackName);
-        }
-
-        // Call if it was a function and we have a response
-        if (responseContainer && jQuery.isFunction(overwritten)) {
-          overwritten(responseContainer[0]);
-        }
-
-        responseContainer = overwritten = undefined;
-      });
-
-      // Delegate to script
-      return 'script';
-    }
-  });
-
-  // data: string of html
-  // context (optional): If specified, the fragment will be created in this context, defaults to document
-  // keepScripts (optional): If true, will include scripts passed in the html string
-  jQuery.parseHTML = function (data, context, keepScripts) {
-    if (!data || typeof data !== 'string') {
-      return null;
-    }
-    if (typeof context === 'boolean') {
-      keepScripts = context;
-      context = false;
-    }
-    context = context || document;
-
-    let parsed = rsingleTag.exec(data);
-    const scripts = !keepScripts && [];
-
-    // Single tag
-    if (parsed) {
-      return [context.createElement(parsed[1])];
-    }
-
-    parsed = jQuery.buildFragment([data], context, scripts);
-
-    if (scripts && scripts.length) {
-      jQuery(scripts).remove();
-    }
-
-    return jQuery.merge([], parsed.childNodes);
-  };
-
-  // Keep a copy of the old load method
-  const _load = jQuery.fn.load;
-
-  /**
- * Load a url into a page
- */
-  jQuery.fn.load = function (url, params, callback) {
-    if (typeof url !== 'string' && _load) {
-      return _load.apply(this, arguments);
-    }
-
-    let selector; let type; let response;
-    const self = this;
-    const off = url.indexOf(' ');
-
-    if (off >= 0) {
-      selector = url.slice(off);
-      url = url.slice(0, off);
-    }
-
-    // If it's a function
-    if (jQuery.isFunction(params)) {
-      // We assume that it's the callback
-      callback = params;
-      params = undefined;
-
-      // Otherwise, build a param string
-    } else if (params && typeof params === 'object') {
-      type = 'POST';
-    }
-
-    // If we have elements to modify, make the request
-    if (self.length > 0) {
-      jQuery.ajax({
-        url,
-
-        // if "type" variable is undefined, then "GET" method will be used
-        type,
-        dataType: 'html',
-        data: params,
-      }).done(function (responseText) {
-        // Save response for use in complete callback
-        response = arguments;
-
-        self.html(selector
-
-        // If a selector was specified, locate the right elements in a dummy div
-        // Exclude scripts to avoid IE 'Permission Denied' errors
-          ? jQuery('<div>').append(jQuery.parseHTML(responseText)).find(selector)
-
-        // Otherwise use the full result
-          : responseText);
-      }).complete(callback && ((jqXHR, status) => {
-        self.each(callback, response || [jqXHR.responseText, status, jqXHR]);
-      }));
-    }
-
-    return this;
-  };
-
-  jQuery.expr.filters.animated = function (elem) {
-    return jQuery.grep(jQuery.timers, (fn) => elem === fn.elem).length;
-  };
-
-  const docElem = window.document.documentElement;
-
-  /**
- * Gets a window from an element
- */
-  function getWindow(elem) {
-    return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 && elem.defaultView;
-  }
-
-  jQuery.offset = {
-    setOffset(elem, options, i) {
-      let curPosition; let curLeft; let curCSSTop; let curTop; let curOffset; let curCSSLeft; let calculatePosition;
-      const position = jQuery.css(elem, 'position');
-      const curElem = jQuery(elem);
-      const props = {};
-
-      // Set position first, in-case top/left are set even on static elem
-      if (position === 'static') {
-        elem.style.position = 'relative';
-      }
-
-      curOffset = curElem.offset();
-      curCSSTop = jQuery.css(elem, 'top');
-      curCSSLeft = jQuery.css(elem, 'left');
-      calculatePosition = (position === 'absolute' || position === 'fixed')
-			&& (curCSSTop + curCSSLeft).indexOf('auto') > -1;
-
-      // Need to be able to calculate position if either top or left is auto and position is either absolute or fixed
-      if (calculatePosition) {
-        curPosition = curElem.position();
-        curTop = curPosition.top;
-        curLeft = curPosition.left;
-      } else {
-        curTop = parseFloat(curCSSTop) || 0;
-        curLeft = parseFloat(curCSSLeft) || 0;
-      }
-
-      if (jQuery.isFunction(options)) {
-        options = options.call(elem, i, curOffset);
-      }
-
-      if (options.top != null) {
-        props.top = (options.top - curOffset.top) + curTop;
-      }
-      if (options.left != null) {
-        props.left = (options.left - curOffset.left) + curLeft;
-      }
-
-      if ('using' in options) {
-        options.using.call(elem, props);
-      } else {
-        curElem.css(props);
-      }
-    },
-  };
-
-  jQuery.fn.extend({
-    offset(options) {
-      if (arguments.length) {
-        return options === undefined
-          ? this
-          : this.each(function (i) {
-            jQuery.offset.setOffset(this, options, i);
-          });
-      }
-
-      let docElem; let win;
-      const elem = this[0];
-      let box = { top: 0, left: 0 };
-      const doc = elem && elem.ownerDocument;
-
-      if (!doc) {
-        return;
-      }
-
-      docElem = doc.documentElement;
-
-      // Make sure it's not a disconnected DOM node
-      if (!jQuery.contains(docElem, elem)) {
-        return box;
-      }
-
-      // If we don't have gBCR, just use 0,0 rather than error
-      // BlackBerry 5, iOS 3 (original iPhone)
-      if (typeof elem.getBoundingClientRect !== strundefined) {
-        box = elem.getBoundingClientRect();
-      }
-      win = getWindow(doc);
-      return {
-        top: box.top + win.pageYOffset - docElem.clientTop,
-        left: box.left + win.pageXOffset - docElem.clientLeft,
-      };
-    },
-
-    position() {
-      if (!this[0]) {
-        return;
-      }
-
-      let offsetParent; let offset;
-      const elem = this[0];
-      let parentOffset = { top: 0, left: 0 };
-
-      // Fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent
-      if (jQuery.css(elem, 'position') === 'fixed') {
-        // We assume that getBoundingClientRect is available when computed position is fixed
-        offset = elem.getBoundingClientRect();
-      } else {
-        // Get *real* offsetParent
-        offsetParent = this.offsetParent();
-
-        // Get correct offsets
-        offset = this.offset();
-        if (!jQuery.nodeName(offsetParent[0], 'html')) {
-          parentOffset = offsetParent.offset();
-        }
-
-        // Add offsetParent borders
-        parentOffset.top += jQuery.css(offsetParent[0], 'borderTopWidth', true);
-        parentOffset.left += jQuery.css(offsetParent[0], 'borderLeftWidth', true);
-      }
-
-      // Subtract parent offsets and element margins
-      return {
-        top: offset.top - parentOffset.top - jQuery.css(elem, 'marginTop', true),
-        left: offset.left - parentOffset.left - jQuery.css(elem, 'marginLeft', true),
-      };
-    },
-
-    offsetParent() {
-      return this.map(function () {
-        let offsetParent = this.offsetParent || docElem;
-
-        while (offsetParent && (!jQuery.nodeName(offsetParent, 'html') && jQuery.css(offsetParent, 'position') === 'static')) {
-          offsetParent = offsetParent.offsetParent;
-        }
-
-        return offsetParent || docElem;
-      });
-    },
-  });
-
-  // Create scrollLeft and scrollTop methods
-  jQuery.each({ scrollLeft: 'pageXOffset', scrollTop: 'pageYOffset' }, (method, prop) => {
-    const top = prop === 'pageYOffset';
-
-    jQuery.fn[method] = function (val) {
-      return access(this, (elem, method, val) => {
-        const win = getWindow(elem);
-
-        if (val === undefined) {
-          return win ? win[prop] : elem[method];
-        }
-
-        if (win) {
-          win.scrollTo(
-            !top ? val : window.pageXOffset,
-            top ? val : window.pageYOffset,
-          );
-        } else {
-          elem[method] = val;
-        }
-      }, method, val, arguments.length, null);
-    };
-  });
-
-  // Add the top/left cssHooks using jQuery.fn.position
-  // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
-  // getComputedStyle returns percent when specified for top/left/bottom/right
-  // rather than make the css module depend on the offset module, we just check for it here
-  jQuery.each(['top', 'left'], (i, prop) => {
-    jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition,
-      (elem, computed) => {
-        if (computed) {
-          computed = curCSS(elem, prop);
-          // if curCSS returns percentage, fallback to offset
-          return rnumnonpx.test(computed)
-            ? `${jQuery(elem).position()[prop]}px`
-            : computed;
-        }
-      });
-  });
-
-  // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
-  jQuery.each({ Height: 'height', Width: 'width' }, (name, type) => {
-    jQuery.each({ padding: `inner${name}`, content: type, '': `outer${name}` }, (defaultExtra, funcName) => {
-      // margin is only for outerHeight, outerWidth
-      jQuery.fn[funcName] = function (margin, value) {
-        const chainable = arguments.length && (defaultExtra || typeof margin !== 'boolean');
-        const extra = defaultExtra || (margin === true || value === true ? 'margin' : 'border');
-
-        return access(this, (elem, type, value) => {
-          let doc;
-
-          if (jQuery.isWindow(elem)) {
-            // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
-            // isn't a whole lot we can do. See pull request at this URL for discussion:
-            // https://github.com/jquery/jquery/pull/764
-            return elem.document.documentElement[`client${name}`];
-          }
-
-          // Get document width or height
-          if (elem.nodeType === 9) {
-            doc = elem.documentElement;
-
-            // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
-            // whichever is greatest
-            return Math.max(
-              elem.body[`scroll${name}`], doc[`scroll${name}`],
-              elem.body[`offset${name}`], doc[`offset${name}`],
-              doc[`client${name}`],
-            );
-          }
-
-          return value === undefined
-          // Get width or height on the element, requesting but not forcing parseFloat
-            ? jQuery.css(elem, type, extra)
-
-          // Set width or height on the element
-            : jQuery.style(elem, type, value, extra);
-        }, type, chainable ? margin : undefined, chainable, null);
-      };
-    });
-  });
-
-  // The number of elements contained in the matched element set
-  jQuery.fn.size = function () {
-    return this.length;
-  };
-
-  jQuery.fn.andSelf = jQuery.fn.addBack;
-
-  // Register as a named AMD module, since jQuery can be concatenated with other
-  // files that may use define, but not via a proper concatenation script that
-  // understands anonymous AMD modules. A named AMD is safest and most robust
-  // way to register. Lowercase jquery is used because AMD module names are
-  // derived from file names, and jQuery is normally delivered in a lowercase
-  // file name. Do this after creating the global so that if an AMD module wants
-  // to call noConflict to hide this version of jQuery, it will work.
-  if (typeof define === 'function' && define.amd) {
-    define('jquery', [], () => jQuery);
-  }
-
-  const
-    // Map over jQuery in case of overwrite
-    _jQuery = window.jQuery;
-
-  // Map over the $ in case of overwrite
-  const _$ = window.$;
-
-  jQuery.noConflict = function (deep) {
-    if (window.$ === jQuery) {
-      window.$ = _$;
-    }
-
-    if (deep && window.jQuery === jQuery) {
-      window.jQuery = _jQuery;
-    }
-
-    return jQuery;
-  };
-
-  // Expose jQuery and $ identifiers, even in
-  // AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
-  // and CommonJS for browser emulators (#13566)
-  if (typeof noGlobal === strundefined) {
-    window.jQuery = window.$ = jQuery;
-  }
-
-  return jQuery;
-}));
diff --git a/packages/mindplot/src/components/libraries/jquery/jquery-2.1.0.min.js b/packages/mindplot/src/components/libraries/jquery/jquery-2.1.0.min.js
deleted file mode 100644
index cf64da21..00000000
--- a/packages/mindplot/src/components/libraries/jquery/jquery-2.1.0.min.js
+++ /dev/null
@@ -1,185 +0,0 @@
-/*! jQuery v2.1.0 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license */
-!(function (a, b) { typeof module === 'object' && typeof module.exports === 'object' ? module.exports = a.document ? b(a, !0) : function (a) { if (!a.document) throw new Error('jQuery requires a window with a document'); return b(a); } : b(a); }(typeof window !== 'undefined' ? window : this, (a, b) => {
-  const c = []; const d = c.slice; const e = c.concat; const f = c.push; const g = c.indexOf; const h = {}; const i = h.toString; const j = h.hasOwnProperty; const k = ''.trim; const l = {}; const m = a.document; const n = '2.1.0'; var o = function (a, b) { return new o.fn.init(a, b); }; const p = /^-ms-/; const q = /-([\da-z])/gi; const r = function (a, b) { return b.toUpperCase(); }; o.fn = o.prototype = {
-    jquery: n, constructor: o, selector: '', length: 0, toArray() { return d.call(this); }, get(a) { return a != null ? a < 0 ? this[a + this.length] : this[a] : d.call(this); }, pushStack(a) { const b = o.merge(this.constructor(), a); return b.prevObject = this, b.context = this.context, b; }, each(a, b) { return o.each(this, a, b); }, map(a) { return this.pushStack(o.map(this, (b, c) => a.call(b, c, b))); }, slice() { return this.pushStack(d.apply(this, arguments)); }, first() { return this.eq(0); }, last() { return this.eq(-1); }, eq(a) { const b = this.length; const c = +a + (a < 0 ? b : 0); return this.pushStack(c >= 0 && b > c ? [this[c]] : []); }, end() { return this.prevObject || this.constructor(null); }, push: f, sort: c.sort, splice: c.splice,
-  }, o.extend = o.fn.extend = function () { let a; let b; let c; let d; let e; let f; let g = arguments[0] || {}; let h = 1; const i = arguments.length; let j = !1; for (typeof g === 'boolean' && (j = g, g = arguments[h] || {}, h++), typeof g === 'object' || o.isFunction(g) || (g = {}), h === i && (g = this, h--); i > h; h++) if ((a = arguments[h]) != null) for (b in a)c = g[b], d = a[b], g !== d && (j && d && (o.isPlainObject(d) || (e = o.isArray(d))) ? (e ? (e = !1, f = c && o.isArray(c) ? c : []) : f = c && o.isPlainObject(c) ? c : {}, g[b] = o.extend(j, f, d)) : void 0 !== d && (g[b] = d)); return g; }, o.extend({
-    expando: `jQuery${(n + Math.random()).replace(/\D/g, '')}`, isReady: !0, error(a) { throw new Error(a); }, noop() {}, isFunction(a) { return o.type(a) === 'function'; }, isArray: Array.isArray, isWindow(a) { return a != null && a === a.window; }, isNumeric(a) { return a - parseFloat(a) >= 0; }, isPlainObject(a) { if (o.type(a) !== 'object' || a.nodeType || o.isWindow(a)) return !1; try { if (a.constructor && !j.call(a.constructor.prototype, 'isPrototypeOf')) return !1; } catch (b) { return !1; } return !0; }, isEmptyObject(a) { let b; for (b in a) return !1; return !0; }, type(a) { return a == null ? `${a}` : typeof a === 'object' || typeof a === 'function' ? h[i.call(a)] || 'object' : typeof a; }, globalEval(a) { let b; const c = eval; a = o.trim(a), a && (a.indexOf('use strict') === 1 ? (b = m.createElement('script'), b.text = a, m.head.appendChild(b).parentNode.removeChild(b)) : c(a)); }, camelCase(a) { return a.replace(p, 'ms-').replace(q, r); }, nodeName(a, b) { return a.nodeName && a.nodeName.toLowerCase() === b.toLowerCase(); }, each(a, b, c) { let d; let e = 0; const f = a.length; const g = s(a); if (c) { if (g) { for (;f > e; e++) if (d = b.apply(a[e], c), d === !1) break; } else for (e in a) if (d = b.apply(a[e], c), d === !1) break; } else if (g) { for (;f > e; e++) if (d = b.call(a[e], e, a[e]), d === !1) break; } else for (e in a) if (d = b.call(a[e], e, a[e]), d === !1) break; return a; }, trim(a) { return a == null ? '' : k.call(a); }, makeArray(a, b) { const c = b || []; return a != null && (s(Object(a)) ? o.merge(c, typeof a === 'string' ? [a] : a) : f.call(c, a)), c; }, inArray(a, b, c) { return b == null ? -1 : g.call(b, a, c); }, merge(a, b) { for (var c = +b.length, d = 0, e = a.length; c > d; d++)a[e++] = b[d]; return a.length = e, a; }, grep(a, b, c) { for (var d, e = [], f = 0, g = a.length, h = !c; g > f; f++)d = !b(a[f], f), d !== h && e.push(a[f]); return e; }, map(a, b, c) { let d; let f = 0; const g = a.length; const h = s(a); const i = []; if (h) for (;g > f; f++)d = b(a[f], f, c), d != null && i.push(d); else for (f in a)d = b(a[f], f, c), d != null && i.push(d); return e.apply([], i); }, guid: 1, proxy(a, b) { let c; let e; let f; return typeof b === 'string' && (c = a[b], b = a, a = c), o.isFunction(a) ? (e = d.call(arguments, 2), f = function () { return a.apply(b || this, e.concat(d.call(arguments))); }, f.guid = a.guid = a.guid || o.guid++, f) : void 0; }, now: Date.now, support: l,
-  }), o.each('Boolean Number String Function Array Date RegExp Object Error'.split(' '), (a, b) => { h[`[object ${b}]`] = b.toLowerCase(); }); function s(a) { const b = a.length; const c = o.type(a); return c === 'function' || o.isWindow(a) ? !1 : a.nodeType === 1 && b ? !0 : c === 'array' || b === 0 || typeof b === 'number' && b > 0 && b - 1 in a; } const t = (function (a) {
-    let b; let c; let d; let e; let f; let g; let h; let i; let j; let k; let l; let m; let n; let o; let p; let q; let r; const s = `sizzle${-new Date()}`; const t = a.document; let u = 0; let v = 0; const w = eb(); const x = eb(); const y = eb(); let z = function (a, b) { return a === b && (j = !0), 0; }; const A = 'undefined'; const B = 1 << 31; const C = {}.hasOwnProperty; let D = []; const E = D.pop; const F = D.push; let G = D.push; const H = D.slice; const I = D.indexOf || function (a) { for (let b = 0, c = this.length; c > b; b++) if (this[b] === a) return b; return -1; }; const J = 'checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped'; const K = '[\\x20\\t\\r\\n\\f]'; const L = '(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+'; const M = L.replace('w', 'w#'); const N = `\\[${K}*(${L})${K}*(?:([*^$|!~]?=)${K}*(?:(['"])((?:\\\\.|[^\\\\])*?)\\3|(${M})|)|)${K}*\\]`; const O = `:(${L})(?:\\(((['"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|${N.replace(3, 8)})*)|.*)\\)|)`; const P = new RegExp(`^${K}+|((?:^|[^\\\\])(?:\\\\.)*)${K}+$`, 'g'); const Q = new RegExp(`^${K}*,${K}*`); const R = new RegExp(`^${K}*([>+~]|${K})${K}*`); const S = new RegExp(`=${K}*([^\\]'"]*?)${K}*\\]`, 'g'); const T = new RegExp(O); const U = new RegExp(`^${M}$`); const V = {
-      ID: new RegExp(`^#(${L})`), CLASS: new RegExp(`^\\.(${L})`), TAG: new RegExp(`^(${L.replace('w', 'w*')})`), ATTR: new RegExp(`^${N}`), PSEUDO: new RegExp(`^${O}`), CHILD: new RegExp(`^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(${K}*(even|odd|(([+-]|)(\\d*)n|)${K}*(?:([+-]|)${K}*(\\d+)|))${K}*\\)|)`, 'i'), bool: new RegExp(`^(?:${J})$`, 'i'), needsContext: new RegExp(`^${K}*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(${K}*((?:-\\d)?\\d*)${K}*\\)|)(?=[^-]|$)`, 'i'),
-    }; const W = /^(?:input|select|textarea|button)$/i; const X = /^h\d$/i; const Y = /^[^{]+\{\s*\[native \w/; const Z = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/; const $ = /[+~]/; const _ = /'|\\/g; const ab = new RegExp(`\\\\([\\da-f]{1,6}${K}?|(${K})|.)`, 'ig'); const bb = function (a, b, c) { const d = `0x${b}` - 65536; return d !== d || c ? b : d < 0 ? String.fromCharCode(d + 65536) : String.fromCharCode(d >> 10 | 55296, 1023 & d | 56320); }; try { G.apply(D = H.call(t.childNodes), t.childNodes), D[t.childNodes.length].nodeType; } catch (cb) { G = { apply: D.length ? function (a, b) { F.apply(a, H.call(b)); } : function (a, b) { let c = a.length; let d = 0; while (a[c++] = b[d++]);a.length = c - 1; } }; } function db(a, b, d, e) { let f; let g; let h; let i; let j; let m; let p; let q; let u; let v; if ((b ? b.ownerDocument || b : t) !== l && k(b), b = b || l, d = d || [], !a || typeof a !== 'string') return d; if ((i = b.nodeType) !== 1 && i !== 9) return []; if (n && !e) { if (f = Z.exec(a)) if (h = f[1]) { if (i === 9) { if (g = b.getElementById(h), !g || !g.parentNode) return d; if (g.id === h) return d.push(g), d; } else if (b.ownerDocument && (g = b.ownerDocument.getElementById(h)) && r(b, g) && g.id === h) return d.push(g), d; } else { if (f[2]) return G.apply(d, b.getElementsByTagName(a)), d; if ((h = f[3]) && c.getElementsByClassName && b.getElementsByClassName) return G.apply(d, b.getElementsByClassName(h)), d; } if (c.qsa && (!o || !o.test(a))) { if (q = p = s, u = b, v = i === 9 && a, i === 1 && b.nodeName.toLowerCase() !== 'object') { m = ob(a), (p = b.getAttribute('id')) ? q = p.replace(_, '\\$&') : b.setAttribute('id', q), q = `[id='${q}'] `, j = m.length; while (j--)m[j] = q + pb(m[j]); u = $.test(a) && mb(b.parentNode) || b, v = m.join(','); } if (v) try { return G.apply(d, u.querySelectorAll(v)), d; } catch (w) {} finally { p || b.removeAttribute('id'); } } } return xb(a.replace(P, '$1'), b, d, e); } function eb() { const a = []; function b(c, e) { return a.push(`${c} `) > d.cacheLength && delete b[a.shift()], b[`${c} `] = e; } return b; } function fb(a) { return a[s] = !0, a; } function gb(a) { let b = l.createElement('div'); try { return !!a(b); } catch (c) { return !1; } finally { b.parentNode && b.parentNode.removeChild(b), b = null; } } function hb(a, b) { const c = a.split('|'); let e = a.length; while (e--)d.attrHandle[c[e]] = b; } function ib(a, b) { let c = b && a; const d = c && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || B) - (~a.sourceIndex || B); if (d) return d; if (c) while (c = c.nextSibling) if (c === b) return -1; return a ? 1 : -1; } function jb(a) { return function (b) { const c = b.nodeName.toLowerCase(); return c === 'input' && b.type === a; }; } function kb(a) { return function (b) { const c = b.nodeName.toLowerCase(); return (c === 'input' || c === 'button') && b.type === a; }; } function lb(a) { return fb((b) => (b = +b, fb((c, d) => { let e; const f = a([], c.length, b); let g = f.length; while (g--)c[e = f[g]] && (c[e] = !(d[e] = c[e])); }))); } function mb(a) { return a && typeof a.getElementsByTagName !== A && a; }c = db.support = {}, f = db.isXML = function (a) { const b = a && (a.ownerDocument || a).documentElement; return b ? b.nodeName !== 'HTML' : !1; }, k = db.setDocument = function (a) { let b; const e = a ? a.ownerDocument || a : t; const g = e.defaultView; return e !== l && e.nodeType === 9 && e.documentElement ? (l = e, m = e.documentElement, n = !f(e), g && g !== g.top && (g.addEventListener ? g.addEventListener('unload', () => { k(); }, !1) : g.attachEvent && g.attachEvent('onunload', () => { k(); })), c.attributes = gb((a) => (a.className = 'i', !a.getAttribute('className'))), c.getElementsByTagName = gb((a) => (a.appendChild(e.createComment('')), !a.getElementsByTagName('*').length)), c.getElementsByClassName = Y.test(e.getElementsByClassName) && gb((a) => (a.innerHTML = "<div class='a'></div><div class='a i'></div>", a.firstChild.className = 'i', a.getElementsByClassName('i').length === 2)), c.getById = gb((a) => (m.appendChild(a).id = s, !e.getElementsByName || !e.getElementsByName(s).length)), c.getById ? (d.find.ID = function (a, b) { if (typeof b.getElementById !== A && n) { const c = b.getElementById(a); return c && c.parentNode ? [c] : []; } }, d.filter.ID = function (a) { const b = a.replace(ab, bb); return function (a) { return a.getAttribute('id') === b; }; }) : (delete d.find.ID, d.filter.ID = function (a) { const b = a.replace(ab, bb); return function (a) { const c = typeof a.getAttributeNode !== A && a.getAttributeNode('id'); return c && c.value === b; }; }), d.find.TAG = c.getElementsByTagName ? function (a, b) { return typeof b.getElementsByTagName !== A ? b.getElementsByTagName(a) : void 0; } : function (a, b) { let c; const d = []; let e = 0; const f = b.getElementsByTagName(a); if (a === '*') { while (c = f[e++])c.nodeType === 1 && d.push(c); return d; } return f; }, d.find.CLASS = c.getElementsByClassName && function (a, b) { return typeof b.getElementsByClassName !== A && n ? b.getElementsByClassName(a) : void 0; }, p = [], o = [], (c.qsa = Y.test(e.querySelectorAll)) && (gb((a) => { a.innerHTML = "<select t=''><option selected=''></option></select>", a.querySelectorAll("[t^='']").length && o.push(`[*^$]=${K}*(?:''|"")`), a.querySelectorAll('[selected]').length || o.push(`\\[${K}*(?:value|${J})`), a.querySelectorAll(':checked').length || o.push(':checked'); }), gb((a) => { const b = e.createElement('input'); b.setAttribute('type', 'hidden'), a.appendChild(b).setAttribute('name', 'D'), a.querySelectorAll('[name=d]').length && o.push(`name${K}*[*^$|!~]?=`), a.querySelectorAll(':enabled').length || o.push(':enabled', ':disabled'), a.querySelectorAll('*,:x'), o.push(',.*:'); })), (c.matchesSelector = Y.test(q = m.webkitMatchesSelector || m.mozMatchesSelector || m.oMatchesSelector || m.msMatchesSelector)) && gb((a) => { c.disconnectedMatch = q.call(a, 'div'), q.call(a, "[s!='']:x"), p.push('!=', O); }), o = o.length && new RegExp(o.join('|')), p = p.length && new RegExp(p.join('|')), b = Y.test(m.compareDocumentPosition), r = b || Y.test(m.contains) ? function (a, b) { const c = a.nodeType === 9 ? a.documentElement : a; const d = b && b.parentNode; return a === d || !(!d || d.nodeType !== 1 || !(c.contains ? c.contains(d) : a.compareDocumentPosition && 16 & a.compareDocumentPosition(d))); } : function (a, b) { if (b) while (b = b.parentNode) if (b === a) return !0; return !1; }, z = b ? function (a, b) { if (a === b) return j = !0, 0; let d = !a.compareDocumentPosition - !b.compareDocumentPosition; return d || (d = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1, 1 & d || !c.sortDetached && b.compareDocumentPosition(a) === d ? a === e || a.ownerDocument === t && r(t, a) ? -1 : b === e || b.ownerDocument === t && r(t, b) ? 1 : i ? I.call(i, a) - I.call(i, b) : 0 : 4 & d ? -1 : 1); } : function (a, b) { if (a === b) return j = !0, 0; let c; let d = 0; const f = a.parentNode; const g = b.parentNode; const h = [a]; const k = [b]; if (!f || !g) return a === e ? -1 : b === e ? 1 : f ? -1 : g ? 1 : i ? I.call(i, a) - I.call(i, b) : 0; if (f === g) return ib(a, b); c = a; while (c = c.parentNode)h.unshift(c); c = b; while (c = c.parentNode)k.unshift(c); while (h[d] === k[d])d++; return d ? ib(h[d], k[d]) : h[d] === t ? -1 : k[d] === t ? 1 : 0; }, e) : l; }, db.matches = function (a, b) { return db(a, null, null, b); }, db.matchesSelector = function (a, b) { if ((a.ownerDocument || a) !== l && k(a), b = b.replace(S, "='$1']"), !(!c.matchesSelector || !n || p && p.test(b) || o && o.test(b))) try { const d = q.call(a, b); if (d || c.disconnectedMatch || a.document && a.document.nodeType !== 11) return d; } catch (e) {} return db(b, l, null, [a]).length > 0; }, db.contains = function (a, b) { return (a.ownerDocument || a) !== l && k(a), r(a, b); }, db.attr = function (a, b) { (a.ownerDocument || a) !== l && k(a); const e = d.attrHandle[b.toLowerCase()]; let f = e && C.call(d.attrHandle, b.toLowerCase()) ? e(a, b, !n) : void 0; return void 0 !== f ? f : c.attributes || !n ? a.getAttribute(b) : (f = a.getAttributeNode(b)) && f.specified ? f.value : null; }, db.error = function (a) { throw new Error(`Syntax error, unrecognized expression: ${a}`); }, db.uniqueSort = function (a) { let b; const d = []; let e = 0; let f = 0; if (j = !c.detectDuplicates, i = !c.sortStable && a.slice(0), a.sort(z), j) { while (b = a[f++])b === a[f] && (e = d.push(f)); while (e--)a.splice(d[e], 1); } return i = null, a; }, e = db.getText = function (a) { let b; let c = ''; let d = 0; const f = a.nodeType; if (f) { if (f === 1 || f === 9 || f === 11) { if (typeof a.textContent === 'string') return a.textContent; for (a = a.firstChild; a; a = a.nextSibling)c += e(a); } else if (f === 3 || f === 4) return a.nodeValue; } else while (b = a[d++])c += e(b); return c; }, d = db.selectors = {
-      cacheLength: 50,
-      createPseudo: fb,
-      match: V,
-      attrHandle: {},
-      find: {},
-      relative: {
-        '>': { dir: 'parentNode', first: !0 }, ' ': { dir: 'parentNode' }, '+': { dir: 'previousSibling', first: !0 }, '~': { dir: 'previousSibling' },
-      },
-      preFilter: { ATTR(a) { return a[1] = a[1].replace(ab, bb), a[3] = (a[4] || a[5] || '').replace(ab, bb), a[2] === '~=' && (a[3] = ` ${a[3]} `), a.slice(0, 4); }, CHILD(a) { return a[1] = a[1].toLowerCase(), a[1].slice(0, 3) === 'nth' ? (a[3] || db.error(a[0]), a[4] = +(a[4] ? a[5] + (a[6] || 1) : 2 * (a[3] === 'even' || a[3] === 'odd')), a[5] = +(a[7] + a[8] || a[3] === 'odd')) : a[3] && db.error(a[0]), a; }, PSEUDO(a) { let b; const c = !a[5] && a[2]; return V.CHILD.test(a[0]) ? null : (a[3] && void 0 !== a[4] ? a[2] = a[4] : c && T.test(c) && (b = ob(c, !0)) && (b = c.indexOf(')', c.length - b) - c.length) && (a[0] = a[0].slice(0, b), a[2] = c.slice(0, b)), a.slice(0, 3)); } },
-      filter: {
-        TAG(a) { const b = a.replace(ab, bb).toLowerCase(); return a === '*' ? function () { return !0; } : function (a) { return a.nodeName && a.nodeName.toLowerCase() === b; }; }, CLASS(a) { let b = w[`${a} `]; return b || (b = new RegExp(`(^|${K})${a}(${K}|$)`)) && w(a, (a) => b.test(typeof a.className === 'string' && a.className || typeof a.getAttribute !== A && a.getAttribute('class') || '')); }, ATTR(a, b, c) { return function (d) { let e = db.attr(d, a); return e == null ? b === '!=' : b ? (e += '', b === '=' ? e === c : b === '!=' ? e !== c : b === '^=' ? c && e.indexOf(c) === 0 : b === '*=' ? c && e.indexOf(c) > -1 : b === '$=' ? c && e.slice(-c.length) === c : b === '~=' ? (` ${e} `).indexOf(c) > -1 : b === '|=' ? e === c || e.slice(0, c.length + 1) === `${c}-` : !1) : !0; }; }, CHILD(a, b, c, d, e) { const f = a.slice(0, 3) !== 'nth'; const g = a.slice(-4) !== 'last'; const h = b === 'of-type'; return d === 1 && e === 0 ? function (a) { return !!a.parentNode; } : function (b, c, i) { let j; let k; let l; let m; let n; let o; let p = f !== g ? 'nextSibling' : 'previousSibling'; const q = b.parentNode; const r = h && b.nodeName.toLowerCase(); const t = !i && !h; if (q) { if (f) { while (p) { l = b; while (l = l[p]) if (h ? l.nodeName.toLowerCase() === r : l.nodeType === 1) return !1; o = p = a === 'only' && !o && 'nextSibling'; } return !0; } if (o = [g ? q.firstChild : q.lastChild], g && t) { k = q[s] || (q[s] = {}), j = k[a] || [], n = j[0] === u && j[1], m = j[0] === u && j[2], l = n && q.childNodes[n]; while (l = ++n && l && l[p] || (m = n = 0) || o.pop()) if (l.nodeType === 1 && ++m && l === b) { k[a] = [u, n, m]; break; } } else if (t && (j = (b[s] || (b[s] = {}))[a]) && j[0] === u)m = j[1]; else while (l = ++n && l && l[p] || (m = n = 0) || o.pop()) if ((h ? l.nodeName.toLowerCase() === r : l.nodeType === 1) && ++m && (t && ((l[s] || (l[s] = {}))[a] = [u, m]), l === b)) break; return m -= e, m === d || m % d === 0 && m / d >= 0; } }; }, PSEUDO(a, b) { let c; const e = d.pseudos[a] || d.setFilters[a.toLowerCase()] || db.error(`unsupported pseudo: ${a}`); return e[s] ? e(b) : e.length > 1 ? (c = [a, a, '', b], d.setFilters.hasOwnProperty(a.toLowerCase()) ? fb((a, c) => { let d; const f = e(a, b); let g = f.length; while (g--)d = I.call(a, f[g]), a[d] = !(c[d] = f[g]); }) : function (a) { return e(a, 0, c); }) : e; },
-      },
-      pseudos: {
-        not: fb((a) => { const b = []; const c = []; const d = g(a.replace(P, '$1')); return d[s] ? fb((a, b, c, e) => { let f; const g = d(a, null, e, []); let h = a.length; while (h--)(f = g[h]) && (a[h] = !(b[h] = f)); }) : function (a, e, f) { return b[0] = a, d(b, null, f, c), !c.pop(); }; }), has: fb((a) => function (b) { return db(a, b).length > 0; }), contains: fb((a) => function (b) { return (b.textContent || b.innerText || e(b)).indexOf(a) > -1; }), lang: fb((a) => (U.test(a || '') || db.error(`unsupported lang: ${a}`), a = a.replace(ab, bb).toLowerCase(), function (b) { let c; do if (c = n ? b.lang : b.getAttribute('xml:lang') || b.getAttribute('lang')) return c = c.toLowerCase(), c === a || c.indexOf(`${a}-`) === 0; while ((b = b.parentNode) && b.nodeType === 1); return !1; })), target(b) { const c = a.location && a.location.hash; return c && c.slice(1) === b.id; }, root(a) { return a === m; }, focus(a) { return a === l.activeElement && (!l.hasFocus || l.hasFocus()) && !!(a.type || a.href || ~a.tabIndex); }, enabled(a) { return a.disabled === !1; }, disabled(a) { return a.disabled === !0; }, checked(a) { const b = a.nodeName.toLowerCase(); return b === 'input' && !!a.checked || b === 'option' && !!a.selected; }, selected(a) { return a.parentNode && a.parentNode.selectedIndex, a.selected === !0; }, empty(a) { for (a = a.firstChild; a; a = a.nextSibling) if (a.nodeType < 6) return !1; return !0; }, parent(a) { return !d.pseudos.empty(a); }, header(a) { return X.test(a.nodeName); }, input(a) { return W.test(a.nodeName); }, button(a) { const b = a.nodeName.toLowerCase(); return b === 'input' && a.type === 'button' || b === 'button'; }, text(a) { let b; return a.nodeName.toLowerCase() === 'input' && a.type === 'text' && ((b = a.getAttribute('type')) == null || b.toLowerCase() === 'text'); }, first: lb(() => [0]), last: lb((a, b) => [b - 1]), eq: lb((a, b, c) => [c < 0 ? c + b : c]), even: lb((a, b) => { for (let c = 0; b > c; c += 2)a.push(c); return a; }), odd: lb((a, b) => { for (let c = 1; b > c; c += 2)a.push(c); return a; }), lt: lb((a, b, c) => { for (let d = c < 0 ? c + b : c; --d >= 0;)a.push(d); return a; }), gt: lb((a, b, c) => { for (let d = c < 0 ? c + b : c; ++d < b;)a.push(d); return a; }),
-      },
-    }, d.pseudos.nth = d.pseudos.eq; for (b in {
-      radio: !0, checkbox: !0, file: !0, password: !0, image: !0,
-    })d.pseudos[b] = jb(b); for (b in { submit: !0, reset: !0 })d.pseudos[b] = kb(b); function nb() {}nb.prototype = d.filters = d.pseudos, d.setFilters = new nb(); function ob(a, b) { let c; let e; let f; let g; let h; let i; let j; const k = x[`${a} `]; if (k) return b ? 0 : k.slice(0); h = a, i = [], j = d.preFilter; while (h) { (!c || (e = Q.exec(h))) && (e && (h = h.slice(e[0].length) || h), i.push(f = [])), c = !1, (e = R.exec(h)) && (c = e.shift(), f.push({ value: c, type: e[0].replace(P, ' ') }), h = h.slice(c.length)); for (g in d.filter)!(e = V[g].exec(h)) || j[g] && !(e = j[g](e)) || (c = e.shift(), f.push({ value: c, type: g, matches: e }), h = h.slice(c.length)); if (!c) break; } return b ? h.length : h ? db.error(a) : x(a, i).slice(0); } function pb(a) { for (var b = 0, c = a.length, d = ''; c > b; b++)d += a[b].value; return d; } function qb(a, b, c) { const d = b.dir; const e = c && d === 'parentNode'; const f = v++; return b.first ? function (b, c, f) { while (b = b[d]) if (b.nodeType === 1 || e) return a(b, c, f); } : function (b, c, g) { let h; let i; const j = [u, f]; if (g) { while (b = b[d]) if ((b.nodeType === 1 || e) && a(b, c, g)) return !0; } else while (b = b[d]) if (b.nodeType === 1 || e) { if (i = b[s] || (b[s] = {}), (h = i[d]) && h[0] === u && h[1] === f) return j[2] = h[2]; if (i[d] = j, j[2] = a(b, c, g)) return !0; } }; } function rb(a) { return a.length > 1 ? function (b, c, d) { let e = a.length; while (e--) if (!a[e](b, c, d)) return !1; return !0; } : a[0]; } function sb(a, b, c, d, e) { for (var f, g = [], h = 0, i = a.length, j = b != null; i > h; h++)(f = a[h]) && (!c || c(f, d, e)) && (g.push(f), j && b.push(h)); return g; } function tb(a, b, c, d, e, f) { return d && !d[s] && (d = tb(d)), e && !e[s] && (e = tb(e, f)), fb((f, g, h, i) => { let j; let k; let l; const m = []; const n = []; const o = g.length; const p = f || wb(b || '*', h.nodeType ? [h] : h, []); const q = !a || !f && b ? p : sb(p, m, a, h, i); let r = c ? e || (f ? a : o || d) ? [] : g : q; if (c && c(q, r, h, i), d) { j = sb(r, n), d(j, [], h, i), k = j.length; while (k--)(l = j[k]) && (r[n[k]] = !(q[n[k]] = l)); } if (f) { if (e || a) { if (e) { j = [], k = r.length; while (k--)(l = r[k]) && j.push(q[k] = l); e(null, r = [], j, i); }k = r.length; while (k--)(l = r[k]) && (j = e ? I.call(f, l) : m[k]) > -1 && (f[j] = !(g[j] = l)); } } else r = sb(r === g ? r.splice(o, r.length) : r), e ? e(null, g, r, i) : G.apply(g, r); }); } function ub(a) { for (var b, c, e, f = a.length, g = d.relative[a[0].type], i = g || d.relative[' '], j = g ? 1 : 0, k = qb((a) => a === b, i, !0), l = qb((a) => I.call(b, a) > -1, i, !0), m = [function (a, c, d) { return !g && (d || c !== h) || ((b = c).nodeType ? k(a, c, d) : l(a, c, d)); }]; f > j; j++) if (c = d.relative[a[j].type])m = [qb(rb(m), c)]; else { if (c = d.filter[a[j].type].apply(null, a[j].matches), c[s]) { for (e = ++j; f > e; e++) if (d.relative[a[e].type]) break; return tb(j > 1 && rb(m), j > 1 && pb(a.slice(0, j - 1).concat({ value: a[j - 2].type === ' ' ? '*' : '' })).replace(P, '$1'), c, e > j && ub(a.slice(j, e)), f > e && ub(a = a.slice(e)), f > e && pb(a)); }m.push(c); } return rb(m); } function vb(a, b) { const c = b.length > 0; const e = a.length > 0; const f = function (f, g, i, j, k) { let m; let n; let o; let p = 0; let q = '0'; const r = f && []; let s = []; const t = h; const v = f || e && d.find.TAG('*', k); const w = u += t == null ? 1 : Math.random() || 0.1; const x = v.length; for (k && (h = g !== l && g); q !== x && (m = v[q]) != null; q++) { if (e && m) { n = 0; while (o = a[n++]) if (o(m, g, i)) { j.push(m); break; }k && (u = w); }c && ((m = !o && m) && p--, f && r.push(m)); } if (p += q, c && q !== p) { n = 0; while (o = b[n++])o(r, s, g, i); if (f) { if (p > 0) while (q--)r[q] || s[q] || (s[q] = E.call(j)); s = sb(s); }G.apply(j, s), k && !f && s.length > 0 && p + b.length > 1 && db.uniqueSort(j); } return k && (u = w, h = t), r; }; return c ? fb(f) : f; }g = db.compile = function (a, b) { let c; const d = []; const e = []; let f = y[`${a} `]; if (!f) { b || (b = ob(a)), c = b.length; while (c--)f = ub(b[c]), f[s] ? d.push(f) : e.push(f); f = y(a, vb(e, d)); } return f; }; function wb(a, b, c) { for (let d = 0, e = b.length; e > d; d++)db(a, b[d], c); return c; } function xb(a, b, e, f) { let h; let i; let j; let k; let l; const m = ob(a); if (!f && m.length === 1) { if (i = m[0] = m[0].slice(0), i.length > 2 && (j = i[0]).type === 'ID' && c.getById && b.nodeType === 9 && n && d.relative[i[1].type]) { if (b = (d.find.ID(j.matches[0].replace(ab, bb), b) || [])[0], !b) return e; a = a.slice(i.shift().value.length); }h = V.needsContext.test(a) ? 0 : i.length; while (h--) { if (j = i[h], d.relative[k = j.type]) break; if ((l = d.find[k]) && (f = l(j.matches[0].replace(ab, bb), $.test(i[0].type) && mb(b.parentNode) || b))) { if (i.splice(h, 1), a = f.length && pb(i), !a) return G.apply(e, f), e; break; } } } return g(a, m)(f, b, !n, e, $.test(a) && mb(b.parentNode) || b), e; } return c.sortStable = s.split('').sort(z).join('') === s, c.detectDuplicates = !!j, k(), c.sortDetached = gb((a) => 1 & a.compareDocumentPosition(l.createElement('div'))), gb((a) => (a.innerHTML = "<a href='#'></a>", a.firstChild.getAttribute('href') === '#')) || hb('type|href|height|width', (a, b, c) => (c ? void 0 : a.getAttribute(b, b.toLowerCase() === 'type' ? 1 : 2))), c.attributes && gb((a) => (a.innerHTML = '<input/>', a.firstChild.setAttribute('value', ''), a.firstChild.getAttribute('value') === '')) || hb('value', (a, b, c) => (c || a.nodeName.toLowerCase() !== 'input' ? void 0 : a.defaultValue)), gb((a) => a.getAttribute('disabled') == null) || hb(J, (a, b, c) => { let d; return c ? void 0 : a[b] === !0 ? b.toLowerCase() : (d = a.getAttributeNode(b)) && d.specified ? d.value : null; }), db;
-  }(a)); o.find = t, o.expr = t.selectors, o.expr[':'] = o.expr.pseudos, o.unique = t.uniqueSort, o.text = t.getText, o.isXMLDoc = t.isXML, o.contains = t.contains; const u = o.expr.match.needsContext; const v = /^<(\w+)\s*\/?>(?:<\/\1>|)$/; const w = /^.[^:#\[\.,]*$/; function x(a, b, c) { if (o.isFunction(b)) return o.grep(a, (a, d) => !!b.call(a, d, a) !== c); if (b.nodeType) return o.grep(a, (a) => a === b !== c); if (typeof b === 'string') { if (w.test(b)) return o.filter(b, a, c); b = o.filter(b, a); } return o.grep(a, (a) => g.call(b, a) >= 0 !== c); }o.filter = function (a, b, c) { const d = b[0]; return c && (a = `:not(${a})`), b.length === 1 && d.nodeType === 1 ? o.find.matchesSelector(d, a) ? [d] : [] : o.find.matches(a, o.grep(b, (a) => a.nodeType === 1)); }, o.fn.extend({
-    find(a) { let b; const c = this.length; let d = []; const e = this; if (typeof a !== 'string') return this.pushStack(o(a).filter(function () { for (b = 0; c > b; b++) if (o.contains(e[b], this)) return !0; })); for (b = 0; c > b; b++)o.find(a, e[b], d); return d = this.pushStack(c > 1 ? o.unique(d) : d), d.selector = this.selector ? `${this.selector} ${a}` : a, d; }, filter(a) { return this.pushStack(x(this, a || [], !1)); }, not(a) { return this.pushStack(x(this, a || [], !0)); }, is(a) { return !!x(this, typeof a === 'string' && u.test(a) ? o(a) : a || [], !1).length; },
-  }); let y; const z = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/; const A = o.fn.init = function (a, b) { let c; let d; if (!a) return this; if (typeof a === 'string') { if (c = a[0] === '<' && a[a.length - 1] === '>' && a.length >= 3 ? [null, a, null] : z.exec(a), !c || !c[1] && b) return !b || b.jquery ? (b || y).find(a) : this.constructor(b).find(a); if (c[1]) { if (b = b instanceof o ? b[0] : b, o.merge(this, o.parseHTML(c[1], b && b.nodeType ? b.ownerDocument || b : m, !0)), v.test(c[1]) && o.isPlainObject(b)) for (c in b)o.isFunction(this[c]) ? this[c](b[c]) : this.attr(c, b[c]); return this; } return d = m.getElementById(c[2]), d && d.parentNode && (this.length = 1, this[0] = d), this.context = m, this.selector = a, this; } return a.nodeType ? (this.context = this[0] = a, this.length = 1, this) : o.isFunction(a) ? typeof y.ready !== 'undefined' ? y.ready(a) : a(o) : (void 0 !== a.selector && (this.selector = a.selector, this.context = a.context), o.makeArray(a, this)); }; A.prototype = o.fn, y = o(m); const B = /^(?:parents|prev(?:Until|All))/; const C = {
-    children: !0, contents: !0, next: !0, prev: !0,
-  }; o.extend({ dir(a, b, c) { const d = []; const e = void 0 !== c; while ((a = a[b]) && a.nodeType !== 9) if (a.nodeType === 1) { if (e && o(a).is(c)) break; d.push(a); } return d; }, sibling(a, b) { for (var c = []; a; a = a.nextSibling)a.nodeType === 1 && a !== b && c.push(a); return c; } }), o.fn.extend({
-    has(a) { const b = o(a, this); const c = b.length; return this.filter(function () { for (let a = 0; c > a; a++) if (o.contains(this, b[a])) return !0; }); }, closest(a, b) { for (var c, d = 0, e = this.length, f = [], g = u.test(a) || typeof a !== 'string' ? o(a, b || this.context) : 0; e > d; d++) for (c = this[d]; c && c !== b; c = c.parentNode) if (c.nodeType < 11 && (g ? g.index(c) > -1 : c.nodeType === 1 && o.find.matchesSelector(c, a))) { f.push(c); break; } return this.pushStack(f.length > 1 ? o.unique(f) : f); }, index(a) { return a ? typeof a === 'string' ? g.call(o(a), this[0]) : g.call(this, a.jquery ? a[0] : a) : this[0] && this[0].parentNode ? this.first().prevAll().length : -1; }, add(a, b) { return this.pushStack(o.unique(o.merge(this.get(), o(a, b)))); }, addBack(a) { return this.add(a == null ? this.prevObject : this.prevObject.filter(a)); },
-  }); function D(a, b) { while ((a = a[b]) && a.nodeType !== 1);return a; }o.each({
-    parent(a) { const b = a.parentNode; return b && b.nodeType !== 11 ? b : null; }, parents(a) { return o.dir(a, 'parentNode'); }, parentsUntil(a, b, c) { return o.dir(a, 'parentNode', c); }, next(a) { return D(a, 'nextSibling'); }, prev(a) { return D(a, 'previousSibling'); }, nextAll(a) { return o.dir(a, 'nextSibling'); }, prevAll(a) { return o.dir(a, 'previousSibling'); }, nextUntil(a, b, c) { return o.dir(a, 'nextSibling', c); }, prevUntil(a, b, c) { return o.dir(a, 'previousSibling', c); }, siblings(a) { return o.sibling((a.parentNode || {}).firstChild, a); }, children(a) { return o.sibling(a.firstChild); }, contents(a) { return a.contentDocument || o.merge([], a.childNodes); },
-  }, (a, b) => { o.fn[a] = function (c, d) { let e = o.map(this, b, c); return a.slice(-5) !== 'Until' && (d = c), d && typeof d === 'string' && (e = o.filter(d, e)), this.length > 1 && (C[a] || o.unique(e), B.test(a) && e.reverse()), this.pushStack(e); }; }); const E = /\S+/g; const F = {}; function G(a) { const b = F[a] = {}; return o.each(a.match(E) || [], (a, c) => { b[c] = !0; }), b; }o.Callbacks = function (a) {
-    a = typeof a === 'string' ? F[a] || G(a) : o.extend({}, a); let b; let c; let d; let e; let f; let g; let h = []; let i = !a.once && []; var j = function (l) { for (b = a.memory && l, c = !0, g = e || 0, e = 0, f = h.length, d = !0; h && f > g; g++) if (h[g].apply(l[0], l[1]) === !1 && a.stopOnFalse) { b = !1; break; }d = !1, h && (i ? i.length && j(i.shift()) : b ? h = [] : k.disable()); }; var k = {
-      add() { if (h) { const c = h.length; !(function g(b) { o.each(b, (b, c) => { const d = o.type(c); d === 'function' ? a.unique && k.has(c) || h.push(c) : c && c.length && d !== 'string' && g(c); }); }(arguments)), d ? f = h.length : b && (e = c, j(b)); } return this; }, remove() { return h && o.each(arguments, (a, b) => { let c; while ((c = o.inArray(b, h, c)) > -1)h.splice(c, 1), d && (f >= c && f--, g >= c && g--); }), this; }, has(a) { return a ? o.inArray(a, h) > -1 : !(!h || !h.length); }, empty() { return h = [], f = 0, this; }, disable() { return h = i = b = void 0, this; }, disabled() { return !h; }, lock() { return i = void 0, b || k.disable(), this; }, locked() { return !i; }, fireWith(a, b) { return !h || c && !i || (b = b || [], b = [a, b.slice ? b.slice() : b], d ? i.push(b) : j(b)), this; }, fire() { return k.fireWith(this, arguments), this; }, fired() { return !!c; },
-    }; return k;
-  }, o.extend({
-    Deferred(a) {
-      const b = [['resolve', 'done', o.Callbacks('once memory'), 'resolved'], ['reject', 'fail', o.Callbacks('once memory'), 'rejected'], ['notify', 'progress', o.Callbacks('memory')]]; let c = 'pending'; var d = {
-        state() { return c; }, always() { return e.done(arguments).fail(arguments), this; }, then() { let a = arguments; return o.Deferred((c) => { o.each(b, (b, f) => { const g = o.isFunction(a[b]) && a[b]; e[f[1]](function () { const a = g && g.apply(this, arguments); a && o.isFunction(a.promise) ? a.promise().done(c.resolve).fail(c.reject).progress(c.notify) : c[`${f[0]}With`](this === d ? c.promise() : this, g ? [a] : arguments); }); }), a = null; }).promise(); }, promise(a) { return a != null ? o.extend(a, d) : d; },
-      }; var e = {}; return d.pipe = d.then, o.each(b, (a, f) => { const g = f[2]; const h = f[3]; d[f[1]] = g.add, h && g.add(() => { c = h; }, b[1 ^ a][2].disable, b[2][2].lock), e[f[0]] = function () { return e[`${f[0]}With`](this === e ? d : this, arguments), this; }, e[`${f[0]}With`] = g.fireWith; }), d.promise(e), a && a.call(e, e), e;
-    },
-    when(a) { let b = 0; const c = d.call(arguments); const e = c.length; let f = e !== 1 || a && o.isFunction(a.promise) ? e : 0; const g = f === 1 ? a : o.Deferred(); const h = function (a, b, c) { return function (e) { b[a] = this, c[a] = arguments.length > 1 ? d.call(arguments) : e, c === i ? g.notifyWith(b, c) : --f || g.resolveWith(b, c); }; }; let i; let j; let k; if (e > 1) for (i = new Array(e), j = new Array(e), k = new Array(e); e > b; b++)c[b] && o.isFunction(c[b].promise) ? c[b].promise().done(h(b, k, c)).fail(g.reject).progress(h(b, j, i)) : --f; return f || g.resolveWith(k, c), g.promise(); },
-  }); let H; o.fn.ready = function (a) { return o.ready.promise().done(a), this; }, o.extend({
-    isReady: !1, readyWait: 1, holdReady(a) { a ? o.readyWait++ : o.ready(!0); }, ready(a) { (a === !0 ? --o.readyWait : o.isReady) || (o.isReady = !0, a !== !0 && --o.readyWait > 0 || (H.resolveWith(m, [o]), o.fn.trigger && o(m).trigger('ready').off('ready'))); },
-  }); function I() { m.removeEventListener('DOMContentLoaded', I, !1), a.removeEventListener('load', I, !1), o.ready(); }o.ready.promise = function (b) { return H || (H = o.Deferred(), m.readyState === 'complete' ? setTimeout(o.ready) : (m.addEventListener('DOMContentLoaded', I, !1), a.addEventListener('load', I, !1))), H.promise(b); }, o.ready.promise(); const J = o.access = function (a, b, c, d, e, f, g) { let h = 0; const i = a.length; let j = c == null; if (o.type(c) === 'object') { e = !0; for (h in c)o.access(a, b, h, c[h], !0, f, g); } else if (void 0 !== d && (e = !0, o.isFunction(d) || (g = !0), j && (g ? (b.call(a, d), b = null) : (j = b, b = function (a, b, c) { return j.call(o(a), c); })), b)) for (;i > h; h++)b(a[h], c, g ? d : d.call(a[h], h, b(a[h], c))); return e ? a : j ? b.call(a) : i ? b(a[0], c) : f; }; o.acceptData = function (a) { return a.nodeType === 1 || a.nodeType === 9 || !+a.nodeType; }; function K() { Object.defineProperty(this.cache = {}, 0, { get() { return {}; } }), this.expando = o.expando + Math.random(); }K.uid = 1, K.accepts = o.acceptData, K.prototype = {
-    key(a) { if (!K.accepts(a)) return 0; const b = {}; let c = a[this.expando]; if (!c) { c = K.uid++; try { b[this.expando] = { value: c }, Object.defineProperties(a, b); } catch (d) { b[this.expando] = c, o.extend(a, b); } } return this.cache[c] || (this.cache[c] = {}), c; }, set(a, b, c) { let d; const e = this.key(a); const f = this.cache[e]; if (typeof b === 'string')f[b] = c; else if (o.isEmptyObject(f))o.extend(this.cache[e], b); else for (d in b)f[d] = b[d]; return f; }, get(a, b) { const c = this.cache[this.key(a)]; return void 0 === b ? c : c[b]; }, access(a, b, c) { let d; return void 0 === b || b && typeof b === 'string' && void 0 === c ? (d = this.get(a, b), void 0 !== d ? d : this.get(a, o.camelCase(b))) : (this.set(a, b, c), void 0 !== c ? c : b); }, remove(a, b) { let c; let d; let e; const f = this.key(a); const g = this.cache[f]; if (void 0 === b) this.cache[f] = {}; else { o.isArray(b) ? d = b.concat(b.map(o.camelCase)) : (e = o.camelCase(b), b in g ? d = [b, e] : (d = e, d = d in g ? [d] : d.match(E) || [])), c = d.length; while (c--) delete g[d[c]]; } }, hasData(a) { return !o.isEmptyObject(this.cache[a[this.expando]] || {}); }, discard(a) { a[this.expando] && delete this.cache[a[this.expando]]; },
-  }; const L = new K(); const M = new K(); const N = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/; const
-    O = /([A-Z])/g; function P(a, b, c) { let d; if (void 0 === c && a.nodeType === 1) if (d = `data-${b.replace(O, '-$1').toLowerCase()}`, c = a.getAttribute(d), typeof c === 'string') { try { c = c === 'true' ? !0 : c === 'false' ? !1 : c === 'null' ? null : `${+c}` === c ? +c : N.test(c) ? o.parseJSON(c) : c; } catch (e) {}M.set(a, b, c); } else c = void 0; return c; }o.extend({
-    hasData(a) { return M.hasData(a) || L.hasData(a); }, data(a, b, c) { return M.access(a, b, c); }, removeData(a, b) { M.remove(a, b); }, _data(a, b, c) { return L.access(a, b, c); }, _removeData(a, b) { L.remove(a, b); },
-  }), o.fn.extend({
-    data(a, b) {
-      let c; let d; let e; const f = this[0]; const g = f && f.attributes; if (void 0 === a) {
-        if (this.length && (e = M.get(f), f.nodeType === 1 && !L.get(f, 'hasDataAttrs'))) {
-          c = g.length;
-          while (c--)d = g[c].name, d.indexOf('data-') === 0 && (d = o.camelCase(d.slice(5)), P(f, d, e[d])); L.set(f, 'hasDataAttrs', !0);
-        } return e;
-      } return typeof a === 'object' ? this.each(function () { M.set(this, a); }) : J(this, function (b) { let c; const d = o.camelCase(a); if (f && void 0 === b) { if (c = M.get(f, a), void 0 !== c) return c; if (c = M.get(f, d), void 0 !== c) return c; if (c = P(f, d, void 0), void 0 !== c) return c; } else this.each(function () { const c = M.get(this, d); M.set(this, d, b), a.indexOf('-') !== -1 && void 0 !== c && M.set(this, a, b); }); }, null, b, arguments.length > 1, null, !0);
-    },
-    removeData(a) { return this.each(function () { M.remove(this, a); }); },
-  }), o.extend({ queue(a, b, c) { let d; return a ? (b = `${b || 'fx'}queue`, d = L.get(a, b), c && (!d || o.isArray(c) ? d = L.access(a, b, o.makeArray(c)) : d.push(c)), d || []) : void 0; }, dequeue(a, b) { b = b || 'fx'; const c = o.queue(a, b); let d = c.length; let e = c.shift(); const f = o._queueHooks(a, b); const g = function () { o.dequeue(a, b); }; e === 'inprogress' && (e = c.shift(), d--), e && (b === 'fx' && c.unshift('inprogress'), delete f.stop, e.call(a, g, f)), !d && f && f.empty.fire(); }, _queueHooks(a, b) { const c = `${b}queueHooks`; return L.get(a, c) || L.access(a, c, { empty: o.Callbacks('once memory').add(() => { L.remove(a, [`${b}queue`, c]); }) }); } }), o.fn.extend({
-    queue(a, b) { let c = 2; return typeof a !== 'string' && (b = a, a = 'fx', c--), arguments.length < c ? o.queue(this[0], a) : void 0 === b ? this : this.each(function () { const c = o.queue(this, a, b); o._queueHooks(this, a), a === 'fx' && c[0] !== 'inprogress' && o.dequeue(this, a); }); }, dequeue(a) { return this.each(function () { o.dequeue(this, a); }); }, clearQueue(a) { return this.queue(a || 'fx', []); }, promise(a, b) { let c; let d = 1; const e = o.Deferred(); const f = this; let g = this.length; const h = function () { --d || e.resolveWith(f, [f]); }; typeof a !== 'string' && (b = a, a = void 0), a = a || 'fx'; while (g--)c = L.get(f[g], `${a}queueHooks`), c && c.empty && (d++, c.empty.add(h)); return h(), e.promise(b); },
-  }); const Q = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source; const R = ['Top', 'Right', 'Bottom', 'Left']; const S = function (a, b) { return a = b || a, o.css(a, 'display') === 'none' || !o.contains(a.ownerDocument, a); }; const T = /^(?:checkbox|radio)$/i; !(function () { const a = m.createDocumentFragment(); const b = a.appendChild(m.createElement('div')); b.innerHTML = "<input type='radio' checked='checked' name='t'/>", l.checkClone = b.cloneNode(!0).cloneNode(!0).lastChild.checked, b.innerHTML = '<textarea>x</textarea>', l.noCloneChecked = !!b.cloneNode(!0).lastChild.defaultValue; }()); const U = 'undefined'; l.focusinBubbles = 'onfocusin' in a; const V = /^key/; const W = /^(?:mouse|contextmenu)|click/; const X = /^(?:focusinfocus|focusoutblur)$/; const Y = /^([^.]*)(?:\.(.+)|)$/; function Z() { return !0; } function $() { return !1; } function _() { try { return m.activeElement; } catch (a) {} }o.event = {
-    global: {},
-    add(a, b, c, d, e) {
-      let f; let g; let h; let i; let j; let k; let l; let m; let n; let p; let q; const r = L.get(a); if (r) {
-        c.handler && (f = c, c = f.handler, e = f.selector), c.guid || (c.guid = o.guid++), (i = r.events) || (i = r.events = {}), (g = r.handle) || (g = r.handle = function (b) { return typeof o !== U && o.event.triggered !== b.type ? o.event.dispatch.apply(a, arguments) : void 0; }), b = (b || '').match(E) || [''], j = b.length; while (j--) {
-          h = Y.exec(b[j]) || [], n = q = h[1], p = (h[2] || '').split('.').sort(), n && (l = o.event.special[n] || {}, n = (e ? l.delegateType : l.bindType) || n, l = o.event.special[n] || {}, k = o.extend({
-            type: n, origType: q, data: d, handler: c, guid: c.guid, selector: e, needsContext: e && o.expr.match.needsContext.test(e), namespace: p.join('.'),
-          }, f), (m = i[n]) || (m = i[n] = [], m.delegateCount = 0, l.setup && l.setup.call(a, d, p, g) !== !1 || a.addEventListener && a.addEventListener(n, g, !1)), l.add && (l.add.call(a, k), k.handler.guid || (k.handler.guid = c.guid)), e ? m.splice(m.delegateCount++, 0, k) : m.push(k), o.event.global[n] = !0);
-        }
-      }
-    },
-    remove(a, b, c, d, e) { let f; let g; let h; let i; let j; let k; let l; let m; let n; let p; let q; const r = L.hasData(a) && L.get(a); if (r && (i = r.events)) { b = (b || '').match(E) || [''], j = b.length; while (j--) if (h = Y.exec(b[j]) || [], n = q = h[1], p = (h[2] || '').split('.').sort(), n) { l = o.event.special[n] || {}, n = (d ? l.delegateType : l.bindType) || n, m = i[n] || [], h = h[2] && new RegExp(`(^|\\.)${p.join('\\.(?:.*\\.|)')}(\\.|$)`), g = f = m.length; while (f--)k = m[f], !e && q !== k.origType || c && c.guid !== k.guid || h && !h.test(k.namespace) || d && d !== k.selector && (d !== '**' || !k.selector) || (m.splice(f, 1), k.selector && m.delegateCount--, l.remove && l.remove.call(a, k)); g && !m.length && (l.teardown && l.teardown.call(a, p, r.handle) !== !1 || o.removeEvent(a, n, r.handle), delete i[n]); } else for (n in i)o.event.remove(a, n + b[j], c, d, !0); o.isEmptyObject(i) && (delete r.handle, L.remove(a, 'events')); } },
-    trigger(b, c, d, e) { let f; let g; let h; let i; let k; let l; let n; const p = [d || m]; let q = j.call(b, 'type') ? b.type : b; let r = j.call(b, 'namespace') ? b.namespace.split('.') : []; if (g = h = d = d || m, d.nodeType !== 3 && d.nodeType !== 8 && !X.test(q + o.event.triggered) && (q.indexOf('.') >= 0 && (r = q.split('.'), q = r.shift(), r.sort()), k = q.indexOf(':') < 0 && `on${q}`, b = b[o.expando] ? b : new o.Event(q, typeof b === 'object' && b), b.isTrigger = e ? 2 : 3, b.namespace = r.join('.'), b.namespace_re = b.namespace ? new RegExp(`(^|\\.)${r.join('\\.(?:.*\\.|)')}(\\.|$)`) : null, b.result = void 0, b.target || (b.target = d), c = c == null ? [b] : o.makeArray(c, [b]), n = o.event.special[q] || {}, e || !n.trigger || n.trigger.apply(d, c) !== !1)) { if (!e && !n.noBubble && !o.isWindow(d)) { for (i = n.delegateType || q, X.test(i + q) || (g = g.parentNode); g; g = g.parentNode)p.push(g), h = g; h === (d.ownerDocument || m) && p.push(h.defaultView || h.parentWindow || a); }f = 0; while ((g = p[f++]) && !b.isPropagationStopped())b.type = f > 1 ? i : n.bindType || q, l = (L.get(g, 'events') || {})[b.type] && L.get(g, 'handle'), l && l.apply(g, c), l = k && g[k], l && l.apply && o.acceptData(g) && (b.result = l.apply(g, c), b.result === !1 && b.preventDefault()); return b.type = q, e || b.isDefaultPrevented() || n._default && n._default.apply(p.pop(), c) !== !1 || !o.acceptData(d) || k && o.isFunction(d[q]) && !o.isWindow(d) && (h = d[k], h && (d[k] = null), o.event.triggered = q, d[q](), o.event.triggered = void 0, h && (d[k] = h)), b.result; } },
-    dispatch(a) { a = o.event.fix(a); let b; let c; let e; let f; let g; let h = []; const i = d.call(arguments); const j = (L.get(this, 'events') || {})[a.type] || []; const k = o.event.special[a.type] || {}; if (i[0] = a, a.delegateTarget = this, !k.preDispatch || k.preDispatch.call(this, a) !== !1) { h = o.event.handlers.call(this, a, j), b = 0; while ((f = h[b++]) && !a.isPropagationStopped()) { a.currentTarget = f.elem, c = 0; while ((g = f.handlers[c++]) && !a.isImmediatePropagationStopped())(!a.namespace_re || a.namespace_re.test(g.namespace)) && (a.handleObj = g, a.data = g.data, e = ((o.event.special[g.origType] || {}).handle || g.handler).apply(f.elem, i), void 0 !== e && (a.result = e) === !1 && (a.preventDefault(), a.stopPropagation())); } return k.postDispatch && k.postDispatch.call(this, a), a.result; } },
-    handlers(a, b) { let c; let d; let e; let f; const g = []; const h = b.delegateCount; let i = a.target; if (h && i.nodeType && (!a.button || a.type !== 'click')) for (;i !== this; i = i.parentNode || this) if (i.disabled !== !0 || a.type !== 'click') { for (d = [], c = 0; h > c; c++)f = b[c], e = `${f.selector} `, void 0 === d[e] && (d[e] = f.needsContext ? o(e, this).index(i) >= 0 : o.find(e, this, null, [i]).length), d[e] && d.push(f); d.length && g.push({ elem: i, handlers: d }); } return h < b.length && g.push({ elem: this, handlers: b.slice(h) }), g; },
-    props: 'altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which'.split(' '),
-    fixHooks: {},
-    keyHooks: { props: 'char charCode key keyCode'.split(' '), filter(a, b) { return a.which == null && (a.which = b.charCode != null ? b.charCode : b.keyCode), a; } },
-    mouseHooks: { props: 'button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement'.split(' '), filter(a, b) { let c; let d; let e; const f = b.button; return a.pageX == null && b.clientX != null && (c = a.target.ownerDocument || m, d = c.documentElement, e = c.body, a.pageX = b.clientX + (d && d.scrollLeft || e && e.scrollLeft || 0) - (d && d.clientLeft || e && e.clientLeft || 0), a.pageY = b.clientY + (d && d.scrollTop || e && e.scrollTop || 0) - (d && d.clientTop || e && e.clientTop || 0)), a.which || void 0 === f || (a.which = 1 & f ? 1 : 2 & f ? 3 : 4 & f ? 2 : 0), a; } },
-    fix(a) { if (a[o.expando]) return a; let b; let c; let d; const e = a.type; const f = a; let g = this.fixHooks[e]; g || (this.fixHooks[e] = g = W.test(e) ? this.mouseHooks : V.test(e) ? this.keyHooks : {}), d = g.props ? this.props.concat(g.props) : this.props, a = new o.Event(f), b = d.length; while (b--)c = d[b], a[c] = f[c]; return a.target || (a.target = m), a.target.nodeType === 3 && (a.target = a.target.parentNode), g.filter ? g.filter(a, f) : a; },
-    special: {
-      load: { noBubble: !0 }, focus: { trigger() { return this !== _() && this.focus ? (this.focus(), !1) : void 0; }, delegateType: 'focusin' }, blur: { trigger() { return this === _() && this.blur ? (this.blur(), !1) : void 0; }, delegateType: 'focusout' }, click: { trigger() { return this.type === 'checkbox' && this.click && o.nodeName(this, 'input') ? (this.click(), !1) : void 0; }, _default(a) { return o.nodeName(a.target, 'a'); } }, beforeunload: { postDispatch(a) { void 0 !== a.result && (a.originalEvent.returnValue = a.result); } },
-    },
-    simulate(a, b, c, d) { const e = o.extend(new o.Event(), c, { type: a, isSimulated: !0, originalEvent: {} }); d ? o.event.trigger(e, null, b) : o.event.dispatch.call(b, e), e.isDefaultPrevented() && c.preventDefault(); },
-  }, o.removeEvent = function (a, b, c) { a.removeEventListener && a.removeEventListener(b, c, !1); }, o.Event = function (a, b) { return this instanceof o.Event ? (a && a.type ? (this.originalEvent = a, this.type = a.type, this.isDefaultPrevented = a.defaultPrevented || void 0 === a.defaultPrevented && a.getPreventDefault && a.getPreventDefault() ? Z : $) : this.type = a, b && o.extend(this, b), this.timeStamp = a && a.timeStamp || o.now(), void (this[o.expando] = !0)) : new o.Event(a, b); }, o.Event.prototype = {
-    isDefaultPrevented: $, isPropagationStopped: $, isImmediatePropagationStopped: $, preventDefault() { const a = this.originalEvent; this.isDefaultPrevented = Z, a && a.preventDefault && a.preventDefault(); }, stopPropagation() { const a = this.originalEvent; this.isPropagationStopped = Z, a && a.stopPropagation && a.stopPropagation(); }, stopImmediatePropagation() { this.isImmediatePropagationStopped = Z, this.stopPropagation(); },
-  }, o.each({ mouseenter: 'mouseover', mouseleave: 'mouseout' }, (a, b) => { o.event.special[a] = { delegateType: b, bindType: b, handle(a) { let c; const d = this; const e = a.relatedTarget; const f = a.handleObj; return (!e || e !== d && !o.contains(d, e)) && (a.type = f.origType, c = f.handler.apply(this, arguments), a.type = b), c; } }; }), l.focusinBubbles || o.each({ focus: 'focusin', blur: 'focusout' }, (a, b) => { const c = function (a) { o.event.simulate(b, a.target, o.event.fix(a), !0); }; o.event.special[b] = { setup() { const d = this.ownerDocument || this; const e = L.access(d, b); e || d.addEventListener(a, c, !0), L.access(d, b, (e || 0) + 1); }, teardown() { const d = this.ownerDocument || this; const e = L.access(d, b) - 1; e ? L.access(d, b, e) : (d.removeEventListener(a, c, !0), L.remove(d, b)); } }; }), o.fn.extend({
-    on(a, b, c, d, e) { let f; let g; if (typeof a === 'object') { typeof b !== 'string' && (c = c || b, b = void 0); for (g in a) this.on(g, b, c, a[g], e); return this; } if (c == null && d == null ? (d = b, c = b = void 0) : d == null && (typeof b === 'string' ? (d = c, c = void 0) : (d = c, c = b, b = void 0)), d === !1)d = $; else if (!d) return this; return e === 1 && (f = d, d = function (a) { return o().off(a), f.apply(this, arguments); }, d.guid = f.guid || (f.guid = o.guid++)), this.each(function () { o.event.add(this, a, d, c, b); }); }, one(a, b, c, d) { return this.on(a, b, c, d, 1); }, off(a, b, c) { let d; let e; if (a && a.preventDefault && a.handleObj) return d = a.handleObj, o(a.delegateTarget).off(d.namespace ? `${d.origType}.${d.namespace}` : d.origType, d.selector, d.handler), this; if (typeof a === 'object') { for (e in a) this.off(e, b, a[e]); return this; } return (b === !1 || typeof b === 'function') && (c = b, b = void 0), c === !1 && (c = $), this.each(function () { o.event.remove(this, a, c, b); }); }, trigger(a, b) { return this.each(function () { o.event.trigger(a, b, this); }); }, triggerHandler(a, b) { const c = this[0]; return c ? o.event.trigger(a, b, c, !0) : void 0; },
-  }); const ab = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi; const bb = /<([\w:]+)/; const cb = /<|&#?\w+;/; const db = /<(?:script|style|link)/i; const eb = /checked\s*(?:[^=]|=\s*.checked.)/i; const fb = /^$|\/(?:java|ecma)script/i; const gb = /^true\/(.*)/; const hb = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g; const ib = {
-    option: [1, "<select multiple='multiple'>", '</select>'], thead: [1, '<table>', '</table>'], col: [2, '<table><colgroup>', '</colgroup></table>'], tr: [2, '<table><tbody>', '</tbody></table>'], td: [3, '<table><tbody><tr>', '</tr></tbody></table>'], _default: [0, '', ''],
-  }; ib.optgroup = ib.option, ib.tbody = ib.tfoot = ib.colgroup = ib.caption = ib.thead, ib.th = ib.td; function jb(a, b) { return o.nodeName(a, 'table') && o.nodeName(b.nodeType !== 11 ? b : b.firstChild, 'tr') ? a.getElementsByTagName('tbody')[0] || a.appendChild(a.ownerDocument.createElement('tbody')) : a; } function kb(a) { return a.type = `${a.getAttribute('type') !== null}/${a.type}`, a; } function lb(a) { const b = gb.exec(a.type); return b ? a.type = b[1] : a.removeAttribute('type'), a; } function mb(a, b) { for (let c = 0, d = a.length; d > c; c++)L.set(a[c], 'globalEval', !b || L.get(b[c], 'globalEval')); } function nb(a, b) { let c; let d; let e; let f; let g; let h; let i; let j; if (b.nodeType === 1) { if (L.hasData(a) && (f = L.access(a), g = L.set(b, f), j = f.events)) { delete g.handle, g.events = {}; for (e in j) for (c = 0, d = j[e].length; d > c; c++)o.event.add(b, e, j[e][c]); }M.hasData(a) && (h = M.access(a), i = o.extend({}, h), M.set(b, i)); } } function ob(a, b) { const c = a.getElementsByTagName ? a.getElementsByTagName(b || '*') : a.querySelectorAll ? a.querySelectorAll(b || '*') : []; return void 0 === b || b && o.nodeName(a, b) ? o.merge([a], c) : c; } function pb(a, b) { const c = b.nodeName.toLowerCase(); c === 'input' && T.test(a.type) ? b.checked = a.checked : (c === 'input' || c === 'textarea') && (b.defaultValue = a.defaultValue); }o.extend({ clone(a, b, c) { let d; let e; let f; let g; const h = a.cloneNode(!0); const i = o.contains(a.ownerDocument, a); if (!(l.noCloneChecked || a.nodeType !== 1 && a.nodeType !== 11 || o.isXMLDoc(a))) for (g = ob(h), f = ob(a), d = 0, e = f.length; e > d; d++)pb(f[d], g[d]); if (b) if (c) for (f = f || ob(a), g = g || ob(h), d = 0, e = f.length; e > d; d++)nb(f[d], g[d]); else nb(a, h); return g = ob(h, 'script'), g.length > 0 && mb(g, !i && ob(a, 'script')), h; }, buildFragment(a, b, c, d) { for (var e, f, g, h, i, j, k = b.createDocumentFragment(), l = [], m = 0, n = a.length; n > m; m++) if (e = a[m], e || e === 0) if (o.type(e) === 'object')o.merge(l, e.nodeType ? [e] : e); else if (cb.test(e)) { f = f || k.appendChild(b.createElement('div')), g = (bb.exec(e) || ['', ''])[1].toLowerCase(), h = ib[g] || ib._default, f.innerHTML = h[1] + e.replace(ab, '<$1></$2>') + h[2], j = h[0]; while (j--)f = f.lastChild; o.merge(l, f.childNodes), f = k.firstChild, f.textContent = ''; } else l.push(b.createTextNode(e)); k.textContent = '', m = 0; while (e = l[m++]) if ((!d || o.inArray(e, d) === -1) && (i = o.contains(e.ownerDocument, e), f = ob(k.appendChild(e), 'script'), i && mb(f), c)) { j = 0; while (e = f[j++])fb.test(e.type || '') && c.push(e); } return k; }, cleanData(a) { for (var b, c, d, e, f, g, h = o.event.special, i = 0; void 0 !== (c = a[i]); i++) { if (o.acceptData(c) && (f = c[L.expando], f && (b = L.cache[f]))) { if (d = Object.keys(b.events || {}), d.length) for (g = 0; void 0 !== (e = d[g]); g++)h[e] ? o.event.remove(c, e) : o.removeEvent(c, e, b.handle); L.cache[f] && delete L.cache[f]; } delete M.cache[c[M.expando]]; } } }), o.fn.extend({
-    text(a) { return J(this, function (a) { return void 0 === a ? o.text(this) : this.empty().each(function () { (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) && (this.textContent = a); }); }, null, a, arguments.length); }, append() { return this.domManip(arguments, function (a) { if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { const b = jb(this, a); b.appendChild(a); } }); }, prepend() { return this.domManip(arguments, function (a) { if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) { const b = jb(this, a); b.insertBefore(a, b.firstChild); } }); }, before() { return this.domManip(arguments, function (a) { this.parentNode && this.parentNode.insertBefore(a, this); }); }, after() { return this.domManip(arguments, function (a) { this.parentNode && this.parentNode.insertBefore(a, this.nextSibling); }); }, remove(a, b) { for (var c, d = a ? o.filter(a, this) : this, e = 0; (c = d[e]) != null; e++)b || c.nodeType !== 1 || o.cleanData(ob(c)), c.parentNode && (b && o.contains(c.ownerDocument, c) && mb(ob(c, 'script')), c.parentNode.removeChild(c)); return this; }, empty() { for (var a, b = 0; (a = this[b]) != null; b++)a.nodeType === 1 && (o.cleanData(ob(a, !1)), a.textContent = ''); return this; }, clone(a, b) { return a = a == null ? !1 : a, b = b == null ? a : b, this.map(function () { return o.clone(this, a, b); }); }, html(a) { return J(this, function (a) { let b = this[0] || {}; let c = 0; const d = this.length; if (void 0 === a && b.nodeType === 1) return b.innerHTML; if (typeof a === 'string' && !db.test(a) && !ib[(bb.exec(a) || ['', ''])[1].toLowerCase()]) { a = a.replace(ab, '<$1></$2>'); try { for (;d > c; c++)b = this[c] || {}, b.nodeType === 1 && (o.cleanData(ob(b, !1)), b.innerHTML = a); b = 0; } catch (e) {} }b && this.empty().append(a); }, null, a, arguments.length); }, replaceWith() { let a = arguments[0]; return this.domManip(arguments, function (b) { a = this.parentNode, o.cleanData(ob(this)), a && a.replaceChild(b, this); }), a && (a.length || a.nodeType) ? this : this.remove(); }, detach(a) { return this.remove(a, !0); }, domManip(a, b) { a = e.apply([], a); let c; let d; let f; let g; let h; let i; let j = 0; const k = this.length; const m = this; const n = k - 1; const p = a[0]; const q = o.isFunction(p); if (q || k > 1 && typeof p === 'string' && !l.checkClone && eb.test(p)) return this.each(function (c) { const d = m.eq(c); q && (a[0] = p.call(this, c, d.html())), d.domManip(a, b); }); if (k && (c = o.buildFragment(a, this[0].ownerDocument, !1, this), d = c.firstChild, c.childNodes.length === 1 && (c = d), d)) { for (f = o.map(ob(c, 'script'), kb), g = f.length; k > j; j++)h = c, j !== n && (h = o.clone(h, !0, !0), g && o.merge(f, ob(h, 'script'))), b.call(this[j], h, j); if (g) for (i = f[f.length - 1].ownerDocument, o.map(f, lb), j = 0; g > j; j++)h = f[j], fb.test(h.type || '') && !L.access(h, 'globalEval') && o.contains(i, h) && (h.src ? o._evalUrl && o._evalUrl(h.src) : o.globalEval(h.textContent.replace(hb, ''))); } return this; },
-  }), o.each({
-    appendTo: 'append', prependTo: 'prepend', insertBefore: 'before', insertAfter: 'after', replaceAll: 'replaceWith',
-  }, (a, b) => { o.fn[a] = function (a) { for (var c, d = [], e = o(a), g = e.length - 1, h = 0; g >= h; h++)c = h === g ? this : this.clone(!0), o(e[h])[b](c), f.apply(d, c.get()); return this.pushStack(d); }; }); let qb; const rb = {}; function sb(b, c) { const d = o(c.createElement(b)).appendTo(c.body); const e = a.getDefaultComputedStyle ? a.getDefaultComputedStyle(d[0]).display : o.css(d[0], 'display'); return d.detach(), e; } function tb(a) { let b = m; let c = rb[a]; return c || (c = sb(a, b), c !== 'none' && c || (qb = (qb || o("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement), b = qb[0].contentDocument, b.write(), b.close(), c = sb(a, b), qb.detach()), rb[a] = c), c; } const ub = /^margin/; const vb = new RegExp(`^(${Q})(?!px)[a-z%]+$`, 'i'); const wb = function (a) { return a.ownerDocument.defaultView.getComputedStyle(a, null); }; function xb(a, b, c) { let d; let e; let f; let g; const h = a.style; return c = c || wb(a), c && (g = c.getPropertyValue(b) || c[b]), c && (g !== '' || o.contains(a.ownerDocument, a) || (g = o.style(a, b)), vb.test(g) && ub.test(b) && (d = h.width, e = h.minWidth, f = h.maxWidth, h.minWidth = h.maxWidth = h.width = g, g = c.width, h.width = d, h.minWidth = e, h.maxWidth = f)), void 0 !== g ? `${g}` : g; } function yb(a, b) { return { get() { return a() ? void delete this.get : (this.get = b).apply(this, arguments); } }; }!(function () { let b; let c; const d = 'padding:0;margin:0;border:0;display:block;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box'; const e = m.documentElement; const f = m.createElement('div'); const g = m.createElement('div'); g.style.backgroundClip = 'content-box', g.cloneNode(!0).style.backgroundClip = '', l.clearCloneStyle = g.style.backgroundClip === 'content-box', f.style.cssText = 'border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px', f.appendChild(g); function h() { g.style.cssText = '-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%', e.appendChild(f); const d = a.getComputedStyle(g, null); b = d.top !== '1%', c = d.width === '4px', e.removeChild(f); }a.getComputedStyle && o.extend(l, { pixelPosition() { return h(), b; }, boxSizingReliable() { return c == null && h(), c; }, reliableMarginRight() { let b; const c = g.appendChild(m.createElement('div')); return c.style.cssText = g.style.cssText = d, c.style.marginRight = c.style.width = '0', g.style.width = '1px', e.appendChild(f), b = !parseFloat(a.getComputedStyle(c, null).marginRight), e.removeChild(f), g.innerHTML = '', b; } }); }()), o.swap = function (a, b, c, d) { let e; let f; const g = {}; for (f in b)g[f] = a.style[f], a.style[f] = b[f]; e = c.apply(a, d || []); for (f in b)a.style[f] = g[f]; return e; }; const zb = /^(none|table(?!-c[ea]).+)/; const Ab = new RegExp(`^(${Q})(.*)$`, 'i'); const Bb = new RegExp(`^([+-])=(${Q})`, 'i'); const Cb = { position: 'absolute', visibility: 'hidden', display: 'block' }; const Db = { letterSpacing: 0, fontWeight: 400 }; const Eb = ['Webkit', 'O', 'Moz', 'ms']; function Fb(a, b) { if (b in a) return b; const c = b[0].toUpperCase() + b.slice(1); const d = b; let e = Eb.length; while (e--) if (b = Eb[e] + c, b in a) return b; return d; } function Gb(a, b, c) { const d = Ab.exec(b); return d ? Math.max(0, d[1] - (c || 0)) + (d[2] || 'px') : b; } function Hb(a, b, c, d, e) { for (var f = c === (d ? 'border' : 'content') ? 4 : b === 'width' ? 1 : 0, g = 0; f < 4; f += 2)c === 'margin' && (g += o.css(a, c + R[f], !0, e)), d ? (c === 'content' && (g -= o.css(a, `padding${R[f]}`, !0, e)), c !== 'margin' && (g -= o.css(a, `border${R[f]}Width`, !0, e))) : (g += o.css(a, `padding${R[f]}`, !0, e), c !== 'padding' && (g += o.css(a, `border${R[f]}Width`, !0, e))); return g; } function Ib(a, b, c) { let d = !0; let e = b === 'width' ? a.offsetWidth : a.offsetHeight; const f = wb(a); const g = o.css(a, 'boxSizing', !1, f) === 'border-box'; if (e <= 0 || e == null) { if (e = xb(a, b, f), (e < 0 || e == null) && (e = a.style[b]), vb.test(e)) return e; d = g && (l.boxSizingReliable() || e === a.style[b]), e = parseFloat(e) || 0; } return `${e + Hb(a, b, c || (g ? 'border' : 'content'), d, f)}px`; } function Jb(a, b) { for (var c, d, e, f = [], g = 0, h = a.length; h > g; g++)d = a[g], d.style && (f[g] = L.get(d, 'olddisplay'), c = d.style.display, b ? (f[g] || c !== 'none' || (d.style.display = ''), d.style.display === '' && S(d) && (f[g] = L.access(d, 'olddisplay', tb(d.nodeName)))) : f[g] || (e = S(d), (c && c !== 'none' || !e) && L.set(d, 'olddisplay', e ? c : o.css(d, 'display')))); for (g = 0; h > g; g++)d = a[g], d.style && (b && d.style.display !== 'none' && d.style.display !== '' || (d.style.display = b ? f[g] || '' : 'none')); return a; }o.extend({
-    cssHooks: { opacity: { get(a, b) { if (b) { const c = xb(a, 'opacity'); return c === '' ? '1' : c; } } } },
-    cssNumber: {
-      columnCount: !0, fillOpacity: !0, fontWeight: !0, lineHeight: !0, opacity: !0, order: !0, orphans: !0, widows: !0, zIndex: !0, zoom: !0,
-    },
-    cssProps: { float: 'cssFloat' },
-    style(a, b, c, d) { if (a && a.nodeType !== 3 && a.nodeType !== 8 && a.style) { let e; let f; let g; const h = o.camelCase(b); const i = a.style; return b = o.cssProps[h] || (o.cssProps[h] = Fb(i, h)), g = o.cssHooks[b] || o.cssHooks[h], void 0 === c ? g && 'get' in g && void 0 !== (e = g.get(a, !1, d)) ? e : i[b] : (f = typeof c, f === 'string' && (e = Bb.exec(c)) && (c = (e[1] + 1) * e[2] + parseFloat(o.css(a, b)), f = 'number'), c != null && c === c && (f !== 'number' || o.cssNumber[h] || (c += 'px'), l.clearCloneStyle || c !== '' || b.indexOf('background') !== 0 || (i[b] = 'inherit'), g && 'set' in g && void 0 === (c = g.set(a, c, d)) || (i[b] = '', i[b] = c)), void 0); } },
-    css(a, b, c, d) { let e; let f; let g; const h = o.camelCase(b); return b = o.cssProps[h] || (o.cssProps[h] = Fb(a.style, h)), g = o.cssHooks[b] || o.cssHooks[h], g && 'get' in g && (e = g.get(a, !0, c)), void 0 === e && (e = xb(a, b, d)), e === 'normal' && b in Db && (e = Db[b]), c === '' || c ? (f = parseFloat(e), c === !0 || o.isNumeric(f) ? f || 0 : e) : e; },
-  }), o.each(['height', 'width'], (a, b) => { o.cssHooks[b] = { get(a, c, d) { return c ? a.offsetWidth === 0 && zb.test(o.css(a, 'display')) ? o.swap(a, Cb, () => Ib(a, b, d)) : Ib(a, b, d) : void 0; }, set(a, c, d) { const e = d && wb(a); return Gb(a, c, d ? Hb(a, b, d, o.css(a, 'boxSizing', !1, e) === 'border-box', e) : 0); } }; }), o.cssHooks.marginRight = yb(l.reliableMarginRight, (a, b) => (b ? o.swap(a, { display: 'inline-block' }, xb, [a, 'marginRight']) : void 0)), o.each({ margin: '', padding: '', border: 'Width' }, (a, b) => { o.cssHooks[a + b] = { expand(c) { for (var d = 0, e = {}, f = typeof c === 'string' ? c.split(' ') : [c]; d < 4; d++)e[a + R[d] + b] = f[d] || f[d - 2] || f[0]; return e; } }, ub.test(a) || (o.cssHooks[a + b].set = Gb); }), o.fn.extend({
-    css(a, b) { return J(this, (a, b, c) => { let d; let e; const f = {}; let g = 0; if (o.isArray(b)) { for (d = wb(a), e = b.length; e > g; g++)f[b[g]] = o.css(a, b[g], !1, d); return f; } return void 0 !== c ? o.style(a, b, c) : o.css(a, b); }, a, b, arguments.length > 1); }, show() { return Jb(this, !0); }, hide() { return Jb(this); }, toggle(a) { return typeof a === 'boolean' ? a ? this.show() : this.hide() : this.each(function () { S(this) ? o(this).show() : o(this).hide(); }); },
-  }); function Kb(a, b, c, d, e) { return new Kb.prototype.init(a, b, c, d, e); }o.Tween = Kb, Kb.prototype = {
-    constructor: Kb, init(a, b, c, d, e, f) { this.elem = a, this.prop = c, this.easing = e || 'swing', this.options = b, this.start = this.now = this.cur(), this.end = d, this.unit = f || (o.cssNumber[c] ? '' : 'px'); }, cur() { const a = Kb.propHooks[this.prop]; return a && a.get ? a.get(this) : Kb.propHooks._default.get(this); }, run(a) { let b; const c = Kb.propHooks[this.prop]; return this.pos = b = this.options.duration ? o.easing[this.easing](a, this.options.duration * a, 0, 1, this.options.duration) : a, this.now = (this.end - this.start) * b + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), c && c.set ? c.set(this) : Kb.propHooks._default.set(this), this; },
-  }, Kb.prototype.init.prototype = Kb.prototype, Kb.propHooks = { _default: { get(a) { let b; return a.elem[a.prop] == null || a.elem.style && a.elem.style[a.prop] != null ? (b = o.css(a.elem, a.prop, ''), b && b !== 'auto' ? b : 0) : a.elem[a.prop]; }, set(a) { o.fx.step[a.prop] ? o.fx.step[a.prop](a) : a.elem.style && (a.elem.style[o.cssProps[a.prop]] != null || o.cssHooks[a.prop]) ? o.style(a.elem, a.prop, a.now + a.unit) : a.elem[a.prop] = a.now; } } }, Kb.propHooks.scrollTop = Kb.propHooks.scrollLeft = { set(a) { a.elem.nodeType && a.elem.parentNode && (a.elem[a.prop] = a.now); } }, o.easing = { linear(a) { return a; }, swing(a) { return 0.5 - Math.cos(a * Math.PI) / 2; } }, o.fx = Kb.prototype.init, o.fx.step = {}; let Lb; let Mb; const Nb = /^(?:toggle|show|hide)$/; const Ob = new RegExp(`^(?:([+-])=|)(${Q})([a-z%]*)$`, 'i'); const Pb = /queueHooks$/; const Qb = [Vb]; const Rb = { '*': [function (a, b) { const c = this.createTween(a, b); const d = c.cur(); let e = Ob.exec(b); let f = e && e[3] || (o.cssNumber[a] ? '' : 'px'); let g = (o.cssNumber[a] || f !== 'px' && +d) && Ob.exec(o.css(c.elem, a)); let h = 1; let i = 20; if (g && g[3] !== f) { f = f || g[3], e = e || [], g = +d || 1; do h = h || '.5', g /= h, o.style(c.elem, a, g + f); while (h !== (h = c.cur() / d) && h !== 1 && --i); } return e && (g = c.start = +g || +d || 0, c.unit = f, c.end = e[1] ? g + (e[1] + 1) * e[2] : +e[2]), c; }] }; function Sb() { return setTimeout(() => { Lb = void 0; }), Lb = o.now(); } function Tb(a, b) { let c; let d = 0; const e = { height: a }; for (b = b ? 1 : 0; d < 4; d += 2 - b)c = R[d], e[`margin${c}`] = e[`padding${c}`] = a; return b && (e.opacity = e.width = a), e; } function Ub(a, b, c) { for (var d, e = (Rb[b] || []).concat(Rb['*']), f = 0, g = e.length; g > f; f++) if (d = e[f].call(c, b, a)) return d; } function Vb(a, b, c) { let d; let e; let f; let g; let h; let i; let j; const k = this; const l = {}; const m = a.style; let n = a.nodeType && S(a); let p = L.get(a, 'fxshow'); c.queue || (h = o._queueHooks(a, 'fx'), h.unqueued == null && (h.unqueued = 0, i = h.empty.fire, h.empty.fire = function () { h.unqueued || i(); }), h.unqueued++, k.always(() => { k.always(() => { h.unqueued--, o.queue(a, 'fx').length || h.empty.fire(); }); })), a.nodeType === 1 && ('height' in b || 'width' in b) && (c.overflow = [m.overflow, m.overflowX, m.overflowY], j = o.css(a, 'display'), j === 'none' && (j = tb(a.nodeName)), j === 'inline' && o.css(a, 'float') === 'none' && (m.display = 'inline-block')), c.overflow && (m.overflow = 'hidden', k.always(() => { m.overflow = c.overflow[0], m.overflowX = c.overflow[1], m.overflowY = c.overflow[2]; })); for (d in b) if (e = b[d], Nb.exec(e)) { if (delete b[d], f = f || e === 'toggle', e === (n ? 'hide' : 'show')) { if (e !== 'show' || !p || void 0 === p[d]) continue; n = !0; }l[d] = p && p[d] || o.style(a, d); } if (!o.isEmptyObject(l)) { p ? 'hidden' in p && (n = p.hidden) : p = L.access(a, 'fxshow', {}), f && (p.hidden = !n), n ? o(a).show() : k.done(() => { o(a).hide(); }), k.done(() => { let b; L.remove(a, 'fxshow'); for (b in l)o.style(a, b, l[b]); }); for (d in l)g = Ub(n ? p[d] : 0, d, k), d in p || (p[d] = g.start, n && (g.end = g.start, g.start = d === 'width' || d === 'height' ? 1 : 0)); } } function Wb(a, b) { let c; let d; let e; let f; let g; for (c in a) if (d = o.camelCase(c), e = b[d], f = a[c], o.isArray(f) && (e = f[1], f = a[c] = f[0]), c !== d && (a[d] = f, delete a[c]), g = o.cssHooks[d], g && 'expand' in g) { f = g.expand(f), delete a[d]; for (c in f)c in a || (a[c] = f[c], b[c] = e); } else b[d] = e; } function Xb(a, b, c) {
-    let d; let e; let f = 0; const g = Qb.length; const h = o.Deferred().always(() => { delete i.elem; }); var i = function () { if (e) return !1; for (var b = Lb || Sb(), c = Math.max(0, j.startTime + j.duration - b), d = c / j.duration || 0, f = 1 - d, g = 0, i = j.tweens.length; i > g; g++)j.tweens[g].run(f); return h.notifyWith(a, [j, f, c]), f < 1 && i ? c : (h.resolveWith(a, [j]), !1); }; var j = h.promise({
-      elem: a, props: o.extend({}, b), opts: o.extend(!0, { specialEasing: {} }, c), originalProperties: b, originalOptions: c, startTime: Lb || Sb(), duration: c.duration, tweens: [], createTween(b, c) { const d = o.Tween(a, j.opts, b, c, j.opts.specialEasing[b] || j.opts.easing); return j.tweens.push(d), d; }, stop(b) { let c = 0; const d = b ? j.tweens.length : 0; if (e) return this; for (e = !0; d > c; c++)j.tweens[c].run(1); return b ? h.resolveWith(a, [j, b]) : h.rejectWith(a, [j, b]), this; },
-    }); const k = j.props; for (Wb(k, j.opts.specialEasing); g > f; f++) if (d = Qb[f].call(j, a, k, j.opts)) return d; return o.map(k, Ub, j), o.isFunction(j.opts.start) && j.opts.start.call(a, j), o.fx.timer(o.extend(i, { elem: a, anim: j, queue: j.opts.queue })), j.progress(j.opts.progress).done(j.opts.done, j.opts.complete).fail(j.opts.fail).always(j.opts.always);
-  }o.Animation = o.extend(Xb, { tweener(a, b) { o.isFunction(a) ? (b = a, a = ['*']) : a = a.split(' '); for (var c, d = 0, e = a.length; e > d; d++)c = a[d], Rb[c] = Rb[c] || [], Rb[c].unshift(b); }, prefilter(a, b) { b ? Qb.unshift(a) : Qb.push(a); } }), o.speed = function (a, b, c) { const d = a && typeof a === 'object' ? o.extend({}, a) : { complete: c || !c && b || o.isFunction(a) && a, duration: a, easing: c && b || b && !o.isFunction(b) && b }; return d.duration = o.fx.off ? 0 : typeof d.duration === 'number' ? d.duration : d.duration in o.fx.speeds ? o.fx.speeds[d.duration] : o.fx.speeds._default, (d.queue == null || d.queue === !0) && (d.queue = 'fx'), d.old = d.complete, d.complete = function () { o.isFunction(d.old) && d.old.call(this), d.queue && o.dequeue(this, d.queue); }, d; }, o.fn.extend({
-    fadeTo(a, b, c, d) {
-      return this.filter(S).css('opacity', 0).show().end()
-        .animate({ opacity: b }, a, c, d);
-    },
-    animate(a, b, c, d) { const e = o.isEmptyObject(a); const f = o.speed(b, c, d); const g = function () { const b = Xb(this, o.extend({}, a), f); (e || L.get(this, 'finish')) && b.stop(!0); }; return g.finish = g, e || f.queue === !1 ? this.each(g) : this.queue(f.queue, g); },
-    stop(a, b, c) { const d = function (a) { const b = a.stop; delete a.stop, b(c); }; return typeof a !== 'string' && (c = b, b = a, a = void 0), b && a !== !1 && this.queue(a || 'fx', []), this.each(function () { let b = !0; let e = a != null && `${a}queueHooks`; const f = o.timers; const g = L.get(this); if (e)g[e] && g[e].stop && d(g[e]); else for (e in g)g[e] && g[e].stop && Pb.test(e) && d(g[e]); for (e = f.length; e--;)f[e].elem !== this || a != null && f[e].queue !== a || (f[e].anim.stop(c), b = !1, f.splice(e, 1)); (b || !c) && o.dequeue(this, a); }); },
-    finish(a) { return a !== !1 && (a = a || 'fx'), this.each(function () { let b; const c = L.get(this); const d = c[`${a}queue`]; const e = c[`${a}queueHooks`]; const f = o.timers; const g = d ? d.length : 0; for (c.finish = !0, o.queue(this, a, []), e && e.stop && e.stop.call(this, !0), b = f.length; b--;)f[b].elem === this && f[b].queue === a && (f[b].anim.stop(!0), f.splice(b, 1)); for (b = 0; g > b; b++)d[b] && d[b].finish && d[b].finish.call(this); delete c.finish; }); },
-  }), o.each(['toggle', 'show', 'hide'], (a, b) => { const c = o.fn[b]; o.fn[b] = function (a, d, e) { return a == null || typeof a === 'boolean' ? c.apply(this, arguments) : this.animate(Tb(b, !0), a, d, e); }; }), o.each({
-    slideDown: Tb('show'), slideUp: Tb('hide'), slideToggle: Tb('toggle'), fadeIn: { opacity: 'show' }, fadeOut: { opacity: 'hide' }, fadeToggle: { opacity: 'toggle' },
-  }, (a, b) => { o.fn[a] = function (a, c, d) { return this.animate(b, a, c, d); }; }), o.timers = [], o.fx.tick = function () { let a; let b = 0; const c = o.timers; for (Lb = o.now(); b < c.length; b++)a = c[b], a() || c[b] !== a || c.splice(b--, 1); c.length || o.fx.stop(), Lb = void 0; }, o.fx.timer = function (a) { o.timers.push(a), a() ? o.fx.start() : o.timers.pop(); }, o.fx.interval = 13, o.fx.start = function () { Mb || (Mb = setInterval(o.fx.tick, o.fx.interval)); }, o.fx.stop = function () { clearInterval(Mb), Mb = null; }, o.fx.speeds = { slow: 600, fast: 200, _default: 400 }, o.fn.delay = function (a, b) { return a = o.fx ? o.fx.speeds[a] || a : a, b = b || 'fx', this.queue(b, (b, c) => { const d = setTimeout(b, a); c.stop = function () { clearTimeout(d); }; }); }, (function () { let a = m.createElement('input'); const b = m.createElement('select'); const c = b.appendChild(m.createElement('option')); a.type = 'checkbox', l.checkOn = a.value !== '', l.optSelected = c.selected, b.disabled = !0, l.optDisabled = !c.disabled, a = m.createElement('input'), a.value = 't', a.type = 'radio', l.radioValue = a.value === 't'; }()); let Yb; let Zb; const $b = o.expr.attrHandle; o.fn.extend({ attr(a, b) { return J(this, o.attr, a, b, arguments.length > 1); }, removeAttr(a) { return this.each(function () { o.removeAttr(this, a); }); } }), o.extend({ attr(a, b, c) { let d; let e; const f = a.nodeType; if (a && f !== 3 && f !== 8 && f !== 2) return typeof a.getAttribute === U ? o.prop(a, b, c) : (f === 1 && o.isXMLDoc(a) || (b = b.toLowerCase(), d = o.attrHooks[b] || (o.expr.match.bool.test(b) ? Zb : Yb)), void 0 === c ? d && 'get' in d && (e = d.get(a, b)) !== null ? e : (e = o.find.attr(a, b), e == null ? void 0 : e) : c !== null ? d && 'set' in d && void 0 !== (e = d.set(a, c, b)) ? e : (a.setAttribute(b, `${c}`), c) : void o.removeAttr(a, b)); }, removeAttr(a, b) { let c; let d; let e = 0; const f = b && b.match(E); if (f && a.nodeType === 1) while (c = f[e++])d = o.propFix[c] || c, o.expr.match.bool.test(c) && (a[d] = !1), a.removeAttribute(c); }, attrHooks: { type: { set(a, b) { if (!l.radioValue && b === 'radio' && o.nodeName(a, 'input')) { const c = a.value; return a.setAttribute('type', b), c && (a.value = c), b; } } } } }), Zb = { set(a, b, c) { return b === !1 ? o.removeAttr(a, c) : a.setAttribute(c, c), c; } }, o.each(o.expr.match.bool.source.match(/\w+/g), (a, b) => {
-    const c = $b[b] || o.find.attr; $b[b] = function (a, b, d) {
-      let e; let f;
-      return d || (f = $b[b], $b[b] = e, e = c(a, b, d) != null ? b.toLowerCase() : null, $b[b] = f), e;
-    };
-  }); const _b = /^(?:input|select|textarea|button)$/i; o.fn.extend({ prop(a, b) { return J(this, o.prop, a, b, arguments.length > 1); }, removeProp(a) { return this.each(function () { delete this[o.propFix[a] || a]; }); } }), o.extend({ propFix: { for: 'htmlFor', class: 'className' }, prop(a, b, c) { let d; let e; let f; const g = a.nodeType; if (a && g !== 3 && g !== 8 && g !== 2) return f = g !== 1 || !o.isXMLDoc(a), f && (b = o.propFix[b] || b, e = o.propHooks[b]), void 0 !== c ? e && 'set' in e && void 0 !== (d = e.set(a, c, b)) ? d : a[b] = c : e && 'get' in e && (d = e.get(a, b)) !== null ? d : a[b]; }, propHooks: { tabIndex: { get(a) { return a.hasAttribute('tabindex') || _b.test(a.nodeName) || a.href ? a.tabIndex : -1; } } } }), l.optSelected || (o.propHooks.selected = { get(a) { const b = a.parentNode; return b && b.parentNode && b.parentNode.selectedIndex, null; } }), o.each(['tabIndex', 'readOnly', 'maxLength', 'cellSpacing', 'cellPadding', 'rowSpan', 'colSpan', 'useMap', 'frameBorder', 'contentEditable'], function () { o.propFix[this.toLowerCase()] = this; }); const ac = /[\t\r\n\f]/g; o.fn.extend({
-    addClass(a) { let b; let c; let d; let e; let f; let g; const h = typeof a === 'string' && a; let i = 0; const j = this.length; if (o.isFunction(a)) return this.each(function (b) { o(this).addClass(a.call(this, b, this.className)); }); if (h) for (b = (a || '').match(E) || []; j > i; i++) if (c = this[i], d = c.nodeType === 1 && (c.className ? (` ${c.className} `).replace(ac, ' ') : ' ')) { f = 0; while (e = b[f++])d.indexOf(` ${e} `) < 0 && (d += `${e} `); g = o.trim(d), c.className !== g && (c.className = g); } return this; }, removeClass(a) { let b; let c; let d; let e; let f; let g; const h = arguments.length === 0 || typeof a === 'string' && a; let i = 0; const j = this.length; if (o.isFunction(a)) return this.each(function (b) { o(this).removeClass(a.call(this, b, this.className)); }); if (h) for (b = (a || '').match(E) || []; j > i; i++) if (c = this[i], d = c.nodeType === 1 && (c.className ? (` ${c.className} `).replace(ac, ' ') : '')) { f = 0; while (e = b[f++]) while (d.indexOf(` ${e} `) >= 0)d = d.replace(` ${e} `, ' '); g = a ? o.trim(d) : '', c.className !== g && (c.className = g); } return this; }, toggleClass(a, b) { const c = typeof a; return typeof b === 'boolean' && c === 'string' ? b ? this.addClass(a) : this.removeClass(a) : this.each(o.isFunction(a) ? function (c) { o(this).toggleClass(a.call(this, c, this.className, b), b); } : function () { if (c === 'string') { let b; let d = 0; const e = o(this); const f = a.match(E) || []; while (b = f[d++])e.hasClass(b) ? e.removeClass(b) : e.addClass(b); } else (c === U || c === 'boolean') && (this.className && L.set(this, '__className__', this.className), this.className = this.className || a === !1 ? '' : L.get(this, '__className__') || ''); }); }, hasClass(a) { for (let b = ` ${a} `, c = 0, d = this.length; d > c; c++) if (this[c].nodeType === 1 && (` ${this[c].className} `).replace(ac, ' ').indexOf(b) >= 0) return !0; return !1; },
-  }); const bc = /\r/g; o.fn.extend({ val(a) { let b; let c; let d; const e = this[0]; { if (arguments.length) return d = o.isFunction(a), this.each(function (c) { let e; this.nodeType === 1 && (e = d ? a.call(this, c, o(this).val()) : a, e == null ? e = '' : typeof e === 'number' ? e += '' : o.isArray(e) && (e = o.map(e, (a) => (a == null ? '' : `${a}`))), b = o.valHooks[this.type] || o.valHooks[this.nodeName.toLowerCase()], b && 'set' in b && void 0 !== b.set(this, e, 'value') || (this.value = e)); }); if (e) return b = o.valHooks[e.type] || o.valHooks[e.nodeName.toLowerCase()], b && 'get' in b && void 0 !== (c = b.get(e, 'value')) ? c : (c = e.value, typeof c === 'string' ? c.replace(bc, '') : c == null ? '' : c); } } }), o.extend({ valHooks: { select: { get(a) { for (var b, c, d = a.options, e = a.selectedIndex, f = a.type === 'select-one' || e < 0, g = f ? null : [], h = f ? e + 1 : d.length, i = e < 0 ? h : f ? e : 0; h > i; i++) if (c = d[i], !(!c.selected && i !== e || (l.optDisabled ? c.disabled : c.getAttribute('disabled') !== null) || c.parentNode.disabled && o.nodeName(c.parentNode, 'optgroup'))) { if (b = o(c).val(), f) return b; g.push(b); } return g; }, set(a, b) { let c; let d; const e = a.options; const f = o.makeArray(b); let g = e.length; while (g--)d = e[g], (d.selected = o.inArray(o(d).val(), f) >= 0) && (c = !0); return c || (a.selectedIndex = -1), f; } } } }), o.each(['radio', 'checkbox'], function () { o.valHooks[this] = { set(a, b) { return o.isArray(b) ? a.checked = o.inArray(o(a).val(), b) >= 0 : void 0; } }, l.checkOn || (o.valHooks[this].get = function (a) { return a.getAttribute('value') === null ? 'on' : a.value; }); }), o.each('blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu'.split(' '), (a, b) => { o.fn[b] = function (a, c) { return arguments.length > 0 ? this.on(b, null, a, c) : this.trigger(b); }; }), o.fn.extend({
-    hover(a, b) { return this.mouseenter(a).mouseleave(b || a); }, bind(a, b, c) { return this.on(a, null, b, c); }, unbind(a, b) { return this.off(a, null, b); }, delegate(a, b, c, d) { return this.on(b, a, c, d); }, undelegate(a, b, c) { return arguments.length === 1 ? this.off(a, '**') : this.off(b, a || '**', c); },
-  }); let cc = o.now(); const dc = /\?/; o.parseJSON = function (a) { return JSON.parse(`${a}`); }, o.parseXML = function (a) { let b; let c; if (!a || typeof a !== 'string') return null; try { c = new DOMParser(), b = c.parseFromString(a, 'text/xml'); } catch (d) { b = void 0; } return (!b || b.getElementsByTagName('parsererror').length) && o.error(`Invalid XML: ${a}`), b; }; let ec; let fc; const gc = /#.*$/; const hc = /([?&])_=[^&]*/; const ic = /^(.*?):[ \t]*([^\r\n]*)$/gm; const jc = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/; const kc = /^(?:GET|HEAD)$/; const lc = /^\/\//; const mc = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/; const nc = {}; const oc = {}; const pc = '*/'.concat('*'); try { fc = location.href; } catch (qc) { fc = m.createElement('a'), fc.href = '', fc = fc.href; }ec = mc.exec(fc.toLowerCase()) || []; function rc(a) { return function (b, c) { typeof b !== 'string' && (c = b, b = '*'); let d; let e = 0; const f = b.toLowerCase().match(E) || []; if (o.isFunction(c)) while (d = f[e++])d[0] === '+' ? (d = d.slice(1) || '*', (a[d] = a[d] || []).unshift(c)) : (a[d] = a[d] || []).push(c); }; } function sc(a, b, c, d) { const e = {}; const f = a === oc; function g(h) { let i; return e[h] = !0, o.each(a[h] || [], (a, h) => { const j = h(b, c, d); return typeof j !== 'string' || f || e[j] ? f ? !(i = j) : void 0 : (b.dataTypes.unshift(j), g(j), !1); }), i; } return g(b.dataTypes[0]) || !e['*'] && g('*'); } function tc(a, b) { let c; let d; const e = o.ajaxSettings.flatOptions || {}; for (c in b) void 0 !== b[c] && ((e[c] ? a : d || (d = {}))[c] = b[c]); return d && o.extend(!0, a, d), a; } function uc(a, b, c) { let d; let e; let f; let g; const h = a.contents; const i = a.dataTypes; while (i[0] === '*')i.shift(), void 0 === d && (d = a.mimeType || b.getResponseHeader('Content-Type')); if (d) for (e in h) if (h[e] && h[e].test(d)) { i.unshift(e); break; } if (i[0] in c)f = i[0]; else { for (e in c) { if (!i[0] || a.converters[`${e} ${i[0]}`]) { f = e; break; }g || (g = e); }f = f || g; } return f ? (f !== i[0] && i.unshift(f), c[f]) : void 0; } function vc(a, b, c, d) { let e; let f; let g; let h; let i; const j = {}; const k = a.dataTypes.slice(); if (k[1]) for (g in a.converters)j[g.toLowerCase()] = a.converters[g]; f = k.shift(); while (f) if (a.responseFields[f] && (c[a.responseFields[f]] = b), !i && d && a.dataFilter && (b = a.dataFilter(b, a.dataType)), i = f, f = k.shift()) if (f === '*')f = i; else if (i !== '*' && i !== f) { if (g = j[`${i} ${f}`] || j[`* ${f}`], !g) for (e in j) if (h = e.split(' '), h[1] === f && (g = j[`${i} ${h[0]}`] || j[`* ${h[0]}`])) { g === !0 ? g = j[e] : j[e] !== !0 && (f = h[0], k.unshift(h[1])); break; } if (g !== !0) if (g && a.throws)b = g(b); else try { b = g(b); } catch (l) { return { state: 'parsererror', error: g ? l : `No conversion from ${i} to ${f}` }; } } return { state: 'success', data: b }; }o.extend({
-    active: 0,
-    lastModified: {},
-    etag: {},
-    ajaxSettings: {
-      url: fc,
-      type: 'GET',
-      isLocal: jc.test(ec[1]),
-      global: !0,
-      processData: !0,
-      async: !0,
-      contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
-      accepts: {
-        '*': pc, text: 'text/plain', html: 'text/html', xml: 'application/xml, text/xml', json: 'application/json, text/javascript',
-      },
-      contents: { xml: /xml/, html: /html/, json: /json/ },
-      responseFields: { xml: 'responseXML', text: 'responseText', json: 'responseJSON' },
-      converters: {
-        '* text': String, 'text html': !0, 'text json': o.parseJSON, 'text xml': o.parseXML,
-      },
-      flatOptions: { url: !0, context: !0 },
-    },
-    ajaxSetup(a, b) { return b ? tc(tc(a, o.ajaxSettings), b) : tc(o.ajaxSettings, a); },
-    ajaxPrefilter: rc(nc),
-    ajaxTransport: rc(oc),
-    ajax(a, b) {
-      typeof a === 'object' && (b = a, a = void 0), b = b || {}; let c; let d; let e; let f; let g; let h; let i; let j; const k = o.ajaxSetup({}, b); const l = k.context || k; const m = k.context && (l.nodeType || l.jquery) ? o(l) : o.event; const n = o.Deferred(); const p = o.Callbacks('once memory'); let q = k.statusCode || {}; const r = {}; const s = {}; let t = 0; let u = 'canceled'; var v = {
-        readyState: 0, getResponseHeader(a) { let b; if (t === 2) { if (!f) { f = {}; while (b = ic.exec(e))f[b[1].toLowerCase()] = b[2]; }b = f[a.toLowerCase()]; } return b == null ? null : b; }, getAllResponseHeaders() { return t === 2 ? e : null; }, setRequestHeader(a, b) { const c = a.toLowerCase(); return t || (a = s[c] = s[c] || a, r[a] = b), this; }, overrideMimeType(a) { return t || (k.mimeType = a), this; }, statusCode(a) { let b; if (a) if (t < 2) for (b in a)q[b] = [q[b], a[b]]; else v.always(a[v.status]); return this; }, abort(a) { const b = a || u; return c && c.abort(b), x(0, b), this; },
-      }; if (n.promise(v).complete = p.add, v.success = v.done, v.error = v.fail, k.url = (`${a || k.url || fc}`).replace(gc, '').replace(lc, `${ec[1]}//`), k.type = b.method || b.type || k.method || k.type, k.dataTypes = o.trim(k.dataType || '*').toLowerCase().match(E) || [''], k.crossDomain == null && (h = mc.exec(k.url.toLowerCase()), k.crossDomain = !(!h || h[1] === ec[1] && h[2] === ec[2] && (h[3] || (h[1] === 'http:' ? '80' : '443')) === (ec[3] || (ec[1] === 'http:' ? '80' : '443')))), k.data && k.processData && typeof k.data !== 'string' && (k.data = o.param(k.data, k.traditional)), sc(nc, k, b, v), t === 2) return v; i = k.global, i && o.active++ === 0 && o.event.trigger('ajaxStart'), k.type = k.type.toUpperCase(), k.hasContent = !kc.test(k.type), d = k.url, k.hasContent || (k.data && (d = k.url += (dc.test(d) ? '&' : '?') + k.data, delete k.data), k.cache === !1 && (k.url = hc.test(d) ? d.replace(hc, `$1_=${cc++}`) : `${d + (dc.test(d) ? '&' : '?')}_=${cc++}`)), k.ifModified && (o.lastModified[d] && v.setRequestHeader('If-Modified-Since', o.lastModified[d]), o.etag[d] && v.setRequestHeader('If-None-Match', o.etag[d])), (k.data && k.hasContent && k.contentType !== !1 || b.contentType) && v.setRequestHeader('Content-Type', k.contentType), v.setRequestHeader('Accept', k.dataTypes[0] && k.accepts[k.dataTypes[0]] ? k.accepts[k.dataTypes[0]] + (k.dataTypes[0] !== '*' ? `, ${pc}; q=0.01` : '') : k.accepts['*']); for (j in k.headers)v.setRequestHeader(j, k.headers[j]); if (k.beforeSend && (k.beforeSend.call(l, v, k) === !1 || t === 2)) return v.abort(); u = 'abort'; for (j in { success: 1, error: 1, complete: 1 })v[j](k[j]); if (c = sc(oc, k, b, v)) { v.readyState = 1, i && m.trigger('ajaxSend', [v, k]), k.async && k.timeout > 0 && (g = setTimeout(() => { v.abort('timeout'); }, k.timeout)); try { t = 1, c.send(r, x); } catch (w) { if (!(t < 2)) throw w; x(-1, w); } } else x(-1, 'No Transport'); function x(a, b, f, h) { let j; let r; let s; let u; let w; let x = b; t !== 2 && (t = 2, g && clearTimeout(g), c = void 0, e = h || '', v.readyState = a > 0 ? 4 : 0, j = a >= 200 && a < 300 || a === 304, f && (u = uc(k, v, f)), u = vc(k, u, v, j), j ? (k.ifModified && (w = v.getResponseHeader('Last-Modified'), w && (o.lastModified[d] = w), w = v.getResponseHeader('etag'), w && (o.etag[d] = w)), a === 204 || k.type === 'HEAD' ? x = 'nocontent' : a === 304 ? x = 'notmodified' : (x = u.state, r = u.data, s = u.error, j = !s)) : (s = x, (a || !x) && (x = 'error', a < 0 && (a = 0))), v.status = a, v.statusText = `${b || x}`, j ? n.resolveWith(l, [r, x, v]) : n.rejectWith(l, [v, x, s]), v.statusCode(q), q = void 0, i && m.trigger(j ? 'ajaxSuccess' : 'ajaxError', [v, k, j ? r : s]), p.fireWith(l, [v, x]), i && (m.trigger('ajaxComplete', [v, k]), --o.active || o.event.trigger('ajaxStop'))); } return v;
-    },
-    getJSON(a, b, c) { return o.get(a, b, c, 'json'); },
-    getScript(a, b) { return o.get(a, void 0, b, 'script'); },
-  }), o.each(['get', 'post'], (a, b) => {
-    o[b] = function (a, c, d, e) {
-      return o.isFunction(c) && (e = e || d, d = c, c = void 0), o.ajax({
-        url: a, type: b, dataType: e, data: c, success: d,
-      });
-    };
-  }), o.each(['ajaxStart', 'ajaxStop', 'ajaxComplete', 'ajaxError', 'ajaxSuccess', 'ajaxSend'], (a, b) => { o.fn[b] = function (a) { return this.on(b, a); }; }), o._evalUrl = function (a) {
-    return o.ajax({
-      url: a, type: 'GET', dataType: 'script', async: !1, global: !1, throws: !0,
-    });
-  }, o.fn.extend({
-    wrapAll(a) { let b; return o.isFunction(a) ? this.each(function (b) { o(this).wrapAll(a.call(this, b)); }) : (this[0] && (b = o(a, this[0].ownerDocument).eq(0).clone(!0), this[0].parentNode && b.insertBefore(this[0]), b.map(function () { let a = this; while (a.firstElementChild)a = a.firstElementChild; return a; }).append(this)), this); }, wrapInner(a) { return this.each(o.isFunction(a) ? function (b) { o(this).wrapInner(a.call(this, b)); } : function () { const b = o(this); const c = b.contents(); c.length ? c.wrapAll(a) : b.append(a); }); }, wrap(a) { const b = o.isFunction(a); return this.each(function (c) { o(this).wrapAll(b ? a.call(this, c) : a); }); }, unwrap() { return this.parent().each(function () { o.nodeName(this, 'body') || o(this).replaceWith(this.childNodes); }).end(); },
-  }), o.expr.filters.hidden = function (a) { return a.offsetWidth <= 0 && a.offsetHeight <= 0; }, o.expr.filters.visible = function (a) { return !o.expr.filters.hidden(a); }; const wc = /%20/g; const xc = /\[\]$/; const yc = /\r?\n/g; const zc = /^(?:submit|button|image|reset|file)$/i; const Ac = /^(?:input|select|textarea|keygen)/i; function Bc(a, b, c, d) { let e; if (o.isArray(b))o.each(b, (b, e) => { c || xc.test(a) ? d(a, e) : Bc(`${a}[${typeof e === 'object' ? b : ''}]`, e, c, d); }); else if (c || o.type(b) !== 'object')d(a, b); else for (e in b)Bc(`${a}[${e}]`, b[e], c, d); }o.param = function (a, b) { let c; const d = []; const e = function (a, b) { b = o.isFunction(b) ? b() : b == null ? '' : b, d[d.length] = `${encodeURIComponent(a)}=${encodeURIComponent(b)}`; }; if (void 0 === b && (b = o.ajaxSettings && o.ajaxSettings.traditional), o.isArray(a) || a.jquery && !o.isPlainObject(a))o.each(a, function () { e(this.name, this.value); }); else for (c in a)Bc(c, a[c], b, e); return d.join('&').replace(wc, '+'); }, o.fn.extend({ serialize() { return o.param(this.serializeArray()); }, serializeArray() { return this.map(function () { const a = o.prop(this, 'elements'); return a ? o.makeArray(a) : this; }).filter(function () { const a = this.type; return this.name && !o(this).is(':disabled') && Ac.test(this.nodeName) && !zc.test(a) && (this.checked || !T.test(a)); }).map(function (a, b) { const c = o(this).val(); return c == null ? null : o.isArray(c) ? o.map(c, (a) => ({ name: b.name, value: a.replace(yc, '\r\n') })) : { name: b.name, value: c.replace(yc, '\r\n') }; }).get(); } }), o.ajaxSettings.xhr = function () { try { return new XMLHttpRequest(); } catch (a) {} }; let Cc = 0; const Dc = {}; const Ec = { 0: 200, 1223: 204 }; let Fc = o.ajaxSettings.xhr(); a.ActiveXObject && o(a).on('unload', () => { for (const a in Dc)Dc[a](); }), l.cors = !!Fc && 'withCredentials' in Fc, l.ajax = Fc = !!Fc, o.ajaxTransport((a) => { let b; return l.cors || Fc && !a.crossDomain ? { send(c, d) { let e; const f = a.xhr(); const g = ++Cc; if (f.open(a.type, a.url, a.async, a.username, a.password), a.xhrFields) for (e in a.xhrFields)f[e] = a.xhrFields[e]; a.mimeType && f.overrideMimeType && f.overrideMimeType(a.mimeType), a.crossDomain || c['X-Requested-With'] || (c['X-Requested-With'] = 'XMLHttpRequest'); for (e in c)f.setRequestHeader(e, c[e]); b = function (a) { return function () { b && (delete Dc[g], b = f.onload = f.onerror = null, a === 'abort' ? f.abort() : a === 'error' ? d(f.status, f.statusText) : d(Ec[f.status] || f.status, f.statusText, typeof f.responseText === 'string' ? { text: f.responseText } : void 0, f.getAllResponseHeaders())); }; }, f.onload = b(), f.onerror = b('error'), b = Dc[g] = b('abort'), f.send(a.hasContent && a.data || null); }, abort() { b && b(); } } : void 0; }), o.ajaxSetup({ accepts: { script: 'text/javascript, application/javascript, application/ecmascript, application/x-ecmascript' }, contents: { script: /(?:java|ecma)script/ }, converters: { 'text script': function (a) { return o.globalEval(a), a; } } }), o.ajaxPrefilter('script', (a) => { void 0 === a.cache && (a.cache = !1), a.crossDomain && (a.type = 'GET'); }), o.ajaxTransport('script', (a) => { if (a.crossDomain) { let b; let c; return { send(d, e) { b = o('<script>').prop({ async: !0, charset: a.scriptCharset, src: a.url }).on('load error', c = function (a) { b.remove(), c = null, a && e(a.type === 'error' ? 404 : 200, a.type); }), m.head.appendChild(b[0]); }, abort() { c && c(); } }; } }); const Gc = []; const Hc = /(=)\?(?=&|$)|\?\?/; o.ajaxSetup({ jsonp: 'callback', jsonpCallback() { const a = Gc.pop() || `${o.expando}_${cc++}`; return this[a] = !0, a; } }), o.ajaxPrefilter('json jsonp', (b, c, d) => { let e; let f; let g; const h = b.jsonp !== !1 && (Hc.test(b.url) ? 'url' : typeof b.data === 'string' && !(b.contentType || '').indexOf('application/x-www-form-urlencoded') && Hc.test(b.data) && 'data'); return h || b.dataTypes[0] === 'jsonp' ? (e = b.jsonpCallback = o.isFunction(b.jsonpCallback) ? b.jsonpCallback() : b.jsonpCallback, h ? b[h] = b[h].replace(Hc, `$1${e}`) : b.jsonp !== !1 && (b.url += `${(dc.test(b.url) ? '&' : '?') + b.jsonp}=${e}`), b.converters['script json'] = function () { return g || o.error(`${e} was not called`), g[0]; }, b.dataTypes[0] = 'json', f = a[e], a[e] = function () { g = arguments; }, d.always(() => { a[e] = f, b[e] && (b.jsonpCallback = c.jsonpCallback, Gc.push(e)), g && o.isFunction(f) && f(g[0]), g = f = void 0; }), 'script') : void 0; }), o.parseHTML = function (a, b, c) { if (!a || typeof a !== 'string') return null; typeof b === 'boolean' && (c = b, b = !1), b = b || m; let d = v.exec(a); const e = !c && []; return d ? [b.createElement(d[1])] : (d = o.buildFragment([a], b, e), e && e.length && o(e).remove(), o.merge([], d.childNodes)); }; const Ic = o.fn.load; o.fn.load = function (a, b, c) {
-    if (typeof a !== 'string' && Ic) return Ic.apply(this, arguments); let d; let e; let f; const g = this; const h = a.indexOf(' '); return h >= 0 && (d = a.slice(h), a = a.slice(0, h)), o.isFunction(b) ? (c = b, b = void 0) : b && typeof b === 'object' && (e = 'POST'), g.length > 0 && o.ajax({
-      url: a, type: e, dataType: 'html', data: b,
-    }).done(function (a) { f = arguments, g.html(d ? o('<div>').append(o.parseHTML(a)).find(d) : a); }).complete(c && ((a, b) => { g.each(c, f || [a.responseText, b, a]); })), this;
-  }, o.expr.filters.animated = function (a) { return o.grep(o.timers, (b) => a === b.elem).length; }; const Jc = a.document.documentElement; function Kc(a) { return o.isWindow(a) ? a : a.nodeType === 9 && a.defaultView; }o.offset = { setOffset(a, b, c) { let d; let e; let f; let g; let h; let i; let j; const k = o.css(a, 'position'); const l = o(a); const m = {}; k === 'static' && (a.style.position = 'relative'), h = l.offset(), f = o.css(a, 'top'), i = o.css(a, 'left'), j = (k === 'absolute' || k === 'fixed') && (f + i).indexOf('auto') > -1, j ? (d = l.position(), g = d.top, e = d.left) : (g = parseFloat(f) || 0, e = parseFloat(i) || 0), o.isFunction(b) && (b = b.call(a, c, h)), b.top != null && (m.top = b.top - h.top + g), b.left != null && (m.left = b.left - h.left + e), 'using' in b ? b.using.call(a, m) : l.css(m); } }, o.fn.extend({ offset(a) { if (arguments.length) return void 0 === a ? this : this.each(function (b) { o.offset.setOffset(this, a, b); }); let b; let c; const d = this[0]; let e = { top: 0, left: 0 }; const f = d && d.ownerDocument; if (f) return b = f.documentElement, o.contains(b, d) ? (typeof d.getBoundingClientRect !== U && (e = d.getBoundingClientRect()), c = Kc(f), { top: e.top + c.pageYOffset - b.clientTop, left: e.left + c.pageXOffset - b.clientLeft }) : e; }, position() { if (this[0]) { let a; let b; const c = this[0]; let d = { top: 0, left: 0 }; return o.css(c, 'position') === 'fixed' ? b = c.getBoundingClientRect() : (a = this.offsetParent(), b = this.offset(), o.nodeName(a[0], 'html') || (d = a.offset()), d.top += o.css(a[0], 'borderTopWidth', !0), d.left += o.css(a[0], 'borderLeftWidth', !0)), { top: b.top - d.top - o.css(c, 'marginTop', !0), left: b.left - d.left - o.css(c, 'marginLeft', !0) }; } }, offsetParent() { return this.map(function () { let a = this.offsetParent || Jc; while (a && !o.nodeName(a, 'html') && o.css(a, 'position') === 'static')a = a.offsetParent; return a || Jc; }); } }), o.each({ scrollLeft: 'pageXOffset', scrollTop: 'pageYOffset' }, (b, c) => { const d = c === 'pageYOffset'; o.fn[b] = function (e) { return J(this, (b, e, f) => { const g = Kc(b); return void 0 === f ? g ? g[c] : b[e] : void (g ? g.scrollTo(d ? a.pageXOffset : f, d ? f : a.pageYOffset) : b[e] = f); }, b, e, arguments.length, null); }; }), o.each(['top', 'left'], (a, b) => { o.cssHooks[b] = yb(l.pixelPosition, (a, c) => (c ? (c = xb(a, b), vb.test(c) ? `${o(a).position()[b]}px` : c) : void 0)); }), o.each({ Height: 'height', Width: 'width' }, (a, b) => { o.each({ padding: `inner${a}`, content: b, '': `outer${a}` }, (c, d) => { o.fn[d] = function (d, e) { const f = arguments.length && (c || typeof d !== 'boolean'); const g = c || (d === !0 || e === !0 ? 'margin' : 'border'); return J(this, (b, c, d) => { let e; return o.isWindow(b) ? b.document.documentElement[`client${a}`] : b.nodeType === 9 ? (e = b.documentElement, Math.max(b.body[`scroll${a}`], e[`scroll${a}`], b.body[`offset${a}`], e[`offset${a}`], e[`client${a}`])) : void 0 === d ? o.css(b, c, g) : o.style(b, c, d, g); }, b, f ? d : void 0, f, null); }; }); }), o.fn.size = function () { return this.length; }, o.fn.andSelf = o.fn.addBack, typeof define === 'function' && define.amd && define('jquery', [], () => o); const Lc = a.jQuery; const Mc = a.$; return o.noConflict = function (b) { return a.$ === o && (a.$ = Mc), b && a.jQuery === o && (a.jQuery = Lc), o; }, typeof b === U && (a.jQuery = a.$ = o), o;
-}));
diff --git a/packages/mindplot/src/components/libraries/jquery/jquery.mousewheel.min.js b/packages/mindplot/src/components/libraries/jquery/jquery.mousewheel.min.js
deleted file mode 100644
index e1b6107a..00000000
--- a/packages/mindplot/src/components/libraries/jquery/jquery.mousewheel.min.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/*! Copyright (c) 2013 Brandon Aaron (http://brandon.aaron.sh)
- * Licensed under the MIT License (LICENSE.txt).
- *
- * Version: 3.1.11
- *
- * Requires: jQuery 1.2.2+
- */
-!(function (a) { typeof define === 'function' && define.amd ? define(['jquery'], a) : typeof exports === 'object' ? module.exports = a : a(jQuery); }((a) => {
-  function b(b) { const g = b || window.event; const h = i.call(arguments, 1); let j = 0; let l = 0; let m = 0; let n = 0; let o = 0; let p = 0; if (b = a.event.fix(g), b.type = 'mousewheel', 'detail' in g && (m = -1 * g.detail), 'wheelDelta' in g && (m = g.wheelDelta), 'wheelDeltaY' in g && (m = g.wheelDeltaY), 'wheelDeltaX' in g && (l = -1 * g.wheelDeltaX), 'axis' in g && g.axis === g.HORIZONTAL_AXIS && (l = -1 * m, m = 0), j = m === 0 ? l : m, 'deltaY' in g && (m = -1 * g.deltaY, j = m), 'deltaX' in g && (l = g.deltaX, m === 0 && (j = -1 * l)), m !== 0 || l !== 0) { if (g.deltaMode === 1) { const q = a.data(this, 'mousewheel-line-height'); j *= q, m *= q, l *= q; } else if (g.deltaMode === 2) { const r = a.data(this, 'mousewheel-page-height'); j *= r, m *= r, l *= r; } if (n = Math.max(Math.abs(m), Math.abs(l)), (!f || f > n) && (f = n, d(g, n) && (f /= 40)), d(g, n) && (j /= 40, l /= 40, m /= 40), j = Math[j >= 1 ? 'floor' : 'ceil'](j / f), l = Math[l >= 1 ? 'floor' : 'ceil'](l / f), m = Math[m >= 1 ? 'floor' : 'ceil'](m / f), k.settings.normalizeOffset && this.getBoundingClientRect) { const s = this.getBoundingClientRect(); o = b.clientX - s.left, p = b.clientY - s.top; } return b.deltaX = l, b.deltaY = m, b.deltaFactor = f, b.offsetX = o, b.offsetY = p, b.deltaMode = 0, h.unshift(b, j, l, m), e && clearTimeout(e), e = setTimeout(c, 200), (a.event.dispatch || a.event.handle).apply(this, h); } } function c() { f = null; } function d(a, b) { return k.settings.adjustOldDeltas && a.type === 'mousewheel' && b % 120 === 0; } let e; let f; const g = ['wheel', 'mousewheel', 'DOMMouseScroll', 'MozMousePixelScroll']; const h = 'onwheel' in document || document.documentMode >= 9 ? ['wheel'] : ['mousewheel', 'DomMouseScroll', 'MozMousePixelScroll']; var i = Array.prototype.slice; if (a.event.fixHooks) for (let j = g.length; j;)a.event.fixHooks[g[--j]] = a.event.mouseHooks; var k = a.event.special.mousewheel = {
-    version: '3.1.11', setup() { if (this.addEventListener) for (let c = h.length; c;) this.addEventListener(h[--c], b, !1); else this.onmousewheel = b; a.data(this, 'mousewheel-line-height', k.getLineHeight(this)), a.data(this, 'mousewheel-page-height', k.getPageHeight(this)); }, teardown() { if (this.removeEventListener) for (let c = h.length; c;) this.removeEventListener(h[--c], b, !1); else this.onmousewheel = null; a.removeData(this, 'mousewheel-line-height'), a.removeData(this, 'mousewheel-page-height'); }, getLineHeight(b) { let c = a(b)['offsetParent' in a.fn ? 'offsetParent' : 'parent'](); return c.length || (c = a('body')), parseInt(c.css('fontSize'), 10); }, getPageHeight(b) { return a(b).height(); }, settings: { adjustOldDeltas: !0, normalizeOffset: !0 },
-  }; a.fn.extend({ mousewheel(a) { return a ? this.bind('mousewheel', a) : this.trigger('mousewheel'); }, unmousewheel(a) { return this.unbind('mousewheel', a); } });
-}));
diff --git a/packages/mindplot/src/components/libraries/less/less-1.4.2.min.js b/packages/mindplot/src/components/libraries/less/less-1.4.2.min.js
deleted file mode 100755
index 3488b625..00000000
--- a/packages/mindplot/src/components/libraries/less/less-1.4.2.min.js
+++ /dev/null
@@ -1,371 +0,0 @@
-/*
- * LESS - Leaner CSS v1.4.2
- * http://lesscss.org
- *
- * Copyright (c) 2009-2013, Alexis Sellier
- * Licensed under the Apache 2.0 License.
- *
- * @licence
- */(function (e, t) {
-  function n(t) { return e.less[t.split('/')[1]]; } function f() { r.env === 'development' ? (r.optimization = 0, r.watchTimer = setInterval(() => { r.watchMode && g((e, t, n, i, s) => { e ? k(e, i.href) : t && S(t.toCSS(r), i, s.lastModified); }); }, r.poll)) : r.optimization = 3; } function m() { const e = document.getElementsByTagName('style'); for (var t = 0; t < e.length; t++) if (e[t].type.match(p)) { const n = new r.tree.parseEnv(r); n.filename = document.location.href.replace(/#.*$/, ''), (new r.Parser(n)).parse(e[t].innerHTML || '', (n, i) => { if (n) return k(n, 'inline'); const s = i.toCSS(r); const o = e[t]; o.type = 'text/css', o.styleSheet ? o.styleSheet.cssText = s : o.innerHTML = s; }); } } function g(e, t) { for (let n = 0; n < r.sheets.length; n++)w(r.sheets[n], e, t, r.sheets.length - (n + 1)); } function y(e, t) { const n = b(e); const r = b(t); let i; let s; let o; let u; let a = ''; if (n.hostPart !== r.hostPart) return ''; s = Math.max(r.directories.length, n.directories.length); for (i = 0; i < s; i++) if (r.directories[i] !== n.directories[i]) break; u = r.directories.slice(i), o = n.directories.slice(i); for (i = 0; i < u.length - 1; i++)a += '../'; for (i = 0; i < o.length - 1; i++)a += `${o[i]}/`; return a; } function b(e, t) { const n = /^((?:[a-z-]+:)?\/+?(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i; const r = e.match(n); const i = {}; let s = []; let o; let u; if (!r) throw new Error(`Could not parse sheet href - '${e}'`); if (!r[1] || r[2]) { u = t.match(n); if (!u) throw new Error(`Could not parse page url - '${t}'`); r[1] = r[1] || u[1] || '', r[2] || (r[3] = u[3] + r[3]); } if (r[3]) { s = r[3].replace(/\\/g, '/').split('/'); for (o = 0; o < s.length; o++)s[o] === '.' && (s.splice(o, 1), o -= 1); for (o = 0; o < s.length; o++)s[o] === '..' && o > 0 && (s.splice(o - 1, 2), o -= 2); } return i.hostPart = r[1], i.directories = s, i.path = r[1] + s.join('/'), i.fileUrl = i.path + (r[4] || ''), i.url = i.fileUrl + (r[5] || ''), i; } function w(t, n, i, s) { const o = b(t.href, e.location.href); const u = o.url; const a = l && l.getItem(u); const f = l && l.getItem(`${u}:timestamp`); const c = { css: a, timestamp: f }; let h; const p = { relativeUrls: r.relativeUrls, currentDirectory: o.path, filename: u }; t instanceof r.tree.parseEnv ? (h = new r.tree.parseEnv(t), p.entryPath = h.currentFileInfo.entryPath, p.rootpath = h.currentFileInfo.rootpath, p.rootFilename = h.currentFileInfo.rootFilename) : (h = new r.tree.parseEnv(r), h.mime = t.type, p.entryPath = o.path, p.rootpath = r.rootpath || o.path, p.rootFilename = u), h.relativeUrls && (r.rootpath ? p.rootpath = b(r.rootpath + y(o.path, p.entryPath)).path : p.rootpath = o.path), x(u, t.type, (e, a) => { v += e.replace(/@import .+?;/ig, ''); if (!i && c && a && (new Date(a)).valueOf() === (new Date(c.timestamp)).valueOf())S(c.css, t), n(null, null, e, t, { local: !0, remaining: s }, u); else try { h.contents[u] = e, h.paths = [o.path], h.currentFileInfo = p, (new r.Parser(h)).parse(e, (r, i) => { if (r) return n(r, null, null, t); try { n(r, i, e, t, { local: !1, lastModified: a, remaining: s }, u), h.currentFileInfo.rootFilename === u && N(document.getElementById(`less-error-message:${E(u)}`)); } catch (r) { n(r, null, null, t); } }); } catch (f) { n(f, null, null, t); } }, (e, r) => { n({ type: 'File', message: `'${r}' wasn't found (${e})` }, null, null, t); }); } function E(e) {
-    return e.replace(/^[a-z-]+:\/+?[^\/]+/, '').replace(/^\//, '').replace(/\.[a-zA-Z]+$/, '').replace(/[^\.\w-]+/g, '-')
-      .replace(/\./g, ':');
-  } function S(e, t, n) { const r = t.href || ''; const i = `less:${t.title || E(r)}`; const s = document.getElementById(i); let o = !1; const u = document.createElement('style'); u.setAttribute('type', 'text/css'), t.media && u.setAttribute('media', t.media), u.id = i; if (u.styleSheet) try { u.styleSheet.cssText = e; } catch (a) { throw new Error("Couldn't reassign styleSheet.cssText."); } else u.appendChild(document.createTextNode(e)), o = s !== null && s.childNodes.length > 0 && u.childNodes.length > 0 && s.firstChild.nodeValue === u.firstChild.nodeValue; const f = document.getElementsByTagName('head')[0]; if (s == null || o === !1) { const c = t && t.nextSibling || null; (c || document.getElementsByTagName('head')[0]).parentNode.insertBefore(u, c); }s && o === !1 && f.removeChild(s); if (n && l) { C(`saving ${r} to cache.`); try { l.setItem(r, e), l.setItem(`${r}:timestamp`, n); } catch (a) { C('failed to save'); } } } function x(e, t, n, i) { function a(t, n, r) { t.status >= 200 && t.status < 300 ? n(t.responseText, t.getResponseHeader('Last-Modified')) : typeof r === 'function' && r(t.status, e); } const s = T(); const u = o ? r.fileAsync : r.async; typeof s.overrideMimeType === 'function' && s.overrideMimeType('text/css'), s.open('GET', e, u), s.setRequestHeader('Accept', t || 'text/x-less, text/css; q=0.9, */*; q=0.5'), s.send(null), o && !r.fileAsync ? s.status === 0 || s.status >= 200 && s.status < 300 ? n(s.responseText) : i(s.status, e) : u ? s.onreadystatechange = function () { s.readyState == 4 && a(s, n, i); } : a(s, n, i); } function T() { if (e.XMLHttpRequest) return new XMLHttpRequest(); try { return new ActiveXObject('MSXML2.XMLHTTP.3.0'); } catch (t) { return C("browser doesn't support AJAX."), null; } } function N(e) { return e && e.parentNode.removeChild(e); } function C(e) { r.env == 'development' && typeof console !== 'undefined' && console.log(`less: ${e}`); } function k(e, n) { const i = `less-error-message:${E(n || '')}`; const s = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>'; const o = document.createElement('div'); let u; let a; const f = []; const l = e.filename || n; const c = l.match(/([^\/]+(\?.*)?)$/)[1]; o.id = i, o.className = 'less-error-message', a = `<h3>${e.type || 'Syntax'}Error: ${e.message || 'There is an error in your .less file'}</h3>` + `<p>in <a href="${l}">${c}</a> `; const h = function (e, n, r) { e.extract[n] != t && f.push(s.replace(/\{line\}/, (parseInt(e.line) || 0) + (n - 1)).replace(/\{class\}/, r).replace(/\{content\}/, e.extract[n])); }; e.extract ? (h(e, 0, ''), h(e, 1, 'line'), h(e, 2, ''), a += `on line ${e.line}, column ${e.column + 1}:</p>` + `<ul>${f.join('')}</ul>`) : e.stack && (a += `<br/>${e.stack.split('\n').slice(1).join('<br/>')}`), o.innerHTML = a, S(['.less-error-message ul, .less-error-message li {', 'list-style-type: none;', 'margin-right: 15px;', 'padding: 4px 0;', 'margin: 0;', '}', '.less-error-message label {', 'font-size: 12px;', 'margin-right: 15px;', 'padding: 4px 0;', 'color: #cc7777;', '}', '.less-error-message pre {', 'color: #dd6666;', 'padding: 4px 0;', 'margin: 0;', 'display: inline-block;', '}', '.less-error-message pre.line {', 'color: #ff0000;', '}', '.less-error-message h3 {', 'font-size: 20px;', 'font-weight: bold;', 'padding: 15px 0 5px 0;', 'margin: 0;', '}', '.less-error-message a {', 'color: #10a', '}', '.less-error-message .error {', 'color: red;', 'font-weight: bold;', 'padding-bottom: 2px;', 'border-bottom: 1px dashed red;', '}'].join('\n'), { title: 'error-message' }), o.style.cssText = ['font-family: Arial, sans-serif', 'border: 1px solid #e00', 'background-color: #eee', 'border-radius: 5px', '-webkit-border-radius: 5px', '-moz-border-radius: 5px', 'color: #e00', 'padding: 15px', 'margin-bottom: 15px'].join(';'), r.env == 'development' && (u = setInterval(() => { document.body && (document.getElementById(i) ? document.body.replaceChild(o, document.getElementById(i)) : document.body.insertBefore(o, document.body.firstChild), clearInterval(u)); }, 10)); } let r; let i; let s; typeof environment === 'object' && {}.toString.call(environment) === '[object Environment]' ? (typeof e === 'undefined' ? r = {} : r = e.less = {}, i = r.tree = {}, r.mode = 'rhino') : typeof e === 'undefined' ? (r = exports, i = n('./tree'), r.mode = 'node') : (typeof e.less === 'undefined' && (e.less = {}), r = e.less, i = e.less.tree = {}, r.mode = 'browser'), r.Parser = function (t) {
-    function m() { a = c[u], f = o, h = o; } function g() { c[u] = a, o = f, h = o; } function y() { o > h && (c[u] = c[u].slice(o - h), h = o); } function b(e) { const t = e.charCodeAt(0); return t === 32 || t === 10 || t === 9; } function w(e) { let t; let n; let r; let i; let a; if (e instanceof Function) return e.call(p.parsers); if (typeof e === 'string')t = s.charAt(o) === e ? e : null, r = 1, y(); else { y(); if (!(t = e.exec(c[u]))) return null; r = t[0].length; } if (t) return E(r), typeof t === 'string' ? t : t.length === 1 ? t[0] : t; } function E(e) { const t = o; const n = u; const r = o + c[u].length; const i = o += e; while (o < r) { if (!b(s.charAt(o))) break; o++; } return c[u] = c[u].slice(e + (o - i)), h = o, c[u].length === 0 && u < c.length - 1 && u++, t !== o || n !== u; } function S(e, t) { const n = w(e); if (n) return n; x(t || (typeof e === 'string' ? `expected '${e}' got '${s.charAt(o)}'` : 'unexpected token')); } function x(e, t) { const n = new Error(e); throw n.index = o, n.type = t || 'Syntax', n; } function T(e) { return typeof e === 'string' ? s.charAt(o) === e : e.test(c[u]) ? !0 : !1; } function N(e, t) { return e.filename && t.currentFileInfo.filename && e.filename !== t.currentFileInfo.filename ? p.imports.contents[e.filename] : s; } function C(e, t) { for (var n = e, r = -1; n >= 0 && t.charAt(n) !== '\n'; n--)r++; return { line: typeof e === 'number' ? (t.slice(0, e).match(/\n/g) || '').length : null, column: r }; } function k(e, t, i) { let s = i.currentFileInfo.filename; return r.mode !== 'browser' && r.mode !== 'rhino' && (s = n('path').resolve(s)), { lineNumber: C(e, t).line + 1, fileName: s }; } function L(e, t) { const n = N(e, t); const r = C(e.index, n); const i = r.line; const s = r.column; const o = n.split('\n'); this.type = e.type || 'Syntax', this.message = e.message, this.filename = e.filename || t.currentFileInfo.filename, this.index = e.index, this.line = typeof i === 'number' ? i + 1 : null, this.callLine = e.call && C(e.call, n).line + 1, this.callExtract = o[C(e.call, n).line], this.stack = e.stack, this.column = s, this.extract = [o[i - 1], o[i], o[i + 1]]; } let s; let o; let u; let a; let f; let l; let c; let h; let p; const d = this; t instanceof i.parseEnv || (t = new i.parseEnv(t)); const v = this.imports = {
-      paths: t.paths || [], queue: [], files: t.files, contents: t.contents, mime: t.mime, error: null, push(e, n, i) { const s = this; this.queue.push(e), r.Parser.importer(e, n, (t, n, r) => { s.queue.splice(s.queue.indexOf(e), 1); const o = r in s.files; s.files[r] = n, t && !s.error && (s.error = t), i(t, n, o); }, t); },
-    }; return L.prototype = new Error(), L.prototype.constructor = L, this.env = t = t || {}, this.optimization = 'optimization' in this.env ? this.env.optimization : 1, p = {
-      imports: v,
-      parse(e, a) {
-        let f; let d; let v; let m; let g; let y; const b = []; let E; let S = null; o = u = h = l = 0, s = e.replace(/\r\n/g, '\n'), s = s.replace(/^\uFEFF/, ''), c = (function (e) {
-          let n = 0; const r = /(?:@\{[\w-]+\}|[^"'`\{\}\/\(\)\\])+/g; const i = /\/\*(?:[^*]|\*+[^\/*])*\*+\/|\/\/.*/g; const o = /"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'|`((?:[^`]|\\.)*)`/g; let u = 0; let a; let f = e[0]; let l; for (var c = 0, h, p; c < s.length;) { r.lastIndex = c, (a = r.exec(s)) && a.index === c && (c += a[0].length, f.push(a[0])), h = s.charAt(c), i.lastIndex = o.lastIndex = c; if (a = o.exec(s)) if (a.index === c) { c += a[0].length, f.push(a[0]); continue; } if (!l && h === '/') { p = s.charAt(c + 1); if (p === '/' || p === '*') if (a = i.exec(s)) if (a.index === c) { c += a[0].length, f.push(a[0]); continue; } } switch (h) { case '{': if (!l) { u++, f.push(h); break; } case '}': if (!l) { u--, f.push(h), e[++n] = f = []; break; } case '(': if (!l) { l = !0, f.push(h); break; } case ')': if (l) { l = !1, f.push(h); break; } default: f.push(h); }c++; } return u != 0 && (S = new L({
-            index: c - 1, type: 'Parse', message: u > 0 ? 'missing closing `}`' : 'missing opening `{`', filename: t.currentFileInfo.filename,
-          }, t)), e.map((e) => e.join(''));
-        }([[]])); if (S) return a(new L(S, t)); try { f = new i.Ruleset([], w(this.parsers.primary)), f.root = !0, f.firstRoot = !0; } catch (x) { return a(new L(x, t)); }f.toCSS = (function (e) { let s; let o; let u; return function (s, o) { s = s || {}; let u; const a = new i.evalEnv(s); typeof o === 'object' && !Array.isArray(o) && (o = Object.keys(o).map((e) => { let t = o[e]; return t instanceof i.Value || (t instanceof i.Expression || (t = new i.Expression([t])), t = new i.Value([t])), new i.Rule(`@${e}`, t, !1, 0); }), a.frames = [new i.Ruleset(null, o)]); try { const f = e.call(this, a); (new i.joinSelectorVisitor()).run(f), (new i.processExtendsVisitor()).run(f); var l = f.toCSS({ compress: Boolean(s.compress), dumpLineNumbers: t.dumpLineNumbers, strictUnits: Boolean(s.strictUnits) }); } catch (c) { throw new L(c, t); } return s.yuicompress && r.mode === 'node' ? n('ycssmin').cssmin(l, s.maxLineLen) : s.compress ? l.replace(/(\s)+/g, '$1') : l; }; }(f.eval)); if (o < s.length - 1) {
-          o = l, y = s.split('\n'), g = (s.slice(0, o).match(/\n/g) || '').length + 1; for (var T = o, N = -1; T >= 0 && s.charAt(T) !== '\n'; T--)N++; S = {
-            type: 'Parse', message: 'Unrecognised input', index: o, filename: t.currentFileInfo.filename, line: g, column: N, extract: [y[g - 2], y[g - 1], y[g]],
-          };
-        } const C = function (e) { e = S || e || p.imports.error, e ? (e instanceof L || (e = new L(e, t)), a(e)) : a(null, f); }; t.processImports !== !1 ? (new i.importVisitor(this.imports, C)).run(f) : C();
-      },
-      parsers: {
-        primary() { let e; const t = []; while ((e = w(this.extendRule) || w(this.mixin.definition) || w(this.rule) || w(this.ruleset) || w(this.mixin.call) || w(this.comment) || w(this.directive)) || w(/^[\s\n]+/) || w(/^;+/))e && t.push(e); return t; },
-        comment() { let e; if (s.charAt(o) !== '/') return; if (s.charAt(o + 1) === '/') return new i.Comment(w(/^\/\/.*/), !0); if (e = w(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/)) return new i.Comment(e); },
-        entities: {
-          quoted() { let e; let n = o; let r; const u = o; s.charAt(n) === '~' && (n++, r = !0); if (s.charAt(n) !== '"' && s.charAt(n) !== "'") return; r && w('~'); if (e = w(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/)) return new i.Quoted(e[0], e[1] || e[2], r, u, t.currentFileInfo); }, keyword() { let e; if (e = w(/^[_A-Za-z-][_A-Za-z0-9-]*/)) return i.colors.hasOwnProperty(e) ? new i.Color(i.colors[e].slice(1)) : new i.Keyword(e); }, call() { let e; let n; let r; let s; const a = o; if (!(e = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(c[u]))) return; e = e[1], n = e.toLowerCase(); if (n === 'url') return null; o += e.length; if (n === 'alpha') { s = w(this.alpha); if (typeof s !== 'undefined') return s; }w('('), r = w(this.entities.arguments); if (!w(')')) return; if (e) return new i.Call(e, r, a, t.currentFileInfo); }, arguments() { const e = []; let t; while (t = w(this.entities.assignment) || w(this.expression)) { e.push(t); if (!w(',')) break; } return e; }, literal() { return w(this.entities.dimension) || w(this.entities.color) || w(this.entities.quoted) || w(this.entities.unicodeDescriptor); }, assignment() { let e; let t; if ((e = w(/^\w+(?=\s?=)/i)) && w('=') && (t = w(this.entity))) return new i.Assignment(e, t); }, url() { let e; if (s.charAt(o) !== 'u' || !w(/^url\(/)) return; return e = w(this.entities.quoted) || w(this.entities.variable) || w(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || '', S(')'), new i.URL(e.value != null || e instanceof i.Variable ? e : new i.Anonymous(e), t.currentFileInfo); }, variable() { let e; const n = o; if (s.charAt(o) === '@' && (e = w(/^@@?[\w-]+/))) return new i.Variable(e, n, t.currentFileInfo); }, variableCurly() { let e; let n; const r = o; if (s.charAt(o) === '@' && (n = w(/^@\{([\w-]+)\}/))) return new i.Variable(`@${n[1]}`, r, t.currentFileInfo); }, color() { let e; if (s.charAt(o) === '#' && (e = w(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/))) return new i.Color(e[1]); }, dimension() { let e; const t = s.charCodeAt(o); if (t > 57 || t < 43 || t === 47 || t == 44) return; if (e = w(/^([+-]?\d*\.?\d+)(%|[a-z]+)?/)) return new i.Dimension(e[1], e[2]); }, unicodeDescriptor() { let e; if (e = w(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/)) return new i.UnicodeDescriptor(e[0]); }, javascript() { let e; let t = o; let n; s.charAt(t) === '~' && (t++, n = !0); if (s.charAt(t) !== '`') return; n && w('~'); if (e = w(/^`([^`]*)`/)) return new i.JavaScript(e[1], o, n); },
-        },
-        variable() { let e; if (s.charAt(o) === '@' && (e = w(/^(@[\w-]+)\s*:/))) return e[1]; },
-        extend(e) { let t; let n; const r = o; let s; const u = []; if (!w(e ? /^&:extend\(/ : /^:extend\(/)) return; do { s = null, t = []; for (;;) { s = w(/^(all)(?=\s*(\)|,))/); if (s) break; n = w(this.element); if (!n) break; t.push(n); }s = s && s[1], u.push(new i.Extend(new i.Selector(t), s, r)); } while (w(',')); return S(/^\)/), e && S(/^;/), u; },
-        extendRule() { return this.extend(!0); },
-        mixin: { call() { const e = []; let n; let r; let u; let a; let f; const l = o; const c = s.charAt(o); let h = !1; if (c !== '.' && c !== '#') return; m(); while (n = w(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/))e.push(new i.Element(r, n, o)), r = w('>'); w('(') && (u = this.mixin.args.call(this, !0).args, S(')')), u = u || [], w(this.important) && (h = !0); if (e.length > 0 && (w(';') || T('}'))) return new i.mixin.Call(e, u, l, t.currentFileInfo, h); g(); }, args(e) { let t = []; const n = []; let r; const u = []; let a; let f; let l; let c; let h; const p = { args: null, variadic: !1 }; for (;;) { if (e)h = w(this.expression); else { w(this.comment); if (s.charAt(o) === '.' && w(/^\.{3}/)) { p.variadic = !0, w(';') && !r && (r = !0), (r ? n : u).push({ variadic: !0 }); break; }h = w(this.entities.variable) || w(this.entities.literal) || w(this.entities.keyword); } if (!h) break; l = null, h.throwAwayComments && h.throwAwayComments(), c = h; var d = null; if (e) { if (h.value.length == 1) var d = h.value[0]; } else d = h; if (d && d instanceof i.Variable) if (w(':'))t.length > 0 && (r && x('Cannot mix ; and , as delimiter types'), a = !0), c = S(this.expression), l = f = d.name; else { if (!e && w(/^\.{3}/)) { p.variadic = !0, w(';') && !r && (r = !0), (r ? n : u).push({ name: h.name, variadic: !0 }); break; }e || (f = l = d.name, c = null); }c && t.push(c), u.push({ name: l, value: c }); if (w(',')) continue; if (w(';') || r)a && x('Cannot mix ; and , as delimiter types'), r = !0, t.length > 1 && (c = new i.Value(t)), n.push({ name: f, value: c }), f = null, t = [], a = !1; } return p.args = r ? n : u, p; }, definition() { let e; let t = []; let n; let r; let u; let a; let f; let c = !1; if (s.charAt(o) !== '.' && s.charAt(o) !== '#' || T(/^[^{]*\}/)) return; m(); if (n = w(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/)) { e = n[1]; const h = this.mixin.args.call(this, !1); t = h.args, c = h.variadic, w(')') || (l = o, g()), w(this.comment), w(/^when/) && (f = S(this.conditions, 'expected condition')), r = w(this.block); if (r) return new i.mixin.Definition(e, t, r, f, c); g(); } } },
-        entity() { return w(this.entities.literal) || w(this.entities.variable) || w(this.entities.url) || w(this.entities.call) || w(this.entities.keyword) || w(this.entities.javascript) || w(this.comment); },
-        end() { return w(';') || T('}'); },
-        alpha() { let e; if (!w(/^\(opacity=/i)) return; if (e = w(/^\d+/) || w(this.entities.variable)) return S(')'), new i.Alpha(e); },
-        element() { let e; let t; let n; let r; n = w(this.combinator), e = w(/^(?:\d+\.\d+|\d+)%/) || w(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) || w('*') || w('&') || w(this.attribute) || w(/^\([^()@]+\)/) || w(/^[\.#](?=@)/) || w(this.entities.variableCurly), e || w('(') && (r = w(this.selector)) && w(')') && (e = new i.Paren(r)); if (e) return new i.Element(n, e, o); },
-        combinator() { const e = s.charAt(o); if (e === '>' || e === '+' || e === '~' || e === '|') { o++; while (s.charAt(o).match(/\s/))o++; return new i.Combinator(e); } return s.charAt(o - 1).match(/\s/) ? new i.Combinator(' ') : new i.Combinator(null); },
-        selector() { let e; let t; const n = []; let r; let u; const a = []; while ((u = w(this.extend)) || (t = w(this.element))) { u ? a.push.apply(a, u) : (a.length && x('Extend can only be used at the end of selector'), r = s.charAt(o), n.push(t), t = null); if (r === '{' || r === '}' || r === ';' || r === ',' || r === ')') break; } if (n.length > 0) return new i.Selector(n, a); a.length && x('Extend must be used to extend a selector, it cannot be used on its own'); },
-        attribute() { const e = ''; let t; let n; let r; if (!w('[')) return; (t = w(this.entities.variableCurly)) || (t = S(/^(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/)); if (r = w(/^[|~*$^]?=/))n = w(this.entities.quoted) || w(/^[\w-]+/) || w(this.entities.variableCurly); return S(']'), new i.Attribute(t, r, n); },
-        block() { let e; if (w('{') && (e = w(this.primary)) && w('}')) return e; },
-        ruleset() { const e = []; let n; let r; let u; m(), t.dumpLineNumbers && (u = k(o, s, t)); while (n = w(this.selector)) { e.push(n), w(this.comment); if (!w(',')) break; w(this.comment); } if (e.length > 0 && (r = w(this.block))) { const a = new i.Ruleset(e, r, t.strictImports); return t.dumpLineNumbers && (a.debugInfo = u), a; }l = o, g(); },
-        rule(e) { let n; let r; const u = s.charAt(o); let a; m(); if (u === '.' || u === '#' || u === '&') return; if (n = w(this.variable) || w(this.property)) { r = !e && (t.compress || n.charAt(0) === '@') ? w(this.value) || w(this.anonymousValue) : w(this.anonymousValue) || w(this.value), a = w(this.important); if (r && w(this.end)) return new i.Rule(n, r, a, f, t.currentFileInfo); l = o, g(); if (r && !e) return this.rule(!0); } },
-        anonymousValue() { let e; if (e = /^([^@+\/'"*`(;{}-]*);/.exec(c[u])) return o += e[0].length - 1, new i.Anonymous(e[1]); },
-        import() { let e; let n; const r = o; m(); const s = w(/^@import?\s+/); const u = (s ? w(this.importOptions) : null) || {}; if (s && (e = w(this.entities.quoted) || w(this.entities.url))) { n = w(this.mediaFeatures); if (w(';')) return n = n && new i.Value(n), new i.Import(e, n, u, r, t.currentFileInfo); }g(); },
-        importOptions() { let e; const t = {}; let n; let r; if (!w('(')) return null; do if (e = w(this.importOption)) { n = e, r = !0; switch (n) { case 'css': n = 'less', r = !1; break; case 'once': n = 'multiple', r = !1; }t[n] = r; if (!w(',')) break; } while (e); return S(')'), t; },
-        importOption() { const e = w(/^(less|css|multiple|once)/); if (e) return e[1]; },
-        mediaFeature() { let e; let n; const r = []; do if (e = w(this.entities.keyword))r.push(e); else if (w('(')) { n = w(this.property), e = w(this.value); if (!w(')')) return null; if (n && e)r.push(new i.Paren(new i.Rule(n, e, null, o, t.currentFileInfo, !0))); else { if (!e) return null; r.push(new i.Paren(e)); } } while (e); if (r.length > 0) return new i.Expression(r); },
-        mediaFeatures() { let e; const t = []; do if (e = w(this.mediaFeature)) { t.push(e); if (!w(',')) break; } else if (e = w(this.entities.variable)) { t.push(e); if (!w(',')) break; } while (e); return t.length > 0 ? t : null; },
-        media() { let e; let n; let r; let u; t.dumpLineNumbers && (u = k(o, s, t)); if (w(/^@media/)) { e = w(this.mediaFeatures); if (n = w(this.block)) return r = new i.Media(n, e), t.dumpLineNumbers && (r.debugInfo = u), r; } },
-        directive() { let e; let n; let r; let u; let a; let f; let l; let c; let h; let p; if (s.charAt(o) !== '@') return; if (n = w(this.import) || w(this.media)) return n; m(), e = w(/^@[a-z-]+/); if (!e) return; l = e, e.charAt(1) == '-' && e.indexOf('-', 2) > 0 && (l = `@${e.slice(e.indexOf('-', 2) + 1)}`); switch (l) { case '@font-face': c = !0; break; case '@viewport': case '@top-left': case '@top-left-corner': case '@top-center': case '@top-right': case '@top-right-corner': case '@bottom-left': case '@bottom-left-corner': case '@bottom-center': case '@bottom-right': case '@bottom-right-corner': case '@left-top': case '@left-middle': case '@left-bottom': case '@right-top': case '@right-middle': case '@right-bottom': c = !0; break; case '@page': case '@document': case '@supports': case '@keyframes': c = !0, h = !0; break; case '@namespace': p = !0; }h && (e += ` ${(w(/^[^{]+/) || '').trim()}`); if (c) { if (r = w(this.block)) return new i.Directive(e, r); } else if ((n = p ? w(this.expression) : w(this.entity)) && w(';')) { const d = new i.Directive(e, n); return t.dumpLineNumbers && (d.debugInfo = k(o, s, t)), d; }g(); },
-        value() { let e; const t = []; let n; while (e = w(this.expression)) { t.push(e); if (!w(',')) break; } if (t.length > 0) return new i.Value(t); },
-        important() { if (s.charAt(o) === '!') return w(/^! *important/); },
-        sub() { let e; let t; if (w('(')) if (e = w(this.addition)) return t = new i.Expression([e]), S(')'), t.parens = !0, t; },
-        multiplication() { let e; let t; let n; let r; let u; const a = []; if (e = w(this.operand)) { u = b(s.charAt(o - 1)); while (!T(/^\/[*\/]/) && (n = w('/') || w('*'))) { if (!(t = w(this.operand))) break; e.parensInOp = !0, t.parensInOp = !0, r = new i.Operation(n, [r || e, t], u), u = b(s.charAt(o - 1)); } return r || e; } },
-        addition() { let e; let t; let n; let r; let u; if (e = w(this.multiplication)) { u = b(s.charAt(o - 1)); while ((n = w(/^[-+]\s+/) || !u && (w('+') || w('-'))) && (t = w(this.multiplication)))e.parensInOp = !0, t.parensInOp = !0, r = new i.Operation(n, [r || e, t], u), u = b(s.charAt(o - 1)); return r || e; } },
-        conditions() { let e; let t; const n = o; let r; if (e = w(this.condition)) { while (w(',') && (t = w(this.condition)))r = new i.Condition('or', r || e, t, n); return r || e; } },
-        condition() { let e; let t; let n; let r; const s = o; let u = !1; w(/^not/) && (u = !0), S('('); if (e = w(this.addition) || w(this.entities.keyword) || w(this.entities.quoted)) return (r = w(/^(?:>=|=<|[<=>])/)) ? (t = w(this.addition) || w(this.entities.keyword) || w(this.entities.quoted)) ? n = new i.Condition(r, e, t, s, u) : x('expected expression') : n = new i.Condition('=', e, new i.Keyword('true'), s, u), S(')'), w(/^and/) ? new i.Condition('and', n, w(this.condition)) : n; },
-        operand() { let e; const t = s.charAt(o + 1); s.charAt(o) === '-' && (t === '@' || t === '(') && (e = w('-')); let n = w(this.sub) || w(this.entities.dimension) || w(this.entities.color) || w(this.entities.variable) || w(this.entities.call); return e && (n.parensInOp = !0, n = new i.Negative(n)), n; },
-        expression() { let e; let t; const n = []; let r; while (e = w(this.addition) || w(this.entity))n.push(e), !T(/^\/[\/*]/) && (t = w('/')) && n.push(new i.Anonymous(t)); if (n.length > 0) return new i.Expression(n); },
-        property() { let e; if (e = w(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/)) return e[1]; },
-      },
-    };
-  }; if (r.mode === 'browser' || r.mode === 'rhino')r.Parser.importer = function (e, t, n, r) { !/^([a-z-]+:)?\//.test(e) && t.currentDirectory && (e = t.currentDirectory + e); const i = r.toSheet(e); i.processImports = !1, i.currentFileInfo = t, w(i, (e, t, r, i, s, o) => { n.call(null, e, t, o); }, !0); }; (function (r) {
-    function u(e) { return r.functions.hsla(e.h, e.s, e.l, e.a); } function a(e, t) { return e instanceof r.Dimension && e.unit.is('%') ? parseFloat(e.value * t / 100) : f(e); } function f(e) { if (e instanceof r.Dimension) return parseFloat(e.unit.is('%') ? e.value / 100 : e.value); if (typeof e === 'number') return e; throw { error: 'RuntimeError', message: 'color functions take numbers as parameters' }; } function l(e) { return Math.min(1, Math.max(0, e)); }r.functions = {
-      rgb(e, t, n) { return this.rgba(e, t, n, 1); },
-      rgba(e, t, n, i) { const s = [e, t, n].map((e) => a(e, 256)); return i = f(i), new r.Color(s, i); },
-      hsl(e, t, n) { return this.hsla(e, t, n, 1); },
-      hsla(e, t, n, r) { function o(e) { return e = e < 0 ? e + 1 : e > 1 ? e - 1 : e, e * 6 < 1 ? s + (i - s) * e * 6 : e * 2 < 1 ? i : e * 3 < 2 ? s + (i - s) * (2 / 3 - e) * 6 : s; }e = f(e) % 360 / 360, t = l(f(t)), n = l(f(n)), r = l(f(r)); var i = n <= 0.5 ? n * (t + 1) : n + t - n * t; var s = n * 2 - i; return this.rgba(o(e + 1 / 3) * 255, o(e) * 255, o(e - 1 / 3) * 255, r); },
-      hsv(e, t, n) { return this.hsva(e, t, n, 1); },
-      hsva(e, t, n, r) { e = f(e) % 360 / 360 * 360, t = f(t), n = f(n), r = f(r); let i; let s; i = Math.floor(e / 60 % 6), s = e / 60 - i; const o = [n, n * (1 - t), n * (1 - s * t), n * (1 - (1 - s) * t)]; const u = [[0, 3, 1], [2, 0, 1], [1, 0, 3], [1, 2, 0], [3, 1, 0], [0, 1, 2]]; return this.rgba(o[u[i][0]] * 255, o[u[i][1]] * 255, o[u[i][2]] * 255, r); },
-      hue(e) { return new r.Dimension(Math.round(e.toHSL().h)); },
-      saturation(e) { return new r.Dimension(Math.round(e.toHSL().s * 100), '%'); },
-      lightness(e) { return new r.Dimension(Math.round(e.toHSL().l * 100), '%'); },
-      hsvhue(e) { return new r.Dimension(Math.round(e.toHSV().h)); },
-      hsvsaturation(e) { return new r.Dimension(Math.round(e.toHSV().s * 100), '%'); },
-      hsvvalue(e) { return new r.Dimension(Math.round(e.toHSV().v * 100), '%'); },
-      red(e) { return new r.Dimension(e.rgb[0]); },
-      green(e) { return new r.Dimension(e.rgb[1]); },
-      blue(e) { return new r.Dimension(e.rgb[2]); },
-      alpha(e) { return new r.Dimension(e.toHSL().a); },
-      luma(e) { return new r.Dimension(Math.round(e.luma() * e.alpha * 100), '%'); },
-      saturate(e, t) { const n = e.toHSL(); return n.s += t.value / 100, n.s = l(n.s), u(n); },
-      desaturate(e, t) { const n = e.toHSL(); return n.s -= t.value / 100, n.s = l(n.s), u(n); },
-      lighten(e, t) { const n = e.toHSL(); return n.l += t.value / 100, n.l = l(n.l), u(n); },
-      darken(e, t) { const n = e.toHSL(); return n.l -= t.value / 100, n.l = l(n.l), u(n); },
-      fadein(e, t) { const n = e.toHSL(); return n.a += t.value / 100, n.a = l(n.a), u(n); },
-      fadeout(e, t) { const n = e.toHSL(); return n.a -= t.value / 100, n.a = l(n.a), u(n); },
-      fade(e, t) { const n = e.toHSL(); return n.a = t.value / 100, n.a = l(n.a), u(n); },
-      spin(e, t) { const n = e.toHSL(); const r = (n.h + t.value) % 360; return n.h = r < 0 ? 360 + r : r, u(n); },
-      mix(e, t, n) { n || (n = new r.Dimension(50)); const i = n.value / 100; const s = i * 2 - 1; const o = e.toHSL().a - t.toHSL().a; const u = ((s * o == -1 ? s : (s + o) / (1 + s * o)) + 1) / 2; const a = 1 - u; const f = [e.rgb[0] * u + t.rgb[0] * a, e.rgb[1] * u + t.rgb[1] * a, e.rgb[2] * u + t.rgb[2] * a]; const l = e.alpha * i + t.alpha * (1 - i); return new r.Color(f, l); },
-      greyscale(e) { return this.desaturate(e, new r.Dimension(100)); },
-      contrast(e, t, n, r) { if (!e.rgb) return null; typeof n === 'undefined' && (n = this.rgba(255, 255, 255, 1)), typeof t === 'undefined' && (t = this.rgba(0, 0, 0, 1)); if (t.luma() > n.luma()) { const i = n; n = t, t = i; } return typeof r === 'undefined' ? r = 0.43 : r = f(r), e.luma() * e.alpha < r ? n : t; },
-      e(e) { return new r.Anonymous(e instanceof r.JavaScript ? e.evaluated : e); },
-      escape(e) {
-        return new r.Anonymous(encodeURI(e.value).replace(/=/g, '%3D').replace(/:/g, '%3A').replace(/#/g, '%23')
-          .replace(/;/g, '%3B')
-          .replace(/\(/g, '%28')
-          .replace(/\)/g, '%29'));
-      },
-      '%': function (e) { const t = Array.prototype.slice.call(arguments, 1); let n = e.value; for (var i = 0; i < t.length; i++)n = n.replace(/%[sda]/i, (e) => { const n = e.match(/s/i) ? t[i].value : t[i].toCSS(); return e.match(/[A-Z]$/) ? encodeURIComponent(n) : n; }); return n = n.replace(/%%/g, '%'), new r.Quoted(`"${n}"`, n); },
-      unit(e, t) { return new r.Dimension(e.value, t ? t.toCSS() : ''); },
-      convert(e, t) { return e.convertTo(t.value); },
-      round(e, t) { const n = typeof t === 'undefined' ? 0 : t.value; return this._math((e) => e.toFixed(n), null, e); },
-      pi() { return new r.Dimension(Math.PI); },
-      mod(e, t) { return new r.Dimension(e.value % t.value, e.unit); },
-      pow(e, t) { if (typeof e === 'number' && typeof t === 'number')e = new r.Dimension(e), t = new r.Dimension(t); else if (!(e instanceof r.Dimension) || !(t instanceof r.Dimension)) throw { type: 'Argument', message: 'arguments must be numbers' }; return new r.Dimension(Math.pow(e.value, t.value), e.unit); },
-      _math(e, t, n) { if (n instanceof r.Dimension) return new r.Dimension(e(parseFloat(n.value)), t == null ? n.unit : t); if (typeof n === 'number') return e(n); throw { type: 'Argument', message: 'argument must be a number' }; },
-      argb(e) { return new r.Anonymous(e.toARGB()); },
-      percentage(e) { return new r.Dimension(e.value * 100, '%'); },
-      color(e) { if (e instanceof r.Quoted) return new r.Color(e.value.slice(1)); throw { type: 'Argument', message: 'argument must be a string' }; },
-      iscolor(e) { return this._isa(e, r.Color); },
-      isnumber(e) { return this._isa(e, r.Dimension); },
-      isstring(e) { return this._isa(e, r.Quoted); },
-      iskeyword(e) { return this._isa(e, r.Keyword); },
-      isurl(e) { return this._isa(e, r.URL); },
-      ispixel(e) { return this.isunit(e, 'px'); },
-      ispercentage(e) { return this.isunit(e, '%'); },
-      isem(e) { return this.isunit(e, 'em'); },
-      isunit(e, t) { return e instanceof r.Dimension && e.unit.is(t.value || t) ? r.True : r.False; },
-      _isa(e, t) { return e instanceof t ? r.True : r.False; },
-      multiply(e, t) { const n = e.rgb[0] * t.rgb[0] / 255; const r = e.rgb[1] * t.rgb[1] / 255; const i = e.rgb[2] * t.rgb[2] / 255; return this.rgb(n, r, i); },
-      screen(e, t) { const n = 255 - (255 - e.rgb[0]) * (255 - t.rgb[0]) / 255; const r = 255 - (255 - e.rgb[1]) * (255 - t.rgb[1]) / 255; const i = 255 - (255 - e.rgb[2]) * (255 - t.rgb[2]) / 255; return this.rgb(n, r, i); },
-      overlay(e, t) { const n = e.rgb[0] < 128 ? 2 * e.rgb[0] * t.rgb[0] / 255 : 255 - 2 * (255 - e.rgb[0]) * (255 - t.rgb[0]) / 255; const r = e.rgb[1] < 128 ? 2 * e.rgb[1] * t.rgb[1] / 255 : 255 - 2 * (255 - e.rgb[1]) * (255 - t.rgb[1]) / 255; const i = e.rgb[2] < 128 ? 2 * e.rgb[2] * t.rgb[2] / 255 : 255 - 2 * (255 - e.rgb[2]) * (255 - t.rgb[2]) / 255; return this.rgb(n, r, i); },
-      softlight(e, t) { let n = t.rgb[0] * e.rgb[0] / 255; const r = n + e.rgb[0] * (255 - (255 - e.rgb[0]) * (255 - t.rgb[0]) / 255 - n) / 255; n = t.rgb[1] * e.rgb[1] / 255; const i = n + e.rgb[1] * (255 - (255 - e.rgb[1]) * (255 - t.rgb[1]) / 255 - n) / 255; n = t.rgb[2] * e.rgb[2] / 255; const s = n + e.rgb[2] * (255 - (255 - e.rgb[2]) * (255 - t.rgb[2]) / 255 - n) / 255; return this.rgb(r, i, s); },
-      hardlight(e, t) { const n = t.rgb[0] < 128 ? 2 * t.rgb[0] * e.rgb[0] / 255 : 255 - 2 * (255 - t.rgb[0]) * (255 - e.rgb[0]) / 255; const r = t.rgb[1] < 128 ? 2 * t.rgb[1] * e.rgb[1] / 255 : 255 - 2 * (255 - t.rgb[1]) * (255 - e.rgb[1]) / 255; const i = t.rgb[2] < 128 ? 2 * t.rgb[2] * e.rgb[2] / 255 : 255 - 2 * (255 - t.rgb[2]) * (255 - e.rgb[2]) / 255; return this.rgb(n, r, i); },
-      difference(e, t) { const n = Math.abs(e.rgb[0] - t.rgb[0]); const r = Math.abs(e.rgb[1] - t.rgb[1]); const i = Math.abs(e.rgb[2] - t.rgb[2]); return this.rgb(n, r, i); },
-      exclusion(e, t) { const n = e.rgb[0] + t.rgb[0] * (255 - e.rgb[0] - e.rgb[0]) / 255; const r = e.rgb[1] + t.rgb[1] * (255 - e.rgb[1] - e.rgb[1]) / 255; const i = e.rgb[2] + t.rgb[2] * (255 - e.rgb[2] - e.rgb[2]) / 255; return this.rgb(n, r, i); },
-      average(e, t) { const n = (e.rgb[0] + t.rgb[0]) / 2; const r = (e.rgb[1] + t.rgb[1]) / 2; const i = (e.rgb[2] + t.rgb[2]) / 2; return this.rgb(n, r, i); },
-      negation(e, t) { const n = 255 - Math.abs(255 - t.rgb[0] - e.rgb[0]); const r = 255 - Math.abs(255 - t.rgb[1] - e.rgb[1]); const i = 255 - Math.abs(255 - t.rgb[2] - e.rgb[2]); return this.rgb(n, r, i); },
-      tint(e, t) { return this.mix(this.rgb(255, 255, 255), e, t); },
-      shade(e, t) { return this.mix(this.rgb(0, 0, 0), e, t); },
-      extract(e, t) { return t = t.value - 1, e.value[t]; },
-      'data-uri': function (t, i) { if (typeof e !== 'undefined') return (new r.URL(i || t, this.currentFileInfo)).eval(this.env); let s = t.value; let o = i && i.value; const u = n('fs'); const a = n('path'); let f = !1; arguments.length < 2 && (o = s), this.env.isPathRelative(o) && (this.currentFileInfo.relativeUrls ? o = a.join(this.currentFileInfo.currentDirectory, o) : o = a.join(this.currentFileInfo.entryPath, o)); if (arguments.length < 2) { let l; try { l = n('mime'); } catch (c) { l = r._mime; }s = l.lookup(o); const h = l.charsets.lookup(s); f = ['US-ASCII', 'UTF-8'].indexOf(h) < 0, f && (s += ';base64'); } else f = /;base64$/.test(s); let p = u.readFileSync(o); const d = 32; const v = parseInt(p.length / 1024, 10); if (v >= d) { if (this.env.ieCompat !== !1) return this.env.silent || console.warn('Skipped data-uri embedding of %s because its size (%dKB) exceeds IE8-safe %dKB!', o, v, d), (new r.URL(i || t, this.currentFileInfo)).eval(this.env); this.env.silent || console.warn("WARNING: Embedding %s (%dKB) exceeds IE8's data-uri size limit of %dKB!", o, v, d); }p = f ? p.toString('base64') : encodeURIComponent(p); const m = `'data:${s},${p}'`; return new r.URL(new r.Anonymous(m)); },
-    }, r._mime = {
-      _types: {
-        '.htm': 'text/html', '.html': 'text/html', '.gif': 'image/gif', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
-      },
-      lookup(e) { const i = n('path').extname(e); const s = r._mime._types[i]; if (s === t) throw new Error(`Optional dependency "mime" is required for ${i}`); return s; },
-      charsets: { lookup(e) { return e && /^text\//.test(e) ? 'UTF-8' : ''; } },
-    }; const i = [{ name: 'ceil' }, { name: 'floor' }, { name: 'sqrt' }, { name: 'abs' }, { name: 'tan', unit: '' }, { name: 'sin', unit: '' }, { name: 'cos', unit: '' }, { name: 'atan', unit: 'rad' }, { name: 'asin', unit: 'rad' }, { name: 'acos', unit: 'rad' }]; const s = function (e, t) { return function (n) { return t != null && (n = n.unify()), this._math(Math[e], t, n); }; }; for (let o = 0; o < i.length; o++)r.functions[i[o].name] = s(i[o].name, i[o].unit); r.functionCall = function (e, t) { this.env = e, this.currentFileInfo = t; }, r.functionCall.prototype = r.functions;
-  }(n('./tree'))), (function (e) {
-    e.colors = {
-      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', darkgrey: '#a9a9a9', darkgreen: '#006400', 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', grey: '#808080', green: '#008000', greenyellow: '#adff2f', 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', lightgrey: '#d3d3d3', lightgreen: '#90ee90', 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: '#9370d8', 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: '#d87093', papayawhip: '#ffefd5', peachpuff: '#ffdab9', peru: '#cd853f', pink: '#ffc0cb', plum: '#dda0dd', powderblue: '#b0e0e6', purple: '#800080', 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',
-    };
-  }(n('./tree'))), (function (e) {
-    e.Alpha = function (e) { this.value = e; }, e.Alpha.prototype = {
-      type: 'Alpha', accept(e) { this.value = e.visit(this.value); }, eval(e) { return this.value.eval && (this.value = this.value.eval(e)), this; }, toCSS() { return `alpha(opacity=${this.value.toCSS ? this.value.toCSS() : this.value})`; },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Anonymous = function (e) { this.value = e.value || e; }, e.Anonymous.prototype = {
-      type: 'Anonymous', toCSS() { return this.value; }, eval() { return this; }, compare(e) { if (!e.toCSS) return -1; const t = this.toCSS(); const n = e.toCSS(); return t === n ? 0 : t < n ? -1 : 1; },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Assignment = function (e, t) { this.key = e, this.value = t; }, e.Assignment.prototype = {
-      type: 'Assignment', accept(e) { this.value = e.visit(this.value); }, toCSS() { return `${this.key}=${this.value.toCSS ? this.value.toCSS() : this.value}`; }, eval(t) { return this.value.eval ? new e.Assignment(this.key, this.value.eval(t)) : this; },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Call = function (e, t, n, r) { this.name = e, this.args = t, this.index = n, this.currentFileInfo = r; }, e.Call.prototype = {
-      type: 'Call',
-      accept(e) { this.args = e.visit(this.args); },
-      eval(t) {
-        const n = this.args.map((e) => e.eval(t)); const r = this.name.toLowerCase(); let i; let s; if (r in e.functions) {
-          try { s = new e.functionCall(t, this.currentFileInfo), i = s[r].apply(s, n); if (i != null) return i; } catch (o) {
-            throw {
-              type: o.type || 'Runtime', message: `error evaluating function \`${this.name}\`${o.message ? `: ${o.message}` : ''}`, index: this.index, filename: this.currentFileInfo.filename,
-            };
-          }
-        } return new e.Anonymous(`${this.name}(${n.map((e) => e.toCSS(t)).join(', ')})`);
-      },
-      toCSS(e) { return this.eval(e).toCSS(); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Color = function (e, t) { Array.isArray(e) ? this.rgb = e : e.length == 6 ? this.rgb = e.match(/.{2}/g).map((e) => parseInt(e, 16)) : this.rgb = e.split('').map((e) => parseInt(e + e, 16)), this.alpha = typeof t === 'number' ? t : 1; }, e.Color.prototype = {
-      type: 'Color',
-      eval() { return this; },
-      luma() { return 0.2126 * this.rgb[0] / 255 + 0.7152 * this.rgb[1] / 255 + 0.0722 * this.rgb[2] / 255; },
-      toCSS(e, t) { const n = e && e.compress && !t; if (this.alpha < 1) return `rgba(${this.rgb.map((e) => Math.round(e)).concat(this.alpha).join(`,${n ? '' : ' '}`)})`; let r = this.rgb.map((e) => (e = Math.round(e), e = (e > 255 ? 255 : e < 0 ? 0 : e).toString(16), e.length === 1 ? `0${e}` : e)).join(''); return n && (r = r.split(''), r[0] == r[1] && r[2] == r[3] && r[4] == r[5] ? r = r[0] + r[2] + r[4] : r = r.join('')), `#${r}`; },
-      operate(t, n, r) { const i = []; r instanceof e.Color || (r = r.toColor()); for (let s = 0; s < 3; s++)i[s] = e.operate(t, n, this.rgb[s], r.rgb[s]); return new e.Color(i, this.alpha + r.alpha); },
-      toHSL() {
-        const e = this.rgb[0] / 255; const t = this.rgb[1] / 255; const n = this.rgb[2] / 255; const r = this.alpha; const i = Math.max(e, t, n); const s = Math.min(e, t, n); let o; let u; const a = (i + s) / 2; const f = i - s; if (i === s)o = u = 0; else { u = a > 0.5 ? f / (2 - i - s) : f / (i + s); switch (i) { case e: o = (t - n) / f + (t < n ? 6 : 0); break; case t: o = (n - e) / f + 2; break; case n: o = (e - t) / f + 4; }o /= 6; } return {
-          h: o * 360, s: u, l: a, a: r,
-        };
-      },
-      toHSV() {
-        const e = this.rgb[0] / 255; const t = this.rgb[1] / 255; const n = this.rgb[2] / 255; const r = this.alpha; const i = Math.max(e, t, n); const s = Math.min(e, t, n); let o; let u; const a = i; const f = i - s; i === 0 ? u = 0 : u = f / i; if (i === s)o = 0; else { switch (i) { case e: o = (t - n) / f + (t < n ? 6 : 0); break; case t: o = (n - e) / f + 2; break; case n: o = (e - t) / f + 4; }o /= 6; } return {
-          h: o * 360, s: u, v: a, a: r,
-        };
-      },
-      toARGB() { const e = [Math.round(this.alpha * 255)].concat(this.rgb); return `#${e.map((e) => (e = Math.round(e), e = (e > 255 ? 255 : e < 0 ? 0 : e).toString(16), e.length === 1 ? `0${e}` : e)).join('')}`; },
-      compare(e) { return e.rgb ? e.rgb[0] === this.rgb[0] && e.rgb[1] === this.rgb[1] && e.rgb[2] === this.rgb[2] && e.alpha === this.alpha ? 0 : -1 : -1; },
-    };
-  }(n('../tree'))), (function (e) { e.Comment = function (e, t) { this.value = e, this.silent = !!t; }, e.Comment.prototype = { type: 'Comment', toCSS(e) { return e.compress ? '' : this.value; }, eval() { return this; } }; }(n('../tree'))), (function (e) { e.Condition = function (e, t, n, r, i) { this.op = e.trim(), this.lvalue = t, this.rvalue = n, this.index = r, this.negate = i; }, e.Condition.prototype = { type: 'Condition', accept(e) { this.lvalue = e.visit(this.lvalue), this.rvalue = e.visit(this.rvalue); }, eval(e) { const t = this.lvalue.eval(e); const n = this.rvalue.eval(e); const r = this.index; var i; var i = (function (e) { switch (e) { case 'and': return t && n; case 'or': return t || n; default: if (t.compare)i = t.compare(n); else { if (!n.compare) throw { type: 'Type', message: 'Unable to perform comparison', index: r }; i = n.compare(t); } switch (i) { case -1: return e === '<' || e === '=<'; case 0: return e === '=' || e === '>=' || e === '=<'; case 1: return e === '>' || e === '>='; } } }(this.op)); return this.negate ? !i : i; } }; }(n('../tree'))), (function (e) {
-    e.Dimension = function (n, r) { this.value = parseFloat(n), this.unit = r && r instanceof e.Unit ? r : new e.Unit(r ? [r] : t); }, e.Dimension.prototype = {
-      type: 'Dimension', accept(e) { this.unit = e.visit(this.unit); }, eval(e) { return this; }, toColor() { return new e.Color([this.value, this.value, this.value]); }, toCSS(e) { if (e && e.strictUnits && !this.unit.isSingular()) throw new Error(`Multiple units in dimension. Correct the units or use the unit function. Bad unit: ${this.unit.toString()}`); const t = this.value; let n = String(t); t !== 0 && t < 1e-6 && t > -0.000001 && (n = t.toFixed(20).replace(/0+$/, '')); if (e && e.compress) { if (t === 0 && !this.unit.isAngle()) return n; t > 0 && t < 1 && (n = n.substr(1)); } return n + this.unit.toCSS(e); }, operate(t, n, r) { let i = e.operate(t, n, this.value, r.value); const s = this.unit.clone(); if (n === '+' || n === '-') { if (s.numerator.length === 0 && s.denominator.length === 0)s.numerator = r.unit.numerator.slice(0), s.denominator = r.unit.denominator.slice(0); else if (r.unit.numerator.length != 0 || s.denominator.length != 0) { r = r.convertTo(this.unit.usedUnits()); if (t.strictUnits && r.unit.toString() !== s.toString()) throw new Error(`Incompatible units. Change the units or use the unit function. Bad units: '${s.toString()}' and '${r.unit.toString()}'.`); i = e.operate(t, n, this.value, r.value); } } else n === '*' ? (s.numerator = s.numerator.concat(r.unit.numerator).sort(), s.denominator = s.denominator.concat(r.unit.denominator).sort(), s.cancel()) : n === '/' && (s.numerator = s.numerator.concat(r.unit.denominator).sort(), s.denominator = s.denominator.concat(r.unit.numerator).sort(), s.cancel()); return new e.Dimension(i, s); }, compare(t) { if (t instanceof e.Dimension) { const n = this.unify(); const r = t.unify(); const i = n.value; const s = r.value; return s > i ? -1 : s < i ? 1 : !r.unit.isEmpty() && n.unit.compare(r.unit) !== 0 ? -1 : 0; } return -1; }, unify() { return this.convertTo({ length: 'm', duration: 's', angle: 'rad' }); }, convertTo(t) { let n = this.value; const r = this.unit.clone(); let i; let s; let o; let u; let a; let f = {}; if (typeof t === 'string') { for (i in e.UnitConversions)e.UnitConversions[i].hasOwnProperty(t) && (f = {}, f[i] = t); t = f; } for (s in t)t.hasOwnProperty(s) && (a = t[s], o = e.UnitConversions[s], r.map((e, t) => (o.hasOwnProperty(e) ? (t ? n /= o[e] / o[a] : n *= o[e] / o[a], a) : e))); return r.cancel(), new e.Dimension(n, r); },
-    }, e.UnitConversions = {
-      length: {
-        m: 1, cm: 0.01, mm: 0.001, in: 0.0254, pt: 0.0254 / 72, pc: 0.0254 / 72 * 12,
-      },
-      duration: { s: 1, ms: 0.001 },
-      angle: {
-        rad: 1 / (2 * Math.PI), deg: 1 / 360, grad: 0.0025, turn: 1,
-      },
-    }, e.Unit = function (e, t, n) { this.numerator = e ? e.slice(0).sort() : [], this.denominator = t ? t.slice(0).sort() : [], this.backupUnit = n; }, e.Unit.prototype = {
-      type: 'Unit', clone() { return new e.Unit(this.numerator.slice(0), this.denominator.slice(0), this.backupUnit); }, toCSS(e) { return this.numerator.length >= 1 ? this.numerator[0] : this.denominator.length >= 1 ? this.denominator[0] : (!e || !e.strictUnits) && this.backupUnit ? this.backupUnit : ''; }, toString() { let e; let t = this.numerator.join('*'); for (e = 0; e < this.denominator.length; e++)t += `/${this.denominator[e]}`; return t; }, compare(e) { return this.is(e.toString()) ? 0 : -1; }, is(e) { return this.toString() === e; }, isAngle() { return e.UnitConversions.angle.hasOwnProperty(this.toCSS()); }, isEmpty() { return this.numerator.length == 0 && this.denominator.length == 0; }, isSingular() { return this.numerator.length <= 1 && this.denominator.length == 0; }, map(e) { let t; for (t = 0; t < this.numerator.length; t++) this.numerator[t] = e(this.numerator[t], !1); for (t = 0; t < this.denominator.length; t++) this.denominator[t] = e(this.denominator[t], !0); }, usedUnits() { let t; let n; const r = {}; for (n in e.UnitConversions)e.UnitConversions.hasOwnProperty(n) && (t = e.UnitConversions[n], this.map((e) => (t.hasOwnProperty(e) && !r[n] && (r[n] = e), e))); return r; }, cancel() { const e = {}; let t; let n; let r; for (n = 0; n < this.numerator.length; n++)t = this.numerator[n], r || (r = t), e[t] = (e[t] || 0) + 1; for (n = 0; n < this.denominator.length; n++)t = this.denominator[n], r || (r = t), e[t] = (e[t] || 0) - 1; this.numerator = [], this.denominator = []; for (t in e) if (e.hasOwnProperty(t)) { const i = e[t]; if (i > 0) for (n = 0; n < i; n++) this.numerator.push(t); else if (i < 0) for (n = 0; n < -i; n++) this.denominator.push(t); } this.numerator.length === 0 && this.denominator.length === 0 && r && (this.backupUnit = r), this.numerator.sort(), this.denominator.sort(); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Directive = function (t, n) { this.name = t, Array.isArray(n) ? (this.ruleset = new e.Ruleset([], n), this.ruleset.allowImports = !0) : this.value = n; }, e.Directive.prototype = {
-      type: 'Directive', accept(e) { this.ruleset = e.visit(this.ruleset), this.value = e.visit(this.value); }, toCSS(e) { return this.ruleset ? (this.ruleset.root = !0, this.name + (e.compress ? '{' : ' {\n  ') + this.ruleset.toCSS(e).trim().replace(/\n/g, '\n  ') + (e.compress ? '}' : '\n}\n')) : `${this.name} ${this.value.toCSS()};\n`; }, eval(t) { let n = this; return this.ruleset && (t.frames.unshift(this), n = new e.Directive(this.name), n.ruleset = this.ruleset.eval(t), t.frames.shift()), n; }, variable(t) { return e.Ruleset.prototype.variable.call(this.ruleset, t); }, find() { return e.Ruleset.prototype.find.apply(this.ruleset, arguments); }, rulesets() { return e.Ruleset.prototype.rulesets.apply(this.ruleset); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Element = function (t, n, r) { this.combinator = t instanceof e.Combinator ? t : new e.Combinator(t), typeof n === 'string' ? this.value = n.trim() : n ? this.value = n : this.value = '', this.index = r; }, e.Element.prototype = {
-      type: 'Element', accept(e) { this.combinator = e.visit(this.combinator), this.value = e.visit(this.value); }, eval(t) { return new e.Element(this.combinator, this.value.eval ? this.value.eval(t) : this.value, this.index); }, toCSS(e) { const t = this.value.toCSS ? this.value.toCSS(e) : this.value; return t == '' && this.combinator.value.charAt(0) == '&' ? '' : this.combinator.toCSS(e || {}) + t; },
-    }, e.Attribute = function (e, t, n) { this.key = e, this.op = t, this.value = n; }, e.Attribute.prototype = {
-      type: 'Attribute', accept(e) { this.value = e.visit(this.value); }, eval(t) { return new e.Attribute(this.key.eval ? this.key.eval(t) : this.key, this.op, this.value && this.value.eval ? this.value.eval(t) : this.value); }, toCSS(e) { let t = this.key.toCSS ? this.key.toCSS(e) : this.key; return this.op && (t += this.op, t += this.value.toCSS ? this.value.toCSS(e) : this.value), `[${t}]`; },
-    }, e.Combinator = function (e) { e === ' ' ? this.value = ' ' : this.value = e ? e.trim() : ''; }, e.Combinator.prototype = {
-      type: 'Combinator',
-      toCSS(e) {
-        return {
-          '': '', ' ': ' ', ':': ' :', '+': e.compress ? '+' : ' + ', '~': e.compress ? '~' : ' ~ ', '>': e.compress ? '>' : ' > ', '|': e.compress ? '|' : ' | ',
-        }[this.value];
-      },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Expression = function (e) { this.value = e; }, e.Expression.prototype = {
-      type: 'Expression', accept(e) { this.value = e.visit(this.value); }, eval(t) { let n; const r = this.parens && !this.parensInOp; let i = !1; return r && t.inParenthesis(), this.value.length > 1 ? n = new e.Expression(this.value.map((e) => e.eval(t))) : this.value.length === 1 ? (this.value[0].parens && !this.value[0].parensInOp && (i = !0), n = this.value[0].eval(t)) : n = this, r && t.outOfParenthesis(), this.parens && this.parensInOp && !t.isMathOn() && !i && (n = new e.Paren(n)), n; }, toCSS(e) { return this.value.map((t) => (t.toCSS ? t.toCSS(e) : '')).join(' '); }, throwAwayComments() { this.value = this.value.filter((t) => !(t instanceof e.Comment)); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Extend = function (t, n, r) { this.selector = t, this.option = n, this.index = r; switch (n) { case 'all': this.allowBefore = !0, this.allowAfter = !0; break; default: this.allowBefore = !1, this.allowAfter = !1; } }, e.Extend.prototype = {
-      type: 'Extend', accept(e) { this.selector = e.visit(this.selector); }, eval(t) { return new e.Extend(this.selector.eval(t), this.option, this.index); }, clone(t) { return new e.Extend(this.selector, this.option, this.index); }, findSelfSelectors(e) { let t = []; let n; for (n = 0; n < e.length; n++)t = t.concat(e[n].elements); this.selfSelectors = [{ elements: t }]; },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Import = function (e, n, r, i, s) { const o = this; this.options = r, this.index = i, this.path = e, this.features = n, this.currentFileInfo = s; if (this.options.less !== t) this.css = !this.options.less; else { const u = this.getPath(); u && /css([\?;].*)?$/.test(u) && (this.css = !0); } }, e.Import.prototype = {
-      type: 'Import', accept(e) { this.features = e.visit(this.features), this.path = e.visit(this.path), this.root = e.visit(this.root); }, toCSS(e) { const t = this.features ? ` ${this.features.toCSS(e)}` : ''; return this.css ? `@import ${this.path.toCSS()}${t};\n` : ''; }, getPath() { if (this.path instanceof e.Quoted) { const n = this.path.value; return this.css !== t || /(\.[a-z]*$)|([\?;].*)$/.test(n) ? n : `${n}.less`; } return this.path instanceof e.URL ? this.path.value.value : null; }, evalForImport(t) { return new e.Import(this.path.eval(t), this.features, this.options, this.index, this.currentFileInfo); }, evalPath(t) { const n = this.path.eval(t); const r = this.currentFileInfo && this.currentFileInfo.rootpath; if (r && !(n instanceof e.URL)) { const i = n.value; i && t.isPathRelative(i) && (n.value = r + i); } return n; }, eval(t) { let n; const r = this.features && this.features.eval(t); if (this.skip) return []; if (this.css) { const i = new e.Import(this.evalPath(t), r, this.options, this.index); if (!i.css && this.error) throw this.error; return i; } return n = new e.Ruleset([], this.root.rules.slice(0)), n.evalImports(t), this.features ? new e.Media(n.rules, this.features.value) : n.rules; },
-    };
-  }(n('../tree'))), (function (e) { e.JavaScript = function (e, t, n) { this.escaped = n, this.expression = e, this.index = t; }, e.JavaScript.prototype = { type: 'JavaScript', eval(t) { let n; const r = this; const i = {}; let s = this.expression.replace(/@\{([\w-]+)\}/g, (n, i) => e.jsify((new e.Variable(`@${i}`, r.index)).eval(t))); try { s = new Function(`return (${s})`); } catch (o) { throw { message: `JavaScript evaluation error: \`${s}\``, index: this.index }; } for (const u in t.frames[0].variables())i[u.slice(1)] = { value: t.frames[0].variables()[u].value, toJS() { return this.value.eval(t).toCSS(); } }; try { n = s.call(i); } catch (o) { throw { message: `JavaScript evaluation error: '${o.name}: ${o.message}'`, index: this.index }; } return typeof n === 'string' ? new e.Quoted(`"${n}"`, n, this.escaped, this.index) : Array.isArray(n) ? new e.Anonymous(n.join(', ')) : new e.Anonymous(n); } }; }(n('../tree'))), (function (e) {
-    e.Keyword = function (e) { this.value = e; }, e.Keyword.prototype = {
-      type: 'Keyword', eval() { return this; }, toCSS() { return this.value; }, compare(t) { return t instanceof e.Keyword ? t.value === this.value ? 0 : 1 : -1; },
-    }, e.True = new e.Keyword('true'), e.False = new e.Keyword('false');
-  }(n('../tree'))), (function (e) {
-    e.Media = function (t, n) { const r = this.emptySelectors(); this.features = new e.Value(n), this.ruleset = new e.Ruleset(r, t), this.ruleset.allowImports = !0; }, e.Media.prototype = {
-      type: 'Media', accept(e) { this.features = e.visit(this.features), this.ruleset = e.visit(this.ruleset); }, toCSS(e) { const t = this.features.toCSS(e); return `@media ${t}${e.compress ? '{' : ' {\n  '}${this.ruleset.toCSS(e).trim().replace(/\n/g, '\n  ')}${e.compress ? '}' : '\n}\n'}`; }, eval(t) { t.mediaBlocks || (t.mediaBlocks = [], t.mediaPath = []); const n = new e.Media([], []); this.debugInfo && (this.ruleset.debugInfo = this.debugInfo, n.debugInfo = this.debugInfo); let r = !1; t.strictMath || (r = !0, t.strictMath = !0); try { n.features = this.features.eval(t); } finally { r && (t.strictMath = !1); } return t.mediaPath.push(n), t.mediaBlocks.push(n), t.frames.unshift(this.ruleset), n.ruleset = this.ruleset.eval(t), t.frames.shift(), t.mediaPath.pop(), t.mediaPath.length === 0 ? n.evalTop(t) : n.evalNested(t); }, variable(t) { return e.Ruleset.prototype.variable.call(this.ruleset, t); }, find() { return e.Ruleset.prototype.find.apply(this.ruleset, arguments); }, rulesets() { return e.Ruleset.prototype.rulesets.apply(this.ruleset); }, emptySelectors() { const t = new e.Element('', '&', 0); return [new e.Selector([t])]; }, evalTop(t) { let n = this; if (t.mediaBlocks.length > 1) { const r = this.emptySelectors(); n = new e.Ruleset(r, t.mediaBlocks), n.multiMedia = !0; } return delete t.mediaBlocks, delete t.mediaPath, n; }, evalNested(t) { let n; let r; const i = t.mediaPath.concat([this]); for (n = 0; n < i.length; n++)r = i[n].features instanceof e.Value ? i[n].features.value : i[n].features, i[n] = Array.isArray(r) ? r : [r]; return this.features = new e.Value(this.permute(i).map((t) => { t = t.map((t) => (t.toCSS ? t : new e.Anonymous(t))); for (n = t.length - 1; n > 0; n--)t.splice(n, 0, new e.Anonymous('and')); return new e.Expression(t); })), new e.Ruleset([], []); }, permute(e) { if (e.length === 0) return []; if (e.length === 1) return e[0]; const t = []; const n = this.permute(e.slice(1)); for (let r = 0; r < n.length; r++) for (let i = 0; i < e[0].length; i++)t.push([e[0][i]].concat(n[r])); return t; }, bubbleSelectors(t) { this.ruleset = new e.Ruleset(t.slice(0), [this.ruleset]); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.mixin = {}, e.mixin.Call = function (t, n, r, i, s) { this.selector = new e.Selector(t), this.arguments = n, this.index = r, this.currentFileInfo = i, this.important = s; }, e.mixin.Call.prototype = {
-      type: 'MixinCall',
-      accept(e) { this.selector = e.visit(this.selector), this.arguments = e.visit(this.arguments); },
-      eval(t) {
-        let n; let r; let i; const s = []; let o = !1; let u; let a; let f; let l; let c; i = this.arguments && this.arguments.map((e) => ({ name: e.name, value: e.value.eval(t) })); for (u = 0; u < t.frames.length; u++) {
-          if ((n = t.frames[u].find(this.selector)).length > 0) {
-            c = !0; for (a = 0; a < n.length; a++) {
-              r = n[a], l = !1; for (f = 0; f < t.frames.length; f++) if (!(r instanceof e.mixin.Definition) && r === (t.frames[f].originalRuleset || t.frames[f])) { l = !0; break; } if (l) continue; if (r.matchArgs(i, t)) {
-                if (!r.matchCondition || r.matchCondition(i, t)) {
-                  try { Array.prototype.push.apply(s, r.eval(t, i, this.important).rules); } catch (h) {
-                    throw {
-                      message: h.message, index: this.index, filename: this.currentFileInfo.filename, stack: h.stack,
-                    };
-                  }
-                }o = !0;
-              }
-            } if (o) return s;
-          }
-        } throw c ? {
-          type: 'Runtime', message: `No matching definition was found for \`${this.selector.toCSS().trim()}(${i ? i.map((e) => { let t = ''; return e.name && (t += `${e.name}:`), e.value.toCSS ? t += e.value.toCSS() : t += '???', t; }).join(', ') : ''})\``, index: this.index, filename: this.currentFileInfo.filename,
-        } : {
-          type: 'Name', message: `${this.selector.toCSS().trim()} is undefined`, index: this.index, filename: this.currentFileInfo.filename,
-        };
-      },
-    }, e.mixin.Definition = function (t, n, r, i, s) { this.name = t, this.selectors = [new e.Selector([new e.Element(null, t)])], this.params = n, this.condition = i, this.variadic = s, this.arity = n.length, this.rules = r, this._lookups = {}, this.required = n.reduce((e, t) => (!t.name || t.name && !t.value ? e + 1 : e), 0), this.parent = e.Ruleset.prototype, this.frames = []; }, e.mixin.Definition.prototype = {
-      type: 'MixinDefinition', accept(e) { this.params = e.visit(this.params), this.rules = e.visit(this.rules), this.condition = e.visit(this.condition); }, toCSS() { return ''; }, variable(e) { return this.parent.variable.call(this, e); }, variables() { return this.parent.variables.call(this); }, find() { return this.parent.find.apply(this, arguments); }, rulesets() { return this.parent.rulesets.apply(this); }, evalParams(t, n, r, i) { const s = new e.Ruleset(null, []); let o; let u; const a = this.params.slice(0); let f; let l; let c; let h; let p; let d; n = new e.evalEnv(n, [s].concat(n.frames)); if (r) { r = r.slice(0); for (f = 0; f < r.length; f++) { u = r[f]; if (h = u && u.name) { p = !1; for (l = 0; l < a.length; l++) if (!i[l] && h === a[l].name) { i[l] = u.value.eval(t), s.rules.unshift(new e.Rule(h, u.value.eval(t))), p = !0; break; } if (p) { r.splice(f, 1), f--; continue; } throw { type: 'Runtime', message: `Named argument for ${this.name} ${r[f].name} not found` }; } } }d = 0; for (f = 0; f < a.length; f++) { if (i[f]) continue; u = r && r[d]; if (h = a[f].name) if (a[f].variadic && r) { o = []; for (l = d; l < r.length; l++)o.push(r[l].value.eval(t)); s.rules.unshift(new e.Rule(h, (new e.Expression(o)).eval(t))); } else { c = u && u.value; if (c)c = c.eval(t); else { if (!a[f].value) throw { type: 'Runtime', message: `wrong number of arguments for ${this.name} (${r.length} for ${this.arity})` }; c = a[f].value.eval(n), s.resetCache(); }s.rules.unshift(new e.Rule(h, c)), i[f] = c; } if (a[f].variadic && r) for (l = d; l < r.length; l++)i[l] = r[l].value.eval(t); d++; } return s; }, eval(t, n, r) { const i = []; const s = this.frames.concat(t.frames); const o = this.evalParams(t, new e.evalEnv(t, s), n, i); let u; let a; let f; let l; return o.rules.unshift(new e.Rule('@arguments', (new e.Expression(i)).eval(t))), a = r ? this.parent.makeImportant.apply(this).rules : this.rules.slice(0), l = (new e.Ruleset(null, a)).eval(new e.evalEnv(t, [this, o].concat(s))), l.originalRuleset = this, l; }, matchCondition(t, n) { return this.condition && !this.condition.eval(new e.evalEnv(n, [this.evalParams(n, new e.evalEnv(n, this.frames.concat(n.frames)), t, [])].concat(n.frames))) ? !1 : !0; }, matchArgs(e, t) { const n = e && e.length || 0; let r; let i; if (!this.variadic) { if (n < this.required) return !1; if (n > this.params.length) return !1; if (this.required > 0 && n > this.params.length) return !1; }r = Math.min(n, this.arity); for (let s = 0; s < r; s++) if (!this.params[s].name && !this.params[s].variadic && e[s].value.eval(t).toCSS() != this.params[s].value.eval(t).toCSS()) return !1; return !0; },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Negative = function (e) { this.value = e; }, e.Negative.prototype = {
-      type: 'Negative', accept(e) { this.value = e.visit(this.value); }, toCSS(e) { return `-${this.value.toCSS(e)}`; }, eval(t) { return t.isMathOn() ? (new e.Operation('*', [new e.Dimension(-1), this.value])).eval(t) : new e.Negative(this.value.eval(t)); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Operation = function (e, t, n) { this.op = e.trim(), this.operands = t, this.isSpaced = n; }, e.Operation.prototype = {
-      type: 'Operation', accept(e) { this.operands = e.visit(this.operands); }, eval(t) { let n = this.operands[0].eval(t); let r = this.operands[1].eval(t); let i; if (t.isMathOn()) { if (n instanceof e.Dimension && r instanceof e.Color) { if (this.op !== '*' && this.op !== '+') throw { type: 'Operation', message: "Can't substract or divide a color from a number" }; i = r, r = n, n = i; } if (!n.operate) throw { type: 'Operation', message: 'Operation on an invalid type' }; return n.operate(t, this.op, r); } return new e.Operation(this.op, [n, r], this.isSpaced); }, toCSS(e) { const t = this.isSpaced ? ' ' : ''; return this.operands[0].toCSS() + t + this.op + t + this.operands[1].toCSS(); },
-    }, e.operate = function (e, t, n, r) { switch (t) { case '+': return n + r; case '-': return n - r; case '*': return n * r; case '/': return n / r; } };
-  }(n('../tree'))), (function (e) {
-    e.Paren = function (e) { this.value = e; }, e.Paren.prototype = {
-      type: 'Paren', accept(e) { this.value = e.visit(this.value); }, toCSS(e) { return `(${this.value.toCSS(e).trim()})`; }, eval(t) { return new e.Paren(this.value.eval(t)); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Quoted = function (e, t, n, r, i) { this.escaped = n, this.value = t || '', this.quote = e.charAt(0), this.index = r, this.currentFileInfo = i; }, e.Quoted.prototype = {
-      type: 'Quoted', toCSS() { return this.escaped ? this.value : this.quote + this.value + this.quote; }, eval(t) { const n = this; const r = this.value.replace(/`([^`]+)`/g, (r, i) => (new e.JavaScript(i, n.index, !0)).eval(t).value).replace(/@\{([\w-]+)\}/g, (r, i) => { const s = (new e.Variable(`@${i}`, n.index, n.currentFileInfo)).eval(t, !0); return s instanceof e.Quoted ? s.value : s.toCSS(); }); return new e.Quoted(this.quote + r + this.quote, r, this.escaped, this.index); }, compare(e) { if (!e.toCSS) return -1; const t = this.toCSS(); const n = e.toCSS(); return t === n ? 0 : t < n ? -1 : 1; },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Rule = function (t, n, r, i, s, o) { this.name = t, this.value = n instanceof e.Value ? n : new e.Value([n]), this.important = r ? ` ${r.trim()}` : '', this.index = i, this.currentFileInfo = s, this.inline = o || !1, t.charAt(0) === '@' ? this.variable = !0 : this.variable = !1; }, e.Rule.prototype = {
-      type: 'Rule', accept(e) { this.value = e.visit(this.value); }, toCSS(e) { if (this.variable) return ''; try { return this.name + (e.compress ? ':' : ': ') + this.value.toCSS(e) + this.important + (this.inline ? '' : ';'); } catch (t) { throw t.index = this.index, t.filename = this.currentFileInfo.filename, t; } }, eval(t) { let n = !1; this.name === 'font' && !t.strictMath && (n = !0, t.strictMath = !0); try { return new e.Rule(this.name, this.value.eval(t), this.important, this.index, this.currentFileInfo, this.inline); } finally { n && (t.strictMath = !1); } }, makeImportant() { return new e.Rule(this.name, this.value, '!important', this.index, this.currentFileInfo, this.inline); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Ruleset = function (e, t, n) { this.selectors = e, this.rules = t, this._lookups = {}, this.strictImports = n; }, e.Ruleset.prototype = {
-      type: 'Ruleset', accept(e) { this.selectors = e.visit(this.selectors), this.rules = e.visit(this.rules); }, eval(t) { const n = this.selectors && this.selectors.map((e) => e.eval(t)); const r = new e.Ruleset(n, this.rules.slice(0), this.strictImports); let i; r.originalRuleset = this, r.root = this.root, r.firstRoot = this.firstRoot, r.allowImports = this.allowImports, this.debugInfo && (r.debugInfo = this.debugInfo), t.frames.unshift(r), t.selectors || (t.selectors = []), t.selectors.unshift(this.selectors), (r.root || r.allowImports || !r.strictImports) && r.evalImports(t); for (var s = 0; s < r.rules.length; s++)r.rules[s] instanceof e.mixin.Definition && (r.rules[s].frames = t.frames.slice(0)); const o = t.mediaBlocks && t.mediaBlocks.length || 0; for (var s = 0; s < r.rules.length; s++)r.rules[s] instanceof e.mixin.Call && (i = r.rules[s].eval(t).filter((t) => (t instanceof e.Rule && t.variable ? !r.variable(t.name) : !0)), r.rules.splice.apply(r.rules, [s, 1].concat(i)), s += i.length - 1, r.resetCache()); for (var s = 0, u; s < r.rules.length; s++)u = r.rules[s], u instanceof e.mixin.Definition || (r.rules[s] = u.eval ? u.eval(t) : u); t.frames.shift(), t.selectors.shift(); if (t.mediaBlocks) for (var s = o; s < t.mediaBlocks.length; s++)t.mediaBlocks[s].bubbleSelectors(n); return r; }, evalImports(t) { let n; let r; for (n = 0; n < this.rules.length; n++) this.rules[n] instanceof e.Import && (r = this.rules[n].eval(t), typeof r.length === 'number' ? (this.rules.splice.apply(this.rules, [n, 1].concat(r)), n += r.length - 1) : this.rules.splice(n, 1, r), this.resetCache()); }, makeImportant() { return new e.Ruleset(this.selectors, this.rules.map((e) => (e.makeImportant ? e.makeImportant() : e)), this.strictImports); }, matchArgs(e) { return !e || e.length === 0; }, resetCache() { this._rulesets = null, this._variables = null, this._lookups = {}; }, variables() { return this._variables ? this._variables : this._variables = this.rules.reduce((t, n) => (n instanceof e.Rule && n.variable === !0 && (t[n.name] = n), t), {}); }, variable(e) { return this.variables()[e]; }, rulesets() { return this.rules.filter((t) => t instanceof e.Ruleset || t instanceof e.mixin.Definition); }, find(t, n) { n = n || this; const r = []; let i; let s; const o = t.toCSS(); return o in this._lookups ? this._lookups[o] : (this.rulesets().forEach((i) => { if (i !== n) for (let o = 0; o < i.selectors.length; o++) if (s = t.match(i.selectors[o])) { t.elements.length > i.selectors[o].elements.length ? Array.prototype.push.apply(r, i.find(new e.Selector(t.elements.slice(1)), n)) : r.push(i); break; } }), this._lookups[o] = r); }, toCSS(t) { const n = []; let r = []; const i = []; let s = []; let o; let u; let a; for (var f = 0; f < this.rules.length; f++) { a = this.rules[f]; if (a.rules || a instanceof e.Media)s.push(a.toCSS(t)); else if (a instanceof e.Directive) { const l = a.toCSS(t); if (a.name === '@charset') { if (t.charset) { a.debugInfo && (s.push(e.debugInfo(t, a)), s.push((new e.Comment(`/* ${l.replace(/\n/g, '')} */\n`)).toCSS(t))); continue; }t.charset = !0; }s.push(l); } else if (a instanceof e.Comment)a.silent || (this.root ? s.push(a.toCSS(t)) : r.push(a.toCSS(t))); else if (a.toCSS && !a.variable) { if (this.firstRoot && a instanceof e.Rule) throw { message: 'properties must be inside selector blocks, they cannot be in the root.', index: a.index, filename: a.currentFileInfo ? a.currentFileInfo.filename : null }; r.push(a.toCSS(t)); } else a.value && !a.variable && r.push(a.value.toString()); }t.compress && r.length && (a = r[r.length - 1], a.charAt(a.length - 1) === ';' && (r[r.length - 1] = a.substring(0, a.length - 1))), s = s.join(''); if (this.root)n.push(r.join(t.compress ? '' : '\n')); else if (r.length > 0) { u = e.debugInfo(t, this), o = this.paths.map((e) => e.map((e) => e.toCSS(t)).join('').trim()).join(t.compress ? ',' : ',\n'); for (var f = r.length - 1; f >= 0; f--)(r[f].slice(0, 2) === '/*' || i.indexOf(r[f]) === -1) && i.unshift(r[f]); r = i, n.push(u + o + (t.compress ? '{' : ' {\n  ') + r.join(t.compress ? '' : '\n  ') + (t.compress ? '}' : '\n}\n')); } return n.push(s), n.join('') + (t.compress ? '\n' : ''); }, joinSelectors(e, t, n) { for (let r = 0; r < n.length; r++) this.joinSelector(e, t, n[r]); }, joinSelector(t, n, r) { let i; let s; let o; let u; let a; let f; let l; let c; let h; let p; let d; let v; let m; let g; let y; for (i = 0; i < r.elements.length; i++)f = r.elements[i], f.value === '&' && (u = !0); if (!u) { if (n.length > 0) for (i = 0; i < n.length; i++)t.push(n[i].concat(r)); else t.push([r]); return; }g = [], a = [[]]; for (i = 0; i < r.elements.length; i++) { f = r.elements[i]; if (f.value !== '&')g.push(f); else { y = [], g.length > 0 && this.mergeElementsOnToSelectors(g, a); for (s = 0; s < a.length; s++) { l = a[s]; if (n.length == 0)l.length > 0 && (l[0].elements = l[0].elements.slice(0), l[0].elements.push(new e.Element(f.combinator, '', 0))), y.push(l); else for (o = 0; o < n.length; o++)c = n[o], h = [], p = [], v = !0, l.length > 0 ? (h = l.slice(0), m = h.pop(), d = new e.Selector(m.elements.slice(0), r.extendList), v = !1) : d = new e.Selector([], r.extendList), c.length > 1 && (p = p.concat(c.slice(1))), c.length > 0 && (v = !1, d.elements.push(new e.Element(f.combinator, c[0].elements[0].value, 0)), d.elements = d.elements.concat(c[0].elements.slice(1))), v || h.push(d), h = h.concat(p), y.push(h); }a = y, g = []; } }g.length > 0 && this.mergeElementsOnToSelectors(g, a); for (i = 0; i < a.length; i++)a[i].length > 0 && t.push(a[i]); }, mergeElementsOnToSelectors(t, n) { let r; let i; let s; if (n.length == 0) { n.push([new e.Selector(t)]); return; } for (r = 0; r < n.length; r++)i = n[r], i.length > 0 ? i[i.length - 1] = new e.Selector(i[i.length - 1].elements.concat(t), i[i.length - 1].extendList) : i.push(new e.Selector(t)); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Selector = function (e, t) { this.elements = e, this.extendList = t || []; }, e.Selector.prototype = {
-      type: 'Selector', accept(e) { this.elements = e.visit(this.elements), this.extendList = e.visit(this.extendList); }, match(e) { const t = this.elements; const n = t.length; let r; let i; let s; let o; r = e.elements.slice(e.elements.length && e.elements[0].value === '&' ? 1 : 0), i = r.length, s = Math.min(n, i); if (i === 0 || n < i) return !1; for (o = 0; o < s; o++) if (t[o].value !== r[o].value) return !1; return !0; }, eval(t) { return new e.Selector(this.elements.map((e) => e.eval(t)), this.extendList.map((e) => e.eval(t))); }, toCSS(e) { return this._css ? this._css : (this.elements[0].combinator.value === '' ? this._css = ' ' : this._css = '', this._css += this.elements.map((t) => (typeof t === 'string' ? ` ${t.trim()}` : t.toCSS(e))).join(''), this._css); },
-    };
-  }(n('../tree'))), (function (e) { e.UnicodeDescriptor = function (e) { this.value = e; }, e.UnicodeDescriptor.prototype = { type: 'UnicodeDescriptor', toCSS(e) { return this.value; }, eval() { return this; } }; }(n('../tree'))), (function (e) {
-    e.URL = function (e, t) { this.value = e, this.currentFileInfo = t; }, e.URL.prototype = {
-      type: 'Url', accept(e) { this.value = e.visit(this.value); }, toCSS() { return `url(${this.value.toCSS()})`; }, eval(t) { const n = this.value.eval(t); let r; return r = this.currentFileInfo && this.currentFileInfo.rootpath, r && typeof n.value === 'string' && t.isPathRelative(n.value) && (n.quote || (r = r.replace(/[\(\)'"\s]/g, (e) => `\\${e}`)), n.value = r + n.value), new e.URL(n, null); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Value = function (e) { this.value = e; }, e.Value.prototype = {
-      type: 'Value', accept(e) { this.value = e.visit(this.value); }, eval(t) { return this.value.length === 1 ? this.value[0].eval(t) : new e.Value(this.value.map((e) => e.eval(t))); }, toCSS(e) { return this.value.map((t) => t.toCSS(e)).join(e.compress ? ',' : ', '); },
-    };
-  }(n('../tree'))), (function (e) {
-    e.Variable = function (e, t, n) { this.name = e, this.index = t, this.currentFileInfo = n; }, e.Variable.prototype = {
-      type: 'Variable',
-      eval(t) {
-        let n; let r; let i = this.name; i.indexOf('@@') == 0 && (i = `@${(new e.Variable(i.slice(1))).eval(t).value}`); if (this.evaluating) {
-          throw {
-            type: 'Name', message: `Recursive variable definition for ${i}`, filename: this.currentFileInfo.file, index: this.index,
-          };
-        } this.evaluating = !0; if (n = e.find(t.frames, (e) => { if (r = e.variable(i)) return r.value.eval(t); })) return this.evaluating = !1, n; throw {
-          type: 'Name', message: `variable ${i} is undefined`, filename: this.currentFileInfo.filename, index: this.index,
-        };
-      },
-    };
-  }(n('../tree'))), (function (e) { e.debugInfo = function (t, n) { let r = ''; if (t.dumpLineNumbers && !t.compress) switch (t.dumpLineNumbers) { case 'comments': r = e.debugInfo.asComment(n); break; case 'mediaquery': r = e.debugInfo.asMediaQuery(n); break; case 'all': r = e.debugInfo.asComment(n) + e.debugInfo.asMediaQuery(n); } return r; }, e.debugInfo.asComment = function (e) { return `/* line ${e.debugInfo.lineNumber}, ${e.debugInfo.fileName} */\n`; }, e.debugInfo.asMediaQuery = function (e) { return `@media -sass-debug-info{filename{font-family:${(`file://${e.debugInfo.fileName}`).replace(/([.:/\\])/g, (e) => (e == '\\' && (e = '/'), `\\${e}`))}}line{font-family:\\00003${e.debugInfo.lineNumber}}}\n`; }, e.find = function (e, t) { for (var n = 0, r; n < e.length; n++) if (r = t.call(e, e[n])) return r; return null; }, e.jsify = function (e) { return Array.isArray(e.value) && e.value.length > 1 ? `[${e.value.map((e) => e.toCSS(!1)).join(', ')}]` : e.toCSS(!1); }; }(n('./tree'))), (function (e) {
-    const t = ['paths', 'optimization', 'files', 'contents', 'relativeUrls', 'strictImports', 'dumpLineNumbers', 'compress', 'processImports', 'syncImport', 'mime', 'currentFileInfo']; e.parseEnv = function (e) {
-      r(e, this, t), this.contents || (this.contents = {}), this.files || (this.files = {}); if (!this.currentFileInfo) {
-        const n = e && e.filename || 'input'; const i = n.replace(/[^\/\\]*$/, ''); e && (e.filename = null), this.currentFileInfo = {
-          filename: n, relativeUrls: this.relativeUrls, rootpath: e && e.rootpath || '', currentDirectory: i, entryPath: i, rootFilename: n,
-        };
-      }
-    }, e.parseEnv.prototype.toSheet = function (t) { const n = new e.parseEnv(this); return n.href = t, n.type = this.mime, n; }; const n = ['silent', 'verbose', 'compress', 'yuicompress', 'ieCompat', 'strictMath', 'strictUnits']; e.evalEnv = function (e, t) { r(e, this, n), this.frames = t || []; }, e.evalEnv.prototype.inParenthesis = function () { this.parensStack || (this.parensStack = []), this.parensStack.push(!0); }, e.evalEnv.prototype.outOfParenthesis = function () { this.parensStack.pop(); }, e.evalEnv.prototype.isMathOn = function () { return this.strictMath ? this.parensStack && this.parensStack.length : !0; }, e.evalEnv.prototype.isPathRelative = function (e) { return !/^(?:[a-z-]+:|\/)/.test(e); }; var r = function (e, t, n) { if (!e) return; for (let r = 0; r < n.length; r++)e.hasOwnProperty(n[r]) && (t[n[r]] = e[n[r]]); };
-  }(n('./tree'))), (function (e) { e.visitor = function (e) { this._implementation = e; }, e.visitor.prototype = { visit(e) { if (e instanceof Array) return this.visitArray(e); if (!e || !e.type) return e; let t = `visit${e.type}`; const n = this._implementation[t]; let r; let i; return n && (r = { visitDeeper: !0 }, i = n.call(this._implementation, e, r), this._implementation.isReplacing && (e = i)), (!r || r.visitDeeper) && e && e.accept && e.accept(this), t += 'Out', this._implementation[t] && this._implementation[t](e), e; }, visitArray(e) { let t; let n = []; for (t = 0; t < e.length; t++) { const r = this.visit(e[t]); r instanceof Array ? n = n.concat(r) : n.push(r); } return this._implementation.isReplacing ? n : e; } }; }(n('./tree'))), (function (e) {
-    e.importVisitor = function (t, n, r) { this._visitor = new e.visitor(this), this._importer = t, this._finish = n, this.env = r || new e.evalEnv(), this.importCount = 0; }, e.importVisitor.prototype = {
-      isReplacing: !0, run(e) { let t; try { this._visitor.visit(e); } catch (n) { t = n; } this.isFinished = !0, this.importCount === 0 && this._finish(t); }, visitImport(t, n) { const r = this; let i; if (!t.css) { try { i = t.evalForImport(this.env); } catch (s) { s.filename || (s.index = t.index, s.filename = t.currentFileInfo.filename), t.css = !0, t.error = s; } if (i && !i.css) { t = i, this.importCount++; const o = new e.evalEnv(this.env, this.env.frames.slice(0)); this._importer.push(t.getPath(), t.currentFileInfo, (n, i, s) => { n && !n.filename && (n.index = t.index, n.filename = t.currentFileInfo.filename), s && !t.options.multiple && (t.skip = s); const u = function (e) { r.importCount--, r.importCount === 0 && r.isFinished && r._finish(e); }; i ? (t.root = i, (new e.importVisitor(r._importer, u, o)).run(i)) : u(); }); } } return n.visitDeeper = !1, t; }, visitRule(e, t) { return t.visitDeeper = !1, e; }, visitDirective(e, t) { return this.env.frames.unshift(e), e; }, visitDirectiveOut(e) { this.env.frames.shift(); }, visitMixinDefinition(e, t) { return this.env.frames.unshift(e), e; }, visitMixinDefinitionOut(e) { this.env.frames.shift(); }, visitRuleset(e, t) { return this.env.frames.unshift(e), e; }, visitRulesetOut(e) { this.env.frames.shift(); }, visitMedia(e, t) { return this.env.frames.unshift(e.ruleset), e; }, visitMediaOut(e) { this.env.frames.shift(); },
-    };
-  }(n('./tree'))), (function (e) {
-    e.joinSelectorVisitor = function () { this.contexts = [[]], this._visitor = new e.visitor(this); }, e.joinSelectorVisitor.prototype = {
-      run(e) { return this._visitor.visit(e); }, visitRule(e, t) { t.visitDeeper = !1; }, visitMixinDefinition(e, t) { t.visitDeeper = !1; }, visitRuleset(e, t) { const n = this.contexts[this.contexts.length - 1]; const r = []; this.contexts.push(r), e.root || (e.joinSelectors(r, n, e.selectors), e.paths = r); }, visitRulesetOut(e) { this.contexts.length = this.contexts.length - 1; }, visitMedia(e, t) { const n = this.contexts[this.contexts.length - 1]; e.ruleset.root = n.length === 0 || n[0].multiMedia; },
-    };
-  }(n('./tree'))), (function (e) {
-    e.extendFinderVisitor = function () { this._visitor = new e.visitor(this), this.contexts = [], this.allExtendsStack = [[]]; }, e.extendFinderVisitor.prototype = {
-      run(e) { return e = this._visitor.visit(e), e.allExtends = this.allExtendsStack[0], e; }, visitRule(e, t) { t.visitDeeper = !1; }, visitMixinDefinition(e, t) { t.visitDeeper = !1; }, visitRuleset(t, n) { if (t.root) return; let r; let i; let s; const o = []; let u; for (r = 0; r < t.rules.length; r++)t.rules[r] instanceof e.Extend && o.push(t.rules[r]); for (r = 0; r < t.paths.length; r++) { const a = t.paths[r]; const f = a[a.length - 1]; u = f.extendList.slice(0).concat(o).map((e) => e.clone()); for (i = 0; i < u.length; i++) this.foundExtends = !0, s = u[i], s.findSelfSelectors(a), s.ruleset = t, i === 0 && (s.firstExtendOnThisSelectorPath = !0), this.allExtendsStack[this.allExtendsStack.length - 1].push(s); } this.contexts.push(t.selectors); }, visitRulesetOut(e) { e.root || (this.contexts.length = this.contexts.length - 1); }, visitMedia(e, t) { e.allExtends = [], this.allExtendsStack.push(e.allExtends); }, visitMediaOut(e) { this.allExtendsStack.length = this.allExtendsStack.length - 1; }, visitDirective(e, t) { e.allExtends = [], this.allExtendsStack.push(e.allExtends); }, visitDirectiveOut(e) { this.allExtendsStack.length = this.allExtendsStack.length - 1; },
-    }, e.processExtendsVisitor = function () { this._visitor = new e.visitor(this); }, e.processExtendsVisitor.prototype = {
-      run(t) { const n = new e.extendFinderVisitor(); return n.run(t), n.foundExtends ? (t.allExtends = t.allExtends.concat(this.doExtendChaining(t.allExtends, t.allExtends)), this.allExtendsStack = [t.allExtends], this._visitor.visit(t)) : t; },
-      doExtendChaining(t, n, r) { let i; let s; let o; const u = []; let a; const f = this; let l; let c; let h; let p; r = r || 0; for (i = 0; i < t.length; i++) for (s = 0; s < n.length; s++) { c = t[i], h = n[s]; if (this.inInheritanceChain(h, c)) continue; l = [h.selfSelectors[0]], o = f.findMatch(c, l), o.length && c.selfSelectors.forEach((t) => { a = f.extendSelector(o, l, t), p = new e.Extend(h.selector, h.option, 0), p.selfSelectors = a, a[a.length - 1].extendList = [p], u.push(p), p.ruleset = h.ruleset, p.parents = [h, c], h.firstExtendOnThisSelectorPath && (p.firstExtendOnThisSelectorPath = !0, h.ruleset.paths.push(a)); }); } if (u.length) { this.extendChainCount++; if (r > 100) { let d = '{unable to calculate}'; let v = '{unable to calculate}'; try { d = u[0].selfSelectors[0].toCSS(), v = u[0].selector.toCSS(); } catch (m) {} throw { message: `extend circular reference detected. One of the circular extends is currently:${d}:extend(${v})` }; } return u.concat(f.doExtendChaining(u, n, r + 1)); } return u; },
-      inInheritanceChain(e, t) { if (e === t) return !0; if (t.parents) { if (this.inInheritanceChain(e, t.parents[0])) return !0; if (this.inInheritanceChain(e, t.parents[1])) return !0; } return !1; },
-      visitRule(e, t) { t.visitDeeper = !1; },
-      visitMixinDefinition(e, t) { t.visitDeeper = !1; },
-      visitSelector(e, t) { t.visitDeeper = !1; },
-      visitRuleset(e, t) { if (e.root) return; let n; let r; let i; const s = this.allExtendsStack[this.allExtendsStack.length - 1]; const o = []; const u = this; let a; for (i = 0; i < s.length; i++) for (r = 0; r < e.paths.length; r++) { a = e.paths[r]; if (a[a.length - 1].extendList.length) continue; n = this.findMatch(s[i], a), n.length && s[i].selfSelectors.forEach((e) => { o.push(u.extendSelector(n, a, e)); }); }e.paths = e.paths.concat(o); },
-      findMatch(e, t) {
-        let n; let r; let i; let s; let o; let u; const a = this; const f = e.selector.elements; const l = []; let c; const h = []; for (n = 0; n < t.length; n++) {
-          r = t[n]; for (i = 0; i < r.elements.length; i++) {
-            s = r.elements[i], (e.allowBefore || n == 0 && i == 0) && l.push({
-              pathIndex: n, index: i, matched: 0, initialCombinator: s.combinator,
-            }); for (u = 0; u < l.length; u++)c = l[u], o = s.combinator.value, o == '' && i === 0 && (o = ' '), !a.isElementValuesEqual(f[c.matched].value, s.value) || c.matched > 0 && f[c.matched].combinator.value !== o ? c = null : c.matched++, c && (c.finished = c.matched === f.length, c.finished && !e.allowAfter && (i + 1 < r.elements.length || n + 1 < t.length) && (c = null)), c ? c.finished && (c.length = f.length, c.endPathIndex = n, c.endPathElementIndex = i + 1, l.length = 0, h.push(c)) : (l.splice(u, 1), u--);
-          }
-        } return h;
-      },
-      isElementValuesEqual(t, n) { if (typeof t === 'string' || typeof n === 'string') return t === n; if (t instanceof e.Attribute) return t.op !== n.op || t.key !== n.key ? !1 : !t.value || !n.value ? t.value || n.value ? !1 : !0 : (t = t.value.value || t.value, n = n.value.value || n.value, t === n); return !1; },
-      extendSelector(t, n, r) { let i = 0; let s = 0; let o = []; let u; let a; let f; let l; for (u = 0; u < t.length; u++)l = t[u], a = n[l.pathIndex], f = new e.Element(l.initialCombinator, r.elements[0].value, r.elements[0].index), l.pathIndex > i && s > 0 && (o[o.length - 1].elements = o[o.length - 1].elements.concat(n[i].elements.slice(s)), s = 0, i++), o = o.concat(n.slice(i, l.pathIndex)), o.push(new e.Selector(a.elements.slice(s, l.index).concat([f]).concat(r.elements.slice(1)))), i = l.endPathIndex, s = l.endPathElementIndex, s >= a.elements.length && (s = 0, i++); return i < n.length && s > 0 && (o[o.length - 1].elements = o[o.length - 1].elements.concat(n[i].elements.slice(s)), s = 0, i++), o = o.concat(n.slice(i, n.length)), o; },
-      visitRulesetOut(e) {},
-      visitMedia(e, t) { let n = e.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]); n = n.concat(this.doExtendChaining(n, e.allExtends)), this.allExtendsStack.push(n); },
-      visitMediaOut(e) { this.allExtendsStack.length = this.allExtendsStack.length - 1; },
-      visitDirective(e, t) { let n = e.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]); n = n.concat(this.doExtendChaining(n, e.allExtends)), this.allExtendsStack.push(n); },
-      visitDirectiveOut(e) { this.allExtendsStack.length = this.allExtendsStack.length - 1; },
-    };
-  }(n('./tree'))); var o = /^(file|chrome(-extension)?|resource|qrc|app):/.test(location.protocol); r.env = r.env || (location.hostname == '127.0.0.1' || location.hostname == '0.0.0.0' || location.hostname == 'localhost' || location.port.length > 0 || o ? 'development' : 'production'), r.async = r.async || !1, r.fileAsync = r.fileAsync || !1, r.poll = r.poll || (o ? 1e3 : 1500); if (r.functions) for (const u in r.functions)r.tree.functions[u] = r.functions[u]; const a = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(location.hash); a && (r.dumpLineNumbers = a[1]), r.watch = function () { return r.watchMode || (r.env = 'development', f()), this.watchMode = !0; }, r.unwatch = function () { return clearInterval(r.watchTimer), this.watchMode = !1; }, /!watch/.test(location.hash) && r.watch(); var l = null; if (r.env != 'development') try { l = typeof e.localStorage === 'undefined' ? null : e.localStorage; } catch (c) {} const h = document.getElementsByTagName('link'); var p = /^text\/(x-)?less$/; r.sheets = []; for (let d = 0; d < h.length; d++)(h[d].rel === 'stylesheet/less' || h[d].rel.match(/stylesheet/) && h[d].type.match(p)) && r.sheets.push(h[d]); var v = ''; r.modifyVars = function (e) { let t = v; for (const n in e)t += `${(n.slice(0, 1) === '@' ? '' : '@') + n}: ${e[n].slice(-1) === ';' ? e[n] : `${e[n]};`}`; (new r.Parser(new r.tree.parseEnv(r))).parse(t, (e, t) => { e ? k(e, 'session_cache') : S(t.toCSS(r), r.sheets[r.sheets.length - 1]); }); }, r.refresh = function (e) { let t; let n; t = n = new Date(), g((e, i, s, o, u) => { if (e) return k(e, o.href); u.local ? C(`loading ${o.href} from cache.`) : (C(`parsed ${o.href} successfully.`), S(i.toCSS(r), o, u.lastModified)), C(`css for ${o.href} generated in ${new Date() - n}ms`), u.remaining === 0 && C(`css generated in ${new Date() - t}ms`), n = new Date(); }, e), m(); }, r.refreshStyles = m, r.refresh(r.env === 'development'), typeof define === 'function' && define.amd && define(() => r);
-}(window));
diff --git a/packages/mindplot/src/components/libraries/less/less-1.6.2.min.js b/packages/mindplot/src/components/libraries/less/less-1.6.2.min.js
deleted file mode 100644
index 7c11e839..00000000
--- a/packages/mindplot/src/components/libraries/less/less-1.6.2.min.js
+++ /dev/null
@@ -1,421 +0,0 @@
-/*!
- * LESS - Leaner CSS v1.6.2
- * http://lesscss.org
- *
- * Copyright (c) 2009-2014, Alexis Sellier <self@cloudhead.net>
- * Licensed under the Apache v2 License.
- *
- */
-
-/** * @license Apache v2
- */
-
-!(function (a, b) {
-  function c(b) { return a.less[b.split('/')[1]]; } function d(a, b) { v.env == 'development' && typeof console !== 'undefined' && v.logLevel >= b && console.log(`less: ${a}`); } function e(a) {
-    return a.replace(/^[a-z-]+:\/+?[^\/]+/, '').replace(/^\//, '').replace(/\.[a-zA-Z]+$/, '').replace(/[^\.\w-]+/g, '-')
-      .replace(/\./g, ':');
-  } function f(a, c) { const e = '{line} {content}'; const f = a.filename || c; const g = []; let h = `${a.type || 'Syntax'}Error: ${a.message || 'There is an error in your .less file'} in ${f} `; const i = function (a, c, d) { a.extract[c] !== b && g.push(e.replace(/\{line\}/, (parseInt(a.line, 10) || 0) + (c - 1)).replace(/\{class\}/, d).replace(/\{content\}/, a.extract[c])); }; a.extract ? (i(a, 0, ''), i(a, 1, 'line'), i(a, 2, ''), h += `on line ${a.line}, column ${a.column + 1}:\n${g.join('\n')}`) : a.stack && (h += a.stack), d(h, y.errors); } function g(a, b, c) { const f = b.href || ''; const g = `less:${b.title || e(f)}`; const h = document.getElementById(g); let i = !1; const j = document.createElement('style'); if (j.setAttribute('type', 'text/css'), b.media && j.setAttribute('media', b.media), j.id = g, j.styleSheet) try { j.styleSheet.cssText = a; } catch (k) { throw new Error("Couldn't reassign styleSheet.cssText."); } else j.appendChild(document.createTextNode(a)), i = h !== null && h.childNodes.length > 0 && j.childNodes.length > 0 && h.firstChild.nodeValue === j.firstChild.nodeValue; const l = document.getElementsByTagName('head')[0]; if (h === null || i === !1) { const m = b && b.nextSibling || null; m ? m.parentNode.insertBefore(j, m) : l.appendChild(j); } if (h && i === !1 && h.parentNode.removeChild(h), c && C) { d(`saving ${f} to cache.`, y.info); try { C.setItem(f, a), C.setItem(`${f}:timestamp`, c); } catch (k) { d('failed to save', y.errors); } } } function h(a, c) { let d; let f; const h = `less-error-message:${e(c || '')}`; const i = '<li><label>{line}</label><pre class="{class}">{content}</pre></li>'; const j = document.createElement('div'); const k = []; const l = a.filename || c; const m = l.match(/([^\/]+(\?.*)?)$/)[1]; j.id = h, j.className = 'less-error-message', f = `<h3>${a.type || 'Syntax'}Error: ${a.message || 'There is an error in your .less file'}</h3><p>in <a href="${l}">${m}</a> `; const n = function (a, c, d) { a.extract[c] !== b && k.push(i.replace(/\{line\}/, (parseInt(a.line, 10) || 0) + (c - 1)).replace(/\{class\}/, d).replace(/\{content\}/, a.extract[c])); }; a.extract ? (n(a, 0, ''), n(a, 1, 'line'), n(a, 2, ''), f += `on line ${a.line}, column ${a.column + 1}:</p><ul>${k.join('')}</ul>`) : a.stack && (f += `<br/>${a.stack.split('\n').slice(1).join('<br/>')}`), j.innerHTML = f, g(['.less-error-message ul, .less-error-message li {', 'list-style-type: none;', 'margin-right: 15px;', 'padding: 4px 0;', 'margin: 0;', '}', '.less-error-message label {', 'font-size: 12px;', 'margin-right: 15px;', 'padding: 4px 0;', 'color: #cc7777;', '}', '.less-error-message pre {', 'color: #dd6666;', 'padding: 4px 0;', 'margin: 0;', 'display: inline-block;', '}', '.less-error-message pre.line {', 'color: #ff0000;', '}', '.less-error-message h3 {', 'font-size: 20px;', 'font-weight: bold;', 'padding: 15px 0 5px 0;', 'margin: 0;', '}', '.less-error-message a {', 'color: #10a', '}', '.less-error-message .error {', 'color: red;', 'font-weight: bold;', 'padding-bottom: 2px;', 'border-bottom: 1px dashed red;', '}'].join('\n'), { title: 'error-message' }), j.style.cssText = ['font-family: Arial, sans-serif', 'border: 1px solid #e00', 'background-color: #eee', 'border-radius: 5px', '-webkit-border-radius: 5px', '-moz-border-radius: 5px', 'color: #e00', 'padding: 15px', 'margin-bottom: 15px'].join(';'), v.env == 'development' && (d = setInterval(() => { document.body && (document.getElementById(h) ? document.body.replaceChild(j, document.getElementById(h)) : document.body.insertBefore(j, document.body.firstChild), clearInterval(d)); }, 10)); } function i(a, b) { v.errorReporting && v.errorReporting !== 'html' ? v.errorReporting === 'console' ? f(a, b) : typeof v.errorReporting === 'function' && v.errorReporting('add', a, b) : h(a, b); } function j(a) { const b = document.getElementById(`less-error-message:${e(a)}`); b && b.parentNode.removeChild(b); } function k() {} function l(a) { v.errorReporting && v.errorReporting !== 'html' ? v.errorReporting === 'console' ? k(a) : typeof v.errorReporting === 'function' && v.errorReporting('remove', a) : j(a); } function m(a) { for (var b, c = document.getElementsByTagName('style'), d = 0; d < c.length; d++) if (b = c[d], b.type.match(B)) { const e = new v.tree.parseEnv(v); const f = b.innerHTML || ''; e.filename = document.location.href.replace(/#.*$/, ''), (a || v.globalVars) && (e.useFileCache = !0); const g = (function (a) { return function (b, c) { if (b) return i(b, 'inline'); const d = c.toCSS(v); a.type = 'text/css', a.styleSheet ? a.styleSheet.cssText = d : a.innerHTML = d; }; }(b)); new v.Parser(e).parse(f, g, { globalVars: v.globalVars, modifyVars: a }); } } function n(a, b) { let c; let d; const e = /^((?:[a-z-]+:)?\/+?(?:[^\/\?#]*\/)|([\/\\]))?((?:[^\/\\\?#]*[\/\\])*)([^\/\\\?#]*)([#\?].*)?$/i; const f = a.match(e); const g = {}; let h = []; if (!f) throw new Error(`Could not parse sheet href - '${a}'`); if (!f[1] || f[2]) { if (d = b.match(e), !d) throw new Error(`Could not parse page url - '${b}'`); f[1] = f[1] || d[1] || '', f[2] || (f[3] = d[3] + f[3]); } if (f[3]) { for (h = f[3].replace(/\\/g, '/').split('/'), c = 0; c < h.length; c++)h[c] === '.' && (h.splice(c, 1), c -= 1); for (c = 0; c < h.length; c++)h[c] === '..' && c > 0 && (h.splice(c - 1, 2), c -= 2); } return g.hostPart = f[1], g.directories = h, g.path = f[1] + h.join('/'), g.fileUrl = g.path + (f[4] || ''), g.url = g.fileUrl + (f[5] || ''), g; } function o(a, b) { let c; let d; let e; let f; const g = n(a); const h = n(b); let i = ''; if (g.hostPart !== h.hostPart) return ''; for (d = Math.max(h.directories.length, g.directories.length), c = 0; d > c && h.directories[c] === g.directories[c]; c++);for (f = h.directories.slice(c), e = g.directories.slice(c), c = 0; c < f.length - 1; c++)i += '../'; for (c = 0; c < e.length - 1; c++)i += `${e[c]}/`; return i; } function p() { if (a.XMLHttpRequest) return new XMLHttpRequest(); try { return new ActiveXObject('MSXML2.XMLHTTP.3.0'); } catch (b) { return d("browser doesn't support AJAX.", y.errors), null; } } function q(a, b, c, e) { function f(b, c, d) { b.status >= 200 && b.status < 300 ? c(b.responseText, b.getResponseHeader('Last-Modified')) : typeof d === 'function' && d(b.status, a); } const g = p(); const h = x ? v.fileAsync : v.async; typeof g.overrideMimeType === 'function' && g.overrideMimeType('text/css'), d(`XHR: Getting '${a}'`, y.info), g.open('GET', a, h), g.setRequestHeader('Accept', b || 'text/x-less, text/css; q=0.9, */*; q=0.5'), g.send(null), x && !v.fileAsync ? g.status === 0 || g.status >= 200 && g.status < 300 ? c(g.responseText) : e(g.status, a) : h ? g.onreadystatechange = function () { g.readyState == 4 && f(g, c, e); } : f(g, c, e); } function r(b, c, d, e) { c && c.currentDirectory && !/^([a-z-]+:)?\//.test(b) && (b = c.currentDirectory + b); const f = n(b, a.location.href); const g = f.url; const h = { currentDirectory: f.path, filename: g }; if (c ? (h.entryPath = c.entryPath, h.rootpath = c.rootpath, h.rootFilename = c.rootFilename, h.relativeUrls = c.relativeUrls) : (h.entryPath = f.path, h.rootpath = v.rootpath || f.path, h.rootFilename = g, h.relativeUrls = e.relativeUrls), h.relativeUrls && (h.rootpath = e.rootpath ? n(e.rootpath + o(f.path, h.entryPath)).path : f.path), e.useFileCache && D[g]) try { const i = D[g]; d(null, i, g, h, { lastModified: new Date() }); } catch (j) { d(j, null, g); } else q(g, e.mime, (a, b) => { D[g] = a; try { d(null, a, g, h, { lastModified: b }); } catch (c) { d(c, null, g); } }, (a, b) => { d({ type: 'File', message: `'${b}' wasn't found (${a})` }, null, g); }); } function s(a, b, c, d, e) { const f = new v.tree.parseEnv(v); f.mime = a.type, (e || v.globalVars) && (f.useFileCache = !0), r(a.href, null, (h, i, j, k, m) => { if (m) { m.remaining = d; const n = C && C.getItem(j); const o = C && C.getItem(`${j}:timestamp`); if (!c && o && m.lastModified && new Date(m.lastModified).valueOf() === new Date(o).valueOf()) return g(n, a), m.local = !0, b(null, null, i, a, m, j), void 0; }l(j), i ? (f.currentFileInfo = k, new v.Parser(f).parse(i, (c, d) => { if (c) return b(c, null, null, a); try { b(c, d, i, a, m, j); } catch (c) { b(c, null, null, a); } }, { modifyVars: e, globalVars: v.globalVars })) : b(h, null, null, a, m, j); }, f, e); } function t(a, b, c) { for (let d = 0; d < v.sheets.length; d++)s(v.sheets[d], a, b, v.sheets.length - (d + 1), c); } function u() { v.env === 'development' ? (v.optimization = 0, v.watchTimer = setInterval(() => { v.watchMode && t((a, b, c, d, e) => { a ? i(a, d.href) : b && g(b.toCSS(v), d, e.lastModified); }); }, v.poll)) : v.optimization = 3; }(typeof a.less === 'undefined' || typeof a.less.nodeType !== 'undefined') && (a.less = {}), v = a.less, w = a.less.tree = {}, v.mode = 'browser'; let v; let w; v === b && (v = exports, w = c('./tree'), v.mode = 'node'), v.Parser = function (a) {
-    function d() { z = D, A = E = x; } function e() { D = z, E = x = A; } function f() { x > E && (D = D.slice(x - E), E = x); } function g(a, b) { const c = a.charCodeAt(0 | b); return c <= 32 && (c === 32 || c === 10 || c === 9); } function h(a) { let b; let c; const d = typeof a; return d === 'string' ? u.charAt(x) !== a ? null : (k(1), a) : (f(), (b = a.exec(D)) ? (c = b[0].length, k(c), typeof b === 'string' ? b : b.length === 1 ? b[0] : b) : null); } function i(a) { x > E && (D = D.slice(x - E), E = x); const b = a.exec(D); return b ? (k(b[0].length), typeof b === 'string' ? b : b.length === 1 ? b[0] : b) : null; } function j(a) { return u.charAt(x) !== a ? null : (k(1), a); } function k(a) { for (var b, c = x, d = y, e = x - E, f = x + D.length - e, g = x += a, h = u; f > x && (b = h.charCodeAt(x), !(b > 32)) && (b === 32 || b === 10 || b === 9 || b === 13); x++);return D = D.slice(a + x - g + e), E = x, !D.length && y < C.length - 1 ? (D = C[++y], k(0), !0) : c !== x || d !== y; } function l(a, b) { const c = Object.prototype.toString.call(a) === '[object Function]' ? a.call(G) : h(a); return c || (n(b || (typeof a === 'string' ? `expected '${a}' got '${u.charAt(x)}'` : 'unexpected token')), void 0); } function m(a, b) { return u.charAt(x) === a ? (k(1), a) : (n(b || `expected '${a}' got '${u.charAt(x)}'`), void 0); } function n(a, b) { const c = new Error(a); throw c.index = x, c.type = b || 'Syntax', c; } function o(a) { return typeof a === 'string' ? u.charAt(x) === a : a.test(D); } function p(a) { return u.charAt(x) === a; } function q(a, b) { return a.filename && b.currentFileInfo.filename && a.filename !== b.currentFileInfo.filename ? F.imports.contents[a.filename] : u; } function r(a, b) { for (var c = a + 1, d = null, e = -1; --c >= 0 && b.charAt(c) !== '\n';)e++; return typeof a === 'number' && (d = (b.slice(0, a).match(/\n/g) || '').length), { line: d, column: e }; } function s(a, b, d) { let e = d.currentFileInfo.filename; return v.mode !== 'browser' && v.mode !== 'rhino' && (e = c('path').resolve(e)), { lineNumber: r(a, b).line + 1, fileName: e }; } function t(a, b) { const c = q(a, b); const d = r(a.index, c); const e = d.line; const f = d.column; const g = a.call && r(a.call, c).line; const h = c.split('\n'); this.type = a.type || 'Syntax', this.message = a.message, this.filename = a.filename || b.currentFileInfo.filename, this.index = a.index, this.line = typeof e === 'number' ? e + 1 : null, this.callLine = g + 1, this.callExtract = h[g], this.stack = a.stack, this.column = f, this.extract = [h[e - 1], h[e], h[e + 1]]; } let u; let x; let y; let z; let A; let B; let C; let D; let E; let F; let G; const H = a && a.filename; a instanceof w.parseEnv || (a = new w.parseEnv(a)); const I = this.imports = {
-      paths: a.paths || [], queue: [], files: a.files, contents: a.contents, contentsIgnoredChars: a.contentsIgnoredChars, mime: a.mime, error: null, push(b, c, d, e) { const f = this; this.queue.push(b); const g = function (a, c, d) { f.queue.splice(f.queue.indexOf(b), 1); const g = d in f.files || d === H; f.files[d] = c, a && !f.error && (f.error = a), e(a, c, g, d); }; v.Parser.importer ? v.Parser.importer(b, c, g, a) : v.Parser.fileLoader(b, c, (b, e, f, h) => { if (b) return g(b), void 0; const i = new w.parseEnv(a); i.currentFileInfo = h, i.processImports = !1, i.contents[f] = e, (c.reference || d.reference) && (h.reference = !0), d.inline ? g(null, e, f) : new v.Parser(i).parse(e, (a, b) => { g(a, b, f); }); }, a); },
-    }; const J = i; return t.prototype = new Error(), t.prototype.constructor = t, this.env = a = a || {}, this.optimization = 'optimization' in this.env ? this.env.optimization : 1, F = {
-      imports: I,
-      parse(d, e, f) {
-        let g; let h; let i; let j; let k; let l = null; let m = ''; if (x = y = E = B = 0, j = f && f.globalVars ? `${v.Parser.serializeVars(f.globalVars)}\n` : '', k = f && f.modifyVars ? `\n${v.Parser.serializeVars(f.modifyVars)}` : '', (j || f && f.banner) && (m = (f && f.banner ? f.banner : '') + j, F.imports.contentsIgnoredChars[a.currentFileInfo.filename] = m.length), d = d.replace(/\r\n/g, '\n'), u = d = m + d.replace(/^\uFEFF/, '') + k, F.imports.contents[a.currentFileInfo.filename] = d, C = (function (b) {
-          function c(b, c) {
-            l = new t({
-              index: c || i, type: 'Parse', message: b, filename: a.currentFileInfo.filename,
-            }, a);
-          } function d(a) { const c = i - s; c < 512 && !a || !c || (r.push(b.slice(s, i + 1)), s = i + 1); } let e; let f; let g; let h; let i; let j; let k; let m; let n; const o = b.length; let p = 0; let q = 0; var r = []; var s = 0; for (i = 0; o > i; i++) if (k = b.charCodeAt(i), !(k >= 97 && k <= 122 || k < 34)) switch (k) { case 40: q++, f = i; continue; case 41: if (--q < 0) return c('missing opening `(`'); continue; case 59: q || d(); continue; case 123: p++, e = i; continue; case 125: if (--p < 0) return c('missing opening `{`'); p || d(); continue; case 92: if (o - 1 > i) { i++; continue; } return c('unescaped `\\`'); case 34: case 39: case 96: for (n = 0, j = i, i += 1; o > i; i++) if (m = b.charCodeAt(i), !(m > 96)) { if (m == k) { n = 1; break; } if (m == 92) { if (i == o - 1) return c('unescaped `\\`'); i++; } } if (n) continue; return c(`unmatched \`${String.fromCharCode(k)}\``, j); case 47: if (q || i == o - 1) continue; if (m = b.charCodeAt(i + 1), m == 47) for (i += 2; o > i && (m = b.charCodeAt(i), !(m <= 13) || m != 10 && m != 13); i++);else if (m == 42) { for (g = j = i, i += 2; o - 1 > i && (m = b.charCodeAt(i), m == 125 && (h = i), m != 42 || b.charCodeAt(i + 1) != 47); i++);if (i == o - 1) return c('missing closing `*/`', j); i++; } continue; case 42: if (o - 1 > i && b.charCodeAt(i + 1) == 47) return c('unmatched `/*`'); continue; } return p !== 0 ? g > e && h > g ? c('missing closing `}` or `*/`', e) : c('missing closing `}`', e) : q !== 0 ? c('missing closing `)`', f) : (d(!0), r);
-        }(d)), l) return e(new t(l, a)); D = C[0]; try { g = new w.Ruleset(null, this.parsers.primary()), g.root = !0, g.firstRoot = !0; } catch (n) { return e(new t(n, a)); } if (g.toCSS = (function (d) {
-          return function (e, f) {
-            e = e || {}; let g; let h; const i = new w.evalEnv(e); typeof f !== 'object' || Array.isArray(f) || (f = Object.keys(f).map((a) => { let b = f[a]; return b instanceof w.Value || (b instanceof w.Expression || (b = new w.Expression([b])), b = new w.Value([b])), new w.Rule(`@${a}`, b, !1, null, 0); }), i.frames = [new w.Ruleset(null, f)]); try {
-              let j; const k = []; const l = [new w.joinSelectorVisitor(), new w.processExtendsVisitor(), new w.toCSSVisitor({ compress: Boolean(e.compress) })]; const m = this; if (e.plugins) for (j = 0; j < e.plugins.length; j++)e.plugins[j].isPreEvalVisitor ? k.push(e.plugins[j]) : e.plugins[j].isPreVisitor ? l.splice(0, 0, e.plugins[j]) : l.push(e.plugins[j]); for (j = 0; j < k.length; j++)k[j].run(m); for (g = d.call(m, i), j = 0; j < l.length; j++)l[j].run(g); e.sourceMap && (g = new w.sourceMapOutput({
-                contentsIgnoredCharsMap: F.imports.contentsIgnoredChars, writeSourceMap: e.writeSourceMap, rootNode: g, contentsMap: F.imports.contents, sourceMapFilename: e.sourceMapFilename, sourceMapURL: e.sourceMapURL, outputFilename: e.sourceMapOutputFilename, sourceMapBasepath: e.sourceMapBasepath, sourceMapRootpath: e.sourceMapRootpath, outputSourceFiles: e.outputSourceFiles, sourceMapGenerator: e.sourceMapGenerator,
-              })), h = g.toCSS({
-                compress: Boolean(e.compress), dumpLineNumbers: a.dumpLineNumbers, strictUnits: Boolean(e.strictUnits), numPrecision: 8,
-              });
-            } catch (n) { throw new t(n, a); } if (e.cleancss && v.mode === 'node') { const o = c('clean-css'); const p = e.cleancssOptions || {}; return p.keepSpecialComments === b && (p.keepSpecialComments = '*'), p.processImport = !1, p.noRebase = !0, p.noAdvanced === b && (p.noAdvanced = !0), new o(p).minify(h); } return e.compress ? h.replace(/(^(\s)+)|((\s)+$)/g, '') : h;
-          };
-        }(g.eval)), x < u.length - 1) {
-          x = B; const o = r(x, u); i = u.split('\n'), h = o.line + 1, l = {
-            type: 'Parse', message: 'Unrecognised input', index: x, filename: a.currentFileInfo.filename, line: h, column: o.column, extract: [i[h - 2], i[h - 1], i[h]],
-          };
-        } const p = function (b) { return b = l || b || F.imports.error, b ? (b instanceof t || (b = new t(b, a)), e(b)) : e(null, g); }; return a.processImports === !1 ? p() : (new w.importVisitor(this.imports, p).run(g), void 0);
-      },
-      parsers: G = {
-        primary() { for (var a, b = this.mixin, c = J, d = []; D;) if (a = this.extendRule() || b.definition() || this.rule() || this.ruleset() || b.call() || this.comment() || this.directive())d.push(a); else if (!c(/^[\s\n]+/) && !c(/^;+/)) break; return d; },
-        comment() { let b; if (u.charAt(x) === '/') return u.charAt(x + 1) === '/' ? new w.Comment(i(/^\/\/.*/), !0, x, a.currentFileInfo) : (b = i(/^\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/), b ? new w.Comment(b, !1, x, a.currentFileInfo) : void 0); },
-        comments() { for (var a, b = []; ;) { if (a = this.comment(), !a) break; b.push(a); } return b; },
-        entities: {
-          quoted() { let b; let c; let d = x; const e = x; return u.charAt(d) === '~' && (d++, c = !0), u.charAt(d) === '"' || u.charAt(d) === "'" ? (c && j('~'), b = i(/^"((?:[^"\\\r\n]|\\.)*)"|'((?:[^'\\\r\n]|\\.)*)'/), b ? new w.Quoted(b[0], b[1] || b[2], c, e, a.currentFileInfo) : void 0) : void 0; }, keyword() { let a; if (a = i(/^[_A-Za-z-][_A-Za-z0-9-]*/)) { const b = w.Color.fromKeyword(a); return b || new w.Keyword(a); } }, call() { let b; let c; let d; let e; const f = x; if (b = /^([\w-]+|%|progid:[\w\.]+)\(/.exec(D)) { if (b = b[1], c = b.toLowerCase(), c === 'url') return null; if (x += b.length, c === 'alpha' && (e = G.alpha(), typeof e !== 'undefined')) return e; if (j('('), d = this.arguments(), j(')')) return b ? new w.Call(b, d, f, a.currentFileInfo) : void 0; } }, arguments() { for (var a, b = []; ;) { if (a = this.assignment() || G.expression(), !a) break; if (b.push(a), !j(',')) break; } return b; }, literal() { return this.dimension() || this.color() || this.quoted() || this.unicodeDescriptor(); }, assignment() { let a; let b; return a = i(/^\w+(?=\s?=)/i), a && j('=') ? (b = G.entity(), b ? new w.Assignment(a, b) : void 0) : void 0; }, url() { let b; if (u.charAt(x) === 'u' && i(/^url\(/)) return b = this.quoted() || this.variable() || i(/^(?:(?:\\[\(\)'"])|[^\(\)'"])+/) || '', m(')'), new w.URL(b.value != null || b instanceof w.Variable ? b : new w.Anonymous(b), a.currentFileInfo); }, variable() { let b; const c = x; return u.charAt(x) === '@' && (b = i(/^@@?[\w-]+/)) ? new w.Variable(b, c, a.currentFileInfo) : void 0; }, variableCurly() { let b; const c = x; return u.charAt(x) === '@' && (b = i(/^@\{([\w-]+)\}/)) ? new w.Variable(`@${b[1]}`, c, a.currentFileInfo) : void 0; }, color() { let a; return u.charAt(x) === '#' && (a = i(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/)) ? new w.Color(a[1]) : void 0; }, dimension() { let a; const b = u.charCodeAt(x); if (!(b > 57 || b < 43 || b === 47 || b == 44)) return a = i(/^([+-]?\d*\.?\d+)(%|[a-z]+)?/), a ? new w.Dimension(a[1], a[2]) : void 0; }, unicodeDescriptor() { let a; return a = i(/^U\+[0-9a-fA-F?]+(\-[0-9a-fA-F?]+)?/), a ? new w.UnicodeDescriptor(a[0]) : void 0; }, javascript() { let c; let d; let e = x; return u.charAt(e) === '~' && (e++, d = !0), u.charAt(e) === '`' ? (a.javascriptEnabled === b || a.javascriptEnabled || n('You are using JavaScript, which has been disabled.'), d && j('~'), c = i(/^`([^`]*)`/), c ? new w.JavaScript(c[1], x, d) : void 0) : void 0; },
-        },
-        variable() { let a; return u.charAt(x) === '@' && (a = i(/^(@[\w-]+)\s*:/)) ? a[1] : void 0; },
-        extend(a) { let b; let c; let d; let e; let f; const g = x; if (a ? i(/^&:extend\(/) : i(/^:extend\(/)) { do { for (d = null, b = null; !(d = i(/^(all)(?=\s*(\)|,))/)) && (c = this.element());)b ? b.push(c) : b = [c]; d = d && d[1], f = new w.Extend(new w.Selector(b), d, g), e ? e.push(f) : e = [f]; } while (j(',')); return l(/^\)/), a && l(/^;/), e; } },
-        extendRule() { return this.extend(!0); },
-        mixin: { call() { let b; let c; let f; let g; let h; let k; const l = u.charAt(x); let n = !1; const o = x; if (l === '.' || l === '#') { for (d(); ;) { if (b = x, g = i(/^[#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/), !g) break; f = new w.Element(h, g, b, a.currentFileInfo), c ? c.push(f) : c = [f], h = j('>'); } return c && (j('(') && (k = this.args(!0).args, m(')')), G.important() && (n = !0), G.end()) ? new w.mixin.Call(c, k, o, a.currentFileInfo, n) : (e(), void 0); } }, args(a) { for (var b, c, d, e, f, g, h = F.parsers, k = h.entities, m = { args: null, variadic: !1 }, o = [], p = [], q = []; ;) { if (a)g = h.expression(); else { if (h.comments(), u.charAt(x) === '.' && i(/^\.{3}/)) { m.variadic = !0, j(';') && !b && (b = !0), (b ? p : q).push({ variadic: !0 }); break; }g = k.variable() || k.literal() || k.keyword(); } if (!g) break; e = null, g.throwAwayComments && g.throwAwayComments(), f = g; let r = null; if (a ? g.value.length == 1 && (r = g.value[0]) : r = g, r && r instanceof w.Variable) if (j(':'))o.length > 0 && (b && n('Cannot mix ; and , as delimiter types'), c = !0), f = l(h.expression), e = d = r.name; else { if (!a && i(/^\.{3}/)) { m.variadic = !0, j(';') && !b && (b = !0), (b ? p : q).push({ name: g.name, variadic: !0 }); break; }a || (d = e = r.name, f = null); }f && o.push(f), q.push({ name: e, value: f }), j(',') || (j(';') || b) && (c && n('Cannot mix ; and , as delimiter types'), b = !0, o.length > 1 && (f = new w.Value(o)), p.push({ name: d, value: f }), d = null, o = [], c = !1); } return m.args = b ? p : q, m; }, definition() { let a; let b; let c; let f; let g = []; let h = !1; if (!(u.charAt(x) !== '.' && u.charAt(x) !== '#' || o(/^[^{]*\}/)) && (d(), b = i(/^([#.](?:[\w-]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/))) { a = b[1]; const k = this.args(!1); if (g = k.args, h = k.variadic, j(')') || (B = x, e()), G.comments(), i(/^when/) && (f = l(G.conditions, 'expected condition')), c = G.block()) return new w.mixin.Definition(a, g, c, f, h); e(); } } },
-        entity() { const a = this.entities; return a.literal() || a.variable() || a.url() || a.call() || a.keyword() || a.javascript() || this.comment(); },
-        end() { return j(';') || p('}'); },
-        alpha() { let a; if (i(/^\(opacity=/i)) return a = i(/^\d+/) || this.entities.variable(), a ? (m(')'), new w.Alpha(a)) : void 0; },
-        element() { let b; let c; let d; const e = x; return c = this.combinator(), b = i(/^(?:\d+\.\d+|\d+)%/) || i(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) || j('*') || j('&') || this.attribute() || i(/^\([^()@]+\)/) || i(/^[\.#](?=@)/) || this.entities.variableCurly(), b || j('(') && (d = this.selector()) && j(')') && (b = new w.Paren(d)), b ? new w.Element(c, b, e, a.currentFileInfo) : void 0; },
-        combinator() { let a = u.charAt(x); if (a === '>' || a === '+' || a === '~' || a === '|' || a === '^') { for (x++, u.charAt(x) === '^' && (a = '^^', x++); g(u, x);)x++; return new w.Combinator(a); } return g(u, x - 1) ? new w.Combinator(' ') : new w.Combinator(null); },
-        lessSelector() { return this.selector(!0); },
-        selector(b) { for (var c, d, e, f, g, h, i, j = x, k = J; (b && (g = this.extend()) || b && (h = k(/^when/)) || (f = this.element())) && (h ? i = l(this.conditions, 'expected condition') : i ? n('CSS guard can only be used at the end of selector') : g ? d ? d.push(g) : d = [g] : (d && n('Extend can only be used at the end of selector'), e = u.charAt(x), c ? c.push(f) : c = [f], f = null), e !== '{' && e !== '}' && e !== ';' && e !== ',' && e !== ')'););return c ? new w.Selector(c, d, i, j, a.currentFileInfo) : (d && n('Extend must be used to extend a selector, it cannot be used on its own'), void 0); },
-        attribute() { if (j('[')) { let a; let b; let c; const d = this.entities; return (a = d.variableCurly()) || (a = l(/^(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\.)+/)), c = i(/^[|~*$^]?=/), c && (b = d.quoted() || i(/^[0-9]+%/) || i(/^[\w-]+/) || d.variableCurly()), m(']'), new w.Attribute(a, c, b); } },
-        block() { let a; return j('{') && (a = this.primary()) && j('}') ? a : void 0; },
-        ruleset() { let b; let c; let f; let g; for (d(), a.dumpLineNumbers && (g = s(x, u, a)); ;) { if (c = this.lessSelector(), !c) break; if (b ? b.push(c) : b = [c], this.comments(), c.condition && b.length > 1 && n('Guards are only currently allowed on a single selector.'), !j(',')) break; c.condition && n('Guards are only currently allowed on a single selector.'), this.comments(); } if (b && (f = this.block())) { const h = new w.Ruleset(b, f, a.strictImports); return a.dumpLineNumbers && (h.debugInfo = g), h; }B = x, e(); },
-        rule(b) { let c; let f; let g; const h = u.charAt(x); let i = !1; if (d(), h !== '.' && h !== '#' && h !== '&' && (c = this.variable() || this.ruleProperty())) { if (f = !b && (a.compress || c.charAt && c.charAt(0) === '@') ? this.value() || this.anonymousValue() : this.anonymousValue() || this.value(), g = this.important(), i = c.pop && c.pop().value === '+', f && this.end()) return new w.Rule(c, f, g, i, A, a.currentFileInfo); if (B = x, e(), f && !b) return this.rule(!0); } },
-        anonymousValue() { let a; return a = /^([^@+\/'"*`(;{}-]*);/.exec(D), a ? (x += a[0].length - 1, new w.Anonymous(a[1])) : void 0; },
-        import() { let b; let c; const f = x; d(); const g = i(/^@import?\s+/); const h = (g ? this.importOptions() : null) || {}; return g && (b = this.entities.quoted() || this.entities.url()) && (c = this.mediaFeatures(), j(';')) ? (c = c && new w.Value(c), new w.Import(b, c, h, f, a.currentFileInfo)) : (e(), void 0); },
-        importOptions() { let a; let b; let c; const d = {}; if (!j('(')) return null; do if (a = this.importOption()) { switch (b = a, c = !0, b) { case 'css': b = 'less', c = !1; break; case 'once': b = 'multiple', c = !1; } if (d[b] = c, !j(',')) break; } while (a); return m(')'), d; },
-        importOption() { const a = i(/^(less|css|multiple|once|inline|reference)/); return a ? a[1] : void 0; },
-        mediaFeature() { let b; let c; const d = this.entities; const e = []; do if (b = d.keyword() || d.variable())e.push(b); else if (j('(')) { if (c = this.property(), b = this.value(), !j(')')) return null; if (c && b)e.push(new w.Paren(new w.Rule(c, b, null, null, x, a.currentFileInfo, !0))); else { if (!b) return null; e.push(new w.Paren(b)); } } while (b); return e.length > 0 ? new w.Expression(e) : void 0; },
-        mediaFeatures() { let a; const b = this.entities; const c = []; do if (a = this.mediaFeature()) { if (c.push(a), !j(',')) break; } else if (a = b.variable(), a && (c.push(a), !j(','))) break; while (a); return c.length > 0 ? c : null; },
-        media() { let b; let c; let d; let e; return a.dumpLineNumbers && (e = s(x, u, a)), i(/^@media/) && (b = this.mediaFeatures(), c = this.block()) ? (d = new w.Media(c, b, x, a.currentFileInfo), a.dumpLineNumbers && (d.debugInfo = e), d) : void 0; },
-        directive() { let b; let c; let f; let g; let h; let k; let l; let m; const n = x; if (u.charAt(x) === '@') { if (c = this.import() || this.media()) return c; if (d(), b = i(/^@[a-z-]+/)) { switch (g = b, b.charAt(1) == '-' && b.indexOf('-', 2) > 0 && (g = `@${b.slice(b.indexOf('-', 2) + 1)}`), g) { case '@font-face': h = !0; break; case '@viewport': case '@top-left': case '@top-left-corner': case '@top-center': case '@top-right': case '@top-right-corner': case '@bottom-left': case '@bottom-left-corner': case '@bottom-center': case '@bottom-right': case '@bottom-right-corner': case '@left-top': case '@left-middle': case '@left-bottom': case '@right-top': case '@right-middle': case '@right-bottom': h = !0; break; case '@host': case '@page': case '@document': case '@supports': case '@keyframes': h = !0, k = !0; break; case '@namespace': l = !0; } if (k && (m = (i(/^[^{]+/) || '').trim(), m && (b += ` ${m}`)), h) { if (f = this.block()) return new w.Directive(b, f, n, a.currentFileInfo); } else if (c = l ? this.expression() : this.entity(), c && j(';')) { const o = new w.Directive(b, c, n, a.currentFileInfo); return a.dumpLineNumbers && (o.debugInfo = s(x, u, a)), o; }e(); } } },
-        value() { let a; const b = []; do if (a = this.expression(), a && (b.push(a), !j(','))) break; while (a); return b.length > 0 ? new w.Value(b) : void 0; },
-        important() { return u.charAt(x) === '!' ? i(/^! *important/) : void 0; },
-        sub() { let a; let b; return j('(') && (a = this.addition()) ? (b = new w.Expression([a]), m(')'), b.parens = !0, b) : void 0; },
-        multiplication() { let a; let b; let c; let d; let e; if (a = this.operand()) { for (e = g(u, x - 1); ;) { if (o(/^\/[*\/]/)) break; if (c = j('/') || j('*'), !c) break; if (b = this.operand(), !b) break; a.parensInOp = !0, b.parensInOp = !0, d = new w.Operation(c, [d || a, b], e), e = g(u, x - 1); } return d || a; } },
-        addition() { let a; let b; let c; let d; let e; if (a = this.multiplication()) { for (e = g(u, x - 1); ;) { if (c = i(/^[-+]\s+/) || !e && (j('+') || j('-')), !c) break; if (b = this.multiplication(), !b) break; a.parensInOp = !0, b.parensInOp = !0, d = new w.Operation(c, [d || a, b], e), e = g(u, x - 1); } return d || a; } },
-        conditions() { let a; let b; let c; const d = x; if (a = this.condition()) { for (;;) { if (!o(/^,\s*(not\s*)?\(/) || !j(',')) break; if (b = this.condition(), !b) break; c = new w.Condition('or', c || a, b, d); } return c || a; } },
-        condition() { let a; let b; let c; let d; const e = this.entities; const f = x; let g = !1; return i(/^not/) && (g = !0), m('('), a = this.addition() || e.keyword() || e.quoted(), a ? (d = i(/^(?:>=|<=|=<|[<=>])/), d ? (b = this.addition() || e.keyword() || e.quoted(), b ? c = new w.Condition(d, a, b, f, g) : n('expected expression')) : c = new w.Condition('=', a, new w.Keyword('true'), f, g), m(')'), i(/^and/) ? new w.Condition('and', c, this.condition()) : c) : void 0; },
-        operand() { let a; const b = this.entities; const c = u.charAt(x + 1); u.charAt(x) !== '-' || c !== '@' && c !== '(' || (a = j('-')); let d = this.sub() || b.dimension() || b.color() || b.variable() || b.call(); return a && (d.parensInOp = !0, d = new w.Negative(d)), d; },
-        expression() { let a; let b; const c = []; do a = this.addition() || this.entity(), a && (c.push(a), o(/^\/[\/*]/) || (b = j('/'), b && c.push(new w.Anonymous(b)))); while (a); return c.length > 0 ? new w.Expression(c) : void 0; },
-        property() { const a = i(/^(\*?-?[_a-zA-Z0-9-]+)\s*:/); return a ? a[1] : void 0; },
-        ruleProperty() { function b(a) { const b = a.exec(e); return b ? (g.push(x + h), h += b[0].length, e = e.slice(b[1].length), f.push(b[1])) : void 0; } let c; let d; var e = D; var f = []; var g = []; var h = 0; for (b(/^(\*?)/); b(/^((?:[\w-]+)|(?:@\{[\w-]+\}))/););if (f.length > 1 && b(/^\s*(\+?)\s*:/)) { for (k(h), f[0] === '' && (f.shift(), g.shift()), d = 0; d < f.length; d++)c = f[d], f[d] = c.charAt(0) !== '@' ? new w.Keyword(c) : new w.Variable(`@${c.slice(2, -1)}`, g[d], a.currentFileInfo); return f; } },
-      },
-    };
-  }, v.Parser.serializeVars = function (a) { let b = ''; for (const c in a) if (Object.hasOwnProperty.call(a, c)) { const d = a[c]; b += `${(c[0] === '@' ? '' : '@') + c}: ${d}${(`${d}`).slice(-1) === ';' ? '' : ';'}`; } return b; }, (function (d) {
-    function e(a, b, c) { if (!(c instanceof d.Dimension)) throw { type: 'Argument', message: 'argument must be a number' }; return b == null ? b = c.unit : c = c.unify(), new d.Dimension(a(parseFloat(c.value)), b); } function f(a, b, c) { let e; let f; let g; let h; const i = b.alpha; const j = c.alpha; const k = []; g = j + i * (1 - j); for (let l = 0; l < 3; l++)e = b.rgb[l] / 255, f = c.rgb[l] / 255, h = a(e, f), g && (h = (j * f + i * (e - j * (e + f - h))) / g), k[l] = 255 * h; return new d.Color(k, g); } function g() { let a; const b = d.functions; for (a in l)l.hasOwnProperty(a) && (b[a] = e.bind(null, Math[a], l[a])); for (a in m)m.hasOwnProperty(a) && (b[a] = f.bind(null, m[a])); a = d.defaultFunc, b.default = a.eval.bind(a); } function h(a) { return d.functions.hsla(a.h, a.s, a.l, a.a); } function i(a, b) { return a instanceof d.Dimension && a.unit.is('%') ? parseFloat(a.value * b / 100) : j(a); } function j(a) { if (a instanceof d.Dimension) return parseFloat(a.unit.is('%') ? a.value / 100 : a.value); if (typeof a === 'number') return a; throw { error: 'RuntimeError', message: 'color functions take numbers as parameters' }; } function k(a) { return Math.min(1, Math.max(0, a)); }d.functions = {
-      rgb(a, b, c) { return this.rgba(a, b, c, 1); },
-      rgba(a, b, c, e) { const f = [a, b, c].map((a) => i(a, 255)); return e = j(e), new d.Color(f, e); },
-      hsl(a, b, c) { return this.hsla(a, b, c, 1); },
-      hsla(a, b, c, d) { function e(a) { return a = a < 0 ? a + 1 : a > 1 ? a - 1 : a, 6 * a < 1 ? g + (f - g) * a * 6 : 2 * a < 1 ? f : 3 * a < 2 ? g + (f - g) * (2 / 3 - a) * 6 : g; }a = j(a) % 360 / 360, b = k(j(b)), c = k(j(c)), d = k(j(d)); var f = c <= 0.5 ? c * (b + 1) : c + b - c * b; var g = 2 * c - f; return this.rgba(255 * e(a + 1 / 3), 255 * e(a), 255 * e(a - 1 / 3), d); },
-      hsv(a, b, c) { return this.hsva(a, b, c, 1); },
-      hsva(a, b, c, d) { a = j(a) % 360 / 360 * 360, b = j(b), c = j(c), d = j(d); let e; let f; e = Math.floor(a / 60 % 6), f = a / 60 - e; const g = [c, c * (1 - b), c * (1 - f * b), c * (1 - (1 - f) * b)]; const h = [[0, 3, 1], [2, 0, 1], [1, 0, 3], [1, 2, 0], [3, 1, 0], [0, 1, 2]]; return this.rgba(255 * g[h[e][0]], 255 * g[h[e][1]], 255 * g[h[e][2]], d); },
-      hue(a) { return new d.Dimension(Math.round(a.toHSL().h)); },
-      saturation(a) { return new d.Dimension(Math.round(100 * a.toHSL().s), '%'); },
-      lightness(a) { return new d.Dimension(Math.round(100 * a.toHSL().l), '%'); },
-      hsvhue(a) { return new d.Dimension(Math.round(a.toHSV().h)); },
-      hsvsaturation(a) { return new d.Dimension(Math.round(100 * a.toHSV().s), '%'); },
-      hsvvalue(a) { return new d.Dimension(Math.round(100 * a.toHSV().v), '%'); },
-      red(a) { return new d.Dimension(a.rgb[0]); },
-      green(a) { return new d.Dimension(a.rgb[1]); },
-      blue(a) { return new d.Dimension(a.rgb[2]); },
-      alpha(a) { return new d.Dimension(a.toHSL().a); },
-      luma(a) { return new d.Dimension(Math.round(a.luma() * a.alpha * 100), '%'); },
-      saturate(a, b) { if (!a.rgb) return null; const c = a.toHSL(); return c.s += b.value / 100, c.s = k(c.s), h(c); },
-      desaturate(a, b) { const c = a.toHSL(); return c.s -= b.value / 100, c.s = k(c.s), h(c); },
-      lighten(a, b) { const c = a.toHSL(); return c.l += b.value / 100, c.l = k(c.l), h(c); },
-      darken(a, b) { const c = a.toHSL(); return c.l -= b.value / 100, c.l = k(c.l), h(c); },
-      fadein(a, b) { const c = a.toHSL(); return c.a += b.value / 100, c.a = k(c.a), h(c); },
-      fadeout(a, b) { const c = a.toHSL(); return c.a -= b.value / 100, c.a = k(c.a), h(c); },
-      fade(a, b) { const c = a.toHSL(); return c.a = b.value / 100, c.a = k(c.a), h(c); },
-      spin(a, b) { const c = a.toHSL(); const d = (c.h + b.value) % 360; return c.h = d < 0 ? 360 + d : d, h(c); },
-      mix(a, b, c) { c || (c = new d.Dimension(50)); const e = c.value / 100; const f = 2 * e - 1; const g = a.toHSL().a - b.toHSL().a; const h = ((f * g == -1 ? f : (f + g) / (1 + f * g)) + 1) / 2; const i = 1 - h; const j = [a.rgb[0] * h + b.rgb[0] * i, a.rgb[1] * h + b.rgb[1] * i, a.rgb[2] * h + b.rgb[2] * i]; const k = a.alpha * e + b.alpha * (1 - e); return new d.Color(j, k); },
-      greyscale(a) { return this.desaturate(a, new d.Dimension(100)); },
-      contrast(a, b, c, d) { if (!a.rgb) return null; if (typeof c === 'undefined' && (c = this.rgba(255, 255, 255, 1)), typeof b === 'undefined' && (b = this.rgba(0, 0, 0, 1)), b.luma() > c.luma()) { const e = c; c = b, b = e; } return d = typeof d === 'undefined' ? 0.43 : j(d), a.luma() < d ? c : b; },
-      e(a) { return new d.Anonymous(a instanceof d.JavaScript ? a.evaluated : a); },
-      escape(a) {
-        return new d.Anonymous(encodeURI(a.value).replace(/=/g, '%3D').replace(/:/g, '%3A').replace(/#/g, '%23')
-          .replace(/;/g, '%3B')
-          .replace(/\(/g, '%28')
-          .replace(/\)/g, '%29'));
-      },
-      '%': function (a) { for (var b = Array.prototype.slice.call(arguments, 1), c = a.value, e = 0; e < b.length; e++)c = c.replace(/%[sda]/i, (a) => { const c = a.match(/s/i) ? b[e].value : b[e].toCSS(); return a.match(/[A-Z]$/) ? encodeURIComponent(c) : c; }); return c = c.replace(/%%/g, '%'), new d.Quoted(`"${c}"`, c); },
-      unit(a, b) { if (!(a instanceof d.Dimension)) throw { type: 'Argument', message: `the first argument to unit must be a number${a instanceof d.Operation ? '. Have you forgotten parenthesis?' : ''}` }; return new d.Dimension(a.value, b ? b.toCSS() : ''); },
-      convert(a, b) { return a.convertTo(b.value); },
-      round(a, b) { const c = typeof b === 'undefined' ? 0 : b.value; return e((a) => a.toFixed(c), null, a); },
-      pi() { return new d.Dimension(Math.PI); },
-      mod(a, b) { return new d.Dimension(a.value % b.value, a.unit); },
-      pow(a, b) {
-        if (typeof a === 'number' && typeof b === 'number')a = new d.Dimension(a), b = new d.Dimension(b); else if (!(a instanceof d.Dimension && b instanceof d.Dimension)) throw { type: 'Argument', message: 'arguments must be numbers' }; return new d.Dimension(Math.pow(a.value, b.value), a.unit);
-      },
-      _minmax(a, c) { switch (c = Array.prototype.slice.call(c), c.length) { case 0: throw { type: 'Argument', message: 'one or more arguments required' }; case 1: return c[0]; } let e; let f; let g; let h; let i; let j; const k = []; const l = {}; for (e = 0; e < c.length; e++)g = c[e], g instanceof d.Dimension ? (h = g.unify(), j = h.unit.toString(), f = l[j], f !== b ? (i = k[f].unify(), (a && h.value < i.value || !a && h.value > i.value) && (k[f] = g)) : (l[j] = k.length, k.push(g))) : k.push(g); return k.length == 1 ? k[0] : (c = k.map(function (a) { return a.toCSS(this.env); }).join(this.env.compress ? ',' : ', '), new d.Anonymous(`${a ? 'min' : 'max'}(${c})`)); },
-      min() { return this._minmax(!0, arguments); },
-      max() { return this._minmax(!1, arguments); },
-      argb(a) { return new d.Anonymous(a.toARGB()); },
-      percentage(a) { return new d.Dimension(100 * a.value, '%'); },
-      color(a) { if (a instanceof d.Quoted) { let b; const c = a.value; if (b = d.Color.fromKeyword(c)) return b; if (/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/.test(c)) return new d.Color(c.slice(1)); throw { type: 'Argument', message: 'argument must be a color keyword or 3/6 digit hex e.g. #FFF' }; } throw { type: 'Argument', message: 'argument must be a string' }; },
-      iscolor(a) { return this._isa(a, d.Color); },
-      isnumber(a) { return this._isa(a, d.Dimension); },
-      isstring(a) { return this._isa(a, d.Quoted); },
-      iskeyword(a) { return this._isa(a, d.Keyword); },
-      isurl(a) { return this._isa(a, d.URL); },
-      ispixel(a) { return this.isunit(a, 'px'); },
-      ispercentage(a) { return this.isunit(a, '%'); },
-      isem(a) { return this.isunit(a, 'em'); },
-      isunit(a, b) { return a instanceof d.Dimension && a.unit.is(b.value || b) ? d.True : d.False; },
-      _isa(a, b) { return a instanceof b ? d.True : d.False; },
-      tint(a, b) { return this.mix(this.rgb(255, 255, 255), a, b); },
-      shade(a, b) { return this.mix(this.rgb(0, 0, 0), a, b); },
-      extract(a, b) { return b = b.value - 1, Array.isArray(a.value) ? a.value[b] : Array(a)[b]; },
-      length(a) { const b = Array.isArray(a.value) ? a.value.length : 1; return new d.Dimension(b); },
-      'data-uri': function (b, e) { if (typeof a !== 'undefined') return new d.URL(e || b, this.currentFileInfo).eval(this.env); let f = b.value; let g = e && e.value; const h = c('fs'); const i = c('path'); let j = !1; if (arguments.length < 2 && (g = f), this.env.isPathRelative(g) && (g = this.currentFileInfo.relativeUrls ? i.join(this.currentFileInfo.currentDirectory, g) : i.join(this.currentFileInfo.entryPath, g)), arguments.length < 2) { let k; try { k = c('mime'); } catch (l) { k = d._mime; }f = k.lookup(g); const m = k.charsets.lookup(f); j = ['US-ASCII', 'UTF-8'].indexOf(m) < 0, j && (f += ';base64'); } else j = /;base64$/.test(f); let n = h.readFileSync(g); const o = 32; const p = parseInt(n.length / 1024, 10); if (p >= o && this.env.ieCompat !== !1) return this.env.silent || console.warn('Skipped data-uri embedding of %s because its size (%dKB) exceeds IE8-safe %dKB!', g, p, o), new d.URL(e || b, this.currentFileInfo).eval(this.env); n = j ? n.toString('base64') : encodeURIComponent(n); const q = `"data:${f},${n}"`; return new d.URL(new d.Anonymous(q)); },
-      'svg-gradient': function (a) { function e() { throw { type: 'Argument', message: 'svg-gradient expects direction, start_color [start_position], [color position,]..., end_color [end_position]' }; }arguments.length < 3 && e(); let f; let g; let h; let i; let j; let k; let l; const m = Array.prototype.slice.call(arguments, 1); let n = 'linear'; let o = 'x="0" y="0" width="1" height="1"'; let p = !0; const q = { compress: !1 }; const r = a.toCSS(q); switch (r) { case 'to bottom': f = 'x1="0%" y1="0%" x2="0%" y2="100%"'; break; case 'to right': f = 'x1="0%" y1="0%" x2="100%" y2="0%"'; break; case 'to bottom right': f = 'x1="0%" y1="0%" x2="100%" y2="100%"'; break; case 'to top right': f = 'x1="0%" y1="100%" x2="100%" y2="0%"'; break; case 'ellipse': case 'ellipse at center': n = 'radial', f = 'cx="50%" cy="50%" r="75%"', o = 'x="-50" y="-50" width="101" height="101"'; break; default: throw { type: 'Argument', message: "svg-gradient direction must be 'to bottom', 'to right', 'to bottom right', 'to top right' or 'ellipse at center'" }; } for (g = `<?xml version="1.0" ?><svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" viewBox="0 0 1 1" preserveAspectRatio="none"><${n}Gradient id="gradient" gradientUnits="userSpaceOnUse" ${f}>`, h = 0; h < m.length; h += 1)m[h].value ? (i = m[h].value[0], j = m[h].value[1]) : (i = m[h], j = b), i instanceof d.Color && ((h === 0 || h + 1 === m.length) && j === b || j instanceof d.Dimension) || e(), k = j ? j.toCSS(q) : h === 0 ? '0%' : '100%', l = i.alpha, g += `<stop offset="${k}" stop-color="${i.toRGB()}"${l < 1 ? ` stop-opacity="${l}"` : ''}/>`; if (g += `</${n}Gradient><rect ${o} fill="url(#gradient)" /></svg>`, p) try { g = c('./encoder').encodeBase64(g); } catch (s) { p = !1; } return g = `'data:image/svg+xml${p ? ';base64' : ''},${g}'`, new d.URL(new d.Anonymous(g)); },
-    }, d._mime = {
-      _types: {
-        '.htm': 'text/html', '.html': 'text/html', '.gif': 'image/gif', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
-      },
-      lookup(a) { const e = c('path').extname(a); const f = d._mime._types[e]; if (f === b) throw new Error(`Optional dependency "mime" is required for ${e}`); return f; },
-      charsets: { lookup(a) { return a && /^text\//.test(a) ? 'UTF-8' : ''; } },
-    }; var l = {
-      ceil: null, floor: null, sqrt: null, abs: null, tan: '', sin: '', cos: '', atan: 'rad', asin: 'rad', acos: 'rad',
-    }; var m = {
-      multiply(a, b) { return a * b; }, screen(a, b) { return a + b - a * b; }, overlay(a, b) { return a *= 2, a <= 1 ? m.multiply(a, b) : m.screen(a - 1, b); }, softlight(a, b) { let c = 1; let d = a; return b > 0.5 && (d = 1, c = a > 0.25 ? Math.sqrt(a) : ((16 * a - 12) * a + 4) * a), a - (1 - 2 * b) * d * (c - a); }, hardlight(a, b) { return m.overlay(b, a); }, difference(a, b) { return Math.abs(a - b); }, exclusion(a, b) { return a + b - 2 * a * b; }, average(a, b) { return (a + b) / 2; }, negation(a, b) { return 1 - Math.abs(a + b - 1); },
-    }; d.defaultFunc = {
-      eval() { const a = this.value_; const b = this.error_; if (b) throw b; return a != null ? a ? d.True : d.False : void 0; }, value(a) { this.value_ = a; }, error(a) { this.error_ = a; }, reset() { this.value_ = this.error_ = null; },
-    }, g(), d.fround = function (a, b) { let c; return a && a.numPrecision != null ? (c = Math.pow(10, a.numPrecision), Math.round(b * c) / c) : b; }, d.functionCall = function (a, b) { this.env = a, this.currentFileInfo = b; }, d.functionCall.prototype = d.functions;
-  }(c('./tree'))), (function (a) {
-    a.colors = {
-      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', darkgrey: '#a9a9a9', darkgreen: '#006400', 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', grey: '#808080', green: '#008000', greenyellow: '#adff2f', 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', lightgrey: '#d3d3d3', lightgreen: '#90ee90', 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: '#9370d8', 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: '#d87093', papayawhip: '#ffefd5', peachpuff: '#ffdab9', peru: '#cd853f', pink: '#ffc0cb', plum: '#dda0dd', powderblue: '#b0e0e6', purple: '#800080', 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',
-    };
-  }(c('./tree'))), (function (a) { a.debugInfo = function (b, c, d) { let e = ''; if (b.dumpLineNumbers && !b.compress) switch (b.dumpLineNumbers) { case 'comments': e = a.debugInfo.asComment(c); break; case 'mediaquery': e = a.debugInfo.asMediaQuery(c); break; case 'all': e = a.debugInfo.asComment(c) + (d || '') + a.debugInfo.asMediaQuery(c); } return e; }, a.debugInfo.asComment = function (a) { return `/* line ${a.debugInfo.lineNumber}, ${a.debugInfo.fileName} */\n`; }, a.debugInfo.asMediaQuery = function (a) { return `@media -sass-debug-info{filename{font-family:${(`file://${a.debugInfo.fileName}`).replace(/([.:\/\\])/g, (a) => (a == '\\' && (a = '/'), `\\${a}`))}}line{font-family:\\00003${a.debugInfo.lineNumber}}}\n`; }, a.find = function (a, b) { for (var c, d = 0; d < a.length; d++) if (c = b.call(a, a[d])) return c; return null; }, a.jsify = function (a) { return Array.isArray(a.value) && a.value.length > 1 ? `[${a.value.map((a) => a.toCSS(!1)).join(', ')}]` : a.toCSS(!1); }, a.toCSS = function (a) { const b = []; return this.genCSS(a, { add(a) { b.push(a); }, isEmpty() { return b.length === 0; } }), b.join(''); }, a.outputRuleset = function (a, b, c) { let d; const e = c.length; if (a.tabLevel = (0 | a.tabLevel) + 1, a.compress) { for (b.add('{'), d = 0; e > d; d++)c[d].genCSS(a, b); return b.add('}'), a.tabLevel--, void 0; } const f = `\n${Array(a.tabLevel).join('  ')}`; const g = `${f}  `; if (e) { for (b.add(` {${g}`), c[0].genCSS(a, b), d = 1; e > d; d++)b.add(g), c[d].genCSS(a, b); b.add(`${f}}`); } else b.add(` {${f}}`); a.tabLevel--; }; }(c('./tree'))), (function (a) {
-    a.Alpha = function (a) { this.value = a; }, a.Alpha.prototype = {
-      type: 'Alpha', accept(a) { this.value = a.visit(this.value); }, eval(b) { return this.value.eval ? new a.Alpha(this.value.eval(b)) : this; }, genCSS(a, b) { b.add('alpha(opacity='), this.value.genCSS ? this.value.genCSS(a, b) : b.add(this.value), b.add(')'); }, toCSS: a.toCSS,
-    };
-  }(c('../tree'))), (function (a) {
-    a.Anonymous = function (a, b, c, d) { this.value = a.value || a, this.index = b, this.mapLines = d, this.currentFileInfo = c; }, a.Anonymous.prototype = {
-      type: 'Anonymous', eval() { return new a.Anonymous(this.value, this.index, this.currentFileInfo, this.mapLines); }, compare(a) { if (!a.toCSS) return -1; const b = this.toCSS(); const c = a.toCSS(); return b === c ? 0 : c > b ? -1 : 1; }, genCSS(a, b) { b.add(this.value, this.currentFileInfo, this.index, this.mapLines); }, toCSS: a.toCSS,
-    };
-  }(c('../tree'))), (function (a) {
-    a.Assignment = function (a, b) { this.key = a, this.value = b; }, a.Assignment.prototype = {
-      type: 'Assignment', accept(a) { this.value = a.visit(this.value); }, eval(b) { return this.value.eval ? new a.Assignment(this.key, this.value.eval(b)) : this; }, genCSS(a, b) { b.add(`${this.key}=`), this.value.genCSS ? this.value.genCSS(a, b) : b.add(this.value); }, toCSS: a.toCSS,
-    };
-  }(c('../tree'))), (function (a) {
-    a.Call = function (a, b, c, d) { this.name = a, this.args = b, this.index = c, this.currentFileInfo = d; }, a.Call.prototype = {
-      type: 'Call',
-      accept(a) { this.args && (this.args = a.visitArray(this.args)); },
-      eval(b) {
-        let c; let d; const e = this.args.map((a) => a.eval(b)); const f = this.name.toLowerCase(); if (f in a.functions) {
-          try { if (d = new a.functionCall(b, this.currentFileInfo), c = d[f].apply(d, e), c != null) return c; } catch (g) {
-            throw {
-              type: g.type || 'Runtime', message: `error evaluating function \`${this.name}\`${g.message ? `: ${g.message}` : ''}`, index: this.index, filename: this.currentFileInfo.filename,
-            };
-          }
-        } return new a.Call(this.name, e, this.index, this.currentFileInfo);
-      },
-      genCSS(a, b) { b.add(`${this.name}(`, this.currentFileInfo, this.index); for (let c = 0; c < this.args.length; c++) this.args[c].genCSS(a, b), c + 1 < this.args.length && b.add(', '); b.add(')'); },
-      toCSS: a.toCSS,
-    };
-  }(c('../tree'))), (function (a) {
-    function b(a) { return `#${a.map((a) => (a = c(Math.round(a), 255), (a < 16 ? '0' : '') + a.toString(16))).join('')}`; } function c(a, b) { return Math.min(Math.max(a, 0), b); }a.Color = function (a, b) { this.rgb = Array.isArray(a) ? a : a.length == 6 ? a.match(/.{2}/g).map((a) => parseInt(a, 16)) : a.split('').map((a) => parseInt(a + a, 16)), this.alpha = typeof b === 'number' ? b : 1; }; const d = 'transparent'; a.Color.prototype = {
-      type: 'Color',
-      eval() { return this; },
-      luma() { return 0.2126 * this.rgb[0] / 255 + 0.7152 * this.rgb[1] / 255 + 0.0722 * this.rgb[2] / 255; },
-      genCSS(a, b) { b.add(this.toCSS(a)); },
-      toCSS(b, e) { const f = b && b.compress && !e; const g = a.fround(b, this.alpha); if (g < 1) return g === 0 && this.isTransparentKeyword ? d : `rgba(${this.rgb.map((a) => c(Math.round(a), 255)).concat(c(g, 1)).join(`,${f ? '' : ' '}`)})`; let h = this.toRGB(); if (f) { const i = h.split(''); i[1] === i[2] && i[3] === i[4] && i[5] === i[6] && (h = `#${i[1]}${i[3]}${i[5]}`); } return h; },
-      operate(b, c, d) { for (var e = [], f = this.alpha * (1 - d.alpha) + d.alpha, g = 0; g < 3; g++)e[g] = a.operate(b, c, this.rgb[g], d.rgb[g]); return new a.Color(e, f); },
-      toRGB() { return b(this.rgb); },
-      toHSL() {
-        let a; let b; const c = this.rgb[0] / 255; const d = this.rgb[1] / 255; const e = this.rgb[2] / 255; const f = this.alpha; const g = Math.max(c, d, e); const h = Math.min(c, d, e); const i = (g + h) / 2; const j = g - h; if (g === h)a = b = 0; else { switch (b = i > 0.5 ? j / (2 - g - h) : j / (g + h), g) { case c: a = (d - e) / j + (e > d ? 6 : 0); break; case d: a = (e - c) / j + 2; break; case e: a = (c - d) / j + 4; }a /= 6; } return {
-          h: 360 * a, s: b, l: i, a: f,
-        };
-      },
-      toHSV() {
-        let a; let b; const c = this.rgb[0] / 255; const d = this.rgb[1] / 255; const e = this.rgb[2] / 255; const f = this.alpha; const g = Math.max(c, d, e); const h = Math.min(c, d, e); const i = g; const j = g - h; if (b = g === 0 ? 0 : j / g, g === h)a = 0; else { switch (g) { case c: a = (d - e) / j + (e > d ? 6 : 0); break; case d: a = (e - c) / j + 2; break; case e: a = (c - d) / j + 4; }a /= 6; } return {
-          h: 360 * a, s: b, v: i, a: f,
-        };
-      },
-      toARGB() { return b([255 * this.alpha].concat(this.rgb)); },
-      compare(a) { return a.rgb ? a.rgb[0] === this.rgb[0] && a.rgb[1] === this.rgb[1] && a.rgb[2] === this.rgb[2] && a.alpha === this.alpha ? 0 : -1 : -1; },
-    }, a.Color.fromKeyword = function (b) { if (b = b.toLowerCase(), a.colors.hasOwnProperty(b)) return new a.Color(a.colors[b].slice(1)); if (b === d) { const c = new a.Color([0, 0, 0], 0); return c.isTransparentKeyword = !0, c; } };
-  }(c('../tree'))), (function (a) {
-    a.Comment = function (a, b, c, d) { this.value = a, this.silent = !!b, this.currentFileInfo = d; }, a.Comment.prototype = {
-      type: 'Comment', genCSS(b, c) { this.debugInfo && c.add(a.debugInfo(b, this), this.currentFileInfo, this.index), c.add(this.value.trim()); }, toCSS: a.toCSS, isSilent(a) { const b = this.currentFileInfo && this.currentFileInfo.reference && !this.isReferenced; const c = a.compress && !this.value.match(/^\/\*!/); return this.silent || b || c; }, eval() { return this; }, markReferenced() { this.isReferenced = !0; },
-    };
-  }(c('../tree'))), (function (a) { a.Condition = function (a, b, c, d, e) { this.op = a.trim(), this.lvalue = b, this.rvalue = c, this.index = d, this.negate = e; }, a.Condition.prototype = { type: 'Condition', accept(a) { this.lvalue = a.visit(this.lvalue), this.rvalue = a.visit(this.rvalue); }, eval(a) { let b; const c = this.lvalue.eval(a); const d = this.rvalue.eval(a); const e = this.index; return b = (function (a) { switch (a) { case 'and': return c && d; case 'or': return c || d; default: if (c.compare)b = c.compare(d); else { if (!d.compare) throw { type: 'Type', message: 'Unable to perform comparison', index: e }; b = d.compare(c); } switch (b) { case -1: return a === '<' || a === '=<' || a === '<='; case 0: return a === '=' || a === '>=' || a === '=<' || a === '<='; case 1: return a === '>' || a === '>='; } } }(this.op)), this.negate ? !b : b; } }; }(c('../tree'))), (function (a) {
-    a.Dimension = function (c, d) { this.value = parseFloat(c), this.unit = d && d instanceof a.Unit ? d : new a.Unit(d ? [d] : b); }, a.Dimension.prototype = {
-      type: 'Dimension', accept(a) { this.unit = a.visit(this.unit); }, eval() { return this; }, toColor() { return new a.Color([this.value, this.value, this.value]); }, genCSS(b, c) { if (b && b.strictUnits && !this.unit.isSingular()) throw new Error(`Multiple units in dimension. Correct the units or use the unit function. Bad unit: ${this.unit.toString()}`); const d = a.fround(b, this.value); let e = String(d); if (d !== 0 && d < 1e-6 && d > -1e-6 && (e = d.toFixed(20).replace(/0+$/, '')), b && b.compress) { if (d === 0 && this.unit.isLength()) return c.add(e), void 0; d > 0 && d < 1 && (e = e.substr(1)); }c.add(e), this.unit.genCSS(b, c); }, toCSS: a.toCSS, operate(b, c, d) { let e = a.operate(b, c, this.value, d.value); const f = this.unit.clone(); if (c === '+' || c === '-') if (f.numerator.length === 0 && f.denominator.length === 0)f.numerator = d.unit.numerator.slice(0), f.denominator = d.unit.denominator.slice(0); else if (d.unit.numerator.length === 0 && f.denominator.length === 0);else { if (d = d.convertTo(this.unit.usedUnits()), b.strictUnits && d.unit.toString() !== f.toString()) throw new Error(`Incompatible units. Change the units or use the unit function. Bad units: '${f.toString()}' and '${d.unit.toString()}'.`); e = a.operate(b, c, this.value, d.value); } else c === '*' ? (f.numerator = f.numerator.concat(d.unit.numerator).sort(), f.denominator = f.denominator.concat(d.unit.denominator).sort(), f.cancel()) : c === '/' && (f.numerator = f.numerator.concat(d.unit.denominator).sort(), f.denominator = f.denominator.concat(d.unit.numerator).sort(), f.cancel()); return new a.Dimension(e, f); }, compare(b) { if (b instanceof a.Dimension) { const c = this.unify(); const d = b.unify(); const e = c.value; const f = d.value; return f > e ? -1 : e > f ? 1 : d.unit.isEmpty() || c.unit.compare(d.unit) === 0 ? 0 : -1; } return -1; }, unify() { return this.convertTo({ length: 'm', duration: 's', angle: 'rad' }); }, convertTo(b) { let c; let d; let e; let f; let g; let h = this.value; const i = this.unit.clone(); let j = {}; if (typeof b === 'string') { for (c in a.UnitConversions)a.UnitConversions[c].hasOwnProperty(b) && (j = {}, j[c] = b); b = j; }g = function (a, b) { return e.hasOwnProperty(a) ? (b ? h /= e[a] / e[f] : h *= e[a] / e[f], f) : a; }; for (d in b)b.hasOwnProperty(d) && (f = b[d], e = a.UnitConversions[d], i.map(g)); return i.cancel(), new a.Dimension(h, i); },
-    }, a.UnitConversions = {
-      length: {
-        m: 1, cm: 0.01, mm: 0.001, in: 0.0254, pt: 0.0254 / 72, pc: 0.0254 / 72 * 12,
-      },
-      duration: { s: 1, ms: 0.001 },
-      angle: {
-        rad: 1 / (2 * Math.PI), deg: 1 / 360, grad: 0.0025, turn: 1,
-      },
-    }, a.Unit = function (a, b, c) { this.numerator = a ? a.slice(0).sort() : [], this.denominator = b ? b.slice(0).sort() : [], this.backupUnit = c; }, a.Unit.prototype = {
-      type: 'Unit', clone() { return new a.Unit(this.numerator.slice(0), this.denominator.slice(0), this.backupUnit); }, genCSS(a, b) { this.numerator.length >= 1 ? b.add(this.numerator[0]) : this.denominator.length >= 1 ? b.add(this.denominator[0]) : a && a.strictUnits || !this.backupUnit || b.add(this.backupUnit); }, toCSS: a.toCSS, toString() { let a; let b = this.numerator.join('*'); for (a = 0; a < this.denominator.length; a++)b += `/${this.denominator[a]}`; return b; }, compare(a) { return this.is(a.toString()) ? 0 : -1; }, is(a) { return this.toString() === a; }, isLength() { return Boolean(this.toCSS().match(/px|em|%|in|cm|mm|pc|pt|ex/)); }, isEmpty() { return this.numerator.length === 0 && this.denominator.length === 0; }, isSingular() { return this.numerator.length <= 1 && this.denominator.length === 0; }, map(a) { let b; for (b = 0; b < this.numerator.length; b++) this.numerator[b] = a(this.numerator[b], !1); for (b = 0; b < this.denominator.length; b++) this.denominator[b] = a(this.denominator[b], !0); }, usedUnits() { let b; let c; const d = {}; c = function (a) { return b.hasOwnProperty(a) && !d[e] && (d[e] = a), a; }; for (var e in a.UnitConversions)a.UnitConversions.hasOwnProperty(e) && (b = a.UnitConversions[e], this.map(c)); return d; }, cancel() { let a; let b; let c; const d = {}; for (b = 0; b < this.numerator.length; b++)a = this.numerator[b], c || (c = a), d[a] = (d[a] || 0) + 1; for (b = 0; b < this.denominator.length; b++)a = this.denominator[b], c || (c = a), d[a] = (d[a] || 0) - 1; this.numerator = [], this.denominator = []; for (a in d) if (d.hasOwnProperty(a)) { const e = d[a]; if (e > 0) for (b = 0; e > b; b++) this.numerator.push(a); else if (e < 0) for (b = 0; -e > b; b++) this.denominator.push(a); } this.numerator.length === 0 && this.denominator.length === 0 && c && (this.backupUnit = c), this.numerator.sort(), this.denominator.sort(); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Directive = function (b, c, d, e) { this.name = b, Array.isArray(c) ? (this.rules = [new a.Ruleset(null, c)], this.rules[0].allowImports = !0) : this.value = c, this.index = d, this.currentFileInfo = e; }, a.Directive.prototype = {
-      type: 'Directive', accept(a) { this.rules && (this.rules = a.visitArray(this.rules)), this.value && (this.value = a.visit(this.value)); }, genCSS(b, c) { c.add(this.name, this.currentFileInfo, this.index), this.rules ? a.outputRuleset(b, c, this.rules) : (c.add(' '), this.value.genCSS(b, c), c.add(';')); }, toCSS: a.toCSS, eval(b) { let c = this; return this.rules && (b.frames.unshift(this), c = new a.Directive(this.name, null, this.index, this.currentFileInfo), c.rules = [this.rules[0].eval(b)], c.rules[0].root = !0, b.frames.shift()), c; }, variable(b) { return a.Ruleset.prototype.variable.call(this.rules[0], b); }, find() { return a.Ruleset.prototype.find.apply(this.rules[0], arguments); }, rulesets() { return a.Ruleset.prototype.rulesets.apply(this.rules[0]); }, markReferenced() { let a; let b; if (this.isReferenced = !0, this.rules) for (b = this.rules[0].rules, a = 0; a < b.length; a++)b[a].markReferenced && b[a].markReferenced(); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Element = function (b, c, d, e) { this.combinator = b instanceof a.Combinator ? b : new a.Combinator(b), this.value = typeof c === 'string' ? c.trim() : c || '', this.index = d, this.currentFileInfo = e; }, a.Element.prototype = {
-      type: 'Element', accept(a) { const b = this.value; this.combinator = a.visit(this.combinator), typeof b === 'object' && (this.value = a.visit(b)); }, eval(b) { return new a.Element(this.combinator, this.value.eval ? this.value.eval(b) : this.value, this.index, this.currentFileInfo); }, genCSS(a, b) { b.add(this.toCSS(a), this.currentFileInfo, this.index); }, toCSS(a) { const b = this.value.toCSS ? this.value.toCSS(a) : this.value; return b === '' && this.combinator.value.charAt(0) === '&' ? '' : this.combinator.toCSS(a || {}) + b; },
-    }, a.Attribute = function (a, b, c) { this.key = a, this.op = b, this.value = c; }, a.Attribute.prototype = {
-      type: 'Attribute', eval(b) { return new a.Attribute(this.key.eval ? this.key.eval(b) : this.key, this.op, this.value && this.value.eval ? this.value.eval(b) : this.value); }, genCSS(a, b) { b.add(this.toCSS(a)); }, toCSS(a) { let b = this.key.toCSS ? this.key.toCSS(a) : this.key; return this.op && (b += this.op, b += this.value.toCSS ? this.value.toCSS(a) : this.value), `[${b}]`; },
-    }, a.Combinator = function (a) { this.value = a === ' ' ? ' ' : a ? a.trim() : ''; }, a.Combinator.prototype = {
-      type: 'Combinator',
-      _outputMap: {
-        '': '', ' ': ' ', ':': ' :', '+': ' + ', '~': ' ~ ', '>': ' > ', '|': '|', '^': ' ^ ', '^^': ' ^^ ',
-      },
-      _outputMapCompressed: {
-        '': '', ' ': ' ', ':': ' :', '+': '+', '~': '~', '>': '>', '|': '|', '^': '^', '^^': '^^',
-      },
-      genCSS(a, b) { b.add((a.compress ? this._outputMapCompressed : this._outputMap)[this.value]); },
-      toCSS: a.toCSS,
-    };
-  }(c('../tree'))), (function (a) {
-    a.Expression = function (a) { this.value = a; }, a.Expression.prototype = {
-      type: 'Expression', accept(a) { this.value && (this.value = a.visitArray(this.value)); }, eval(b) { let c; const d = this.parens && !this.parensInOp; let e = !1; return d && b.inParenthesis(), this.value.length > 1 ? c = new a.Expression(this.value.map((a) => a.eval(b))) : this.value.length === 1 ? (this.value[0].parens && !this.value[0].parensInOp && (e = !0), c = this.value[0].eval(b)) : c = this, d && b.outOfParenthesis(), this.parens && this.parensInOp && !b.isMathOn() && !e && (c = new a.Paren(c)), c; }, genCSS(a, b) { for (let c = 0; c < this.value.length; c++) this.value[c].genCSS(a, b), c + 1 < this.value.length && b.add(' '); }, toCSS: a.toCSS, throwAwayComments() { this.value = this.value.filter((b) => !(b instanceof a.Comment)); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Extend = function (b, c, d) { switch (this.selector = b, this.option = c, this.index = d, this.object_id = a.Extend.next_id++, this.parent_ids = [this.object_id], c) { case 'all': this.allowBefore = !0, this.allowAfter = !0; break; default: this.allowBefore = !1, this.allowAfter = !1; } }, a.Extend.next_id = 0, a.Extend.prototype = {
-      type: 'Extend', accept(a) { this.selector = a.visit(this.selector); }, eval(b) { return new a.Extend(this.selector.eval(b), this.option, this.index); }, clone() { return new a.Extend(this.selector, this.option, this.index); }, findSelfSelectors(a) { let b; let c; let d = []; for (b = 0; b < a.length; b++)c = a[b].elements, b > 0 && c.length && c[0].combinator.value === '' && (c[0].combinator.value = ' '), d = d.concat(a[b].elements); this.selfSelectors = [{ elements: d }]; },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Import = function (a, c, d, e, f) { if (this.options = d, this.index = e, this.path = a, this.features = c, this.currentFileInfo = f, this.options.less !== b || this.options.inline) this.css = !this.options.less || this.options.inline; else { const g = this.getPath(); g && /css([\?;].*)?$/.test(g) && (this.css = !0); } }, a.Import.prototype = {
-      type: 'Import', accept(a) { this.features && (this.features = a.visit(this.features)), this.path = a.visit(this.path), !this.options.inline && this.root && (this.root = a.visit(this.root)); }, genCSS(a, b) { this.css && (b.add('@import ', this.currentFileInfo, this.index), this.path.genCSS(a, b), this.features && (b.add(' '), this.features.genCSS(a, b)), b.add(';')); }, toCSS: a.toCSS, getPath() { if (this.path instanceof a.Quoted) { const c = this.path.value; return this.css !== b || /(\.[a-z]*$)|([\?;].*)$/.test(c) ? c : `${c}.less`; } return this.path instanceof a.URL ? this.path.value.value : null; }, evalForImport(b) { return new a.Import(this.path.eval(b), this.features, this.options, this.index, this.currentFileInfo); }, evalPath(b) { const c = this.path.eval(b); const d = this.currentFileInfo && this.currentFileInfo.rootpath; if (!(c instanceof a.URL)) { if (d) { const e = c.value; e && b.isPathRelative(e) && (c.value = d + e); }c.value = b.normalizePath(c.value); } return c; }, eval(b) { let c; const d = this.features && this.features.eval(b); if (this.skip) return []; if (this.options.inline) { const e = new a.Anonymous(this.root, 0, { filename: this.importedFilename }, !0); return this.features ? new a.Media([e], this.features.value) : [e]; } if (this.css) { const f = new a.Import(this.evalPath(b), d, this.options, this.index); if (!f.css && this.error) throw this.error; return f; } return c = new a.Ruleset(null, this.root.rules.slice(0)), c.evalImports(b), this.features ? new a.Media(c.rules, this.features.value) : c.rules; },
-    };
-  }(c('../tree'))), (function (a) { a.JavaScript = function (a, b, c) { this.escaped = c, this.expression = a, this.index = b; }, a.JavaScript.prototype = { type: 'JavaScript', eval(b) { let c; const d = this; const e = {}; let f = this.expression.replace(/@\{([\w-]+)\}/g, (c, e) => a.jsify(new a.Variable(`@${e}`, d.index).eval(b))); try { f = new Function(`return (${f})`); } catch (g) { throw { message: `JavaScript evaluation error: ${g.message} from \`${f}\``, index: this.index }; } const h = b.frames[0].variables(); for (const i in h)h.hasOwnProperty(i) && (e[i.slice(1)] = { value: h[i].value, toJS() { return this.value.eval(b).toCSS(); } }); try { c = f.call(e); } catch (g) { throw { message: `JavaScript evaluation error: '${g.name}: ${g.message.replace(/["]/g, "'")}'`, index: this.index }; } return typeof c === 'number' ? new a.Dimension(c) : typeof c === 'string' ? new a.Quoted(`"${c}"`, c, this.escaped, this.index) : Array.isArray(c) ? new a.Anonymous(c.join(', ')) : new a.Anonymous(c); } }; }(c('../tree'))), (function (a) {
-    a.Keyword = function (a) { this.value = a; }, a.Keyword.prototype = {
-      type: 'Keyword', eval() { return this; }, genCSS(a, b) { b.add(this.value); }, toCSS: a.toCSS, compare(b) { return b instanceof a.Keyword ? b.value === this.value ? 0 : 1 : -1; },
-    }, a.True = new a.Keyword('true'), a.False = new a.Keyword('false');
-  }(c('../tree'))), (function (a) {
-    a.Media = function (b, c, d, e) { this.index = d, this.currentFileInfo = e; const f = this.emptySelectors(); this.features = new a.Value(c), this.rules = [new a.Ruleset(f, b)], this.rules[0].allowImports = !0; }, a.Media.prototype = {
-      type: 'Media', accept(a) { this.features && (this.features = a.visit(this.features)), this.rules && (this.rules = a.visitArray(this.rules)); }, genCSS(b, c) { c.add('@media ', this.currentFileInfo, this.index), this.features.genCSS(b, c), a.outputRuleset(b, c, this.rules); }, toCSS: a.toCSS, eval(b) { b.mediaBlocks || (b.mediaBlocks = [], b.mediaPath = []); const c = new a.Media(null, [], this.index, this.currentFileInfo); this.debugInfo && (this.rules[0].debugInfo = this.debugInfo, c.debugInfo = this.debugInfo); let d = !1; b.strictMath || (d = !0, b.strictMath = !0); try { c.features = this.features.eval(b); } finally { d && (b.strictMath = !1); } return b.mediaPath.push(c), b.mediaBlocks.push(c), b.frames.unshift(this.rules[0]), c.rules = [this.rules[0].eval(b)], b.frames.shift(), b.mediaPath.pop(), b.mediaPath.length === 0 ? c.evalTop(b) : c.evalNested(b); }, variable(b) { return a.Ruleset.prototype.variable.call(this.rules[0], b); }, find() { return a.Ruleset.prototype.find.apply(this.rules[0], arguments); }, rulesets() { return a.Ruleset.prototype.rulesets.apply(this.rules[0]); }, emptySelectors() { const b = new a.Element('', '&', this.index, this.currentFileInfo); const c = [new a.Selector([b], null, null, this.index, this.currentFileInfo)]; return c[0].mediaEmpty = !0, c; }, markReferenced() { let a; const b = this.rules[0].rules; for (this.isReferenced = !0, a = 0; a < b.length; a++)b[a].markReferenced && b[a].markReferenced(); }, evalTop(b) { let c = this; if (b.mediaBlocks.length > 1) { const d = this.emptySelectors(); c = new a.Ruleset(d, b.mediaBlocks), c.multiMedia = !0; } return delete b.mediaBlocks, delete b.mediaPath, c; }, evalNested(b) { let c; let d; const e = b.mediaPath.concat([this]); for (c = 0; c < e.length; c++)d = e[c].features instanceof a.Value ? e[c].features.value : e[c].features, e[c] = Array.isArray(d) ? d : [d]; return this.features = new a.Value(this.permute(e).map((b) => { for (b = b.map((b) => (b.toCSS ? b : new a.Anonymous(b))), c = b.length - 1; c > 0; c--)b.splice(c, 0, new a.Anonymous('and')); return new a.Expression(b); })), new a.Ruleset([], []); }, permute(a) { if (a.length === 0) return []; if (a.length === 1) return a[0]; for (var b = [], c = this.permute(a.slice(1)), d = 0; d < c.length; d++) for (let e = 0; e < a[0].length; e++)b.push([a[0][e]].concat(c[d])); return b; }, bubbleSelectors(b) { this.rules = [new a.Ruleset(b.slice(0), [this.rules[0]])]; },
-    };
-  }(c('../tree'))), (function (a) {
-    a.mixin = {}, a.mixin.Call = function (b, c, d, e, f) { this.selector = new a.Selector(b), this.arguments = c && c.length ? c : null, this.index = d, this.currentFileInfo = e, this.important = f; }, a.mixin.Call.prototype = {
-      type: 'MixinCall',
-      accept(a) { this.selector && (this.selector = a.visit(this.selector)), this.arguments && (this.arguments = a.visitArray(this.arguments)); },
-      eval(b) {
-        let c; let d; let e; let f; let g; let h; let i; let j; let k; let l; let m; let n; const o = []; let p = !1; const q = []; const r = []; const s = a.defaultFunc; const t = 0; const u = 1; const v = 2; for (e = this.arguments && this.arguments.map((a) => ({ name: a.name, value: a.value.eval(b) })), f = 0; f < b.frames.length; f++) {
-          if ((c = b.frames[f].find(this.selector)).length > 0) {
-            for (j = !0, g = 0; g < c.length; g++) { for (d = c[g], i = !1, h = 0; h < b.frames.length; h++) if (!(d instanceof a.mixin.Definition) && d === (b.frames[h].originalRuleset || b.frames[h])) { i = !0; break; } if (!i && d.matchArgs(e, b)) { if (l = { mixin: d, group: t }, d.matchCondition) { for (h = 0; h < 2; h++)s.value(h), r[h] = d.matchCondition(e, b); (r[0] || r[1]) && (r[0] != r[1] && (l.group = r[1] ? u : v), q.push(l)); } else q.push(l); p = !0; } } for (s.reset(), n = [0, 0, 0], g = 0; g < q.length; g++)n[q[g].group]++; if (n[t] > 0)m = v; else if (m = u, n[u] + n[v] > 1) {
-              throw {
-                type: 'Runtime', message: `Ambiguous use of \`default()\` found when matching for \`${this.format(e)}\``, index: this.index, filename: this.currentFileInfo.filename,
-              };
-            } for (g = 0; g < q.length; g++) {
-              if (l = q[g].group, l === t || l === m) {
-                try { d = q[g].mixin, d instanceof a.mixin.Definition || (d = new a.mixin.Definition('', [], d.rules, null, !1), d.originalRuleset = c[g].originalRuleset || c[g]), Array.prototype.push.apply(o, d.eval(b, e, this.important).rules); } catch (w) {
-                  throw {
-                    message: w.message, index: this.index, filename: this.currentFileInfo.filename, stack: w.stack,
-                  };
-                }
-              }
-            } if (p) { if (!this.currentFileInfo || !this.currentFileInfo.reference) for (f = 0; f < o.length; f++)k = o[f], k.markReferenced && k.markReferenced(); return o; }
-          }
-        } throw j ? {
-          type: 'Runtime', message: `No matching definition was found for \`${this.format(e)}\``, index: this.index, filename: this.currentFileInfo.filename,
-        } : {
-          type: 'Name', message: `${this.selector.toCSS().trim()} is undefined`, index: this.index, filename: this.currentFileInfo.filename,
-        };
-      },
-      format(a) { return `${this.selector.toCSS().trim()}(${a ? a.map((a) => { let b = ''; return a.name && (b += `${a.name}:`), b += a.value.toCSS ? a.value.toCSS() : '???'; }).join(', ') : ''})`; },
-    }, a.mixin.Definition = function (b, c, d, e, f) {
-      this.name = b, this.selectors = [new a.Selector([new a.Element(null, b, this.index, this.currentFileInfo)])], this.params = c, this.condition = e, this.variadic = f, this.arity = c.length, this.rules = d, this._lookups = {}, this.required = c.reduce((a, b) => (!b.name || b.name && !b.value ? a + 1 : a), 0), this.parent = a.Ruleset.prototype, this.frames = [];
-    }, a.mixin.Definition.prototype = {
-      type: 'MixinDefinition', accept(a) { this.params && this.params.length && (this.params = a.visitArray(this.params)), this.rules = a.visitArray(this.rules), this.condition && (this.condition = a.visit(this.condition)); }, variable(a) { return this.parent.variable.call(this, a); }, variables() { return this.parent.variables.call(this); }, find() { return this.parent.find.apply(this, arguments); }, rulesets() { return this.parent.rulesets.apply(this); }, evalParams(b, c, d, e) { let f; let g; let h; let i; let j; let k; let l; let m; const n = new a.Ruleset(null, null); const o = this.params.slice(0); if (c = new a.evalEnv(c, [n].concat(c.frames)), d) for (d = d.slice(0), h = 0; h < d.length; h++) if (g = d[h], k = g && g.name) { for (l = !1, i = 0; i < o.length; i++) if (!e[i] && k === o[i].name) { e[i] = g.value.eval(b), n.prependRule(new a.Rule(k, g.value.eval(b))), l = !0; break; } if (l) { d.splice(h, 1), h--; continue; } throw { type: 'Runtime', message: `Named argument for ${this.name} ${d[h].name} not found` }; } for (m = 0, h = 0; h < o.length; h++) if (!e[h]) { if (g = d && d[m], k = o[h].name) if (o[h].variadic && d) { for (f = [], i = m; i < d.length; i++)f.push(d[i].value.eval(b)); n.prependRule(new a.Rule(k, new a.Expression(f).eval(b))); } else { if (j = g && g.value)j = j.eval(b); else { if (!o[h].value) throw { type: 'Runtime', message: `wrong number of arguments for ${this.name} (${d.length} for ${this.arity})` }; j = o[h].value.eval(c), n.resetCache(); }n.prependRule(new a.Rule(k, j)), e[h] = j; } if (o[h].variadic && d) for (i = m; i < d.length; i++)e[i] = d[i].value.eval(b); m++; } return n; }, eval(b, c, d) { let e; let f; const g = []; const h = this.frames.concat(b.frames); const i = this.evalParams(b, new a.evalEnv(b, h), c, g); return i.prependRule(new a.Rule('@arguments', new a.Expression(g).eval(b))), e = this.rules.slice(0), f = new a.Ruleset(null, e), f.originalRuleset = this, f = f.eval(new a.evalEnv(b, [this, i].concat(h))), d && (f = this.parent.makeImportant.apply(f)), f; }, matchCondition(b, c) { return this.condition && !this.condition.eval(new a.evalEnv(c, [this.evalParams(c, new a.evalEnv(c, this.frames.concat(c.frames)), b, [])].concat(this.frames).concat(c.frames))) ? !1 : !0; }, matchArgs(a, b) { let c; const d = a && a.length || 0; if (this.variadic) { if (d < this.required - 1) return !1; } else { if (d < this.required) return !1; if (d > this.params.length) return !1; }c = Math.min(d, this.arity); for (let e = 0; c > e; e++) if (!this.params[e].name && !this.params[e].variadic && a[e].value.eval(b).toCSS() != this.params[e].value.eval(b).toCSS()) return !1; return !0; },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Negative = function (a) { this.value = a; }, a.Negative.prototype = {
-      type: 'Negative', accept(a) { this.value = a.visit(this.value); }, genCSS(a, b) { b.add('-'), this.value.genCSS(a, b); }, toCSS: a.toCSS, eval(b) { return b.isMathOn() ? new a.Operation('*', [new a.Dimension(-1), this.value]).eval(b) : new a.Negative(this.value.eval(b)); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Operation = function (a, b, c) { this.op = a.trim(), this.operands = b, this.isSpaced = c; }, a.Operation.prototype = {
-      type: 'Operation', accept(a) { this.operands = a.visit(this.operands); }, eval(b) { let c = this.operands[0].eval(b); let d = this.operands[1].eval(b); if (b.isMathOn()) { if (c instanceof a.Dimension && d instanceof a.Color && (c = c.toColor()), d instanceof a.Dimension && c instanceof a.Color && (d = d.toColor()), !c.operate) throw { type: 'Operation', message: 'Operation on an invalid type' }; return c.operate(b, this.op, d); } return new a.Operation(this.op, [c, d], this.isSpaced); }, genCSS(a, b) { this.operands[0].genCSS(a, b), this.isSpaced && b.add(' '), b.add(this.op), this.isSpaced && b.add(' '), this.operands[1].genCSS(a, b); }, toCSS: a.toCSS,
-    }, a.operate = function (a, b, c, d) { switch (b) { case '+': return c + d; case '-': return c - d; case '*': return c * d; case '/': return c / d; } };
-  }(c('../tree'))), (function (a) {
-    a.Paren = function (a) { this.value = a; }, a.Paren.prototype = {
-      type: 'Paren', accept(a) { this.value = a.visit(this.value); }, genCSS(a, b) { b.add('('), this.value.genCSS(a, b), b.add(')'); }, toCSS: a.toCSS, eval(b) { return new a.Paren(this.value.eval(b)); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Quoted = function (a, b, c, d, e) { this.escaped = c, this.value = b || '', this.quote = a.charAt(0), this.index = d, this.currentFileInfo = e; }, a.Quoted.prototype = {
-      type: 'Quoted', genCSS(a, b) { this.escaped || b.add(this.quote, this.currentFileInfo, this.index), b.add(this.value), this.escaped || b.add(this.quote); }, toCSS: a.toCSS, eval(b) { const c = this; const d = this.value.replace(/`([^`]+)`/g, (d, e) => new a.JavaScript(e, c.index, !0).eval(b).value).replace(/@\{([\w-]+)\}/g, (d, e) => { const f = new a.Variable(`@${e}`, c.index, c.currentFileInfo).eval(b, !0); return f instanceof a.Quoted ? f.value : f.toCSS(); }); return new a.Quoted(this.quote + d + this.quote, d, this.escaped, this.index, this.currentFileInfo); }, compare(a) { if (!a.toCSS) return -1; const b = this.toCSS(); const c = a.toCSS(); return b === c ? 0 : c > b ? -1 : 1; },
-    };
-  }(c('../tree'))), (function (a) {
-    function b(a, b) { let c; let d = ''; const e = b.length; const f = { add(a) { d += a; } }; for (c = 0; e > c; c++)b[c].eval(a).genCSS(a, f); return d; }a.Rule = function (b, c, d, e, f, g, h) { this.name = b, this.value = c instanceof a.Value ? c : new a.Value([c]), this.important = d ? ` ${d.trim()}` : '', this.merge = e, this.index = f, this.currentFileInfo = g, this.inline = h || !1, this.variable = b.charAt && b.charAt(0) === '@'; }, a.Rule.prototype = {
-      type: 'Rule', accept(a) { this.value = a.visit(this.value); }, genCSS(a, b) { b.add(this.name + (a.compress ? ':' : ': '), this.currentFileInfo, this.index); try { this.value.genCSS(a, b); } catch (c) { throw c.index = this.index, c.filename = this.currentFileInfo.filename, c; }b.add(this.important + (this.inline || a.lastRule && a.compress ? '' : ';'), this.currentFileInfo, this.index); }, toCSS: a.toCSS, eval(c) { let d = !1; let e = this.name; typeof e !== 'string' && (e = e.length === 1 && e[0] instanceof a.Keyword ? e[0].value : b(c, e)), e !== 'font' || c.strictMath || (d = !0, c.strictMath = !0); try { return new a.Rule(e, this.value.eval(c), this.important, this.merge, this.index, this.currentFileInfo, this.inline); } catch (f) { throw f.index = f.index || this.index, f; } finally { d && (c.strictMath = !1); } }, makeImportant() { return new a.Rule(this.name, this.value, '!important', this.merge, this.index, this.currentFileInfo, this.inline); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Ruleset = function (a, b, c) { this.selectors = a, this.rules = b, this._lookups = {}, this.strictImports = c; }, a.Ruleset.prototype = {
-      type: 'Ruleset', accept(a) { this.paths ? a.visitArray(this.paths, !0) : this.selectors && (this.selectors = a.visitArray(this.selectors)), this.rules && this.rules.length && (this.rules = a.visitArray(this.rules)); }, eval(b) { let c; let d; let e; const f = this.selectors; const g = a.defaultFunc; if (f && (d = f.length)) { for (c = [], g.error({ type: 'Syntax', message: 'it is currently only allowed in parametric mixin guards,' }), e = 0; d > e; e++)c.push(f[e].eval(b)); g.reset(); } let h; let i; let j = this.rules ? this.rules.slice(0) : null; const k = new a.Ruleset(c, j, this.strictImports); k.originalRuleset = this, k.root = this.root, k.firstRoot = this.firstRoot, k.allowImports = this.allowImports, this.debugInfo && (k.debugInfo = this.debugInfo); const l = b.frames; l.unshift(k); let m = b.selectors; m || (b.selectors = m = []), m.unshift(this.selectors), (k.root || k.allowImports || !k.strictImports) && k.evalImports(b); const n = k.rules; let o = n ? n.length : 0; for (e = 0; o > e; e++)n[e] instanceof a.mixin.Definition && (n[e].frames = l.slice(0)); const p = b.mediaBlocks && b.mediaBlocks.length || 0; for (e = 0; o > e; e++)n[e] instanceof a.mixin.Call && (j = n[e].eval(b).filter((b) => (b instanceof a.Rule && b.variable ? !k.variable(b.name) : !0)), n.splice.apply(n, [e, 1].concat(j)), o += j.length - 1, e += j.length - 1, k.resetCache()); for (e = 0; e < n.length; e++) if (h = n[e], !(h instanceof a.mixin.Definition) && (n[e] = h = h.eval ? h.eval(b) : h, h instanceof a.Ruleset && h.selectors && h.selectors.length === 1 && h.selectors[0].isJustParentSelector())) { if (n.splice(e--, 1), !h.selectors[0].evaldCondition) continue; for (let q = 0; q < h.rules.length; q++)i = h.rules[q], i instanceof a.Rule && i.variable || n.splice(++e, 0, i); } if (l.shift(), m.shift(), b.mediaBlocks) for (e = p; e < b.mediaBlocks.length; e++)b.mediaBlocks[e].bubbleSelectors(c); return k; }, evalImports(b) { let c; let d; const e = this.rules; if (e) for (c = 0; c < e.length; c++)e[c] instanceof a.Import && (d = e[c].eval(b), d && d.length ? (e.splice.apply(e, [c, 1].concat(d)), c += d.length - 1) : e.splice(c, 1, d), this.resetCache()); }, makeImportant() { return new a.Ruleset(this.selectors, this.rules.map((a) => (a.makeImportant ? a.makeImportant() : a)), this.strictImports); }, matchArgs(a) { return !a || a.length === 0; }, matchCondition(b, c) { const d = this.selectors[this.selectors.length - 1]; return d.evaldCondition ? d.condition && !d.condition.eval(new a.evalEnv(c, c.frames)) ? !1 : !0 : !1; }, resetCache() { this._rulesets = null, this._variables = null, this._lookups = {}; }, variables() { return this._variables || (this._variables = this.rules ? this.rules.reduce((b, c) => (c instanceof a.Rule && c.variable === !0 && (b[c.name] = c), b), {}) : {}), this._variables; }, variable(a) { return this.variables()[a]; }, rulesets() { if (!this.rules) return null; let b; let c; const d = a.Ruleset; const e = a.mixin.Definition; const f = []; const g = this.rules; const h = g.length; for (b = 0; h > b; b++)c = g[b], (c instanceof d || c instanceof e) && f.push(c); return f; }, prependRule(a) { const b = this.rules; b ? b.unshift(a) : this.rules = [a]; }, find(b, c) { c = c || this; let d; const e = []; const f = b.toCSS(); return f in this._lookups ? this._lookups[f] : (this.rulesets().forEach((f) => { if (f !== c) for (let g = 0; g < f.selectors.length; g++) if (d = b.match(f.selectors[g])) { b.elements.length > d ? Array.prototype.push.apply(e, f.find(new a.Selector(b.elements.slice(d)), c)) : e.push(f); break; } }), this._lookups[f] = e, e); }, genCSS(b, c) { let d; let e; let f; let g; let h; let i; const j = []; const k = []; b.tabLevel = b.tabLevel || 0, this.root || b.tabLevel++; let l; const m = b.compress ? '' : Array(b.tabLevel + 1).join('  '); const n = b.compress ? '' : Array(b.tabLevel).join('  '); for (d = 0; d < this.rules.length; d++)h = this.rules[d], h.rules || h instanceof a.Media || h instanceof a.Directive || this.root && h instanceof a.Comment ? k.push(h) : j.push(h); if (!this.root) { g = a.debugInfo(b, this, n), g && (c.add(g), c.add(n)); let o; const p = this.paths; const q = p.length; for (l = b.compress ? ',' : `,\n${n}`, d = 0; q > d; d++) if (i = p[d], o = i.length) for (d > 0 && c.add(l), b.firstSelector = !0, i[0].genCSS(b, c), b.firstSelector = !1, e = 1; o > e; e++)i[e].genCSS(b, c); c.add((b.compress ? '{' : ' {\n') + m); } for (d = 0; d < j.length; d++)h = j[d], d + 1 !== j.length || this.root && k.length !== 0 && !this.firstRoot || (b.lastRule = !0), h.genCSS ? h.genCSS(b, c) : h.value && c.add(h.value.toString()), b.lastRule ? b.lastRule = !1 : c.add(b.compress ? '' : `\n${m}`); if (this.root || (c.add(b.compress ? '}' : `\n${n}}`), b.tabLevel--), l = (b.compress ? '' : '\n') + (this.root ? m : n), f = k.length) for (j.length && l && c.add(l), k[0].genCSS(b, c), d = 1; f > d; d++)l && c.add(l), k[d].genCSS(b, c); c.isEmpty() || b.compress || !this.firstRoot || c.add('\n'); }, toCSS: a.toCSS, markReferenced() { for (let a = 0; a < this.selectors.length; a++) this.selectors[a].markReferenced(); }, joinSelectors(a, b, c) { for (let d = 0; d < c.length; d++) this.joinSelector(a, b, c[d]); }, joinSelector(b, c, d) { let e; let f; let g; let h; let i; let j; let k; let l; let m; let n; let o; let p; let q; let r; let s; for (e = 0; e < d.elements.length; e++)j = d.elements[e], j.value === '&' && (h = !0); if (h) { for (r = [], i = [[]], e = 0; e < d.elements.length; e++) if (j = d.elements[e], j.value !== '&')r.push(j); else { for (s = [], r.length > 0 && this.mergeElementsOnToSelectors(r, i), f = 0; f < i.length; f++) if (k = i[f], c.length === 0)k.length > 0 && (k[0].elements = k[0].elements.slice(0), k[0].elements.push(new a.Element(j.combinator, '', j.index, j.currentFileInfo))), s.push(k); else for (g = 0; g < c.length; g++)l = c[g], m = [], n = [], p = !0, k.length > 0 ? (m = k.slice(0), q = m.pop(), o = d.createDerived(q.elements.slice(0)), p = !1) : o = d.createDerived([]), l.length > 1 && (n = n.concat(l.slice(1))), l.length > 0 && (p = !1, o.elements.push(new a.Element(j.combinator, l[0].elements[0].value, j.index, j.currentFileInfo)), o.elements = o.elements.concat(l[0].elements.slice(1))), p || m.push(o), m = m.concat(n), s.push(m); i = s, r = []; } for (r.length > 0 && this.mergeElementsOnToSelectors(r, i), e = 0; e < i.length; e++)i[e].length > 0 && b.push(i[e]); } else if (c.length > 0) for (e = 0; e < c.length; e++)b.push(c[e].concat(d)); else b.push([d]); }, mergeElementsOnToSelectors(b, c) { let d; let e; if (c.length === 0) return c.push([new a.Selector(b)]), void 0; for (d = 0; d < c.length; d++)e = c[d], e.length > 0 ? e[e.length - 1] = e[e.length - 1].createDerived(e[e.length - 1].elements.concat(b)) : e.push(new a.Selector(b)); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Selector = function (a, b, c, d, e, f) { this.elements = a, this.extendList = b, this.condition = c, this.currentFileInfo = e || {}, this.isReferenced = f, c || (this.evaldCondition = !0); }, a.Selector.prototype = {
-      type: 'Selector', accept(a) { this.elements && (this.elements = a.visitArray(this.elements)), this.extendList && (this.extendList = a.visitArray(this.extendList)), this.condition && (this.condition = a.visit(this.condition)); }, createDerived(b, c, d) { d = d != null ? d : this.evaldCondition; const e = new a.Selector(b, c || this.extendList, null, this.index, this.currentFileInfo, this.isReferenced); return e.evaldCondition = d, e.mediaEmpty = this.mediaEmpty, e; }, match(a) { let b; let c; const d = this.elements; const e = d.length; if (a.CacheElements(), b = a._elements.length, b === 0 || b > e) return 0; for (c = 0; b > c; c++) if (d[c].value !== a._elements[c]) return 0; return b; }, CacheElements() { let a; let b; let c; let d = ''; if (!this._elements) { for (a = this.elements.length, c = 0; a > c; c++) if (b = this.elements[c], d += b.combinator.value, b.value.value) { if (typeof b.value.value !== 'string') { d = ''; break; }d += b.value.value; } else d += b.value; this._elements = d.match(/[,&#\.\w-]([\w-]|(\\.))*/g), this._elements ? this._elements[0] === '&' && this._elements.shift() : this._elements = []; } }, isJustParentSelector() { return !this.mediaEmpty && this.elements.length === 1 && this.elements[0].value === '&' && (this.elements[0].combinator.value === ' ' || this.elements[0].combinator.value === ''); }, eval(a) { const b = this.condition && this.condition.eval(a); let c = this.elements; let d = this.extendList; return c = c && c.map((b) => b.eval(a)), d = d && d.map((b) => b.eval(a)), this.createDerived(c, d, b); }, genCSS(a, b) { let c; let d; if (a && a.firstSelector || this.elements[0].combinator.value !== '' || b.add(' ', this.currentFileInfo, this.index), !this._css) for (c = 0; c < this.elements.length; c++)d = this.elements[c], d.genCSS(a, b); }, toCSS: a.toCSS, markReferenced() { this.isReferenced = !0; }, getIsReferenced() { return !this.currentFileInfo.reference || this.isReferenced; }, getIsOutput() { return this.evaldCondition; },
-    };
-  }(c('../tree'))), (function (a) {
-    a.UnicodeDescriptor = function (a) { this.value = a; }, a.UnicodeDescriptor.prototype = {
-      type: 'UnicodeDescriptor', genCSS(a, b) { b.add(this.value); }, toCSS: a.toCSS, eval() { return this; },
-    };
-  }(c('../tree'))), (function (a) {
-    a.URL = function (a, b, c) { this.value = a, this.currentFileInfo = b, this.isEvald = c; }, a.URL.prototype = {
-      type: 'Url', accept(a) { this.value = a.visit(this.value); }, genCSS(a, b) { b.add('url('), this.value.genCSS(a, b), b.add(')'); }, toCSS: a.toCSS, eval(b) { let c; const d = this.value.eval(b); if (!this.isEvald && (c = this.currentFileInfo && this.currentFileInfo.rootpath, c && typeof d.value === 'string' && b.isPathRelative(d.value) && (d.quote || (c = c.replace(/[\(\)'"\s]/g, (a) => `\\${a}`)), d.value = c + d.value), d.value = b.normalizePath(d.value), b.urlArgs && !d.value.match(/^\s*data:/))) { const e = d.value.indexOf('?') === -1 ? '?' : '&'; const f = e + b.urlArgs; d.value.indexOf('#') !== -1 ? d.value = d.value.replace('#', `${f}#`) : d.value += f; } return new a.URL(d, this.currentFileInfo, !0); },
-    };
-  }(c('../tree'))), (function (a) {
-    a.Value = function (a) { this.value = a; }, a.Value.prototype = {
-      type: 'Value', accept(a) { this.value && (this.value = a.visitArray(this.value)); }, eval(b) { return this.value.length === 1 ? this.value[0].eval(b) : new a.Value(this.value.map((a) => a.eval(b))); }, genCSS(a, b) { let c; for (c = 0; c < this.value.length; c++) this.value[c].genCSS(a, b), c + 1 < this.value.length && b.add(a && a.compress ? ',' : ', '); }, toCSS: a.toCSS,
-    };
-  }(c('../tree'))), (function (a) {
-    a.Variable = function (a, b, c) { this.name = a, this.index = b, this.currentFileInfo = c || {}; }, a.Variable.prototype = {
-      type: 'Variable',
-      eval(b) {
-        let c; let d = this.name; if (d.indexOf('@@') === 0 && (d = `@${new a.Variable(d.slice(1)).eval(b).value}`), this.evaluating) {
-          throw {
-            type: 'Name', message: `Recursive variable definition for ${d}`, filename: this.currentFileInfo.file, index: this.index,
-          };
-        } if (this.evaluating = !0, c = a.find(b.frames, (a) => { const c = a.variable(d); return c ? c.value.eval(b) : void 0; })) return this.evaluating = !1, c; throw {
-          type: 'Name', message: `variable ${d} is undefined`, filename: this.currentFileInfo.filename, index: this.index,
-        };
-      },
-    };
-  }(c('../tree'))), (function (a) {
-    const b = ['paths', 'optimization', 'files', 'contents', 'contentsIgnoredChars', 'relativeUrls', 'rootpath', 'strictImports', 'insecure', 'dumpLineNumbers', 'compress', 'processImports', 'syncImport', 'javascriptEnabled', 'mime', 'useFileCache', 'currentFileInfo']; a.parseEnv = function (a) {
-      if (d(a, this, b), this.contents || (this.contents = {}), this.contentsIgnoredChars || (this.contentsIgnoredChars = {}), this.files || (this.files = {}), !this.currentFileInfo) {
-        const c = a && a.filename || 'input'; const e = c.replace(/[^\/\\]*$/, ''); a && (a.filename = null), this.currentFileInfo = {
-          filename: c, relativeUrls: this.relativeUrls, rootpath: a && a.rootpath || '', currentDirectory: e, entryPath: e, rootFilename: c,
-        };
-      }
-    }; const c = ['silent', 'verbose', 'compress', 'yuicompress', 'ieCompat', 'strictMath', 'strictUnits', 'cleancss', 'sourceMap', 'importMultiple', 'urlArgs']; a.evalEnv = function (a, b) { d(a, this, c), this.frames = b || []; }, a.evalEnv.prototype.inParenthesis = function () { this.parensStack || (this.parensStack = []), this.parensStack.push(!0); }, a.evalEnv.prototype.outOfParenthesis = function () { this.parensStack.pop(); }, a.evalEnv.prototype.isMathOn = function () { return this.strictMath ? this.parensStack && this.parensStack.length : !0; }, a.evalEnv.prototype.isPathRelative = function (a) { return !/^(?:[a-z-]+:|\/)/.test(a); }, a.evalEnv.prototype.normalizePath = function (a) { let b; const c = a.split('/').reverse(); for (a = []; c.length !== 0;) switch (b = c.pop()) { case '.': break; case '..': a.length === 0 || a[a.length - 1] === '..' ? a.push(b) : a.pop(); break; default: a.push(b); } return a.join('/'); }; var d = function (a, b, c) { if (a) for (let d = 0; d < c.length; d++)a.hasOwnProperty(c[d]) && (b[c[d]] = a[c[d]]); };
-  }(c('./tree'))), (function (a) { function b(a) { return a; } function c(a, b) { let d; let e; for (d in a) if (a.hasOwnProperty(d)) switch (e = a[d], typeof e) { case 'function': e.prototype && e.prototype.type && (e.prototype.typeIndex = b++); break; case 'object': b = c(e, b); } return b; } const d = { visitDeeper: !0 }; let e = !1; a.visitor = function (b) { this._implementation = b, this._visitFnCache = [], e || (c(a, 1), e = !0); }, a.visitor.prototype = { visit(a) { if (!a) return a; const c = a.typeIndex; if (!c) return a; let e; const f = this._visitFnCache; const g = this._implementation; const h = c << 1; const i = 1 | h; let j = f[h]; let k = f[i]; const l = d; if (l.visitDeeper = !0, j || (e = `visit${a.type}`, j = g[e] || b, k = g[`${e}Out`] || b, f[h] = j, f[i] = k), j !== b) { const m = j.call(g, a, l); g.isReplacing && (a = m); } return l.visitDeeper && a && a.accept && a.accept(this), k != b && k.call(g, a), a; }, visitArray(a, b) { if (!a) return a; let c; const d = a.length; if (b || !this._implementation.isReplacing) { for (c = 0; d > c; c++) this.visit(a[c]); return a; } const e = []; for (c = 0; d > c; c++) { const f = this.visit(a[c]); f.splice ? f.length && this.flatten(f, e) : e.push(f); } return e; }, flatten(a, b) { b || (b = []); let c; let d; let e; let f; let g; let h; for (d = 0, c = a.length; c > d; d++) if (e = a[d], e.splice) for (g = 0, f = e.length; f > g; g++)h = e[g], h.splice ? h.length && this.flatten(h, b) : b.push(h); else b.push(e); return b; } }; }(c('./tree'))), (function (a) {
-    a.importVisitor = function (b, c, d) { this._visitor = new a.visitor(this), this._importer = b, this._finish = c, this.env = d || new a.evalEnv(), this.importCount = 0; }, a.importVisitor.prototype = {
-      isReplacing: !0, run(a) { let b; try { this._visitor.visit(a); } catch (c) { b = c; } this.isFinished = !0, this.importCount === 0 && this._finish(b); }, visitImport(b, c) { let d; const e = this; const f = b.options.inline; if (!b.css || f) { try { d = b.evalForImport(this.env); } catch (g) { g.filename || (g.index = b.index, g.filename = b.currentFileInfo.filename), b.css = !0, b.error = g; } if (d && (!d.css || f)) { b = d, this.importCount++; const h = new a.evalEnv(this.env, this.env.frames.slice(0)); b.options.multiple && (h.importMultiple = !0), this._importer.push(b.getPath(), b.currentFileInfo, b.options, (c, d, g, i) => { c && !c.filename && (c.index = b.index, c.filename = b.currentFileInfo.filename), g && !h.importMultiple && (b.skip = g); const j = function (a) { e.importCount--, e.importCount === 0 && e.isFinished && e._finish(a); }; return !d || (b.root = d, b.importedFilename = i, f || b.skip) ? (j(), void 0) : (new a.importVisitor(e._importer, j, h).run(d), void 0); }); } } return c.visitDeeper = !1, b; }, visitRule(a, b) { return b.visitDeeper = !1, a; }, visitDirective(a) { return this.env.frames.unshift(a), a; }, visitDirectiveOut() { this.env.frames.shift(); }, visitMixinDefinition(a) { return this.env.frames.unshift(a), a; }, visitMixinDefinitionOut() { this.env.frames.shift(); }, visitRuleset(a) { return this.env.frames.unshift(a), a; }, visitRulesetOut() { this.env.frames.shift(); }, visitMedia(a) { return this.env.frames.unshift(a.ruleset), a; }, visitMediaOut() { this.env.frames.shift(); },
-    };
-  }(c('./tree'))), (function (a) {
-    a.joinSelectorVisitor = function () { this.contexts = [[]], this._visitor = new a.visitor(this); }, a.joinSelectorVisitor.prototype = {
-      run(a) { return this._visitor.visit(a); }, visitRule(a, b) { b.visitDeeper = !1; }, visitMixinDefinition(a, b) { b.visitDeeper = !1; }, visitRuleset(a) { let b; const c = this.contexts[this.contexts.length - 1]; const d = []; this.contexts.push(d), a.root || (b = a.selectors, b && (b = b.filter((a) => a.getIsOutput()), a.selectors = b.length ? b : b = null, b && a.joinSelectors(d, c, b)), b || (a.rules = null), a.paths = d); }, visitRulesetOut() { this.contexts.length = this.contexts.length - 1; }, visitMedia(a) { const b = this.contexts[this.contexts.length - 1]; a.rules[0].root = b.length === 0 || b[0].multiMedia; },
-    };
-  }(c('./tree'))), (function (a) {
-    a.toCSSVisitor = function (b) { this._visitor = new a.visitor(this), this._env = b; }, a.toCSSVisitor.prototype = {
-      isReplacing: !0, run(a) { return this._visitor.visit(a); }, visitRule(a) { return a.variable ? [] : a; }, visitMixinDefinition() { return []; }, visitExtend() { return []; }, visitComment(a) { return a.isSilent(this._env) ? [] : a; }, visitMedia(a, b) { return a.accept(this._visitor), b.visitDeeper = !1, a.rules.length ? a : []; }, visitDirective(b) { if (b.currentFileInfo.reference && !b.isReferenced) return []; if (b.name === '@charset') { if (this.charset) { if (b.debugInfo) { const c = new a.Comment(`/* ${b.toCSS(this._env).replace(/\n/g, '')} */\n`); return c.debugInfo = b.debugInfo, this._visitor.visit(c); } return []; } this.charset = !0; } return b; }, checkPropertiesInRoot(b) { for (var c, d = 0; d < b.length; d++) if (c = b[d], c instanceof a.Rule && !c.variable) throw { message: 'properties must be inside selector blocks, they cannot be in the root.', index: c.index, filename: c.currentFileInfo ? c.currentFileInfo.filename : null }; }, visitRuleset(b, c) { let d; const e = []; if (b.firstRoot && this.checkPropertiesInRoot(b.rules), b.root)b.accept(this._visitor), c.visitDeeper = !1, (b.firstRoot || b.rules && b.rules.length > 0) && e.splice(0, 0, b); else { b.paths && (b.paths = b.paths.filter((b) => { let c; for (b[0].elements[0].combinator.value === ' ' && (b[0].elements[0].combinator = new a.Combinator('')), c = 0; c < b.length; c++) if (b[c].getIsReferenced() && b[c].getIsOutput()) return !0; return !1; })); for (var f = b.rules, g = f ? f.length : 0, h = 0; g > h;)d = f[h], d && d.rules ? (e.push(this._visitor.visit(d)), f.splice(h, 1), g--) : h++; g > 0 ? b.accept(this._visitor) : b.rules = null, c.visitDeeper = !1, f = b.rules, f && (this._mergeRules(f), f = b.rules), f && (this._removeDuplicateRules(f), f = b.rules), f && f.length > 0 && b.paths.length > 0 && e.splice(0, 0, b); } return e.length === 1 ? e[0] : e; }, _removeDuplicateRules(b) { if (b) { let c; let d; let e; const f = {}; for (e = b.length - 1; e >= 0; e--) if (d = b[e], d instanceof a.Rule) if (f[d.name]) { c = f[d.name], c instanceof a.Rule && (c = f[d.name] = [f[d.name].toCSS(this._env)]); const g = d.toCSS(this._env); c.indexOf(g) !== -1 ? b.splice(e, 1) : c.push(g); } else f[d.name] = d; } }, _mergeRules(b) { if (b) { for (var c, d, e, f = {}, g = 0; g < b.length; g++)d = b[g], d instanceof a.Rule && d.merge && (e = [d.name, d.important ? '!' : ''].join(','), f[e] ? b.splice(g--, 1) : f[e] = [], f[e].push(d)); Object.keys(f).map((b) => { c = f[b], c.length > 1 && (d = c[0], d.value = new a.Value(c.map((a) => a.value))); }); } },
-    };
-  }(c('./tree'))), (function (a) {
-    a.extendFinderVisitor = function () { this._visitor = new a.visitor(this), this.contexts = [], this.allExtendsStack = [[]]; }, a.extendFinderVisitor.prototype = {
-      run(a) { return a = this._visitor.visit(a), a.allExtends = this.allExtendsStack[0], a; }, visitRule(a, b) { b.visitDeeper = !1; }, visitMixinDefinition(a, b) { b.visitDeeper = !1; }, visitRuleset(b) { if (!b.root) { let c; let d; let e; let f; const g = []; const h = b.rules; const i = h ? h.length : 0; for (c = 0; i > c; c++)b.rules[c] instanceof a.Extend && (g.push(h[c]), b.extendOnEveryPath = !0); const j = b.paths; for (c = 0; c < j.length; c++) { const k = j[c]; const l = k[k.length - 1]; const m = l.extendList; for (f = m ? m.slice(0).concat(g) : g, f && (f = f.map((a) => a.clone())), d = 0; d < f.length; d++) this.foundExtends = !0, e = f[d], e.findSelfSelectors(k), e.ruleset = b, d === 0 && (e.firstExtendOnThisSelectorPath = !0), this.allExtendsStack[this.allExtendsStack.length - 1].push(e); } this.contexts.push(b.selectors); } }, visitRulesetOut(a) { a.root || (this.contexts.length = this.contexts.length - 1); }, visitMedia(a) { a.allExtends = [], this.allExtendsStack.push(a.allExtends); }, visitMediaOut() { this.allExtendsStack.length = this.allExtendsStack.length - 1; }, visitDirective(a) { a.allExtends = [], this.allExtendsStack.push(a.allExtends); }, visitDirectiveOut() { this.allExtendsStack.length = this.allExtendsStack.length - 1; },
-    }, a.processExtendsVisitor = function () { this._visitor = new a.visitor(this); }, a.processExtendsVisitor.prototype = {
-      run(b) { const c = new a.extendFinderVisitor(); return c.run(b), c.foundExtends ? (b.allExtends = b.allExtends.concat(this.doExtendChaining(b.allExtends, b.allExtends)), this.allExtendsStack = [b.allExtends], this._visitor.visit(b)) : b; },
-      doExtendChaining(b, c, d) { let e; let f; let g; let h; let i; let j; let k; let l; const m = []; const n = this; for (d = d || 0, e = 0; e < b.length; e++) for (f = 0; f < c.length; f++)j = b[e], k = c[f], j.parent_ids.indexOf(k.object_id) >= 0 || (i = [k.selfSelectors[0]], g = n.findMatch(j, i), g.length && j.selfSelectors.forEach((b) => { h = n.extendSelector(g, i, b), l = new a.Extend(k.selector, k.option, 0), l.selfSelectors = h, h[h.length - 1].extendList = [l], m.push(l), l.ruleset = k.ruleset, l.parent_ids = l.parent_ids.concat(k.parent_ids, j.parent_ids), k.firstExtendOnThisSelectorPath && (l.firstExtendOnThisSelectorPath = !0, k.ruleset.paths.push(h)); })); if (m.length) { if (this.extendChainCount++, d > 100) { let o = '{unable to calculate}'; let p = '{unable to calculate}'; try { o = m[0].selfSelectors[0].toCSS(), p = m[0].selector.toCSS(); } catch (q) {} throw { message: `extend circular reference detected. One of the circular extends is currently:${o}:extend(${p})` }; } return m.concat(n.doExtendChaining(m, c, d + 1)); } return m; },
-      visitRule(a, b) { b.visitDeeper = !1; },
-      visitMixinDefinition(a, b) { b.visitDeeper = !1; },
-      visitSelector(a, b) { b.visitDeeper = !1; },
-      visitRuleset(a) { if (!a.root) { let b; let c; let d; let e; const f = this.allExtendsStack[this.allExtendsStack.length - 1]; const g = []; const h = this; for (d = 0; d < f.length; d++) for (c = 0; c < a.paths.length; c++) if (e = a.paths[c], !a.extendOnEveryPath) { const i = e[e.length - 1].extendList; i && i.length || (b = this.findMatch(f[d], e), b.length && f[d].selfSelectors.forEach((a) => { g.push(h.extendSelector(b, e, a)); })); }a.paths = a.paths.concat(g); } },
-      findMatch(a, b) {
-        let c; let d; let e; let f; let g; let h; let i; const j = this; const k = a.selector.elements; const l = []; const m = []; for (c = 0; c < b.length; c++) {
-          for (d = b[c], e = 0; e < d.elements.length; e++) {
-            for (f = d.elements[e], (a.allowBefore || c === 0 && e === 0) && l.push({
-              pathIndex: c, index: e, matched: 0, initialCombinator: f.combinator,
-            }), h = 0; h < l.length; h++)i = l[h], g = f.combinator.value, g === '' && e === 0 && (g = ' '), !j.isElementValuesEqual(k[i.matched].value, f.value) || i.matched > 0 && k[i.matched].combinator.value !== g ? i = null : i.matched++, i && (i.finished = i.matched === k.length, i.finished && !a.allowAfter && (e + 1 < d.elements.length || c + 1 < b.length) && (i = null)), i ? i.finished && (i.length = k.length, i.endPathIndex = c, i.endPathElementIndex = e + 1, l.length = 0, m.push(i)) : (l.splice(h, 1), h--);
-          }
-        } return m;
-      },
-      isElementValuesEqual(b, c) { if (typeof b === 'string' || typeof c === 'string') return b === c; if (b instanceof a.Attribute) return b.op !== c.op || b.key !== c.key ? !1 : b.value && c.value ? (b = b.value.value || b.value, c = c.value.value || c.value, b === c) : b.value || c.value ? !1 : !0; if (b = b.value, c = c.value, b instanceof a.Selector) { if (!(c instanceof a.Selector) || b.elements.length !== c.elements.length) return !1; for (let d = 0; d < b.elements.length; d++) { if (b.elements[d].combinator.value !== c.elements[d].combinator.value && (d !== 0 || (b.elements[d].combinator.value || ' ') !== (c.elements[d].combinator.value || ' '))) return !1; if (!this.isElementValuesEqual(b.elements[d].value, c.elements[d].value)) return !1; } return !0; } return !1; },
-      extendSelector(b, c, d) { let e; let f; let g; let h; let i; let j = 0; let k = 0; let l = []; for (e = 0; e < b.length; e++)h = b[e], f = c[h.pathIndex], g = new a.Element(h.initialCombinator, d.elements[0].value, d.elements[0].index, d.elements[0].currentFileInfo), h.pathIndex > j && k > 0 && (l[l.length - 1].elements = l[l.length - 1].elements.concat(c[j].elements.slice(k)), k = 0, j++), i = f.elements.slice(k, h.index).concat([g]).concat(d.elements.slice(1)), j === h.pathIndex && e > 0 ? l[l.length - 1].elements = l[l.length - 1].elements.concat(i) : (l = l.concat(c.slice(j, h.pathIndex)), l.push(new a.Selector(i))), j = h.endPathIndex, k = h.endPathElementIndex, k >= c[j].elements.length && (k = 0, j++); return j < c.length && k > 0 && (l[l.length - 1].elements = l[l.length - 1].elements.concat(c[j].elements.slice(k)), j++), l = l.concat(c.slice(j, c.length)); },
-      visitRulesetOut() {},
-      visitMedia(a) { let b = a.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]); b = b.concat(this.doExtendChaining(b, a.allExtends)), this.allExtendsStack.push(b); },
-      visitMediaOut() { this.allExtendsStack.length = this.allExtendsStack.length - 1; },
-      visitDirective(a) { let b = a.allExtends.concat(this.allExtendsStack[this.allExtendsStack.length - 1]); b = b.concat(this.doExtendChaining(b, a.allExtends)), this.allExtendsStack.push(b); },
-      visitDirectiveOut() { this.allExtendsStack.length = this.allExtendsStack.length - 1; },
-    };
-  }(c('./tree'))), (function (a) {
-    a.sourceMapOutput = function (a) { this._css = [], this._rootNode = a.rootNode, this._writeSourceMap = a.writeSourceMap, this._contentsMap = a.contentsMap, this._contentsIgnoredCharsMap = a.contentsIgnoredCharsMap, this._sourceMapFilename = a.sourceMapFilename, this._outputFilename = a.outputFilename, this._sourceMapURL = a.sourceMapURL, a.sourceMapBasepath && (this._sourceMapBasepath = a.sourceMapBasepath.replace(/\\/g, '/')), this._sourceMapRootpath = a.sourceMapRootpath, this._outputSourceFiles = a.outputSourceFiles, this._sourceMapGeneratorConstructor = a.sourceMapGenerator || c('source-map').SourceMapGenerator, this._sourceMapRootpath && this._sourceMapRootpath.charAt(this._sourceMapRootpath.length - 1) !== '/' && (this._sourceMapRootpath += '/'), this._lineNumber = 0, this._column = 0; }, a.sourceMapOutput.prototype.normalizeFilename = function (a) { return a = a.replace(/\\/g, '/'), this._sourceMapBasepath && a.indexOf(this._sourceMapBasepath) === 0 && (a = a.substring(this._sourceMapBasepath.length), (a.charAt(0) === '\\' || a.charAt(0) === '/') && (a = a.substring(1))), (this._sourceMapRootpath || '') + a; }, a.sourceMapOutput.prototype.add = function (a, b, c, d) { if (a) { let e; let f; let g; let h; let i; if (b) { let j = this._contentsMap[b.filename]; this._contentsIgnoredCharsMap[b.filename] && (c -= this._contentsIgnoredCharsMap[b.filename], c < 0 && (c = 0), j = j.slice(this._contentsIgnoredCharsMap[b.filename])), j = j.substring(0, c), f = j.split('\n'), h = f[f.length - 1]; } if (e = a.split('\n'), g = e[e.length - 1], b) if (d) for (i = 0; i < e.length; i++) this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + i + 1, column: i === 0 ? this._column : 0 }, original: { line: f.length + i, column: i === 0 ? h.length : 0 }, source: this.normalizeFilename(b.filename) }); else this._sourceMapGenerator.addMapping({ generated: { line: this._lineNumber + 1, column: this._column }, original: { line: f.length, column: h.length }, source: this.normalizeFilename(b.filename) }); e.length === 1 ? this._column += g.length : (this._lineNumber += e.length - 1, this._column = g.length), this._css.push(a); } }, a.sourceMapOutput.prototype.isEmpty = function () { return this._css.length === 0; }, a.sourceMapOutput.prototype.toCSS = function (a) {
-      if (this._sourceMapGenerator = new this._sourceMapGeneratorConstructor({ file: this._outputFilename, sourceRoot: null }), this._outputSourceFiles) for (const b in this._contentsMap) if (this._contentsMap.hasOwnProperty(b)) { let c = this._contentsMap[b]; this._contentsIgnoredCharsMap[b] && (c = c.slice(this._contentsIgnoredCharsMap[b])), this._sourceMapGenerator.setSourceContent(this.normalizeFilename(b), c); } if (this._rootNode.genCSS(a, this), this._css.length > 0) {
-        let d; const e = JSON.stringify(this._sourceMapGenerator.toJSON()); this._sourceMapURL ? d = this._sourceMapURL : this._sourceMapFilename && (d = this.normalizeFilename(this._sourceMapFilename)), this._writeSourceMap ? this._writeSourceMap(e) : d = `data:application/json,${encodeURIComponent(e)}`, d && this._css.push(`/*# sourceMappingURL=${d} */`);
-      } return this._css.join('');
-    };
-  }(c('./tree'))); var x = /^(file|chrome(-extension)?|resource|qrc|app):/.test(location.protocol); v.env = v.env || (location.hostname == '127.0.0.1' || location.hostname == '0.0.0.0' || location.hostname == 'localhost' || location.port && location.port.length > 0 || x ? 'development' : 'production'); var y = { info: 2, errors: 1, none: 0 }; if (v.logLevel = typeof v.logLevel !== 'undefined' ? v.logLevel : y.info, v.async = v.async || !1, v.fileAsync = v.fileAsync || !1, v.poll = v.poll || (x ? 1e3 : 1500), v.functions) for (const z in v.functions)v.functions.hasOwnProperty(z) && (v.tree.functions[z] = v.functions[z]); const A = /!dumpLineNumbers:(comments|mediaquery|all)/.exec(location.hash); A && (v.dumpLineNumbers = A[1]); var B = /^text\/(x-)?less$/; var C = null; var D = {}; if (v.watch = function () { return v.watchMode || (v.env = 'development', u()), this.watchMode = !0, !0; }, v.unwatch = function () { return clearInterval(v.watchTimer), this.watchMode = !1, !1; }, /!watch/.test(location.hash) && v.watch(), v.env != 'development') try { C = typeof a.localStorage === 'undefined' ? null : a.localStorage; } catch (E) {} const F = document.getElementsByTagName('link'); v.sheets = []; for (let G = 0; G < F.length; G++)(F[G].rel === 'stylesheet/less' || F[G].rel.match(/stylesheet/) && F[G].type.match(B)) && v.sheets.push(F[G]); v.modifyVars = function (a) { v.refresh(!1, a); }, v.refresh = function (a, b) { let c; let e; c = e = new Date(), t((a, b, f, h, j) => (a ? i(a, h.href) : (j.local ? d(`loading ${h.href} from cache.`, y.info) : (d(`parsed ${h.href} successfully.`, y.info), g(b.toCSS(v), h, j.lastModified)), d(`css for ${h.href} generated in ${new Date() - e}ms`, y.info), j.remaining === 0 && d(`css generated in ${new Date() - c}ms`, y.info), e = new Date(), void 0)), a, b), m(b); }, v.refreshStyles = m, v.Parser.fileLoader = r, v.refresh(v.env === 'development'), typeof define === 'function' && define.amd && define(() => v);
-}(window));
diff --git a/packages/mindplot/src/components/libraries/mootools/mootools-core-1.4.5-full-nocompat-yc.js b/packages/mindplot/src/components/libraries/mootools/mootools-core-1.4.5-full-nocompat-yc.js
deleted file mode 100644
index 720b6e0e..00000000
--- a/packages/mindplot/src/components/libraries/mootools/mootools-core-1.4.5-full-nocompat-yc.js
+++ /dev/null
@@ -1,596 +0,0 @@
-/*
- ---
- MooTools: the javascript framework
-
- web build:
- - http://mootools.net/core/b28139f033891d55fabb70ffafd6813b
-
- packager build:
- - packager build Core/Core Core/Array Core/Class Core/Class.Extras
-
- copyrights:
- - [MooTools](http://mootools.net)
-
- licenses:
- - [MIT License](http://mootools.net/license.txt)
- ...
- */
-
-(function () {
-  this.MooTools = { version: '1.4.5', build: 'ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0' };
-  const o = this.typeOf = function (i) {
-    if (i == null) {
-      return 'null';
-    }
-    if (i.$family != null) {
-      return i.$family();
-    }
-    if (i.nodeName) {
-      if (i.nodeType == 1) {
-        return 'element';
-      }
-      if (i.nodeType == 3) {
-        return (/\S/).test(i.nodeValue) ? 'textnode' : 'whitespace';
-      }
-    } else if (typeof i.length === 'number') {
-      if (i.callee) {
-        return 'arguments';
-      }
-      if ('item' in i) {
-        return 'collection';
-      }
-    }
-    return typeof i;
-  };
-  this.instanceOf = function (t, i) {
-    if (t == null) {
-      return false;
-    }
-    let s = t.$constructor || t.constructor;
-    while (s) {
-      if (s === i) {
-        return true;
-      }
-      s = s.parent;
-    }
-    if (!t.hasOwnProperty) {
-      return false;
-    }
-    return t instanceof i;
-  };
-  const f = this.Function;
-  let p = true;
-  for (const k in { toString: 1 }) {
-    p = null;
-  }
-  if (p) {
-    p = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor'];
-  }
-  f.prototype.overloadSetter = function (s) {
-    const i = this;
-    return function (u, t) {
-      if (u == null) {
-        return this;
-      }
-      if (s || typeof u !== 'string') {
-        for (var v in u) {
-          i.call(this, v, u[v]);
-        }
-        if (p) {
-          for (let w = p.length; w--;) {
-            v = p[w];
-            if (u.hasOwnProperty(v)) {
-              i.call(this, v, u[v]);
-            }
-          }
-        }
-      } else {
-        i.call(this, u, t);
-      }
-      return this;
-    };
-  };
-  f.prototype.extend = function (i, s) {
-    this[i] = s;
-  }.overloadSetter();
-  f.prototype.implement = function (i, s) {
-    this.prototype[i] = s;
-  }.overloadSetter();
-  const n = Array.prototype.slice;
-  Array.from = function (i) {
-    if (i == null) {
-      return [];
-    }
-    return (a.isEnumerable(i) && typeof i !== 'string') ? (o(i) == 'array') ? i : n.call(i) : [i];
-  };
-  f.implement({
-    hide() {
-      this.$hidden = true;
-      return this;
-    },
-    protect() {
-      this.$protected = true;
-      return this;
-    },
-  });
-  var a = this.Type = function (u, t) {
-    if (u) {
-      const s = u.toLowerCase();
-      const i = function (v) {
-        return (o(v) == s);
-      };
-      a[`is${u}`] = i;
-      if (t != null) {
-        t.prototype.$family = (function () {
-          return s;
-        }).hide();
-      }
-    }
-    if (t == null) {
-      return null;
-    }
-    t.extend(this);
-    t.$constructor = a;
-    t.prototype.$constructor = t;
-    return t;
-  };
-  const e = Object.prototype.toString;
-  a.isEnumerable = function (i) {
-    return (i != null && typeof i.length === 'number' && e.call(i) != '[object Function]');
-  };
-  const q = {};
-  const r = function (i) {
-    const s = o(i.prototype);
-    return q[s] || (q[s] = []);
-  };
-  var b = function (t, x) {
-    if (x && x.$hidden) {
-      return;
-    }
-    const s = r(this);
-    for (let u = 0; u < s.length;
-      u++) {
-      const w = s[u];
-      if (o(w) == 'type') {
-        b.call(w, t, x);
-      } else {
-        w.call(this, t, x);
-      }
-    }
-    const v = this.prototype[t];
-    if (v == null || !v.$protected) {
-      this.prototype[t] = x;
-    }
-    if (this[t] == null && o(x) == 'function') {
-      m.call(this, t, function (i) {
-        return x.apply(i, n.call(arguments, 1));
-      });
-    }
-  };
-  var m = function (i, t) {
-    if (t && t.$hidden) {
-      return;
-    }
-    const s = this[i];
-    if (s == null || !s.$protected) {
-      this[i] = t;
-    }
-  };
-  a.implement({
-    implement: b.overloadSetter(),
-    extend: m.overloadSetter(),
-    alias: function (i, s) {
-      b.call(this, i, this.prototype[s]);
-    }.overloadSetter(),
-    mirror(i) {
-      r(this).push(i);
-      return this;
-    },
-  });
-  new a('Type', a);
-  var d = function (s, x, v) {
-    const u = (x != Object); const
-      B = x.prototype;
-    if (u) {
-      x = new a(s, x);
-    }
-    for (let y = 0, w = v.length; y < w; y++) {
-      const C = v[y]; const A = x[C]; const
-        z = B[C];
-      if (A) {
-        A.protect();
-      }
-      if (u && z) {
-        x.implement(C, z.protect());
-      }
-    }
-    if (u) {
-      const t = B.propertyIsEnumerable(v[0]);
-      x.forEachMethod = function (G) {
-        if (!t) {
-          for (let F = 0, D = v.length; F < D; F++) {
-            G.call(B, B[v[F]], v[F]);
-          }
-        }
-        for (const E in B) {
-          G.call(B, B[E], E);
-        }
-      };
-    }
-    return d;
-  };
-  d('String', String, ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search', 'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'])('Array', Array, ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice', 'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight'])('Number', Number, ['toExponential', 'toFixed', 'toLocaleString', 'toPrecision'])('Function', f, ['apply', 'call', 'bind'])('RegExp', RegExp, ['exec', 'test'])('Object', Object, ['create', 'defineProperty', 'defineProperties', 'keys', 'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'])('Date', Date, ['now']);
-  Object.extend = m.overloadSetter();
-  Date.extend('now', () => +(new Date()));
-  new a('Boolean', Boolean);
-  Number.prototype.$family = function () {
-    return isFinite(this) ? 'number' : 'null';
-  }.hide();
-  Number.extend('random', (s, i) => Math.floor(Math.random() * (i - s + 1) + s));
-  const g = Object.prototype.hasOwnProperty;
-  Object.extend('forEach', (i, t, u) => {
-    for (const s in i) {
-      if (g.call(i, s)) {
-        t.call(u, i[s], s, i);
-      }
-    }
-  });
-  Object.each = Object.forEach;
-  Array.implement({
-    forEach(u, v) {
-      for (let t = 0, s = this.length; t < s; t++) {
-        if (t in this) {
-          u.call(v, this[t], t, this);
-        }
-      }
-    },
-    each(i, s) {
-      Array.forEach(this, i, s);
-      return this;
-    },
-  });
-  const l = function (i) {
-    switch (o(i)) {
-      case 'array':
-        return i.clone();
-      case 'object':
-        return Object.clone(i);
-      default:
-        return i;
-    }
-  };
-  Array.implement('clone', function () {
-    let s = this.length; const
-      t = new Array(s);
-    while (s--) {
-      t[s] = l(this[s]);
-    }
-    return t;
-  });
-  const h = function (s, i, t) {
-    switch (o(t)) {
-      case 'object':
-        if (o(s[i]) == 'object') {
-          Object.merge(s[i], t);
-        } else {
-          s[i] = Object.clone(t);
-        }
-        break;
-      case 'array':
-        s[i] = t.clone();
-        break;
-      default:
-        s[i] = t;
-    }
-    return s;
-  };
-  Object.extend({
-    merge(z, u, t) {
-      if (o(u) == 'string') {
-        return h(z, u, t);
-      }
-      for (let y = 1, s = arguments.length;
-        y < s; y++) {
-        const w = arguments[y];
-        for (const x in w) {
-          h(z, x, w[x]);
-        }
-      }
-      return z;
-    },
-    clone(i) {
-      const t = {};
-      for (const s in i) {
-        t[s] = l(i[s]);
-      }
-      return t;
-    },
-    append(w) {
-      for (let v = 1, t = arguments.length;
-        v < t; v++) {
-        const s = arguments[v] || {};
-        for (const u in s) {
-          w[u] = s[u];
-        }
-      }
-      return w;
-    },
-  });
-  ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each((i) => {
-    new a(i);
-  });
-  let c = Date.now();
-  String.extend('uniqueID', () => (c++).toString(36));
-}());
-
-Array.implement({
-  filter(d, f) {
-    const c = [];
-    for (var e, b = 0, a = this.length >>> 0; b < a; b++) {
-      if (b in this) {
-        e = this[b];
-        if (d.call(f, e, b, this)) {
-          c.push(e);
-        }
-      }
-    }
-    return c;
-  },
-  indexOf(c, d) {
-    const b = this.length >>> 0;
-    for (let a = (d < 0) ? Math.max(0, b + d) : d || 0; a < b; a++) {
-      if (this[a] === c) {
-        return a;
-      }
-    }
-    return -1;
-  },
-  map(c, e) {
-    const d = this.length >>> 0; const
-      b = Array(d);
-    for (let a = 0; a < d; a++) {
-      if (a in this) {
-        b[a] = c.call(e, this[a], a, this);
-      }
-    }
-    return b;
-  },
-  some(c, d) {
-    for (let b = 0, a = this.length >>> 0;
-      b < a; b++) {
-      if ((b in this) && c.call(d, this[b], b, this)) {
-        return true;
-      }
-    }
-    return false;
-  },
-  clean() {
-    return this.filter((a) => a != null);
-  },
-  contains(a, b) {
-    return this.indexOf(a, b) != -1;
-  },
-  append(a) {
-    this.push.apply(this, a);
-    return this;
-  },
-  getLast() {
-    return (this.length) ? this[this.length - 1] : null;
-  },
-  include(a) {
-    if (!this.contains(a)) {
-      this.push(a);
-    }
-    return this;
-  },
-  erase(b) {
-    for (let a = this.length; a--;) {
-      if (this[a] === b) {
-        this.splice(a, 1);
-      }
-    }
-    return this;
-  },
-  empty() {
-    this.length = 0;
-    return this;
-  },
-  flatten() {
-    let d = [];
-    for (let b = 0, a = this.length; b < a; b++) {
-      const c = typeOf(this[b]);
-      if (c == 'null') {
-        continue;
-      }
-      d = d.concat((c == 'array' || c == 'collection' || c == 'arguments' || instanceOf(this[b], Array)) ? Array.flatten(this[b]) : this[b]);
-    }
-    return d;
-  },
-  pick() {
-    for (let b = 0, a = this.length; b < a; b++) {
-      if (this[b] != null) {
-        return this[b];
-      }
-    }
-    return null;
-  },
-  rgbToHex(d) {
-    if (this.length < 3) {
-      return null;
-    }
-    if (this.length == 4 && this[3] == 0 && !d) {
-      return 'transparent';
-    }
-    const b = [];
-    for (let a = 0; a < 3; a++) {
-      const c = (this[a] - 0).toString(16);
-      b.push((c.length == 1) ? `0${c}` : c);
-    }
-    return (d) ? b : `#${b.join('')}`;
-  },
-});
-String.implement({
-  test(a, b) {
-    return ((typeOf(a) == 'regexp') ? a : new RegExp(`${a}`, b)).test(this);
-  },
-  contains(a, b) {
-    return (b) ? (b + this + b).indexOf(b + a + b) > -1 : String(this).indexOf(a) > -1;
-  },
-  capitalize() {
-    return String(this).replace(/\b[a-z]/g, (a) => a.toUpperCase());
-  },
-  rgbToHex(b) {
-    const a = String(this).match(/\d{1,3}/g);
-    return (a) ? a.rgbToHex(b) : null;
-  },
-});
-Function.implement({
-  bind(e) {
-    const a = this; const b = arguments.length > 1 ? Array.slice(arguments, 1) : null; const
-      d = function () {
-      };
-    var c = function () {
-      let g = e; const
-        h = arguments.length;
-      if (this instanceof c) {
-        d.prototype = a.prototype;
-        g = new d();
-      }
-      const f = (!b && !h) ? a.call(g) : a.apply(g, b && h ? b.concat(Array.slice(arguments)) : b || arguments);
-      return g == e ? f : g;
-    };
-    return c;
-  },
-  pass(b, c) {
-    const a = this;
-    if (b != null) {
-      b = Array.from(b);
-    }
-    return function () {
-      return a.apply(c, b || arguments);
-    };
-  },
-  delay(b, c, a) {
-    return setTimeout(this.pass((a == null ? [] : a), c), b);
-  },
-});
-
-Number.alias('each', 'times');
-(function (b) {
-  const a = {};
-  b.each((c) => {
-    if (!Number[c]) {
-      a[c] = function () {
-        return Math[c].apply(null, [this].concat(Array.from(arguments)));
-      };
-    }
-  });
-  Number.implement(a);
-}(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan']));
-
-(function () {
-  var a = this.Class = new Type('Class', function (h) {
-    if (instanceOf(h, Function)) {
-      h = { initialize: h };
-    }
-    var g = function () {
-      e(this);
-      if (g.$prototyping) {
-        return this;
-      }
-      this.$caller = null;
-      const i = (this.initialize) ? this.initialize.apply(this, arguments) : this;
-      this.$caller = this.caller = null;
-      return i;
-    }.extend(this).implement(h);
-    g.$constructor = a;
-    g.prototype.$constructor = g;
-    g.prototype.parent = c;
-    return g;
-  });
-  var c = function () {
-    if (!this.$caller) {
-      throw new Error('The method "parent" cannot be called.');
-    }
-    const g = this.$caller.$name; const h = this.$caller.$owner.parent; const
-      i = (h) ? h.prototype[g] : null;
-    if (!i) {
-      throw new Error(`The method "${g}" has no parent.`);
-    }
-    return i.apply(this, arguments);
-  };
-  var e = function (g) {
-    for (const h in g) {
-      const j = g[h];
-      switch (typeOf(j)) {
-        case 'object':
-          var i = function () {
-          };
-          i.prototype = j;
-          g[h] = e(new i());
-          break;
-        case 'array':
-          g[h] = j.clone();
-          break;
-      }
-    }
-    return g;
-  };
-  const b = function (g, h, j) {
-    if (j.$origin) {
-      j = j.$origin;
-    }
-    var i = function () {
-      if (j.$protected && this.$caller == null) {
-        throw new Error(`The method "${h}" cannot be called.`);
-      }
-      const l = this.caller; const
-        m = this.$caller;
-      this.caller = m;
-      this.$caller = i;
-      const k = j.apply(this, arguments);
-      this.$caller = m;
-      this.caller = l;
-      return k;
-    }.extend({ $owner: g, $origin: j, $name: h });
-    return i;
-  };
-  const f = function (h, i, g) {
-    if (a.Mutators.hasOwnProperty(h)) {
-      i = a.Mutators[h].call(this, i);
-      if (i == null) {
-        return this;
-      }
-    }
-    if (typeOf(i) == 'function') {
-      if (i.$hidden) {
-        return this;
-      }
-      this.prototype[h] = (g) ? i : b(this, h, i);
-    } else {
-      Object.merge(this.prototype, h, i);
-    }
-    return this;
-  };
-  const d = function (g) {
-    g.$prototyping = true;
-    const h = new g();
-    delete g.$prototyping;
-    return h;
-  };
-  a.implement('implement', f.overloadSetter());
-  a.Mutators = {
-    Extends(g) {
-      this.parent = g;
-      this.prototype = d(g);
-    },
-    Implements(g) {
-      Array.from(g).each(function (j) {
-        const h = new j();
-        for (const i in h) {
-          f.call(this, i, h[i], true);
-        }
-      }, this);
-    },
-  };
-}());
diff --git a/packages/mindplot/src/components/libraries/mootools/mootools-core-1.4.5.js b/packages/mindplot/src/components/libraries/mootools/mootools-core-1.4.5.js
deleted file mode 100644
index 260c965f..00000000
--- a/packages/mindplot/src/components/libraries/mootools/mootools-core-1.4.5.js
+++ /dev/null
@@ -1,271 +0,0 @@
-/*
- ---
- MooTools: the javascript framework
-
- web build:
- - http://mootools.net/core/b28139f033891d55fabb70ffafd6813b
-
- packager build:
- - packager build Core/Core Core/Array Core/Class Core/Class.Extras
-
- copyrights:
- - [MooTools](http://mootools.net)
-
- licenses:
- - [MIT License](http://mootools.net/license.txt)
- ...
- */
-
-(function () {
-  this.MooTools = { version: '1.4.5', build: 'ab8ea8824dc3b24b6666867a2c4ed58ebb762cf0' }; const o = this.typeOf = function (i) {
-    if (i == null) { return 'null'; } if (i.$family != null) {
-      return i.$family();
-    } if (i.nodeName) { if (i.nodeType == 1) { return 'element'; } if (i.nodeType == 3) { return (/\S/).test(i.nodeValue) ? 'textnode' : 'whitespace'; } } else if (typeof i.length === 'number') {
-      if (i.callee) {
-        return 'arguments';
-      } if ('item' in i) { return 'collection'; }
-    } return typeof i;
-  }; const j = this.instanceOf = function (t, i) {
-    if (t == null) { return false; } let s = t.$constructor || t.constructor;
-    while (s) { if (s === i) { return true; }s = s.parent; } if (!t.hasOwnProperty) { return false; } return t instanceof i;
-  }; const f = this.Function; let p = true; for (const k in { toString: 1 }) {
-    p = null;
-  } if (p) { p = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor']; }f.prototype.overloadSetter = function (s) {
-    const i = this;
-    return function (u, t) {
-      if (u == null) { return this; } if (s || typeof u !== 'string') {
-        for (var v in u) { i.call(this, v, u[v]); } if (p) {
-          for (let w = p.length; w--;) {
-            v = p[w]; if (u.hasOwnProperty(v)) {
-              i.call(this, v, u[v]);
-            }
-          }
-        }
-      } else { i.call(this, u, t); } return this;
-    };
-  }; f.prototype.overloadGetter = function (s) {
-    const i = this; return function (u) {
-      let v; let t; if (typeof u !== 'string') { v = u; } else if (arguments.length > 1) {
-        v = arguments;
-      } else if (s) { v = [u]; } if (v) { t = {}; for (let w = 0; w < v.length; w++) { t[v[w]] = i.call(this, v[w]); } } else { t = i.call(this, u); } return t;
-    };
-  }; f.prototype.extend = function (i, s) {
-    this[i] = s;
-  }.overloadSetter(); f.prototype.implement = function (i, s) { this.prototype[i] = s; }.overloadSetter(); const n = Array.prototype.slice; f.from = function (i) {
-    return (o(i) == 'function') ? i : function () {
-      return i;
-    };
-  }; Array.from = function (i) { if (i == null) { return []; } return (a.isEnumerable(i) && typeof i !== 'string') ? (o(i) == 'array') ? i : n.call(i) : [i]; }; Number.from = function (s) {
-    const i = parseFloat(s);
-    return isFinite(i) ? i : null;
-  }; String.from = function (i) { return `${i}`; }; f.implement({
-    hide() { this.$hidden = true; return this; },
-    protect() {
-      this.$protected = true;
-      return this;
-    },
-  }); var a = this.Type = function (u, t) {
-    if (u) {
-      const s = u.toLowerCase(); const i = function (v) { return (o(v) == s); }; a[`is${u}`] = i; if (t != null) {
-        t.prototype.$family = (function () {
-          return s;
-        }).hide();
-      }
-    } if (t == null) { return null; }t.extend(this); t.$constructor = a; t.prototype.$constructor = t; return t;
-  }; const e = Object.prototype.toString; a.isEnumerable = function (i) {
-    return (i != null && typeof i.length === 'number' && e.call(i) != '[object Function]');
-  }; const q = {}; const r = function (i) { const s = o(i.prototype); return q[s] || (q[s] = []); }; var b = function (t, x) {
-    if (x && x.$hidden) { return; } const s = r(this); for (let u = 0; u < s.length;
-      u++) { const w = s[u]; if (o(w) == 'type') { b.call(w, t, x); } else { w.call(this, t, x); } } const v = this.prototype[t]; if (v == null || !v.$protected) { this.prototype[t] = x; } if (this[t] == null && o(x) == 'function') {
-      m.call(this, t, function (i) {
-        return x.apply(i, n.call(arguments, 1));
-      });
-    }
-  }; var m = function (i, t) { if (t && t.$hidden) { return; } const s = this[i]; if (s == null || !s.$protected) { this[i] = t; } }; a.implement({
-    implement: b.overloadSetter(),
-    extend: m.overloadSetter(),
-    alias: function (i, s) {
-      b.call(this, i, this.prototype[s]);
-    }.overloadSetter(),
-    mirror(i) { r(this).push(i); return this; },
-  }); new a('Type', a); var d = function (s, x, v) {
-    const u = (x != Object); const B = x.prototype; if (u) {
-      x = new a(s, x);
-    } for (let y = 0, w = v.length; y < w; y++) { const C = v[y]; const A = x[C]; const z = B[C]; if (A) { A.protect(); } if (u && z) { x.implement(C, z.protect()); } } if (u) {
-      const t = B.propertyIsEnumerable(v[0]);
-      x.forEachMethod = function (G) { if (!t) { for (let F = 0, D = v.length; F < D; F++) { G.call(B, B[v[F]], v[F]); } } for (const E in B) { G.call(B, B[E], E); } };
-    } return d;
-  }; d('String', String, ['charAt', 'charCodeAt', 'concat', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search', 'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase'])('Array', Array, ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice', 'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight'])('Number', Number, ['toExponential', 'toFixed', 'toLocaleString', 'toPrecision'])('Function', f, ['apply', 'call', 'bind'])('RegExp', RegExp, ['exec', 'test'])('Object', Object, ['create', 'defineProperty', 'defineProperties', 'keys', 'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames', 'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen'])('Date', Date, ['now']);
-  Object.extend = m.overloadSetter(); Date.extend('now', () => +(new Date())); new a('Boolean', Boolean); Number.prototype.$family = function () {
-    return isFinite(this) ? 'number' : 'null';
-  }.hide(); Number.extend('random', (s, i) => Math.floor(Math.random() * (i - s + 1) + s)); const g = Object.prototype.hasOwnProperty; Object.extend('forEach', (i, t, u) => {
-    for (const s in i) {
-      if (g.call(i, s)) {
-        t.call(u, i[s], s, i);
-      }
-    }
-  }); Object.each = Object.forEach; Array.implement({
-    forEach(u, v) { for (let t = 0, s = this.length; t < s; t++) { if (t in this) { u.call(v, this[t], t, this); } } },
-    each(i, s) {
-      Array.forEach(this, i, s);
-      return this;
-    },
-  }); const l = function (i) { switch (o(i)) { case 'array': return i.clone(); case 'object': return Object.clone(i); default: return i; } }; Array.implement('clone', function () {
-    let s = this.length; const t = new Array(s);
-    while (s--) { t[s] = l(this[s]); } return t;
-  }); const h = function (s, i, t) {
-    switch (o(t)) {
-      case 'object': if (o(s[i]) == 'object') { Object.merge(s[i], t); } else {
-        s[i] = Object.clone(t);
-      } break; case 'array': s[i] = t.clone(); break; default: s[i] = t;
-    } return s;
-  }; Object.extend({
-    merge(z, u, t) {
-      if (o(u) == 'string') { return h(z, u, t); } for (let y = 1, s = arguments.length;
-        y < s; y++) { const w = arguments[y]; for (const x in w) { h(z, x, w[x]); } } return z;
-    },
-    clone(i) { const t = {}; for (const s in i) { t[s] = l(i[s]); } return t; },
-    append(w) {
-      for (let v = 1, t = arguments.length;
-        v < t; v++) { const s = arguments[v] || {}; for (const u in s) { w[u] = s[u]; } } return w;
-    },
-  }); ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each((i) => {
-    new a(i);
-  }); let c = Date.now(); String.extend('uniqueID', () => (c++).toString(36));
-}()); Array.implement({
-  every(c, d) {
-    for (let b = 0, a = this.length >>> 0;
-      b < a; b++) { if ((b in this) && !c.call(d, this[b], b, this)) { return false; } } return true;
-  },
-  filter(d, f) {
-    const c = []; for (var e, b = 0, a = this.length >>> 0; b < a; b++) {
-      if (b in this) {
-        e = this[b];
-        if (d.call(f, e, b, this)) { c.push(e); }
-      }
-    } return c;
-  },
-  indexOf(c, d) {
-    const b = this.length >>> 0; for (let a = (d < 0) ? Math.max(0, b + d) : d || 0; a < b; a++) {
-      if (this[a] === c) {
-        return a;
-      }
-    } return -1;
-  },
-  map(c, e) { const d = this.length >>> 0; const b = Array(d); for (let a = 0; a < d; a++) { if (a in this) { b[a] = c.call(e, this[a], a, this); } } return b; },
-  some(c, d) {
-    for (let b = 0, a = this.length >>> 0;
-      b < a; b++) { if ((b in this) && c.call(d, this[b], b, this)) { return true; } } return false;
-  },
-  clean() { return this.filter((a) => a != null); },
-  invoke(a) {
-    const b = Array.slice(arguments, 1);
-    return this.map((c) => c[a].apply(c, b));
-  },
-  associate(c) {
-    const d = {}; const b = Math.min(this.length, c.length); for (let a = 0; a < b; a++) {
-      d[c[a]] = this[a];
-    } return d;
-  },
-  link(c) { const a = {}; for (let e = 0, b = this.length; e < b; e++) { for (const d in c) { if (c[d](this[e])) { a[d] = this[e]; delete c[d]; break; } } } return a; },
-  contains(a, b) {
-    return this.indexOf(a, b) != -1;
-  },
-  append(a) { this.push.apply(this, a); return this; },
-  getLast() { return (this.length) ? this[this.length - 1] : null; },
-  getRandom() {
-    return (this.length) ? this[Number.random(0, this.length - 1)] : null;
-  },
-  include(a) { if (!this.contains(a)) { this.push(a); } return this; },
-  combine(c) {
-    for (let b = 0, a = c.length; b < a; b++) { this.include(c[b]); } return this;
-  },
-  erase(b) { for (let a = this.length; a--;) { if (this[a] === b) { this.splice(a, 1); } } return this; },
-  empty() { this.length = 0; return this; },
-  flatten() {
-    let d = [];
-    for (let b = 0, a = this.length; b < a; b++) {
-      const c = typeOf(this[b]); if (c == 'null') { continue; }d = d.concat((c == 'array' || c == 'collection' || c == 'arguments' || instanceOf(this[b], Array)) ? Array.flatten(this[b]) : this[b]);
-    } return d;
-  },
-  pick() { for (let b = 0, a = this.length; b < a; b++) { if (this[b] != null) { return this[b]; } } return null; },
-  rgbToHex(d) {
-    if (this.length < 3) { return null; } if (this.length == 4 && this[3] == 0 && !d) {
-      return 'transparent';
-    } const b = []; for (let a = 0; a < 3; a++) { const c = (this[a] - 0).toString(16); b.push((c.length == 1) ? `0${c}` : c); } return (d) ? b : `#${b.join('')}`;
-  },
-}); String.implement({
-  test(a, b) {
-    return ((typeOf(a) == 'regexp') ? a : new RegExp(`${a}`, b)).test(this);
-  },
-  contains(a, b) { return (b) ? (b + this + b).indexOf(b + a + b) > -1 : String(this).indexOf(a) > -1; },
-  trim() {
-    return String(this).replace(/^\s+|\s+$/g, '');
-  },
-  clean() { return String(this).replace(/\s+/g, ' ').trim(); },
-  camelCase() {
-    return String(this).replace(/-\D/g, (a) => a.charAt(1).toUpperCase());
-  },
-  hyphenate() { return String(this).replace(/[A-Z]/g, (a) => (`-${a.charAt(0).toLowerCase()}`)); },
-  capitalize() {
-    return String(this).replace(/\b[a-z]/g, (a) => a.toUpperCase());
-  },
-  escapeRegExp() { return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1'); },
-  rgbToHex(b) {
-    const a = String(this).match(/\d{1,3}/g);
-    return (a) ? a.rgbToHex(b) : null;
-  },
-  substitute(a, b) {
-    return String(this).replace(b || (/\\?\{([^{}]+)\}/g), (d, c) => {
-      if (d.charAt(0) == '\\') {
-        return d.slice(1);
-      } return (a[c] != null) ? a[c] : '';
-    });
-  },
-});
-Function.implement({ bind(e) { const a = this; const b = arguments.length > 1 ? Array.slice(arguments, 1) : null; const d = function () {}; var c = function () { let g = e; const h = arguments.length; if (this instanceof c) { d.prototype = a.prototype; g = new d(); } const f = (!b && !h) ? a.call(g) : a.apply(g, b && h ? b.concat(Array.slice(arguments)) : b || arguments); return g == e ? f : g; }; return c; }, pass(b, c) { const a = this; if (b != null) { b = Array.from(b); } return function () { return a.apply(c, b || arguments); }; }, delay(b, c, a) { return setTimeout(this.pass((a == null ? [] : a), c), b); } });
-Number.alias('each', 'times'); (function (b) {
-  const a = {}; b.each((c) => {
-    if (!Number[c]) {
-      a[c] = function () {
-        return Math[c].apply(null, [this].concat(Array.from(arguments)));
-      };
-    }
-  }); Number.implement(a);
-}(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan'])); (function () {
-  var a = this.Class = new Type('Class', function (h) {
-    if (instanceOf(h, Function)) {
-      h = { initialize: h };
-    } var g = function () {
-      e(this); if (g.$prototyping) { return this; } this.$caller = null; const i = (this.initialize) ? this.initialize.apply(this, arguments) : this; this.$caller = this.caller = null;
-      return i;
-    }.extend(this).implement(h); g.$constructor = a; g.prototype.$constructor = g; g.prototype.parent = c; return g;
-  }); var c = function () {
-    if (!this.$caller) {
-      throw new Error('The method "parent" cannot be called.');
-    } const g = this.$caller.$name; const h = this.$caller.$owner.parent; const i = (h) ? h.prototype[g] : null; if (!i) { throw new Error(`The method "${g}" has no parent.`); } return i.apply(this, arguments);
-  }; var e = function (g) {
-    for (const h in g) {
-      const j = g[h]; switch (typeOf(j)) {
-        case 'object': var i = function () {}; i.prototype = j; g[h] = e(new i()); break; case 'array': g[h] = j.clone();
-          break;
-      }
-    } return g;
-  }; const b = function (g, h, j) {
-    if (j.$origin) { j = j.$origin; } var i = function () {
-      if (j.$protected && this.$caller == null) {
-        throw new Error(`The method "${h}" cannot be called.`);
-      } const l = this.caller; const m = this.$caller; this.caller = m; this.$caller = i; const k = j.apply(this, arguments); this.$caller = m; this.caller = l; return k;
-    }.extend({ $owner: g, $origin: j, $name: h });
-    return i;
-  }; const f = function (h, i, g) {
-    if (a.Mutators.hasOwnProperty(h)) { i = a.Mutators[h].call(this, i); if (i == null) { return this; } } if (typeOf(i) == 'function') {
-      if (i.$hidden) {
-        return this;
-      } this.prototype[h] = (g) ? i : b(this, h, i);
-    } else { Object.merge(this.prototype, h, i); } return this;
-  }; const d = function (g) {
-    g.$prototyping = true; const h = new g(); delete g.$prototyping;
-    return h;
-  }; a.implement('implement', f.overloadSetter()); a.Mutators = { Extends(g) { this.parent = g; this.prototype = d(g); }, Implements(g) { Array.from(g).each(function (j) { const h = new j(); for (const i in h) { f.call(this, i, h[i], true); } }, this); } };
-}());
diff --git a/packages/mindplot/src/components/libraries/mootools/mootools-core-1.6.0.js b/packages/mindplot/src/components/libraries/mootools/mootools-core-1.6.0.js
deleted file mode 100644
index 63f0cd25..00000000
--- a/packages/mindplot/src/components/libraries/mootools/mootools-core-1.6.0.js
+++ /dev/null
@@ -1,6429 +0,0 @@
-/* MooTools: the javascript framework. license: MIT-style license. copyright: Copyright (c) 2006-2021 [Valerio Proietti](https://mootools.net/). */
-/*!
-Web Build: https://mootools.net/core/builder/e426a9ae7167c5807b173d5deff673fc
-*/
-/*
----
-
-name: Core
-
-description: The heart of MooTools.
-
-license: MIT-style license.
-
-copyright: Copyright (c) 2006-2015 [Valerio Proietti](https://github.com/kamicane/).
-
-authors: The MooTools production team (http://mootools.net/developers/)
-
-inspiration:
-  - Class implementation inspired by [Base.js](http://dean.edwards.name/weblog/2006/03/base/) Copyright (c) 2006 Dean Edwards, [GNU Lesser General Public License](http://opensource.org/licenses/lgpl-license.php)
-  - Some functionality inspired by [Prototype.js](http://prototypejs.org) Copyright (c) 2005-2007 Sam Stephenson, [MIT License](http://opensource.org/licenses/mit-license.php)
-
-provides: [Core, MooTools, Type, typeOf, instanceOf, Native]
-
-...
-*/
-/*! MooTools: the javascript framework. license: MIT-style license. copyright: Copyright (c) 2006-2015 [Valerio Proietti](https://github.com/kamicane/). */
-(function () {
-  this.MooTools = {
-    version: '1.6.0',
-    build: '529422872adfff401b901b8b6c7ca5114ee95e2b',
-  };
-
-  // typeOf, instanceOf
-
-  const typeOf = this.typeOf = function (item) {
-    if (item == null) return 'null';
-    if (item.$family != null) return item.$family();
-
-    if (item.nodeName) {
-      if (item.nodeType == 1) return 'element';
-      if (item.nodeType == 3) return (/\S/).test(item.nodeValue) ? 'textnode' : 'whitespace';
-    } else if (typeof item.length === 'number') {
-      if ('callee' in item) return 'arguments';
-      if ('item' in item) return 'collection';
-    }
-
-    return typeof item;
-  };
-
-  const instanceOf = this.instanceOf = function (item, object) {
-    if (item == null) return false;
-    let constructor = item.$constructor || item.constructor;
-    while (constructor) {
-      if (constructor === object) return true;
-      constructor = constructor.parent;
-    }
-    /* <ltIE8> */
-    if (!item.hasOwnProperty) return false;
-    /* </ltIE8> */
-    return item instanceof object;
-  };
-
-  const { hasOwnProperty } = Object.prototype;
-
-  /* <ltIE8> */
-  let enumerables = true;
-  for (const i in { toString: 1 }) enumerables = null;
-  if (enumerables) enumerables = ['hasOwnProperty', 'valueOf', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'constructor'];
-  function forEachObjectEnumberableKey(object, fn, bind) {
-    if (enumerables) {
-      for (let i = enumerables.length; i--;) {
-        const k = enumerables[i];
-        // signature has key-value, so overloadSetter can directly pass the
-        // method function, without swapping arguments.
-        if (hasOwnProperty.call(object, k)) fn.call(bind, k, object[k]);
-      }
-    }
-  }
-  /* </ltIE8> */
-
-  // Function overloading
-
-  const { Function } = this;
-
-  Function.prototype.overloadSetter = function (usePlural) {
-    const self = this;
-    return function (a, b) {
-      if (a == null) return this;
-      if (usePlural || typeof a !== 'string') {
-        for (const k in a) self.call(this, k, a[k]);
-        /* <ltIE8> */
-        forEachObjectEnumberableKey(a, self, this);
-        /* </ltIE8> */
-      } else {
-        self.call(this, a, b);
-      }
-      return this;
-    };
-  };
-
-  Function.prototype.overloadGetter = function (usePlural) {
-    const self = this;
-    return function (a) {
-      let args; let
-        result;
-      if (typeof a !== 'string') args = a;
-      else if (arguments.length > 1) args = arguments;
-      else if (usePlural) args = [a];
-      if (args) {
-        result = {};
-        for (let i = 0; i < args.length; i++) result[args[i]] = self.call(this, args[i]);
-      } else {
-        result = self.call(this, a);
-      }
-      return result;
-    };
-  };
-
-  Function.prototype.extend = function (key, value) {
-    this[key] = value;
-  }.overloadSetter();
-
-  Function.prototype.implement = function (key, value) {
-    this.prototype[key] = value;
-  }.overloadSetter();
-
-  // From
-
-  const { slice } = Array.prototype;
-
-  Array.convert = function (item) {
-    if (item == null) return [];
-    return (Type.isEnumerable(item) && typeof item !== 'string') ? (typeOf(item) == 'array') ? item : slice.call(item) : [item];
-  };
-
-  Function.convert = function (item) {
-    return (typeOf(item) == 'function') ? item : function () {
-      return item;
-    };
-  };
-
-  Number.convert = function (item) {
-    const number = parseFloat(item);
-    return isFinite(number) ? number : null;
-  };
-
-  String.convert = function (item) {
-    return `${item}`;
-  };
-
-  Function.from = Function.convert;
-  Number.from = Number.convert;
-  String.from = String.convert;
-
-  // hide, protect
-
-  Function.implement({
-
-    hide() {
-      this.$hidden = true;
-      return this;
-    },
-
-    protect() {
-      this.$protected = true;
-      return this;
-    },
-
-  });
-
-  // Type
-
-  var Type = this.Type = function (name, object) {
-    if (name) {
-      const lower = name.toLowerCase();
-      const typeCheck = function (item) {
-        return (typeOf(item) == lower);
-      };
-
-      Type[`is${name}`] = typeCheck;
-      if (object != null) {
-        object.prototype.$family = (function () {
-          return lower;
-        }).hide();
-      }
-    }
-
-    if (object == null) return null;
-
-    object.extend(this);
-    object.$constructor = Type;
-    object.prototype.$constructor = object;
-
-    return object;
-  };
-
-  const { toString } = Object.prototype;
-
-  Type.isEnumerable = function (item) {
-    return (item != null && typeof item.length === 'number' && toString.call(item) != '[object Function]');
-  };
-
-  const hooks = {};
-
-  const hooksOf = function (object) {
-    const type = typeOf(object.prototype);
-    return hooks[type] || (hooks[type] = []);
-  };
-
-  var implement = function (name, method) {
-    if (method && method.$hidden) return;
-
-    const hooks = hooksOf(this);
-
-    for (let i = 0; i < hooks.length; i++) {
-      const hook = hooks[i];
-      if (typeOf(hook) == 'type') implement.call(hook, name, method);
-      else hook.call(this, name, method);
-    }
-
-    const previous = this.prototype[name];
-    if (previous == null || !previous.$protected) this.prototype[name] = method;
-
-    if (this[name] == null && typeOf(method) == 'function') {
-      extend.call(this, name, function (item) {
-        return method.apply(item, slice.call(arguments, 1));
-      });
-    }
-  };
-
-  var extend = function (name, method) {
-    if (method && method.$hidden) return;
-    const previous = this[name];
-    if (previous == null || !previous.$protected) this[name] = method;
-  };
-
-  Type.implement({
-
-    implement: implement.overloadSetter(),
-
-    extend: extend.overloadSetter(),
-
-    alias: function (name, existing) {
-      implement.call(this, name, this.prototype[existing]);
-    }.overloadSetter(),
-
-    mirror(hook) {
-      hooksOf(this).push(hook);
-      return this;
-    },
-
-  });
-
-  new Type('Type', Type);
-
-  // Default Types
-
-  var force = function (name, object, methods) {
-    const isType = (object != Object);
-    const { prototype } = object;
-
-    if (isType) object = new Type(name, object);
-
-    for (let i = 0, l = methods.length; i < l; i++) {
-      const key = methods[i];
-      const generic = object[key];
-      const proto = prototype[key];
-
-      if (generic) generic.protect();
-      if (isType && proto) object.implement(key, proto.protect());
-    }
-
-    if (isType) {
-      const methodsEnumerable = prototype.propertyIsEnumerable(methods[0]);
-      object.forEachMethod = function (fn) {
-        if (!methodsEnumerable) {
-          for (let i = 0, l = methods.length; i < l; i++) {
-            fn.call(prototype, prototype[methods[i]], methods[i]);
-          }
-        }
-        for (const key in prototype) fn.call(prototype, prototype[key], key);
-      };
-    }
-
-    return force;
-  };
-
-  force('String', String, [
-    'charAt', 'charCodeAt', 'concat', 'contains', 'indexOf', 'lastIndexOf', 'match', 'quote', 'replace', 'search',
-    'slice', 'split', 'substr', 'substring', 'trim', 'toLowerCase', 'toUpperCase',
-  ])('Array', Array, [
-    'pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice',
-    'indexOf', 'lastIndexOf', 'filter', 'forEach', 'every', 'map', 'some', 'reduce', 'reduceRight', 'contains',
-  ])('Number', Number, [
-    'toExponential', 'toFixed', 'toLocaleString', 'toPrecision',
-  ])('Function', Function, [
-    'apply', 'call', 'bind',
-  ])('RegExp', RegExp, [
-    'exec', 'test',
-  ])('Object', Object, [
-    'create', 'defineProperty', 'defineProperties', 'keys',
-    'getPrototypeOf', 'getOwnPropertyDescriptor', 'getOwnPropertyNames',
-    'preventExtensions', 'isExtensible', 'seal', 'isSealed', 'freeze', 'isFrozen',
-  ])('Date', Date, ['now']);
-
-  Object.extend = extend.overloadSetter();
-
-  Date.extend('now', () => +(new Date()));
-
-  new Type('Boolean', Boolean);
-
-  // fixes NaN returning as Number
-
-  Number.prototype.$family = function () {
-    return isFinite(this) ? 'number' : 'null';
-  }.hide();
-
-  // Number.random
-
-  Number.extend('random', (min, max) => Math.floor(Math.random() * (max - min + 1) + min));
-
-  // forEach, each, keys
-
-  Array.implement({
-
-    /* <!ES5> */
-    forEach(fn, bind) {
-      for (let i = 0, l = this.length; i < l; i++) {
-        if (i in this) fn.call(bind, this[i], i, this);
-      }
-    },
-    /* </!ES5> */
-
-    each(fn, bind) {
-      Array.forEach(this, fn, bind);
-      return this;
-    },
-
-  });
-
-  Object.extend({
-
-    keys(object) {
-      const keys = [];
-      for (const k in object) {
-        if (hasOwnProperty.call(object, k)) keys.push(k);
-      }
-      /* <ltIE8> */
-      forEachObjectEnumberableKey(object, (k) => {
-        keys.push(k);
-      });
-      /* </ltIE8> */
-      return keys;
-    },
-
-    forEach(object, fn, bind) {
-      Object.keys(object).forEach((key) => {
-        fn.call(bind, object[key], key, object);
-      });
-    },
-
-  });
-
-  Object.each = Object.forEach;
-
-  // Array & Object cloning, Object merging and appending
-
-  const cloneOf = function (item) {
-    switch (typeOf(item)) {
-      case 'array': return item.clone();
-      case 'object': return Object.clone(item);
-      default: return item;
-    }
-  };
-
-  Array.implement('clone', function () {
-    let i = this.length; const
-      clone = new Array(i);
-    while (i--) clone[i] = cloneOf(this[i]);
-    return clone;
-  });
-
-  const mergeOne = function (source, key, current) {
-    switch (typeOf(current)) {
-      case 'object':
-        if (typeOf(source[key]) == 'object') Object.merge(source[key], current);
-        else source[key] = Object.clone(current);
-        break;
-      case 'array': source[key] = current.clone(); break;
-      default: source[key] = current;
-    }
-    return source;
-  };
-
-  Object.extend({
-
-    merge(source, k, v) {
-      if (typeOf(k) == 'string') return mergeOne(source, k, v);
-      for (let i = 1, l = arguments.length; i < l; i++) {
-        const object = arguments[i];
-        for (const key in object) mergeOne(source, key, object[key]);
-      }
-      return source;
-    },
-
-    clone(object) {
-      const clone = {};
-      for (const key in object) clone[key] = cloneOf(object[key]);
-      return clone;
-    },
-
-    append(original) {
-      for (let i = 1, l = arguments.length; i < l; i++) {
-        const extended = arguments[i] || {};
-        for (const key in extended) original[key] = extended[key];
-      }
-      return original;
-    },
-
-  });
-
-  // Object-less types
-
-  ['Object', 'WhiteSpace', 'TextNode', 'Collection', 'Arguments'].each((name) => {
-    new Type(name);
-  });
-
-  // Unique ID
-
-  let UID = Date.now();
-
-  String.extend('uniqueID', () => (UID++).toString(36));
-}());
-
-/*
----
-
-name: Array
-
-description: Contains Array Prototypes like each, contains, and erase.
-
-license: MIT-style license.
-
-requires: [Type]
-
-provides: Array
-
-...
-*/
-
-Array.implement({
-
-  /* <!ES5> */
-  every(fn, bind) {
-    for (let i = 0, l = this.length >>> 0; i < l; i++) {
-      if ((i in this) && !fn.call(bind, this[i], i, this)) return false;
-    }
-    return true;
-  },
-
-  filter(fn, bind) {
-    const results = [];
-    for (var value, i = 0, l = this.length >>> 0; i < l; i++) {
-      if (i in this) {
-        value = this[i];
-        if (fn.call(bind, value, i, this)) results.push(value);
-      }
-    }
-    return results;
-  },
-
-  indexOf(item, from) {
-    const length = this.length >>> 0;
-    for (let i = (from < 0) ? Math.max(0, length + from) : from || 0; i < length; i++) {
-      if (this[i] === item) return i;
-    }
-    return -1;
-  },
-
-  map(fn, bind) {
-    const length = this.length >>> 0; const
-      results = Array(length);
-    for (let i = 0; i < length; i++) {
-      if (i in this) results[i] = fn.call(bind, this[i], i, this);
-    }
-    return results;
-  },
-
-  some(fn, bind) {
-    for (let i = 0, l = this.length >>> 0; i < l; i++) {
-      if ((i in this) && fn.call(bind, this[i], i, this)) return true;
-    }
-    return false;
-  },
-  /* </!ES5> */
-
-  clean() {
-    return this.filter((item) => item != null);
-  },
-
-  invoke(methodName) {
-    const args = Array.slice(arguments, 1);
-    return this.map((item) => item[methodName].apply(item, args));
-  },
-
-  associate(keys) {
-    const obj = {}; const
-      length = Math.min(this.length, keys.length);
-    for (let i = 0; i < length; i++) obj[keys[i]] = this[i];
-    return obj;
-  },
-
-  link(object) {
-    const result = {};
-    for (let i = 0, l = this.length; i < l; i++) {
-      for (const key in object) {
-        if (object[key](this[i])) {
-          result[key] = this[i];
-          delete object[key];
-          break;
-        }
-      }
-    }
-    return result;
-  },
-
-  contains(item, from) {
-    return this.indexOf(item, from) != -1;
-  },
-
-  append(array) {
-    this.push.apply(this, array);
-    return this;
-  },
-
-  getLast() {
-    return (this.length) ? this[this.length - 1] : null;
-  },
-
-  getRandom() {
-    return (this.length) ? this[Number.random(0, this.length - 1)] : null;
-  },
-
-  include(item) {
-    if (!this.contains(item)) this.push(item);
-    return this;
-  },
-
-  combine(array) {
-    for (let i = 0, l = array.length; i < l; i++) this.include(array[i]);
-    return this;
-  },
-
-  erase(item) {
-    for (let i = this.length; i--;) {
-      if (this[i] === item) this.splice(i, 1);
-    }
-    return this;
-  },
-
-  empty() {
-    this.length = 0;
-    return this;
-  },
-
-  flatten() {
-    let array = [];
-    for (let i = 0, l = this.length; i < l; i++) {
-      const type = typeOf(this[i]);
-      if (type == 'null') continue;
-      array = array.concat((type == 'array' || type == 'collection' || type == 'arguments' || instanceOf(this[i], Array)) ? Array.flatten(this[i]) : this[i]);
-    }
-    return array;
-  },
-
-  pick() {
-    for (let i = 0, l = this.length; i < l; i++) {
-      if (this[i] != null) return this[i];
-    }
-    return null;
-  },
-
-  hexToRgb(array) {
-    if (this.length != 3) return null;
-    const rgb = this.map((value) => {
-      if (value.length == 1) value += value;
-      return parseInt(value, 16);
-    });
-    return (array) ? rgb : `rgb(${rgb})`;
-  },
-
-  rgbToHex(array) {
-    if (this.length < 3) return null;
-    if (this.length == 4 && this[3] == 0 && !array) return 'transparent';
-    const hex = [];
-    for (let i = 0; i < 3; i++) {
-      const bit = (this[i] - 0).toString(16);
-      hex.push((bit.length == 1) ? `0${bit}` : bit);
-    }
-    return (array) ? hex : `#${hex.join('')}`;
-  },
-
-});
-
-/*
----
-
-name: Function
-
-description: Contains Function Prototypes like create, bind, pass, and delay.
-
-license: MIT-style license.
-
-requires: Type
-
-provides: Function
-
-...
-*/
-
-Function.extend({
-
-  attempt() {
-    for (let i = 0, l = arguments.length; i < l; i++) {
-      try {
-        return arguments[i]();
-      } catch (e) {}
-    }
-    return null;
-  },
-
-});
-
-Function.implement({
-
-  attempt(args, bind) {
-    try {
-      return this.apply(bind, Array.convert(args));
-    } catch (e) {}
-
-    return null;
-  },
-
-  /* <!ES5-bind> */
-  bind(that) {
-    const self = this;
-    const args = arguments.length > 1 ? Array.slice(arguments, 1) : null;
-    const F = function () {};
-
-    var bound = function () {
-      let context = that; const
-        { length } = arguments;
-      if (this instanceof bound) {
-        F.prototype = self.prototype;
-        context = new F();
-      }
-      const result = (!args && !length)
-        ? self.call(context)
-        : self.apply(context, args && length ? args.concat(Array.slice(arguments)) : args || arguments);
-      return context == that ? result : context;
-    };
-    return bound;
-  },
-  /* </!ES5-bind> */
-
-  pass(args, bind) {
-    const self = this;
-    if (args != null) args = Array.convert(args);
-    return function () {
-      return self.apply(bind, args || arguments);
-    };
-  },
-
-  delay(delay, bind, args) {
-    return setTimeout(this.pass((args == null ? [] : args), bind), delay);
-  },
-
-  periodical(periodical, bind, args) {
-    return setInterval(this.pass((args == null ? [] : args), bind), periodical);
-  },
-
-});
-
-/*
----
-
-name: Number
-
-description: Contains Number Prototypes like limit, round, times, and ceil.
-
-license: MIT-style license.
-
-requires: Type
-
-provides: Number
-
-...
-*/
-
-Number.implement({
-
-  limit(min, max) {
-    return Math.min(max, Math.max(min, this));
-  },
-
-  round(precision) {
-    precision = Math.pow(10, precision || 0).toFixed(precision < 0 ? -precision : 0);
-    return Math.round(this * precision) / precision;
-  },
-
-  times(fn, bind) {
-    for (let i = 0; i < this; i++) fn.call(bind, i, this);
-  },
-
-  toFloat() {
-    return parseFloat(this);
-  },
-
-  toInt(base) {
-    return parseInt(this, base || 10);
-  },
-
-});
-
-Number.alias('each', 'times');
-
-(function (math) {
-  const methods = {};
-
-  math.each((name) => {
-    if (!Number[name]) {
-      methods[name] = function () {
-        return Math[name].apply(null, [this].concat(Array.convert(arguments)));
-      };
-    }
-  });
-
-  Number.implement(methods);
-}(['abs', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'exp', 'floor', 'log', 'max', 'min', 'pow', 'sin', 'sqrt', 'tan']));
-
-/*
----
-
-name: String
-
-description: Contains String Prototypes like camelCase, capitalize, test, and toInt.
-
-license: MIT-style license.
-
-requires: [Type, Array]
-
-provides: String
-
-...
-*/
-
-String.implement({
-
-  // <!ES6>
-  contains(string, index) {
-    return (index ? String(this).slice(index) : String(this)).indexOf(string) > -1;
-  },
-  // </!ES6>
-
-  test(regex, params) {
-    return ((typeOf(regex) == 'regexp') ? regex : new RegExp(`${regex}`, params)).test(this);
-  },
-
-  trim() {
-    return String(this).replace(/^\s+|\s+$/g, '');
-  },
-
-  clean() {
-    return String(this).replace(/\s+/g, ' ').trim();
-  },
-
-  camelCase() {
-    return String(this).replace(/-\D/g, (match) => match.charAt(1).toUpperCase());
-  },
-
-  hyphenate() {
-    return String(this).replace(/[A-Z]/g, (match) => (`-${match.charAt(0).toLowerCase()}`));
-  },
-
-  capitalize() {
-    return String(this).replace(/\b[a-z]/g, (match) => match.toUpperCase());
-  },
-
-  escapeRegExp() {
-    return String(this).replace(/([-.*+?^${}()|[\]\/\\])/g, '\\$1');
-  },
-
-  toInt(base) {
-    return parseInt(this, base || 10);
-  },
-
-  toFloat() {
-    return parseFloat(this);
-  },
-
-  hexToRgb(array) {
-    const hex = String(this).match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
-    return (hex) ? hex.slice(1).hexToRgb(array) : null;
-  },
-
-  rgbToHex(array) {
-    const rgb = String(this).match(/\d{1,3}/g);
-    return (rgb) ? rgb.rgbToHex(array) : null;
-  },
-
-  substitute(object, regexp) {
-    return String(this).replace(regexp || (/\\?\{([^{}]+)\}/g), (match, name) => {
-      if (match.charAt(0) == '\\') return match.slice(1);
-      return (object[name] != null) ? object[name] : '';
-    });
-  },
-
-});
-
-/*
----
-
-name: Browser
-
-description: The Browser Object. Contains Browser initialization, Window and Document, and the Browser Hash.
-
-license: MIT-style license.
-
-requires: [Array, Function, Number, String]
-
-provides: [Browser, Window, Document]
-
-...
-*/
-
-(function () {
-  let { document } = this;
-  let window = document.window = this;
-
-  const parse = function (ua, platform) {
-    ua = ua.toLowerCase();
-    platform = (platform ? platform.toLowerCase() : '');
-
-    // chrome is included in the edge UA, so need to check for edge first,
-    // before checking if it's chrome.
-    let UA = ua.match(/(edge)[\s\/:]([\w\d\.]+)/);
-    if (!UA) {
-      UA = ua.match(/(opera|ie|firefox|chrome|trident|crios|version)[\s\/:]([\w\d\.]+)?.*?(safari|(?:rv[\s\/:]|version[\s\/:])([\w\d\.]+)|$)/) || [null, 'unknown', 0];
-    }
-
-    if (UA[1] == 'trident') {
-      UA[1] = 'ie';
-      if (UA[4]) UA[2] = UA[4];
-    } else if (UA[1] == 'crios') {
-      UA[1] = 'chrome';
-    }
-
-    platform = ua.match(/ip(?:ad|od|hone)/) ? 'ios' : (ua.match(/(?:webos|android)/) || ua.match(/mac|win|linux/) || ['other'])[0];
-    if (platform == 'win') platform = 'windows';
-
-    return {
-      extend: Function.prototype.extend,
-      name: (UA[1] == 'version') ? UA[3] : UA[1],
-      version: parseFloat((UA[1] == 'opera' && UA[4]) ? UA[4] : UA[2]),
-      platform,
-    };
-  };
-
-  const Browser = this.Browser = parse(navigator.userAgent, navigator.platform);
-
-  if (Browser.name == 'ie' && document.documentMode) {
-    Browser.version = document.documentMode;
-  }
-
-  Browser.extend({
-    Features: {
-      xpath: !!(document.evaluate),
-      air: !!(window.runtime),
-      query: !!(document.querySelector),
-      json: !!(window.JSON),
-    },
-    parseUA: parse,
-  });
-
-  // Request
-
-  Browser.Request = (function () {
-    const XMLHTTP = function () {
-      return new XMLHttpRequest();
-    };
-
-    const MSXML2 = function () {
-      return new ActiveXObject('MSXML2.XMLHTTP');
-    };
-
-    const MSXML = function () {
-      return new ActiveXObject('Microsoft.XMLHTTP');
-    };
-
-    return Function.attempt(() => {
-      XMLHTTP();
-      return XMLHTTP;
-    }, () => {
-      MSXML2();
-      return MSXML2;
-    }, () => {
-      MSXML();
-      return MSXML;
-    });
-  }());
-
-  Browser.Features.xhr = !!(Browser.Request);
-
-  // String scripts
-
-  Browser.exec = function (text) {
-    if (!text) return text;
-    if (window.execScript) {
-      window.execScript(text);
-    } else {
-      const script = document.createElement('script');
-      script.setAttribute('type', 'text/javascript');
-      script.text = text;
-      document.head.appendChild(script);
-      document.head.removeChild(script);
-    }
-    return text;
-  };
-
-  String.implement('stripScripts', function (exec) {
-    let scripts = '';
-    const text = this.replace(/<script[^>]*>([\s\S]*?)<\/script>/gi, (all, code) => {
-      scripts += `${code}\n`;
-      return '';
-    });
-    if (exec === true) Browser.exec(scripts);
-    else if (typeOf(exec) == 'function') exec(scripts, text);
-    return text;
-  });
-
-  // Window, Document
-
-  Browser.extend({
-    Document: this.Document,
-    Window: this.Window,
-    Element: this.Element,
-    Event: this.Event,
-  });
-
-  this.Window = this.$constructor = new Type('Window', (() => {}));
-
-  this.$family = Function.convert('window').hide();
-
-  Window.mirror((name, method) => {
-    window[name] = method;
-  });
-
-  this.Document = document.$constructor = new Type('Document', (() => {}));
-
-  document.$family = Function.convert('document').hide();
-
-  Document.mirror((name, method) => {
-    document[name] = method;
-  });
-
-  document.html = document.documentElement;
-  if (!document.head) document.head = document.getElementsByTagName('head')[0];
-
-  if (document.execCommand) {
-    try {
-      document.execCommand('BackgroundImageCache', false, true);
-    } catch (e) {}
-  }
-
-  /* <ltIE9> */
-  if (this.attachEvent && !this.addEventListener) {
-    var unloadEvent = function () {
-      this.detachEvent('onunload', unloadEvent);
-      document.head = document.html = document.window = null;
-      window = this.Window = document = null;
-    };
-    this.attachEvent('onunload', unloadEvent);
-  }
-
-  // IE fails on collections and <select>.options (refers to <select>)
-  const arrayFrom = Array.convert;
-  try {
-    arrayFrom(document.html.childNodes);
-  } catch (e) {
-    Array.convert = function (item) {
-      if (typeof item !== 'string' && Type.isEnumerable(item) && typeOf(item) != 'array') {
-        let i = item.length; const
-          array = new Array(i);
-        while (i--) array[i] = item[i];
-        return array;
-      }
-      return arrayFrom(item);
-    };
-
-    const { prototype } = Array;
-    const { slice } = prototype;
-    ['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift', 'concat', 'join', 'slice'].each((name) => {
-      const method = prototype[name];
-      Array[name] = function (item) {
-        return method.apply(Array.convert(item), slice.call(arguments, 1));
-      };
-    });
-  }
-  /* </ltIE9> */
-}());
-
-/*
----
-
-name: Class
-
-description: Contains the Class Function for easily creating, extending, and implementing reusable Classes.
-
-license: MIT-style license.
-
-requires: [Array, String, Function, Number]
-
-provides: Class
-
-...
-*/
-
-(function () {
-  var Class = this.Class = new Type('Class', function (params) {
-    if (instanceOf(params, Function)) params = { initialize: params };
-
-    var newClass = function () {
-      reset(this);
-      if (newClass.$prototyping) return this;
-      this.$caller = null;
-      this.$family = null;
-      const value = (this.initialize) ? this.initialize.apply(this, arguments) : this;
-      this.$caller = this.caller = null;
-      return value;
-    }.extend(this).implement(params);
-
-    newClass.$constructor = Class;
-    newClass.prototype.$constructor = newClass;
-    newClass.prototype.parent = parent;
-
-    return newClass;
-  });
-
-  var parent = function () {
-    if (!this.$caller) throw new Error('The method "parent" cannot be called.');
-    const name = this.$caller.$name;
-    const { parent } = this.$caller.$owner;
-    const previous = (parent) ? parent.prototype[name] : null;
-    if (!previous) throw new Error(`The method "${name}" has no parent.`);
-    return previous.apply(this, arguments);
-  };
-
-  var reset = function (object) {
-    for (const key in object) {
-      const value = object[key];
-      switch (typeOf(value)) {
-        case 'object':
-          var F = function () {};
-          F.prototype = value;
-          object[key] = reset(new F());
-          break;
-        case 'array': object[key] = value.clone(); break;
-      }
-    }
-    return object;
-  };
-
-  const wrap = function (self, key, method) {
-    if (method.$origin) method = method.$origin;
-    var wrapper = function () {
-      if (method.$protected && this.$caller == null) throw new Error(`The method "${key}" cannot be called.`);
-      const { caller } = this;
-      const current = this.$caller;
-      this.caller = current; this.$caller = wrapper;
-      const result = method.apply(this, arguments);
-      this.$caller = current; this.caller = caller;
-      return result;
-    }.extend({ $owner: self, $origin: method, $name: key });
-    return wrapper;
-  };
-
-  const implement = function (key, value, retain) {
-    if (Class.Mutators.hasOwnProperty(key)) {
-      value = Class.Mutators[key].call(this, value);
-      if (value == null) return this;
-    }
-
-    if (typeOf(value) == 'function') {
-      if (value.$hidden) return this;
-      this.prototype[key] = (retain) ? value : wrap(this, key, value);
-    } else {
-      Object.merge(this.prototype, key, value);
-    }
-
-    return this;
-  };
-
-  const getInstance = function (klass) {
-    klass.$prototyping = true;
-    const proto = new klass();
-    delete klass.$prototyping;
-    return proto;
-  };
-
-  Class.implement('implement', implement.overloadSetter());
-
-  Class.Mutators = {
-
-    Extends(parent) {
-      this.parent = parent;
-      this.prototype = getInstance(parent);
-    },
-
-    Implements(items) {
-      Array.convert(items).each(function (item) {
-        const instance = new item();
-        for (const key in instance) implement.call(this, key, instance[key], true);
-      }, this);
-    },
-  };
-}());
-
-/*
----
-
-name: Class.Extras
-
-description: Contains Utility Classes that can be implemented into your own Classes to ease the execution of many common tasks.
-
-license: MIT-style license.
-
-requires: Class
-
-provides: [Class.Extras, Chain, Events, Options]
-
-...
-*/
-
-(function () {
-  this.Chain = new Class({
-
-    $chain: [],
-
-    chain() {
-      this.$chain.append(Array.flatten(arguments));
-      return this;
-    },
-
-    callChain() {
-      return (this.$chain.length) ? this.$chain.shift().apply(this, arguments) : false;
-    },
-
-    clearChain() {
-      this.$chain.empty();
-      return this;
-    },
-
-  });
-
-  const removeOn = function (string) {
-    return string.replace(/^on([A-Z])/, (full, first) => first.toLowerCase());
-  };
-
-  this.Events = new Class({
-
-    $events: {},
-
-    addEvent(type, fn, internal) {
-      type = removeOn(type);
-
-      this.$events[type] = (this.$events[type] || []).include(fn);
-      if (internal) fn.internal = true;
-      return this;
-    },
-
-    addEvents(events) {
-      for (const type in events) this.addEvent(type, events[type]);
-      return this;
-    },
-
-    fireEvent(type, args, delay) {
-      type = removeOn(type);
-      const events = this.$events[type];
-      if (!events) return this;
-      args = Array.convert(args);
-      events.each(function (fn) {
-        if (delay) fn.delay(delay, this, args);
-        else fn.apply(this, args);
-      }, this);
-      return this;
-    },
-
-    removeEvent(type, fn) {
-      type = removeOn(type);
-      const events = this.$events[type];
-      if (events && !fn.internal) {
-        const index = events.indexOf(fn);
-        if (index != -1) delete events[index];
-      }
-      return this;
-    },
-
-    removeEvents(events) {
-      let type;
-      if (typeOf(events) == 'object') {
-        for (type in events) this.removeEvent(type, events[type]);
-        return this;
-      }
-      if (events) events = removeOn(events);
-      for (type in this.$events) {
-        if (events && events != type) continue;
-        const fns = this.$events[type];
-        for (let i = fns.length; i--;) {
-          if (i in fns) {
-            this.removeEvent(type, fns[i]);
-          }
-        }
-      }
-      return this;
-    },
-
-  });
-
-  this.Options = new Class({
-
-    setOptions() {
-      const options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
-      if (this.addEvent) {
-        for (const option in options) {
-          if (typeOf(options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
-          this.addEvent(option, options[option]);
-          delete options[option];
-        }
-      }
-      return this;
-    },
-
-  });
-}());
-
-/*
----
-
-name: Class.Thenable
-
-description: Contains a Utility Class that can be implemented into your own Classes to make them "thenable".
-
-license: MIT-style license.
-
-requires: Class
-
-provides: [Class.Thenable]
-
-...
-*/
-
-(function () {
-  const STATE_PENDING = 0;
-  const STATE_FULFILLED = 1;
-  const STATE_REJECTED = 2;
-
-  var Thenable = Class.Thenable = new Class({
-
-    $thenableState: STATE_PENDING,
-    $thenableResult: null,
-    $thenableReactions: [],
-
-    resolve(value) {
-      resolve(this, value);
-      return this;
-    },
-
-    reject(reason) {
-      reject(this, reason);
-      return this;
-    },
-
-    getThenableState() {
-      switch (this.$thenableState) {
-        case STATE_PENDING:
-          return 'pending';
-
-        case STATE_FULFILLED:
-          return 'fulfilled';
-
-        case STATE_REJECTED:
-          return 'rejected';
-      }
-    },
-
-    resetThenable(reason) {
-      reject(this, reason);
-      reset(this);
-      return this;
-    },
-
-    then(onFulfilled, onRejected) {
-      if (typeof onFulfilled !== 'function') onFulfilled = 'Identity';
-      if (typeof onRejected !== 'function') onRejected = 'Thrower';
-
-      const thenable = new Thenable();
-
-      this.$thenableReactions.push({
-        thenable,
-        fulfillHandler: onFulfilled,
-        rejectHandler: onRejected,
-      });
-
-      if (this.$thenableState !== STATE_PENDING) {
-        react(this);
-      }
-
-      return thenable;
-    },
-
-    catch(onRejected) {
-      return this.then(null, onRejected);
-    },
-
-  });
-
-  Thenable.extend({
-    resolve(value) {
-      let thenable;
-      if (value instanceof Thenable) {
-        thenable = value;
-      } else {
-        thenable = new Thenable();
-        resolve(thenable, value);
-      }
-      return thenable;
-    },
-    reject(reason) {
-      const thenable = new Thenable();
-      reject(thenable, reason);
-      return thenable;
-    },
-  });
-
-  // Private functions
-
-  function resolve(thenable, value) {
-    if (thenable.$thenableState === STATE_PENDING) {
-      if (thenable === value) {
-        reject(thenable, new TypeError('Tried to resolve a thenable with itself.'));
-      } else if (value && (typeof value === 'object' || typeof value === 'function')) {
-        let then;
-        try {
-          then = value.then;
-        } catch (exception) {
-          reject(thenable, exception);
-        }
-        if (typeof then === 'function') {
-          let resolved = false;
-          defer(() => {
-            try {
-              then.call(
-                value,
-                (nextValue) => {
-                  if (!resolved) {
-                    resolved = true;
-                    resolve(thenable, nextValue);
-                  }
-                },
-                (reason) => {
-                  if (!resolved) {
-                    resolved = true;
-                    reject(thenable, reason);
-                  }
-                },
-              );
-            } catch (exception) {
-              if (!resolved) {
-                resolved = true;
-                reject(thenable, exception);
-              }
-            }
-          });
-        } else {
-          fulfill(thenable, value);
-        }
-      } else {
-        fulfill(thenable, value);
-      }
-    }
-  }
-
-  function fulfill(thenable, value) {
-    if (thenable.$thenableState === STATE_PENDING) {
-      thenable.$thenableResult = value;
-      thenable.$thenableState = STATE_FULFILLED;
-
-      react(thenable);
-    }
-  }
-
-  function reject(thenable, reason) {
-    if (thenable.$thenableState === STATE_PENDING) {
-      thenable.$thenableResult = reason;
-      thenable.$thenableState = STATE_REJECTED;
-
-      react(thenable);
-    }
-  }
-
-  function reset(thenable) {
-    if (thenable.$thenableState !== STATE_PENDING) {
-      thenable.$thenableResult = null;
-      thenable.$thenableState = STATE_PENDING;
-    }
-  }
-
-  function react(thenable) {
-    const state = thenable.$thenableState;
-    const result = thenable.$thenableResult;
-    const reactions = thenable.$thenableReactions;
-    let type;
-
-    if (state === STATE_FULFILLED) {
-      thenable.$thenableReactions = [];
-      type = 'fulfillHandler';
-    } else if (state == STATE_REJECTED) {
-      thenable.$thenableReactions = [];
-      type = 'rejectHandler';
-    }
-
-    if (type) {
-      defer(handle.pass([result, reactions, type]));
-    }
-  }
-
-  function handle(result, reactions, type) {
-    for (let i = 0, l = reactions.length; i < l; ++i) {
-      const reaction = reactions[i];
-      const handler = reaction[type];
-
-      if (handler === 'Identity') {
-        resolve(reaction.thenable, result);
-      } else if (handler === 'Thrower') {
-        reject(reaction.thenable, result);
-      } else {
-        try {
-          resolve(reaction.thenable, handler(result));
-        } catch (exception) {
-          reject(reaction.thenable, exception);
-        }
-      }
-    }
-  }
-
-  let defer;
-  if (typeof process !== 'undefined' && typeof process.nextTick === 'function') {
-    defer = process.nextTick;
-  } else if (typeof setImmediate !== 'undefined') {
-    defer = setImmediate;
-  } else {
-    defer = function (fn) {
-      setTimeout(fn, 0);
-    };
-  }
-}());
-
-/*
----
-
-name: Object
-
-description: Object generic methods
-
-license: MIT-style license.
-
-requires: Type
-
-provides: [Object, Hash]
-
-...
-*/
-
-(function () {
-  Object.extend({
-
-    subset(object, keys) {
-      const results = {};
-      for (let i = 0, l = keys.length; i < l; i++) {
-        const k = keys[i];
-        if (k in object) results[k] = object[k];
-      }
-      return results;
-    },
-
-    map(object, fn, bind) {
-      const results = {};
-      const keys = Object.keys(object);
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        results[key] = fn.call(bind, object[key], key, object);
-      }
-      return results;
-    },
-
-    filter(object, fn, bind) {
-      const results = {};
-      const keys = Object.keys(object);
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i]; const
-          value = object[key];
-        if (fn.call(bind, value, key, object)) results[key] = value;
-      }
-      return results;
-    },
-
-    every(object, fn, bind) {
-      const keys = Object.keys(object);
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        if (!fn.call(bind, object[key], key)) return false;
-      }
-      return true;
-    },
-
-    some(object, fn, bind) {
-      const keys = Object.keys(object);
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        if (fn.call(bind, object[key], key)) return true;
-      }
-      return false;
-    },
-
-    values(object) {
-      const values = [];
-      const keys = Object.keys(object);
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i];
-        values.push(object[k]);
-      }
-      return values;
-    },
-
-    getLength(object) {
-      return Object.keys(object).length;
-    },
-
-    keyOf(object, value) {
-      const keys = Object.keys(object);
-      for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        if (object[key] === value) return key;
-      }
-      return null;
-    },
-
-    contains(object, value) {
-      return Object.keyOf(object, value) != null;
-    },
-
-    toQueryString(object, base) {
-      const queryString = [];
-
-      Object.each(object, (value, key) => {
-        if (base) key = `${base}[${key}]`;
-        let result;
-        switch (typeOf(value)) {
-          case 'object': result = Object.toQueryString(value, key); break;
-          case 'array':
-            var qs = {};
-            value.each((val, i) => {
-              qs[i] = val;
-            });
-            result = Object.toQueryString(qs, key);
-            break;
-          default: result = `${key}=${encodeURIComponent(value)}`;
-        }
-        if (value != null) queryString.push(result);
-      });
-
-      return queryString.join('&');
-    },
-
-  });
-}());
-
-/*
----
-name: Slick.Parser
-description: Standalone CSS3 Selector parser
-provides: Slick.Parser
-...
-*/
-
-(function () {
-  let parsed;
-  let separatorIndex;
-  let combinatorIndex;
-  let reversed;
-  const cache = {};
-  const reverseCache = {};
-  const reUnescape = /\\/g;
-
-  var parse = function (expression, isReversed) {
-    if (expression == null) return null;
-    if (expression.Slick === true) return expression;
-    expression = (`${expression}`).replace(/^\s+|\s+$/g, '');
-    reversed = !!isReversed;
-    const currentCache = (reversed) ? reverseCache : cache;
-    if (currentCache[expression]) return currentCache[expression];
-    parsed = {
-      Slick: true,
-      expressions: [],
-      raw: expression,
-      reverse() {
-        return parse(this.raw, true);
-      },
-    };
-    separatorIndex = -1;
-    while (expression != (expression = expression.replace(regexp, parser)));
-    parsed.length = parsed.expressions.length;
-    return currentCache[parsed.raw] = (reversed) ? reverse(parsed) : parsed;
-  };
-
-  const reverseCombinator = function (combinator) {
-    if (combinator === '!') return ' ';
-    if (combinator === ' ') return '!';
-    if ((/^!/).test(combinator)) return combinator.replace(/^!/, '');
-    return `!${combinator}`;
-  };
-
-  var reverse = function (expression) {
-    const { expressions } = expression;
-    for (let i = 0; i < expressions.length; i++) {
-      const exp = expressions[i];
-      const last = { parts: [], tag: '*', combinator: reverseCombinator(exp[0].combinator) };
-
-      for (let j = 0; j < exp.length; j++) {
-        const cexp = exp[j];
-        if (!cexp.reverseCombinator) cexp.reverseCombinator = ' ';
-        cexp.combinator = cexp.reverseCombinator;
-        delete cexp.reverseCombinator;
-      }
-
-      exp.reverse().push(last);
-    }
-    return expression;
-  };
-
-  const escapeRegExp = function (string) { // Credit: XRegExp 0.6.1 (c) 2007-2008 Steven Levithan <http://stevenlevithan.com/regex/xregexp/> MIT License
-    return string.replace(/[-[\]{}()*+?.\\^$|,#\s]/g, (match) => `\\${match}`);
-  };
-
-  var regexp = new RegExp(
-    /*
-#!/usr/bin/env ruby
-puts "\t\t" + DATA.read.gsub(/\(\?x\)|\s+#.*$|\s+|\\$|\\n/,'')
-__END__
-	"(?x)^(?:\
-	  \\s* ( , ) \\s*               # Separator          \n\
-	| \\s* ( <combinator>+ ) \\s*   # Combinator         \n\
-	|      ( \\s+ )                 # CombinatorChildren \n\
-	|      ( <unicode>+ | \\* )     # Tag                \n\
-	| \\#  ( <unicode>+       )     # ID                 \n\
-	| \\.  ( <unicode>+       )     # ClassName          \n\
-	|                               # Attribute          \n\
-	\\[  \
-		\\s* (<unicode1>+)  (?:  \
-			\\s* ([*^$!~|]?=)  (?:  \
-				\\s* (?:\
-					([\"']?)(.*?)\\9 \
-				)\
-			)  \
-		)?  \\s*  \
-	\\](?!\\]) \n\
-	|   :+ ( <unicode>+ )(?:\
-	\\( (?:\
-		(?:([\"'])([^\\12]*)\\12)|((?:\\([^)]+\\)|[^()]*)+)\
-	) \\)\
-	)?\
-	)"
-*/
-    "^(?:\\s*(,)\\s*|\\s*(<combinator>+)\\s*|(\\s+)|(<unicode>+|\\*)|\\#(<unicode>+)|\\.(<unicode>+)|\\[\\s*(<unicode1>+)(?:\\s*([*^$!~|]?=)(?:\\s*(?:([\"']?)(.*?)\\9)))?\\s*\\](?!\\])|(:+)(<unicode>+)(?:\\((?:(?:([\"'])([^\\13]*)\\13)|((?:\\([^)]+\\)|[^()]*)+))\\))?)"
-      .replace(/<combinator>/, `[${escapeRegExp('>+~`!@$%^&={}\\;</')}]`)
-      .replace(/<unicode>/g, '(?:[\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])')
-      .replace(/<unicode1>/g, '(?:[:\\w\\u00a1-\\uFFFF-]|\\\\[^\\s0-9a-f])'),
-  );
-
-  function parser(
-    rawMatch,
-
-    separator,
-    combinator,
-    combinatorChildren,
-
-    tagName,
-    id,
-    className,
-
-    attributeKey,
-    attributeOperator,
-    attributeQuote,
-    attributeValue,
-
-    pseudoMarker,
-    pseudoClass,
-    pseudoQuote,
-    pseudoClassQuotedValue,
-    pseudoClassValue,
-  ) {
-    if (separator || separatorIndex === -1) {
-      parsed.expressions[++separatorIndex] = [];
-      combinatorIndex = -1;
-      if (separator) return '';
-    }
-
-    if (combinator || combinatorChildren || combinatorIndex === -1) {
-      combinator = combinator || ' ';
-      const currentSeparator = parsed.expressions[separatorIndex];
-      if (reversed && currentSeparator[combinatorIndex]) currentSeparator[combinatorIndex].reverseCombinator = reverseCombinator(combinator);
-      currentSeparator[++combinatorIndex] = { combinator, tag: '*' };
-    }
-
-    const currentParsed = parsed.expressions[separatorIndex][combinatorIndex];
-
-    if (tagName) {
-      currentParsed.tag = tagName.replace(reUnescape, '');
-    } else if (id) {
-      currentParsed.id = id.replace(reUnescape, '');
-    } else if (className) {
-      className = className.replace(reUnescape, '');
-
-      if (!currentParsed.classList) currentParsed.classList = [];
-      if (!currentParsed.classes) currentParsed.classes = [];
-      currentParsed.classList.push(className);
-      currentParsed.classes.push({
-        value: className,
-        regexp: new RegExp(`(^|\\s)${escapeRegExp(className)}(\\s|$)`),
-      });
-    } else if (pseudoClass) {
-      pseudoClassValue = pseudoClassValue || pseudoClassQuotedValue;
-      pseudoClassValue = pseudoClassValue ? pseudoClassValue.replace(reUnescape, '') : null;
-
-      if (!currentParsed.pseudos) currentParsed.pseudos = [];
-      currentParsed.pseudos.push({
-        key: pseudoClass.replace(reUnescape, ''),
-        value: pseudoClassValue,
-        type: pseudoMarker.length == 1 ? 'class' : 'element',
-      });
-    } else if (attributeKey) {
-      attributeKey = attributeKey.replace(reUnescape, '');
-      attributeValue = (attributeValue || '').replace(reUnescape, '');
-
-      let test; let
-        regexp;
-
-      switch (attributeOperator) {
-        case '^=': regexp = new RegExp(`^${escapeRegExp(attributeValue)}`); break;
-        case '$=': regexp = new RegExp(`${escapeRegExp(attributeValue)}$`); break;
-        case '~=': regexp = new RegExp(`(^|\\s)${escapeRegExp(attributeValue)}(\\s|$)`); break;
-        case '|=': regexp = new RegExp(`^${escapeRegExp(attributeValue)}(-|$)`); break;
-        case '=': test = function (value) {
-          return attributeValue == value;
-        }; break;
-        case '*=': test = function (value) {
-          return value && value.indexOf(attributeValue) > -1;
-        }; break;
-        case '!=': test = function (value) {
-          return attributeValue != value;
-        }; break;
-        default: test = function (value) {
-          return !!value;
-        };
-      }
-
-      if (attributeValue == '' && (/^[*$^]=$/).test(attributeOperator)) {
-        test = function () {
-          return false;
-        };
-      }
-
-      if (!test) {
-        test = function (value) {
-          return value && regexp.test(value);
-        };
-      }
-
-      if (!currentParsed.attributes) currentParsed.attributes = [];
-      currentParsed.attributes.push({
-        key: attributeKey,
-        operator: attributeOperator,
-        value: attributeValue,
-        test,
-      });
-    }
-
-    return '';
-  }
-
-  // Slick NS
-
-  const Slick = (this.Slick || {});
-
-  Slick.parse = function (expression) {
-    return parse(expression);
-  };
-
-  Slick.escapeRegExp = escapeRegExp;
-
-  if (!this.Slick) this.Slick = Slick;
-}).apply(/* <CommonJS> */(typeof exports !== 'undefined') ? exports : /* </CommonJS> */this);
-
-/*
----
-name: Slick.Finder
-description: The new, superfast css selector engine.
-provides: Slick.Finder
-requires: Slick.Parser
-...
-*/
-
-(function () {
-  const local = {};
-  const featuresCache = {};
-  const { toString } = Object.prototype;
-
-  // Feature / Bug detection
-
-  local.isNativeCode = function (fn) {
-    return (/\{\s*\[native code\]\s*\}/).test(`${fn}`);
-  };
-
-  local.isXML = function (document) {
-    return (!!document.xmlVersion) || (!!document.xml) || (toString.call(document) == '[object XMLDocument]')
-	|| (document.nodeType == 9 && document.documentElement.nodeName != 'HTML');
-  };
-
-  local.setDocument = function (document) {
-    // convert elements / window arguments to document. if document cannot be extrapolated, the function returns.
-    const { nodeType } = document;
-    if (nodeType == 9); // document
-    else if (nodeType) document = document.ownerDocument; // node
-    else if (document.navigator) document = document.document; // window
-    else return;
-
-    // check if it's the old document
-
-    if (this.document === document) return;
-    this.document = document;
-
-    // check if we have done feature detection on this document before
-
-    let root = document.documentElement;
-    const rootUid = this.getUIDXML(root);
-    let features = featuresCache[rootUid];
-    let feature;
-
-    if (features) {
-      for (feature in features) {
-        this[feature] = features[feature];
-      }
-      return;
-    }
-
-    features = featuresCache[rootUid] = {};
-
-    features.root = root;
-    features.isXMLDocument = this.isXML(document);
-
-    features.brokenStarGEBTN	= features.starSelectsClosedQSA	= features.idGetsName	= features.brokenMixedCaseQSA	= features.brokenGEBCN	= features.brokenCheckedQSA	= features.brokenEmptyAttributeQSA	= features.isHTMLDocument	= features.nativeMatchesSelector	= false;
-
-    let starSelectsClosed; let starSelectsComments;
-    let brokenSecondClassNameGEBCN; let cachedGetElementsByClassName;
-    let brokenFormAttributeGetter;
-
-    let selected; const
-      id = 'slick_uniqueid';
-    let testNode = document.createElement('div');
-
-    let testRoot = document.body || document.getElementsByTagName('body')[0] || root;
-    testRoot.appendChild(testNode);
-
-    // on non-HTML documents innerHTML and getElementsById doesnt work properly
-    try {
-      testNode.innerHTML = `<a id="${id}"></a>`;
-      features.isHTMLDocument = !!document.getElementById(id);
-    } catch (e) {}
-
-    if (features.isHTMLDocument) {
-      testNode.style.display = 'none';
-
-      // IE returns comment nodes for getElementsByTagName('*') for some documents
-      testNode.appendChild(document.createComment(''));
-      starSelectsComments = (testNode.getElementsByTagName('*').length > 1);
-
-      // IE returns closed nodes (EG:"</foo>") for getElementsByTagName('*') for some documents
-      try {
-        testNode.innerHTML = 'foo</foo>';
-        selected = testNode.getElementsByTagName('*');
-        starSelectsClosed = (selected && !!selected.length && selected[0].nodeName.charAt(0) == '/');
-      } catch (e) {}
-
-      features.brokenStarGEBTN = starSelectsComments || starSelectsClosed;
-
-      // IE returns elements with the name instead of just id for getElementsById for some documents
-      try {
-        testNode.innerHTML = `<a name="${id}"></a><b id="${id}"></b>`;
-        features.idGetsName = document.getElementById(id) === testNode.firstChild;
-      } catch (e) {}
-
-      if (testNode.getElementsByClassName) {
-        // Safari 3.2 getElementsByClassName caches results
-        try {
-          testNode.innerHTML = '<a class="f"></a><a class="b"></a>';
-          testNode.getElementsByClassName('b').length;
-          testNode.firstChild.className = 'b';
-          cachedGetElementsByClassName = (testNode.getElementsByClassName('b').length != 2);
-        } catch (e) {}
-
-        // Opera 9.6 getElementsByClassName doesnt detects the class if its not the first one
-        try {
-          testNode.innerHTML = '<a class="a"></a><a class="f b a"></a>';
-          brokenSecondClassNameGEBCN = (testNode.getElementsByClassName('a').length != 2);
-        } catch (e) {}
-
-        features.brokenGEBCN = cachedGetElementsByClassName || brokenSecondClassNameGEBCN;
-      }
-
-      if (testNode.querySelectorAll) {
-        // IE 8 returns closed nodes (EG:"</foo>") for querySelectorAll('*') for some documents
-        try {
-          testNode.innerHTML = 'foo</foo>';
-          selected = testNode.querySelectorAll('*');
-          features.starSelectsClosedQSA = (selected && !!selected.length && selected[0].nodeName.charAt(0) == '/');
-        } catch (e) {}
-
-        // Safari 3.2 querySelectorAll doesnt work with mixedcase on quirksmode
-        try {
-          testNode.innerHTML = '<a class="MiX"></a>';
-          features.brokenMixedCaseQSA = !testNode.querySelectorAll('.MiX').length;
-        } catch (e) {}
-
-        // Webkit and Opera dont return selected options on querySelectorAll
-        try {
-          testNode.innerHTML = '<select><option selected="selected">a</option></select>';
-          features.brokenCheckedQSA = (testNode.querySelectorAll(':checked').length == 0);
-        } catch (e) {}
-
-        // IE returns incorrect results for attr[*^$]="" selectors on querySelectorAll
-        try {
-          testNode.innerHTML = '<a class=""></a>';
-          features.brokenEmptyAttributeQSA = (testNode.querySelectorAll('[class*=""]').length != 0);
-        } catch (e) {}
-      }
-
-      // IE6-7, if a form has an input of id x, form.getAttribute(x) returns a reference to the input
-      try {
-        testNode.innerHTML = '<form action="s"><input id="action"/></form>';
-        brokenFormAttributeGetter = (testNode.firstChild.getAttribute('action') != 's');
-      } catch (e) {}
-
-      // native matchesSelector function
-
-      features.nativeMatchesSelector = root.matches || /* root.msMatchesSelector || */ root.mozMatchesSelector || root.webkitMatchesSelector;
-      if (features.nativeMatchesSelector) {
-        try {
-        // if matchesSelector trows errors on incorrect sintaxes we can use it
-          features.nativeMatchesSelector.call(root, ':slick');
-          features.nativeMatchesSelector = null;
-        } catch (e) {}
-      }
-    }
-
-    try {
-      root.slick_expando = 1;
-      delete root.slick_expando;
-      features.getUID = this.getUIDHTML;
-    } catch (e) {
-      features.getUID = this.getUIDXML;
-    }
-
-    testRoot.removeChild(testNode);
-    testNode = selected = testRoot = null;
-
-    // getAttribute
-
-    features.getAttribute = (features.isHTMLDocument && brokenFormAttributeGetter) ? function (node, name) {
-      const method = this.attributeGetters[name];
-      if (method) return method.call(node);
-      const attributeNode = node.getAttributeNode(name);
-      return (attributeNode) ? attributeNode.nodeValue : null;
-    } : function (node, name) {
-      const method = this.attributeGetters[name];
-      return (method) ? method.call(node) : node.getAttribute(name);
-    };
-
-    // hasAttribute
-
-    features.hasAttribute = (root && this.isNativeCode(root.hasAttribute)) ? function (node, attribute) {
-      return node.hasAttribute(attribute);
-    } : function (node, attribute) {
-      node = node.getAttributeNode(attribute);
-      return !!(node && (node.specified || node.nodeValue));
-    };
-
-    // contains
-    // FIXME: Add specs: local.contains should be different for xml and html documents?
-    const nativeRootContains = root && this.isNativeCode(root.contains);
-    const nativeDocumentContains = document && this.isNativeCode(document.contains);
-
-    features.contains = (nativeRootContains && nativeDocumentContains) ? function (context, node) {
-      return context.contains(node);
-    } : (nativeRootContains && !nativeDocumentContains) ? function (context, node) {
-      // IE8 does not have .contains on document.
-      return context === node || ((context === document) ? document.documentElement : context).contains(node);
-    } : (root && root.compareDocumentPosition) ? function (context, node) {
-      return context === node || !!(context.compareDocumentPosition(node) & 16);
-    } : function (context, node) {
-      if (node) {
-        do {
-          if (node === context) return true;
-        } while ((node = node.parentNode));
-      }
-      return false;
-    };
-
-    // document order sorting
-    // credits to Sizzle (http://sizzlejs.com/)
-
-    features.documentSorter = (root.compareDocumentPosition) ? function (a, b) {
-      if (!a.compareDocumentPosition || !b.compareDocumentPosition) return 0;
-      return a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
-    } : ('sourceIndex' in root) ? function (a, b) {
-      if (!a.sourceIndex || !b.sourceIndex) return 0;
-      return a.sourceIndex - b.sourceIndex;
-    } : (document.createRange) ? function (a, b) {
-      if (!a.ownerDocument || !b.ownerDocument) return 0;
-      const aRange = a.ownerDocument.createRange(); const
-        bRange = b.ownerDocument.createRange();
-      aRange.setStart(a, 0);
-      aRange.setEnd(a, 0);
-      bRange.setStart(b, 0);
-      bRange.setEnd(b, 0);
-      return aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
-    } : null;
-
-    root = null;
-
-    for (feature in features) {
-      this[feature] = features[feature];
-    }
-  };
-
-  // Main Method
-
-  const reSimpleSelector = /^([#.]?)((?:[\w-]+|\*))$/;
-  const reEmptyAttribute = /\[.+[*$^]=(?:""|'')?\]/;
-  const qsaFailExpCache = {};
-
-  local.search = function (context, expression, append, first) {
-    let found = this.found = (first) ? null : (append || []);
-
-    if (!context) return found;
-    if (context.navigator) context = context.document; // Convert the node from a window to a document
-    else if (!context.nodeType) return found;
-
-    // setup
-
-    let parsed; let i; let node; let nodes;
-    const uniques = this.uniques = {};
-    const hasOthers = !!(append && append.length);
-    const contextIsDocument = (context.nodeType == 9);
-
-    if (this.document !== (contextIsDocument ? context : context.ownerDocument)) this.setDocument(context);
-
-    // avoid duplicating items already in the append array
-    if (hasOthers) for (i = found.length; i--;) uniques[this.getUID(found[i])] = true;
-
-    // expression checks
-
-    if (typeof expression === 'string') { // expression is a string
-      /* <simple-selectors-override> */
-      const simpleSelector = expression.match(reSimpleSelector);
-      simpleSelectors: if (simpleSelector) {
-        const symbol = simpleSelector[1];
-        const name = simpleSelector[2];
-
-        if (!symbol) {
-          if (name == '*' && this.brokenStarGEBTN) break simpleSelectors;
-          nodes = context.getElementsByTagName(name);
-          if (first) return nodes[0] || null;
-          for (i = 0; node = nodes[i++];) {
-            if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
-          }
-        } else if (symbol == '#') {
-          if (!this.isHTMLDocument || !contextIsDocument) break simpleSelectors;
-          node = context.getElementById(name);
-          if (!node) return found;
-          if (this.idGetsName && node.getAttributeNode('id').nodeValue != name) break simpleSelectors;
-          if (first) return node || null;
-          if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
-        } else if (symbol == '.') {
-          if (!this.isHTMLDocument || ((!context.getElementsByClassName || this.brokenGEBCN) && context.querySelectorAll)) break simpleSelectors;
-          if (context.getElementsByClassName && !this.brokenGEBCN) {
-            nodes = context.getElementsByClassName(name);
-            if (first) return nodes[0] || null;
-            for (i = 0; node = nodes[i++];) {
-              if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
-            }
-          } else {
-            const matchClass = new RegExp(`(^|\\s)${Slick.escapeRegExp(name)}(\\s|$)`);
-            nodes = context.getElementsByTagName('*');
-            for (i = 0; node = nodes[i++];) {
-              className = node.className;
-              if (!(className && matchClass.test(className))) continue;
-              if (first) return node;
-              if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
-            }
-          }
-        }
-
-        if (hasOthers) this.sort(found);
-        return (first) ? null : found;
-      }
-      /* </simple-selectors-override> */
-
-      /* <query-selector-override> */
-      querySelector: if (context.querySelectorAll) {
-        if (!this.isHTMLDocument
-				|| qsaFailExpCache[expression]
-				// TODO: only skip when expression is actually mixed case
-				|| this.brokenMixedCaseQSA
-				|| (this.brokenCheckedQSA && expression.indexOf(':checked') > -1)
-				|| (this.brokenEmptyAttributeQSA && reEmptyAttribute.test(expression))
-				|| (!contextIsDocument // Abort when !contextIsDocument and...
-					//  there are multiple expressions in the selector
-					//  since we currently only fix non-document rooted QSA for single expression selectors
-					&& expression.indexOf(',') > -1
-				)
-				|| Slick.disableQSA
-        ) break querySelector;
-
-        let _expression = expression; const _context = context; let
-          currentId;
-        if (!contextIsDocument) {
-          // non-document rooted QSA
-          // credits to Andrew Dupont
-          currentId = _context.getAttribute('id'), slickid = 'slickid__';
-          _context.setAttribute('id', slickid);
-          _expression = `#${slickid} ${_expression}`;
-          context = _context.parentNode;
-        }
-
-        try {
-          if (first) return context.querySelector(_expression) || null;
-          nodes = context.querySelectorAll(_expression);
-        } catch (e) {
-          qsaFailExpCache[expression] = 1;
-          break querySelector;
-        } finally {
-          if (!contextIsDocument) {
-            if (currentId) _context.setAttribute('id', currentId);
-            else _context.removeAttribute('id');
-            context = _context;
-          }
-        }
-
-        if (this.starSelectsClosedQSA) {
-          for (i = 0; node = nodes[i++];) {
-            if (node.nodeName > '@' && !(hasOthers && uniques[this.getUID(node)])) found.push(node);
-          }
-        } else {
-          for (i = 0; node = nodes[i++];) {
-            if (!(hasOthers && uniques[this.getUID(node)])) found.push(node);
-          }
-        }
-
-        if (hasOthers) this.sort(found);
-        return found;
-      }
-      /* </query-selector-override> */
-
-      parsed = this.Slick.parse(expression);
-      if (!parsed.length) return found;
-    } else if (expression == null) { // there is no expression
-      return found;
-    } else if (expression.Slick) { // expression is a parsed Slick object
-      parsed = expression;
-    } else if (this.contains(context.documentElement || context, expression)) { // expression is a node
-      (found) ? found.push(expression) : found = expression;
-      return found;
-    } else { // other junk
-      return found;
-    }
-
-    /* <pseudo-selectors> *//* <nth-pseudo-selectors> */
-
-    // cache elements for the nth selectors
-
-    this.posNTH = {};
-    this.posNTHLast = {};
-    this.posNTHType = {};
-    this.posNTHTypeLast = {};
-
-    /* </nth-pseudo-selectors> *//* </pseudo-selectors> */
-
-    // if append is null and there is only a single selector with one expression use pushArray, else use pushUID
-    this.push = (!hasOthers && (first || (parsed.length == 1 && parsed.expressions[0].length == 1))) ? this.pushArray : this.pushUID;
-
-    if (found == null) found = [];
-
-    // default engine
-
-    let j; let m; let
-      n;
-    let combinator; let tag; let id; let classList; let classes; let attributes; let
-      pseudos;
-    let currentItems; let currentExpression; let currentBit; let lastBit; const
-      { expressions } = parsed;
-
-    search: for (i = 0; (currentExpression = expressions[i]); i++) {
-      for (j = 0; (currentBit = currentExpression[j]); j++) {
-        combinator = `combinator:${currentBit.combinator}`;
-        if (!this[combinator]) continue search;
-
-        tag = (this.isXMLDocument) ? currentBit.tag : currentBit.tag.toUpperCase();
-        id = currentBit.id;
-        classList = currentBit.classList;
-        classes = currentBit.classes;
-        attributes = currentBit.attributes;
-        pseudos = currentBit.pseudos;
-        lastBit = (j === (currentExpression.length - 1));
-
-        this.bitUniques = {};
-
-        if (lastBit) {
-          this.uniques = uniques;
-          this.found = found;
-        } else {
-          this.uniques = {};
-          this.found = [];
-        }
-
-        if (j === 0) {
-          this[combinator](context, tag, id, classes, attributes, pseudos, classList);
-          if (first && lastBit && found.length) break search;
-        } else if (first && lastBit) {
-          for (m = 0, n = currentItems.length; m < n; m++) {
-            this[combinator](currentItems[m], tag, id, classes, attributes, pseudos, classList);
-            if (found.length) break search;
-          }
-        } else for (m = 0, n = currentItems.length; m < n; m++) this[combinator](currentItems[m], tag, id, classes, attributes, pseudos, classList);
-
-        currentItems = this.found;
-      }
-    }
-
-    // should sort if there are nodes in append and if you pass multiple expressions.
-    if (hasOthers || (parsed.expressions.length > 1)) this.sort(found);
-
-    return (first) ? (found[0] || null) : found;
-  };
-
-  // Utils
-
-  local.uidx = 1;
-  local.uidk = 'slick-uniqueid';
-
-  local.getUIDXML = function (node) {
-    let uid = node.getAttribute(this.uidk);
-    if (!uid) {
-      uid = this.uidx++;
-      node.setAttribute(this.uidk, uid);
-    }
-    return uid;
-  };
-
-  local.getUIDHTML = function (node) {
-    return node.uniqueNumber || (node.uniqueNumber = this.uidx++);
-  };
-
-  // sort based on the setDocument documentSorter method.
-
-  local.sort = function (results) {
-    if (!this.documentSorter) return results;
-    results.sort(this.documentSorter);
-    return results;
-  };
-
-  /* <pseudo-selectors> *//* <nth-pseudo-selectors> */
-
-  local.cacheNTH = {};
-
-  local.matchNTH = /^([+-]?\d*)?([a-z]+)?([+-]\d+)?$/;
-
-  local.parseNTHArgument = function (argument) {
-    let parsed = argument.match(this.matchNTH);
-    if (!parsed) return false;
-    const special = parsed[2] || false;
-    let a = parsed[1] || 1;
-    if (a == '-') a = -1;
-    const b = +parsed[3] || 0;
-    parsed =		(special == 'n')	? { a, b }
-      : (special == 'odd')	? { a: 2, b: 1 }
-        : (special == 'even')	? { a: 2, b: 0 } : { a: 0, b: a };
-
-    return (this.cacheNTH[argument] = parsed);
-  };
-
-  local.createNTHPseudo = function (child, sibling, positions, ofType) {
-    return function (node, argument) {
-      const uid = this.getUID(node);
-      if (!this[positions][uid]) {
-        const parent = node.parentNode;
-        if (!parent) return false;
-        let el = parent[child]; let
-          count = 1;
-        if (ofType) {
-          const { nodeName } = node;
-          do {
-            if (el.nodeName != nodeName) continue;
-            this[positions][this.getUID(el)] = count++;
-          } while ((el = el[sibling]));
-        } else {
-          do {
-            if (el.nodeType != 1) continue;
-            this[positions][this.getUID(el)] = count++;
-          } while ((el = el[sibling]));
-        }
-      }
-      argument = argument || 'n';
-      const parsed = this.cacheNTH[argument] || this.parseNTHArgument(argument);
-      if (!parsed) return false;
-      const { a } = parsed;
-      const { b } = parsed;
-      const pos = this[positions][uid];
-      if (a == 0) return b == pos;
-      if (a > 0) {
-        if (pos < b) return false;
-      } else if (b < pos) return false;
-      return ((pos - b) % a) == 0;
-    };
-  };
-
-  /* </nth-pseudo-selectors> *//* </pseudo-selectors> */
-
-  local.pushArray = function (node, tag, id, classes, attributes, pseudos) {
-    if (this.matchSelector(node, tag, id, classes, attributes, pseudos)) this.found.push(node);
-  };
-
-  local.pushUID = function (node, tag, id, classes, attributes, pseudos) {
-    const uid = this.getUID(node);
-    if (!this.uniques[uid] && this.matchSelector(node, tag, id, classes, attributes, pseudos)) {
-      this.uniques[uid] = true;
-      this.found.push(node);
-    }
-  };
-
-  local.matchNode = function (node, selector) {
-    if (this.isHTMLDocument && this.nativeMatchesSelector) {
-      try {
-        return this.nativeMatchesSelector.call(node, selector.replace(/\[([^=]+)=\s*([^'"\]]+?)\s*\]/g, '[$1="$2"]'));
-      } catch (matchError) {}
-    }
-
-    const parsed = this.Slick.parse(selector);
-    if (!parsed) return true;
-
-    // simple (single) selectors
-    const { expressions } = parsed;
-    let simpleExpCounter = 0;
-    let i;
-    let currentExpression;
-    for (i = 0; (currentExpression = expressions[i]); i++) {
-      if (currentExpression.length == 1) {
-        const exp = currentExpression[0];
-        if (this.matchSelector(node, (this.isXMLDocument) ? exp.tag : exp.tag.toUpperCase(), exp.id, exp.classes, exp.attributes, exp.pseudos)) return true;
-        simpleExpCounter++;
-      }
-    }
-
-    if (simpleExpCounter == parsed.length) return false;
-
-    const nodes = this.search(this.document, parsed); let
-      item;
-    for (i = 0; item = nodes[i++];) {
-      if (item === node) return true;
-    }
-    return false;
-  };
-
-  local.matchPseudo = function (node, name, argument) {
-    const pseudoName = `pseudo:${name}`;
-    if (this[pseudoName]) return this[pseudoName](node, argument);
-    const attribute = this.getAttribute(node, name);
-    return (argument) ? argument == attribute : !!attribute;
-  };
-
-  local.matchSelector = function (node, tag, id, classes, attributes, pseudos) {
-    if (tag) {
-      const nodeName = (this.isXMLDocument) ? node.nodeName : node.nodeName.toUpperCase();
-      if (tag == '*') {
-        if (nodeName < '@') return false; // Fix for comment nodes and closed nodes
-      } else if (nodeName != tag) return false;
-    }
-
-    if (id && node.getAttribute('id') != id) return false;
-
-    let i; let part; let
-      cls;
-    if (classes) {
-      for (i = classes.length; i--;) {
-        cls = this.getAttribute(node, 'class');
-        if (!(cls && classes[i].regexp.test(cls))) return false;
-      }
-    }
-    if (attributes) {
-      for (i = attributes.length; i--;) {
-        part = attributes[i];
-        if (part.operator ? !part.test(this.getAttribute(node, part.key)) : !this.hasAttribute(node, part.key)) return false;
-      }
-    }
-    if (pseudos) {
-      for (i = pseudos.length; i--;) {
-        part = pseudos[i];
-        if (!this.matchPseudo(node, part.key, part.value)) return false;
-      }
-    }
-    return true;
-  };
-
-  const combinators = {
-
-    ' ': function (node, tag, id, classes, attributes, pseudos, classList) { // all child nodes, any level
-      let i; let item; let
-        children;
-
-      if (this.isHTMLDocument) {
-        getById: if (id) {
-          item = this.document.getElementById(id);
-          if ((!item && node.all) || (this.idGetsName && item && item.getAttributeNode('id').nodeValue != id)) {
-            // all[id] returns all the elements with that name or id inside node
-            // if theres just one it will return the element, else it will be a collection
-            children = node.all[id];
-            if (!children) return;
-            if (!children[0]) children = [children];
-            for (i = 0; item = children[i++];) {
-              const idNode = item.getAttributeNode('id');
-              if (idNode && idNode.nodeValue == id) {
-                this.push(item, tag, null, classes, attributes, pseudos);
-                break;
-              }
-            }
-            return;
-          }
-          if (!item) {
-            // if the context is in the dom we return, else we will try GEBTN, breaking the getById label
-            if (this.contains(this.root, node)) return;
-            break getById;
-          } else if (this.document !== node && !this.contains(node, item)) return;
-          this.push(item, tag, null, classes, attributes, pseudos);
-          return;
-        }
-        getByClass: if (classes && node.getElementsByClassName && !this.brokenGEBCN) {
-          children = node.getElementsByClassName(classList.join(' '));
-          if (!(children && children.length)) break getByClass;
-          for (i = 0; item = children[i++];) this.push(item, tag, id, null, attributes, pseudos);
-          return;
-        }
-      }
-      getByTag: {
-        children = node.getElementsByTagName(tag);
-        if (!(children && children.length)) break getByTag;
-        if (!this.brokenStarGEBTN) tag = null;
-        for (i = 0; item = children[i++];) this.push(item, tag, id, classes, attributes, pseudos);
-      }
-    },
-
-    '>': function (node, tag, id, classes, attributes, pseudos) { // direct children
-      if ((node = node.firstChild)) {
-        do {
-          if (node.nodeType == 1) this.push(node, tag, id, classes, attributes, pseudos);
-        } while ((node = node.nextSibling));
-      }
-    },
-
-    '+': function (node, tag, id, classes, attributes, pseudos) { // next sibling
-      while ((node = node.nextSibling)) {
-        if (node.nodeType == 1) {
-          this.push(node, tag, id, classes, attributes, pseudos);
-          break;
-        }
-      }
-    },
-
-    '^': function (node, tag, id, classes, attributes, pseudos) { // first child
-      node = node.firstChild;
-      if (node) {
-        if (node.nodeType == 1) this.push(node, tag, id, classes, attributes, pseudos);
-        else this['combinator:+'](node, tag, id, classes, attributes, pseudos);
-      }
-    },
-
-    '~': function (node, tag, id, classes, attributes, pseudos) { // next siblings
-      while ((node = node.nextSibling)) {
-        if (node.nodeType != 1) continue;
-        const uid = this.getUID(node);
-        if (this.bitUniques[uid]) break;
-        this.bitUniques[uid] = true;
-        this.push(node, tag, id, classes, attributes, pseudos);
-      }
-    },
-
-    '++': function (node, tag, id, classes, attributes, pseudos) { // next sibling and previous sibling
-      this['combinator:+'](node, tag, id, classes, attributes, pseudos);
-      this['combinator:!+'](node, tag, id, classes, attributes, pseudos);
-    },
-
-    '~~': function (node, tag, id, classes, attributes, pseudos) { // next siblings and previous siblings
-      this['combinator:~'](node, tag, id, classes, attributes, pseudos);
-      this['combinator:!~'](node, tag, id, classes, attributes, pseudos);
-    },
-
-    '!': function (node, tag, id, classes, attributes, pseudos) { // all parent nodes up to document
-      while ((node = node.parentNode)) if (node !== this.document) this.push(node, tag, id, classes, attributes, pseudos);
-    },
-
-    '!>': function (node, tag, id, classes, attributes, pseudos) { // direct parent (one level)
-      node = node.parentNode;
-      if (node !== this.document) this.push(node, tag, id, classes, attributes, pseudos);
-    },
-
-    '!+': function (node, tag, id, classes, attributes, pseudos) { // previous sibling
-      while ((node = node.previousSibling)) {
-        if (node.nodeType == 1) {
-          this.push(node, tag, id, classes, attributes, pseudos);
-          break;
-        }
-      }
-    },
-
-    '!^': function (node, tag, id, classes, attributes, pseudos) { // last child
-      node = node.lastChild;
-      if (node) {
-        if (node.nodeType == 1) this.push(node, tag, id, classes, attributes, pseudos);
-        else this['combinator:!+'](node, tag, id, classes, attributes, pseudos);
-      }
-    },
-
-    '!~': function (node, tag, id, classes, attributes, pseudos) { // previous siblings
-      while ((node = node.previousSibling)) {
-        if (node.nodeType != 1) continue;
-        const uid = this.getUID(node);
-        if (this.bitUniques[uid]) break;
-        this.bitUniques[uid] = true;
-        this.push(node, tag, id, classes, attributes, pseudos);
-      }
-    },
-
-  };
-
-  for (const c in combinators) local[`combinator:${c}`] = combinators[c];
-
-  const pseudos = {
-
-    /* <pseudo-selectors> */
-
-    empty(node) {
-      const child = node.firstChild;
-      return !(child && child.nodeType == 1) && !(node.innerText || node.textContent || '').length;
-    },
-
-    not(node, expression) {
-      return !this.matchNode(node, expression);
-    },
-
-    contains(node, text) {
-      return (node.innerText || node.textContent || '').indexOf(text) > -1;
-    },
-
-    'first-child': function (node) {
-      while ((node = node.previousSibling)) if (node.nodeType == 1) return false;
-      return true;
-    },
-
-    'last-child': function (node) {
-      while ((node = node.nextSibling)) if (node.nodeType == 1) return false;
-      return true;
-    },
-
-    'only-child': function (node) {
-      let prev = node;
-      while ((prev = prev.previousSibling)) if (prev.nodeType == 1) return false;
-      let next = node;
-      while ((next = next.nextSibling)) if (next.nodeType == 1) return false;
-      return true;
-    },
-
-    /* <nth-pseudo-selectors> */
-
-    'nth-child': local.createNTHPseudo('firstChild', 'nextSibling', 'posNTH'),
-
-    'nth-last-child': local.createNTHPseudo('lastChild', 'previousSibling', 'posNTHLast'),
-
-    'nth-of-type': local.createNTHPseudo('firstChild', 'nextSibling', 'posNTHType', true),
-
-    'nth-last-of-type': local.createNTHPseudo('lastChild', 'previousSibling', 'posNTHTypeLast', true),
-
-    index(node, index) {
-      return this['pseudo:nth-child'](node, `${index + 1}`);
-    },
-
-    even(node) {
-      return this['pseudo:nth-child'](node, '2n');
-    },
-
-    odd(node) {
-      return this['pseudo:nth-child'](node, '2n+1');
-    },
-
-    /* </nth-pseudo-selectors> */
-
-    /* <of-type-pseudo-selectors> */
-
-    'first-of-type': function (node) {
-      const { nodeName } = node;
-      while ((node = node.previousSibling)) if (node.nodeName == nodeName) return false;
-      return true;
-    },
-
-    'last-of-type': function (node) {
-      const { nodeName } = node;
-      while ((node = node.nextSibling)) if (node.nodeName == nodeName) return false;
-      return true;
-    },
-
-    'only-of-type': function (node) {
-      let prev = node; const
-        { nodeName } = node;
-      while ((prev = prev.previousSibling)) if (prev.nodeName == nodeName) return false;
-      let next = node;
-      while ((next = next.nextSibling)) if (next.nodeName == nodeName) return false;
-      return true;
-    },
-
-    /* </of-type-pseudo-selectors> */
-
-    // custom pseudos
-
-    enabled(node) {
-      return !node.disabled;
-    },
-
-    disabled(node) {
-      return node.disabled;
-    },
-
-    checked(node) {
-      return node.checked || node.selected;
-    },
-
-    focus(node) {
-      return this.isHTMLDocument && this.document.activeElement === node && (node.href || node.type || this.hasAttribute(node, 'tabindex'));
-    },
-
-    root(node) {
-      return (node === this.root);
-    },
-
-    selected(node) {
-      return node.selected;
-    },
-
-    /* </pseudo-selectors> */
-  };
-
-  for (const p in pseudos) local[`pseudo:${p}`] = pseudos[p];
-
-  // attributes methods
-
-  const attributeGetters = local.attributeGetters = {
-
-    for() {
-      return ('htmlFor' in this) ? this.htmlFor : this.getAttribute('for');
-    },
-
-    href() {
-      return ('href' in this) ? this.getAttribute('href', 2) : this.getAttribute('href');
-    },
-
-    style() {
-      return (this.style) ? this.style.cssText : this.getAttribute('style');
-    },
-
-    tabindex() {
-      const attributeNode = this.getAttributeNode('tabindex');
-      return (attributeNode && attributeNode.specified) ? attributeNode.nodeValue : null;
-    },
-
-    type() {
-      return this.getAttribute('type');
-    },
-
-    maxlength() {
-      const attributeNode = this.getAttributeNode('maxLength');
-      return (attributeNode && attributeNode.specified) ? attributeNode.nodeValue : null;
-    },
-
-  };
-
-  attributeGetters.MAXLENGTH = attributeGetters.maxLength = attributeGetters.maxlength;
-
-  // Slick
-
-  var Slick = local.Slick = (this.Slick || {});
-
-  Slick.version = '1.1.7';
-
-  // Slick finder
-
-  Slick.search = function (context, expression, append) {
-    return local.search(context, expression, append);
-  };
-
-  Slick.find = function (context, expression) {
-    return local.search(context, expression, null, true);
-  };
-
-  // Slick containment checker
-
-  Slick.contains = function (container, node) {
-    local.setDocument(container);
-    return local.contains(container, node);
-  };
-
-  // Slick attribute getter
-
-  Slick.getAttribute = function (node, name) {
-    local.setDocument(node);
-    return local.getAttribute(node, name);
-  };
-
-  Slick.hasAttribute = function (node, name) {
-    local.setDocument(node);
-    return local.hasAttribute(node, name);
-  };
-
-  // Slick matcher
-
-  Slick.match = function (node, selector) {
-    if (!(node && selector)) return false;
-    if (!selector || selector === node) return true;
-    local.setDocument(node);
-    return local.matchNode(node, selector);
-  };
-
-  // Slick attribute accessor
-
-  Slick.defineAttributeGetter = function (name, fn) {
-    local.attributeGetters[name] = fn;
-    return this;
-  };
-
-  Slick.lookupAttributeGetter = function (name) {
-    return local.attributeGetters[name];
-  };
-
-  // Slick pseudo accessor
-
-  Slick.definePseudo = function (name, fn) {
-    local[`pseudo:${name}`] = function (node, argument) {
-      return fn.call(node, argument);
-    };
-    return this;
-  };
-
-  Slick.lookupPseudo = function (name) {
-    const pseudo = local[`pseudo:${name}`];
-    if (pseudo) {
-      return function (argument) {
-        return pseudo.call(this, argument);
-      };
-    }
-    return null;
-  };
-
-  // Slick overrides accessor
-
-  Slick.override = function (regexp, fn) {
-    local.override(regexp, fn);
-    return this;
-  };
-
-  Slick.isXML = local.isXML;
-
-  Slick.uidOf = function (node) {
-    return local.getUIDHTML(node);
-  };
-
-  if (!this.Slick) this.Slick = Slick;
-}).apply(/* <CommonJS> */(typeof exports !== 'undefined') ? exports : /* </CommonJS> */this);
-
-/*
----
-
-name: Element
-
-description: One of the most important items in MooTools. Contains the dollar function, the dollars function, and an handful of cross-browser, time-saver methods to let you easily work with HTML Elements.
-
-license: MIT-style license.
-
-requires: [Window, Document, Array, String, Function, Object, Number, Slick.Parser, Slick.Finder]
-
-provides: [Element, Elements, $, $$, IFrame, Selectors]
-
-...
-*/
-
-var Element = this.Element = function (tag, props) {
-  const konstructor = Element.Constructors[tag];
-  if (konstructor) return konstructor(props);
-  if (typeof tag !== 'string') return document.id(tag).set(props);
-
-  if (!props) props = {};
-
-  if (!(/^[\w-]+$/).test(tag)) {
-    const parsed = Slick.parse(tag).expressions[0][0];
-    tag = (parsed.tag == '*') ? 'div' : parsed.tag;
-    if (parsed.id && props.id == null) props.id = parsed.id;
-
-    const { attributes } = parsed;
-    if (attributes) {
-      for (var attr, i = 0, l = attributes.length; i < l; i++) {
-        attr = attributes[i];
-        if (props[attr.key] != null) continue;
-
-        if (attr.value != null && attr.operator == '=') props[attr.key] = attr.value;
-        else if (!attr.value && !attr.operator) props[attr.key] = true;
-      }
-    }
-
-    if (parsed.classList && props.class == null) props.class = parsed.classList.join(' ');
-  }
-
-  return document.newElement(tag, props);
-};
-
-if (Browser.Element) {
-  Element.prototype = Browser.Element.prototype;
-  // IE8 and IE9 require the wrapping.
-  Element.prototype._fireEvent = (function (fireEvent) {
-    return function (type, event) {
-      return fireEvent.call(this, type, event);
-    };
-  }(Element.prototype.fireEvent));
-}
-
-new Type('Element', Element).mirror((name) => {
-  if (Array.prototype[name]) return;
-
-  const obj = {};
-  obj[name] = function () {
-    const results = []; const args = arguments; let
-      elements = true;
-    for (let i = 0, l = this.length; i < l; i++) {
-      const element = this[i]; const
-        result = results[i] = element[name].apply(element, args);
-      elements = (elements && typeOf(result) == 'element');
-    }
-    return (elements) ? new Elements(results) : results;
-  };
-
-  Elements.implement(obj);
-});
-
-if (!Browser.Element) {
-  Element.parent = Object;
-
-  Element.Prototype = {
-    $constructor: Element,
-    $family: Function.convert('element').hide(),
-  };
-
-  Element.mirror((name, method) => {
-    Element.Prototype[name] = method;
-  });
-}
-
-Element.Constructors = {};
-
-const IFrame = new Type('IFrame', function () {
-  const params = Array.link(arguments, {
-    properties: Type.isObject,
-    iframe(obj) {
-      return (obj != null);
-    },
-  });
-
-  const props = params.properties || {}; let
-    iframe;
-  if (params.iframe) iframe = document.id(params.iframe);
-  const onload = props.onload || function () {};
-  delete props.onload;
-  props.id = props.name = [props.id, props.name, iframe ? (iframe.id || iframe.name) : `IFrame_${String.uniqueID()}`].pick();
-  iframe = new Element(iframe || 'iframe', props);
-
-  const onLoad = function () {
-    onload.call(iframe.contentWindow);
-  };
-
-  if (window.frames[props.id]) onLoad();
-  else iframe.addListener('load', onLoad);
-  return iframe;
-});
-
-var Elements = this.Elements = function (nodes) {
-  if (nodes && nodes.length) {
-    const uniques = {}; let
-      node;
-    for (let i = 0; node = nodes[i++];) {
-      const uid = Slick.uidOf(node);
-      if (!uniques[uid]) {
-        uniques[uid] = true;
-        this.push(node);
-      }
-    }
-  }
-};
-
-Elements.prototype = { length: 0 };
-Elements.parent = Array;
-
-new Type('Elements', Elements).implement({
-
-  filter: function (filter, bind) {
-    if (!filter) return this;
-    return new Elements(Array.filter(this, (typeOf(filter) == 'string') ? (item) => item.match(filter) : filter, bind));
-  }.protect(),
-
-  push: function () {
-    let { length } = this;
-    for (let i = 0, l = arguments.length; i < l; i++) {
-      const item = document.id(arguments[i]);
-      if (item) this[length++] = item;
-    }
-    return (this.length = length);
-  }.protect(),
-
-  unshift: function () {
-    const items = [];
-    for (let i = 0, l = arguments.length; i < l; i++) {
-      const item = document.id(arguments[i]);
-      if (item) items.push(item);
-    }
-    return Array.prototype.unshift.apply(this, items);
-  }.protect(),
-
-  concat: function () {
-    const newElements = new Elements(this);
-    for (let i = 0, l = arguments.length; i < l; i++) {
-      const item = arguments[i];
-      if (Type.isEnumerable(item)) newElements.append(item);
-      else newElements.push(item);
-    }
-    return newElements;
-  }.protect(),
-
-  append: function (collection) {
-    for (let i = 0, l = collection.length; i < l; i++) this.push(collection[i]);
-    return this;
-  }.protect(),
-
-  empty: function () {
-    while (this.length) delete this[--this.length];
-    return this;
-  }.protect(),
-
-});
-
-(function () {
-// FF, IE
-  const { splice } = Array.prototype;
-  const object = { 0: 0, 1: 1, length: 2 };
-
-  splice.call(object, 1, 1);
-  if (object[1] == 1) {
-    Elements.implement('splice', function () {
-      let { length } = this;
-      const result = splice.apply(this, arguments);
-      while (length >= this.length) delete this[length--];
-      return result;
-    }.protect());
-  }
-
-  Array.forEachMethod((method, name) => {
-    Elements.implement(name, method);
-  });
-
-  Array.mirror(Elements);
-
-  /* <ltIE8> */
-  let createElementAcceptsHTML;
-  try {
-    createElementAcceptsHTML = (document.createElement('<input name=x>').name == 'x');
-  } catch (e) {}
-
-  const escapeQuotes = function (html) {
-    return (`${html}`).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
-  };
-  /* </ltIE8> */
-
-  /* <ltIE9> */
-  // #2479 - IE8 Cannot set HTML of style element
-  const canChangeStyleHTML = (function () {
-    const div = document.createElement('style');
-    let flag = false;
-    try {
-      div.innerHTML = '#justTesing{margin: 0px;}';
-      flag = !!div.innerHTML;
-    } catch (e) {}
-    return flag;
-  }());
-  /* </ltIE9> */
-
-  Document.implement({
-
-    newElement(tag, props) {
-      if (props) {
-        if (props.checked != null) props.defaultChecked = props.checked;
-        if ((props.type == 'checkbox' || props.type == 'radio') && props.value == null) props.value = 'on';
-        /* <ltIE9> */ // IE needs the type to be set before changing content of style element
-        if (!canChangeStyleHTML && tag == 'style') {
-          const styleElement = document.createElement('style');
-          styleElement.setAttribute('type', 'text/css');
-          if (props.type) delete props.type;
-          return this.id(styleElement).set(props);
-        }
-        /* </ltIE9> */
-        /* <ltIE8> */// Fix for readonly name and type properties in IE < 8
-        if (createElementAcceptsHTML) {
-          tag = `<${tag}`;
-          if (props.name) tag += ` name="${escapeQuotes(props.name)}"`;
-          if (props.type) tag += ` type="${escapeQuotes(props.type)}"`;
-          tag += '>';
-          delete props.name;
-          delete props.type;
-        }
-        /* </ltIE8> */
-      }
-      return this.id(this.createElement(tag)).set(props);
-    },
-
-  });
-}());
-
-(function () {
-  Slick.uidOf(window);
-  Slick.uidOf(document);
-
-  Document.implement({
-
-    newTextNode(text) {
-      return this.createTextNode(text);
-    },
-
-    getDocument() {
-      return this;
-    },
-
-    getWindow() {
-      return this.window;
-    },
-
-    id: (function () {
-      var types = {
-
-        string(id, nocash, doc) {
-          id = Slick.find(doc, `#${id.replace(/(\W)/g, '\\$1')}`);
-          return (id) ? types.element(id, nocash) : null;
-        },
-
-        element(el, nocash) {
-          Slick.uidOf(el);
-          if (!nocash && !el.$family && !(/^(?:object|embed)$/i).test(el.tagName)) {
-            const { fireEvent } = el;
-            // wrapping needed in IE7, or else crash
-            el._fireEvent = function (type, event) {
-              return fireEvent(type, event);
-            };
-            Object.append(el, Element.Prototype);
-          }
-          return el;
-        },
-
-        object(obj, nocash, doc) {
-          if (obj.toElement) return types.element(obj.toElement(doc), nocash);
-          return null;
-        },
-
-      };
-
-      types.textnode = types.whitespace = types.window = types.document = function (zero) {
-        return zero;
-      };
-
-      return function (el, nocash, doc) {
-        if (el && el.$family && el.uniqueNumber) return el;
-        const type = typeOf(el);
-        return (types[type]) ? types[type](el, nocash, doc || document) : null;
-      };
-    }()),
-
-  });
-
-  if (window.$ == null) {
-    Window.implement('$', function (el, nc) {
-      return document.id(el, nc, this.document);
-    });
-  }
-
-  Window.implement({
-
-    getDocument() {
-      return this.document;
-    },
-
-    getWindow() {
-      return this;
-    },
-
-  });
-
-  [Document, Element].invoke('implement', {
-
-    getElements(expression) {
-      return Slick.search(this, expression, new Elements());
-    },
-
-    getElement(expression) {
-      return document.id(Slick.find(this, expression));
-    },
-
-  });
-
-  const contains = {
-    contains(element) {
-      return Slick.contains(this, element);
-    },
-  };
-
-  if (!document.contains) Document.implement(contains);
-  if (!document.createElement('div').contains) Element.implement(contains);
-
-  // tree walking
-
-  const injectCombinator = function (expression, combinator) {
-    if (!expression) return combinator;
-
-    expression = Object.clone(Slick.parse(expression));
-
-    const { expressions } = expression;
-    for (let i = expressions.length; i--;) expressions[i][0].combinator = combinator;
-
-    return expression;
-  };
-
-  Object.forEach({
-    getNext: '~',
-    getPrevious: '!~',
-    getParent: '!',
-  }, (combinator, method) => {
-    Element.implement(method, function (expression) {
-      return this.getElement(injectCombinator(expression, combinator));
-    });
-  });
-
-  Object.forEach({
-    getAllNext: '~',
-    getAllPrevious: '!~',
-    getSiblings: '~~',
-    getChildren: '>',
-    getParents: '!',
-  }, (combinator, method) => {
-    Element.implement(method, function (expression) {
-      return this.getElements(injectCombinator(expression, combinator));
-    });
-  });
-
-  Element.implement({
-
-    getFirst(expression) {
-      return document.id(Slick.search(this, injectCombinator(expression, '>'))[0]);
-    },
-
-    getLast(expression) {
-      return document.id(Slick.search(this, injectCombinator(expression, '>')).getLast());
-    },
-
-    getWindow() {
-      return this.ownerDocument.window;
-    },
-
-    getDocument() {
-      return this.ownerDocument;
-    },
-
-    getElementById(id) {
-      return document.id(Slick.find(this, `#${(`${id}`).replace(/(\W)/g, '\\$1')}`));
-    },
-
-    match(expression) {
-      return !expression || Slick.match(this, expression);
-    },
-
-  });
-
-  if (window.$$ == null) {
-    Window.implement('$$', function (selector) {
-      if (arguments.length == 1) {
-        if (typeof selector === 'string') return Slick.search(this.document, selector, new Elements());
-        if (Type.isEnumerable(selector)) return new Elements(selector);
-      }
-      return new Elements(arguments);
-    });
-  }
-
-  // Inserters
-
-  const inserters = {
-
-    before(context, element) {
-      const parent = element.parentNode;
-      if (parent) parent.insertBefore(context, element);
-    },
-
-    after(context, element) {
-      const parent = element.parentNode;
-      if (parent) parent.insertBefore(context, element.nextSibling);
-    },
-
-    bottom(context, element) {
-      element.appendChild(context);
-    },
-
-    top(context, element) {
-      element.insertBefore(context, element.firstChild);
-    },
-
-  };
-
-  inserters.inside = inserters.bottom;
-
-  // getProperty / setProperty
-
-  const propertyGetters = {}; const
-    propertySetters = {};
-
-  // properties
-
-  const properties = {};
-  Array.forEach([
-    'type', 'value', 'defaultValue', 'accessKey', 'cellPadding', 'cellSpacing', 'colSpan',
-    'frameBorder', 'rowSpan', 'tabIndex', 'useMap',
-  ], (property) => {
-    properties[property.toLowerCase()] = property;
-  });
-
-  properties.html = 'innerHTML';
-  properties.text = (document.createElement('div').textContent == null) ? 'innerText' : 'textContent';
-
-  Object.forEach(properties, (real, key) => {
-    propertySetters[key] = function (node, value) {
-      node[real] = value;
-    };
-    propertyGetters[key] = function (node) {
-      return node[real];
-    };
-  });
-
-  /* <ltIE9> */
-  propertySetters.text = (function () {
-    return function (node, value) {
-      if (node.get('tag') == 'style') node.set('html', value);
-      else node[properties.text] = value;
-    };
-  }(propertySetters.text));
-
-  propertyGetters.text = (function (getter) {
-    return function (node) {
-      return (node.get('tag') == 'style') ? node.innerHTML : getter(node);
-    };
-  }(propertyGetters.text));
-  /* </ltIE9> */
-
-  // Booleans
-
-  const bools = [
-    'compact', 'nowrap', 'ismap', 'declare', 'noshade', 'checked',
-    'disabled', 'readOnly', 'multiple', 'selected', 'noresize',
-    'defer', 'defaultChecked', 'autofocus', 'controls', 'autoplay',
-    'loop',
-  ];
-
-  const booleans = {};
-  Array.forEach(bools, (bool) => {
-    const lower = bool.toLowerCase();
-    booleans[lower] = bool;
-    propertySetters[lower] = function (node, value) {
-      node[bool] = !!value;
-    };
-    propertyGetters[lower] = function (node) {
-      return !!node[bool];
-    };
-  });
-
-  // Special cases
-
-  Object.append(propertySetters, {
-
-    class(node, value) {
-      ('className' in node) ? node.className = (value || '') : node.setAttribute('class', value);
-    },
-
-    for(node, value) {
-      ('htmlFor' in node) ? node.htmlFor = value : node.setAttribute('for', value);
-    },
-
-    style(node, value) {
-      (node.style) ? node.style.cssText = value : node.setAttribute('style', value);
-    },
-
-    value(node, value) {
-      node.value = (value != null) ? value : '';
-    },
-
-  });
-
-  propertyGetters.class = function (node) {
-    return ('className' in node) ? node.className || null : node.getAttribute('class');
-  };
-
-  /* <webkit> */
-  let el = document.createElement('button');
-  // IE sets type as readonly and throws
-  try { el.type = 'button'; } catch (e) {}
-  if (el.type != 'button') {
-    propertySetters.type = function (node, value) {
-      node.setAttribute('type', value);
-    };
-  }
-  el = null;
-  /* </webkit> */
-
-  /* <IE> */
-
-  /* <ltIE9> */
-  // #2479 - IE8 Cannot set HTML of style element
-  const canChangeStyleHTML = (function () {
-    const div = document.createElement('style');
-    let flag = false;
-    try {
-      div.innerHTML = '#justTesing{margin: 0px;}';
-      flag = !!div.innerHTML;
-    } catch (e) {}
-    return flag;
-  }());
-  /* </ltIE9> */
-
-  let input = document.createElement('input'); let volatileInputValue; let
-    html5InputSupport;
-
-  // #2178
-  input.value = 't';
-  input.type = 'submit';
-  volatileInputValue = input.value != 't';
-
-  // #2443 - IE throws "Invalid Argument" when trying to use html5 input types
-  try {
-    input.value = '';
-    input.type = 'email';
-    html5InputSupport = input.type == 'email';
-  } catch (e) {}
-
-  input = null;
-
-  if (volatileInputValue || !html5InputSupport) {
-    propertySetters.type = function (node, type) {
-      try {
-        const { value } = node;
-        node.type = type;
-        node.value = value;
-      } catch (e) {}
-    };
-  }
-  /* </IE> */
-
-  /* getProperty, setProperty */
-
-  /* <ltIE9> */
-  const pollutesGetAttribute = (function (div) {
-    div.random = 'attribute';
-    return (div.getAttribute('random') == 'attribute');
-  }(document.createElement('div')));
-
-  const hasCloneBug = (function (test) {
-    test.innerHTML = '<object><param name="should_fix" value="the unknown" /></object>';
-    return test.cloneNode(true).firstChild.childNodes.length != 1;
-  }(document.createElement('div')));
-  /* </ltIE9> */
-
-  const hasClassList = !!document.createElement('div').classList;
-
-  const classes = function (className) {
-    const classNames = (className || '').clean().split(' '); const
-      uniques = {};
-    return classNames.filter((className) => {
-      if (className !== '' && !uniques[className]) return uniques[className] = className;
-    });
-  };
-
-  const addToClassList = function (name) {
-    this.classList.add(name);
-  };
-
-  const removeFromClassList = function (name) {
-    this.classList.remove(name);
-  };
-
-  Element.implement({
-
-    setProperty(name, value) {
-      const setter = propertySetters[name.toLowerCase()];
-      if (setter) {
-        setter(this, value);
-      } else {
-        /* <ltIE9> */
-        let attributeWhiteList;
-        if (pollutesGetAttribute) attributeWhiteList = this.retrieve('$attributeWhiteList', {});
-        /* </ltIE9> */
-
-        if (value == null) {
-          this.removeAttribute(name);
-          /* <ltIE9> */
-          if (pollutesGetAttribute) delete attributeWhiteList[name];
-          /* </ltIE9> */
-        } else {
-          this.setAttribute(name, `${value}`);
-          /* <ltIE9> */
-          if (pollutesGetAttribute) attributeWhiteList[name] = true;
-          /* </ltIE9> */
-        }
-      }
-      return this;
-    },
-
-    setProperties(attributes) {
-      for (const attribute in attributes) this.setProperty(attribute, attributes[attribute]);
-      return this;
-    },
-
-    getProperty(name) {
-      const getter = propertyGetters[name.toLowerCase()];
-      if (getter) return getter(this);
-      /* <ltIE9> */
-      if (pollutesGetAttribute) {
-        const attr = this.getAttributeNode(name); const
-          attributeWhiteList = this.retrieve('$attributeWhiteList', {});
-        if (!attr) return null;
-        if (attr.expando && !attributeWhiteList[name]) {
-          const outer = this.outerHTML;
-          // segment by the opening tag and find mention of attribute name
-          if (outer.substr(0, outer.search(/\/?['"]?>(?![^<]*<['"])/)).indexOf(name) < 0) return null;
-          attributeWhiteList[name] = true;
-        }
-      }
-      /* </ltIE9> */
-      const result = Slick.getAttribute(this, name);
-      return (!result && !Slick.hasAttribute(this, name)) ? null : result;
-    },
-
-    getProperties() {
-      const args = Array.convert(arguments);
-      return args.map(this.getProperty, this).associate(args);
-    },
-
-    removeProperty(name) {
-      return this.setProperty(name, null);
-    },
-
-    removeProperties() {
-      Array.each(arguments, this.removeProperty, this);
-      return this;
-    },
-
-    set: function (prop, value) {
-      const property = Element.Properties[prop];
-      (property && property.set) ? property.set.call(this, value) : this.setProperty(prop, value);
-    }.overloadSetter(),
-
-    get: function (prop) {
-      const property = Element.Properties[prop];
-      return (property && property.get) ? property.get.apply(this) : this.getProperty(prop);
-    }.overloadGetter(),
-
-    erase(prop) {
-      const property = Element.Properties[prop];
-      (property && property.erase) ? property.erase.apply(this) : this.removeProperty(prop);
-      return this;
-    },
-
-    hasClass: hasClassList ? function (className) {
-      return this.classList.contains(className);
-    } : function (className) {
-      return classes(this.className).contains(className);
-    },
-
-    addClass: hasClassList ? function (className) {
-      classes(className).forEach(addToClassList, this);
-      return this;
-    } : function (className) {
-      this.className = classes(`${className} ${this.className}`).join(' ');
-      return this;
-    },
-
-    removeClass: hasClassList ? function (className) {
-      classes(className).forEach(removeFromClassList, this);
-      return this;
-    } : function (className) {
-      const classNames = classes(this.className);
-      classes(className).forEach(classNames.erase, classNames);
-      this.className = classNames.join(' ');
-      return this;
-    },
-
-    toggleClass(className, force) {
-      if (force == null) force = !this.hasClass(className);
-      return (force) ? this.addClass(className) : this.removeClass(className);
-    },
-
-    adopt() {
-      let parent = this; let fragment; const elements = Array.flatten(arguments); const
-        { length } = elements;
-      if (length > 1) parent = fragment = document.createDocumentFragment();
-
-      for (let i = 0; i < length; i++) {
-        const element = document.id(elements[i], true);
-        if (element) parent.appendChild(element);
-      }
-
-      if (fragment) this.appendChild(fragment);
-
-      return this;
-    },
-
-    appendText(text, where) {
-      return this.grab(this.getDocument().newTextNode(text), where);
-    },
-
-    grab(el, where) {
-      inserters[where || 'bottom'](document.id(el, true), this);
-      return this;
-    },
-
-    inject(el, where) {
-      inserters[where || 'bottom'](this, document.id(el, true));
-      return this;
-    },
-
-    replaces(el) {
-      el = document.id(el, true);
-      el.parentNode.replaceChild(this, el);
-      return this;
-    },
-
-    wraps(el, where) {
-      el = document.id(el, true);
-      return this.replaces(el).grab(el, where);
-    },
-
-    getSelected() {
-      this.selectedIndex; // Safari 3.2.1
-      return new Elements(Array.convert(this.options).filter((option) => option.selected));
-    },
-
-    toQueryString() {
-      const queryString = [];
-      this.getElements('input, select, textarea').each((el) => {
-        const { type } = el;
-        if (!el.name || el.disabled || type == 'submit' || type == 'reset' || type == 'file' || type == 'image') return;
-
-        const value = (el.get('tag') == 'select') ? el.getSelected().map((opt) =>
-          // IE
-          document.id(opt).get('value')) : ((type == 'radio' || type == 'checkbox') && !el.checked) ? null : el.get('value');
-
-        Array.convert(value).each((val) => {
-          if (typeof val !== 'undefined') queryString.push(`${encodeURIComponent(el.name)}=${encodeURIComponent(val)}`);
-        });
-      });
-      return queryString.join('&');
-    },
-
-  });
-
-  // appendHTML
-
-  const appendInserters = {
-    before: 'beforeBegin',
-    after: 'afterEnd',
-    bottom: 'beforeEnd',
-    top: 'afterBegin',
-    inside: 'beforeEnd',
-  };
-
-  Element.implement('appendHTML', ('insertAdjacentHTML' in document.createElement('div')) ? function (html, where) {
-    this.insertAdjacentHTML(appendInserters[where || 'bottom'], html);
-    return this;
-  } : function (html, where) {
-    const temp = new Element('div', { html });
-    const children = temp.childNodes;
-    let fragment = temp.firstChild;
-
-    if (!fragment) return this;
-    if (children.length > 1) {
-      fragment = document.createDocumentFragment();
-      for (let i = 0, l = children.length; i < l; i++) {
-        fragment.appendChild(children[i]);
-      }
-    }
-
-    inserters[where || 'bottom'](fragment, this);
-    return this;
-  });
-
-  const collected = {}; const
-    storage = {};
-
-  const get = function (uid) {
-    return (storage[uid] || (storage[uid] = {}));
-  };
-
-  const clean = function (item) {
-    const uid = item.uniqueNumber;
-    if (item.removeEvents) item.removeEvents();
-    if (item.clearAttributes) item.clearAttributes();
-    if (uid != null) {
-      delete collected[uid];
-      delete storage[uid];
-    }
-    return item;
-  };
-
-  const formProps = { input: 'checked', option: 'selected', textarea: 'value' };
-
-  Element.implement({
-
-    destroy() {
-      const children = clean(this).getElementsByTagName('*');
-      Array.each(children, clean);
-      Element.dispose(this);
-      return null;
-    },
-
-    empty() {
-      Array.convert(this.childNodes).each(Element.dispose);
-      return this;
-    },
-
-    dispose() {
-      return (this.parentNode) ? this.parentNode.removeChild(this) : this;
-    },
-
-    clone(contents, keepid) {
-      contents = contents !== false;
-      const clone = this.cloneNode(contents); const ce = [clone]; const te = [this]; let
-        i;
-
-      if (contents) {
-        ce.append(Array.convert(clone.getElementsByTagName('*')));
-        te.append(Array.convert(this.getElementsByTagName('*')));
-      }
-
-      for (i = ce.length; i--;) {
-        const node = ce[i]; const
-          element = te[i];
-        if (!keepid) node.removeAttribute('id');
-        /* <ltIE9> */
-        if (node.clearAttributes) {
-          node.clearAttributes();
-          node.mergeAttributes(element);
-          node.removeAttribute('uniqueNumber');
-          if (node.options) {
-            const no = node.options; const
-              eo = element.options;
-            for (let j = no.length; j--;) no[j].selected = eo[j].selected;
-          }
-        }
-        /* </ltIE9> */
-        const prop = formProps[element.tagName.toLowerCase()];
-        if (prop && element[prop]) node[prop] = element[prop];
-      }
-
-      /* <ltIE9> */
-      if (hasCloneBug) {
-        const co = clone.getElementsByTagName('object'); const
-          to = this.getElementsByTagName('object');
-        for (i = co.length; i--;) co[i].outerHTML = to[i].outerHTML;
-      }
-      /* </ltIE9> */
-      return document.id(clone);
-    },
-
-  });
-
-  [Element, Window, Document].invoke('implement', {
-
-    addListener(type, fn) {
-      if (window.attachEvent && !window.addEventListener) {
-        collected[Slick.uidOf(this)] = this;
-      }
-      if (this.addEventListener) this.addEventListener(type, fn, !!arguments[2]);
-      else this.attachEvent(`on${type}`, fn);
-      return this;
-    },
-
-    removeListener(type, fn) {
-      if (this.removeEventListener) this.removeEventListener(type, fn, !!arguments[2]);
-      else this.detachEvent(`on${type}`, fn);
-      return this;
-    },
-
-    retrieve(property, dflt) {
-      const storage = get(Slick.uidOf(this)); let
-        prop = storage[property];
-      if (dflt != null && prop == null) prop = storage[property] = dflt;
-      return prop != null ? prop : null;
-    },
-
-    store(property, value) {
-      const storage = get(Slick.uidOf(this));
-      storage[property] = value;
-      return this;
-    },
-
-    eliminate(property) {
-      const storage = get(Slick.uidOf(this));
-      delete storage[property];
-      return this;
-    },
-
-  });
-
-  /* <ltIE9> */
-  if (window.attachEvent && !window.addEventListener) {
-    var gc = function () {
-      Object.each(collected, clean);
-      if (window.CollectGarbage) CollectGarbage();
-      window.removeListener('unload', gc);
-    };
-    window.addListener('unload', gc);
-  }
-  /* </ltIE9> */
-
-  Element.Properties = {};
-
-  Element.Properties.style = {
-
-    set(style) {
-      this.style.cssText = style;
-    },
-
-    get() {
-      return this.style.cssText;
-    },
-
-    erase() {
-      this.style.cssText = '';
-    },
-
-  };
-
-  Element.Properties.tag = {
-
-    get() {
-      return this.tagName.toLowerCase();
-    },
-
-  };
-
-  Element.Properties.html = {
-
-    set(html) {
-      if (html == null) html = '';
-      else if (typeOf(html) == 'array') html = html.join('');
-
-      /* <ltIE9> */
-      if (this.styleSheet && !canChangeStyleHTML) this.styleSheet.cssText = html;
-      else /* </ltIE9> */this.innerHTML = html;
-    },
-    erase() {
-      this.set('html', '');
-    },
-
-  };
-
-  let supportsHTML5Elements = true; let supportsTableInnerHTML = true; let
-    supportsTRInnerHTML = true;
-
-  /* <ltIE9> */
-  // technique by jdbarlett - http://jdbartlett.com/innershiv/
-  let div = document.createElement('div');
-  let fragment;
-  div.innerHTML = '<nav></nav>';
-  supportsHTML5Elements = (div.childNodes.length == 1);
-  if (!supportsHTML5Elements) {
-    const tags = 'abbr article aside audio canvas datalist details figcaption figure footer header hgroup mark meter nav output progress section summary time video'.split(' ');
-    fragment = document.createDocumentFragment(), l = tags.length;
-    while (l--) fragment.createElement(tags[l]);
-  }
-  div = null;
-  /* </ltIE9> */
-
-  /* <IE> */
-  supportsTableInnerHTML = Function.attempt(() => {
-    const table = document.createElement('table');
-    table.innerHTML = '<tr><td></td></tr>';
-    return true;
-  });
-
-  /* <ltFF4> */
-  let tr = document.createElement('tr'); const
-    html = '<td></td>';
-  tr.innerHTML = html;
-  supportsTRInnerHTML = (tr.innerHTML == html);
-  tr = null;
-  /* </ltFF4> */
-
-  if (!supportsTableInnerHTML || !supportsTRInnerHTML || !supportsHTML5Elements) {
-    Element.Properties.html.set = (function (set) {
-      const translations = {
-        table: [1, '<table>', '</table>'],
-        select: [1, '<select>', '</select>'],
-        tbody: [2, '<table><tbody>', '</tbody></table>'],
-        tr: [3, '<table><tbody><tr>', '</tr></tbody></table>'],
-      };
-
-      translations.thead = translations.tfoot = translations.tbody;
-
-      return function (html) {
-        /* <ltIE9> */
-        if (this.styleSheet) return set.call(this, html);
-        /* </ltIE9> */
-        let wrap = translations[this.get('tag')];
-        if (!wrap && !supportsHTML5Elements) wrap = [0, '', ''];
-        if (!wrap) return set.call(this, html);
-
-        let level = wrap[0]; let wrapper = document.createElement('div'); let
-          target = wrapper;
-        if (!supportsHTML5Elements) fragment.appendChild(wrapper);
-        wrapper.innerHTML = [wrap[1], html, wrap[2]].flatten().join('');
-        while (level--) target = target.firstChild;
-        this.empty().adopt(target.childNodes);
-        if (!supportsHTML5Elements) fragment.removeChild(wrapper);
-        wrapper = null;
-      };
-    }(Element.Properties.html.set));
-  }
-  /* </IE> */
-
-  /* <ltIE9> */
-  let testForm = document.createElement('form');
-  testForm.innerHTML = '<select><option>s</option></select>';
-
-  if (testForm.firstChild.value != 's') {
-    Element.Properties.value = {
-
-      set(value) {
-        const tag = this.get('tag');
-        if (tag != 'select') return this.setProperty('value', value);
-        const options = this.getElements('option');
-        value = String(value);
-        for (let i = 0; i < options.length; i++) {
-          const option = options[i];
-          const attr = option.getAttributeNode('value');
-          const optionValue = (attr && attr.specified) ? option.value : option.get('text');
-          if (optionValue === value) return option.selected = true;
-        }
-      },
-
-      get() {
-        let option = this; const
-          tag = option.get('tag');
-
-        if (tag != 'select' && tag != 'option') return this.getProperty('value');
-
-        if (tag == 'select' && !(option = option.getSelected()[0])) return '';
-
-        const attr = option.getAttributeNode('value');
-        return (attr && attr.specified) ? option.value : option.get('text');
-      },
-
-    };
-  }
-  testForm = null;
-  /* </ltIE9> */
-
-  /* <IE> */
-  if (document.createElement('div').getAttributeNode('id')) {
-    Element.Properties.id = {
-      set(id) {
-        this.id = this.getAttributeNode('id').value = id;
-      },
-      get() {
-        return this.id || null;
-      },
-      erase() {
-        this.id = this.getAttributeNode('id').value = '';
-      },
-    };
-  }
-  /* </IE> */
-}());
-
-/*
----
-
-name: Event
-
-description: Contains the Event Type, to make the event object cross-browser.
-
-license: MIT-style license.
-
-requires: [Window, Document, Array, Function, String, Object]
-
-provides: Event
-
-...
-*/
-
-(function () {
-  const _keys = {};
-  const normalizeWheelSpeed = function (event) {
-    let normalized;
-    if (event.wheelDelta) {
-      normalized = event.wheelDelta % 120 == 0 ? event.wheelDelta / 120 : event.wheelDelta / 12;
-    } else {
-      const rawAmount = event.deltaY || event.detail || 0;
-      normalized = -(rawAmount % 3 == 0 ? rawAmount / 3 : rawAmount * 10);
-    }
-    return normalized;
-  };
-
-  const DOMEvent = this.DOMEvent = new Type('DOMEvent', function (event, win) {
-    if (!win) win = window;
-    event = event || win.event;
-    if (event.$extended) return event;
-    this.event = event;
-    this.$extended = true;
-    this.shift = event.shiftKey;
-    this.control = event.ctrlKey;
-    this.alt = event.altKey;
-    this.meta = event.metaKey;
-    const type = this.type = event.type;
-    let target = event.target || event.srcElement;
-    while (target && target.nodeType == 3) target = target.parentNode;
-    this.target = document.id(target);
-
-    if (type.indexOf('key') == 0) {
-      const code = this.code = (event.which || event.keyCode);
-      if (!this.shift || type != 'keypress') this.key = _keys[code];
-      if (type == 'keydown' || type == 'keyup') {
-        if (code > 111 && code < 124) this.key = `f${code - 111}`;
-        else if (code > 95 && code < 106) this.key = code - 96;
-      }
-      if (this.key == null) this.key = String.fromCharCode(code).toLowerCase();
-    } else if (type == 'click' || type == 'dblclick' || type == 'contextmenu' || type == 'wheel' || type == 'DOMMouseScroll' || type.indexOf('mouse') == 0) {
-      let doc = win.document;
-      doc = (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html : doc.body;
-      this.page = {
-        x: (event.pageX != null) ? event.pageX : event.clientX + doc.scrollLeft,
-        y: (event.pageY != null) ? event.pageY : event.clientY + doc.scrollTop,
-      };
-      this.client = {
-        x: (event.pageX != null) ? event.pageX - win.pageXOffset : event.clientX,
-        y: (event.pageY != null) ? event.pageY - win.pageYOffset : event.clientY,
-      };
-      if (type == 'DOMMouseScroll' || type == 'wheel' || type == 'mousewheel') this.wheel = normalizeWheelSpeed(event);
-      this.rightClick = (event.which == 3 || event.button == 2);
-      if (type == 'mouseover' || type == 'mouseout' || type == 'mouseenter' || type == 'mouseleave') {
-        const overTarget = type == 'mouseover' || type == 'mouseenter';
-        let related = event.relatedTarget || event[`${overTarget ? 'from' : 'to'}Element`];
-        while (related && related.nodeType == 3) related = related.parentNode;
-        this.relatedTarget = document.id(related);
-      }
-    } else if (type.indexOf('touch') == 0 || type.indexOf('gesture') == 0) {
-      this.rotation = event.rotation;
-      this.scale = event.scale;
-      this.targetTouches = event.targetTouches;
-      this.changedTouches = event.changedTouches;
-      const touches = this.touches = event.touches;
-      if (touches && touches[0]) {
-        const touch = touches[0];
-        this.page = { x: touch.pageX, y: touch.pageY };
-        this.client = { x: touch.clientX, y: touch.clientY };
-      }
-    }
-
-    if (!this.client) this.client = {};
-    if (!this.page) this.page = {};
-  });
-
-  DOMEvent.implement({
-
-    stop() {
-      return this.preventDefault().stopPropagation();
-    },
-
-    stopPropagation() {
-      if (this.event.stopPropagation) this.event.stopPropagation();
-      else this.event.cancelBubble = true;
-      return this;
-    },
-
-    preventDefault() {
-      if (this.event.preventDefault) this.event.preventDefault();
-      else this.event.returnValue = false;
-      return this;
-    },
-
-  });
-
-  DOMEvent.defineKey = function (code, key) {
-    _keys[code] = key;
-    return this;
-  };
-
-  DOMEvent.defineKeys = DOMEvent.defineKey.overloadSetter(true);
-
-  DOMEvent.defineKeys({
-    38: 'up',
-    40: 'down',
-    37: 'left',
-    39: 'right',
-    27: 'esc',
-    32: 'space',
-    8: 'backspace',
-    9: 'tab',
-    46: 'delete',
-    13: 'enter',
-  });
-}());
-
-/*
----
-
-name: Element.Event
-
-description: Contains Element methods for dealing with events. This file also includes mouseenter and mouseleave custom Element Events, if necessary.
-
-license: MIT-style license.
-
-requires: [Element, Event]
-
-provides: Element.Event
-
-...
-*/
-
-(function () {
-  Element.Properties.events = {
-    set(events) {
-      this.addEvents(events);
-    },
-  };
-
-  [Element, Window, Document].invoke('implement', {
-
-    addEvent(type, fn) {
-      const events = this.retrieve('events', {});
-      if (!events[type]) events[type] = { keys: [], values: [] };
-      if (events[type].keys.contains(fn)) return this;
-      events[type].keys.push(fn);
-      let realType = type;
-      const custom = Element.Events[type];
-      let condition = fn;
-      const self = this;
-      if (custom) {
-        if (custom.onAdd) custom.onAdd.call(this, fn, type);
-        if (custom.condition) {
-          condition = function (event) {
-            if (custom.condition.call(this, event, type)) return fn.call(this, event);
-            return true;
-          };
-        }
-        if (custom.base) realType = Function.convert(custom.base).call(this, type);
-      }
-      let defn = function () {
-        return fn.call(self);
-      };
-      const nativeEvent = Element.NativeEvents[realType];
-      if (nativeEvent) {
-        if (nativeEvent == 2) {
-          defn = function (event) {
-            event = new DOMEvent(event, self.getWindow());
-            if (condition.call(self, event) === false) event.stop();
-          };
-        }
-        this.addListener(realType, defn, arguments[2]);
-      }
-      events[type].values.push(defn);
-      return this;
-    },
-
-    removeEvent(type, fn) {
-      const events = this.retrieve('events');
-      if (!events || !events[type]) return this;
-      const list = events[type];
-      const index = list.keys.indexOf(fn);
-      if (index == -1) return this;
-      const value = list.values[index];
-      delete list.keys[index];
-      delete list.values[index];
-      const custom = Element.Events[type];
-      if (custom) {
-        if (custom.onRemove) custom.onRemove.call(this, fn, type);
-        if (custom.base) type = Function.convert(custom.base).call(this, type);
-      }
-      return (Element.NativeEvents[type]) ? this.removeListener(type, value, arguments[2]) : this;
-    },
-
-    addEvents(events) {
-      for (const event in events) this.addEvent(event, events[event]);
-      return this;
-    },
-
-    removeEvents(events) {
-      let type;
-      if (typeOf(events) == 'object') {
-        for (type in events) this.removeEvent(type, events[type]);
-        return this;
-      }
-      const attached = this.retrieve('events');
-      if (!attached) return this;
-      if (!events) {
-        for (type in attached) this.removeEvents(type);
-        this.eliminate('events');
-      } else if (attached[events]) {
-        attached[events].keys.each(function (fn) {
-          this.removeEvent(events, fn);
-        }, this);
-        delete attached[events];
-      }
-      return this;
-    },
-
-    fireEvent(type, args, delay) {
-      const events = this.retrieve('events');
-      if (!events || !events[type]) return this;
-      args = Array.convert(args);
-
-      events[type].keys.each(function (fn) {
-        if (delay) fn.delay(delay, this, args);
-        else fn.apply(this, args);
-      }, this);
-      return this;
-    },
-
-    cloneEvents(from, type) {
-      from = document.id(from);
-      const events = from.retrieve('events');
-      if (!events) return this;
-      if (!type) {
-        for (const eventType in events) this.cloneEvents(from, eventType);
-      } else if (events[type]) {
-        events[type].keys.each(function (fn) {
-          this.addEvent(type, fn);
-        }, this);
-      }
-      return this;
-    },
-
-  });
-
-  Element.NativeEvents = {
-    click: 2,
-    dblclick: 2,
-    mouseup: 2,
-    mousedown: 2,
-    contextmenu: 2, // mouse buttons
-    wheel: 2,
-    mousewheel: 2,
-    DOMMouseScroll: 2, // mouse wheel
-    mouseover: 2,
-    mouseout: 2,
-    mousemove: 2,
-    selectstart: 2,
-    selectend: 2, // mouse movement
-    keydown: 2,
-    keypress: 2,
-    keyup: 2, // keyboard
-    orientationchange: 2, // mobile
-    touchstart: 2,
-    touchmove: 2,
-    touchend: 2,
-    touchcancel: 2, // touch
-    gesturestart: 2,
-    gesturechange: 2,
-    gestureend: 2, // gesture
-    focus: 2,
-    blur: 2,
-    change: 2,
-    reset: 2,
-    select: 2,
-    submit: 2,
-    paste: 2,
-    input: 2, // form elements
-    load: 2,
-    unload: 1,
-    beforeunload: 2,
-    resize: 1,
-    move: 1,
-    DOMContentLoaded: 1,
-    readystatechange: 1, // window
-    hashchange: 1,
-    popstate: 2,
-    pageshow: 2,
-    pagehide: 2, // history
-    error: 1,
-    abort: 1,
-    scroll: 1,
-    message: 2, // misc
-  };
-
-  Element.Events = {
-    mousewheel: {
-      base: 'onwheel' in document ? 'wheel' : 'onmousewheel' in document ? 'mousewheel' : 'DOMMouseScroll',
-    },
-  };
-
-  const check = function (event) {
-    const related = event.relatedTarget;
-    if (related == null) return true;
-    if (!related) return false;
-    return (related != this && related.prefix != 'xul' && typeOf(this) != 'document' && !this.contains(related));
-  };
-
-  if ('onmouseenter' in document.documentElement) {
-    Element.NativeEvents.mouseenter = Element.NativeEvents.mouseleave = 2;
-    Element.MouseenterCheck = check;
-  } else {
-    Element.Events.mouseenter = {
-      base: 'mouseover',
-      condition: check,
-    };
-
-    Element.Events.mouseleave = {
-      base: 'mouseout',
-      condition: check,
-    };
-  }
-
-  /* <ltIE9> */
-  if (!window.addEventListener) {
-    Element.NativeEvents.propertychange = 2;
-    Element.Events.change = {
-      base() {
-        const { type } = this;
-        return (this.get('tag') == 'input' && (type == 'radio' || type == 'checkbox')) ? 'propertychange' : 'change';
-      },
-      condition(event) {
-        return event.type != 'propertychange' || event.event.propertyName == 'checked';
-      },
-    };
-  }
-  /* </ltIE9> */
-}());
-
-/*
----
-
-name: Element.Delegation
-
-description: Extends the Element native object to include the delegate method for more efficient event management.
-
-license: MIT-style license.
-
-requires: [Element.Event]
-
-provides: [Element.Delegation]
-
-...
-*/
-
-(function () {
-  const eventListenerSupport = !!window.addEventListener;
-
-  Element.NativeEvents.focusin = Element.NativeEvents.focusout = 2;
-
-  const bubbleUp = function (self, match, fn, event, target) {
-    while (target && target != self) {
-      if (match(target, event)) return fn.call(target, event, target);
-      target = document.id(target.parentNode);
-    }
-  };
-
-  const map = {
-    mouseenter: {
-      base: 'mouseover',
-      condition: Element.MouseenterCheck,
-    },
-    mouseleave: {
-      base: 'mouseout',
-      condition: Element.MouseenterCheck,
-    },
-    focus: {
-      base: `focus${eventListenerSupport ? '' : 'in'}`,
-      capture: true,
-    },
-    blur: {
-      base: eventListenerSupport ? 'blur' : 'focusout',
-      capture: true,
-    },
-  };
-
-  /* <ltIE9> */
-  const _key = '$delegation:';
-  const formObserver = function (type) {
-    return {
-
-      base: 'focusin',
-
-      remove(self, uid) {
-        const list = self.retrieve(`${_key + type}listeners`, {})[uid];
-        if (list && list.forms) {
-          for (let i = list.forms.length; i--;) {
-          // the form may have been destroyed, so it won't have the
-          // removeEvent method anymore. In that case the event was
-          // removed as well.
-            if (list.forms[i].removeEvent) list.forms[i].removeEvent(type, list.fns[i]);
-          }
-        }
-      },
-
-      listen(self, match, fn, event, target, uid) {
-        const form = (target.get('tag') == 'form') ? target : event.target.getParent('form');
-        if (!form) return;
-
-        const listeners = self.retrieve(`${_key + type}listeners`, {});
-        const listener = listeners[uid] || { forms: [], fns: [] };
-        const { forms } = listener; const
-          { fns } = listener;
-
-        if (forms.indexOf(form) != -1) return;
-        forms.push(form);
-
-        const _fn = function (event) {
-          bubbleUp(self, match, fn, event, target);
-        };
-        form.addEvent(type, _fn);
-        fns.push(_fn);
-
-        listeners[uid] = listener;
-        self.store(`${_key + type}listeners`, listeners);
-      },
-    };
-  };
-
-  const inputObserver = function (type) {
-    return {
-      base: 'focusin',
-      listen(self, match, fn, event, target) {
-        var events = {
-          blur() {
-            this.removeEvents(events);
-          },
-        };
-        events[type] = function (event) {
-          bubbleUp(self, match, fn, event, target);
-        };
-        event.target.addEvents(events);
-      },
-    };
-  };
-
-  if (!eventListenerSupport) {
-    Object.append(map, {
-      submit: formObserver('submit'),
-      reset: formObserver('reset'),
-      change: inputObserver('change'),
-      select: inputObserver('select'),
-    });
-  }
-  /* </ltIE9> */
-
-  const proto = Element.prototype;
-  const { addEvent } = proto;
-  const { removeEvent } = proto;
-
-  const relay = function (old, method) {
-    return function (type, fn, useCapture) {
-      if (type.indexOf(':relay') == -1) return old.call(this, type, fn, useCapture);
-      const parsed = Slick.parse(type).expressions[0][0];
-      if (parsed.pseudos[0].key != 'relay') return old.call(this, type, fn, useCapture);
-      let newType = parsed.tag;
-      parsed.pseudos.slice(1).each((pseudo) => {
-        newType += `:${pseudo.key}${pseudo.value ? `(${pseudo.value})` : ''}`;
-      });
-      old.call(this, type, fn);
-      return method.call(this, newType, parsed.pseudos[0].value, fn);
-    };
-  };
-
-  var delegation = {
-
-    addEvent(type, match, fn) {
-      const storage = this.retrieve('$delegates', {}); let
-        stored = storage[type];
-      if (stored) {
-        for (const _uid in stored) {
-          if (stored[_uid].fn == fn && stored[_uid].match == match) return this;
-        }
-      }
-
-      const _type = type; const _match = match; const _fn = fn; const
-        _map = map[type] || {};
-      type = _map.base || _type;
-
-      match = function (target) {
-        return Slick.match(target, _match);
-      };
-
-      const elementEvent = Element.Events[_type];
-      if (_map.condition || elementEvent && elementEvent.condition) {
-        const __match = match; const
-          condition = _map.condition || elementEvent.condition;
-        match = function (target, event) {
-          return __match(target, event) && condition.call(target, event, type);
-        };
-      }
-
-      const self = this; const
-        uid = String.uniqueID();
-      const delegator = _map.listen ? function (event, target) {
-        if (!target && event && event.target) target = event.target;
-        if (target) _map.listen(self, match, fn, event, target, uid);
-      } : function (event, target) {
-        if (!target && event && event.target) target = event.target;
-        if (target) bubbleUp(self, match, fn, event, target);
-      };
-
-      if (!stored) stored = {};
-      stored[uid] = {
-        match: _match,
-        fn: _fn,
-        delegator,
-      };
-      storage[_type] = stored;
-      return addEvent.call(this, type, delegator, _map.capture);
-    },
-
-    removeEvent(type, match, fn, _uid) {
-      const storage = this.retrieve('$delegates', {}); const
-        stored = storage[type];
-      if (!stored) return this;
-
-      if (_uid) {
-        const _type = type; const { delegator } = stored[_uid]; const
-          _map = map[type] || {};
-        type = _map.base || _type;
-        if (_map.remove) _map.remove(this, _uid);
-        delete stored[_uid];
-        storage[_type] = stored;
-        return removeEvent.call(this, type, delegator, _map.capture);
-      }
-
-      let __uid; let
-        s;
-      if (fn) {
-        for (__uid in stored) {
-          s = stored[__uid];
-          if (s.match == match && s.fn == fn) return delegation.removeEvent.call(this, type, match, fn, __uid);
-        }
-      } else {
-        for (__uid in stored) {
-          s = stored[__uid];
-          if (s.match == match) delegation.removeEvent.call(this, type, match, s.fn, __uid);
-        }
-      }
-      return this;
-    },
-
-  };
-
-  [Element, Window, Document].invoke('implement', {
-    addEvent: relay(addEvent, delegation.addEvent),
-    removeEvent: relay(removeEvent, delegation.removeEvent),
-  });
-}());
-
-/*
----
-
-name: Element.Style
-
-description: Contains methods for interacting with the styles of Elements in a fashionable way.
-
-license: MIT-style license.
-
-requires: Element
-
-provides: Element.Style
-
-...
-*/
-
-(function () {
-  const { html } = document;
-  let el;
-
-  // <ltIE9>
-  // Check for oldIE, which does not remove styles when they're set to null
-  el = document.createElement('div');
-  el.style.color = 'red';
-  el.style.color = null;
-  const doesNotRemoveStyles = el.style.color == 'red';
-
-  // check for oldIE, which returns border* shorthand styles in the wrong order (color-width-style instead of width-style-color)
-  const border = '1px solid #123abc';
-  el.style.border = border;
-  const returnsBordersInWrongOrder = el.style.border != border;
-  el = null;
-  // </ltIE9>
-
-  const hasGetComputedStyle = !!window.getComputedStyle;
-  const supportBorderRadius = document.createElement('div').style.borderRadius != null;
-
-  Element.Properties.styles = {
-    set(styles) {
-      this.setStyles(styles);
-    },
-  };
-
-  const hasOpacity = (html.style.opacity != null);
-  const hasFilter = (html.style.filter != null);
-  const reAlpha = /alpha\(opacity=([\d.]+)\)/i;
-
-  const setVisibility = function (element, opacity) {
-    element.store('$opacity', opacity);
-    element.style.visibility = opacity > 0 || opacity == null ? 'visible' : 'hidden';
-  };
-
-  // <ltIE9>
-  const setFilter = function (element, regexp, value) {
-    const { style } = element;
-    const filter = style.filter || element.getComputedStyle('filter') || '';
-    style.filter = (regexp.test(filter) ? filter.replace(regexp, value) : `${filter} ${value}`).trim();
-    if (!style.filter) style.removeAttribute('filter');
-  };
-  // </ltIE9>
-
-  const setOpacity = (hasOpacity ? function (element, opacity) {
-    element.style.opacity = opacity;
-  } : (hasFilter ? function (element, opacity) {
-    if (!element.currentStyle || !element.currentStyle.hasLayout) element.style.zoom = 1;
-    if (opacity == null || opacity == 1) {
-      setFilter(element, reAlpha, '');
-      if (opacity == 1 && getOpacity(element) != 1) setFilter(element, reAlpha, 'alpha(opacity=100)');
-    } else {
-      setFilter(element, reAlpha, `alpha(opacity=${(opacity * 100).limit(0, 100).round()})`);
-    }
-  } : setVisibility));
-
-  var getOpacity = (hasOpacity ? function (element) {
-    const opacity = element.style.opacity || element.getComputedStyle('opacity');
-    return (opacity == '') ? 1 : opacity.toFloat();
-  } : (hasFilter ? function (element) {
-    const filter = (element.style.filter || element.getComputedStyle('filter'));
-    let opacity;
-    if (filter) opacity = filter.match(reAlpha);
-    return (opacity == null || filter == null) ? 1 : (opacity[1] / 100);
-  } : function (element) {
-    let opacity = element.retrieve('$opacity');
-    if (opacity == null) opacity = (element.style.visibility == 'hidden' ? 0 : 1);
-    return opacity;
-  }));
-
-  const floatName = (html.style.cssFloat == null) ? 'styleFloat' : 'cssFloat';
-  const namedPositions = {
-    left: '0%', top: '0%', center: '50%', right: '100%', bottom: '100%',
-  };
-  const hasBackgroundPositionXY = (html.style.backgroundPositionX != null);
-  const prefixPattern = /^-(ms)-/;
-
-  const camelCase = function (property) {
-    return property.replace(prefixPattern, '$1-').camelCase();
-  };
-
-  // <ltIE9>
-  const removeStyle = function (style, property) {
-    if (property == 'backgroundPosition') {
-      style.removeAttribute(`${property}X`);
-      property += 'Y';
-    }
-    style.removeAttribute(property);
-  };
-  // </ltIE9>
-
-  Element.implement({
-
-    getComputedStyle(property) {
-      if (!hasGetComputedStyle && this.currentStyle) return this.currentStyle[camelCase(property)];
-      const { defaultView } = Element.getDocument(this);
-      const computed = defaultView ? defaultView.getComputedStyle(this, null) : null;
-      return (computed) ? computed.getPropertyValue((property == floatName) ? 'float' : property.hyphenate()) : '';
-    },
-
-    setStyle(property, value) {
-      if (property == 'opacity') {
-        if (value != null) value = parseFloat(value);
-        setOpacity(this, value);
-        return this;
-      }
-      property = camelCase(property == 'float' ? floatName : property);
-      if (typeOf(value) != 'string') {
-        const map = (Element.Styles[property] || '@').split(' ');
-        value = Array.convert(value).map((val, i) => {
-          if (!map[i]) return '';
-          return (typeOf(val) == 'number') ? map[i].replace('@', Math.round(val)) : val;
-        }).join(' ');
-      } else if (value == String(Number(value))) {
-        value = Math.round(value);
-      }
-      this.style[property] = value;
-      // <ltIE9>
-      if ((value == '' || value == null) && doesNotRemoveStyles && this.style.removeAttribute) {
-        removeStyle(this.style, property);
-      }
-      // </ltIE9>
-      return this;
-    },
-
-    getStyle(property) {
-      if (property == 'opacity') return getOpacity(this);
-      property = camelCase(property == 'float' ? floatName : property);
-      if (supportBorderRadius && property.indexOf('borderRadius') != -1) {
-        return ['borderTopLeftRadius', 'borderTopRightRadius', 'borderBottomRightRadius', 'borderBottomLeftRadius'].map(function (corner) {
-          return this.style[corner] || '0px';
-        }, this).join(' ');
-      }
-      let result = this.style[property];
-      if (!result || property == 'zIndex') {
-        if (Element.ShortStyles.hasOwnProperty(property)) {
-          result = [];
-          for (const s in Element.ShortStyles[property]) result.push(this.getStyle(s));
-          return result.join(' ');
-        }
-        result = this.getComputedStyle(property);
-      }
-      if (hasBackgroundPositionXY && /^backgroundPosition[XY]?$/.test(property)) {
-        return result.replace(/(top|right|bottom|left)/g, (position) => namedPositions[position]) || '0px';
-      }
-      if (!result && property == 'backgroundPosition') return '0px 0px';
-      if (result) {
-        result = String(result);
-        const color = result.match(/rgba?\([\d\s,]+\)/);
-        if (color) result = result.replace(color[0], color[0].rgbToHex());
-      }
-      if (!hasGetComputedStyle && !this.style[property]) {
-        if ((/^(height|width)$/).test(property) && !(/px$/.test(result))) {
-          const values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom']; let
-            size = 0;
-          values.each(function (value) {
-            size += this.getStyle(`border-${value}-width`).toInt() + this.getStyle(`padding-${value}`).toInt();
-          }, this);
-          return `${this[`offset${property.capitalize()}`] - size}px`;
-        }
-        if ((/^border(.+)Width|margin|padding/).test(property) && isNaN(parseFloat(result))) {
-          return '0px';
-        }
-      }
-      // <ltIE9>
-      if (returnsBordersInWrongOrder && /^border(Top|Right|Bottom|Left)?$/.test(property) && /^#/.test(result)) {
-        return result.replace(/^(.+)\s(.+)\s(.+)$/, '$2 $3 $1');
-      }
-      // </ltIE9>
-
-      return result;
-    },
-
-    setStyles(styles) {
-      for (const style in styles) this.setStyle(style, styles[style]);
-      return this;
-    },
-
-    getStyles() {
-      const result = {};
-      Array.flatten(arguments).each(function (key) {
-        result[key] = this.getStyle(key);
-      }, this);
-      return result;
-    },
-
-  });
-
-  Element.Styles = {
-    left: '@px',
-    top: '@px',
-    bottom: '@px',
-    right: '@px',
-    width: '@px',
-    height: '@px',
-    maxWidth: '@px',
-    maxHeight: '@px',
-    minWidth: '@px',
-    minHeight: '@px',
-    backgroundColor: 'rgb(@, @, @)',
-    backgroundSize: '@px',
-    backgroundPosition: '@px @px',
-    color: 'rgb(@, @, @)',
-    fontSize: '@px',
-    letterSpacing: '@px',
-    lineHeight: '@px',
-    clip: 'rect(@px @px @px @px)',
-    margin: '@px @px @px @px',
-    padding: '@px @px @px @px',
-    border: '@px @ rgb(@, @, @) @px @ rgb(@, @, @) @px @ rgb(@, @, @)',
-    borderWidth: '@px @px @px @px',
-    borderStyle: '@ @ @ @',
-    borderColor: 'rgb(@, @, @) rgb(@, @, @) rgb(@, @, @) rgb(@, @, @)',
-    zIndex: '@',
-    zoom: '@',
-    fontWeight: '@',
-    textIndent: '@px',
-    opacity: '@',
-    borderRadius: '@px @px @px @px',
-  };
-
-  Element.ShortStyles = {
-    margin: {}, padding: {}, border: {}, borderWidth: {}, borderStyle: {}, borderColor: {},
-  };
-
-  ['Top', 'Right', 'Bottom', 'Left'].each((direction) => {
-    const Short = Element.ShortStyles;
-    const All = Element.Styles;
-    ['margin', 'padding'].each((style) => {
-      const sd = style + direction;
-      Short[style][sd] = All[sd] = '@px';
-    });
-    const bd = `border${direction}`;
-    Short.border[bd] = All[bd] = '@px @ rgb(@, @, @)';
-    const bdw = `${bd}Width`;
-    const bds = `${bd}Style`;
-    const bdc = `${bd}Color`;
-    Short[bd] = {};
-    Short.borderWidth[bdw] = Short[bd][bdw] = All[bdw] = '@px';
-    Short.borderStyle[bds] = Short[bd][bds] = All[bds] = '@';
-    Short.borderColor[bdc] = Short[bd][bdc] = All[bdc] = 'rgb(@, @, @)';
-  });
-
-  if (hasBackgroundPositionXY) Element.ShortStyles.backgroundPosition = { backgroundPositionX: '@', backgroundPositionY: '@' };
-}());
-
-/*
----
-
-name: Element.Dimensions
-
-description: Contains methods to work with size, scroll, or positioning of Elements and the window object.
-
-license: MIT-style license.
-
-credits:
-  - Element positioning based on the [qooxdoo](http://qooxdoo.org/) code and smart browser fixes, [LGPL License](http://www.gnu.org/licenses/lgpl.html).
-  - Viewport dimensions based on [YUI](http://developer.yahoo.com/yui/) code, [BSD License](http://developer.yahoo.com/yui/license.html).
-
-requires: [Element, Element.Style]
-
-provides: [Element.Dimensions]
-
-...
-*/
-
-(function () {
-  let element = document.createElement('div');
-  let child = document.createElement('div');
-  element.style.height = '0';
-  element.appendChild(child);
-  const brokenOffsetParent = (child.offsetParent === element);
-  element = child = null;
-
-  const heightComponents = ['height', 'paddingTop', 'paddingBottom', 'borderTopWidth', 'borderBottomWidth'];
-  const widthComponents = ['width', 'paddingLeft', 'paddingRight', 'borderLeftWidth', 'borderRightWidth'];
-
-  const svgCalculateSize = function (el) {
-    const gCS = window.getComputedStyle(el);
-    const bounds = { x: 0, y: 0 };
-
-    heightComponents.each((css) => {
-      bounds.y += parseFloat(gCS[css]);
-    });
-    widthComponents.each((css) => {
-      bounds.x += parseFloat(gCS[css]);
-    });
-    return bounds;
-  };
-
-  const isOffset = function (el) {
-    return styleString(el, 'position') != 'static' || isBody(el);
-  };
-
-  const isOffsetStatic = function (el) {
-    return isOffset(el) || (/^(?:table|td|th)$/i).test(el.tagName);
-  };
-
-  Element.implement({
-
-    scrollTo(x, y) {
-      if (isBody(this)) {
-        this.getWindow().scrollTo(x, y);
-      } else {
-        this.scrollLeft = x;
-        this.scrollTop = y;
-      }
-      return this;
-    },
-
-    getSize() {
-      if (isBody(this)) return this.getWindow().getSize();
-
-      // <ltIE9>
-      // This if clause is because IE8- cannot calculate getBoundingClientRect of elements with visibility hidden.
-      if (!window.getComputedStyle) return { x: this.offsetWidth, y: this.offsetHeight };
-      // </ltIE9>
-
-      // This svg section under, calling `svgCalculateSize()`, can be removed when FF fixed the svg size bug.
-      // Bug info: https://bugzilla.mozilla.org/show_bug.cgi?id=530985
-      if (this.get('tag') == 'svg') return svgCalculateSize(this);
-
-      try {
-        const bounds = this.getBoundingClientRect();
-        return { x: bounds.width, y: bounds.height };
-      } catch (e) {
-        return { x: 0, y: 0 };
-      }
-    },
-
-    getScrollSize() {
-      if (isBody(this)) return this.getWindow().getScrollSize();
-      return { x: this.scrollWidth, y: this.scrollHeight };
-    },
-
-    getScroll() {
-      if (isBody(this)) return this.getWindow().getScroll();
-      return { x: this.scrollLeft, y: this.scrollTop };
-    },
-
-    getScrolls() {
-      let element = this.parentNode; const
-        position = { x: 0, y: 0 };
-      while (element && !isBody(element)) {
-        position.x += element.scrollLeft;
-        position.y += element.scrollTop;
-        element = element.parentNode;
-      }
-      return position;
-    },
-
-    getOffsetParent: brokenOffsetParent ? function () {
-      let element = this;
-      if (isBody(element) || styleString(element, 'position') == 'fixed') return null;
-
-      const isOffsetCheck = (styleString(element, 'position') == 'static') ? isOffsetStatic : isOffset;
-      while ((element = element.parentNode)) {
-        if (isOffsetCheck(element)) return element;
-      }
-      return null;
-    } : function () {
-      const element = this;
-      if (isBody(element) || styleString(element, 'position') == 'fixed') return null;
-
-      try {
-        return element.offsetParent;
-      } catch (e) {}
-      return null;
-    },
-
-    getOffsets() {
-      const hasGetBoundingClientRect = this.getBoundingClientRect;
-
-      if (hasGetBoundingClientRect) {
-        const bound = this.getBoundingClientRect();
-        const html = document.id(this.getDocument().documentElement);
-        const htmlScroll = html.getScroll();
-        const elemScrolls = this.getScrolls();
-        const isFixed = (styleString(this, 'position') == 'fixed');
-
-        return {
-          x: bound.left.toFloat() + elemScrolls.x + ((isFixed) ? 0 : htmlScroll.x) - html.clientLeft,
-          y: bound.top.toFloat() + elemScrolls.y + ((isFixed) ? 0 : htmlScroll.y) - html.clientTop,
-        };
-      }
-
-      let element = this; const
-        position = { x: 0, y: 0 };
-      if (isBody(this)) return position;
-
-      while (element && !isBody(element)) {
-        position.x += element.offsetLeft;
-        position.y += element.offsetTop;
-
-        element = element.offsetParent;
-      }
-
-      return position;
-    },
-
-    getPosition(relative) {
-      const offset = this.getOffsets();
-      const scroll = this.getScrolls();
-      const position = {
-        x: offset.x - scroll.x,
-        y: offset.y - scroll.y,
-      };
-
-      if (relative && (relative = document.id(relative))) {
-        const relativePosition = relative.getPosition();
-        return { x: position.x - relativePosition.x - leftBorder(relative), y: position.y - relativePosition.y - topBorder(relative) };
-      }
-      return position;
-    },
-
-    getCoordinates(element) {
-      if (isBody(this)) return this.getWindow().getCoordinates();
-      const position = this.getPosition(element);
-      const size = this.getSize();
-      const obj = {
-        left: position.x,
-        top: position.y,
-        width: size.x,
-        height: size.y,
-      };
-      obj.right = obj.left + obj.width;
-      obj.bottom = obj.top + obj.height;
-      return obj;
-    },
-
-    computePosition(obj) {
-      return {
-        left: obj.x - styleNumber(this, 'margin-left'),
-        top: obj.y - styleNumber(this, 'margin-top'),
-      };
-    },
-
-    setPosition(obj) {
-      return this.setStyles(this.computePosition(obj));
-    },
-
-  });
-
-  [Document, Window].invoke('implement', {
-
-    getSize() {
-      const doc = getCompatElement(this);
-      return { x: doc.clientWidth, y: doc.clientHeight };
-    },
-
-    getScroll() {
-      const win = this.getWindow(); const
-        doc = getCompatElement(this);
-      return { x: win.pageXOffset || doc.scrollLeft, y: win.pageYOffset || doc.scrollTop };
-    },
-
-    getScrollSize() {
-      const doc = getCompatElement(this);
-      const min = this.getSize();
-      const { body } = this.getDocument();
-
-      return { x: Math.max(doc.scrollWidth, body.scrollWidth, min.x), y: Math.max(doc.scrollHeight, body.scrollHeight, min.y) };
-    },
-
-    getPosition() {
-      return { x: 0, y: 0 };
-    },
-
-    getCoordinates() {
-      const size = this.getSize();
-      return {
-        top: 0, left: 0, bottom: size.y, right: size.x, height: size.y, width: size.x,
-      };
-    },
-
-  });
-
-  // private methods
-
-  var styleString = Element.getComputedStyle;
-
-  function styleNumber(element, style) {
-    return styleString(element, style).toInt() || 0;
-  }
-
-  function topBorder(element) {
-    return styleNumber(element, 'border-top-width');
-  }
-
-  function leftBorder(element) {
-    return styleNumber(element, 'border-left-width');
-  }
-
-  function isBody(element) {
-    return (/^(?:body|html)$/i).test(element.tagName);
-  }
-
-  function getCompatElement(element) {
-    const doc = element.getDocument();
-    return (!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html : doc.body;
-  }
-}());
-
-// aliases
-Element.alias({ position: 'setPosition' }); // compatability
-
-[Window, Document, Element].invoke('implement', {
-
-  getHeight() {
-    return this.getSize().y;
-  },
-
-  getWidth() {
-    return this.getSize().x;
-  },
-
-  getScrollTop() {
-    return this.getScroll().y;
-  },
-
-  getScrollLeft() {
-    return this.getScroll().x;
-  },
-
-  getScrollHeight() {
-    return this.getScrollSize().y;
-  },
-
-  getScrollWidth() {
-    return this.getScrollSize().x;
-  },
-
-  getTop() {
-    return this.getPosition().y;
-  },
-
-  getLeft() {
-    return this.getPosition().x;
-  },
-
-});
-
-/*
----
-
-name: Fx
-
-description: Contains the basic animation logic to be extended by all other Fx Classes.
-
-license: MIT-style license.
-
-requires: [Chain, Events, Options, Class.Thenable]
-
-provides: Fx
-
-...
-*/
-
-(function () {
-  var Fx = this.Fx = new Class({
-
-    Implements: [Chain, Events, Options, Class.Thenable],
-
-    options: {
-      /*
-		onStart: nil,
-		onCancel: nil,
-		onComplete: nil,
-		*/
-      fps: 60,
-      unit: false,
-      duration: 500,
-      frames: null,
-      frameSkip: true,
-      link: 'ignore',
-    },
-
-    initialize(options) {
-      this.subject = this.subject || this;
-      this.setOptions(options);
-    },
-
-    getTransition() {
-      return function (p) {
-        return -(Math.cos(Math.PI * p) - 1) / 2;
-      };
-    },
-
-    step(now) {
-      if (this.options.frameSkip) {
-        const diff = (this.time != null) ? (now - this.time) : 0; const
-          frames = diff / this.frameInterval;
-        this.time = now;
-        this.frame += frames;
-      } else {
-        this.frame++;
-      }
-
-      if (this.frame < this.frames) {
-        const delta = this.transition(this.frame / this.frames);
-        this.set(this.compute(this.from, this.to, delta));
-      } else {
-        this.frame = this.frames;
-        this.set(this.compute(this.from, this.to, 1));
-        this.stop();
-      }
-    },
-
-    set(now) {
-      return now;
-    },
-
-    compute(from, to, delta) {
-      return Fx.compute(from, to, delta);
-    },
-
-    check() {
-      if (!this.isRunning()) return true;
-      switch (this.options.link) {
-        case 'cancel': this.cancel(); return true;
-        case 'chain': this.chain(this.caller.pass(arguments, this)); return false;
-      }
-      return false;
-    },
-
-    start(from, to) {
-      if (!this.check(from, to)) return this;
-      this.from = from;
-      this.to = to;
-      this.frame = (this.options.frameSkip) ? 0 : -1;
-      this.time = null;
-      this.transition = this.getTransition();
-      const { frames } = this.options;
-      const { fps } = this.options;
-      const { duration } = this.options;
-      this.duration = Fx.Durations[duration] || duration.toInt();
-      this.frameInterval = 1000 / fps;
-      this.frames = frames || Math.round(this.duration / this.frameInterval);
-      if (this.getThenableState() !== 'pending') {
-        this.resetThenable(this.subject);
-      }
-      this.fireEvent('start', this.subject);
-      pushInstance.call(this, fps);
-      return this;
-    },
-
-    stop() {
-      if (this.isRunning()) {
-        this.time = null;
-        pullInstance.call(this, this.options.fps);
-        if (this.frames == this.frame) {
-          this.fireEvent('complete', this.subject);
-          if (!this.callChain()) this.fireEvent('chainComplete', this.subject);
-        } else {
-          this.fireEvent('stop', this.subject);
-        }
-        this.resolve(this.subject === this ? null : this.subject);
-      }
-      return this;
-    },
-
-    cancel() {
-      if (this.isRunning()) {
-        this.time = null;
-        pullInstance.call(this, this.options.fps);
-        this.frame = this.frames;
-        this.fireEvent('cancel', this.subject).clearChain();
-        this.reject(this.subject);
-      }
-      return this;
-    },
-
-    pause() {
-      if (this.isRunning()) {
-        this.time = null;
-        pullInstance.call(this, this.options.fps);
-      }
-      return this;
-    },
-
-    resume() {
-      if (this.isPaused()) pushInstance.call(this, this.options.fps);
-      return this;
-    },
-
-    isRunning() {
-      const list = instances[this.options.fps];
-      return list && list.contains(this);
-    },
-
-    isPaused() {
-      return (this.frame < this.frames) && !this.isRunning();
-    },
-
-  });
-
-  Fx.compute = function (from, to, delta) {
-    return (to - from) * delta + from;
-  };
-
-  Fx.Durations = { short: 250, normal: 500, long: 1000 };
-
-  // global timers
-
-  var instances = {}; const
-    timers = {};
-
-  const loop = function () {
-    const now = Date.now();
-    for (let i = this.length; i--;) {
-      const instance = this[i];
-      if (instance) instance.step(now);
-    }
-  };
-
-  var pushInstance = function (fps) {
-    const list = instances[fps] || (instances[fps] = []);
-    list.push(this);
-    if (!timers[fps]) timers[fps] = loop.periodical(Math.round(1000 / fps), list);
-  };
-
-  var pullInstance = function (fps) {
-    const list = instances[fps];
-    if (list) {
-      list.erase(this);
-      if (!list.length && timers[fps]) {
-        delete instances[fps];
-        timers[fps] = clearInterval(timers[fps]);
-      }
-    }
-  };
-}());
-
-/*
----
-
-name: Fx.CSS
-
-description: Contains the CSS animation logic. Used by Fx.Tween, Fx.Morph, Fx.Elements.
-
-license: MIT-style license.
-
-requires: [Fx, Element.Style]
-
-provides: Fx.CSS
-
-...
-*/
-
-Fx.CSS = new Class({
-
-  Extends: Fx,
-
-  // prepares the base from/to object
-
-  prepare(element, property, values) {
-    values = Array.convert(values);
-    let from = values[0]; let
-      to = values[1];
-    if (to == null) {
-      to = from;
-      from = element.getStyle(property);
-      const { unit } = this.options;
-      // adapted from: https://github.com/ryanmorr/fx/blob/master/fx.js#L299
-      if (unit && from && typeof from === 'string' && from.slice(-unit.length) != unit && parseFloat(from) != 0) {
-        element.setStyle(property, to + unit);
-        let value = element.getComputedStyle(property);
-        // IE and Opera support pixelLeft or pixelWidth
-        if (!(/px$/.test(value))) {
-          value = element.style[(`pixel-${property}`).camelCase()];
-          if (value == null) {
-            // adapted from Dean Edwards' http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
-            const { left } = element.style;
-            element.style.left = to + unit;
-            value = element.style.pixelLeft;
-            element.style.left = left;
-          }
-        }
-        from = (to || 1) / (parseFloat(value) || 1) * (parseFloat(from) || 0);
-        element.setStyle(property, from + unit);
-      }
-    }
-    return { from: this.parse(from), to: this.parse(to) };
-  },
-
-  // parses a value into an array
-
-  parse(value) {
-    value = Function.convert(value)();
-    value = (typeof value === 'string') ? value.split(' ') : Array.convert(value);
-    return value.map((val) => {
-      val = String(val);
-      let found = false;
-      Object.each(Fx.CSS.Parsers, (parser) => {
-        if (found) return;
-        const parsed = parser.parse(val);
-        if (parsed || parsed === 0) found = { value: parsed, parser };
-      });
-      found = found || { value: val, parser: Fx.CSS.Parsers.String };
-      return found;
-    });
-  },
-
-  // computes by a from and to prepared objects, using their parsers.
-
-  compute(from, to, delta) {
-    const computed = [];
-    (Math.min(from.length, to.length)).times((i) => {
-      computed.push({ value: from[i].parser.compute(from[i].value, to[i].value, delta), parser: from[i].parser });
-    });
-    computed.$family = Function.convert('fx:css:value');
-    return computed;
-  },
-
-  // serves the value as settable
-
-  serve(value, unit) {
-    if (typeOf(value) != 'fx:css:value') value = this.parse(value);
-    let returned = [];
-    value.each((bit) => {
-      returned = returned.concat(bit.parser.serve(bit.value, unit));
-    });
-    return returned;
-  },
-
-  // renders the change to an element
-
-  render(element, property, value, unit) {
-    element.setStyle(property, this.serve(value, unit));
-  },
-
-  // searches inside the page css to find the values for a selector
-
-  search(selector) {
-    if (Fx.CSS.Cache[selector]) return Fx.CSS.Cache[selector];
-    const to = {}; const
-      selectorTest = new RegExp(`^${selector.escapeRegExp()}$`);
-
-    var searchStyles = function (rules) {
-      Array.each(rules, (rule) => {
-        if (rule.media) {
-          searchStyles(rule.rules || rule.cssRules);
-          return;
-        }
-        if (!rule.style) return;
-        const selectorText = (rule.selectorText) ? rule.selectorText.replace(/^\w+/, (m) => m.toLowerCase()) : null;
-        if (!selectorText || !selectorTest.test(selectorText)) return;
-        Object.each(Element.Styles, (value, style) => {
-          if (!rule.style[style] || Element.ShortStyles[style]) return;
-          value = String(rule.style[style]);
-          to[style] = ((/^rgb/).test(value)) ? value.rgbToHex() : value;
-        });
-      });
-    };
-
-    Array.each(document.styleSheets, (sheet) => {
-      const { href } = sheet;
-      if (href && href.indexOf('://') > -1 && href.indexOf(document.domain) == -1) return;
-      const rules = sheet.rules || sheet.cssRules;
-      searchStyles(rules);
-    });
-    return Fx.CSS.Cache[selector] = to;
-  },
-
-});
-
-Fx.CSS.Cache = {};
-
-Fx.CSS.Parsers = {
-
-  Color: {
-    parse(value) {
-      if (value.match(/^#[0-9a-f]{3,6}$/i)) return value.hexToRgb(true);
-      return ((value = value.match(/(\d+),\s*(\d+),\s*(\d+)/))) ? [value[1], value[2], value[3]] : false;
-    },
-    compute(from, to, delta) {
-      return from.map((value, i) => Math.round(Fx.compute(from[i], to[i], delta)));
-    },
-    serve(value) {
-      return value.map(Number);
-    },
-  },
-
-  Number: {
-    parse: parseFloat,
-    compute: Fx.compute,
-    serve(value, unit) {
-      return (unit) ? value + unit : value;
-    },
-  },
-
-  String: {
-    parse: Function.convert(false),
-    compute(zero, one) {
-      return one;
-    },
-    serve(zero) {
-      return zero;
-    },
-  },
-
-};
-
-/*
----
-
-name: Fx.Morph
-
-description: Formerly Fx.Styles, effect to transition any number of CSS properties for an element using an object of rules, or CSS based selector rules.
-
-license: MIT-style license.
-
-requires: Fx.CSS
-
-provides: Fx.Morph
-
-...
-*/
-
-Fx.Morph = new Class({
-
-  Extends: Fx.CSS,
-
-  initialize(element, options) {
-    this.element = this.subject = document.id(element);
-    this.parent(options);
-  },
-
-  set(now) {
-    if (typeof now === 'string') now = this.search(now);
-    for (const p in now) this.render(this.element, p, now[p], this.options.unit);
-    return this;
-  },
-
-  compute(from, to, delta) {
-    const now = {};
-    for (const p in from) now[p] = this.parent(from[p], to[p], delta);
-    return now;
-  },
-
-  start(properties) {
-    if (!this.check(properties)) return this;
-    if (typeof properties === 'string') properties = this.search(properties);
-    const from = {}; const
-      to = {};
-    for (const p in properties) {
-      const parsed = this.prepare(this.element, p, properties[p]);
-      from[p] = parsed.from;
-      to[p] = parsed.to;
-    }
-    return this.parent(from, to);
-  },
-
-});
-
-Element.Properties.morph = {
-
-  set(options) {
-    this.get('morph').cancel().setOptions(options);
-    return this;
-  },
-
-  get() {
-    let morph = this.retrieve('morph');
-    if (!morph) {
-      morph = new Fx.Morph(this, { link: 'cancel' });
-      this.store('morph', morph);
-    }
-    return morph;
-  },
-
-};
-
-Element.implement({
-
-  morph(props) {
-    this.get('morph').start(props);
-    return this;
-  },
-
-});
-
-/*
----
-
-name: Fx.Transitions
-
-description: Contains a set of advanced transitions to be used with any of the Fx Classes.
-
-license: MIT-style license.
-
-credits:
-  - Easing Equations by Robert Penner, <http://www.robertpenner.com/easing/>, modified and optimized to be used with MooTools.
-
-requires: Fx
-
-provides: Fx.Transitions
-
-...
-*/
-
-Fx.implement({
-
-  getTransition() {
-    let trans = this.options.transition || Fx.Transitions.Sine.easeInOut;
-    if (typeof trans === 'string') {
-      const data = trans.split(':');
-      trans = Fx.Transitions;
-      trans = trans[data[0]] || trans[data[0].capitalize()];
-      if (data[1]) trans = trans[`ease${data[1].capitalize()}${data[2] ? data[2].capitalize() : ''}`];
-    }
-    return trans;
-  },
-
-});
-
-Fx.Transition = function (transition, params) {
-  params = Array.convert(params);
-  const easeIn = function (pos) {
-    return transition(pos, params);
-  };
-  return Object.append(easeIn, {
-    easeIn,
-    easeOut(pos) {
-      return 1 - transition(1 - pos, params);
-    },
-    easeInOut(pos) {
-      return (pos <= 0.5 ? transition(2 * pos, params) : (2 - transition(2 * (1 - pos), params))) / 2;
-    },
-  });
-};
-
-Fx.Transitions = {
-
-  linear(zero) {
-    return zero;
-  },
-
-};
-
-Fx.Transitions.extend = function (transitions) {
-  for (const transition in transitions) Fx.Transitions[transition] = new Fx.Transition(transitions[transition]);
-};
-
-Fx.Transitions.extend({
-
-  Pow(p, x) {
-    return Math.pow(p, x && x[0] || 6);
-  },
-
-  Expo(p) {
-    return Math.pow(2, 8 * (p - 1));
-  },
-
-  Circ(p) {
-    return 1 - Math.sin(Math.acos(p));
-  },
-
-  Sine(p) {
-    return 1 - Math.cos(p * Math.PI / 2);
-  },
-
-  Back(p, x) {
-    x = x && x[0] || 1.618;
-    return Math.pow(p, 2) * ((x + 1) * p - x);
-  },
-
-  Bounce(p) {
-    let value;
-    for (let a = 0, b = 1; 1; a += b, b /= 2) {
-      if (p >= (7 - 4 * a) / 11) {
-        value = b * b - Math.pow((11 - 6 * a - 11 * p) / 4, 2);
-        break;
-      }
-    }
-    return value;
-  },
-
-  Elastic(p, x) {
-    return Math.pow(2, 10 * --p) * Math.cos(20 * p * Math.PI * (x && x[0] || 1) / 3);
-  },
-
-});
-
-['Quad', 'Cubic', 'Quart', 'Quint'].each((transition, i) => {
-  Fx.Transitions[transition] = new Fx.Transition((p) => Math.pow(p, i + 2));
-});
-
-/*
----
-
-name: Fx.Tween
-
-description: Formerly Fx.Style, effect to transition any CSS property for an element.
-
-license: MIT-style license.
-
-requires: Fx.CSS
-
-provides: [Fx.Tween, Element.fade, Element.highlight]
-
-...
-*/
-
-Fx.Tween = new Class({
-
-  Extends: Fx.CSS,
-
-  initialize(element, options) {
-    this.element = this.subject = document.id(element);
-    this.parent(options);
-  },
-
-  set(property, now) {
-    if (arguments.length == 1) {
-      now = property;
-      property = this.property || this.options.property;
-    }
-    this.render(this.element, property, now, this.options.unit);
-    return this;
-  },
-
-  start(property, from, to) {
-    if (!this.check(property, from, to)) return this;
-    const args = Array.flatten(arguments);
-    this.property = this.options.property || args.shift();
-    const parsed = this.prepare(this.element, this.property, args);
-    return this.parent(parsed.from, parsed.to);
-  },
-
-});
-
-Element.Properties.tween = {
-
-  set(options) {
-    this.get('tween').cancel().setOptions(options);
-    return this;
-  },
-
-  get() {
-    let tween = this.retrieve('tween');
-    if (!tween) {
-      tween = new Fx.Tween(this, { link: 'cancel' });
-      this.store('tween', tween);
-    }
-    return tween;
-  },
-
-};
-
-Element.implement({
-
-  tween(property, from, to) {
-    this.get('tween').start(property, from, to);
-    return this;
-  },
-
-  fade() {
-    const fade = this.get('tween'); let method; const args = ['opacity'].append(arguments); let
-      toggle;
-    if (args[1] == null) args[1] = 'toggle';
-    switch (args[1]) {
-      case 'in': method = 'start'; args[1] = 1; break;
-      case 'out': method = 'start'; args[1] = 0; break;
-      case 'show': method = 'set'; args[1] = 1; break;
-      case 'hide': method = 'set'; args[1] = 0; break;
-      case 'toggle':
-        var flag = this.retrieve('fade:flag', this.getStyle('opacity') == 1);
-        method = 'start';
-        args[1] = flag ? 0 : 1;
-        this.store('fade:flag', !flag);
-        toggle = true;
-        break;
-      default: method = 'start';
-    }
-    if (!toggle) this.eliminate('fade:flag');
-    fade[method].apply(fade, args);
-    const to = args[args.length - 1];
-
-    if (method == 'set') {
-      this.setStyle('visibility', to == 0 ? 'hidden' : 'visible');
-    } else if (to != 0) {
-      if (fade.$chain.length) {
-        fade.chain(function () {
-          this.element.setStyle('visibility', 'visible');
-          this.callChain();
-        });
-      } else {
-        this.setStyle('visibility', 'visible');
-      }
-    } else {
-      fade.chain(function () {
-        if (this.element.getStyle('opacity')) return;
-        this.element.setStyle('visibility', 'hidden');
-        this.callChain();
-      });
-    }
-
-    return this;
-  },
-
-  highlight(start, end) {
-    if (!end) {
-      end = this.retrieve('highlight:original', this.getStyle('background-color'));
-      end = (end == 'transparent') ? '#fff' : end;
-    }
-    const tween = this.get('tween');
-    tween.start('background-color', start || '#ffff88', end).chain(() => {
-      this.setStyle('background-color', this.retrieve('highlight:original'));
-      tween.callChain();
-    });
-    return this;
-  },
-
-});
-
-/*
----
-
-name: Request
-
-description: Powerful all purpose Request Class. Uses XMLHTTPRequest.
-
-license: MIT-style license.
-
-requires: [Object, Element, Chain, Events, Options, Class.Thenable, Browser]
-
-provides: Request
-
-...
-*/
-
-(function () {
-  const empty = function () {};
-  const progressSupport = ('onprogress' in new Browser.Request());
-
-  const Request = this.Request = new Class({
-
-    Implements: [Chain, Events, Options, Class.Thenable],
-
-    options: { /*
-		onRequest: function(){},
-		onLoadstart: function(event, xhr){},
-		onProgress: function(event, xhr){},
-		onComplete: function(){},
-		onCancel: function(){},
-		onSuccess: function(responseText, responseXML){},
-		onFailure: function(xhr){},
-		onException: function(headerName, value){},
-		onTimeout: function(){},
-		user: '',
-		password: '',
-		withCredentials: false, */
-      url: '',
-      data: '',
-      headers: {
-        'X-Requested-With': 'XMLHttpRequest',
-        Accept: 'text/javascript, text/html, application/xml, text/xml, */*',
-      },
-      async: true,
-      format: false,
-      method: 'post',
-      link: 'ignore',
-      isSuccess: null,
-      emulation: true,
-      urlEncoded: true,
-      encoding: 'utf-8',
-      evalScripts: false,
-      evalResponse: false,
-      timeout: 0,
-      noCache: false,
-    },
-
-    initialize(options) {
-      this.xhr = new Browser.Request();
-      this.setOptions(options);
-      this.headers = this.options.headers;
-    },
-
-    onStateChange() {
-      const { xhr } = this;
-      if (xhr.readyState != 4 || !this.running) return;
-      this.running = false;
-      this.status = 0;
-      Function.attempt(() => {
-        const { status } = xhr;
-        this.status = (status == 1223) ? 204 : status;
-      });
-      xhr.onreadystatechange = empty;
-      if (progressSupport) xhr.onprogress = xhr.onloadstart = empty;
-      if (this.timer) {
-        clearTimeout(this.timer);
-        delete this.timer;
-      }
-
-      this.response = { text: this.xhr.responseText || '', xml: this.xhr.responseXML };
-      if (this.options.isSuccess.call(this, this.status)) this.success(this.response.text, this.response.xml);
-      else this.failure();
-    },
-
-    isSuccess() {
-      const { status } = this;
-      return (status >= 200 && status < 300);
-    },
-
-    isRunning() {
-      return !!this.running;
-    },
-
-    processScripts(text) {
-      if (this.options.evalResponse || (/(ecma|java)script/).test(this.getHeader('Content-type'))) return Browser.exec(text);
-      return text.stripScripts(this.options.evalScripts);
-    },
-
-    success(text, xml) {
-      this.onSuccess(this.processScripts(text), xml);
-      this.resolve({ text, xml });
-    },
-
-    onSuccess() {
-      this.fireEvent('complete', arguments).fireEvent('success', arguments).callChain();
-    },
-
-    failure() {
-      this.onFailure();
-      this.reject({ reason: 'failure', xhr: this.xhr });
-    },
-
-    onFailure() {
-      this.fireEvent('complete').fireEvent('failure', this.xhr);
-    },
-
-    loadstart(event) {
-      this.fireEvent('loadstart', [event, this.xhr]);
-    },
-
-    progress(event) {
-      this.fireEvent('progress', [event, this.xhr]);
-    },
-
-    timeout() {
-      this.fireEvent('timeout', this.xhr);
-      this.reject({ reason: 'timeout', xhr: this.xhr });
-    },
-
-    setHeader(name, value) {
-      this.headers[name] = value;
-      return this;
-    },
-
-    getHeader(name) {
-      return Function.attempt(() => this.xhr.getResponseHeader(name));
-    },
-
-    check() {
-      if (!this.running) return true;
-      switch (this.options.link) {
-        case 'cancel': this.cancel(); return true;
-        case 'chain': this.chain(this.caller.pass(arguments, this)); return false;
-      }
-      return false;
-    },
-
-    send(options) {
-      if (!this.check(options)) return this;
-
-      this.options.isSuccess = this.options.isSuccess || this.isSuccess;
-      this.running = true;
-
-      const type = typeOf(options);
-      if (type == 'string' || type == 'element') options = { data: options };
-
-      const old = this.options;
-      options = Object.append({ data: old.data, url: old.url, method: old.method }, options);
-      let { data } = options;
-      let url = String(options.url);
-      let method = options.method.toLowerCase();
-
-      switch (typeOf(data)) {
-        case 'element': data = document.id(data).toQueryString(); break;
-        case 'object': case 'hash': data = Object.toQueryString(data);
-      }
-
-      if (this.options.format) {
-        const format = `format=${this.options.format}`;
-        data = (data) ? `${format}&${data}` : format;
-      }
-
-      if (this.options.emulation && !['get', 'post'].contains(method)) {
-        const _method = `_method=${method}`;
-        data = (data) ? `${_method}&${data}` : _method;
-        method = 'post';
-      }
-
-      if (this.options.urlEncoded && ['post', 'put'].contains(method)) {
-        const encoding = (this.options.encoding) ? `; charset=${this.options.encoding}` : '';
-        this.headers['Content-type'] = `application/x-www-form-urlencoded${encoding}`;
-      }
-
-      if (!url) url = document.location.pathname;
-
-      let trimPosition = url.lastIndexOf('/');
-      if (trimPosition > -1 && (trimPosition = url.indexOf('#')) > -1) url = url.substr(0, trimPosition);
-
-      if (this.options.noCache) url += (url.indexOf('?') > -1 ? '&' : '?') + String.uniqueID();
-
-      if (data && (method == 'get' || method == 'delete')) {
-        url += (url.indexOf('?') > -1 ? '&' : '?') + data;
-        data = null;
-      }
-
-      const { xhr } = this;
-      if (progressSupport) {
-        xhr.onloadstart = this.loadstart.bind(this);
-        xhr.onprogress = this.progress.bind(this);
-      }
-
-      xhr.open(method.toUpperCase(), url, this.options.async, this.options.user, this.options.password);
-      if ((this.options.withCredentials) && 'withCredentials' in xhr) xhr.withCredentials = true;
-
-      xhr.onreadystatechange = this.onStateChange.bind(this);
-
-      Object.each(this.headers, function (value, key) {
-        try {
-          xhr.setRequestHeader(key, value);
-        } catch (e) {
-          this.fireEvent('exception', [key, value]);
-          this.reject({ reason: 'exception', xhr, exception: e });
-        }
-      }, this);
-
-      if (this.getThenableState() !== 'pending') {
-        this.resetThenable({ reason: 'send' });
-      }
-      this.fireEvent('request');
-      xhr.send(data);
-      if (!this.options.async) this.onStateChange();
-      else if (this.options.timeout) this.timer = this.timeout.delay(this.options.timeout, this);
-      return this;
-    },
-
-    cancel() {
-      if (!this.running) return this;
-      this.running = false;
-      const { xhr } = this;
-      xhr.abort();
-      if (this.timer) {
-        clearTimeout(this.timer);
-        delete this.timer;
-      }
-      xhr.onreadystatechange = empty;
-      if (progressSupport) xhr.onprogress = xhr.onloadstart = empty;
-      this.xhr = new Browser.Request();
-      this.fireEvent('cancel');
-      this.reject({ reason: 'cancel', xhr });
-      return this;
-    },
-
-  });
-
-  const methods = {};
-  ['get', 'post', 'put', 'delete', 'patch', 'head', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'].each((method) => {
-    methods[method] = function (data) {
-      const object = {
-        method,
-      };
-      if (data != null) object.data = data;
-      return this.send(object);
-    };
-  });
-
-  Request.implement(methods);
-
-  Element.Properties.send = {
-
-    set(options) {
-      const send = this.get('send').cancel();
-      send.setOptions(options);
-      return this;
-    },
-
-    get() {
-      let send = this.retrieve('send');
-      if (!send) {
-        send = new Request({
-          data: this, link: 'cancel', method: this.get('method') || 'post', url: this.get('action'),
-        });
-        this.store('send', send);
-      }
-      return send;
-    },
-
-  };
-
-  Element.implement({
-
-    send(url) {
-      const sender = this.get('send');
-      sender.send({ data: this, url: url || sender.options.url });
-      return this;
-    },
-
-  });
-}());
-
-/*
----
-
-name: Request.HTML
-
-description: Extends the basic Request Class with additional methods for interacting with HTML responses.
-
-license: MIT-style license.
-
-requires: [Element, Request]
-
-provides: Request.HTML
-
-...
-*/
-
-Request.HTML = new Class({
-
-  Extends: Request,
-
-  options: {
-    update: false,
-    append: false,
-    evalScripts: true,
-    filter: false,
-    headers: {
-      Accept: 'text/html, application/xml, text/xml, */*',
-    },
-  },
-
-  success(text) {
-    const { options } = this;
-    const { response } = this;
-
-    response.html = text.stripScripts((script) => {
-      response.javascript = script;
-    });
-
-    const match = response.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
-    if (match) response.html = match[1];
-    const temp = new Element('div').set('html', response.html);
-
-    response.tree = temp.childNodes;
-    response.elements = temp.getElements(options.filter || '*');
-
-    if (options.filter) response.tree = response.elements;
-    if (options.update) {
-      const update = document.id(options.update).empty();
-      if (options.filter) update.adopt(response.elements);
-      else update.set('html', response.html);
-    } else if (options.append) {
-      const append = document.id(options.append);
-      if (options.filter) response.elements.reverse().inject(append);
-      else append.adopt(temp.getChildren());
-    }
-    if (options.evalScripts) Browser.exec(response.javascript);
-
-    this.onSuccess(response.tree, response.elements, response.html, response.javascript);
-    this.resolve({
-      tree: response.tree, elements: response.elements, html: response.html, javascript: response.javascript,
-    });
-  },
-
-});
-
-Element.Properties.load = {
-
-  set(options) {
-    const load = this.get('load').cancel();
-    load.setOptions(options);
-    return this;
-  },
-
-  get() {
-    let load = this.retrieve('load');
-    if (!load) {
-      load = new Request.HTML({
-        data: this, link: 'cancel', update: this, method: 'get',
-      });
-      this.store('load', load);
-    }
-    return load;
-  },
-
-};
-
-Element.implement({
-
-  load() {
-    this.get('load').send(Array.link(arguments, { data: Type.isObject, url: Type.isString }));
-    return this;
-  },
-
-});
-
-/*
----
-
-name: JSON
-
-description: JSON encoder and decoder.
-
-license: MIT-style license.
-
-SeeAlso: <http://www.json.org/>
-
-requires: [Array, String, Number, Function]
-
-provides: JSON
-
-...
-*/
-
-if (typeof JSON === 'undefined') this.JSON = {};
-
-(function () {
-  const special = {
-    '\b': '\\b', '\t': '\\t', '\n': '\\n', '\f': '\\f', '\r': '\\r', '"': '\\"', '\\': '\\\\',
-  };
-
-  const escape = function (chr) {
-    return special[chr] || `\\u${(`0000${chr.charCodeAt(0).toString(16)}`).slice(-4)}`;
-  };
-
-  JSON.validate = function (string) {
-    string = string.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
-      .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
-      .replace(/(?:^|:|,)(?:\s*\[)+/g, '');
-
-    return (/^[\],:{}\s]*$/).test(string);
-  };
-
-  JSON.encode = JSON.stringify ? function (obj) {
-    return JSON.stringify(obj);
-  } : function (obj) {
-    if (obj && obj.toJSON) obj = obj.toJSON();
-
-    switch (typeOf(obj)) {
-      case 'string':
-        return `"${obj.replace(/[\x00-\x1f\\"]/g, escape)}"`;
-      case 'array':
-        return `[${obj.map(JSON.encode).clean()}]`;
-      case 'object': case 'hash':
-        var string = [];
-        Object.each(obj, (value, key) => {
-          const json = JSON.encode(value);
-          if (json) string.push(`${JSON.encode(key)}:${json}`);
-        });
-        return `{${string}}`;
-      case 'number': case 'boolean': return `${obj}`;
-      case 'null': return 'null';
-    }
-
-    return null;
-  };
-
-  JSON.secure = true;
-
-  JSON.decode = function (string, secure) {
-    if (!string || typeOf(string) != 'string') return null;
-
-    if (secure == null) secure = JSON.secure;
-    if (secure) {
-      if (JSON.parse) return JSON.parse(string);
-      if (!JSON.validate(string)) throw new Error('JSON could not decode the input; security is enabled and the value is not secure.');
-    }
-
-    return eval(`(${string})`);
-  };
-}());
-
-/*
----
-
-name: Request.JSON
-
-description: Extends the basic Request Class with additional methods for sending and receiving JSON data.
-
-license: MIT-style license.
-
-requires: [Request, JSON]
-
-provides: Request.JSON
-
-...
-*/
-
-Request.JSON = new Class({
-
-  Extends: Request,
-
-  options: {
-    /* onError: function(text, error){}, */
-    secure: true,
-  },
-
-  initialize(options) {
-    this.parent(options);
-    Object.append(this.headers, {
-      Accept: 'application/json',
-      'X-Request': 'JSON',
-    });
-  },
-
-  success(text) {
-    let json;
-    try {
-      json = this.response.json = JSON.decode(text, this.options.secure);
-    } catch (error) {
-      this.fireEvent('error', [text, error]);
-      return;
-    }
-    if (json == null) {
-      this.failure();
-    } else {
-      this.onSuccess(json, text);
-      this.resolve({ json, text });
-    }
-  },
-
-});
-
-/*
----
-
-name: Cookie
-
-description: Class for creating, reading, and deleting browser Cookies.
-
-license: MIT-style license.
-
-credits:
-  - Based on the functions by Peter-Paul Koch (http://quirksmode.org).
-
-requires: [Options, Browser]
-
-provides: Cookie
-
-...
-*/
-
-var Cookie = new Class({
-
-  Implements: Options,
-
-  options: {
-    path: '/',
-    domain: false,
-    duration: false,
-    secure: false,
-    document,
-    encode: true,
-    httpOnly: false,
-  },
-
-  initialize(key, options) {
-    this.key = key;
-    this.setOptions(options);
-  },
-
-  write(value) {
-    if (this.options.encode) value = encodeURIComponent(value);
-    if (this.options.domain) value += `; domain=${this.options.domain}`;
-    if (this.options.path) value += `; path=${this.options.path}`;
-    if (this.options.duration) {
-      const date = new Date();
-      date.setTime(date.getTime() + this.options.duration * 24 * 60 * 60 * 1000);
-      value += `; expires=${date.toGMTString()}`;
-    }
-    if (this.options.secure) value += '; secure';
-    if (this.options.httpOnly) value += '; HttpOnly';
-    this.options.document.cookie = `${this.key}=${value}`;
-    return this;
-  },
-
-  read() {
-    const value = this.options.document.cookie.match(`(?:^|;)\\s*${this.key.escapeRegExp()}=([^;]*)`);
-    return (value) ? decodeURIComponent(value[1]) : null;
-  },
-
-  dispose() {
-    new Cookie(this.key, Object.merge({}, this.options, { duration: -1 })).write('');
-    return this;
-  },
-
-});
-
-Cookie.write = function (key, value, options) {
-  return new Cookie(key, options).write(value);
-};
-
-Cookie.read = function (key) {
-  return new Cookie(key).read();
-};
-
-Cookie.dispose = function (key, options) {
-  return new Cookie(key, options).dispose();
-};
-
-/*
----
-
-name: DOMReady
-
-description: Contains the custom event domready.
-
-license: MIT-style license.
-
-requires: [Browser, Element, Element.Event]
-
-provides: [DOMReady, DomReady]
-
-...
-*/
-
-(function (window, document) {
-  let ready;
-  let loaded;
-  const checks = [];
-  let shouldPoll;
-  let timer;
-  let testElement = document.createElement('div');
-
-  var domready = function () {
-    clearTimeout(timer);
-    if (!ready) {
-      Browser.loaded = ready = true;
-      document.removeListener('DOMContentLoaded', domready).removeListener('readystatechange', check);
-      document.fireEvent('domready');
-      window.fireEvent('domready');
-    }
-    // cleanup scope vars
-    document = window = testElement = null;
-  };
-
-  var check = function () {
-    for (let i = checks.length; i--;) {
-      if (checks[i]()) {
-        domready();
-        return true;
-      }
-    }
-    return false;
-  };
-
-  var poll = function () {
-    clearTimeout(timer);
-    if (!check()) timer = setTimeout(poll, 10);
-  };
-
-  document.addListener('DOMContentLoaded', domready);
-
-  /* <ltIE8> */
-  // doScroll technique by Diego Perini http://javascript.nwbox.com/IEContentLoaded/
-  // testElement.doScroll() throws when the DOM is not ready, only in the top window
-  const doScrollWorks = function () {
-    try {
-      testElement.doScroll();
-      return true;
-    } catch (e) {}
-    return false;
-  };
-  // If doScroll works already, it can't be used to determine domready
-  //   e.g. in an iframe
-  if (testElement.doScroll && !doScrollWorks()) {
-    checks.push(doScrollWorks);
-    shouldPoll = true;
-  }
-  /* </ltIE8> */
-
-  if (document.readyState) {
-    checks.push(() => {
-      const state = document.readyState;
-      return (state == 'loaded' || state == 'complete');
-    });
-  }
-
-  if ('onreadystatechange' in document) document.addListener('readystatechange', check);
-  else shouldPoll = true;
-
-  if (shouldPoll) poll();
-
-  Element.Events.domready = {
-    onAdd(fn) {
-      if (ready) fn.call(this);
-    },
-  };
-
-  // Make sure that domready fires before load
-  Element.Events.load = {
-    base: 'load',
-    onAdd(fn) {
-      if (loaded && this == window) fn.call(this);
-    },
-    condition() {
-      if (this == window) {
-        domready();
-        delete Element.Events.load;
-      }
-      return true;
-    },
-  };
-
-  // This is based on the custom load event
-  window.addEvent('load', () => {
-    loaded = true;
-  });
-}(window, document));
diff --git a/packages/mindplot/src/components/libraries/underscorejs/underscore-min.js b/packages/mindplot/src/components/libraries/underscorejs/underscore-min.js
deleted file mode 100644
index 90b5ebfd..00000000
--- a/packages/mindplot/src/components/libraries/underscorejs/underscore-min.js
+++ /dev/null
@@ -1,13 +0,0 @@
-//     Underscore.js 1.6.0
-//     http://underscorejs.org
-//     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-//     Underscore may be freely distributed under the MIT license.
-(function () {
-  const n = this; const t = n._; const r = {}; const e = Array.prototype; const u = Object.prototype; const i = Function.prototype; const a = e.push; const o = e.slice; const c = e.concat; const l = u.toString; const f = u.hasOwnProperty; const s = e.forEach; const p = e.map; const h = e.reduce; const v = e.reduceRight; const g = e.filter; const d = e.every; const m = e.some; const y = e.indexOf; const b = e.lastIndexOf; const x = Array.isArray; const w = Object.keys; const _ = i.bind; var j = function (n) { return n instanceof j ? n : this instanceof j ? void (this._wrapped = n) : new j(n); }; typeof exports !== 'undefined' ? (typeof module !== 'undefined' && module.exports && (exports = module.exports = j), exports._ = j) : n._ = j, j.VERSION = '1.6.0'; const A = j.each = j.forEach = function (n, t, e) { if (n == null) return n; if (s && n.forEach === s)n.forEach(t, e); else if (n.length === +n.length) { for (var u = 0, i = n.length; i > u; u++) if (t.call(e, n[u], u, n) === r) return; } else for (var a = j.keys(n), u = 0, i = a.length; i > u; u++) if (t.call(e, n[a[u]], a[u], n) === r) return; return n; }; j.map = j.collect = function (n, t, r) { const e = []; return n == null ? e : p && n.map === p ? n.map(t, r) : (A(n, (n, u, i) => { e.push(t.call(r, n, u, i)); }), e); }; const O = 'Reduce of empty array with no initial value'; j.reduce = j.foldl = j.inject = function (n, t, r, e) { let u = arguments.length > 2; if (n == null && (n = []), h && n.reduce === h) return e && (t = j.bind(t, e)), u ? n.reduce(t, r) : n.reduce(t); if (A(n, (n, i, a) => { u ? r = t.call(e, r, n, i, a) : (r = n, u = !0); }), !u) throw new TypeError(O); return r; }, j.reduceRight = j.foldr = function (n, t, r, e) { let u = arguments.length > 2; if (n == null && (n = []), v && n.reduceRight === v) return e && (t = j.bind(t, e)), u ? n.reduceRight(t, r) : n.reduceRight(t); let i = n.length; if (i !== +i) { var a = j.keys(n); i = a.length; } if (A(n, (o, c, l) => { c = a ? a[--i] : --i, u ? r = t.call(e, r, n[c], c, l) : (r = n[c], u = !0); }), !u) throw new TypeError(O); return r; }, j.find = j.detect = function (n, t, r) { let e; return k(n, (n, u, i) => (t.call(r, n, u, i) ? (e = n, !0) : void 0)), e; }, j.filter = j.select = function (n, t, r) { const e = []; return n == null ? e : g && n.filter === g ? n.filter(t, r) : (A(n, (n, u, i) => { t.call(r, n, u, i) && e.push(n); }), e); }, j.reject = function (n, t, r) { return j.filter(n, (n, e, u) => !t.call(r, n, e, u), r); }, j.every = j.all = function (n, t, e) { t || (t = j.identity); let u = !0; return n == null ? u : d && n.every === d ? n.every(t, e) : (A(n, (n, i, a) => ((u = u && t.call(e, n, i, a)) ? void 0 : r)), !!u); }; var k = j.some = j.any = function (n, t, e) { t || (t = j.identity); let u = !1; return n == null ? u : m && n.some === m ? n.some(t, e) : (A(n, (n, i, a) => (u || (u = t.call(e, n, i, a)) ? r : void 0)), !!u); }; j.contains = j.include = function (n, t) { return n == null ? !1 : y && n.indexOf === y ? n.indexOf(t) != -1 : k(n, (n) => n === t); }, j.invoke = function (n, t) { const r = o.call(arguments, 2); const e = j.isFunction(t); return j.map(n, (n) => (e ? t : n[t]).apply(n, r)); }, j.pluck = function (n, t) { return j.map(n, j.property(t)); }, j.where = function (n, t) { return j.filter(n, j.matches(t)); }, j.findWhere = function (n, t) { return j.find(n, j.matches(t)); }, j.max = function (n, t, r) { if (!t && j.isArray(n) && n[0] === +n[0] && n.length < 65535) return Math.max.apply(Math, n); let e = -1 / 0; let u = -1 / 0; return A(n, (n, i, a) => { const o = t ? t.call(r, n, i, a) : n; o > u && (e = n, u = o); }), e; }, j.min = function (n, t, r) { if (!t && j.isArray(n) && n[0] === +n[0] && n.length < 65535) return Math.min.apply(Math, n); let e = 1 / 0; let u = 1 / 0; return A(n, (n, i, a) => { const o = t ? t.call(r, n, i, a) : n; u > o && (e = n, u = o); }), e; }, j.shuffle = function (n) { let t; let r = 0; const e = []; return A(n, (n) => { t = j.random(r++), e[r - 1] = e[t], e[t] = n; }), e; }, j.sample = function (n, t, r) { return t == null || r ? (n.length !== +n.length && (n = j.values(n)), n[j.random(n.length - 1)]) : j.shuffle(n).slice(0, Math.max(0, t)); }; const E = function (n) { return n == null ? j.identity : j.isFunction(n) ? n : j.property(n); }; j.sortBy = function (n, t, r) { return t = E(t), j.pluck(j.map(n, (n, e, u) => ({ value: n, index: e, criteria: t.call(r, n, e, u) })).sort((n, t) => { const r = n.criteria; const e = t.criteria; if (r !== e) { if (r > e || r === void 0) return 1; if (e > r || e === void 0) return -1; } return n.index - t.index; }), 'value'); }; const F = function (n) { return function (t, r, e) { const u = {}; return r = E(r), A(t, (i, a) => { const o = r.call(e, i, a, t); n(u, o, i); }), u; }; }; j.groupBy = F((n, t, r) => { j.has(n, t) ? n[t].push(r) : n[t] = [r]; }), j.indexBy = F((n, t, r) => { n[t] = r; }), j.countBy = F((n, t) => { j.has(n, t) ? n[t]++ : n[t] = 1; }), j.sortedIndex = function (n, t, r, e) { r = E(r); for (var u = r.call(e, t), i = 0, a = n.length; a > i;) { const o = i + a >>> 1; r.call(e, n[o]) < u ? i = o + 1 : a = o; } return i; }, j.toArray = function (n) { return n ? j.isArray(n) ? o.call(n) : n.length === +n.length ? j.map(n, j.identity) : j.values(n) : []; }, j.size = function (n) { return n == null ? 0 : n.length === +n.length ? n.length : j.keys(n).length; }, j.first = j.head = j.take = function (n, t, r) { return n == null ? void 0 : t == null || r ? n[0] : t < 0 ? [] : o.call(n, 0, t); }, j.initial = function (n, t, r) { return o.call(n, 0, n.length - (t == null || r ? 1 : t)); }, j.last = function (n, t, r) { return n == null ? void 0 : t == null || r ? n[n.length - 1] : o.call(n, Math.max(n.length - t, 0)); }, j.rest = j.tail = j.drop = function (n, t, r) { return o.call(n, t == null || r ? 1 : t); }, j.compact = function (n) { return j.filter(n, j.identity); }; var M = function (n, t, r) { return t && j.every(n, j.isArray) ? c.apply(r, n) : (A(n, (n) => { j.isArray(n) || j.isArguments(n) ? t ? a.apply(r, n) : M(n, t, r) : r.push(n); }), r); }; j.flatten = function (n, t) { return M(n, t, []); }, j.without = function (n) { return j.difference(n, o.call(arguments, 1)); }, j.partition = function (n, t) { const r = []; const e = []; return A(n, (n) => { (t(n) ? r : e).push(n); }), [r, e]; }, j.uniq = j.unique = function (n, t, r, e) { j.isFunction(t) && (e = r, r = t, t = !1); const u = r ? j.map(n, r, e) : n; const i = []; const a = []; return A(u, (r, e) => { (t ? e && a[a.length - 1] === r : j.contains(a, r)) || (a.push(r), i.push(n[e])); }), i; }, j.union = function () { return j.uniq(j.flatten(arguments, !0)); }, j.intersection = function (n) { const t = o.call(arguments, 1); return j.filter(j.uniq(n), (n) => j.every(t, (t) => j.contains(t, n))); }, j.difference = function (n) { const t = c.apply(e, o.call(arguments, 1)); return j.filter(n, (n) => !j.contains(t, n)); }, j.zip = function () { for (var n = j.max(j.pluck(arguments, 'length').concat(0)), t = new Array(n), r = 0; n > r; r++)t[r] = j.pluck(arguments, `${r}`); return t; }, j.object = function (n, t) { if (n == null) return {}; for (var r = {}, e = 0, u = n.length; u > e; e++)t ? r[n[e]] = t[e] : r[n[e][0]] = n[e][1]; return r; }, j.indexOf = function (n, t, r) { if (n == null) return -1; let e = 0; const u = n.length; if (r) { if (typeof r !== 'number') return e = j.sortedIndex(n, t), n[e] === t ? e : -1; e = r < 0 ? Math.max(0, u + r) : r; } if (y && n.indexOf === y) return n.indexOf(t, r); for (;u > e; e++) if (n[e] === t) return e; return -1; }, j.lastIndexOf = function (n, t, r) { if (n == null) return -1; const e = r != null; if (b && n.lastIndexOf === b) return e ? n.lastIndexOf(t, r) : n.lastIndexOf(t); for (let u = e ? r : n.length; u--;) if (n[u] === t) return u; return -1; }, j.range = function (n, t, r) { arguments.length <= 1 && (t = n || 0, n = 0), r = arguments[2] || 1; for (var e = Math.max(Math.ceil((t - n) / r), 0), u = 0, i = new Array(e); e > u;)i[u++] = n, n += r; return i; }; const R = function () {}; j.bind = function (n, t) { let r; let e; if (_ && n.bind === _) return _.apply(n, o.call(arguments, 1)); if (!j.isFunction(n)) throw new TypeError(); return r = o.call(arguments, 2), e = function () { if (!(this instanceof e)) return n.apply(t, r.concat(o.call(arguments))); R.prototype = n.prototype; const u = new R(); R.prototype = null; const i = n.apply(u, r.concat(o.call(arguments))); return Object(i) === i ? i : u; }; }, j.partial = function (n) { const t = o.call(arguments, 1); return function () { for (var r = 0, e = t.slice(), u = 0, i = e.length; i > u; u++)e[u] === j && (e[u] = arguments[r++]); for (;r < arguments.length;)e.push(arguments[r++]); return n.apply(this, e); }; }, j.bindAll = function (n) { const t = o.call(arguments, 1); if (t.length === 0) throw new Error('bindAll must be passed function names'); return A(t, (t) => { n[t] = j.bind(n[t], n); }), n; }, j.memoize = function (n, t) { const r = {}; return t || (t = j.identity), function () { const e = t.apply(this, arguments); return j.has(r, e) ? r[e] : r[e] = n.apply(this, arguments); }; }, j.delay = function (n, t) { const r = o.call(arguments, 2); return setTimeout(() => n.apply(null, r), t); }, j.defer = function (n) { return j.delay.apply(j, [n, 1].concat(o.call(arguments, 1))); }, j.throttle = function (n, t, r) { let e; let u; let i; let a = null; let o = 0; r || (r = {}); const c = function () { o = r.leading === !1 ? 0 : j.now(), a = null, i = n.apply(e, u), e = u = null; }; return function () { const l = j.now(); o || r.leading !== !1 || (o = l); const f = t - (l - o); return e = this, u = arguments, f <= 0 ? (clearTimeout(a), a = null, o = l, i = n.apply(e, u), e = u = null) : a || r.trailing === !1 || (a = setTimeout(c, f)), i; }; }, j.debounce = function (n, t, r) { let e; let u; let i; let a; let o; var c = function () { const l = j.now() - a; t > l ? e = setTimeout(c, t - l) : (e = null, r || (o = n.apply(i, u), i = u = null)); }; return function () { i = this, u = arguments, a = j.now(); const l = r && !e; return e || (e = setTimeout(c, t)), l && (o = n.apply(i, u), i = u = null), o; }; }, j.once = function (n) { let t; let r = !1; return function () { return r ? t : (r = !0, t = n.apply(this, arguments), n = null, t); }; }, j.wrap = function (n, t) { return j.partial(t, n); }, j.compose = function () { const n = arguments; return function () { for (var t = arguments, r = n.length - 1; r >= 0; r--)t = [n[r].apply(this, t)]; return t[0]; }; }, j.after = function (n, t) { return function () { return --n < 1 ? t.apply(this, arguments) : void 0; }; }, j.keys = function (n) { if (!j.isObject(n)) return []; if (w) return w(n); const t = []; for (const r in n)j.has(n, r) && t.push(r); return t; }, j.values = function (n) { for (var t = j.keys(n), r = t.length, e = new Array(r), u = 0; r > u; u++)e[u] = n[t[u]]; return e; }, j.pairs = function (n) { for (var t = j.keys(n), r = t.length, e = new Array(r), u = 0; r > u; u++)e[u] = [t[u], n[t[u]]]; return e; }, j.invert = function (n) { for (var t = {}, r = j.keys(n), e = 0, u = r.length; u > e; e++)t[n[r[e]]] = r[e]; return t; }, j.functions = j.methods = function (n) { const t = []; for (const r in n)j.isFunction(n[r]) && t.push(r); return t.sort(); }, j.extend = function (n) { return A(o.call(arguments, 1), (t) => { if (t) for (const r in t)n[r] = t[r]; }), n; }, j.pick = function (n) { const t = {}; const r = c.apply(e, o.call(arguments, 1)); return A(r, (r) => { r in n && (t[r] = n[r]); }), t; }, j.omit = function (n) { const t = {}; const r = c.apply(e, o.call(arguments, 1)); for (const u in n)j.contains(r, u) || (t[u] = n[u]); return t; }, j.defaults = function (n) { return A(o.call(arguments, 1), (t) => { if (t) for (const r in t)n[r] === void 0 && (n[r] = t[r]); }), n; }, j.clone = function (n) { return j.isObject(n) ? j.isArray(n) ? n.slice() : j.extend({}, n) : n; }, j.tap = function (n, t) { return t(n), n; }; var S = function (n, t, r, e) { if (n === t) return n !== 0 || 1 / n == 1 / t; if (n == null || t == null) return n === t; n instanceof j && (n = n._wrapped), t instanceof j && (t = t._wrapped); const u = l.call(n); if (u != l.call(t)) return !1; switch (u) { case '[object String]': return n == String(t); case '[object Number]': return n != +n ? t != +t : n == 0 ? 1 / n == 1 / t : n == +t; case '[object Date]': case '[object Boolean]': return +n == +t; case '[object RegExp]': return n.source == t.source && n.global == t.global && n.multiline == t.multiline && n.ignoreCase == t.ignoreCase; } if (typeof n !== 'object' || typeof t !== 'object') return !1; for (let i = r.length; i--;) if (r[i] == n) return e[i] == t; const a = n.constructor; const o = t.constructor; if (a !== o && !(j.isFunction(a) && a instanceof a && j.isFunction(o) && o instanceof o) && 'constructor' in n && 'constructor' in t) return !1; r.push(n), e.push(t); let c = 0; let f = !0; if (u == '[object Array]') { if (c = n.length, f = c == t.length) for (;c-- && (f = S(n[c], t[c], r, e));); } else { for (var s in n) if (j.has(n, s) && (c++, !(f = j.has(t, s) && S(n[s], t[s], r, e)))) break; if (f) { for (s in t) if (j.has(t, s) && !c--) break; f = !c; } } return r.pop(), e.pop(), f; }; j.isEqual = function (n, t) { return S(n, t, [], []); }, j.isEmpty = function (n) { if (n == null) return !0; if (j.isArray(n) || j.isString(n)) return n.length === 0; for (const t in n) if (j.has(n, t)) return !1; return !0; }, j.isElement = function (n) { return !(!n || n.nodeType !== 1); }, j.isArray = x || function (n) { return l.call(n) == '[object Array]'; }, j.isObject = function (n) { return n === Object(n); }, A(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], (n) => { j[`is${n}`] = function (t) { return l.call(t) == `[object ${n}]`; }; }), j.isArguments(arguments) || (j.isArguments = function (n) { return !(!n || !j.has(n, 'callee')); }), typeof /./ !== 'function' && (j.isFunction = function (n) { return typeof n === 'function'; }), j.isFinite = function (n) { return isFinite(n) && !isNaN(parseFloat(n)); }, j.isNaN = function (n) { return j.isNumber(n) && n != +n; }, j.isBoolean = function (n) { return n === !0 || n === !1 || l.call(n) == '[object Boolean]'; }, j.isNull = function (n) { return n === null; }, j.isUndefined = function (n) { return n === void 0; }, j.has = function (n, t) { return f.call(n, t); }, j.noConflict = function () { return n._ = t, this; }, j.identity = function (n) { return n; }, j.constant = function (n) { return function () { return n; }; }, j.property = function (n) { return function (t) { return t[n]; }; }, j.matches = function (n) { return function (t) { if (t === n) return !0; for (const r in n) if (n[r] !== t[r]) return !1; return !0; }; }, j.times = function (n, t, r) { for (var e = Array(Math.max(0, n)), u = 0; n > u; u++)e[u] = t.call(r, u); return e; }, j.random = function (n, t) { return t == null && (t = n, n = 0), n + Math.floor(Math.random() * (t - n + 1)); }, j.now = Date.now || function () { return (new Date()).getTime(); }; const T = {
-    escape: {
-      '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#x27;',
-    },
-  }; T.unescape = j.invert(T.escape); const I = { escape: new RegExp(`[${j.keys(T.escape).join('')}]`, 'g'), unescape: new RegExp(`(${j.keys(T.unescape).join('|')})`, 'g') }; j.each(['escape', 'unescape'], (n) => { j[n] = function (t) { return t == null ? '' : (`${t}`).replace(I[n], (t) => T[n][t]); }; }), j.result = function (n, t) { if (n == null) return void 0; const r = n[t]; return j.isFunction(r) ? r.call(n) : r; }, j.mixin = function (n) { A(j.functions(n), (t) => { const r = j[t] = n[t]; j.prototype[t] = function () { const n = [this._wrapped]; return a.apply(n, arguments), z.call(this, r.apply(j, n)); }; }); }; let N = 0; j.uniqueId = function (n) { const t = `${++N}`; return n ? n + t : t; }, j.templateSettings = { evaluate: /<%([\s\S]+?)%>/g, interpolate: /<%=([\s\S]+?)%>/g, escape: /<%-([\s\S]+?)%>/g }; const q = /(.)^/; const B = {
-    "'": "'", '\\': '\\', '\r': 'r', '\n': 'n', '	': 't', '\u2028': 'u2028', '\u2029': 'u2029',
-  }; const D = /\\|'|\r|\n|\t|\u2028|\u2029/g; j.template = function (n, t, r) { let e; r = j.defaults({}, r, j.templateSettings); const u = new RegExp(`${[(r.escape || q).source, (r.interpolate || q).source, (r.evaluate || q).source].join('|')}|$`, 'g'); let i = 0; let a = "__p+='"; n.replace(u, (t, r, e, u, o) => (a += n.slice(i, o).replace(D, (n) => `\\${B[n]}`), r && (a += `'+\n((__t=(${r}))==null?'':_.escape(__t))+\n'`), e && (a += `'+\n((__t=(${e}))==null?'':__t)+\n'`), u && (a += `';\n${u}\n__p+='`), i = o + t.length, t)), a += "';\n", r.variable || (a = `with(obj||{}){\n${a}}\n`), a = `${"var __t,__p='',__j=Array.prototype.join," + "print=function(){__p+=__j.call(arguments,'');};\n"}${a}return __p;\n`; try { e = new Function(r.variable || 'obj', '_', a); } catch (o) { throw o.source = a, o; } if (t) return e(t, j); const c = function (n) { return e.call(this, n, j); }; return c.source = `function(${r.variable || 'obj'}){\n${a}}`, c; }, j.chain = function (n) { return j(n).chain(); }; var z = function (n) { return this._chain ? j(n).chain() : n; }; j.mixin(j), A(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], (n) => { const t = e[n]; j.prototype[n] = function () { const r = this._wrapped; return t.apply(r, arguments), n != 'shift' && n != 'splice' || r.length !== 0 || delete r[0], z.call(this, r); }; }), A(['concat', 'join', 'slice'], (n) => { const t = e[n]; j.prototype[n] = function () { return z.call(this, t.apply(this._wrapped, arguments)); }; }), j.extend(j.prototype, { chain() { return this._chain = !0, this; }, value() { return this._wrapped; } }), typeof define === 'function' && define.amd && define('underscore', [], () => j);
-}).call(this);
diff --git a/packages/mindplot/src/components/model/INodeModel.js b/packages/mindplot/src/components/model/INodeModel.js
index 0002a4dc..6d5cad0a 100644
--- a/packages/mindplot/src/components/model/INodeModel.js
+++ b/packages/mindplot/src/components/model/INodeModel.js
@@ -363,7 +363,7 @@ class INodeModel {
 
   /** @abstract */
   removeChild(child) {
-    throw 'Unsupported operation';
+    throw new Error('Unsupported operation');
   }
 }
 
diff --git a/packages/mindplot/src/components/model/LinkModel.js b/packages/mindplot/src/components/model/LinkModel.js
index 9e698fae..84364e4d 100644
--- a/packages/mindplot/src/components/model/LinkModel.js
+++ b/packages/mindplot/src/components/model/LinkModel.js
@@ -43,7 +43,7 @@ class LinkModel extends FeatureModel {
   }
 
   // url format is already checked in LinkEditor.checkUrl
-  _fixUrl(url) {
+  static _fixUrl(url) {
     let result = url;
     if (!result.contains('http://') && !result.contains('https://') && !result.contains('mailto://')) {
       result = `http://${result}`;
diff --git a/packages/mindplot/src/components/model/Mindmap.js b/packages/mindplot/src/components/model/Mindmap.js
index 5967e758..d65dce28 100644
--- a/packages/mindplot/src/components/model/Mindmap.js
+++ b/packages/mindplot/src/components/model/Mindmap.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import IMindmap from './IMindmap';
 import INodeModel from './INodeModel';
 import NodeModel from './NodeModel';
@@ -71,10 +72,10 @@ class Mindmap extends IMindmap {
     $assert(nodeModel && nodeModel.isNodeModel(), 'Add node must be invoked with model objects');
     const branches = this.getBranches();
     if (branches.length === 0) {
-      $assert(nodeModel.getType() == INodeModel.CENTRAL_TOPIC_TYPE, 'First element must be the central topic');
+      $assert(nodeModel.getType() === INodeModel.CENTRAL_TOPIC_TYPE, 'First element must be the central topic');
       nodeModel.setPosition(0, 0);
     } else {
-      $assert(nodeModel.getType() != INodeModel.CENTRAL_TOPIC_TYPE, 'Mindmaps only have one cental topic');
+      $assert(nodeModel.getType() !== INodeModel.CENTRAL_TOPIC_TYPE, 'Mindmaps only have one cental topic');
     }
 
     this._branches.push(nodeModel);
diff --git a/packages/mindplot/src/components/model/NodeModel.js b/packages/mindplot/src/components/model/NodeModel.js
index afb9ead9..f34e10af 100644
--- a/packages/mindplot/src/components/model/NodeModel.js
+++ b/packages/mindplot/src/components/model/NodeModel.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import { $assert, $defined } from '@wisemapping/core-js';
 import INodeModel from './INodeModel';
 import TopicFeature from '../TopicFeature';
 
@@ -63,7 +64,7 @@ class NodeModel extends INodeModel {
   removeFeature(feature) {
     $assert(feature, 'feature can not be null');
     const size = this._feature.length;
-    this._feature = this._feature.filter((f) => feature.getId() != f.getId());
+    this._feature = this._feature.filter((f) => feature.getId() !== f.getId());
     $assert(size - 1 === this._feature.length, 'Could not be removed ...');
   }
 
@@ -190,7 +191,7 @@ class NodeModel extends INodeModel {
 
   _isChildNode(node) {
     let result = false;
-    if (node == this) {
+    if (node === this) {
       result = true;
     } else {
       const children = this.getChildren();
@@ -211,7 +212,7 @@ class NodeModel extends INodeModel {
      */
   findNodeById(id) {
     let result = null;
-    if (this.getId() == id) {
+    if (this.getId() === id) {
       result = this;
     } else {
       const children = this.getChildren();
diff --git a/packages/mindplot/src/components/model/index.js b/packages/mindplot/src/components/model/index.js
deleted file mode 100644
index 76dca648..00000000
--- a/packages/mindplot/src/components/model/index.js
+++ /dev/null
@@ -1,21 +0,0 @@
-import featureModel from './FeatureModel';
-import iconModel from './IconModel';
-import iMindmap from './IMindmap';
-import iNodeModel from './INodeModel';
-import linkModel from './LinkModel';
-import noteModel from './NoteModel';
-import mindmap from './Mindmap';
-import nodeModel from './NodeModel';
-import relationshipModel from './RelationshipModel';
-
-export default {
-  FeatureModel: featureModel,
-  IconModel: iconModel,
-  IMindmap: iMindmap,
-  INodeModel: iNodeModel,
-  LinkModel: linkModel,
-  NoteModel: noteModel,
-  Mindmap: mindmap,
-  NodeModel: nodeModel,
-  RelationshipModel: relationshipModel,
-};
diff --git a/packages/mindplot/src/components/widget/ColorPalettePanel.js b/packages/mindplot/src/components/widget/ColorPalettePanel.js
index 63d647a8..3138137e 100644
--- a/packages/mindplot/src/components/widget/ColorPalettePanel.js
+++ b/packages/mindplot/src/components/widget/ColorPalettePanel.js
@@ -15,17 +15,17 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
+import _ from '@libraries/underscore-min';
 import { $assert, $defined } from '@wisemapping/core-js';
 import ToolbarPaneItem from './ToolbarPaneItem';
 
-const ColorPalettePanel = new Class({
-  Extends: ToolbarPaneItem,
-
-  initialize(buttonId, model, baseUrl) {
+class ColorPalettePanel extends ToolbarPaneItem {
+  constructor(buttonId, model, baseUrl) {
+    super(buttonId, model);
     this._baseUrl = baseUrl;
-    this.parent(buttonId, model);
     $assert($defined(baseUrl), 'baseUrl can not be null');
-  },
+  }
 
   _load() {
     if (!ColorPalettePanel._panelContent) {
@@ -52,7 +52,7 @@ const ColorPalettePanel = new Class({
       ColorPalettePanel._panelContent = result;
     }
     return ColorPalettePanel._panelContent;
-  },
+  }
 
   buildPanel() {
     const content = $('<div class="toolbarPanel"></div>').attr(
@@ -74,7 +74,7 @@ const ColorPalettePanel = new Class({
     });
 
     return content;
-  },
+  }
 
   _updateSelectedItem() {
     const panelElem = this.getPanelElem();
@@ -99,7 +99,7 @@ const ColorPalettePanel = new Class({
       }
     });
     return panelElem;
-  },
-});
+  }
+}
 
 export default ColorPalettePanel;
diff --git a/packages/mindplot/src/components/widget/FloatingTip.js b/packages/mindplot/src/components/widget/FloatingTip.js
index af6ed756..08a09490 100644
--- a/packages/mindplot/src/components/widget/FloatingTip.js
+++ b/packages/mindplot/src/components/widget/FloatingTip.js
@@ -15,32 +15,29 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-import Options from '../Options';
 import Events from '../Events';
 
-const FloatingTip = new Class({
-  Implements: [Options, Events],
+// const options = {
+//   animation: true,
+//   html: false,
+//   placement: 'right',
+//   selector: false,
+//   trigger: 'hover',
+//   title: '',
+//   content: '',
+//   delay: 0,
+//   container: false,
+//   destroyOnExit: false,
+// };
 
-  options: {
-    animation: true,
-    html: false,
-    placement: 'right',
-    selector: false,
-    trigger: 'hover',
-    title: '',
-    content: '',
-    delay: 0,
-    container: false,
-    destroyOnExit: false,
-  },
-
-  initialize(element, options) {
+class FloatingTip extends Events {
+  constructor(element, options) {
+    super(element, options);
     this.setOptions(options);
     this.element = element;
     this._createPopover();
-  },
+  }
 
-  // FIXME: find a better way to do that...
   _createPopover() {
     this.element.popover(this.options);
     const me = this;
@@ -50,19 +47,30 @@ const FloatingTip = new Class({
         me._createPopover();
       });
     }
-  },
+  }
 
   show() {
     this.element.popover('show');
     this.fireEvent('show');
     return this;
-  },
+  }
 
   hide() {
     this.element.popover('hide');
     this.fireEvent('hide');
     return this;
-  },
-});
+  }
 
+  setOptions() {
+    const options = this.options = Object.merge.apply(null, [{}, this.options].append(arguments));
+    if (this.addEvent) {
+      for (const option in options) {
+        if (typeOf(options[option]) != 'function' || !(/^on[A-Z]/).test(option)) continue;
+        this.addEvent(option, options[option]);
+        delete options[option];
+      }
+    }
+    return this;
+  }
+}
 export default FloatingTip;
diff --git a/packages/mindplot/src/components/widget/FontFamilyPanel.js b/packages/mindplot/src/components/widget/FontFamilyPanel.js
index 4696dafc..f38aa59f 100644
--- a/packages/mindplot/src/components/widget/FontFamilyPanel.js
+++ b/packages/mindplot/src/components/widget/FontFamilyPanel.js
@@ -15,24 +15,21 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
 import ListToolbarPanel from './ListToolbarPanel';
 
-const FontFamilyPanel = new Class({
-  Extends: ListToolbarPanel,
-  initialize(buttonId, model) {
-    this.parent(buttonId, model);
-  },
-
+class FontFamilyPanel extends ListToolbarPanel {
+  // eslint-disable-next-line class-methods-use-this
   buildPanel() {
     const content = $("<div class='toolbarPanel' id='fontFamilyPanel'></div>");
     content.html(
       '<div id="times" model="Times" class="toolbarPanelLink" style="font-family:times;">Times</div>'
-            + '<div id="arial"  model="Arial" style="font-family:arial;">Arial</div>'
-            + '<div id="tahoma" model="Tahoma" style="font-family:tahoma;">Tahoma</div>'
-            + '<div id="verdana" model="Verdana" style="font-family:verdana;">Verdana</div>',
+      + '<div id="arial"  model="Arial" style="font-family:arial;">Arial</div>'
+      + '<div id="tahoma" model="Tahoma" style="font-family:tahoma;">Tahoma</div>'
+      + '<div id="verdana" model="Verdana" style="font-family:verdana;">Verdana</div>',
     );
     return content;
-  },
-});
+  }
+}
 
 export default FontFamilyPanel;
diff --git a/packages/mindplot/src/components/widget/FontSizePanel.js b/packages/mindplot/src/components/widget/FontSizePanel.js
index 1ee6dd02..9415437c 100644
--- a/packages/mindplot/src/components/widget/FontSizePanel.js
+++ b/packages/mindplot/src/components/widget/FontSizePanel.js
@@ -16,23 +16,20 @@
  *   limitations under the License.
  */
 import ListToolbarPanel from './ListToolbarPanel';
+import $ from '@libraries/jquery-2.1.0';
 
-const FontSizePanel = new Class({
-  Extends: ListToolbarPanel,
-  initialize(buttonId, model) {
-    this.parent(buttonId, model);
-  },
-
+class FontSizePanel extends ListToolbarPanel {
+  // eslint-disable-next-line class-methods-use-this
   buildPanel() {
     const content = $("<div class='toolbarPanel' id='fontSizePanel'></div>");
     content[0].innerHTML = ''
-            + '<div id="small" model="6" style="font-size:8px">Small</div>'
-            + '<div id="normal" model="8" style="font-size:12px">Normal</div>'
-            + '<div id="large" model="10" style="font-size:15px">Large</div>'
-            + '<div id="huge"  model="15" style="font-size:24px">Huge</div>';
+      + '<div id="small" model="6" style="font-size:8px">Small</div>'
+      + '<div id="normal" model="8" style="font-size:12px">Normal</div>'
+      + '<div id="large" model="10" style="font-size:15px">Large</div>'
+      + '<div id="huge"  model="15" style="font-size:24px">Huge</div>';
 
     return content;
-  },
-});
+  }
+}
 
 export default FontSizePanel;
diff --git a/packages/mindplot/src/components/widget/IconPanel.js b/packages/mindplot/src/components/widget/IconPanel.js
index 0586a723..6e72f5c0 100644
--- a/packages/mindplot/src/components/widget/IconPanel.js
+++ b/packages/mindplot/src/components/widget/IconPanel.js
@@ -15,18 +15,14 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
 import ToolbarPaneItem from './ToolbarPaneItem';
 import ImageIcon from '../ImageIcon';
 
-const IconPanel = new Class({
-  Extends: ToolbarPaneItem,
-  initialize(buttonId, model) {
-    this.parent(buttonId, model);
-  },
-
+class IconPanel extends ToolbarPaneItem {
   _updateSelectedItem() {
     return this.getPanelElem();
-  },
+  }
 
   buildPanel() {
     const content = $('<div class="toolbarPanel" id="IconsPanel"></div>').css({ width: 245, height: 230 });
@@ -44,7 +40,7 @@ const IconPanel = new Class({
           familyContent = $('<div></div>');
           content.append(familyContent);
         }
-
+ 
         const iconId = familyIcons[j];
         const img = $('<img>')
           .attr('id', iconId)
@@ -53,8 +49,8 @@ const IconPanel = new Class({
 
         familyContent.append(img);
 
-        var panel = this;
-        var model = this.getModel();
+        const panel = this;
+        const model = this.getModel();
         img.on('click', function (event) {
           model.setValue($(this).attr('id'));
           panel.hide();
@@ -64,7 +60,7 @@ const IconPanel = new Class({
       }
     }
     return content;
-  },
-});
+  }
+}
 
 export default IconPanel;
diff --git a/packages/mindplot/src/components/widget/KeyboardShortcutTooltip.js b/packages/mindplot/src/components/widget/KeyboardShortcutTooltip.js
index df55697e..84f79520 100644
--- a/packages/mindplot/src/components/widget/KeyboardShortcutTooltip.js
+++ b/packages/mindplot/src/components/widget/KeyboardShortcutTooltip.js
@@ -15,16 +15,14 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
 import { $assert } from '@wisemapping/core-js';
 import FloatingTip from './FloatingTip';
 
-const KeyboardShortcutTooltip = new Class({
-  Extends: FloatingTip,
-
-  initialize(buttonElem, text) {
+class KeyboardShortcutTooltip extends FloatingTip {
+  constructor(buttonElem, text) {
     $assert(buttonElem, 'buttonElem can not be null');
     $assert(text, 'text can not be null');
-    this._text = text;
 
     const children = buttonElem.children().first();
     const tipElemId = `${buttonElem.attr('id')}Tip`;
@@ -32,21 +30,21 @@ const KeyboardShortcutTooltip = new Class({
     tipDiv.append(children);
     buttonElem.append(tipDiv);
 
-    this.parent(tipDiv, {
+    super(tipDiv, {
       // Content can also be a function of the target element!
-      content: this._buildContent(),
+      content: KeyboardShortcutTooltip._buildContent(),
       html: true,
       placement: 'bottom',
       className: 'keyboardShortcutTip',
       template: '<div class="popover popoverBlack" role="tooltip"><div class="arrow arrowBlack"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>',
     });
-
+    this._text = text;
     tipDiv.on('click', (e) => {
       tipDiv.trigger('mouseleave', e);
     });
-  },
+  }
 
-  _buildContent() {
+  static _buildContent() {
     const result = $('<div></div>');
     result.css({
       padding: '3px 0px',
@@ -64,7 +62,7 @@ const KeyboardShortcutTooltip = new Class({
 
     result.append(textContainer);
     return result;
-  },
-});
+  }
+}
 
 export default KeyboardShortcutTooltip;
diff --git a/packages/mindplot/src/components/widget/LinkIconTooltip.js b/packages/mindplot/src/components/widget/LinkIconTooltip.js
index f8314da7..0f2efe1c 100644
--- a/packages/mindplot/src/components/widget/LinkIconTooltip.js
+++ b/packages/mindplot/src/components/widget/LinkIconTooltip.js
@@ -17,15 +17,13 @@
  */
 import FloatingTip from './FloatingTip';
 
-const LinkIconTooltip = new Class({
-  Extends: FloatingTip,
-
-  initialize(linkIcon) {
+class LinkIconTooltip extends FloatingTip {
+  constructor(linkIcon) {
     $assert(linkIcon, 'linkIcon can not be null');
     const nativeElement = $(linkIcon.getImage().peer._native);
-    this.parent(nativeElement, {
+    super(nativeElement, {
       // Content can also be a function of the target element!
-      content: this._buildContent(linkIcon),
+      content: LinkIconTooltip._buildContent(linkIcon),
       html: true,
       placement: 'bottom',
       container: 'body',
@@ -33,9 +31,9 @@ const LinkIconTooltip = new Class({
       trigger: 'manual',
       template: '<div id="linkPopover" class="popover" onmouseover="$(this).mouseleave(function() {$(this).fadeOut(200); });" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>',
     });
-  },
+  }
 
-  _buildContent(linkIcon) {
+  static _buildContent(linkIcon) {
     const result = $('<div></div>').css({
       padding: '5px',
       width: '100%',
@@ -73,7 +71,7 @@ const LinkIconTooltip = new Class({
     imgContainer.append(link);
     result.append(imgContainer);
     return result;
-  },
-});
+  }
+}
 
 export default LinkIconTooltip;
diff --git a/packages/mindplot/src/components/widget/ListToolbarPanel.js b/packages/mindplot/src/components/widget/ListToolbarPanel.js
index 31714d72..803575dc 100644
--- a/packages/mindplot/src/components/widget/ListToolbarPanel.js
+++ b/packages/mindplot/src/components/widget/ListToolbarPanel.js
@@ -17,12 +17,11 @@
  */
 import ToolbarPaneItem from './ToolbarPaneItem';
 
-const ListToolbarPanel = new Class({
-  Extends: ToolbarPaneItem,
-  initialize(buttonId, model) {
-    this.parent(buttonId, model);
+class ListToolbarPanel extends ToolbarPaneItem {
+  constructor(buttonId, model) {
+    super(buttonId, model);
     this._initPanel();
-  },
+  }
 
   _initPanel() {
     // Register on toolbar elements ...
@@ -33,7 +32,7 @@ const ListToolbarPanel = new Class({
       const value = $defined($(this).attr('model')) ? $(this).attr('model') : $(this).attr('id');
       me.getModel().setValue(value);
     });
-  },
+  }
 
   _updateSelectedItem() {
     const panelElem = this.getPanelElem();
@@ -42,11 +41,11 @@ const ListToolbarPanel = new Class({
     _.each(menuElems, (elem) => {
       const elemValue = $defined($(elem).attr('model')) ? $(elem).attr('model') : $(elem).attr('id');
       $assert(elemValue, 'elemValue can not be null');
-      if (elemValue == value) $(elem).attr('class', 'toolbarPanelLinkSelectedLink');
+      if (elemValue === value) $(elem).attr('class', 'toolbarPanelLinkSelectedLink');
       else $(elem).attr('class', 'toolbarPanelLink');
     });
     return panelElem;
-  },
-});
+  }
+}
 
 export default ListToolbarPanel;
diff --git a/packages/mindplot/src/components/widget/Menu.js b/packages/mindplot/src/components/widget/Menu.js
index 3df5523d..587da226 100644
--- a/packages/mindplot/src/components/widget/Menu.js
+++ b/packages/mindplot/src/components/widget/Menu.js
@@ -15,6 +15,9 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
+import _ from '@libraries/underscore-min';
+
 import { $defined } from '@wisemapping/core-js';
 import BootstrapDialog from '../libraries/bootstrap/BootstrapDialog';
 import IMenu from './IMenu';
@@ -26,11 +29,10 @@ import ColorPalettePanel from './ColorPalettePanel';
 import ToolbarItem from './ToolbarItem';
 import KeyboardShortcutTooltip from './KeyboardShortcutTooltip';
 
-const Menu = new Class({
-  Extends: IMenu,
-
-  initialize(designer, containerId, mapId, readOnly, baseUrl) {
-    this.parent(designer, containerId, mapId);
+class Menu extends IMenu {
+  constructor(designer, containerId, mapId, readOnly, baseUrl) {
+    super(designer, containerId, mapId);
+    const saveElem = $('#save');
 
     baseUrl = !$defined(baseUrl) ? '' : baseUrl;
     const widgetsBaseUrl = `${baseUrl}css/widget`;
@@ -57,7 +59,7 @@ const Menu = new Class({
           let result = null;
           for (let i = 0; i < nodes.length; i++) {
             const fontFamily = nodes[i].getFontFamily();
-            if (result != null && result != fontFamily) {
+            if (result != null && result !== fontFamily) {
               result = null;
               break;
             }
@@ -71,7 +73,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new FontFamilyPanel('fontFamily', fontFamilyModel));
-      this._registerTooltip('fontFamily', $msg('FONT_FAMILY'));
+      Menu._registerTooltip('fontFamily', $msg('FONT_FAMILY'));
     }
 
     const fontSizeBtn = $('#fontSize');
@@ -82,7 +84,7 @@ const Menu = new Class({
           let result = null;
           for (let i = 0; i < nodes.length; i++) {
             const fontSize = nodes[i].getFontSize();
-            if (result != null && result != fontSize) {
+            if (result != null && result !== fontSize) {
               result = null;
               break;
             }
@@ -95,7 +97,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new FontSizePanel('fontSize', fontSizeModel));
-      this._registerTooltip('fontSize', $msg('FONT_SIZE'));
+      Menu._registerTooltip('fontSize', $msg('FONT_SIZE'));
     }
 
     const topicShapeBtn = $('#topicShape');
@@ -106,7 +108,7 @@ const Menu = new Class({
           let result = null;
           for (let i = 0; i < nodes.length; i++) {
             const shapeType = nodes[i].getShapeType();
-            if (result != null && result != shapeType) {
+            if (result != null && result !== shapeType) {
               result = null;
               break;
             }
@@ -119,7 +121,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new TopicShapePanel('topicShape', topicShapeModel));
-      this._registerTooltip('topicShape', $msg('TOPIC_SHAPE'));
+      Menu._registerTooltip('topicShape', $msg('TOPIC_SHAPE'));
     }
 
     const topicIconBtn = $('#topicIcon');
@@ -134,7 +136,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new IconPanel('topicIcon', topicIconModel));
-      this._registerTooltip('topicIcon', $msg('TOPIC_ICON'));
+      Menu._registerTooltip('topicIcon', $msg('TOPIC_ICON'));
     }
 
     // Topic color item ...
@@ -146,7 +148,7 @@ const Menu = new Class({
           let result = null;
           for (let i = 0; i < nodes.length; i++) {
             const color = nodes[i].getBackgroundColor();
-            if (result != null && result != color) {
+            if (result != null && result !== color) {
               result = null;
               break;
             }
@@ -159,7 +161,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new ColorPalettePanel('topicColor', topicColorModel, widgetsBaseUrl));
-      this._registerTooltip('topicColor', $msg('TOPIC_COLOR'));
+      Menu._registerTooltip('topicColor', $msg('TOPIC_COLOR'));
     }
 
     // Border color item ...
@@ -171,7 +173,7 @@ const Menu = new Class({
           let result = null;
           for (let i = 0; i < nodes.length; i++) {
             const color = nodes[i].getBorderColor();
-            if (result != null && result != color) {
+            if (result != null && result !== color) {
               result = null;
               break;
             }
@@ -184,7 +186,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new ColorPalettePanel('topicBorder', borderColorModel, widgetsBaseUrl));
-      this._registerTooltip('topicBorder', $msg('TOPIC_BORDER_COLOR'));
+      Menu._registerTooltip('topicBorder', $msg('TOPIC_BORDER_COLOR'));
     }
 
     // Font color item ...
@@ -196,7 +198,7 @@ const Menu = new Class({
           const nodes = designerModel.filterSelectedTopics();
           for (let i = 0; i < nodes.length; i++) {
             const color = nodes[i].getFontColor();
-            if (result != null && result != color) {
+            if (result != null && result !== color) {
               result = null;
               break;
             }
@@ -209,7 +211,7 @@ const Menu = new Class({
         },
       };
       this._toolbarElems.push(new ColorPalettePanel('fontColor', fontColorModel, baseUrl));
-      this._registerTooltip('fontColor', $msg('FONT_COLOR'));
+      Menu._registerTooltip('fontColor', $msg('FONT_COLOR'));
     }
 
     this._addButton('export', false, false, () => {
@@ -218,7 +220,7 @@ const Menu = new Class({
         closeButton: true,
       });
     });
-    this._registerTooltip('export', $msg('EXPORT'));
+    Menu._registerTooltip('export', $msg('EXPORT'));
 
     const me = this;
 
@@ -228,17 +230,17 @@ const Menu = new Class({
       window.open(`${baseUrl}c/maps/${mapId}/print`);
     });
 
-    this._registerTooltip('print', $msg('PRINT'));
+    Menu._registerTooltip('print', $msg('PRINT'));
 
     this._addButton('zoomIn', false, false, () => {
       designer.zoomIn();
     });
-    this._registerTooltip('zoomIn', $msg('ZOOM_IN'));
+    Menu._registerTooltip('zoomIn', $msg('ZOOM_IN'));
 
     this._addButton('zoomOut', false, false, () => {
       designer.zoomOut();
     });
-    this._registerTooltip('zoomOut', $msg('ZOOM_OUT'));
+    Menu._registerTooltip('zoomOut', $msg('ZOOM_OUT'));
 
     const undoButton = this._addButton('undoEdition', false, false, () => {
       designer.undo();
@@ -246,7 +248,7 @@ const Menu = new Class({
     if (undoButton) {
       undoButton.disable();
     }
-    this._registerTooltip('undoEdition', $msg('UNDO'), 'meta+Z');
+    Menu._registerTooltip('undoEdition', $msg('UNDO'), 'meta+Z');
 
     const redoButton = this._addButton('redoEdition', false, false, () => {
       designer.redo();
@@ -254,7 +256,7 @@ const Menu = new Class({
     if (redoButton) {
       redoButton.disable();
     }
-    this._registerTooltip('redoEdition', $msg('REDO'), 'meta+shift+Z');
+    Menu._registerTooltip('redoEdition', $msg('REDO'), 'meta+shift+Z');
 
     if (redoButton && undoButton) {
       designer.addEvent('modelUpdate', (event) => {
@@ -274,45 +276,44 @@ const Menu = new Class({
     this._addButton('addTopic', true, false, () => {
       designer.createSiblingForSelectedNode();
     });
-    this._registerTooltip('addTopic', $msg('ADD_TOPIC'), 'Enter');
+    Menu._registerTooltip('addTopic', $msg('ADD_TOPIC'), 'Enter');
 
     this._addButton('deleteTopic', true, true, () => {
       designer.deleteSelectedEntities();
     });
-    this._registerTooltip('deleteTopic', $msg('TOPIC_DELETE'), 'Delete');
+    Menu._registerTooltip('deleteTopic', $msg('TOPIC_DELETE'), 'Delete');
 
     this._addButton('topicLink', true, false, () => {
       designer.addLink();
     });
-    this._registerTooltip('topicLink', $msg('TOPIC_LINK'));
+    Menu._registerTooltip('topicLink', $msg('TOPIC_LINK'));
 
     this._addButton('topicRelation', true, false, (event) => {
       designer.showRelPivot(event);
     });
-    this._registerTooltip('topicRelation', $msg('TOPIC_RELATIONSHIP'));
+    Menu._registerTooltip('topicRelation', $msg('TOPIC_RELATIONSHIP'));
 
     this._addButton('topicNote', true, false, () => {
       designer.addNote();
     });
-    this._registerTooltip('topicNote', $msg('TOPIC_NOTE'));
+    Menu._registerTooltip('topicNote', $msg('TOPIC_NOTE'));
 
     this._addButton('fontBold', true, false, () => {
       designer.changeFontWeight();
     });
-    this._registerTooltip('fontBold', $msg('FONT_BOLD'), 'meta+B');
+    Menu._registerTooltip('fontBold', $msg('FONT_BOLD'), 'meta+B');
 
     this._addButton('fontItalic', true, false, () => {
       designer.changeFontStyle();
     });
-    this._registerTooltip('fontItalic', $msg('FONT_ITALIC'), 'meta+I');
+    Menu._registerTooltip('fontItalic', $msg('FONT_ITALIC'), 'meta+I');
 
-    var saveElem = $('#save');
     if (saveElem) {
       this._addButton('save', false, false,
         () => {
           me.save(saveElem, designer, true);
         });
-      this._registerTooltip('save', $msg('SAVE'), 'meta+S');
+      Menu._registerTooltip('save', $msg('SAVE'), 'meta+S');
 
       if (!readOnly) {
         // To prevent the user from leaving the page with changes ...
@@ -340,7 +341,7 @@ const Menu = new Class({
       this._addButton('discard', false, false, () => {
         me.discardChanges(designer);
       });
-      this._registerTooltip('discard', $msg('DISCARD_CHANGES'));
+      Menu._registerTooltip('discard', $msg('DISCARD_CHANGES'));
     }
 
     const shareElem = $('#shareIt');
@@ -352,7 +353,7 @@ const Menu = new Class({
         });
         designer.onObjectFocusEvent();
       });
-      this._registerTooltip('shareIt', $msg('COLLABORATE'));
+      Menu._registerTooltip('shareIt', $msg('COLLABORATE'));
     }
 
     const publishElem = $('#publishIt');
@@ -364,7 +365,7 @@ const Menu = new Class({
         });
         designer.onObjectFocusEvent();
       });
-      this._registerTooltip('publishIt', $msg('PUBLISH'));
+      Menu._registerTooltip('publishIt', $msg('PUBLISH'));
     }
 
     const historyElem = $('#history');
@@ -376,7 +377,7 @@ const Menu = new Class({
         });
         designer.onObjectFocusEvent();
       });
-      this._registerTooltip('history', $msg('HISTORY'));
+      Menu._registerTooltip('history', $msg('HISTORY'));
     }
 
     this._registerEvents(designer);
@@ -406,7 +407,7 @@ const Menu = new Class({
         event.preventDefault();
       });
     }
-  },
+  }
 
   _registerEvents(designer) {
     const me = this;
@@ -454,7 +455,7 @@ const Menu = new Class({
         }
       });
     });
-  },
+  }
 
   _addButton(buttonId, topic, rel, fn) {
     const me = this;
@@ -470,18 +471,18 @@ const Menu = new Class({
       result = button;
     }
     return result;
-  },
+  }
 
-  _registerTooltip(buttonId, text, shortcut) {
+  static _registerTooltip(buttonId, text, shortcut) {
     if ($(`#${buttonId}`)) {
       let tooltip = text;
       if (shortcut) {
-        shortcut = navigator.appVersion.indexOf('Mac') != -1 ? shortcut.replace('meta+', '⌘') : shortcut.replace('meta+', 'ctrl+');
+        shortcut = navigator.appVersion.indexOf('Mac') !== -1 ? shortcut.replace('meta+', '⌘') : shortcut.replace('meta+', 'ctrl+');
         tooltip = `${tooltip} (${shortcut})`;
       }
       new KeyboardShortcutTooltip($(`#${buttonId}`), tooltip);
     }
-  },
-});
+  }
+}
 
 export default Menu;
diff --git a/packages/mindplot/src/components/widget/NoteEditor.js b/packages/mindplot/src/components/widget/NoteEditor.js
index f9230591..3376ed52 100644
--- a/packages/mindplot/src/components/widget/NoteEditor.js
+++ b/packages/mindplot/src/components/widget/NoteEditor.js
@@ -15,6 +15,7 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import jQuery from '@libraries/jquery-2.1.0';
 import BootstrapDialog from '../libraries/bootstrap/BootstrapDialog';
 
 const NoteEditor = new Class({
diff --git a/packages/mindplot/src/components/widget/ToolbarItem.js b/packages/mindplot/src/components/widget/ToolbarItem.js
index 68b25a0b..e019532b 100644
--- a/packages/mindplot/src/components/widget/ToolbarItem.js
+++ b/packages/mindplot/src/components/widget/ToolbarItem.js
@@ -15,42 +15,49 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
 import { $assert } from '@wisemapping/core-js';
 import Events from '../Events';
 
-const ToolbarItem = new Class({
-  Implements: Events, // FIXME: should be extends?
-  initialize(buttonId, fn, options) {
+class ToolbarItem extends Events {
+  constructor(buttonId, fn, options) {
     $assert(buttonId, 'buttonId can not be null');
-    $assert(fn, 'fn can not be null');
+    super();
     this._buttonId = buttonId;
-    this._fn = fn;
     this._options = options;
+    if (fn) {
+      this.setEventHandler(fn);
+    }
+  }
+
+  setEventHandler(fn) {
+    $assert(fn, 'fn can not be null');
+    this._fn = fn;
     this._enable = false;
     this.enable();
-  },
+  }
 
-  getButtonElem: function () {
+  getButtonElem() {
     const elem = $(`#${this._buttonId}`);
     $assert(elem, `Could not find element for ${this._buttonId}`);
     return elem;
-  }.protect(),
+  }
 
   show() {
     this.fireEvent('show');
-  },
+  }
 
   hide() {
     this.fireEvent('hide');
-  },
+  }
 
   isTopicAction() {
     return this._options.topicAction;
-  },
+  }
 
   isRelAction() {
     return this._options.relAction;
-  },
+  }
 
   disable() {
     const elem = this.getButtonElem();
@@ -60,7 +67,7 @@ const ToolbarItem = new Class({
       elem.addClass('buttonOff');
       this._enable = false;
     }
-  },
+  }
 
   enable() {
     const elem = this.getButtonElem();
@@ -70,11 +77,11 @@ const ToolbarItem = new Class({
       elem.addClass('buttonOn');
       this._enable = true;
     }
-  },
+  }
 
-  getTip: function () {
+  getTip() {
     return this._tip;
-  }.protect(),
-});
+  }
+}
 
 export default ToolbarItem;
diff --git a/packages/mindplot/src/components/widget/ToolbarPaneItem.js b/packages/mindplot/src/components/widget/ToolbarPaneItem.js
index 02d2c56d..c11f0879 100644
--- a/packages/mindplot/src/components/widget/ToolbarPaneItem.js
+++ b/packages/mindplot/src/components/widget/ToolbarPaneItem.js
@@ -19,21 +19,18 @@ import { $assert } from '@wisemapping/core-js';
 import ToolbarItem from './ToolbarItem';
 import FloatingTip from './FloatingTip';
 
-const ToolbarPaneItem = new Class({
-  Extends: ToolbarItem,
-  initialize(buttonId, model) {
+class ToolbarPaneItem extends ToolbarItem {
+  constructor(buttonId, model) {
     $assert(buttonId, 'buttonId can not be null');
     $assert(model, 'model can not be null');
+    super(buttonId, null, { topicAction: true, relAction: false });
+
+    const handler = () => (this.isVisible() ? this.hide() : this.show());
+    this.setEventHandler(handler);
     this._model = model;
-    const me = this;
-    const fn = () => {
-      return me.isVisible() ? me.hide() : me.show();
-    };
-    
-    this.parent(buttonId, fn, { topicAction: true, relAction: false });
     this._panelElem = this._init();
     this._visible = false;
-  },
+  }
 
   _init() {
     // Load the context of the panel ...
@@ -51,7 +48,7 @@ const ToolbarPaneItem = new Class({
       className: 'toolbarPaneTip',
       trigger: 'manual',
       template:
-                '<div class="popover popoverGray" role="tooltip"><div class="arrow arrowGray"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>',
+        '<div class="popover popoverGray" role="tooltip"><div class="arrow arrowGray"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>',
     });
 
     this._tip.addEvent('hide', () => {
@@ -63,15 +60,15 @@ const ToolbarPaneItem = new Class({
     });
 
     return panelElem;
-  },
+  }
 
   getModel() {
     return this._model;
-  },
+  }
 
-  getPanelElem: function () {
+  getPanelElem() {
     return this._panelElem;
-  }.protect(),
+  }
 
   show() {
     if (!this.isVisible()) {
@@ -79,7 +76,7 @@ const ToolbarPaneItem = new Class({
       this._tip.show();
       this.getButtonElem().className = 'buttonExtActive';
     }
-  },
+  }
 
   hide() {
     if (this.isVisible()) {
@@ -87,11 +84,11 @@ const ToolbarPaneItem = new Class({
       this._tip.hide();
       this.getButtonElem().className = 'buttonExtOn';
     }
-  },
+  }
 
   isVisible() {
     return this._visible;
-  },
+  }
 
   disable() {
     this.hide();
@@ -106,7 +103,7 @@ const ToolbarPaneItem = new Class({
       elem.addClass('buttonExtOff');
       this._enable = false;
     }
-  },
+  }
 
   enable() {
     const elem = this.getButtonElem();
@@ -116,11 +113,12 @@ const ToolbarPaneItem = new Class({
       elem.addClass('buttonExtOn');
       this._enable = true;
     }
-  },
+  }
 
-  buildPanel: function () {
+  // eslint-disable-next-line class-methods-use-this
+  buildPanel() {
     throw new Error('Method must be implemented');
-  }.protect(),
-});
+  }
+}
 
 export default ToolbarPaneItem;
diff --git a/packages/mindplot/src/components/widget/TopicShapePanel.js b/packages/mindplot/src/components/widget/TopicShapePanel.js
index a706fbd2..bbced409 100644
--- a/packages/mindplot/src/components/widget/TopicShapePanel.js
+++ b/packages/mindplot/src/components/widget/TopicShapePanel.js
@@ -15,24 +15,21 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+import $ from '@libraries/jquery-2.1.0';
 import ListToolbarPanel from './ListToolbarPanel';
 
-const TopicShapePanel = new Class({
-  Extends: ListToolbarPanel,
-  initialize(buttonId, model) {
-    this.parent(buttonId, model);
-  },
-
+class TopicShapePanel extends ListToolbarPanel {
+  // eslint-disable-next-line class-methods-use-this
   buildPanel() {
     const content = $("<div class='toolbarPanel' id='topicShapePanel'></div>");
     content[0].innerHTML = ''
-            + '<div id="rectagle" model="rectagle"><img src="images/shape-rectangle.png" alt="Rectangle"></div>'
-            + '<div id="rounded_rectagle" model="rounded rectagle" ><img src="images/shape-rectangle-round.png" alt="Rounded Rectangle"></div>'
-            + '<div id="line" model="line"><img src="images/shape-line.png" alt="Line"></div>'
-            + '<div id="elipse" model="elipse"><img src="images/shape-circle.png"></div>';
+      + '<div id="rectagle" model="rectagle"><img src="images/shape-rectangle.png" alt="Rectangle"></div>'
+      + '<div id="rounded_rectagle" model="rounded rectagle" ><img src="images/shape-rectangle-round.png" alt="Rounded Rectangle"></div>'
+      + '<div id="line" model="line"><img src="images/shape-line.png" alt="Line"></div>'
+      + '<div id="elipse" model="elipse"><img src="images/shape-circle.png"></div>';
 
     return content;
-  },
-});
+  }
+}
 
 export default TopicShapePanel;
diff --git a/packages/mindplot/src/components/widget/index.js b/packages/mindplot/src/components/widget/index.js
deleted file mode 100644
index f498c470..00000000
--- a/packages/mindplot/src/components/widget/index.js
+++ /dev/null
@@ -1,37 +0,0 @@
-import colorPalettePanel from './ColorPalettePanel';
-import floatingTip from './FloatingTip';
-import fontFamilyPanel from './FontFamilyPanel';
-import fontSizePanel from './FontSizePanel';
-import iconPanel from './IconPanel';
-import iMenu from './IMenu';
-import keyboardShortcutTooltip from './KeyboardShortcutTooltip';
-import linkEditor from './LinkEditor';
-import linkIconTooltip from './LinkIconTooltip';
-import listToolbarPanel from './ListToolbarPanel';
-import menu from './Menu';
-import modalDialogNotifier from './ModalDialogNotifier';
-import noteEditor from './NoteEditor';
-import toolbarItem from './ToolbarItem';
-import toolbarNotifier from './ToolbarNotifier';
-import toolbarPanelItem from './ToolbarPaneItem';
-import topicShapePanel from './TopicShapePanel';
-
-export default {
-  ColorPalettePanel: colorPalettePanel,
-  FloatingTip: floatingTip,
-  FontFamilyPanel: fontFamilyPanel,
-  FontSizePanel: fontSizePanel,
-  IconPanel: iconPanel,
-  IMenu: iMenu,
-  KeyboardShortcutTooltip: keyboardShortcutTooltip,
-  LinkEditor: linkEditor,
-  LinkIconTooltip: linkIconTooltip,
-  ListToolbarPanel: listToolbarPanel,
-  Menu: menu,
-  ModalDialogNotifier: modalDialogNotifier,
-  NoteEditor: noteEditor,
-  ToolbarItem: toolbarItem,
-  ToolbarNotifier: toolbarNotifier,
-  ToolbarPaneItem: toolbarPanelItem,
-  TopicShapePanel: topicShapePanel,
-};
diff --git a/packages/mindplot/src/index.js b/packages/mindplot/src/index.js
new file mode 100644
index 00000000..5d2618b4
--- /dev/null
+++ b/packages/mindplot/src/index.js
@@ -0,0 +1,13 @@
+/* eslint-disable no-unused-vars */
+import '@libraries/mootools-core-1.4.5';
+import _ from '@libraries/underscore-min';
+
+import Mindmap from './components/model/Mindmap';
+import PersistenceManager from './components/PersistenceManager';
+import Designer from './components/Designer';
+import LocalStorageManager from './components/LocalStorageManager';
+import Menu from './components/widget/Menu';
+
+export {
+  Mindmap, PersistenceManager, Designer, LocalStorageManager, Menu,
+};
diff --git a/packages/mindplot/src/mindplot.js b/packages/mindplot/src/mindplot.js
deleted file mode 100644
index b4756339..00000000
--- a/packages/mindplot/src/mindplot.js
+++ /dev/null
@@ -1,6 +0,0 @@
-/* eslint-disable no-unused-vars */
-import '@libraries/mootools-core-1.4.5';
-import _ from '@libraries/underscore-min';
-
-import Mindmap from './components/model/Mindmap';
-import PersistenceManager from './components/PersistenceManager';
diff --git a/packages/mindplot/test/playground/layout/BalancedTestSuite.js b/packages/mindplot/test/playground/layout/BalancedTestSuite.js
index 1f50a718..a5fff029 100644
--- a/packages/mindplot/test/playground/layout/BalancedTestSuite.js
+++ b/packages/mindplot/test/playground/layout/BalancedTestSuite.js
@@ -16,7 +16,7 @@
  *   limitations under the License.
  */
 import TestSuite from './TestSuite';
-import mindplot from '../../../src/mindplot';
+import LayoutManager from '../../../src/components/layout/LayoutManager';
 
 const BalancedTestSuite = new Class({
   Extends: TestSuite,
@@ -33,7 +33,7 @@ const BalancedTestSuite = new Class({
     console.log('testBalanced:');
     const position = { x: 0, y: 0 };
     const plotsize = { width: 1000, height: 200 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.connectNode(0, 1, 0);
@@ -181,7 +181,7 @@ const BalancedTestSuite = new Class({
   testBalancedPredict() {
     console.log('testBalancedPredict:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -215,7 +215,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1a);
     $assert(
       prediction1a.position.y < manager.find(1).getPosition().y
-                && prediction1a.position.x == manager.find(1).getPosition().x,
+      && prediction1a.position.x == manager.find(1).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1a.order == 0, 'Prediction order should be 0');
@@ -225,8 +225,8 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1b);
     $assert(
       prediction1b.position.y > manager.find(1).getPosition().y
-                && prediction1b.position.y < manager.find(3).getPosition().y
-                && prediction1b.position.x == manager.find(1).getPosition().x,
+      && prediction1b.position.y < manager.find(3).getPosition().y
+      && prediction1b.position.x == manager.find(1).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1b.order == 2, 'Prediction order should be 2');
@@ -236,8 +236,8 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1c);
     $assert(
       prediction1c.position.y > manager.find(3).getPosition().y
-                && prediction1c.position.y < manager.find(5).getPosition().y
-                && prediction1c.position.x == manager.find(3).getPosition().x,
+      && prediction1c.position.y < manager.find(5).getPosition().y
+      && prediction1c.position.x == manager.find(3).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1c.order == 4, 'Prediction order should be 4');
@@ -247,7 +247,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1d);
     $assert(
       prediction1d.position.y > manager.find(5).getPosition().y
-                && prediction1d.position.x == manager.find(5).getPosition().x,
+      && prediction1d.position.x == manager.find(5).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1d.order == 6, 'Prediction order should be 6');
@@ -260,7 +260,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2a);
     $assert(
       prediction2a.position.y < manager.find(2).getPosition().y
-                && prediction2a.position.x == manager.find(2).getPosition().x,
+      && prediction2a.position.x == manager.find(2).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2a.order == 1, 'Prediction order should be 1');
@@ -270,8 +270,8 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2b);
     $assert(
       prediction2b.position.y > manager.find(2).getPosition().y
-                && prediction2b.position.y < manager.find(4).getPosition().y
-                && prediction2b.position.x == manager.find(2).getPosition().x,
+      && prediction2b.position.y < manager.find(4).getPosition().y
+      && prediction2b.position.x == manager.find(2).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2b.order == 3, 'Prediction order should be 3');
@@ -281,7 +281,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2c);
     $assert(
       prediction2c.position.y > manager.find(4).getPosition().y
-                && prediction2c.position.x == manager.find(4).getPosition().x,
+      && prediction2c.position.x == manager.find(4).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2c.order == 5, 'Prediction order should be 5');
@@ -293,7 +293,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph3, prediction3);
     $assert(
       prediction3.position.y > manager.find(4).getPosition().y
-                && prediction3.position.x == manager.find(4).getPosition().x,
+      && prediction3.position.x == manager.find(4).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction3.order == 5, 'Prediction order should be 5');
@@ -307,7 +307,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph4, prediction4);
     $assert(
       prediction4.position.y > manager.find(5).getPosition().y
-                && prediction4.position.x == manager.find(5).getPosition().x,
+      && prediction4.position.x == manager.find(5).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction4.order == 6, 'Prediction order should be 6');
@@ -323,13 +323,13 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph5, prediction5b);
     $assert(
       prediction5a.position.x > manager.find(0).getPosition().x
-                && prediction5a.position.y == manager.find(0).getPosition().y,
+      && prediction5a.position.y == manager.find(0).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction5a.order == 0, 'Prediction order should be 0');
     $assert(
       prediction5a.position.x == prediction5b.position.x
-                && prediction5a.position.y == prediction5b.position.y,
+      && prediction5a.position.y == prediction5b.position.y,
       'Both predictions should be the same',
     );
     $assert(prediction5a.order == prediction5b.order, 'Both predictions should be the same');
@@ -340,7 +340,7 @@ const BalancedTestSuite = new Class({
   testBalancedNodeDragPredict() {
     console.log('testBalancedNodeDragPredict:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Graph 1
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
@@ -351,7 +351,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1a);
     $assert(
       prediction1a.position.x == manager.find(1).getPosition().x
-                && prediction1a.position.y == manager.find(1).getPosition().y,
+      && prediction1a.position.y == manager.find(1).getPosition().y,
       'Prediction position should be the same as node 1',
     );
     $assert(
@@ -363,7 +363,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1b);
     $assert(
       prediction1b.position.x == manager.find(1).getPosition().x
-                && prediction1b.position.y == manager.find(1).getPosition().y,
+      && prediction1b.position.y == manager.find(1).getPosition().y,
       'Prediction position should be the same as node 1',
     );
     $assert(
@@ -375,7 +375,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1c);
     $assert(
       prediction1c.position.x < manager.find(0).getPosition().x
-                && prediction1c.position.y == manager.find(0).getPosition().y,
+      && prediction1c.position.y == manager.find(0).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1c.order == 1, 'Prediction order should be the same as node 1');
@@ -384,7 +384,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph1, prediction1d);
     $assert(
       prediction1d.position.x < manager.find(0).getPosition().x
-                && prediction1d.position.y == manager.find(0).getPosition().y,
+      && prediction1d.position.y == manager.find(0).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1d.order == 1, 'Prediction order should be the same as node 1');
@@ -399,7 +399,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2a);
     $assert(
       prediction2a.position.x > manager.find(0).getPosition().x
-                && prediction2a.position.y == manager.find(0).getPosition().y,
+      && prediction2a.position.y == manager.find(0).getPosition().y,
       'Prediction is positioned incorrectly',
     );
     $assert(prediction2a.order == 0, 'Prediction order should be 0');
@@ -408,7 +408,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2b);
     $assert(
       prediction2b.position.x > manager.find(0).getPosition().x
-                && prediction2b.position.y == manager.find(0).getPosition().y,
+      && prediction2b.position.y == manager.find(0).getPosition().y,
       'Prediction is positioned incorrectly',
     );
     $assert(prediction2b.order == 0, 'Prediction order should be 0');
@@ -417,7 +417,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2c);
     $assert(
       prediction2c.position.x == manager.find(1).getPosition().x
-                && prediction2c.position.y == manager.find(1).getPosition().y,
+      && prediction2c.position.y == manager.find(1).getPosition().y,
       'Prediction position should be the same as node 1',
     );
     $assert(
@@ -429,7 +429,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph2, prediction2d);
     $assert(
       prediction2d.position.x == manager.find(1).getPosition().x
-                && prediction2d.position.y == manager.find(1).getPosition().y,
+      && prediction2d.position.y == manager.find(1).getPosition().y,
       'Prediction position should be the same as node 1',
     );
     $assert(
@@ -448,7 +448,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph3, prediction3a);
     $assert(
       prediction3a.position.x == manager.find(2).getPosition().x
-                && prediction3a.position.y > manager.find(2).getPosition().y,
+      && prediction3a.position.y > manager.find(2).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction3a.order == 4, 'Prediction order should be 4');
@@ -457,8 +457,8 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph3, prediction3b);
     $assert(
       prediction3b.position.x == manager.find(1).getPosition().x
-                && prediction3b.position.y == manager.find(1).getPosition().y
-                && prediction3b.order == manager.find(1).getOrder(),
+      && prediction3b.position.y == manager.find(1).getPosition().y
+      && prediction3b.order == manager.find(1).getOrder(),
       'Prediction should be the exact same as dragged node',
     );
 
@@ -466,7 +466,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph3, prediction3c);
     $assert(
       prediction3c.position.x < manager.find(0).getPosition().x
-                && prediction3c.position.y == manager.find(0).getPosition().y,
+      && prediction3c.position.y == manager.find(0).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction3c.order == 1, 'Prediction order should be 1');
@@ -475,7 +475,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph3, prediction3d);
     $assert(
       prediction3d.position.x < manager.find(0).getPosition().x
-                && prediction3d.position.y == manager.find(0).getPosition().y,
+      && prediction3d.position.y == manager.find(0).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction3d.order == 1, 'Prediction order should be 1');
@@ -484,7 +484,7 @@ const BalancedTestSuite = new Class({
     this._plotPrediction(graph3, prediction3e);
     $assert(
       prediction3e.position.x == manager.find(1).getPosition().x
-                && prediction3e.position.y == manager.find(1).getPosition().y,
+      && prediction3e.position.y == manager.find(1).getPosition().y,
       'Prediction position should be the same as node 1',
     );
     $assert(
diff --git a/packages/mindplot/test/playground/layout/FreeTestSuite.js b/packages/mindplot/test/playground/layout/FreeTestSuite.js
index 78403d9e..eafc5835 100644
--- a/packages/mindplot/test/playground/layout/FreeTestSuite.js
+++ b/packages/mindplot/test/playground/layout/FreeTestSuite.js
@@ -16,7 +16,7 @@
  *   limitations under the License.
  */
 import TestSuite from './TestSuite';
-import mindplot from '../../../src/mindplot';
+import LayoutManager from '../../../src/components/layout/LayoutManager';
 
 const FreeTestSuite = new Class({
   Extends: TestSuite,
@@ -37,7 +37,7 @@ const FreeTestSuite = new Class({
   testFreePosition() {
     console.log('testFreePosition:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position);
@@ -104,7 +104,7 @@ const FreeTestSuite = new Class({
     this._assertFreePosition(manager, 11, { x: 250, y: -50 });
     $assert(
       manager.find(13).getPosition().x == node13Pos.x
-                && manager.find(13).getPosition().y == node13Pos.y,
+      && manager.find(13).getPosition().y == node13Pos.y,
       "Node 13 shouldn't have moved",
     );
 
@@ -147,7 +147,7 @@ const FreeTestSuite = new Class({
   testFreePredict() {
     console.log('testFreePredict:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position);
@@ -217,7 +217,7 @@ const FreeTestSuite = new Class({
   testReconnectFreeNode() {
     console.log('testReconnectFreeNode:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position);
@@ -260,7 +260,7 @@ const FreeTestSuite = new Class({
     manager.plot('testReconnectFreeNode3', { width: 1000, height: 400 });
     $assert(
       manager.find(5).getPosition().y > manager.find(10).getPosition().y
-                && manager.find(5).getPosition().x == manager.find(10).getPosition().x,
+      && manager.find(5).getPosition().x == manager.find(10).getPosition().x,
       'Node 5 is incorrectly positioned',
     );
     $assert(manager.find(5).getOrder() == 2, 'Node 5 should have order 2');
@@ -278,7 +278,7 @@ const FreeTestSuite = new Class({
     manager.plot('testReconnectFreeNode5', { width: 1000, height: 400 });
     $assert(
       manager.find(5).getPosition().y == manager.find(10).getPosition().y
-                && manager.find(5).getPosition().x < manager.find(10).getPosition().x,
+      && manager.find(5).getPosition().x < manager.find(10).getPosition().x,
       'Node 5 is incorrectly positioned',
     );
     $assert(manager.find(5).getOrder() == 0, 'Node 5 should have order 0');
@@ -290,7 +290,7 @@ const FreeTestSuite = new Class({
     manager.plot('testReconnectFreeNode6', { width: 1000, height: 400 });
     $assert(
       manager.find(5).getPosition().y > manager.find(6).getPosition().y
-                && manager.find(5).getPosition().x == manager.find(6).getPosition().x,
+      && manager.find(5).getPosition().x == manager.find(6).getPosition().x,
       'Node 5 is incorrectly positioned',
     );
     $assert(manager.find(5).getOrder() == 2, 'Node 5 should have order 2');
@@ -307,7 +307,7 @@ const FreeTestSuite = new Class({
   testSiblingOverlapping() {
     console.log('testSiblingOverlapping:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
@@ -340,7 +340,7 @@ const FreeTestSuite = new Class({
   testRootNodeChildrenPositioning() {
     console.log('testRootNodeChildrenPositioning:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
@@ -383,7 +383,7 @@ const FreeTestSuite = new Class({
   testBalancedFreePredict() {
     console.log('testBalancedFreePredict:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
@@ -403,7 +403,7 @@ const FreeTestSuite = new Class({
   testFreeReorder() {
     console.log('testFreeReorder:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
@@ -440,7 +440,7 @@ const FreeTestSuite = new Class({
   testFreeOverlap() {
     console.log('testFreeOverlap:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
@@ -481,18 +481,13 @@ const FreeTestSuite = new Class({
       const node = manager.find(id);
       $assert(
         node.getPosition().x == position.x && node.getPosition().y == position.y,
-        `Freely moved node ${
-          id
-        } is not left at free position (${
-          position.x
-        },${
-          position.y
+        `Freely moved node ${id
+        } is not left at free position (${position.x
+        },${position.y
         }). `
-                    + `Actual position: (${
-                      node.getPosition().x
-                    },${
-                      node.getPosition().y
-                    })`,
+        + `Actual position: (${node.getPosition().x
+        },${node.getPosition().y
+        })`,
       );
     }
 
diff --git a/packages/mindplot/test/playground/layout/SymmetricTestSuite.js b/packages/mindplot/test/playground/layout/SymmetricTestSuite.js
index f71414f4..c602c12b 100644
--- a/packages/mindplot/test/playground/layout/SymmetricTestSuite.js
+++ b/packages/mindplot/test/playground/layout/SymmetricTestSuite.js
@@ -16,7 +16,7 @@
  *   limitations under the License.
  */
 import TestSuite from './TestSuite';
-import mindplot from '../../../src/mindplot';
+import LayoutManager from '../../../src/components/layout/LayoutManager';
 
 const SymmetricTestSuite = new Class({
   Extends: TestSuite,
@@ -32,7 +32,7 @@ const SymmetricTestSuite = new Class({
   testSymmetry() {
     console.log('testSymmetry:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -68,26 +68,26 @@ const SymmetricTestSuite = new Class({
 
     // All nodes should be positioned symmetrically with respect to their common ancestors
     $assert(
-      manager.find(14).getPosition().y == manager.find(13).getPosition().y,
+      manager.find(14).getPosition().y === manager.find(13).getPosition().y,
       'Symmetry is not respected',
     );
     $assert(
-      manager.find(5).getPosition().y == manager.find(10).getPosition().y,
+      manager.find(5).getPosition().y === manager.find(10).getPosition().y,
       'Symmetry is not respected',
     );
     $assert(
       manager.find(11).getPosition().y - manager.find(6).getPosition().y
-                == -(manager.find(12).getPosition().y - manager.find(6).getPosition().y),
+      === -(manager.find(12).getPosition().y - manager.find(6).getPosition().y),
       'Symmetry is not respected',
     );
     $assert(
       manager.find(8).getPosition().y - manager.find(1).getPosition().y
-                == -(manager.find(11).getPosition().y - manager.find(1).getPosition().y),
+      == -(manager.find(11).getPosition().y - manager.find(1).getPosition().y),
       'Symmetry is not respected',
     );
     $assert(
       manager.find(9).getPosition().y - manager.find(1).getPosition().y
-                == -(manager.find(11).getPosition().y - manager.find(1).getPosition().y),
+      == -(manager.find(11).getPosition().y - manager.find(1).getPosition().y),
       'Symmetry is not respected',
     );
 
@@ -97,7 +97,7 @@ const SymmetricTestSuite = new Class({
   testSymmetricPredict() {
     console.log('testSymmetricPredict:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position);
@@ -134,7 +134,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1a);
     $assert(
       prediction1a.position.x < manager.find(9).getPosition().x
-                && prediction1a.position.y == manager.find(9).getPosition().y,
+      && prediction1a.position.y == manager.find(9).getPosition().y,
       'Prediction incorrectly positioned',
     );
     $assert(prediction1a.order == 0, 'Prediction order should be 0');
@@ -144,7 +144,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1b);
     $assert(
       prediction1b.position.x > manager.find(1).getPosition().x
-                && prediction1b.position.y == manager.find(1).getPosition().y,
+      && prediction1b.position.y == manager.find(1).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1b.order == 0, 'Prediction order should be 0');
@@ -159,7 +159,7 @@ const SymmetricTestSuite = new Class({
     // Prediction calculator error
     $assert(
       prediction2d.position.y < manager.find(7).getPosition().y
-                && prediction2d.position.x == manager.find(7).getPosition().x,
+      && prediction2d.position.x == manager.find(7).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2d.order == 0, 'Prediction order should be 0');
@@ -170,8 +170,8 @@ const SymmetricTestSuite = new Class({
 
     $assert(
       prediction2a.position.y > manager.find(7).getPosition().y
-                && prediction2a.position.y < manager.find(8).getPosition().y
-                && prediction2a.position.x == manager.find(7).getPosition().x,
+      && prediction2a.position.y < manager.find(8).getPosition().y
+      && prediction2a.position.x == manager.find(7).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2a.order == 1, 'Prediction order should be 1');
@@ -181,8 +181,8 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph2, prediction2b);
     $assert(
       prediction2b.position.y > manager.find(8).getPosition().y
-                && prediction2b.position.y < manager.find(11).getPosition().y
-                && prediction2b.position.x == manager.find(7).getPosition().x,
+      && prediction2b.position.y < manager.find(11).getPosition().y
+      && prediction2b.position.x == manager.find(7).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2b.order == 2, 'Prediction order should be 2');
@@ -192,7 +192,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph2, prediction2c);
     $assert(
       prediction2c.position.y > manager.find(11).getPosition().y
-                && prediction2c.position.x == manager.find(11).getPosition().x,
+      && prediction2c.position.x == manager.find(11).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction2c.order == 3, 'Prediction order should be 3');
@@ -205,8 +205,8 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph3, prediction3a);
     $assert(
       prediction3a.position.y > manager.find(5).getPosition().y
-                && prediction3a.position.y < manager.find(6).getPosition().y
-                && prediction3a.position.x == manager.find(5).getPosition().x,
+      && prediction3a.position.y < manager.find(6).getPosition().y
+      && prediction3a.position.x == manager.find(5).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction3a.order == 2, 'Prediction order should be 2');
@@ -216,7 +216,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph3, prediction3b);
     $assert(
       prediction3b.position.y > manager.find(6).getPosition().y
-                && prediction3b.position.x == manager.find(6).getPosition().x,
+      && prediction3b.position.x == manager.find(6).getPosition().x,
       'Prediction incorrectly positioned',
     );
     $assert(prediction3b.order == 3, 'Prediction order should be 3');
@@ -228,8 +228,8 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph4, prediction4);
     $assert(
       prediction4.position.y > manager.find(9).getPosition().y
-                && prediction4.position.y < manager.find(10).getPosition().y
-                && prediction4.position.x == manager.find(9).getPosition().x,
+      && prediction4.position.y < manager.find(10).getPosition().y
+      && prediction4.position.x == manager.find(9).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction4.order == 1, 'Prediction order should be 1');
@@ -241,7 +241,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph5, prediction5a);
     $assert(
       prediction5a.position.y == manager.find(1).getPosition().y
-                && prediction5a.position.x > manager.find(1).getPosition().x,
+      && prediction5a.position.x > manager.find(1).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction5a.order == 0, 'Prediction order should be 0');
@@ -250,8 +250,8 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph5, prediction5b);
     $assert(
       prediction5b.position.y > manager.find(10).getPosition().y
-                && prediction5b.position.x < manager.find(2).getPosition().x
-                && prediction5b.position.x == manager.find(10).getPosition().x,
+      && prediction5b.position.x < manager.find(2).getPosition().x
+      && prediction5b.position.x == manager.find(10).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction5b.order == 2, 'Prediction order should be 2');
@@ -260,8 +260,8 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph5, prediction5c);
     $assert(
       prediction5c.position.y > manager.find(6).getPosition().y
-                && prediction5c.position.x > manager.find(3).getPosition().x
-                && prediction5c.position.x == manager.find(6).getPosition().x,
+      && prediction5c.position.x > manager.find(3).getPosition().x
+      && prediction5c.position.x == manager.find(6).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction5c.order == 3, 'Prediction order should be 3');
@@ -270,7 +270,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph5, prediction5d);
     $assert(
       prediction5d.position.y == manager.find(10).getPosition().y
-                && prediction5d.position.x < manager.find(10).getPosition().x,
+      && prediction5d.position.x < manager.find(10).getPosition().x,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction5d.order == 0, 'Prediction order should be 0');
@@ -281,7 +281,7 @@ const SymmetricTestSuite = new Class({
   testSymmetricDragPredict() {
     console.log('testSymmetricDragPredict:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 1);
     manager.addNode(2, TestSuite.NODE_SIZE, position).connectNode(1, 2, 0);
@@ -294,7 +294,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1a);
     $assert(
       prediction1a.position.x == manager.find(2).getPosition().x
-                && prediction1a.position.y == manager.find(2).getPosition().y,
+      && prediction1a.position.y == manager.find(2).getPosition().y,
       'Prediction position should be the same as node 2',
     );
     $assert(
@@ -306,7 +306,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1b);
     $assert(
       prediction1b.position.x == manager.find(2).getPosition().x
-                && prediction1b.position.y == manager.find(2).getPosition().y,
+      && prediction1b.position.y == manager.find(2).getPosition().y,
       'Prediction position should be the same as node 2',
     );
     $assert(
@@ -318,7 +318,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1c);
     $assert(
       prediction1c.position.x == manager.find(1).getPosition().x
-                && prediction1c.position.y < manager.find(1).getPosition().y,
+      && prediction1c.position.y < manager.find(1).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1c.order == 1, 'Prediction order should be 1');
@@ -327,7 +327,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1d);
     $assert(
       prediction1d.position.x == manager.find(1).getPosition().x
-                && prediction1d.position.y > manager.find(1).getPosition().y,
+      && prediction1d.position.y > manager.find(1).getPosition().y,
       'Prediction is incorrectly positioned',
     );
     $assert(prediction1d.order == 3, 'Prediction order should be 3');
@@ -336,7 +336,7 @@ const SymmetricTestSuite = new Class({
     this._plotPrediction(graph1, prediction1e);
     $assert(
       prediction1e.position.x == manager.find(2).getPosition().x
-                && prediction1e.position.y == manager.find(2).getPosition().y,
+      && prediction1e.position.y == manager.find(2).getPosition().y,
       'Prediction position should be the same as node 2',
     );
     $assert(
diff --git a/packages/mindplot/test/playground/layout/TestSuite.js b/packages/mindplot/test/playground/layout/TestSuite.js
index 79b9c104..c75bdc5f 100644
--- a/packages/mindplot/test/playground/layout/TestSuite.js
+++ b/packages/mindplot/test/playground/layout/TestSuite.js
@@ -15,10 +15,10 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
-import mindplot from '../../../src/mindplot';
+import LayoutManager from '../../../src/components/layout/LayoutManager';
 
 const TestSuite = new Class({
-  Extends: mindplot.layout.ChildrenSorterStrategy,
+  Extends: ChildrenSorterStrategy,
 
   initialize() {
     $('#basicTest').css('display', 'block');
@@ -37,7 +37,7 @@ const TestSuite = new Class({
   testAligned() {
     console.log('testAligned:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
     manager.addNode(2, TestSuite.NODE_SIZE, position).connectNode(1, 2, 0);
@@ -84,7 +84,7 @@ const TestSuite = new Class({
   testBaselineAligned1() {
     console.log('testBaselineAligned1:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
     manager.addNode(3, TestSuite.NODE_SIZE, position).connectNode(1, 3, 0);
@@ -130,7 +130,7 @@ const TestSuite = new Class({
   testBaselineAligned2() {
     console.log('testBaselineAligned2:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
     manager.addNode(2, { width: 130, height: 200 }, position).connectNode(1, 2, 0);
@@ -148,7 +148,7 @@ const TestSuite = new Class({
   testEvents() {
     console.log('testEvents:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -161,14 +161,10 @@ const TestSuite = new Class({
     const events = [];
     manager.addEvent('change', (event) => {
       console.log(
-        `\tUpdated nodes: {id:${
-          event.getId()
-        }, order: ${
-          event.getOrder()
-        },position: {${
-          event.getPosition().x
-        },${
-          event.getPosition().y
+        `\tUpdated nodes: {id:${event.getId()
+        }, order: ${event.getOrder()
+        },position: {${event.getPosition().x
+        },${event.getPosition().y
         }}`,
       );
       events.push(event);
@@ -190,7 +186,7 @@ const TestSuite = new Class({
   testEventsComplex() {
     console.log('testEventsComplex:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -207,14 +203,10 @@ const TestSuite = new Class({
     const events = [];
     manager.addEvent('change', (event) => {
       console.log(
-        `\tUpdated nodes: {id:${
-          event.getId()
-        }, order: ${
-          event.getOrder()
-        },position: {${
-          event.getPosition().x
-        },${
-          event.getPosition().y
+        `\tUpdated nodes: {id:${event.getId()
+        }, order: ${event.getOrder()
+        },position: {${event.getPosition().x
+        },${event.getPosition().y
         }}`,
       );
       events.push(event);
@@ -242,7 +234,7 @@ const TestSuite = new Class({
   testDisconnect() {
     console.log('testDisconnect:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -265,10 +257,8 @@ const TestSuite = new Class({
       const posStr = pos ? `,position: {${pos.x},${pos.y}` : '';
       const node = manager.find(event.getId());
       console.log(
-        `\tUpdated nodes: {id:${
-          event.getId()
-        }, order: ${
-          event.getOrder()
+        `\tUpdated nodes: {id:${event.getId()
+        }, order: ${event.getOrder()
         }${posStr
         }}`,
       );
@@ -305,7 +295,7 @@ const TestSuite = new Class({
   testReconnect() {
     console.log('testReconnect:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -357,7 +347,7 @@ const TestSuite = new Class({
     );
     $assert(
       manager.find(6).getPosition().x > manager.find(11).getPosition().x
-                && manager.find(11).getPosition().x == manager.find(12).getPosition().x,
+      && manager.find(11).getPosition().x == manager.find(12).getPosition().x,
       'Nodes 11 and 12 should be to the left of node 6 and horizontally aligned',
     );
 
@@ -367,7 +357,7 @@ const TestSuite = new Class({
   testRemoveNode() {
     console.log('testRemoveNode:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position);
@@ -437,7 +427,7 @@ const TestSuite = new Class({
   testSize() {
     console.log('testSize:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, { width: 60, height: 60 }, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -479,7 +469,7 @@ const TestSuite = new Class({
     // Check that all enlarged nodes shift children accordingly
     $assert(
       manager.find(10).getPosition().x > manager.find(3).getPosition().x
-                && manager.find(10).getPosition().x == manager.find(11).getPosition().x,
+      && manager.find(10).getPosition().x == manager.find(11).getPosition().x,
       'Nodes 10 and 11 should be horizontally algined and to the right of enlarged node 3',
     );
     const xPosNode7 = manager.find(7).getPosition().x;
@@ -534,7 +524,7 @@ const TestSuite = new Class({
   testReconnectSingleNode() {
     console.log('testReconnectSingleNode:');
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     // Prepare a sample graph ...
     manager.addNode(1, TestSuite.NODE_SIZE, position);
@@ -565,19 +555,16 @@ const TestSuite = new Class({
   },
 
   _plotPrediction(canvas, prediction) {
-    if(!canvas) {
+    if (!canvas) {
       console.warn('no canvas in _plotPrediction. Remove this method if plot() not in use');
       return;
     }
     const { position } = prediction;
     const { order } = prediction;
     console.log(
-      `\t\tprediction {order:${
-        order
-      }, position: (${
-        position.x
-      },${
-        position.y
+      `\t\tprediction {order:${order
+      }, position: (${position.x
+      },${position.y
       })}`,
     );
     const cx = position.x + canvas.width / 2 - TestSuite.NODE_SIZE.width / 2;
@@ -587,6 +574,6 @@ const TestSuite = new Class({
 });
 
 (TestSuite.NODE_SIZE = { width: 80, height: 30 }),
-(TestSuite.ROOT_NODE_SIZE = { width: 120, height: 40 });
+  (TestSuite.ROOT_NODE_SIZE = { width: 120, height: 40 });
 
 export default TestSuite;
diff --git a/packages/mindplot/test/playground/map-render/bootstrap/BootstrapDialog.Request.js b/packages/mindplot/test/playground/map-render/bootstrap/BootstrapDialog.Request.js
index 4f12b859..2de28a17 100644
--- a/packages/mindplot/test/playground/map-render/bootstrap/BootstrapDialog.Request.js
+++ b/packages/mindplot/test/playground/map-render/bootstrap/BootstrapDialog.Request.js
@@ -1,23 +1,21 @@
 BootstrapDialog.Request = new Class({
-
     Extends: BootstrapDialog,
-
-    initialize: function(url, title, options) {
+    initialize: function (url, title, options) {
         this.parent(title, options);
         this.requestOptions = {};
         this.requestOptions.cache = false;
         var me = this;
-        this.requestOptions.fail = function(xhr) {
+        this.requestOptions.fail = function (xhr) {
             // Intercept form requests ...
             console.log("Failure:");
             console.log(xhr);
         };
 
-        this.requestOptions.success = function() {
+        this.requestOptions.success = function () {
             // Intercept form requests ...
             var forms = me._native.find('form');
-            _.each(forms, function(form) {
-                $(form).on('submit', function(event) {
+            _.each(forms, function (form) {
+                $(form).on('submit', function (event) {
                     // Intercept form ...
                     me.requestOptions.url = form.action;
                     me.requestOptions.method = form.method ? form.method : 'post';
@@ -39,8 +37,8 @@ BootstrapDialog.Request = new Class({
         });
     },
 
-    onDialogShown: function() {
-        if (typeof(onDialogShown) == "function") {
+    onDialogShown: function () {
+        if (typeof (onDialogShown) == "function") {
             onDialogShown();
         }
     }
diff --git a/packages/mindplot/test/playground/map-render/js/bootstrap.js b/packages/mindplot/test/playground/map-render/js/bootstrap.js
deleted file mode 100644
index b04a0e82..00000000
--- a/packages/mindplot/test/playground/map-render/js/bootstrap.js
+++ /dev/null
@@ -1,6 +0,0 @@
-/*!
- * Bootstrap v3.1.1 (http://getbootstrap.com)
- * Copyright 2011-2014 Twitter, Inc.
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
- */
-if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");+function(a){"use strict";function b(){var a=document.createElement("bootstrap"),b={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var c in b)if(void 0!==a.style[c])return{end:b[c]};return!1}a.fn.emulateTransitionEnd=function(b){var c=!1,d=this;a(this).one(a.support.transition.end,function(){c=!0});var e=function(){c||a(d).trigger(a.support.transition.end)};return setTimeout(e,b),this},a(function(){a.support.transition=b()})}(jQuery),+function(a){"use strict";var b='[data-dismiss="alert"]',c=function(c){a(c).on("click",b,this.close)};c.prototype.close=function(b){function c(){f.trigger("closed.bs.alert").remove()}var d=a(this),e=d.attr("data-target");e||(e=d.attr("href"),e=e&&e.replace(/.*(?=#[^\s]*$)/,""));var f=a(e);b&&b.preventDefault(),f.length||(f=d.hasClass("alert")?d:d.parent()),f.trigger(b=a.Event("close.bs.alert")),b.isDefaultPrevented()||(f.removeClass("in"),a.support.transition&&f.hasClass("fade")?f.one(a.support.transition.end,c).emulateTransitionEnd(150):c())};var d=a.fn.alert;a.fn.alert=function(b){return this.each(function(){var d=a(this),e=d.data("bs.alert");e||d.data("bs.alert",e=new c(this)),"string"==typeof b&&e[b].call(d)})},a.fn.alert.Constructor=c,a.fn.alert.noConflict=function(){return a.fn.alert=d,this},a(document).on("click.bs.alert.data-api",b,c.prototype.close)}(jQuery),+function(a){"use strict";var b=function(c,d){this.$element=a(c),this.options=a.extend({},b.DEFAULTS,d),this.isLoading=!1};b.DEFAULTS={loadingText:"loading..."},b.prototype.setState=function(b){var c="disabled",d=this.$element,e=d.is("input")?"val":"html",f=d.data();b+="Text",f.resetText||d.data("resetText",d[e]()),d[e](f[b]||this.options[b]),setTimeout(a.proxy(function(){"loadingText"==b?(this.isLoading=!0,d.addClass(c).attr(c,c)):this.isLoading&&(this.isLoading=!1,d.removeClass(c).removeAttr(c))},this),0)},b.prototype.toggle=function(){var a=!0,b=this.$element.closest('[data-toggle="buttons"]');if(b.length){var c=this.$element.find("input");"radio"==c.prop("type")&&(c.prop("checked")&&this.$element.hasClass("active")?a=!1:b.find(".active").removeClass("active")),a&&c.prop("checked",!this.$element.hasClass("active")).trigger("change")}a&&this.$element.toggleClass("active")};var c=a.fn.button;a.fn.button=function(c){return this.each(function(){var d=a(this),e=d.data("bs.button"),f="object"==typeof c&&c;e||d.data("bs.button",e=new b(this,f)),"toggle"==c?e.toggle():c&&e.setState(c)})},a.fn.button.Constructor=b,a.fn.button.noConflict=function(){return a.fn.button=c,this},a(document).on("click.bs.button.data-api","[data-toggle^=button]",function(b){var c=a(b.target);c.hasClass("btn")||(c=c.closest(".btn")),c.button("toggle"),b.preventDefault()})}(jQuery),+function(a){"use strict";var b=function(b,c){this.$element=a(b),this.$indicators=this.$element.find(".carousel-indicators"),this.options=c,this.paused=this.sliding=this.interval=this.$active=this.$items=null,"hover"==this.options.pause&&this.$element.on("mouseenter",a.proxy(this.pause,this)).on("mouseleave",a.proxy(this.cycle,this))};b.DEFAULTS={interval:5e3,pause:"hover",wrap:!0},b.prototype.cycle=function(b){return b||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(a.proxy(this.next,this),this.options.interval)),this},b.prototype.getActiveIndex=function(){return this.$active=this.$element.find(".item.active"),this.$items=this.$active.parent().children(),this.$items.index(this.$active)},b.prototype.to=function(b){var c=this,d=this.getActiveIndex();return b>this.$items.length-1||0>b?void 0:this.sliding?this.$element.one("slid.bs.carousel",function(){c.to(b)}):d==b?this.pause().cycle():this.slide(b>d?"next":"prev",a(this.$items[b]))},b.prototype.pause=function(b){return b||(this.paused=!0),this.$element.find(".next, .prev").length&&a.support.transition&&(this.$element.trigger(a.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},b.prototype.next=function(){return this.sliding?void 0:this.slide("next")},b.prototype.prev=function(){return this.sliding?void 0:this.slide("prev")},b.prototype.slide=function(b,c){var d=this.$element.find(".item.active"),e=c||d[b](),f=this.interval,g="next"==b?"left":"right",h="next"==b?"first":"last",i=this;if(!e.length){if(!this.options.wrap)return;e=this.$element.find(".item")[h]()}if(e.hasClass("active"))return this.sliding=!1;var j=a.Event("slide.bs.carousel",{relatedTarget:e[0],direction:g});return this.$element.trigger(j),j.isDefaultPrevented()?void 0:(this.sliding=!0,f&&this.pause(),this.$indicators.length&&(this.$indicators.find(".active").removeClass("active"),this.$element.one("slid.bs.carousel",function(){var b=a(i.$indicators.children()[i.getActiveIndex()]);b&&b.addClass("active")})),a.support.transition&&this.$element.hasClass("slide")?(e.addClass(b),e[0].offsetWidth,d.addClass(g),e.addClass(g),d.one(a.support.transition.end,function(){e.removeClass([b,g].join(" ")).addClass("active"),d.removeClass(["active",g].join(" ")),i.sliding=!1,setTimeout(function(){i.$element.trigger("slid.bs.carousel")},0)}).emulateTransitionEnd(1e3*d.css("transition-duration").slice(0,-1))):(d.removeClass("active"),e.addClass("active"),this.sliding=!1,this.$element.trigger("slid.bs.carousel")),f&&this.cycle(),this)};var c=a.fn.carousel;a.fn.carousel=function(c){return this.each(function(){var d=a(this),e=d.data("bs.carousel"),f=a.extend({},b.DEFAULTS,d.data(),"object"==typeof c&&c),g="string"==typeof c?c:f.slide;e||d.data("bs.carousel",e=new b(this,f)),"number"==typeof c?e.to(c):g?e[g]():f.interval&&e.pause().cycle()})},a.fn.carousel.Constructor=b,a.fn.carousel.noConflict=function(){return a.fn.carousel=c,this},a(document).on("click.bs.carousel.data-api","[data-slide], [data-slide-to]",function(b){var c,d=a(this),e=a(d.attr("data-target")||(c=d.attr("href"))&&c.replace(/.*(?=#[^\s]+$)/,"")),f=a.extend({},e.data(),d.data()),g=d.attr("data-slide-to");g&&(f.interval=!1),e.carousel(f),(g=d.attr("data-slide-to"))&&e.data("bs.carousel").to(g),b.preventDefault()}),a(window).on("load",function(){a('[data-ride="carousel"]').each(function(){var b=a(this);b.carousel(b.data())})})}(jQuery),+function(a){"use strict";var b=function(c,d){this.$element=a(c),this.options=a.extend({},b.DEFAULTS,d),this.transitioning=null,this.options.parent&&(this.$parent=a(this.options.parent)),this.options.toggle&&this.toggle()};b.DEFAULTS={toggle:!0},b.prototype.dimension=function(){var a=this.$element.hasClass("width");return a?"width":"height"},b.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var b=a.Event("show.bs.collapse");if(this.$element.trigger(b),!b.isDefaultPrevented()){var c=this.$parent&&this.$parent.find("> .panel > .in");if(c&&c.length){var d=c.data("bs.collapse");if(d&&d.transitioning)return;c.collapse("hide"),d||c.data("bs.collapse",null)}var e=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[e](0),this.transitioning=1;var f=function(){this.$element.removeClass("collapsing").addClass("collapse in")[e]("auto"),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!a.support.transition)return f.call(this);var g=a.camelCase(["scroll",e].join("-"));this.$element.one(a.support.transition.end,a.proxy(f,this)).emulateTransitionEnd(350)[e](this.$element[0][g])}}},b.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var b=a.Event("hide.bs.collapse");if(this.$element.trigger(b),!b.isDefaultPrevented()){var c=this.dimension();this.$element[c](this.$element[c]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse").removeClass("in"),this.transitioning=1;var d=function(){this.transitioning=0,this.$element.trigger("hidden.bs.collapse").removeClass("collapsing").addClass("collapse")};return a.support.transition?void this.$element[c](0).one(a.support.transition.end,a.proxy(d,this)).emulateTransitionEnd(350):d.call(this)}}},b.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()};var c=a.fn.collapse;a.fn.collapse=function(c){return this.each(function(){var d=a(this),e=d.data("bs.collapse"),f=a.extend({},b.DEFAULTS,d.data(),"object"==typeof c&&c);!e&&f.toggle&&"show"==c&&(c=!c),e||d.data("bs.collapse",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.collapse.Constructor=b,a.fn.collapse.noConflict=function(){return a.fn.collapse=c,this},a(document).on("click.bs.collapse.data-api","[data-toggle=collapse]",function(b){var c,d=a(this),e=d.attr("data-target")||b.preventDefault()||(c=d.attr("href"))&&c.replace(/.*(?=#[^\s]+$)/,""),f=a(e),g=f.data("bs.collapse"),h=g?"toggle":d.data(),i=d.attr("data-parent"),j=i&&a(i);g&&g.transitioning||(j&&j.find('[data-toggle=collapse][data-parent="'+i+'"]').not(d).addClass("collapsed"),d[f.hasClass("in")?"addClass":"removeClass"]("collapsed")),f.collapse(h)})}(jQuery),+function(a){"use strict";function b(b){a(d).remove(),a(e).each(function(){var d=c(a(this)),e={relatedTarget:this};d.hasClass("open")&&(d.trigger(b=a.Event("hide.bs.dropdown",e)),b.isDefaultPrevented()||d.removeClass("open").trigger("hidden.bs.dropdown",e))})}function c(b){var c=b.attr("data-target");c||(c=b.attr("href"),c=c&&/#[A-Za-z]/.test(c)&&c.replace(/.*(?=#[^\s]*$)/,""));var d=c&&a(c);return d&&d.length?d:b.parent()}var d=".dropdown-backdrop",e="[data-toggle=dropdown]",f=function(b){a(b).on("click.bs.dropdown",this.toggle)};f.prototype.toggle=function(d){var e=a(this);if(!e.is(".disabled, :disabled")){var f=c(e),g=f.hasClass("open");if(b(),!g){"ontouchstart"in document.documentElement&&!f.closest(".navbar-nav").length&&a('<div class="dropdown-backdrop"/>').insertAfter(a(this)).on("click",b);var h={relatedTarget:this};if(f.trigger(d=a.Event("show.bs.dropdown",h)),d.isDefaultPrevented())return;f.toggleClass("open").trigger("shown.bs.dropdown",h),e.focus()}return!1}},f.prototype.keydown=function(b){if(/(38|40|27)/.test(b.keyCode)){var d=a(this);if(b.preventDefault(),b.stopPropagation(),!d.is(".disabled, :disabled")){var f=c(d),g=f.hasClass("open");if(!g||g&&27==b.keyCode)return 27==b.which&&f.find(e).focus(),d.click();var h=" li:not(.divider):visible a",i=f.find("[role=menu]"+h+", [role=listbox]"+h);if(i.length){var j=i.index(i.filter(":focus"));38==b.keyCode&&j>0&&j--,40==b.keyCode&&j<i.length-1&&j++,~j||(j=0),i.eq(j).focus()}}}};var g=a.fn.dropdown;a.fn.dropdown=function(b){return this.each(function(){var c=a(this),d=c.data("bs.dropdown");d||c.data("bs.dropdown",d=new f(this)),"string"==typeof b&&d[b].call(c)})},a.fn.dropdown.Constructor=f,a.fn.dropdown.noConflict=function(){return a.fn.dropdown=g,this},a(document).on("click.bs.dropdown.data-api",b).on("click.bs.dropdown.data-api",".dropdown form",function(a){a.stopPropagation()}).on("click.bs.dropdown.data-api",e,f.prototype.toggle).on("keydown.bs.dropdown.data-api",e+", [role=menu], [role=listbox]",f.prototype.keydown)}(jQuery),+function(a){"use strict";var b=function(b,c){this.options=c,this.$element=a(b),this.$backdrop=this.isShown=null,this.options.remote&&this.$element.find(".modal-content").load(this.options.remote,a.proxy(function(){this.$element.trigger("loaded.bs.modal")},this))};b.DEFAULTS={backdrop:!0,keyboard:!0,show:!0},b.prototype.toggle=function(a){return this[this.isShown?"hide":"show"](a)},b.prototype.show=function(b){var c=this,d=a.Event("show.bs.modal",{relatedTarget:b});this.$element.trigger(d),this.isShown||d.isDefaultPrevented()||(this.isShown=!0,this.escape(),this.$element.on("click.dismiss.bs.modal",'[data-dismiss="modal"]',a.proxy(this.hide,this)),this.backdrop(function(){var d=a.support.transition&&c.$element.hasClass("fade");c.$element.parent().length||c.$element.appendTo(document.body),c.$element.show().scrollTop(0),d&&c.$element[0].offsetWidth,c.$element.addClass("in").attr("aria-hidden",!1),c.enforceFocus();var e=a.Event("shown.bs.modal",{relatedTarget:b});d?c.$element.find(".modal-dialog").one(a.support.transition.end,function(){c.$element.focus().trigger(e)}).emulateTransitionEnd(300):c.$element.focus().trigger(e)}))},b.prototype.hide=function(b){b&&b.preventDefault(),b=a.Event("hide.bs.modal"),this.$element.trigger(b),this.isShown&&!b.isDefaultPrevented()&&(this.isShown=!1,this.escape(),a(document).off("focusin.bs.modal"),this.$element.removeClass("in").attr("aria-hidden",!0).off("click.dismiss.bs.modal"),a.support.transition&&this.$element.hasClass("fade")?this.$element.one(a.support.transition.end,a.proxy(this.hideModal,this)).emulateTransitionEnd(300):this.hideModal())},b.prototype.enforceFocus=function(){a(document).off("focusin.bs.modal").on("focusin.bs.modal",a.proxy(function(a){this.$element[0]===a.target||this.$element.has(a.target).length||this.$element.focus()},this))},b.prototype.escape=function(){this.isShown&&this.options.keyboard?this.$element.on("keyup.dismiss.bs.modal",a.proxy(function(a){27==a.which&&this.hide()},this)):this.isShown||this.$element.off("keyup.dismiss.bs.modal")},b.prototype.hideModal=function(){var a=this;this.$element.hide(),this.backdrop(function(){a.removeBackdrop(),a.$element.trigger("hidden.bs.modal")})},b.prototype.removeBackdrop=function(){this.$backdrop&&this.$backdrop.remove(),this.$backdrop=null},b.prototype.backdrop=function(b){var c=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var d=a.support.transition&&c;if(this.$backdrop=a('<div class="modal-backdrop '+c+'" />').appendTo(document.body),this.$element.on("click.dismiss.bs.modal",a.proxy(function(a){a.target===a.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus.call(this.$element[0]):this.hide.call(this))},this)),d&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!b)return;d?this.$backdrop.one(a.support.transition.end,b).emulateTransitionEnd(150):b()}else!this.isShown&&this.$backdrop?(this.$backdrop.removeClass("in"),a.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one(a.support.transition.end,b).emulateTransitionEnd(150):b()):b&&b()};var c=a.fn.modal;a.fn.modal=function(c,d){return this.each(function(){var e=a(this),f=e.data("bs.modal"),g=a.extend({},b.DEFAULTS,e.data(),"object"==typeof c&&c);f||e.data("bs.modal",f=new b(this,g)),"string"==typeof c?f[c](d):g.show&&f.show(d)})},a.fn.modal.Constructor=b,a.fn.modal.noConflict=function(){return a.fn.modal=c,this},a(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',function(b){var c=a(this),d=c.attr("href"),e=a(c.attr("data-target")||d&&d.replace(/.*(?=#[^\s]+$)/,"")),f=e.data("bs.modal")?"toggle":a.extend({remote:!/#/.test(d)&&d},e.data(),c.data());c.is("a")&&b.preventDefault(),e.modal(f,this).one("hide",function(){c.is(":visible")&&c.focus()})}),a(document).on("show.bs.modal",".modal",function(){a(document.body).addClass("modal-open")}).on("hidden.bs.modal",".modal",function(){a(document.body).removeClass("modal-open")})}(jQuery),+function(a){"use strict";var b=function(a,b){this.type=this.options=this.enabled=this.timeout=this.hoverState=this.$element=null,this.init("tooltip",a,b)};b.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,container:!1},b.prototype.init=function(b,c,d){this.enabled=!0,this.type=b,this.$element=a(c),this.options=this.getOptions(d);for(var e=this.options.trigger.split(" "),f=e.length;f--;){var g=e[f];if("click"==g)this.$element.on("click."+this.type,this.options.selector,a.proxy(this.toggle,this));else if("manual"!=g){var h="hover"==g?"mouseenter":"focusin",i="hover"==g?"mouseleave":"focusout";this.$element.on(h+"."+this.type,this.options.selector,a.proxy(this.enter,this)),this.$element.on(i+"."+this.type,this.options.selector,a.proxy(this.leave,this))}}this.options.selector?this._options=a.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.getOptions=function(b){return b=a.extend({},this.getDefaults(),this.$element.data(),b),b.delay&&"number"==typeof b.delay&&(b.delay={show:b.delay,hide:b.delay}),b},b.prototype.getDelegateOptions=function(){var b={},c=this.getDefaults();return this._options&&a.each(this._options,function(a,d){c[a]!=d&&(b[a]=d)}),b},b.prototype.enter=function(b){var c=b instanceof this.constructor?b:a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type);return clearTimeout(c.timeout),c.hoverState="in",c.options.delay&&c.options.delay.show?void(c.timeout=setTimeout(function(){"in"==c.hoverState&&c.show()},c.options.delay.show)):c.show()},b.prototype.leave=function(b){var c=b instanceof this.constructor?b:a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type);return clearTimeout(c.timeout),c.hoverState="out",c.options.delay&&c.options.delay.hide?void(c.timeout=setTimeout(function(){"out"==c.hoverState&&c.hide()},c.options.delay.hide)):c.hide()},b.prototype.show=function(){var b=a.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){if(this.$element.trigger(b),b.isDefaultPrevented())return;var c=this,d=this.tip();this.setContent(),this.options.animation&&d.addClass("fade");var e="function"==typeof this.options.placement?this.options.placement.call(this,d[0],this.$element[0]):this.options.placement,f=/\s?auto?\s?/i,g=f.test(e);g&&(e=e.replace(f,"")||"top"),d.detach().css({top:0,left:0,display:"block"}).addClass(e),this.options.container?d.appendTo(this.options.container):d.insertAfter(this.$element);var h=this.getPosition(),i=d[0].offsetWidth,j=d[0].offsetHeight;if(g){var k=this.$element.parent(),l=e,m=document.documentElement.scrollTop||document.body.scrollTop,n="body"==this.options.container?window.innerWidth:k.outerWidth(),o="body"==this.options.container?window.innerHeight:k.outerHeight(),p="body"==this.options.container?0:k.offset().left;e="bottom"==e&&h.top+h.height+j-m>o?"top":"top"==e&&h.top-m-j<0?"bottom":"right"==e&&h.right+i>n?"left":"left"==e&&h.left-i<p?"right":e,d.removeClass(l).addClass(e)}var q=this.getCalculatedOffset(e,h,i,j);this.applyPlacement(q,e),this.hoverState=null;var r=function(){c.$element.trigger("shown.bs."+c.type)};a.support.transition&&this.$tip.hasClass("fade")?d.one(a.support.transition.end,r).emulateTransitionEnd(150):r()}},b.prototype.applyPlacement=function(b,c){var d,e=this.tip(),f=e[0].offsetWidth,g=e[0].offsetHeight,h=parseInt(e.css("margin-top"),10),i=parseInt(e.css("margin-left"),10);isNaN(h)&&(h=0),isNaN(i)&&(i=0),b.top=b.top+h,b.left=b.left+i,a.offset.setOffset(e[0],a.extend({using:function(a){e.css({top:Math.round(a.top),left:Math.round(a.left)})}},b),0),e.addClass("in");var j=e[0].offsetWidth,k=e[0].offsetHeight;if("top"==c&&k!=g&&(d=!0,b.top=b.top+g-k),/bottom|top/.test(c)){var l=0;b.left<0&&(l=-2*b.left,b.left=0,e.offset(b),j=e[0].offsetWidth,k=e[0].offsetHeight),this.replaceArrow(l-f+j,j,"left")}else this.replaceArrow(k-g,k,"top");d&&e.offset(b)},b.prototype.replaceArrow=function(a,b,c){this.arrow().css(c,a?50*(1-a/b)+"%":"")},b.prototype.setContent=function(){var a=this.tip(),b=this.getTitle();a.find(".tooltip-inner")[this.options.html?"html":"text"](b),a.removeClass("fade in top bottom left right")},b.prototype.hide=function(){function b(){"in"!=c.hoverState&&d.detach(),c.$element.trigger("hidden.bs."+c.type)}var c=this,d=this.tip(),e=a.Event("hide.bs."+this.type);return this.$element.trigger(e),e.isDefaultPrevented()?void 0:(d.removeClass("in"),a.support.transition&&this.$tip.hasClass("fade")?d.one(a.support.transition.end,b).emulateTransitionEnd(150):b(),this.hoverState=null,this)},b.prototype.fixTitle=function(){var a=this.$element;(a.attr("title")||"string"!=typeof a.attr("data-original-title"))&&a.attr("data-original-title",a.attr("title")||"").attr("title","")},b.prototype.hasContent=function(){return this.getTitle()},b.prototype.getPosition=function(){var b=this.$element[0];return a.extend({},"function"==typeof b.getBoundingClientRect?b.getBoundingClientRect():{width:b.offsetWidth,height:b.offsetHeight},this.$element.offset())},b.prototype.getCalculatedOffset=function(a,b,c,d){return"bottom"==a?{top:b.top+b.height,left:b.left+b.width/2-c/2}:"top"==a?{top:b.top-d,left:b.left+b.width/2-c/2}:"left"==a?{top:b.top+b.height/2-d/2,left:b.left-c}:{top:b.top+b.height/2-d/2,left:b.left+b.width}},b.prototype.getTitle=function(){var a,b=this.$element,c=this.options;return a=b.attr("data-original-title")||("function"==typeof c.title?c.title.call(b[0]):c.title)},b.prototype.tip=function(){return this.$tip=this.$tip||a(this.options.template)},b.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},b.prototype.validate=function(){this.$element[0].parentNode||(this.hide(),this.$element=null,this.options=null)},b.prototype.enable=function(){this.enabled=!0},b.prototype.disable=function(){this.enabled=!1},b.prototype.toggleEnabled=function(){this.enabled=!this.enabled},b.prototype.toggle=function(b){var c=b?a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type):this;c.tip().hasClass("in")?c.leave(c):c.enter(c)},b.prototype.destroy=function(){clearTimeout(this.timeout),this.hide().$element.off("."+this.type).removeData("bs."+this.type)};var c=a.fn.tooltip;a.fn.tooltip=function(c){return this.each(function(){var d=a(this),e=d.data("bs.tooltip"),f="object"==typeof c&&c;(e||"destroy"!=c)&&(e||d.data("bs.tooltip",e=new b(this,f)),"string"==typeof c&&e[c]())})},a.fn.tooltip.Constructor=b,a.fn.tooltip.noConflict=function(){return a.fn.tooltip=c,this}}(jQuery),+function(a){"use strict";var b=function(a,b){this.init("popover",a,b)};if(!a.fn.tooltip)throw new Error("Popover requires tooltip.js");b.DEFAULTS=a.extend({},a.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:'<div class="popover"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'}),b.prototype=a.extend({},a.fn.tooltip.Constructor.prototype),b.prototype.constructor=b,b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.setContent=function(){var a=this.tip(),b=this.getTitle(),c=this.getContent();a.find(".popover-title")[this.options.html?"html":"text"](b),a.find(".popover-content")[this.options.html?"string"==typeof c?"html":"append":"text"](c),a.removeClass("fade top bottom left right in"),a.find(".popover-title").html()||a.find(".popover-title").hide()},b.prototype.hasContent=function(){return this.getTitle()||this.getContent()},b.prototype.getContent=function(){var a=this.$element,b=this.options;return a.attr("data-content")||("function"==typeof b.content?b.content.call(a[0]):b.content)},b.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")},b.prototype.tip=function(){return this.$tip||(this.$tip=a(this.options.template)),this.$tip};var c=a.fn.popover;a.fn.popover=function(c){return this.each(function(){var d=a(this),e=d.data("bs.popover"),f="object"==typeof c&&c;(e||"destroy"!=c)&&(e||d.data("bs.popover",e=new b(this,f)),"string"==typeof c&&e[c]())})},a.fn.popover.Constructor=b,a.fn.popover.noConflict=function(){return a.fn.popover=c,this}}(jQuery),+function(a){"use strict";function b(c,d){var e,f=a.proxy(this.process,this);this.$element=a(a(c).is("body")?window:c),this.$body=a("body"),this.$scrollElement=this.$element.on("scroll.bs.scroll-spy.data-api",f),this.options=a.extend({},b.DEFAULTS,d),this.selector=(this.options.target||(e=a(c).attr("href"))&&e.replace(/.*(?=#[^\s]+$)/,"")||"")+" .nav li > a",this.offsets=a([]),this.targets=a([]),this.activeTarget=null,this.refresh(),this.process()}b.DEFAULTS={offset:10},b.prototype.refresh=function(){var b=this.$element[0]==window?"offset":"position";this.offsets=a([]),this.targets=a([]);{var c=this;this.$body.find(this.selector).map(function(){var d=a(this),e=d.data("target")||d.attr("href"),f=/^#./.test(e)&&a(e);return f&&f.length&&f.is(":visible")&&[[f[b]().top+(!a.isWindow(c.$scrollElement.get(0))&&c.$scrollElement.scrollTop()),e]]||null}).sort(function(a,b){return a[0]-b[0]}).each(function(){c.offsets.push(this[0]),c.targets.push(this[1])})}},b.prototype.process=function(){var a,b=this.$scrollElement.scrollTop()+this.options.offset,c=this.$scrollElement[0].scrollHeight||this.$body[0].scrollHeight,d=c-this.$scrollElement.height(),e=this.offsets,f=this.targets,g=this.activeTarget;if(b>=d)return g!=(a=f.last()[0])&&this.activate(a);if(g&&b<=e[0])return g!=(a=f[0])&&this.activate(a);for(a=e.length;a--;)g!=f[a]&&b>=e[a]&&(!e[a+1]||b<=e[a+1])&&this.activate(f[a])},b.prototype.activate=function(b){this.activeTarget=b,a(this.selector).parentsUntil(this.options.target,".active").removeClass("active");var c=this.selector+'[data-target="'+b+'"],'+this.selector+'[href="'+b+'"]',d=a(c).parents("li").addClass("active");d.parent(".dropdown-menu").length&&(d=d.closest("li.dropdown").addClass("active")),d.trigger("activate.bs.scrollspy")};var c=a.fn.scrollspy;a.fn.scrollspy=function(c){return this.each(function(){var d=a(this),e=d.data("bs.scrollspy"),f="object"==typeof c&&c;e||d.data("bs.scrollspy",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.scrollspy.Constructor=b,a.fn.scrollspy.noConflict=function(){return a.fn.scrollspy=c,this},a(window).on("load",function(){a('[data-spy="scroll"]').each(function(){var b=a(this);b.scrollspy(b.data())})})}(jQuery),+function(a){"use strict";var b=function(b){this.element=a(b)};b.prototype.show=function(){var b=this.element,c=b.closest("ul:not(.dropdown-menu)"),d=b.data("target");if(d||(d=b.attr("href"),d=d&&d.replace(/.*(?=#[^\s]*$)/,"")),!b.parent("li").hasClass("active")){var e=c.find(".active:last a")[0],f=a.Event("show.bs.tab",{relatedTarget:e});if(b.trigger(f),!f.isDefaultPrevented()){var g=a(d);this.activate(b.parent("li"),c),this.activate(g,g.parent(),function(){b.trigger({type:"shown.bs.tab",relatedTarget:e})})}}},b.prototype.activate=function(b,c,d){function e(){f.removeClass("active").find("> .dropdown-menu > .active").removeClass("active"),b.addClass("active"),g?(b[0].offsetWidth,b.addClass("in")):b.removeClass("fade"),b.parent(".dropdown-menu")&&b.closest("li.dropdown").addClass("active"),d&&d()}var f=c.find("> .active"),g=d&&a.support.transition&&f.hasClass("fade");g?f.one(a.support.transition.end,e).emulateTransitionEnd(150):e(),f.removeClass("in")};var c=a.fn.tab;a.fn.tab=function(c){return this.each(function(){var d=a(this),e=d.data("bs.tab");e||d.data("bs.tab",e=new b(this)),"string"==typeof c&&e[c]()})},a.fn.tab.Constructor=b,a.fn.tab.noConflict=function(){return a.fn.tab=c,this},a(document).on("click.bs.tab.data-api",'[data-toggle="tab"], [data-toggle="pill"]',function(b){b.preventDefault(),a(this).tab("show")})}(jQuery),+function(a){"use strict";var b=function(c,d){this.options=a.extend({},b.DEFAULTS,d),this.$window=a(window).on("scroll.bs.affix.data-api",a.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",a.proxy(this.checkPositionWithEventLoop,this)),this.$element=a(c),this.affixed=this.unpin=this.pinnedOffset=null,this.checkPosition()};b.RESET="affix affix-top affix-bottom",b.DEFAULTS={offset:0},b.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(b.RESET).addClass("affix");var a=this.$window.scrollTop(),c=this.$element.offset();return this.pinnedOffset=c.top-a},b.prototype.checkPositionWithEventLoop=function(){setTimeout(a.proxy(this.checkPosition,this),1)},b.prototype.checkPosition=function(){if(this.$element.is(":visible")){var c=a(document).height(),d=this.$window.scrollTop(),e=this.$element.offset(),f=this.options.offset,g=f.top,h=f.bottom;"top"==this.affixed&&(e.top+=d),"object"!=typeof f&&(h=g=f),"function"==typeof g&&(g=f.top(this.$element)),"function"==typeof h&&(h=f.bottom(this.$element));var i=null!=this.unpin&&d+this.unpin<=e.top?!1:null!=h&&e.top+this.$element.height()>=c-h?"bottom":null!=g&&g>=d?"top":!1;if(this.affixed!==i){this.unpin&&this.$element.css("top","");var j="affix"+(i?"-"+i:""),k=a.Event(j+".bs.affix");this.$element.trigger(k),k.isDefaultPrevented()||(this.affixed=i,this.unpin="bottom"==i?this.getPinnedOffset():null,this.$element.removeClass(b.RESET).addClass(j).trigger(a.Event(j.replace("affix","affixed"))),"bottom"==i&&this.$element.offset({top:c-h-this.$element.height()}))}}};var c=a.fn.affix;a.fn.affix=function(c){return this.each(function(){var d=a(this),e=d.data("bs.affix"),f="object"==typeof c&&c;e||d.data("bs.affix",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.affix.Constructor=b,a.fn.affix.noConflict=function(){return a.fn.affix=c,this},a(window).on("load",function(){a('[data-spy="affix"]').each(function(){var b=a(this),c=b.data();c.offset=c.offset||{},c.offsetBottom&&(c.offset.bottom=c.offsetBottom),c.offsetTop&&(c.offset.top=c.offsetTop),b.affix(c)})})}(jQuery);
\ No newline at end of file
diff --git a/packages/mindplot/test/playground/map-render/js/editor.js b/packages/mindplot/test/playground/map-render/js/editor.js
index bc8be3ad..be120ec6 100644
--- a/packages/mindplot/test/playground/map-render/js/editor.js
+++ b/packages/mindplot/test/playground/map-render/js/editor.js
@@ -16,9 +16,10 @@
  *   limitations under the License.
  */
 import { $assert } from '@wisemapping/core-js';
-import Mindmap from '../../../../src/components/model/Mindmap';
-import PersistenceManager from '../../../../src/components/PersistenceManager';
-import $ from '@libraries/jquery-2.1.0'
+import { Mindmap, PersistenceManager, Designer, LocalStorageManager, Menu } from '../../../../src/';
+
+import $ from '@libraries/jquery-2.1.0';
+global.jQuery = $;
 
 let designer = null;
 
@@ -48,7 +49,7 @@ function buildDesigner(options) {
   $assert(container, 'container could not be null');
 
   // Register load events ...
-  designer = new mindplot.Designer(options, container);
+  designer = new Designer(options, container);
   designer.addEvent('loadSuccess', () => {
     window.waitDialog.close();
     window.waitDialog = null;
@@ -109,13 +110,13 @@ function buildDesigner(options) {
       persistence = options.persistenceManager;
     }
   } else {
-    persistence = new mindplot.LocalStorageManager('samples/{id}.xml');
+    persistence = new LocalStorageManager('samples/{id}.xml');
   }
-  mindplot.PersistenceManager.init(persistence);
+  PersistenceManager.init(persistence);
 
   // Register toolbar event ...
   if ($('#toolbar')) {
-    const menu = new mindplot.widget.Menu(designer, 'toolbar', options.mapId, '');
+    const menu = new Menu(designer, 'toolbar', options.mapId, '');
 
     //  If a node has focus, focus can be move to another node using the keys.
     designer._cleanScreen = function () {
@@ -193,7 +194,7 @@ global.editor.WaitDialog = new Class({
 
 // Show loading dialog ...
 $(() => {
-  import('./bootstrap').then(() => {
+  import('../../../../../../libraries/bootstrap').then(() => {
     global.waitDialog = new global.editor.WaitDialog();
     global.waitDialog.show();
 
diff --git a/packages/mindplot/test/unit/BalancedTestSuite.js b/packages/mindplot/test/unit/BalancedTestSuite.js
index b354ec70..4d123a91 100644
--- a/packages/mindplot/test/unit/BalancedTestSuite.js
+++ b/packages/mindplot/test/unit/BalancedTestSuite.js
@@ -1,7 +1,9 @@
+import LayoutManager from '../../../src/components/layout/LayoutManager';
+
 describe('Balanced Test Suite', () => {
   it('balancedTest', () => {
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.connectNode(0, 1, 0);
     manager.layout();
@@ -96,7 +98,7 @@ describe('Balanced Test Suite', () => {
 
   it('balancedPredictTest', () => {
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position);
     manager.addNode(2, TestSuite.NODE_SIZE, position);
@@ -198,7 +200,7 @@ describe('Balanced Test Suite', () => {
 
   it('balancedNodeDragPredictTest', () => {
     const position = { x: 0, y: 0 };
-    const manager = new mindplot.layout.LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
+    const manager = new LayoutManager(0, TestSuite.ROOT_NODE_SIZE);
 
     manager.addNode(1, TestSuite.NODE_SIZE, position).connectNode(0, 1, 0);
     manager.layout();
diff --git a/packages/mindplot/webpack.common.js b/packages/mindplot/webpack.common.js
index 6bc15598..61430011 100644
--- a/packages/mindplot/webpack.common.js
+++ b/packages/mindplot/webpack.common.js
@@ -3,7 +3,6 @@ const { CleanWebpackPlugin } = require('clean-webpack-plugin');
 
 /** @type {import('webpack').Configuration} */
 module.exports = {
-  entry: './src/mindplot',
   output: {
     path: path.resolve(__dirname, 'dist'),
     filename: '[name].js',
@@ -29,14 +28,6 @@ module.exports = {
   resolve: {
     alias: {
       '@libraries': path.resolve(__dirname, '../../libraries/'),
-      '@commands': path.resolve(__dirname, './src/components/commands/'),
-      '@layout': path.resolve(__dirname, './src/components/layout/'),
-      '@libs': path.resolve(__dirname, './src/components/libraries/'),
-      '@model': path.resolve(__dirname, './src/components/model'),
-      '@persistence': path.resolve(__dirname, './src/components/persistence/'),
-      '@util': path.resolve(__dirname, './src/components/util/'),
-      '@widget': path.resolve(__dirname, './src/components/widget/'),
-      '@components': path.resolve(__dirname, './src/components/'),
     },
     extensions: ['.js', '.json'],
   },