text: (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var E =
  /*#__PURE__*/
  function () {
    function E(node) {
      _classCallCheck(this, E);
  
      this.node = node;
    }
  
    _createClass(E, [{
      key: "activate",
      value: function activate() {
        throw new Error('activate function must be defined');
      }
    }]);
  
    return E;
  }();
  
  module.exports = E;
  
  },{}],2:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var _require = require('./../cutie/exports'),
      as = _require.as;
  
  var _require2 = require('./../async-ajax/exports'),
      ResponseFromAjaxRequest = _require2.ResponseFromAjaxRequest,
      ResponseBody = _require2.ResponseBody,
      ResponseHeaders = _require2.ResponseHeaders,
      ResponseStatusCode = _require2.ResponseStatusCode,
      JSResponseByHTTPReponseComponents = _require2.JSResponseByHTTPReponseComponents;
  
  var _require3 = require('./../async-object/exports'),
      CreatedOptions = _require3.CreatedOptions;
  
  var _require4 = require('./../async-dom/exports'),
      ShownElement = _require4.ShownElement,
      HiddenElement = _require4.HiddenElement,
      EnabledElement = _require4.EnabledElement,
      DisabledElement = _require4.DisabledElement,
      FirstParsedElmSelector = _require4.FirstParsedElmSelector;
  
  var _require5 = require('./../async-json/exports'),
      ParsedJSON = _require5.ParsedJSON,
      StringifiedJSON = _require5.StringifiedJSON;
  
  var _require6 = require('./../async-string/exports'),
      StringFromBuffer = _require6.StringFromBuffer;
  
  var _require7 = require('./../actions/exports'),
      AppliedActionsOnResponse = _require7.AppliedActionsOnResponse;
  
  var _require8 = require('./../file/exports'),
      FileInfo = _require8.FileInfo;
  
  var _require9 = require('./../events/exports'),
      ShowProgressEvent = _require9.ShowProgressEvent,
      ShowFileReaderProgressEvent = _require9.ShowFileReaderProgressEvent,
      ShowFileReaderEndEvent = _require9.ShowFileReaderEndEvent;
  
  var VALIDATION_PATTERNS = {
    date: /\d\d\d\d-\d\d-\d\d/,
    dateTime: /[0-3]\d\/[0-1]\d\/\d\d\d\d, \d\d:\d\d/,
    email: /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/,
    month: /^\d\d\d\d-\d\d$/,
    number: /(\d)+/,
    password: /^.*(?=.{8,})(?=.*[a-zA-Z])(?=.*\d)(?=.*[!#$%&? "]).*$/,
    tel: /[0-9]{0,14}$/,
    time: /\d\d:\d\d/,
    // eslint-disable-next-line  no-useless-escape
    url: /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\-;:&=\+\$,\w]+@)?[A-Za-z0-9\.\-]+|(?:www\.|[\-;:&=\+\$,\w]+@)[A-Za-z0-9\.\-]+)((?:\/[\+~%\/\.\w\-_]*)?\??(?:[\-\+=&;%@\.\w_]*)#?(?:[\.\!\/\\\w]*))?)/
  };
  
  var E_FORM =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_FORM, _E);
  
    function E_FORM(node) {
      _classCallCheck(this, E_FORM);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_FORM).call(this, node));
    }
  
    _createClass(E_FORM, [{
      key: "activate",
      value: function activate() {
        this.setup();
      }
    }, {
      key: "setup",
      value: function setup() {
        this.replaceWithForm();
        this.node.progressBars = this.node.getElementsByTagName('progress');
        this.node.inputs = this.node.getElementsByTagName('input');
        this.node.selects = this.node.getElementsByTagName('select');
        this.node.textareas = this.node.getElementsByTagName('textarea');
        this.node.localStorageValues = this.node.getElementsByTagName('e-local-storage-value');
        this.node.sessionStorageValues = this.node.getElementsByTagName('e-session-storage-value');
        this.node.buttons = this.node.getElementsByTagName('button');
        this.tuneFileInputs(this.filteredFileInputs(this.node.inputs));
        this.prepareDifferentFormElements();
        this.prepareProgressBars(this.node.progressBars);
      }
    }, {
      key: "replaceWithForm",
      value: function replaceWithForm() {
        var form = document.createElement('form');
        form.setAttribute('novalidate', 'true');
        form.setAttribute('data-e-form', 'true');
  
        for (var i = 0; i < this.node.attributes.length; i++) {
          form.setAttribute(this.node.attributes[i].name, this.node.attributes[i].value);
        }
  
        form.onsubmit = function () {
          return false;
        };
  
        form.submit = this.submit;
        form.validationErrorBoxes = [];
        this.setupMethodsForForm(form);
  
        while (this.node.firstChild) {
          var child = this.node.removeChild(this.node.firstChild);
          form.appendChild(child);
        }
  
        this.node.parentNode.replaceChild(form, this.node);
        this.node = form;
      }
    }, {
      key: "setupMethodsForForm",
      value: function setupMethodsForForm(form) {
        form.requestBody = this.requestBody;
        form.retrievedValuesFromInputsForRequestBody = this.retrievedValuesFromInputsForRequestBody;
        form.retrievedValuesFromSelectsForRequestBody = this.retrievedValuesFromSelectsForRequestBody;
        form.retrievedValuesFromTextareasForRequestBody = this.retrievedValuesFromTextareasForRequestBody;
        form.retrievedValuesFromLocalStorageForRequestBody = this.retrievedValuesFromLocalStorageForRequestBody;
        form.retrievedValuesFromSessionStorageForRequestBody = this.retrievedValuesFromSessionStorageForRequestBody;
        form.hideAllErrorsForForm = this.hideAllErrorsForForm;
        form.validateDifferentFormElements = this.validateDifferentFormElements;
        form.validateFormElements = this.validateFormElements;
        form.validateFormElement = this.validateFormElement;
        form.isFormValid = this.isFormValid;
        form.isCheckbox = this.isCheckbox;
        form.isFile = this.isFile;
        form.scrollToFirstErrorBox = this.scrollToFirstErrorBox;
        form.showErrorForFormElement = this.showErrorForFormElement;
      }
    }, {
      key: "prepareDifferentFormElements",
      value: function prepareDifferentFormElements() {
        this.prepareFormElements(this.node.inputs);
        this.prepareFormElements(this.node.selects);
        this.prepareFormElements(this.node.textareas);
        this.prepareFormElements(this.node.localStorageValues);
        this.prepareFormElements(this.node.sessionStorageValues);
        this.prepareFormElements(this.node.buttons);
      }
    }, {
      key: "prepareFormElements",
      value: function prepareFormElements(elms) {
        for (var index = 0; index < elms.length; index++) {
          var elm = elms[index];
          var ajaxIcon = document.querySelector(elm.getAttribute('data-ajax-icon'));
  
          if (ajaxIcon) {
            ajaxIcon.style.display = 'none';
          }
        }
      }
    }, {
      key: "prepareProgressBars",
      value: function prepareProgressBars(progressBars) {
        for (var index = 0; index < progressBars.length; index++) {
          if (progressBars[index]) {
            var progressBar = progressBars[index];
            progressBar.max = 100;
            progressBar.value = 0;
            progressBar.style.display = 'none';
          }
        }
      }
    }, {
      key: "submit",
      value: function submit(target) {
        if (!target) {
          throw new Error('you must pass target in submit method like: \'this.form.submit(this)\'');
        }
  
        var requestBody = this.requestBody(this);
        this.hideAllErrorsForForm(this);
        var validations = [];
        this.validateDifferentFormElements(this, requestBody, validations);
  
        if (this.isFormValid(this, validations)) {
          new DisabledElement(target).after(new FirstParsedElmSelector(target.getAttribute('data-ajax-icon')).as('AJAX_ICON').after(new ShownElement(as('AJAX_ICON')).after(new ResponseFromAjaxRequest(new CreatedOptions('url', target.getAttribute('data-request-url'), 'headers', new ParsedJSON(target.getAttribute('data-request-headers') || '{}'), 'method', target.getAttribute('data-request-method') || 'POST', 'uploadProgressEvent', new ShowProgressEvent(new FirstParsedElmSelector(target.getAttribute('data-upload-progress-bar'))), 'progressEvent', new ShowProgressEvent(new FirstParsedElmSelector(target.getAttribute('data-progress-bar')))), new StringifiedJSON(requestBody)).as('RESPONSE').after(new EnabledElement(target).after(new HiddenElement(as('AJAX_ICON')).after(new AppliedActionsOnResponse(target.tagName, target.getAttribute('data-response-name'), new JSResponseByHTTPReponseComponents(new ParsedJSON(new StringFromBuffer(new ResponseBody(as('RESPONSE')))), new ResponseHeaders(as('RESPONSE')), new ResponseStatusCode(as('RESPONSE'))), target.getAttribute('data-actions-on-response')))))))).call();
        } else {
          this.scrollToFirstErrorBox(this);
        }
      }
    }, {
      key: "isFormValid",
      value: function isFormValid(form, validations) {
        for (var i = 0; i < validations.length; i++) {
          if (!validations[i]) {
            form.showErrorForFormElement(form, form, form.getAttribute('data-validation-error-message') || "the form is invalid", form.getAttribute('data-validation-error-class-for-element'), form.getAttribute('data-validation-error-class-for-message-box'));
            return false;
          }
        }
  
        return true;
      }
    }, {
      key: "validateDifferentFormElements",
      value: function validateDifferentFormElements(form, requestBody, validations) {
        form.validateFormElements(form, form.inputs, requestBody, validations);
        form.validateFormElements(form, form.selects, requestBody, validations);
        form.validateFormElements(form, form.textareas, requestBody, validations);
        form.validateFormElements(form, form.localStorageValues, requestBody, validations);
        form.validateFormElements(form, form.sessionStorageValues, requestBody, validations);
      }
    }, {
      key: "validateFormElements",
      value: function validateFormElements(form, elements, requestBody, results) {
        for (var i = 0; i < elements.length; i++) {
          var element = elements[i];
          results.push(form.validateFormElement(form, element, requestBody));
        }
      }
    }, {
      key: "validateFormElement",
      value: function validateFormElement(form, element, requestBody) {
        var validationPatternAttribute = element.getAttribute('data-validation-pattern');
        var requiredAttribute = element.hasAttribute('required');
        var nameAttribute = element.getAttribute('name');
        var value = requestBody[nameAttribute];
  
        if (typeof value === 'string') {
          value = value.trim();
        }
  
        if (requiredAttribute) {
          if (!value) {
            form.showErrorForFormElement(form, element, element.getAttribute('data-validation-absence-error-message') || "".concat(nameAttribute, " is required"), element.getAttribute('data-validation-error-class-for-element'), element.getAttribute('data-validation-error-class-for-message-box'));
            return false;
          }
  
          if (form.isFile(element)) {
            var minFilesNumber = element.getAttribute('data-validation-min-files-number') * 1 || 1;
  
            if (value.length < minFilesNumber) {
              form.showErrorForFormElement(form, element, element.getAttribute('data-validation-absence-error-message') || "".concat(nameAttribute, " must have at least ").concat(minFilesNumber, " files"), element.getAttribute('data-validation-error-class-for-element'), element.getAttribute('data-validation-error-class-for-message-box'));
              return false;
            }
          }
  
          if (form.isCheckbox(element)) {
            var checkboxValue = element.getAttribute('value');
  
            if (!checkboxValue) {
              throw new Error('checkbox must have \'value\' attribute');
            }
  
            if (value.indexOf(checkboxValue) === -1) {
              form.showErrorForFormElement(form, element, element.getAttribute('data-validation-absence-error-message') || "".concat(nameAttribute, " is required to be true for this value"), element.getAttribute('data-validation-error-class-for-element'), element.getAttribute('data-validation-error-class-for-message-box'));
              return false;
            }
          }
        }
  
        if (validationPatternAttribute) {
          var validationPattern = VALIDATION_PATTERNS[validationPatternAttribute] || new RegExp(validationPatternAttribute, 'ig');
  
          if (!validationPattern.test(value)) {
            form.showErrorForFormElement(form, element, element.getAttribute('data-validation-bad-format-error-message') || "".concat(nameAttribute, " must have format ").concat(validationPattern), element.getAttribute('data-validation-error-class-for-element'), element.getAttribute('data-validation-error-class-for-message-box'));
            return false;
          }
        }
  
        return true;
      }
    }, {
      key: "isCheckbox",
      value: function isCheckbox(element) {
        return element instanceof HTMLInputElement && element.type.toLowerCase() === 'checkbox';
      }
    }, {
      key: "isFile",
      value: function isFile(element) {
        return element instanceof HTMLInputElement && element.type.toLowerCase() === 'file';
      }
    }, {
      key: "showErrorForFormElement",
      value: function showErrorForFormElement(form, element, errorMessage, elementErrorClass, messageBoxErrorClass) {
        var elementWithErrorMessageBox = document.createElement('div');
        var messageBox = document.createElement('div');
        messageBox.innerText = errorMessage;
        element.parentNode.replaceChild(elementWithErrorMessageBox, element);
        elementWithErrorMessageBox.appendChild(element);
        elementWithErrorMessageBox.appendChild(messageBox);
  
        if (elementErrorClass) {
          element.classList.add(elementErrorClass);
        }
  
        if (messageBoxErrorClass) {
          messageBox.classList.add(messageBoxErrorClass);
        }
  
        form.validationErrorBoxes.push({
          elementWithErrorMessageBox: elementWithErrorMessageBox,
          element: element
        });
  
        var listener = function listener() {
          if (elementWithErrorMessageBox.parentNode) {
            elementWithErrorMessageBox.parentNode.replaceChild(element, elementWithErrorMessageBox);
  
            if (elementErrorClass) {
              element.classList.remove(elementErrorClass);
            }
          }
  
          element.removeEventListener('focus', listener);
          element.focus();
          element.click();
        };
  
        element.addEventListener('focus', listener);
      }
    }, {
      key: "hideAllErrorsForForm",
      value: function hideAllErrorsForForm(form) {
        form.validationErrorBoxes.forEach(function (errorBox) {
          if (errorBox.elementWithErrorMessageBox.parentNode) {
            errorBox.elementWithErrorMessageBox.parentNode.replaceChild(errorBox.element, errorBox.elementWithErrorMessageBox);
          }
  
          var elementErrorClass = errorBox.element.getAttribute('data-validation-error-class-for-element');
  
          if (elementErrorClass) {
            errorBox.element.classList.remove(elementErrorClass);
          }
        });
        form.validationErrorBoxes = [];
      }
    }, {
      key: "scrollToFirstErrorBox",
      value: function scrollToFirstErrorBox(form) {
        form.validationErrorBoxes[0].elementWithErrorMessageBox.scrollIntoView({
          behavior: 'smooth',
          block: 'center'
        });
      }
    }, {
      key: "requestBody",
      value: function requestBody(form) {
        var requestBody = {};
        form.retrievedValuesFromInputsForRequestBody(form.inputs, requestBody);
        form.retrievedValuesFromSelectsForRequestBody(form.selects, requestBody);
        form.retrievedValuesFromTextareasForRequestBody(form.textareas, requestBody);
        form.retrievedValuesFromLocalStorageForRequestBody(form.localStorageValues, requestBody);
        form.retrievedValuesFromSessionStorageForRequestBody(form.sessionStorageValues, requestBody);
        return requestBody;
      }
    }, {
      key: "retrievedValuesFromInputsForRequestBody",
      value: function retrievedValuesFromInputsForRequestBody(inputs, requestBody) {
        for (var index = 0; index < inputs.length; index++) {
          var input = inputs[index];
  
          if (!input.name) {
            throw new Error("input ".concat(input, " has no name"));
          }
  
          if (input.type.toLowerCase() === 'radio') {
            if (input.checked) {
              requestBody[input.name] = input.value;
            }
          } else if (input.type.toLowerCase() === 'checkbox') {
            if (!requestBody[input.name]) {
              requestBody[input.name] = [];
            }
  
            var inputValue = input.value;
  
            if (!inputValue) {
              throw new Error('checkbox must have \'value\' attribute');
            }
  
            if (input.checked) {
              requestBody[input.name].push(inputValue);
            }
          } else if (input.type.toLowerCase() === 'file') {
            requestBody[input.name] = input.filesInfo;
          } else {
            requestBody[input.name] = input.value;
          }
        }
      }
    }, {
      key: "retrievedValuesFromSelectsForRequestBody",
      value: function retrievedValuesFromSelectsForRequestBody(selects, requestBody) {
        for (var index = 0; index < selects.length; index++) {
          var select = selects[index];
  
          if (!select.name) {
            throw new Error("select ".concat(select, " has no name"));
          }
  
          requestBody[select.name] = select.value;
        }
      }
    }, {
      key: "retrievedValuesFromTextareasForRequestBody",
      value: function retrievedValuesFromTextareasForRequestBody(textareas, requestBody) {
        for (var index = 0; index < textareas.length; index++) {
          var textarea = textareas[index];
  
          if (!textarea.name) {
            throw new Error("textarea ".concat(textarea, " has no name"));
          }
  
          requestBody[textarea.name] = textarea.value;
        }
      }
    }, {
      key: "retrievedValuesFromLocalStorageForRequestBody",
      value: function retrievedValuesFromLocalStorageForRequestBody(localStorageValues, requestBody) {
        for (var index = 0; index < localStorageValues.length; index++) {
          var localStorageValue = localStorageValues[index];
  
          if (!localStorageValue.name) {
            throw new Error("localStorageValue ".concat(localStorageValue, " has no name"));
          }
  
          requestBody[localStorageValue.name] = localStorageValue.value();
        }
      }
    }, {
      key: "retrievedValuesFromSessionStorageForRequestBody",
      value: function retrievedValuesFromSessionStorageForRequestBody(sessionStorageValues, requestBody) {
        for (var index = 0; index < sessionStorageValues.length; index++) {
          var sessionStorageValue = sessionStorageValues[index];
  
          if (!sessionStorageValue.name) {
            throw new Error("sessionStorageValue ".concat(sessionStorageValue, " has no name"));
          }
  
          requestBody[sessionStorageValue.name] = sessionStorageValue.value();
        }
      }
    }, {
      key: "tuneFileInputs",
      value: function tuneFileInputs(fileInputs) {
        for (var index = 0; index < fileInputs.length; index++) {
          this.tuneFileInput(fileInputs[index]);
        }
      }
    }, {
      key: "tuneFileInput",
      value: function tuneFileInput(fileInput) {
        var _this = this;
  
        var readProgressBar = document.querySelector(fileInput.getAttribute('data-read-progress-bar'));
        fileInput.addEventListener('change', function () {
          _this.readFilesContentForRequestBody(fileInput, readProgressBar);
        });
      }
    }, {
      key: "readFilesContentForRequestBody",
      value: function readFilesContentForRequestBody(fileInput, readProgressBar) {
        fileInput.filesInfo = [];
        var filesRead = {
          count: 0
        };
  
        for (var index = 0; index < fileInput.files.length; index++) {
          this.readFileContentForRequestBody(fileInput, readProgressBar, index, filesRead, fileInput.files.length);
        }
      }
    }, {
      key: "readFileContentForRequestBody",
      value: function readFileContentForRequestBody(fileInput, readProgressBar, index, filesRead, filesLength) {
        var file = fileInput.files[index];
        var reader = new FileReader();
        reader.readAsDataURL(file);
  
        reader.onload = function () {
          fileInput.filesInfo[index] = new FileInfo(file.name, file.size, file.type, reader.result, file.lastModifiedDate);
        };
  
        reader.onprogress = new ShowFileReaderProgressEvent(readProgressBar);
        reader.onloadend = new ShowFileReaderEndEvent(readProgressBar, filesRead, filesLength);
  
        reader.onerror = function () {
          throw new Error("cound not read file ".concat(file.name));
        };
      }
    }, {
      key: "filteredFileInputs",
      value: function filteredFileInputs(inputs) {
        var fileInputs = {
          length: 0
        };
  
        for (var index = 0; index < inputs.length; index++) {
          if (inputs[index].type.toLowerCase() === 'file') {
            fileInputs[fileInputs.length] = inputs[index];
            fileInputs.length += 1;
          }
        }
  
        return fileInputs;
      }
    }]);
  
    return E_FORM;
  }(E);
  
  module.exports = E_FORM;
  
  },{"./../actions/exports":20,"./../async-ajax/exports":27,"./../async-dom/exports":60,"./../async-json/exports":70,"./../async-object/exports":79,"./../async-string/exports":88,"./../cutie/exports":101,"./../events/exports":107,"./../file/exports":109,"./E":1}],3:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_FOR_EACH =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_FOR_EACH, _E);
  
    function E_FOR_EACH(node) {
      _classCallCheck(this, E_FOR_EACH);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_FOR_EACH).call(this, node));
    }
  
    _createClass(E_FOR_EACH, [{
      key: "activate",
      value: function activate() {
        throw new Error('You can use e-for-each only for mapping objects in the attribute "data-actions-on-response", probably in the future there will be elements that would help you map global elements');
      }
    }]);
  
    return E_FOR_EACH;
  }(E);
  
  module.exports = E_FOR_EACH;
  
  },{"./E":1}],4:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var _require = require('./../cutie/exports'),
      as = _require.as;
  
  var _require2 = require('./../async-ajax/exports'),
      ResponseFromAjaxRequest = _require2.ResponseFromAjaxRequest,
      ResponseBody = _require2.ResponseBody,
      ResponseHeaders = _require2.ResponseHeaders,
      ResponseStatusCode = _require2.ResponseStatusCode,
      JSResponseByHTTPReponseComponents = _require2.JSResponseByHTTPReponseComponents;
  
  var _require3 = require('./../async-string/exports'),
      StringFromBuffer = _require3.StringFromBuffer;
  
  var _require4 = require('./../async-json/exports'),
      ParsedJSON = _require4.ParsedJSON;
  
  var _require5 = require('./../actions/exports'),
      AppliedActionsOnResponse = _require5.AppliedActionsOnResponse;
  
  var GOOGLE_API_SRC = 'https://apis.google.com/js/api:client.js';
  
  var E_GOOGLE_OAUTH_BUTTON =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_GOOGLE_OAUTH_BUTTON, _E);
  
    function E_GOOGLE_OAUTH_BUTTON(node) {
      _classCallCheck(this, E_GOOGLE_OAUTH_BUTTON);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_GOOGLE_OAUTH_BUTTON).call(this, node));
    }
  
    _createClass(E_GOOGLE_OAUTH_BUTTON, [{
      key: "activate",
      value: function activate() {
        var _this = this;
  
        this.replaceWithButton();
        var googleSignInMetaElm = this.googleSignInMetaElm();
        var googleApiScriptElm = this.googleApiScriptElm();
        document.head.prepend(googleSignInMetaElm, googleApiScriptElm);
        this.node.style.display = 'none';
  
        googleApiScriptElm.onload = function () {
          _this.initGoogleOauth();
        };
      }
    }, {
      key: "replaceWithButton",
      value: function replaceWithButton() {
        var button = document.createElement('button');
        button.setAttribute('data-e-google-oauth-button', 'true');
  
        for (var i = 0; i < this.node.attributes.length; i++) {
          button.setAttribute(this.node.attributes[i].name, this.node.attributes[i].value);
        }
  
        while (this.node.firstChild) {
          var child = this.node.removeChild(this.node.firstChild);
          button.appendChild(child);
        }
  
        this.node.parentNode.replaceChild(button, this.node);
        this.node = button;
      }
    }, {
      key: "initGoogleOauth",
      value: function initGoogleOauth() {
        var _this2 = this;
  
        this.node.style.display = ''; // eslint-disable-next-line no-undef
  
        gapi.load('auth2', function () {
          // eslint-disable-next-line no-undef
          var auth2 = gapi.auth2.init({
            client_id: _this2.node.getAttribute('data-client-id'),
            cookiepolicy: _this2.node.getAttribute('data-cookiepolicy') || 'single_host_origin',
            scope: _this2.node.getAttribute('data-scope') || 'profile'
          });
          auth2.attachClickHandler(_this2.node, {}, function (googleUser) {
            var body = {};
            body[_this2.node.getAttribute('data-request-token-key') || 'googleToken'] = googleUser.getAuthResponse().id_token;
            new ResponseFromAjaxRequest({
              url: _this2.node.getAttribute('data-redirect-url') || '/',
              method: 'POST'
            }, JSON.stringify(body)).as('RESPONSE').after(new AppliedActionsOnResponse(_this2.node.tagName, _this2.node.getAttribute('data-response-name'), new JSResponseByHTTPReponseComponents(new ParsedJSON(new StringFromBuffer(new ResponseBody(as('RESPONSE')))), new ResponseHeaders(as('RESPONSE')), new ResponseStatusCode(as('RESPONSE'))), _this2.node.getAttribute('data-actions-on-response'))).call();
          }, function (error) {
            console.log(JSON.stringify(error, undefined, 2));
          });
        });
      }
    }, {
      key: "googleSignInMetaElm",
      value: function googleSignInMetaElm() {
        var googleSignInMetaElm = document.createElement('meta');
        googleSignInMetaElm.setAttribute('name', 'google-signin-client_id');
        googleSignInMetaElm.setAttribute('content', this.node.getAttribute('data-client-id'));
        return googleSignInMetaElm;
      }
    }, {
      key: "googleApiScriptElm",
      value: function googleApiScriptElm() {
        var googleApiScriptElm = document.createElement('script');
        googleApiScriptElm.setAttribute('src', GOOGLE_API_SRC);
        return googleApiScriptElm;
      }
    }]);
  
    return E_GOOGLE_OAUTH_BUTTON;
  }(E);
  
  module.exports = E_GOOGLE_OAUTH_BUTTON;
  
  },{"./../actions/exports":20,"./../async-ajax/exports":27,"./../async-json/exports":70,"./../async-string/exports":88,"./../cutie/exports":101,"./E":1}],5:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var _require = require('./../async-dom/exports'),
      UnwrappedChildrenOfParent = _require.UnwrappedChildrenOfParent,
      ElementWithInnerHTML = _require.ElementWithInnerHTML;
  
  var _require2 = require('./../async-ajax/exports'),
      ResponseFromAjaxRequest = _require2.ResponseFromAjaxRequest,
      ResponseBody = _require2.ResponseBody;
  
  var _require3 = require('./../async-object/exports'),
      CreatedOptions = _require3.CreatedOptions;
  
  var _require4 = require('./../async-json/exports'),
      ParsedJSON = _require4.ParsedJSON;
  
  var E_HTML =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_HTML, _E);
  
    function E_HTML(node) {
      _classCallCheck(this, E_HTML);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_HTML).call(this, node));
    }
  
    _createClass(E_HTML, [{
      key: "activate",
      value: function activate() {
        new UnwrappedChildrenOfParent(new ElementWithInnerHTML(this.node, new ResponseBody(new ResponseFromAjaxRequest(new CreatedOptions('url', this.node.getAttribute('data-src'), 'method', 'GET', 'headers', new ParsedJSON(this.node.getAttribute('data-headers') || '{}')))))).call();
      }
    }]);
  
    return E_HTML;
  }(E);
  
  module.exports = E_HTML;
  
  },{"./../async-ajax/exports":27,"./../async-dom/exports":60,"./../async-json/exports":70,"./../async-object/exports":79,"./E":1}],6:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_IF =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_IF, _E);
  
    function E_IF(node) {
      _classCallCheck(this, E_IF);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_IF).call(this, node));
    }
  
    _createClass(E_IF, [{
      key: "activate",
      value: function activate() {
        var toDisplayExpression = this.node.getAttribute('data-condition-to-display');
  
        if (!toDisplayExpression) {
          throw new Error('e-if must have "data-condition-to-display" attribute');
        }
  
        var toDisplay = this.appliedExpressionsInString(toDisplayExpression);
  
        if (toDisplay === 'true') {
          var contentNode = document.importNode(this.node.content, true);
          this.node.parentNode.insertBefore(contentNode, this.node);
        }
  
        this.node.parentNode.removeChild(this.node);
      }
    }, {
      key: "appliedExpressionsInString",
      value: function appliedExpressionsInString(string) {
        return string.replace(/\$\{([^${}]+)\}/g, function (match, p1) {
          // eslint-disable-next-line no-eval
          var appliedExpression = eval(p1);
  
          if (_typeof(appliedExpression) === 'object') {
            return JSON.stringify(appliedExpression);
          }
  
          return appliedExpression;
        });
      }
    }]);
  
    return E_IF;
  }(E);
  
  module.exports = E_IF;
  
  },{"./E":1}],7:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var _require = require('./../cutie/exports'),
      as = _require.as;
  
  var _require2 = require('./../async-dom/exports'),
      FirstParsedElmSelector = _require2.FirstParsedElmSelector,
      PreparedProgressBar = _require2.PreparedProgressBar,
      ShownElement = _require2.ShownElement,
      HiddenElement = _require2.HiddenElement;
  
  var _require3 = require('./../async-ajax/exports'),
      ResponseFromAjaxRequest = _require3.ResponseFromAjaxRequest,
      ResponseBody = _require3.ResponseBody,
      ResponseHeaders = _require3.ResponseHeaders,
      ResponseStatusCode = _require3.ResponseStatusCode,
      JSResponseByHTTPReponseComponents = _require3.JSResponseByHTTPReponseComponents;
  
  var _require4 = require('./../async-object/exports'),
      CreatedOptions = _require4.CreatedOptions;
  
  var _require5 = require('./../async-json/exports'),
      ParsedJSON = _require5.ParsedJSON;
  
  var _require6 = require('./../async-string/exports'),
      StringFromBuffer = _require6.StringFromBuffer;
  
  var _require7 = require('./../events/exports'),
      ShowProgressEvent = _require7.ShowProgressEvent;
  
  var _require8 = require('./../actions/exports'),
      AppliedActionsOnResponse = _require8.AppliedActionsOnResponse;
  
  var E_JSON =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_JSON, _E);
  
    function E_JSON(node) {
      _classCallCheck(this, E_JSON);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_JSON).call(this, node));
    }
  
    _createClass(E_JSON, [{
      key: "activate",
      value: function activate() {
        new ShownElement(new FirstParsedElmSelector(this.node.getAttribute('data-ajax-icon')).as('AJAX_ICON')).after(new PreparedProgressBar(new FirstParsedElmSelector(this.node.getAttribute('data-progress-bar'))).as('PROGRESS_BAR').after(new ResponseFromAjaxRequest(new CreatedOptions('url', this.node.getAttribute('data-src'), 'method', 'GET', 'headers', new ParsedJSON(this.node.getAttribute('data-request-headers') || '{}'), 'progressEvent', new ShowProgressEvent(as('PROGRESS_BAR')))).as('RESPONSE').after(new HiddenElement(as('AJAX_ICON')).after(new AppliedActionsOnResponse(this.node.tagName, this.node.getAttribute('data-response-name'), new JSResponseByHTTPReponseComponents(new ParsedJSON(new StringFromBuffer(new ResponseBody(as('RESPONSE')))), new ResponseHeaders(as('RESPONSE')), new ResponseStatusCode(as('RESPONSE'))), this.node.getAttribute('data-actions-on-response')))))).call();
      }
    }]);
  
    return E_JSON;
  }(E);
  
  module.exports = E_JSON;
  
  },{"./../actions/exports":20,"./../async-ajax/exports":27,"./../async-dom/exports":60,"./../async-json/exports":70,"./../async-object/exports":79,"./../async-string/exports":88,"./../cutie/exports":101,"./../events/exports":107,"./E":1}],8:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_LOCAL_STORAGE_VALUE =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_LOCAL_STORAGE_VALUE, _E);
  
    function E_LOCAL_STORAGE_VALUE(node) {
      _classCallCheck(this, E_LOCAL_STORAGE_VALUE);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_LOCAL_STORAGE_VALUE).call(this, node));
    }
  
    _createClass(E_LOCAL_STORAGE_VALUE, [{
      key: "activate",
      value: function activate() {
        var _this = this;
  
        this.node.name = this.node.getAttribute('name');
  
        this.node.value = function () {
          return localStorage.getItem(_this.node.getAttribute('data-key'));
        };
      }
    }]);
  
    return E_LOCAL_STORAGE_VALUE;
  }(E);
  
  module.exports = E_LOCAL_STORAGE_VALUE;
  
  },{"./E":1}],9:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_PAGE_WITH_URL =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_PAGE_WITH_URL, _E);
  
    function E_PAGE_WITH_URL(node) {
      _classCallCheck(this, E_PAGE_WITH_URL);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_PAGE_WITH_URL).call(this, node));
    }
  
    _createClass(E_PAGE_WITH_URL, [{
      key: "activate",
      value: function activate() {
        var urlParams = {};
        var urlPattern = this.node.getAttribute('data-url-pattern');
        var parsedUrlPattern = this.parsedUrlPattern(urlPattern);
        var locationPath = window.location.pathname;
        var locationSearch = window.location.search;
        var localtionPathParts = locationPath.split(/\//g).filter(function (part) {
          return part !== '';
        });
        var locationRequestParams = this.requestParamsOfLocationSearch(locationSearch);
        parsedUrlPattern.pathVariables.forEach(function (variable, index) {
          if (/^\{([^{}\s.]+)}$/g.test(variable)) {
            urlParams[/^\{([^{}\s.]+)}$/g.exec(variable)[1]] = localtionPathParts[index];
          }
        });
        parsedUrlPattern.requestParams.forEach(function (param) {
          if (/^\{([^{}\s.]+)}$/g.test(param)) {
            var key = /^\{([^{}\s.]+)}$/g.exec(param)[1];
            urlParams[key] = locationRequestParams[key];
          }
        });
        window.urlParams = urlParams;
        this.node.parentNode.replaceChild(document.importNode(this.node.content, true), this.node);
      }
    }, {
      key: "parsedUrlPattern",
      value: function parsedUrlPattern(url) {
        return {
          pathVariables: url.split(/\?/g)[0].split(/\//g).filter(function (part) {
            return part !== '';
          }),
          requestParams: url.split(/\?/g)[1].split(/&/g).filter(function (part) {
            return part !== '';
          })
        };
      }
    }, {
      key: "requestParamsOfLocationSearch",
      value: function requestParamsOfLocationSearch(locationSearch) {
        var requestParams = {};
        locationSearch.split('?')[1].split('&').forEach(function (exp) {
          var parts = exp.split('=');
          requestParams[parts[0]] = parts[1];
        });
        return requestParams;
      }
    }]);
  
    return E_PAGE_WITH_URL;
  }(E);
  
  module.exports = E_PAGE_WITH_URL;
  
  },{"./E":1}],10:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_REUSABLE =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_REUSABLE, _E);
  
    function E_REUSABLE(node) {
      _classCallCheck(this, E_REUSABLE);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_REUSABLE).call(this, node));
    }
  
    _createClass(E_REUSABLE, [{
      key: "activate",
      value: function activate() {
        throw new Error('You can use e-reusable only for mapping objects in the attribute "data-actions-on-response", probably in the future there will be elements that would help you map global elements');
      }
    }]);
  
    return E_REUSABLE;
  }(E);
  
  module.exports = E_REUSABLE;
  
  },{"./E":1}],11:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_SELECT =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_SELECT, _E);
  
    function E_SELECT(node) {
      _classCallCheck(this, E_SELECT);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_SELECT).call(this, node));
    }
  
    _createClass(E_SELECT, [{
      key: "activate",
      value: function activate() {
        this.replaceWithSelect();
        var value = this.node.getAttribute('value');
  
        for (var index = 0; index < this.node.options.length; index++) {
          var item = this.node.options.item(index);
  
          if (item.value === value) {
            this.node.selectedIndex = index;
            break;
          }
        }
      }
    }, {
      key: "replaceWithSelect",
      value: function replaceWithSelect() {
        var select = document.createElement('select');
        select.setAttribute('data-e-select', 'true');
  
        for (var i = 0; i < this.node.attributes.length; i++) {
          select.setAttribute(this.node.attributes[i].name, this.node.attributes[i].value);
        }
  
        while (this.node.firstChild) {
          var child = this.node.removeChild(this.node.firstChild);
          select.appendChild(child);
        }
  
        this.node.parentNode.replaceChild(select, this.node);
        this.node = select;
      }
    }]);
  
    return E_SELECT;
  }(E);
  
  module.exports = E_SELECT;
  
  },{"./E":1}],12:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var E_SESSION_STORAGE_VALUE =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_SESSION_STORAGE_VALUE, _E);
  
    function E_SESSION_STORAGE_VALUE(node) {
      _classCallCheck(this, E_SESSION_STORAGE_VALUE);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_SESSION_STORAGE_VALUE).call(this, node));
    }
  
    _createClass(E_SESSION_STORAGE_VALUE, [{
      key: "activate",
      value: function activate() {
        var _this = this;
  
        this.node.name = this.node.getAttribute('name');
  
        this.node.value = function () {
          return sessionStorage.getItem(_this.node.getAttribute('data-key'));
        };
      }
    }]);
  
    return E_SESSION_STORAGE_VALUE;
  }(E);
  
  module.exports = E_SESSION_STORAGE_VALUE;
  
  },{"./E":1}],13:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var E = require('./E');
  
  var _require = require('./../async-location/exports'),
      TurboRedirected = _require.TurboRedirected;
  
  var _require2 = require('./../async-json/exports'),
      ParsedJSON = _require2.ParsedJSON;
  
  var E_TURBOLINK =
  /*#__PURE__*/
  function (_E) {
    _inherits(E_TURBOLINK, _E);
  
    function E_TURBOLINK(node) {
      _classCallCheck(this, E_TURBOLINK);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(E_TURBOLINK).call(this, node));
    }
  
    _createClass(E_TURBOLINK, [{
      key: "activate",
      value: function activate() {
        var _this = this;
  
        this.replaceWithLink();
        this.node.addEventListener('click', function () {
          new TurboRedirected(_this.node.getAttribute('data-href'), new ParsedJSON(_this.node.getAttribute('data-headers') || '{}'), {
            ajaxFavicon: _this.node.getAttribute('data-ajax-favicon'),
            progressBarClassName: _this.node.getAttribute('data-with-progress-bar'),
            progressBarPlace: _this.node.getAttribute('data-progress-bar-place')
          }).call();
        });
      }
    }, {
      key: "replaceWithLink",
      value: function replaceWithLink() {
        var link = document.createElement('a');
        link.setAttribute('data-e-turbolink', 'true');
  
        for (var i = 0; i < this.node.attributes.length; i++) {
          link.setAttribute(this.node.attributes[i].name, this.node.attributes[i].value);
        }
  
        while (this.node.firstChild) {
          var child = this.node.removeChild(this.node.firstChild);
          link.appendChild(child);
        }
  
        this.node.parentNode.replaceChild(link, this.node);
        this.node = link;
      }
    }]);
  
    return E_TURBOLINK;
  }(E);
  
  module.exports = E_TURBOLINK;
  
  },{"./../async-json/exports":70,"./../async-location/exports":74,"./E":1}],14:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    'e-html': require('./E_HTML'),
    'e-json': require('./E_JSON'),
    'e-if': require('./E_IF'),
    'e-for-each': require('./E_FOR_EACH'),
    'e-form': require('./E_FORM'),
    'e-local-storage-value': require('./E_LOCAL_STORAGE_VALUE'),
    'e-session-storage-value': require('./E_SESSION_STORAGE_VALUE'),
    'e-google-oauth-button': require('./E_GOOGLE_OAUTH_BUTTON'),
    'e-page-with-url': require('./E_PAGE_WITH_URL'),
    'e-reusable': require('./E_REUSABLE'),
    'e-turbolink': require('./E_TURBOLINK'),
    'e-select': require('./E_SELECT')
  };
  
  },{"./E_FORM":2,"./E_FOR_EACH":3,"./E_GOOGLE_OAUTH_BUTTON":4,"./E_HTML":5,"./E_IF":6,"./E_JSON":7,"./E_LOCAL_STORAGE_VALUE":8,"./E_PAGE_WITH_URL":9,"./E_REUSABLE":10,"./E_SELECT":11,"./E_SESSION_STORAGE_VALUE":12,"./E_TURBOLINK":13}],15:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var ELEMENTS = require('./E/exports');
  
  var MutationObservation =
  /*#__PURE__*/
  function () {
    function MutationObservation() {
      _classCallCheck(this, MutationObservation);
  
      this.targetNode = document;
    }
  
    _createClass(MutationObservation, [{
      key: "run",
      value: function run() {
        var _this = this;
  
        var observer = new MutationObserver(function (mutationsList, observer) {
          var _iteratorNormalCompletion = true;
          var _didIteratorError = false;
          var _iteratorError = undefined;
  
          try {
            for (var _iterator = mutationsList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
              var mutation = _step.value;
  
              if (mutation.type === 'childList') {
                for (var i = 0; i < mutation.addedNodes.length; i++) {
                  var node = mutation.addedNodes[i];
  
                  _this.processNodeWithItsChildNodes(node);
                }
              }
            }
          } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
          } finally {
            try {
              if (!_iteratorNormalCompletion && _iterator["return"] != null) {
                _iterator["return"]();
              }
            } finally {
              if (_didIteratorError) {
                throw _iteratorError;
              }
            }
          }
        });
        observer.observe(this.targetNode, {
          childList: true,
          subtree: true
        });
      }
    }, {
      key: "processNodeWithItsChildNodes",
      value: function processNodeWithItsChildNodes(node) {
        if (!node.observedByEHTML) {
          node.observedByEHTML = true;
          var nodeName = this.nodeName(node);
          this.processAttributesOfNode(node);
  
          if (ELEMENTS[nodeName]) {
            if (!node.activatedByEHTML) {
              node.activatedByEHTML = true;
              new ELEMENTS[nodeName](node).activate();
            }
          }
  
          var childNodes = node.childNodes;
  
          for (var i = 0; i < childNodes.length; i++) {
            this.processNodeWithItsChildNodes(childNodes[i]);
          }
        }
      }
    }, {
      key: "processAttributesOfNode",
      value: function processAttributesOfNode(node) {
        if (node.attributes) {
          for (var i = 0; i < node.attributes.length; i++) {
            var attr = node.attributes[i];
  
            if (this.isForProcessing(attr)) {
              node.setAttribute(attr.name, attr.value.replace(/\$\{([^${}]+)\}/g, function (match, p1) {
                // eslint-disable-next-line no-eval
                var appliedExpression = eval(p1);
  
                if (_typeof(appliedExpression) === 'object') {
                  return JSON.stringify(appliedExpression);
                }
  
                return appliedExpression;
              }));
  
              if (attr.name === 'data-text') {
                var textNode = document.createTextNode(attr.value);
  
                if (node.childNodes.length === 0) {
                  node.appendChild(textNode);
                } else {
                  node.insertBefore(textNode, node.childNodes[0]);
                }
  
                node.removeAttribute('data-text');
              } else if (attr.name === 'data-value') {
                node.value = attr.value;
                node.removeAttribute('data-value');
              }
            }
          }
        }
      }
    }, {
      key: "isForProcessing",
      value: function isForProcessing(attr) {
        return ['data-actions-on-response', 'data-list-to-iterate', 'data-item-name'].indexOf(attr.name) === -1 && /\$\{([^${}]+)\}/g.test(attr.value);
      }
    }, {
      key: "nodeName",
      value: function nodeName(node) {
        if (this.isTemplateWithType(node, 'e-page-with-url')) {
          return 'e-page-with-url';
        } else if (this.isTemplateWithType(node, 'e-if')) {
          return 'e-if';
        } else if (this.isTemplateWithType(node, 'e-for-each')) {
          return 'e-for-each';
        }
  
        return node.nodeName.toLowerCase();
      }
    }, {
      key: "isTemplateWithType",
      value: function isTemplateWithType(node, type) {
        if (node.nodeName.toLowerCase() === type) {
          throw new Error("".concat(type, " must be <template>"));
        }
  
        if (this.isTemplate(node)) {
          var templateType = node.getAttribute('is');
  
          if (templateType) {
            return templateType === type;
          }
  
          return false;
        }
  
        return false;
      }
    }, {
      key: "isTemplate",
      value: function isTemplate(node) {
        return node.nodeName.toLowerCase() === 'template';
      }
    }]);
  
    return MutationObservation;
  }();
  
  new MutationObservation().run();
  
  },{"./E/exports":14}],16:[function(require,module,exports){
  'use strict';
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
  
  function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  
  function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../async-ajax/exports'),
      ResponseFromAjaxRequest = _require.ResponseFromAjaxRequest,
      ResponseBody = _require.ResponseBody;
  
  var _require2 = require('./../async-object/exports'),
      CreatedOptions = _require2.CreatedOptions;
  
  var _require3 = require('./../async-dom/exports'),
      ElementWithInnerHTML = _require3.ElementWithInnerHTML,
      ElementWithAdditionalHTML = _require3.ElementWithAdditionalHTML,
      ElementWithTextContent = _require3.ElementWithTextContent,
      HiddenElements = _require3.HiddenElements,
      ShownElements = _require3.ShownElements,
      DisabledElements = _require3.DisabledElements,
      EnabledElements = _require3.EnabledElements,
      ElementWithMappedObject = _require3.ElementWithMappedObject,
      ElementsWithToggledClass = _require3.ElementsWithToggledClass,
      ElementWithChangedValue = _require3.ElementWithChangedValue,
      ElementWithChangedAttribute = _require3.ElementWithChangedAttribute,
      ParsedElmSelectors = _require3.ParsedElmSelectors,
      RemovedElements = _require3.RemovedElements;
  
  var _require4 = require('./../async-log/exports'),
      Logged = _require4.Logged;
  
  var _require5 = require('./../async-if-else/exports'),
      If = _require5.If;
  
  var _require6 = require('./../async-location/exports'),
      RedirectedLocation = _require6.RedirectedLocation,
      ReloadedLocation = _require6.ReloadedLocation,
      TurboRedirected = _require6.TurboRedirected;
  
  var _require7 = require('./../async-storage/exports'),
      LocalStorageWithSetValue = _require7.LocalStorageWithSetValue,
      SessionStorageWithSetValue = _require7.SessionStorageWithSetValue,
      LocalStorageWithRemovedValue = _require7.LocalStorageWithRemovedValue,
      SessionStorageWithRemovedValue = _require7.SessionStorageWithRemovedValue;
  
  var _require8 = require('./../async-array/exports'),
      First = _require8.First;
  
  var _require9 = require('./../async-uri/exports'),
      EncodedURI = _require9.EncodedURI;
  
  var actions = {
    "if": function _if(statement, action) {
      return new If(statement, action);
    },
    logToConsole: function logToConsole() {
      for (var _len = arguments.length, objs = new Array(_len), _key = 0; _key < _len; _key++) {
        objs[_key] = arguments[_key];
      }
  
      return _construct(Logged, objs);
    },
    mapToTemplate: function mapToTemplate(obj, elmSelector) {
      return new ElementWithMappedObject(new First(new ParsedElmSelectors(elmSelector)), obj);
    },
    redirect: function redirect(url) {
      return new RedirectedLocation(new EncodedURI(url));
    },
    reload: function reload() {
      return new ReloadedLocation();
    },
    turboRedirect: function turboRedirect(href, headers) {
      var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
          progressBarPlace = _ref.progressBarPlace,
          progressBarClassName = _ref.progressBarClassName,
          ajaxFavicon = _ref.ajaxFavicon;
  
      return new TurboRedirected(href, headers, {
        progressBarPlace: progressBarPlace,
        progressBarClassName: progressBarClassName,
        ajaxFavicon: ajaxFavicon
      });
    },
    saveToLocalStorage: function saveToLocalStorage(key, value) {
      return new LocalStorageWithSetValue(localStorage, key, value);
    },
    saveToSessionStorage: function saveToSessionStorage(key, value) {
      return new SessionStorageWithSetValue(sessionStorage, key, value);
    },
    removeFromLocalStorage: function removeFromLocalStorage(key) {
      return new LocalStorageWithRemovedValue(localStorage, key);
    },
    removeFromSessionStorage: function removeFromSessionStorage(key, value) {
      return new SessionStorageWithRemovedValue(sessionStorage, key);
    },
    hideElms: function hideElms() {
      for (var _len2 = arguments.length, elmSelectors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        elmSelectors[_key2] = arguments[_key2];
      }
  
      return new HiddenElements(_construct(ParsedElmSelectors, elmSelectors));
    },
    showElms: function showElms() {
      for (var _len3 = arguments.length, elmSelectors = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        elmSelectors[_key3] = arguments[_key3];
      }
  
      return new ShownElements(_construct(ParsedElmSelectors, elmSelectors));
    },
    disableElms: function disableElms() {
      for (var _len4 = arguments.length, elmSelectors = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        elmSelectors[_key4] = arguments[_key4];
      }
  
      return new DisabledElements(_construct(ParsedElmSelectors, elmSelectors));
    },
    enableElms: function enableElms() {
      for (var _len5 = arguments.length, elmSelectors = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
        elmSelectors[_key5] = arguments[_key5];
      }
  
      return new EnabledElements(_construct(ParsedElmSelectors, elmSelectors));
    },
    removeElms: function removeElms() {
      for (var _len6 = arguments.length, elmSelectors = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
        elmSelectors[_key6] = arguments[_key6];
      }
  
      return new RemovedElements(_construct(ParsedElmSelectors, elmSelectors));
    },
    toggleElms: function toggleElms(className) {
      for (var _len7 = arguments.length, elmSelectors = new Array(_len7 > 1 ? _len7 - 1 : 0), _key7 = 1; _key7 < _len7; _key7++) {
        elmSelectors[_key7 - 1] = arguments[_key7];
      }
  
      return new ElementsWithToggledClass(className, _construct(ParsedElmSelectors, elmSelectors));
    },
    innerHTML: function innerHTML(elmSelector, url, headers) {
      return new ElementWithInnerHTML(new First(new ParsedElmSelectors(elmSelector)), new ResponseBody(new ResponseFromAjaxRequest(new CreatedOptions('url', new EncodedURI(url), 'method', 'GET', 'headers', headers))));
    },
    addHTMLTo: function addHTMLTo(elmSelector, url, headers) {
      return new ElementWithAdditionalHTML(new First(new ParsedElmSelectors(elmSelector)), new ResponseBody(new ResponseFromAjaxRequest(new CreatedOptions('url', new EncodedURI(url), 'method', 'GET', 'headers', headers))));
    },
    textContent: function textContent(elmSelector, url, headers) {
      return new ElementWithTextContent(new First(new ParsedElmSelectors(elmSelector)), new ResponseBody(new ResponseFromAjaxRequest(new CreatedOptions('url', new EncodedURI(url), 'method', 'GET', 'headers', headers))));
    },
    changeValueOf: function changeValueOf(elmSelector, newValue) {
      return new ElementWithChangedValue(new First(new ParsedElmSelectors(elmSelector)), newValue);
    },
    updateAttribute: function updateAttribute(elmSelector, attrName, attrValue) {
      return new ElementWithChangedAttribute(new First(new ParsedElmSelectors(elmSelector)), attrName, attrValue);
    }
  };
  
  var ActionByNameWithParams =
  /*#__PURE__*/
  function () {
    function ActionByNameWithParams(name) {
      _classCallCheck(this, ActionByNameWithParams);
  
      this.name = name;
  
      for (var _len8 = arguments.length, params = new Array(_len8 > 1 ? _len8 - 1 : 0), _key8 = 1; _key8 < _len8; _key8++) {
        params[_key8 - 1] = arguments[_key8];
      }
  
      this.params = params;
    }
  
    _createClass(ActionByNameWithParams, [{
      key: "value",
      value: function value() {
        if (!actions[this.name]) {
          throw new Error("no such action with name \"".concat(this.name, "\""));
        }
  
        return actions[this.name].apply(actions, _toConsumableArray(this.params));
      }
    }]);
  
    return ActionByNameWithParams;
  }();
  
  module.exports = ActionByNameWithParams;
  
  },{"./../async-ajax/exports":27,"./../async-array/exports":29,"./../async-dom/exports":60,"./../async-if-else/exports":66,"./../async-location/exports":74,"./../async-log/exports":76,"./../async-object/exports":79,"./../async-storage/exports":86,"./../async-uri/exports":90}],17:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ParsedActions = require('./ParsedActions');
  
  var BuiltAsyncTreeByParsedActions = require('./BuiltAsyncTreeByParsedActions');
  
  var AppliedActionsOnResponse =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(AppliedActionsOnResponse, _AsyncObject);
  
    function AppliedActionsOnResponse(tagName, resName, res, actions) {
      _classCallCheck(this, AppliedActionsOnResponse);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(AppliedActionsOnResponse).call(this, tagName, resName, res, actions));
    }
  
    _createClass(AppliedActionsOnResponse, [{
      key: "syncCall",
      value: function syncCall() {
        return function (tagName, resName, res, actions) {
          if (!resName) {
            throw new Error("You need to specify attribute \"data-response-name\" in <".concat(tagName, ">"));
          }
  
          new BuiltAsyncTreeByParsedActions(new ParsedActions(actions, tagName, res, resName).value()).value().call();
        };
      }
    }]);
  
    return AppliedActionsOnResponse;
  }(AsyncObject);
  
  module.exports = AppliedActionsOnResponse;
  
  },{"./../cutie/exports":101,"./BuiltAsyncTreeByParsedActions":18,"./ParsedActions":19}],18:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var _require = require('./../async/exports'),
      EmptyAsyncObject = _require.EmptyAsyncObject;
  
  var BuiltAsyncTreeByParsedActions =
  /*#__PURE__*/
  function () {
    function BuiltAsyncTreeByParsedActions(parsedActions) {
      _classCallCheck(this, BuiltAsyncTreeByParsedActions);
  
      this.parsedActions = parsedActions;
    }
  
    _createClass(BuiltAsyncTreeByParsedActions, [{
      key: "value",
      value: function value() {
        if (this.parsedActions.length === 0) {
          return new EmptyAsyncObject();
        }
  
        return this.buildAsyncTree();
      }
    }, {
      key: "buildAsyncTree",
      value: function buildAsyncTree() {
        var curIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
  
        if (this.parsedActions.length === curIndex) {
          return this.parsedActions[0];
        } else {
          this.getLastNext(this.parsedActions[curIndex]).after(this.parsedActions[curIndex + 1]);
          return this.buildAsyncTree(curIndex + 1);
        }
      }
    }, {
      key: "getLastNext",
      value: function getLastNext(parsedAction) {
        if (parsedAction.next) {
          return this.getLastNext(parsedAction.next);
        }
  
        return parsedAction;
      }
    }]);
  
    return BuiltAsyncTreeByParsedActions;
  }();
  
  module.exports = BuiltAsyncTreeByParsedActions;
  
  },{"./../async/exports":92}],19:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  
  function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
  
  function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var ActionByNameWithParams = require('./ActionByNameWithParams');
  
  var ParsedActions =
  /*#__PURE__*/
  function () {
    function ParsedActions(actions, tagName, resObj, resName) {
      _classCallCheck(this, ParsedActions);
  
      // act1(p1, p2); act(q1, q2); ...
      this.actions = actions;
      this.tagName = tagName;
      this.resObj = resObj;
      this.resName = resName;
    }
  
    _createClass(ParsedActions, [{
      key: "value",
      value: function value() {
        var _this = this;
  
        var parsedActions = {};
  
        if (!this.actions) {
          return {
            length: 0
          };
        }
  
        var splittedActions = this.actions.split(';').map(function (action) {
          return action.trim();
        }).filter(function (action) {
          return action.length !== 0;
        });
        splittedActions.forEach(function (action, index) {
          var executedIfStatement = /if([\s]+)?(\(.+\))([\s]+)/.exec(action);
          var ifStatement;
  
          if (executedIfStatement) {
            ifStatement = executedIfStatement[0];
            action = action.replace(ifStatement, '');
          }
  
          var actionName = _this.expressionName(action);
  
          var actionParams = _this.expressionParams(action, actionName);
  
          var parsedAction;
  
          if (ifStatement) {
            var ifStatementName = _this.expressionName(ifStatement);
  
            var ifStatementParam = _this.expressionParams(ifStatement, ifStatementName)[0];
  
            parsedAction = new ActionByNameWithParams(ifStatementName, ifStatementParam, _construct(ActionByNameWithParams, [actionName].concat(_toConsumableArray(actionParams))).value()).value();
          } else {
            parsedAction = _construct(ActionByNameWithParams, [actionName].concat(_toConsumableArray(actionParams))).value();
          }
  
          parsedActions[index] = parsedAction;
        });
        parsedActions.length = splittedActions.length;
        return parsedActions;
      }
    }, {
      key: "expressionName",
      value: function expressionName(action) {
        return action.split('(')[0].trim();
      }
    }, {
      key: "expressionParams",
      value: function expressionParams(action, actionName) {
        var params = action.split(actionName)[1]; // eslint-disable-next-line no-eval
  
        return eval("this.funcWithParams".concat(params));
      }
    }, {
      key: "funcWithParams",
      value: function funcWithParams() {
        var _this2 = this;
  
        for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
          params[_key] = arguments[_key];
        }
  
        return params.map(function (param) {
          return _this2.evaluatedParam(param, _this2.resObj, _this2.resName);
        });
      }
    }, {
      key: "evaluatedParam",
      value: function evaluatedParam(param, resObj, resName) {
        if (typeof param === 'string') {
          if (!/\$\{([^${}]+)\}/g.test(param)) {
            return param;
          }
  
          var value = param.replace(/\$\{([^${}]+)\}/g, function (match, p1) {
            // eslint-disable-next-line no-eval
            var value = eval("\n          const ".concat(resName, " = resObj\n          ").concat(match.replace(/^\$\{([^${}]+)\}$/g, function (match, p1) {
              return p1;
            }), "\n        "));
  
            if (_typeof(value) === 'object') {
              return JSON.stringify(value);
            }
  
            return value;
          });
  
          try {
            return JSON.parse(value);
          } catch (err) {
            return value;
          }
        }
  
        if (_typeof(param) === 'object') {
          for (var key in param) {
            param[key] = this.evaluatedParam(param[key], resObj, resName);
          }
  
          return param;
        }
  
        return param;
      }
    }]);
  
    return ParsedActions;
  }();
  
  module.exports = ParsedActions;
  
  },{"./ActionByNameWithParams":16}],20:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    ActionByNameWithParams: require('./ActionByNameWithParams'),
    AppliedActionsOnResponse: require('./AppliedActionsOnResponse'),
    BuiltAsyncTreeByParsedActions: require('./BuiltAsyncTreeByParsedActions'),
    ParsedActions: require('./ParsedActions')
  };
  
  },{"./ActionByNameWithParams":16,"./AppliedActionsOnResponse":17,"./BuiltAsyncTreeByParsedActions":18,"./ParsedActions":19}],21:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var JSResponseByHTTPReponseComponents =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(JSResponseByHTTPReponseComponents, _AsyncObject);
  
    function JSResponseByHTTPReponseComponents(body, headers, statusCode) {
      _classCallCheck(this, JSResponseByHTTPReponseComponents);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(JSResponseByHTTPReponseComponents).call(this, body, headers, statusCode));
    }
  
    _createClass(JSResponseByHTTPReponseComponents, [{
      key: "syncCall",
      value: function syncCall() {
        return function (body, headers, statusCode) {
          return {
            body: body,
            headers: headers,
            statusCode: statusCode
          };
        };
      }
    }]);
  
    return JSResponseByHTTPReponseComponents;
  }(AsyncObject);
  
  module.exports = JSResponseByHTTPReponseComponents;
  
  },{"./../cutie/exports":101}],22:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ResponseBody =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ResponseBody, _AsyncObject);
  
    function ResponseBody(response) {
      _classCallCheck(this, ResponseBody);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ResponseBody).call(this, response));
    }
  
    _createClass(ResponseBody, [{
      key: "syncCall",
      value: function syncCall() {
        return function (response) {
          return response.body;
        };
      }
    }]);
  
    return ResponseBody;
  }(AsyncObject);
  
  module.exports = ResponseBody;
  
  },{"./../cutie/exports":101}],23:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var responseFromAjaxRequest = require('./custom-calls/responseFromAjaxRequest'); // Represented result is {statusCode, headers, body}
  
  
  var ResponseFromAjaxRequest =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ResponseFromAjaxRequest, _AsyncObject);
  
    function ResponseFromAjaxRequest(options, requestBody) {
      _classCallCheck(this, ResponseFromAjaxRequest);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ResponseFromAjaxRequest).call(this, options, requestBody || null));
    }
  
    _createClass(ResponseFromAjaxRequest, [{
      key: "asyncCall",
      value: function asyncCall() {
        return responseFromAjaxRequest;
      }
    }]);
  
    return ResponseFromAjaxRequest;
  }(AsyncObject);
  
  module.exports = ResponseFromAjaxRequest;
  
  },{"./../cutie/exports":101,"./custom-calls/responseFromAjaxRequest":26}],24:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ResponseHeaders =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ResponseHeaders, _AsyncObject);
  
    function ResponseHeaders(response) {
      _classCallCheck(this, ResponseHeaders);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ResponseHeaders).call(this, response));
    }
  
    _createClass(ResponseHeaders, [{
      key: "syncCall",
      value: function syncCall() {
        return function (response) {
          return response.headers;
        };
      }
    }]);
  
    return ResponseHeaders;
  }(AsyncObject);
  
  module.exports = ResponseHeaders;
  
  },{"./../cutie/exports":101}],25:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ResponseStatusCode =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ResponseStatusCode, _AsyncObject);
  
    function ResponseStatusCode(response) {
      _classCallCheck(this, ResponseStatusCode);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ResponseStatusCode).call(this, response));
    }
  
    _createClass(ResponseStatusCode, [{
      key: "syncCall",
      value: function syncCall() {
        return function (response) {
          return response.statusCode;
        };
      }
    }]);
  
    return ResponseStatusCode;
  }(AsyncObject);
  
  module.exports = ResponseStatusCode;
  
  },{"./../cutie/exports":101}],26:[function(require,module,exports){
  "use strict";
  
  // custom call
  // err, {statusCode, headers, body} in callback
  // options: {url, method, headers, mimeType, withCredentials, user, password, timeout, progressEvent, uploadProgressEvent}
  var responseFromAjaxRequest = function responseFromAjaxRequest(options, requestBody, callback) {
    var resObj = {};
    var req = new XMLHttpRequest();
    req.open(options.method, options.url, true, options.user || null, options.password || null);
    req.withCredentials = options.withCredentials || false;
    req.timeout = options.timeout || 0;
  
    if (options.overrideMimeType !== undefined) {
      req.overrideMimeType(options.overrideMimeType);
    }
  
    var headers = options.headers || {};
  
    for (var headerName in headers) {
      req.setRequestHeader(headerName, headers[headerName]);
    }
  
    req.onreadystatechange = function () {
      if (req.readyState === req.DONE) {
        var allHeadersStr = req.getAllResponseHeaders().trim();
        var headerMap = {};
  
        var _headers = allHeadersStr.split(/[\r\n]+/);
  
        _headers.forEach(function (line) {
          var parts = line.split(/:\s*/);
          var header = parts.shift();
          var value = parts.join(': ');
          headerMap[header] = value;
        });
  
        resObj.statusCode = req.status;
        resObj.headers = headerMap;
        resObj.body = req.response;
        callback(null, resObj);
      }
    };
  
    req.addEventListener('progress', options.progressEvent);
    req.upload.addEventListener('progress', options.uploadProgressEvent);
    req.send(requestBody);
  };
  
  module.exports = responseFromAjaxRequest;
  
  },{}],27:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    JSResponseByHTTPReponseComponents: require('./JSResponseByHTTPReponseComponents'),
    ResponseBody: require('./ResponseBody'),
    ResponseFromAjaxRequest: require('./ResponseFromAjaxRequest'),
    ResponseHeaders: require('./ResponseHeaders'),
    ResponseStatusCode: require('./ResponseStatusCode')
  };
  
  },{"./JSResponseByHTTPReponseComponents":21,"./ResponseBody":22,"./ResponseFromAjaxRequest":23,"./ResponseHeaders":24,"./ResponseStatusCode":25}],28:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var First =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(First, _AsyncObject);
  
    function First(array) {
      _classCallCheck(this, First);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(First).call(this, array));
    }
  
    _createClass(First, [{
      key: "syncCall",
      value: function syncCall() {
        return function (array) {
          return array[0] || null;
        };
      }
    }]);
  
    return First;
  }(AsyncObject);
  
  module.exports = First;
  
  },{"./../cutie/exports":101}],29:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    First: require('./First')
  };
  
  },{"./First":28}],30:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var BodyOfDocument =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(BodyOfDocument, _AsyncObject);
  
    function BodyOfDocument(doc) {
      _classCallCheck(this, BodyOfDocument);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(BodyOfDocument).call(this, doc));
    }
  
    _createClass(BodyOfDocument, [{
      key: "syncCall",
      value: function syncCall() {
        return function (doc) {
          if (doc.body) {
            return doc.body;
          }
  
          throw new Error('body element is missing in the html resource');
        };
      }
    }]);
  
    return BodyOfDocument;
  }(AsyncObject);
  
  module.exports = BodyOfDocument;
  
  },{"./../cutie/exports":101}],31:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ChangedPageFavicon =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ChangedPageFavicon, _AsyncObject);
  
    function ChangedPageFavicon(doc, favicon, ajax) {
      _classCallCheck(this, ChangedPageFavicon);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ChangedPageFavicon).call(this, doc, favicon, ajax));
    }
  
    _createClass(ChangedPageFavicon, [{
      key: "syncCall",
      value: function syncCall() {
        return function (doc, favicon, ajax) {
          if (favicon) {
            var oldLink = document.querySelector("link[rel*='icon']");
            var newLink = document.createElement('link');
            newLink.type = ajax ? 'image/gif' : 'image/x-icon';
            newLink.rel = 'shortcut icon';
            newLink.href = favicon;
  
            if (oldLink) {
              document.head.removeChild(oldLink);
            }
  
            document.head.appendChild(newLink);
          }
  
          return favicon;
        };
      }
    }]);
  
    return ChangedPageFavicon;
  }(AsyncObject);
  
  module.exports = ChangedPageFavicon;
  
  },{"./../cutie/exports":101}],32:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ChangedPageTitle =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ChangedPageTitle, _AsyncObject);
  
    function ChangedPageTitle(doc, title) {
      _classCallCheck(this, ChangedPageTitle);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ChangedPageTitle).call(this, doc, title));
    }
  
    _createClass(ChangedPageTitle, [{
      key: "syncCall",
      value: function syncCall() {
        return function (doc, title) {
          doc.title = title;
          return title;
        };
      }
    }]);
  
    return ChangedPageTitle;
  }(AsyncObject);
  
  module.exports = ChangedPageTitle;
  
  },{"./../cutie/exports":101}],33:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../dom/exports'),
      DocumentFragmentWithAttributes = _require.DocumentFragmentWithAttributes;
  
  var _require2 = require('./../cutie/exports'),
      AsyncObject = _require2.AsyncObject;
  
  var CreatedDocumentFragmentWithAttributes =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(CreatedDocumentFragmentWithAttributes, _AsyncObject);
  
    function CreatedDocumentFragmentWithAttributes(fragment, attributes) {
      _classCallCheck(this, CreatedDocumentFragmentWithAttributes);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(CreatedDocumentFragmentWithAttributes).call(this, fragment, attributes));
    }
  
    _createClass(CreatedDocumentFragmentWithAttributes, [{
      key: "syncCall",
      value: function syncCall() {
        return function (fragment, attributes) {
          return new DocumentFragmentWithAttributes(fragment, attributes);
        };
      }
    }]);
  
    return CreatedDocumentFragmentWithAttributes;
  }(AsyncObject);
  
  module.exports = CreatedDocumentFragmentWithAttributes;
  
  },{"./../cutie/exports":101,"./../dom/exports":103}],34:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var DisabledElement =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(DisabledElement, _AsyncObject);
  
    function DisabledElement(elm) {
      _classCallCheck(this, DisabledElement);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(DisabledElement).call(this, elm));
    }
  
    _createClass(DisabledElement, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm) {
          if (elm) {
            elm.setAttribute('disabled', true);
          }
  
          return elm;
        };
      }
    }]);
  
    return DisabledElement;
  }(AsyncObject);
  
  module.exports = DisabledElement;
  
  },{"./../cutie/exports":101}],35:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var DisabledElements =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(DisabledElements, _AsyncObject);
  
    function DisabledElements(elms) {
      _classCallCheck(this, DisabledElements);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(DisabledElements).call(this, elms));
    }
  
    _createClass(DisabledElements, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elms) {
          elms.forEach(function (elm) {
            elm.setAttribute('disabled', true);
          });
        };
      }
    }]);
  
    return DisabledElements;
  }(AsyncObject);
  
  module.exports = DisabledElements;
  
  },{"./../cutie/exports":101}],36:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ElementWithAdditionalHTML =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ElementWithAdditionalHTML, _AsyncObject);
  
    function ElementWithAdditionalHTML(elm, html) {
      _classCallCheck(this, ElementWithAdditionalHTML);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ElementWithAdditionalHTML).call(this, elm, html));
    }
  
    _createClass(ElementWithAdditionalHTML, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm, html) {
          elm.innerHTML += html;
          return elm;
        };
      }
    }]);
  
    return ElementWithAdditionalHTML;
  }(AsyncObject);
  
  module.exports = ElementWithAdditionalHTML;
  
  },{"./../cutie/exports":101}],37:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ElementWithChangedAttribute =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ElementWithChangedAttribute, _AsyncObject);
  
    function ElementWithChangedAttribute(elm, attrName, attrValue) {
      _classCallCheck(this, ElementWithChangedAttribute);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ElementWithChangedAttribute).call(this, elm, attrName, attrValue));
    }
  
    _createClass(ElementWithChangedAttribute, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm, attrName, attrValue) {
          elm.setAttribute(attrName, attrValue);
          return elm;
        };
      }
    }]);
  
    return ElementWithChangedAttribute;
  }(AsyncObject);
  
  module.exports = ElementWithChangedAttribute;
  
  },{"./../cutie/exports":101}],38:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ElementWithChangedValue =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ElementWithChangedValue, _AsyncObject);
  
    function ElementWithChangedValue(elm, newValue) {
      _classCallCheck(this, ElementWithChangedValue);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ElementWithChangedValue).call(this, elm, newValue));
    }
  
    _createClass(ElementWithChangedValue, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm, newValue) {
          elm.value = newValue;
          return elm;
        };
      }
    }]);
  
    return ElementWithChangedValue;
  }(AsyncObject);
  
  module.exports = ElementWithChangedValue;
  
  },{"./../cutie/exports":101}],39:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ElementWithInnerHTML =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ElementWithInnerHTML, _AsyncObject);
  
    function ElementWithInnerHTML(elm, html) {
      _classCallCheck(this, ElementWithInnerHTML);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ElementWithInnerHTML).call(this, elm, html));
    }
  
    _createClass(ElementWithInnerHTML, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm, html) {
          elm.innerHTML = html;
          return elm;
        };
      }
    }]);
  
    return ElementWithInnerHTML;
  }(AsyncObject);
  
  module.exports = ElementWithInnerHTML;
  
  },{"./../cutie/exports":101}],40:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var _require2 = require('./../dom/exports'),
      ElementWithMappedObject = _require2.ElementWithMappedObject;
  
  var AsyncElementWithMappedObject =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(AsyncElementWithMappedObject, _AsyncObject);
  
    function AsyncElementWithMappedObject(element, obj) {
      _classCallCheck(this, AsyncElementWithMappedObject);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(AsyncElementWithMappedObject).call(this, element, obj));
    }
  
    _createClass(AsyncElementWithMappedObject, [{
      key: "syncCall",
      value: function syncCall() {
        return function (element, response) {
          return new ElementWithMappedObject(element, response).value();
        };
      }
    }]);
  
    return AsyncElementWithMappedObject;
  }(AsyncObject);
  
  module.exports = AsyncElementWithMappedObject;
  
  },{"./../cutie/exports":101,"./../dom/exports":103}],41:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ElementWithTextContent =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ElementWithTextContent, _AsyncObject);
  
    function ElementWithTextContent(elm, html) {
      _classCallCheck(this, ElementWithTextContent);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ElementWithTextContent).call(this, elm, html));
    }
  
    _createClass(ElementWithTextContent, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm, html) {
          elm.textContent = html;
          return elm;
        };
      }
    }]);
  
    return ElementWithTextContent;
  }(AsyncObject);
  
  module.exports = ElementWithTextContent;
  
  },{"./../cutie/exports":101}],42:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ElementsWithToggledClass =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ElementsWithToggledClass, _AsyncObject);
  
    function ElementsWithToggledClass(className, elms) {
      _classCallCheck(this, ElementsWithToggledClass);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ElementsWithToggledClass).call(this, className, elms));
    }
  
    _createClass(ElementsWithToggledClass, [{
      key: "syncCall",
      value: function syncCall() {
        return function (className, elms) {
          elms.forEach(function (elm) {
            elm.classList.toggle(className);
          });
          return elms;
        };
      }
    }]);
  
    return ElementsWithToggledClass;
  }(AsyncObject);
  
  module.exports = ElementsWithToggledClass;
  
  },{"./../cutie/exports":101}],43:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var EnabledElement =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(EnabledElement, _AsyncObject);
  
    function EnabledElement(elm) {
      _classCallCheck(this, EnabledElement);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(EnabledElement).call(this, elm));
    }
  
    _createClass(EnabledElement, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm) {
          if (elm) {
            elm.removeAttribute('disabled');
          }
  
          return elm;
        };
      }
    }]);
  
    return EnabledElement;
  }(AsyncObject);
  
  module.exports = EnabledElement;
  
  },{"./../cutie/exports":101}],44:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var EnabledElements =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(EnabledElements, _AsyncObject);
  
    function EnabledElements(elms) {
      _classCallCheck(this, EnabledElements);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(EnabledElements).call(this, elms));
    }
  
    _createClass(EnabledElements, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elms) {
          elms.forEach(function (elm) {
            elm.removeAttribute('disabled');
          });
          return elms;
        };
      }
    }]);
  
    return EnabledElements;
  }(AsyncObject);
  
  module.exports = EnabledElements;
  
  },{"./../cutie/exports":101}],45:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ExtractedDocument =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ExtractedDocument, _AsyncObject);
  
    function ExtractedDocument(html) {
      _classCallCheck(this, ExtractedDocument);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ExtractedDocument).call(this, html));
    }
  
    _createClass(ExtractedDocument, [{
      key: "syncCall",
      value: function syncCall() {
        return function (html) {
          var domparser = new DOMParser();
          return domparser.parseFromString(html, 'text/html');
        };
      }
    }]);
  
    return ExtractedDocument;
  }(AsyncObject);
  
  module.exports = ExtractedDocument;
  
  },{"./../cutie/exports":101}],46:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var FaviconOfDocument =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(FaviconOfDocument, _AsyncObject);
  
    function FaviconOfDocument(doc) {
      _classCallCheck(this, FaviconOfDocument);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(FaviconOfDocument).call(this, doc));
    }
  
    _createClass(FaviconOfDocument, [{
      key: "syncCall",
      value: function syncCall() {
        return function (doc) {
          if (doc.head) {
            var favicon = doc.head.querySelector("link[rel*='icon']");
            return favicon ? favicon.href : null;
          }
  
          return null;
        };
      }
    }]);
  
    return FaviconOfDocument;
  }(AsyncObject);
  
  module.exports = FaviconOfDocument;
  
  },{"./../cutie/exports":101}],47:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var FirstParsedElmSelector =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(FirstParsedElmSelector, _AsyncObject);
  
    function FirstParsedElmSelector(elmSelector) {
      _classCallCheck(this, FirstParsedElmSelector);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(FirstParsedElmSelector).call(this, elmSelector));
    }
  
    _createClass(FirstParsedElmSelector, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elmSelector) {
          return document.querySelector(elmSelector);
        };
      }
    }]);
  
    return FirstParsedElmSelector;
  }(AsyncObject);
  
  module.exports = FirstParsedElmSelector;
  
  },{"./../cutie/exports":101}],48:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var HiddenElement =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(HiddenElement, _AsyncObject);
  
    function HiddenElement(elm) {
      _classCallCheck(this, HiddenElement);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(HiddenElement).call(this, elm));
    }
  
    _createClass(HiddenElement, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm) {
          if (elm) {
            elm.style.display = 'none';
          }
  
          return elm;
        };
      }
    }]);
  
    return HiddenElement;
  }(AsyncObject);
  
  module.exports = HiddenElement;
  
  },{"./../cutie/exports":101}],49:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var HiddenElements =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(HiddenElements, _AsyncObject);
  
    function HiddenElements(elms) {
      _classCallCheck(this, HiddenElements);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(HiddenElements).call(this, elms));
    }
  
    _createClass(HiddenElements, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elms) {
          elms.forEach(function (elm) {
            elm.style.display = 'none';
          });
          return elms;
        };
      }
    }]);
  
    return HiddenElements;
  }(AsyncObject);
  
  module.exports = HiddenElements;
  
  },{"./../cutie/exports":101}],50:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ParsedElmSelectors =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ParsedElmSelectors, _AsyncObject);
  
    function ParsedElmSelectors() {
      var _getPrototypeOf2;
  
      _classCallCheck(this, ParsedElmSelectors);
  
      for (var _len = arguments.length, elmSelectors = new Array(_len), _key = 0; _key < _len; _key++) {
        elmSelectors[_key] = arguments[_key];
      }
  
      return _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ParsedElmSelectors)).call.apply(_getPrototypeOf2, [this].concat(elmSelectors)));
    }
  
    _createClass(ParsedElmSelectors, [{
      key: "syncCall",
      value: function syncCall() {
        return function () {
          var elms = [];
  
          for (var _len2 = arguments.length, elmSelectors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            elmSelectors[_key2] = arguments[_key2];
          }
  
          elmSelectors.forEach(function (elmSelector) {
            if (elmSelector) {
              var elmsToPush = document.querySelectorAll(elmSelector);
  
              for (var i = 0; i < elmsToPush.length; i++) {
                elms.push(elmsToPush[i]);
              }
            }
          });
          return elms;
        };
      }
    }]);
  
    return ParsedElmSelectors;
  }(AsyncObject);
  
  module.exports = ParsedElmSelectors;
  
  },{"./../cutie/exports":101}],51:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var PreparedProgressBar =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(PreparedProgressBar, _AsyncObject);
  
    function PreparedProgressBar(progressBar) {
      _classCallCheck(this, PreparedProgressBar);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(PreparedProgressBar).call(this, progressBar));
    }
  
    _createClass(PreparedProgressBar, [{
      key: "syncCall",
      value: function syncCall() {
        return function (progressBar) {
          if (progressBar) {
            progressBar.max = 100;
            progressBar.value = 0;
            progressBar.style.display = 'none';
            return progressBar;
          }
  
          return null;
        };
      }
    }]);
  
    return PreparedProgressBar;
  }(AsyncObject);
  
  module.exports = PreparedProgressBar;
  
  },{"./../cutie/exports":101}],52:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var PreparedProgressBars =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(PreparedProgressBars, _AsyncObject);
  
    function PreparedProgressBars(progressBars) {
      _classCallCheck(this, PreparedProgressBars);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(PreparedProgressBars).call(this, progressBars));
    }
  
    _createClass(PreparedProgressBars, [{
      key: "syncCall",
      value: function syncCall() {
        return function (progressBars) {
          for (var index = 0; index < progressBars.length; index++) {
            if (progressBars[index]) {
              var progressBar = progressBars[index];
              progressBar.max = 100;
              progressBar.value = 0;
              progressBar.style.display = 'none';
            }
          }
  
          return progressBars;
        };
      }
    }]);
  
    return PreparedProgressBars;
  }(AsyncObject);
  
  module.exports = PreparedProgressBars;
  
  },{"./../cutie/exports":101}],53:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var RemovedElements =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(RemovedElements, _AsyncObject);
  
    function RemovedElements(elms) {
      _classCallCheck(this, RemovedElements);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(RemovedElements).call(this, elms));
    }
  
    _createClass(RemovedElements, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elms) {
          elms.forEach(function (elm) {
            elm.parentNode.removeChild(elm);
          });
          return elms;
        };
      }
    }]);
  
    return RemovedElements;
  }(AsyncObject);
  
  module.exports = RemovedElements;
  
  },{"./../cutie/exports":101}],54:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ReplacedElementWithAnotherOne =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ReplacedElementWithAnotherOne, _AsyncObject);
  
    function ReplacedElementWithAnotherOne(oldElement, newElement) {
      _classCallCheck(this, ReplacedElementWithAnotherOne);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ReplacedElementWithAnotherOne).call(this, oldElement, newElement));
    }
  
    _createClass(ReplacedElementWithAnotherOne, [{
      key: "syncCall",
      value: function syncCall() {
        return function (oldElement, newElement) {
          oldElement.parentNode.replaceChild(newElement, oldElement);
          return newElement;
        };
      }
    }]);
  
    return ReplacedElementWithAnotherOne;
  }(AsyncObject);
  
  module.exports = ReplacedElementWithAnotherOne;
  
  },{"./../cutie/exports":101}],55:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ShownElement =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ShownElement, _AsyncObject);
  
    function ShownElement(elm) {
      _classCallCheck(this, ShownElement);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ShownElement).call(this, elm));
    }
  
    _createClass(ShownElement, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elm) {
          if (elm) {
            elm.style.display = '';
          }
  
          return elm;
        };
      }
    }]);
  
    return ShownElement;
  }(AsyncObject);
  
  module.exports = ShownElement;
  
  },{"./../cutie/exports":101}],56:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ShownElements =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ShownElements, _AsyncObject);
  
    function ShownElements(elms) {
      _classCallCheck(this, ShownElements);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ShownElements).call(this, elms));
    }
  
    _createClass(ShownElements, [{
      key: "syncCall",
      value: function syncCall() {
        return function (elms) {
          elms.forEach(function (elm) {
            elm.style.display = '';
          });
          return elms;
        };
      }
    }]);
  
    return ShownElements;
  }(AsyncObject);
  
  module.exports = ShownElements;
  
  },{"./../cutie/exports":101}],57:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var TitleOfDocument =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(TitleOfDocument, _AsyncObject);
  
    function TitleOfDocument(doc) {
      _classCallCheck(this, TitleOfDocument);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(TitleOfDocument).call(this, doc));
    }
  
    _createClass(TitleOfDocument, [{
      key: "syncCall",
      value: function syncCall() {
        return function (doc) {
          return doc.title;
        };
      }
    }]);
  
    return TitleOfDocument;
  }(AsyncObject);
  
  module.exports = TitleOfDocument;
  
  },{"./../cutie/exports":101}],58:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject; // remove parent without removing childen
  
  
  var UnwrappedChildrenOfParent =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(UnwrappedChildrenOfParent, _AsyncObject);
  
    function UnwrappedChildrenOfParent(parent) {
      _classCallCheck(this, UnwrappedChildrenOfParent);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(UnwrappedChildrenOfParent).call(this, parent));
    }
  
    _createClass(UnwrappedChildrenOfParent, [{
      key: "syncCall",
      value: function syncCall() {
        return function (parent) {
          var docFrag = document.createDocumentFragment();
  
          while (parent.firstChild) {
            var child = parent.removeChild(parent.firstChild);
            docFrag.appendChild(child);
          }
  
          parent.parentNode.replaceChild(docFrag, parent);
          return docFrag;
        };
      }
    }]);
  
    return UnwrappedChildrenOfParent;
  }(AsyncObject);
  
  module.exports = UnwrappedChildrenOfParent;
  
  },{"./../cutie/exports":101}],59:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var UnwrappedTemplate =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(UnwrappedTemplate, _AsyncObject);
  
    function UnwrappedTemplate(template) {
      _classCallCheck(this, UnwrappedTemplate);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(UnwrappedTemplate).call(this, template));
    }
  
    _createClass(UnwrappedTemplate, [{
      key: "syncCall",
      value: function syncCall() {
        return function (template) {
          var fragment = template.content.cloneNode(true);
          template.parentNode.replaceChild(fragment, template);
          return fragment;
        };
      }
    }]);
  
    return UnwrappedTemplate;
  }(AsyncObject);
  
  module.exports = UnwrappedTemplate;
  
  },{"./../cutie/exports":101}],60:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    BodyOfDocument: require('./BodyOfDocument'),
    ChangedPageFavicon: require('./ChangedPageFavicon'),
    ChangedPageTitle: require('./ChangedPageTitle'),
    CreatedDocumentFragmentWithAttributes: require('./CreatedDocumentFragmentWithAttributes'),
    DisabledElement: require('./DisabledElement'),
    DisabledElements: require('./DisabledElements'),
    ElementWithAdditionalHTML: require('./ElementWithAdditionalHTML'),
    ElementWithChangedAttribute: require('./ElementWithChangedAttribute'),
    ElementWithChangedValue: require('./ElementWithChangedValue'),
    ElementWithInnerHTML: require('./ElementWithInnerHTML'),
    ElementWithMappedObject: require('./ElementWithMappedObject'),
    ElementWithTextContent: require('./ElementWithTextContent'),
    ElementsWithToggledClass: require('./ElementsWithToggledClass'),
    EnabledElement: require('./EnabledElement'),
    EnabledElements: require('./EnabledElements'),
    ExtractedDocument: require('./ExtractedDocument'),
    FaviconOfDocument: require('./FaviconOfDocument'),
    FirstParsedElmSelector: require('./FirstParsedElmSelector'),
    HiddenElement: require('./HiddenElement'),
    HiddenElements: require('./HiddenElements'),
    ParsedElmSelectors: require('./ParsedElmSelectors'),
    PreparedProgressBar: require('./PreparedProgressBar'),
    PreparedProgressBars: require('./PreparedProgressBars'),
    RemovedElements: require('./RemovedElements'),
    ReplacedElementWithAnotherOne: require('./ReplacedElementWithAnotherOne'),
    ShownElement: require('./ShownElement'),
    ShownElements: require('./ShownElements'),
    TitleOfDocument: require('./TitleOfDocument'),
    UnwrappedChildrenOfParent: require('./UnwrappedChildrenOfParent'),
    UnwrappedTemplate: require('./UnwrappedTemplate')
  };
  
  },{"./BodyOfDocument":30,"./ChangedPageFavicon":31,"./ChangedPageTitle":32,"./CreatedDocumentFragmentWithAttributes":33,"./DisabledElement":34,"./DisabledElements":35,"./ElementWithAdditionalHTML":36,"./ElementWithChangedAttribute":37,"./ElementWithChangedValue":38,"./ElementWithInnerHTML":39,"./ElementWithMappedObject":40,"./ElementWithTextContent":41,"./ElementsWithToggledClass":42,"./EnabledElement":43,"./EnabledElements":44,"./ExtractedDocument":45,"./FaviconOfDocument":46,"./FirstParsedElmSelector":47,"./HiddenElement":48,"./HiddenElements":49,"./ParsedElmSelectors":50,"./PreparedProgressBar":51,"./PreparedProgressBars":52,"./RemovedElements":53,"./ReplacedElementWithAnotherOne":54,"./ShownElement":55,"./ShownElements":56,"./TitleOfDocument":57,"./UnwrappedChildrenOfParent":58,"./UnwrappedTemplate":59}],61:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var PushedStartStateToHistoryIfNeeded =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(PushedStartStateToHistoryIfNeeded, _AsyncObject);
  
    function PushedStartStateToHistoryIfNeeded(state, href) {
      _classCallCheck(this, PushedStartStateToHistoryIfNeeded);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(PushedStartStateToHistoryIfNeeded).call(this, state, href));
    }
  
    _createClass(PushedStartStateToHistoryIfNeeded, [{
      key: "syncCall",
      value: function syncCall() {
        return function (state, href) {
          if (sessionStorage.getItem('isFirstStatePushedToHistory') === 'false') {
            history.replaceState(state, null, href);
            sessionStorage.setItem('isFirstStatePushedToHistory', 'true');
          }
  
          return state;
        };
      }
    }]);
  
    return PushedStartStateToHistoryIfNeeded;
  }(AsyncObject);
  
  module.exports = PushedStartStateToHistoryIfNeeded;
  
  },{"./../cutie/exports":101}],62:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var PushedStateToHistory =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(PushedStateToHistory, _AsyncObject);
  
    function PushedStateToHistory(state, href) {
      _classCallCheck(this, PushedStateToHistory);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(PushedStateToHistory).call(this, state, href));
    }
  
    _createClass(PushedStateToHistory, [{
      key: "syncCall",
      value: function syncCall() {
        return function (state, href) {
          history.pushState(state, null, href);
          return state;
        };
      }
    }]);
  
    return PushedStateToHistory;
  }(AsyncObject);
  
  module.exports = PushedStateToHistory;
  
  },{"./../cutie/exports":101}],63:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    PushedStartStateToHistoryIfNeeded: require('./PushedStartStateToHistoryIfNeeded'),
    PushedStateToHistory: require('./PushedStateToHistory')
  };
  
  },{"./PushedStartStateToHistoryIfNeeded":61,"./PushedStateToHistory":62}],64:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var Else =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(Else, _AsyncObject);
  
    function Else(action) {
      _classCallCheck(this, Else);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(Else).call(this, function () {
        return action;
      }));
    }
  
    _createClass(Else, [{
      key: "syncCall",
      value: function syncCall() {
        var _this = this;
  
        return function (action) {
          var actionTree = action();
  
          _this.propagateCache(actionTree);
  
          actionTree.call();
          return true;
        };
      }
    }]);
  
    return Else;
  }(AsyncObject);
  
  module.exports = Else;
  
  },{"./../cutie/exports":101}],65:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var If =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(If, _AsyncObject);
  
    function If(statement, action, nextStatement) {
      _classCallCheck(this, If);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(If).call(this, statement, function () {
        return action;
      }, nextStatement ? function () {
        return nextStatement;
      } : undefined));
    }
  
    _createClass(If, [{
      key: "syncCall",
      value: function syncCall() {
        var _this = this;
  
        return function (statement, action, nextStatement) {
          if (statement) {
            var actionTree = action();
  
            _this.propagateCache(actionTree);
  
            actionTree.call();
          } else if (nextStatement) {
            var nextStatementTree = nextStatement();
  
            _this.propagateCache(nextStatementTree);
  
            nextStatementTree.call();
          }
  
          return statement;
        };
      }
    }]);
  
    return If;
  }(AsyncObject);
  
  module.exports = If;
  
  },{"./../cutie/exports":101}],66:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    Else: require('./Else'),
    If: require('./If')
  };
  
  },{"./Else":64,"./If":65}],67:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject; // Represented result is json
  
  
  var ParsedJSON =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ParsedJSON, _AsyncObject);
  
    function ParsedJSON(string) {
      _classCallCheck(this, ParsedJSON);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ParsedJSON).call(this, string));
    }
  
    _createClass(ParsedJSON, [{
      key: "syncCall",
      value: function syncCall() {
        return JSON.parse;
      }
    }]);
  
    return ParsedJSON;
  }(AsyncObject);
  
  module.exports = ParsedJSON;
  
  },{"./../cutie/exports":101}],68:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ParsedJSONOrString =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ParsedJSONOrString, _AsyncObject);
  
    function ParsedJSONOrString(string) {
      _classCallCheck(this, ParsedJSONOrString);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ParsedJSONOrString).call(this, string));
    }
  
    _createClass(ParsedJSONOrString, [{
      key: "syncCall",
      value: function syncCall() {
        return function (string) {
          try {
            return JSON.parse(string);
          } catch (error) {
            return string;
          }
        };
      }
    }]);
  
    return ParsedJSONOrString;
  }(AsyncObject);
  
  module.exports = ParsedJSONOrString;
  
  },{"./../cutie/exports":101}],69:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject; // Represented result is string
  
  
  var StringifiedJSON =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(StringifiedJSON, _AsyncObject);
  
    function StringifiedJSON(json) {
      _classCallCheck(this, StringifiedJSON);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(StringifiedJSON).call(this, json));
    }
  
    _createClass(StringifiedJSON, [{
      key: "syncCall",
      value: function syncCall() {
        return JSON.stringify;
      }
    }]);
  
    return StringifiedJSON;
  }(AsyncObject);
  
  module.exports = StringifiedJSON;
  
  },{"./../cutie/exports":101}],70:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    ParsedJSON: require('./ParsedJSON'),
    ParsedJSONOrString: require('./ParsedJSONOrString'),
    StringifiedJSON: require('./StringifiedJSON')
  };
  
  },{"./ParsedJSON":67,"./ParsedJSONOrString":68,"./StringifiedJSON":69}],71:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var RedirectedLocation =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(RedirectedLocation, _AsyncObject);
  
    function RedirectedLocation(url) {
      _classCallCheck(this, RedirectedLocation);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(RedirectedLocation).call(this, url));
    }
  
    _createClass(RedirectedLocation, [{
      key: "syncCall",
      value: function syncCall() {
        return function (url) {
          window.location.href = url;
        };
      }
    }]);
  
    return RedirectedLocation;
  }(AsyncObject);
  
  module.exports = RedirectedLocation;
  
  },{"./../cutie/exports":101}],72:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ReloadedLocation =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ReloadedLocation, _AsyncObject);
  
    function ReloadedLocation() {
      _classCallCheck(this, ReloadedLocation);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ReloadedLocation).call(this));
    }
  
    _createClass(ReloadedLocation, [{
      key: "syncCall",
      value: function syncCall() {
        return function () {
          window.location.reload();
        };
      }
    }]);
  
    return ReloadedLocation;
  }(AsyncObject);
  
  module.exports = ReloadedLocation;
  
  },{"./../cutie/exports":101}],73:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var _require = require('./../cutie/exports'),
      as = _require.as;
  
  var _require2 = require('./../async-string/exports'),
      StringFromBuffer = _require2.StringFromBuffer;
  
  var _require3 = require('./../async-ajax/exports'),
      ResponseFromAjaxRequest = _require3.ResponseFromAjaxRequest,
      ResponseBody = _require3.ResponseBody;
  
  var _require4 = require('./../async-object/exports'),
      CreatedOptions = _require4.CreatedOptions;
  
  var _require5 = require('./../async-dom/exports'),
      ReplacedElementWithAnotherOne = _require5.ReplacedElementWithAnotherOne,
      ExtractedDocument = _require5.ExtractedDocument,
      BodyOfDocument = _require5.BodyOfDocument,
      TitleOfDocument = _require5.TitleOfDocument,
      FaviconOfDocument = _require5.FaviconOfDocument,
      ChangedPageTitle = _require5.ChangedPageTitle,
      ChangedPageFavicon = _require5.ChangedPageFavicon;
  
  var _require6 = require('./../async-history/exports'),
      PushedStartStateToHistoryIfNeeded = _require6.PushedStartStateToHistoryIfNeeded,
      PushedStateToHistory = _require6.PushedStateToHistory;
  
  var _require7 = require('./../events/exports'),
      ShowProgressEvent = _require7.ShowProgressEvent;
  
  var TurboRedirected = function TurboRedirected(href, headers, _ref) {
    var progressBarPlace = _ref.progressBarPlace,
        progressBarClassName = _ref.progressBarClassName,
        ajaxFavicon = _ref.ajaxFavicon;
  
    _classCallCheck(this, TurboRedirected);
  
    var progressBar;
  
    if (progressBarClassName) {
      progressBar = document.createElement('progress');
      progressBar.setAttribute('class', progressBarClassName);
      progressBar.style.display = 'none';
      progressBar.max = 100;
      progressBar.value = 0;
  
      if (progressBarPlace) {
        document.querySelector(progressBarPlace).prepend(progressBar);
      } else {
        document.body.prepend(progressBar);
      }
    }
  
    return new PushedStartStateToHistoryIfNeeded(new CreatedOptions('url', location.href, 'headers', headers), location.href).after(new ChangedPageFavicon(document, ajaxFavicon, true).after(new ExtractedDocument(new StringFromBuffer(new ResponseBody(new ResponseFromAjaxRequest(new CreatedOptions('url', href, 'method', 'GET', 'headers', headers, 'progressEvent', new ShowProgressEvent(progressBar, true)))))).as('DOC').after(new BodyOfDocument(as('DOC')).as('BODY').after(new TitleOfDocument(as('DOC')).as('TITLE').after(new FaviconOfDocument(as('DOC')).as('FAVICON').after(new PushedStateToHistory(new CreatedOptions('url', href, 'headers', headers), href).after(new ReplacedElementWithAnotherOne(document.body, as('BODY')).after(new ChangedPageTitle(document, as('TITLE')).after(new ChangedPageFavicon(document, as('FAVICON')))))))))));
  };
  
  module.exports = TurboRedirected;
  
  },{"./../async-ajax/exports":27,"./../async-dom/exports":60,"./../async-history/exports":63,"./../async-object/exports":79,"./../async-string/exports":88,"./../cutie/exports":101,"./../events/exports":107}],74:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    RedirectedLocation: require('./RedirectedLocation'),
    ReloadedLocation: require('./ReloadedLocation'),
    TurboRedirected: require('./TurboRedirected')
  };
  
  },{"./RedirectedLocation":71,"./ReloadedLocation":72,"./TurboRedirected":73}],75:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var Logged =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(Logged, _AsyncObject);
  
    function Logged() {
      var _getPrototypeOf2;
  
      _classCallCheck(this, Logged);
  
      for (var _len = arguments.length, objs = new Array(_len), _key = 0; _key < _len; _key++) {
        objs[_key] = arguments[_key];
      }
  
      return _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Logged)).call.apply(_getPrototypeOf2, [this].concat(objs)));
    }
  
    _createClass(Logged, [{
      key: "syncCall",
      value: function syncCall() {
        return function () {
          var _console;
  
          for (var _len2 = arguments.length, objs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            objs[_key2] = arguments[_key2];
          }
  
          (_console = console).log.apply(_console, objs);
  
          return objs;
        };
      }
    }]);
  
    return Logged;
  }(AsyncObject);
  
  module.exports = Logged;
  
  },{"./../cutie/exports":101}],76:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    Logged: require('./Logged')
  };
  
  },{"./Logged":75}],77:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject; // Represented result is object
  
  
  var CreatedOptions =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(CreatedOptions, _AsyncObject);
  
    function CreatedOptions() {
      var _getPrototypeOf2;
  
      _classCallCheck(this, CreatedOptions);
  
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      return _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CreatedOptions)).call.apply(_getPrototypeOf2, [this].concat(args)));
    }
  
    _createClass(CreatedOptions, [{
      key: "syncCall",
      value: function syncCall() {
        return function () {
          var options = {};
  
          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
            args[_key2] = arguments[_key2];
          }
  
          if (args.length % 2 !== 0) {
            throw new Error('odd number of parameters for options');
          }
  
          for (var i = 0; i < args.length - 1; i += 2) {
            options[args[i]] = args[i + 1];
          }
  
          return options;
        };
      }
    }]);
  
    return CreatedOptions;
  }(AsyncObject);
  
  module.exports = CreatedOptions;
  
  },{"./../cutie/exports":101}],78:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject; // Represented result is obj
  
  
  var TheSameObjectWithValue =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(TheSameObjectWithValue, _AsyncObject);
  
    function TheSameObjectWithValue(obj, key, value) {
      _classCallCheck(this, TheSameObjectWithValue);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(TheSameObjectWithValue).call(this, obj, key, value));
    }
  
    _createClass(TheSameObjectWithValue, [{
      key: "syncCall",
      value: function syncCall() {
        return function (obj, key, value) {
          obj[key] = value;
          return obj;
        };
      }
    }]);
  
    return TheSameObjectWithValue;
  }(AsyncObject);
  
  module.exports = TheSameObjectWithValue;
  
  },{"./../cutie/exports":101}],79:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    CreatedOptions: require('./CreatedOptions'),
    TheSameObjectWithValue: require('./TheSameObjectWithValue')
  };
  
  },{"./CreatedOptions":77,"./TheSameObjectWithValue":78}],80:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var LocalStorageWithRemovedValue =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(LocalStorageWithRemovedValue, _AsyncObject);
  
    function LocalStorageWithRemovedValue(localStorage, key) {
      _classCallCheck(this, LocalStorageWithRemovedValue);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(LocalStorageWithRemovedValue).call(this, localStorage, key));
    }
  
    _createClass(LocalStorageWithRemovedValue, [{
      key: "syncCall",
      value: function syncCall() {
        return function (localStorage, key) {
          localStorage.removeItem(key);
          return localStorage;
        };
      }
    }]);
  
    return LocalStorageWithRemovedValue;
  }(AsyncObject);
  
  module.exports = LocalStorageWithRemovedValue;
  
  },{"./../cutie/exports":101}],81:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var LocalStorageWithSetValue =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(LocalStorageWithSetValue, _AsyncObject);
  
    function LocalStorageWithSetValue(localStorage, key, value) {
      _classCallCheck(this, LocalStorageWithSetValue);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(LocalStorageWithSetValue).call(this, localStorage, key, value));
    }
  
    _createClass(LocalStorageWithSetValue, [{
      key: "syncCall",
      value: function syncCall() {
        return function (localStorage, key, value) {
          localStorage.setItem(key, value);
          return localStorage;
        };
      }
    }]);
  
    return LocalStorageWithSetValue;
  }(AsyncObject);
  
  module.exports = LocalStorageWithSetValue;
  
  },{"./../cutie/exports":101}],82:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var SessionStorageWithRemovedValue =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(SessionStorageWithRemovedValue, _AsyncObject);
  
    function SessionStorageWithRemovedValue(sessionStorage, key) {
      _classCallCheck(this, SessionStorageWithRemovedValue);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(SessionStorageWithRemovedValue).call(this, sessionStorage, key));
    }
  
    _createClass(SessionStorageWithRemovedValue, [{
      key: "syncCall",
      value: function syncCall() {
        return function (sessionStorage, key) {
          sessionStorage.removeItem(key);
          return sessionStorage;
        };
      }
    }]);
  
    return SessionStorageWithRemovedValue;
  }(AsyncObject);
  
  module.exports = SessionStorageWithRemovedValue;
  
  },{"./../cutie/exports":101}],83:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var SessionStorageWithSetValue =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(SessionStorageWithSetValue, _AsyncObject);
  
    function SessionStorageWithSetValue(sessionStorage, key, value) {
      _classCallCheck(this, SessionStorageWithSetValue);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(SessionStorageWithSetValue).call(this, sessionStorage, key, value));
    }
  
    _createClass(SessionStorageWithSetValue, [{
      key: "syncCall",
      value: function syncCall() {
        return function (sessionStorage, key, value) {
          sessionStorage.setItem(key, value);
          return sessionStorage;
        };
      }
    }]);
  
    return SessionStorageWithSetValue;
  }(AsyncObject);
  
  module.exports = SessionStorageWithSetValue;
  
  },{"./../cutie/exports":101}],84:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ValueFromLocalStorage =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ValueFromLocalStorage, _AsyncObject);
  
    function ValueFromLocalStorage(localStorage, key) {
      _classCallCheck(this, ValueFromLocalStorage);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ValueFromLocalStorage).call(this, localStorage, key));
    }
  
    _createClass(ValueFromLocalStorage, [{
      key: "syncCall",
      value: function syncCall() {
        return function (localStorage, key) {
          return localStorage.getItem(key);
        };
      }
    }]);
  
    return ValueFromLocalStorage;
  }(AsyncObject);
  
  module.exports = ValueFromLocalStorage;
  
  },{"./../cutie/exports":101}],85:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ValueFromSessionStorage =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ValueFromSessionStorage, _AsyncObject);
  
    function ValueFromSessionStorage(sessionStorage, key) {
      _classCallCheck(this, ValueFromSessionStorage);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ValueFromSessionStorage).call(this, sessionStorage, key));
    }
  
    _createClass(ValueFromSessionStorage, [{
      key: "syncCall",
      value: function syncCall() {
        return function (sessionStorage, key) {
          return sessionStorage.getItem(key);
        };
      }
    }]);
  
    return ValueFromSessionStorage;
  }(AsyncObject);
  
  module.exports = ValueFromSessionStorage;
  
  },{"./../cutie/exports":101}],86:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    LocalStorageWithRemovedValue: require('./LocalStorageWithRemovedValue'),
    LocalStorageWithSetValue: require('./LocalStorageWithSetValue'),
    SessionStorageWithRemovedValue: require('./SessionStorageWithRemovedValue'),
    SessionStorageWithSetValue: require('./SessionStorageWithSetValue'),
    ValueFromLocalStorage: require('./ValueFromLocalStorage'),
    ValueFromSessionStorage: require('./ValueFromSessionStorage')
  };
  
  },{"./LocalStorageWithRemovedValue":80,"./LocalStorageWithSetValue":81,"./SessionStorageWithRemovedValue":82,"./SessionStorageWithSetValue":83,"./ValueFromLocalStorage":84,"./ValueFromSessionStorage":85}],87:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject; // Represented result is buffer
  
  
  var StringFromBuffer =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(StringFromBuffer, _AsyncObject);
  
    function StringFromBuffer(buf, encoding, start, end) {
      _classCallCheck(this, StringFromBuffer);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(StringFromBuffer).call(this, buf, encoding || 'utf8', start || 0, end || buf.length));
    }
  
    _createClass(StringFromBuffer, [{
      key: "syncCall",
      value: function syncCall() {
        return function (buf, encoding, start, end) {
          return buf.toString(encoding, start, end);
        };
      }
    }]);
  
    return StringFromBuffer;
  }(AsyncObject);
  
  module.exports = StringFromBuffer;
  
  },{"./../cutie/exports":101}],88:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    StringFromBuffer: require('./StringFromBuffer')
  };
  
  },{"./StringFromBuffer":87}],89:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var EncodedURI =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(EncodedURI, _AsyncObject);
  
    function EncodedURI(url) {
      _classCallCheck(this, EncodedURI);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(EncodedURI).call(this, url));
    }
  
    _createClass(EncodedURI, [{
      key: "syncCall",
      value: function syncCall() {
        return function (url) {
          return encodeURI(url);
        };
      }
    }]);
  
    return EncodedURI;
  }(AsyncObject);
  
  module.exports = EncodedURI;
  
  },{"./../cutie/exports":101}],90:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    EncodedURI: require('./EncodedURI')
  };
  
  },{"./EncodedURI":89}],91:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var EmptyAsyncObject =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(EmptyAsyncObject, _AsyncObject);
  
    function EmptyAsyncObject() {
      _classCallCheck(this, EmptyAsyncObject);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(EmptyAsyncObject).call(this));
    }
  
    _createClass(EmptyAsyncObject, [{
      key: "syncCall",
      value: function syncCall() {
        return function () {};
      }
    }]);
  
    return EmptyAsyncObject;
  }(AsyncObject);
  
  module.exports = EmptyAsyncObject;
  
  },{"./../cutie/exports":101}],92:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    EmptyAsyncObject: require('./EmptyAsyncObject')
  };
  
  },{"./EmptyAsyncObject":91}],93:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var AsyncObject = require('./AsyncObject');
  
  var As =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(As, _AsyncObject);
  
    function As(key) {
      _classCallCheck(this, As);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(As).call(this, key));
    }
  
    _createClass(As, [{
      key: "syncCall",
      value: function syncCall() {
        var _this = this;
  
        return function (key) {
          var result = _this.cache[key];
  
          if (result === undefined) {
            throw new Error("There is no value that is cached with key: ".concat(key));
          }
  
          return result;
        };
      }
    }]);
  
    return As;
  }(AsyncObject);
  
  module.exports = function (key) {
    return new As(key);
  };
  
  },{"./AsyncObject":94}],94:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var AsyncTree = require('./AsyncTree');
  /* abstract class */
  
  
  var AsyncObject =
  /*#__PURE__*/
  function () {
    /*
      args: any type (including AsyncObject)
    */
    function AsyncObject() {
      _classCallCheck(this, AsyncObject);
  
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
  
      this.args = args;
      this.cache = {};
      this.next = undefined;
      this.asKey = undefined;
    } // TO BE OVERRIDDEN
  
  
    _createClass(AsyncObject, [{
      key: "asyncCall",
      value: function asyncCall() {
        throw new Error('asyncCall or syncCall must be defined');
      }
    }, {
      key: "syncCall",
      value: function syncCall() {
        throw new Error('asyncCall or syncCall must be defined');
      }
    }, {
      key: "onError",
      value: function onError(error) {
        throw error;
      }
    }, {
      key: "onResult",
      value: function onResult(result) {
        return result;
      }
      /*
        Works only if this.continueAfterFail returns true
          (in that case this.onError and this.onResult will be ignored),
      */
  
    }, {
      key: "onErrorAndResult",
      value: function onErrorAndResult(error, result) {
        return error || result;
      }
      /*
        If it returns true, then this.onError and this.onResult will be ignored,
        and the represented result of this object
        will be returned by this.onErrorAndResult.
      */
  
    }, {
      key: "continueAfterFail",
      value: function continueAfterFail() {
        return false;
      }
    }, {
      key: "callbackWithError",
      value: function callbackWithError() {
        return true;
      } // PUBLIC API
  
    }, {
      key: "call",
      value: function call() {
        this.propagateCache(this);
        new AsyncTree(this).create().call();
      }
    }, {
      key: "after",
      value: function after(asyncObject) {
        this.next = asyncObject;
        return this;
      }
    }, {
      key: "as",
      value: function as(key) {
        this.asKey = key;
        return this;
      } // NOT ALLOWED TO BE OVERRIDDEN
  
    }, {
      key: "iterateArgs",
      value: function iterateArgs(func) {
        var _this = this;
  
        this.args.forEach(function (arg, index) {
          func(arg, index, _this.isAsyncObject(arg), _this.isEvent(arg));
        });
      }
    }, {
      key: "hasNoArgs",
      value: function hasNoArgs() {
        return this.args.length === 0;
      }
    }, {
      key: "readyToBeInvoked",
      value: function readyToBeInvoked(readyResultsNum) {
        return this.args.length === readyResultsNum;
      }
    }, {
      key: "callNextTreeIfExists",
      value: function callNextTreeIfExists() {
        if (this.next) {
          this.propagateCache(this.next);
          new AsyncTree(this.next).create().call();
        }
      }
    }, {
      key: "propagateCache",
      value: function propagateCache(arg) {
        var _this2 = this;
  
        if (this.isAsyncObject(arg)) {
          arg.withCache(this.cache);
          arg.iterateArgs(function (arg) {
            return _this2.propagateCache(arg);
          });
        }
      }
    }, {
      key: "withCache",
      value: function withCache(cache) {
        this.cache = cache;
        return this;
      }
    }, {
      key: "saveValueIntoCacheIfNeeded",
      value: function saveValueIntoCacheIfNeeded(value) {
        if (this.asKey) {
          this.cache[this.asKey] = value;
        }
  
        return this;
      }
    }, {
      key: "isAsyncObject",
      value: function isAsyncObject(arg) {
        return this.classChain(arg).indexOf('AsyncObject') !== -1;
      }
    }, {
      key: "isEvent",
      value: function isEvent(arg) {
        return this.classChain(arg).indexOf('Event') !== -1;
      }
    }, {
      key: "classChain",
      value: function classChain(obj, chain) {
        if (!chain) {
          chain = [];
        }
  
        if (typeof obj === 'function') {
          if (!obj.name || obj === Object) {
            return chain;
          }
  
          return this.classChain(Object.getPrototypeOf(obj), chain.concat(obj.name));
        }
  
        if (_typeof(obj) === 'object' && obj !== null) {
          return this.classChain(obj.constructor, chain);
        }
  
        return chain;
      }
    }]);
  
    return AsyncObject;
  }();
  
  module.exports = AsyncObject;
  
  },{"./AsyncTree":95}],95:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var SimpleTreeNode = require('./SimpleTreeNode');
  
  var AsyncTreeNode = require('./AsyncTreeNode');
  
  var NotDefinedAsyncTreeNode = require('./NotDefinedAsyncTreeNode');
  
  var AsyncTree =
  /*#__PURE__*/
  function () {
    /*
      rootField: AsyncObject
    */
    function AsyncTree(rootField) {
      _classCallCheck(this, AsyncTree);
  
      this.rootField = rootField;
      this.nodes = [];
    } // PUBLIC
  
  
    _createClass(AsyncTree, [{
      key: "create",
      value: function create() {
        this.createAsyncTreeNode(this.rootField, new NotDefinedAsyncTreeNode(), 0);
        return this;
      }
    }, {
      key: "call",
      value: function call() {
        var leaves = this.nodes.filter(function (node) {
          return node.isLeaf();
        });
        leaves.forEach(function (leaf) {
          leaf.call();
        });
      } // PRIVATE
  
    }, {
      key: "createChildNodes",
      value: function createChildNodes(field, parent) {
        var _this = this;
  
        field.iterateArgs(function (argAsField, index, isAsyncObject, isEvent) {
          if (isAsyncObject) {
            _this.createAsyncTreeNode(argAsField, parent, index);
          } else if (isEvent) {
            _this.createSimpleTreeNode(function () {
              argAsField.body.apply(argAsField, arguments);
            }, parent, index);
          } else {
            _this.createSimpleTreeNode(argAsField, parent, index);
          }
        });
      }
    }, {
      key: "createAsyncTreeNode",
      value: function createAsyncTreeNode(field, parent, index) {
        var asyncTreeNode = new AsyncTreeNode(field, parent, index);
        this.nodes.push(asyncTreeNode);
        this.createChildNodes(field, asyncTreeNode);
      }
    }, {
      key: "createSimpleTreeNode",
      value: function createSimpleTreeNode(field, parent, index) {
        var treeNode = new SimpleTreeNode(field, parent, index);
        this.nodes.push(treeNode);
      }
    }]);
  
    return AsyncTree;
  }();
  
  module.exports = AsyncTree;
  
  },{"./AsyncTreeNode":96,"./NotDefinedAsyncTreeNode":98,"./SimpleTreeNode":99}],96:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
  
  function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
  
  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var TreeNode = require('./TreeNode');
  
  var AsyncTreeNode =
  /*#__PURE__*/
  function (_TreeNode) {
    _inherits(AsyncTreeNode, _TreeNode);
  
    /*
      field: AsyncObject
      parent: AsyncTreeNode or NotDefinedAsyncTree
      position: int
    */
    function AsyncTreeNode(field, parent, position) {
      var _this;
  
      _classCallCheck(this, AsyncTreeNode);
  
      _this = _possibleConstructorReturn(this, _getPrototypeOf(AsyncTreeNode).call(this, field, parent, position));
      _this.argResults = [];
      _this.readyResultsNum = 0;
      return _this;
    } // PUBLIC
  
  
    _createClass(AsyncTreeNode, [{
      key: "call",
      value: function call() {
        var args = this.argResults;
  
        try {
          var asyncCall = this.field.asyncCall();
  
          if (this.field.callbackWithError()) {
            this.invokeAsyncCallWithError.apply(this, [asyncCall].concat(_toConsumableArray(args)));
          } else {
            this.invokeAsyncCallWithoutError.apply(this, [asyncCall].concat(_toConsumableArray(args)));
          }
        } catch (error) {
          if (error.message !== 'asyncCall or syncCall must be defined') {
            if (this.field.continueAfterFail()) {
              this.field.onErrorAndResult(error);
            } else {
              this.field.onError(error);
            }
          } else {
            var syncCall = this.field.syncCall();
            this.invokeSyncCall.apply(this, [syncCall].concat(_toConsumableArray(args)));
          }
        }
      }
    }, {
      key: "isLeaf",
      value: function isLeaf() {
        return this.field.hasNoArgs();
      }
    }, {
      key: "readyToBeInvoked",
      value: function readyToBeInvoked() {
        return this.field.readyToBeInvoked(this.readyResultsNum);
      }
    }, {
      key: "hasParent",
      value: function hasParent() {
        return this.parent instanceof AsyncTreeNode;
      }
    }, {
      key: "insertArgumentResult",
      value: function insertArgumentResult(position, result) {
        this.argResults[position] = result;
        this.readyResultsNum += 1;
      } // PRIVATE
  
    }, {
      key: "invokeAsyncCallWithError",
      value: function invokeAsyncCallWithError(asyncCall) {
        var _this2 = this;
  
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }
  
        asyncCall.apply(void 0, args.concat([function (error) {
          for (var _len2 = arguments.length, results = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
            results[_key2 - 1] = arguments[_key2];
          }
  
          if (!_this2.processedError.apply(_this2, [error].concat(results))) {
            _this2.processedResult.apply(_this2, results);
          }
        }]));
      }
    }, {
      key: "invokeAsyncCallWithoutError",
      value: function invokeAsyncCallWithoutError(asyncCall) {
        var _this3 = this;
  
        for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
          args[_key3 - 1] = arguments[_key3];
        }
  
        asyncCall.apply(void 0, args.concat([function () {
          _this3.processedResult.apply(_this3, arguments);
        }]));
      }
    }, {
      key: "invokeSyncCall",
      value: function invokeSyncCall(syncCall) {
        try {
          for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
            args[_key4 - 1] = arguments[_key4];
          }
  
          var syncCallResult = syncCall.apply(void 0, args);
          this.processedResult(syncCallResult);
        } catch (error) {
          this.processedError(error);
        }
      }
    }, {
      key: "processedError",
      value: function processedError(error) {
        var isProcessed = false; // It's not possible to get rid of null here :(
  
        if (error != null) {
          if (this.field.continueAfterFail()) {
            var _this$field;
  
            for (var _len5 = arguments.length, results = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
              results[_key5 - 1] = arguments[_key5];
            }
  
            var totalResult = (_this$field = this.field).onErrorAndResult.apply(_this$field, [error].concat(results));
  
            this.field.saveValueIntoCacheIfNeeded(totalResult);
  
            if (this.hasParent()) {
              _get(_getPrototypeOf(AsyncTreeNode.prototype), "callParent", this).call(this, totalResult);
            } else {
              this.field.callNextTreeIfExists();
            }
          } else {
            this.field.onError(error);
          }
  
          isProcessed = true;
        }
  
        return isProcessed;
      }
    }, {
      key: "processedResult",
      value: function processedResult() {
        var totalResult;
  
        for (var _len6 = arguments.length, results = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
          results[_key6] = arguments[_key6];
        }
  
        if (this.field.continueAfterFail()) {
          var _this$field2;
  
          totalResult = (_this$field2 = this.field).onErrorAndResult.apply(_this$field2, [null].concat(results));
        } else {
          var _this$field3;
  
          totalResult = (_this$field3 = this.field).onResult.apply(_this$field3, results);
        }
  
        this.field.saveValueIntoCacheIfNeeded(totalResult);
  
        if (this.hasParent()) {
          _get(_getPrototypeOf(AsyncTreeNode.prototype), "callParent", this).call(this, totalResult);
        } else {
          this.field.callNextTreeIfExists();
        }
  
        return true;
      }
    }]);
  
    return AsyncTreeNode;
  }(TreeNode);
  
  module.exports = AsyncTreeNode;
  
  },{"./TreeNode":100}],97:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var Event =
  /*#__PURE__*/
  function () {
    function Event() {
      _classCallCheck(this, Event);
    } // TO BE OVERRIDDEN
  
  
    _createClass(Event, [{
      key: "body",
      value: function body() {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
  
        throw new Error("Method body must be overriden with arguments ".concat(args, " of the event/eventListener you call"));
      }
    }]);
  
    return Event;
  }();
  
  module.exports = Event;
  
  },{}],98:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var NotDefinedAsyncTreeNode = function NotDefinedAsyncTreeNode() {
    _classCallCheck(this, NotDefinedAsyncTreeNode);
  };
  
  module.exports = NotDefinedAsyncTreeNode;
  
  },{}],99:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
  
  function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var TreeNode = require('./TreeNode');
  
  var SimpleTreeNode =
  /*#__PURE__*/
  function (_TreeNode) {
    _inherits(SimpleTreeNode, _TreeNode);
  
    /*
      field: simple argument (not AsyncObject, can be Event)
      parent: AsyncTreeNode or NotDefinedAsyncTree
      position: int
    */
    function SimpleTreeNode(field, parent, position) {
      _classCallCheck(this, SimpleTreeNode);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(SimpleTreeNode).call(this, field, parent, position));
    } // PUBLIC
  
  
    _createClass(SimpleTreeNode, [{
      key: "call",
      value: function call() {
        _get(_getPrototypeOf(SimpleTreeNode.prototype), "callParent", this).call(this, this.field);
      }
    }, {
      key: "isLeaf",
      value: function isLeaf() {
        return true;
      }
    }]);
  
    return SimpleTreeNode;
  }(TreeNode);
  
  module.exports = SimpleTreeNode;
  
  },{"./TreeNode":100}],100:[function(require,module,exports){
  'use strict';
  /* abstract class */
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var TreeNode =
  /*#__PURE__*/
  function () {
    /*
      field: just some value (argument), also can be Event
      parent: AsyncTreeNode
      position: int
    */
    function TreeNode(field, parent, position) {
      _classCallCheck(this, TreeNode);
  
      this.field = field;
      this.parent = parent;
      this.position = position;
    } // TO BE OVERRIDEN
  
  
    _createClass(TreeNode, [{
      key: "call",
      value: function call(result) {
        result = result || '';
        throw new Error("call must be overridden and insert result ".concat(result, " into parent node"));
      }
    }, {
      key: "isLeaf",
      value: function isLeaf() {
        throw new Error('isLeaf must be overridden');
      } // NOT ALLOWED TO BE OVERRIDDEN
  
    }, {
      key: "callParent",
      value: function callParent(result) {
        this.parent.insertArgumentResult(this.position, result);
  
        if (this.parent.readyToBeInvoked()) {
          this.parent.call();
        }
      }
    }]);
  
    return TreeNode;
  }();
  
  module.exports = TreeNode;
  
  },{}],101:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    AsyncObject: require('./AsyncObject'),
    Event: require('./Event'),
    as: require('./As')
  };
  
  },{"./As":93,"./AsyncObject":94,"./Event":97}],102:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var ElementWithMappedObject =
  /*#__PURE__*/
  function () {
    function ElementWithMappedObject(elm, obj) {
      _classCallCheck(this, ElementWithMappedObject);
  
      this.elm = elm;
      this.obj = obj;
    }
  
    _createClass(ElementWithMappedObject, [{
      key: "value",
      value: function value() {
        if (this.elm == null) {
          throw new Error('Mapping element is not found');
        }
  
        if (!this.isTemplate(this.elm)) {
          throw new Error('Mapping element must be <template>');
        }
  
        var elmContentNode = document.importNode(this.elm.content, true);
        var objName = this.elm.getAttribute('data-object-name');
  
        if (!objName) {
          throw new Error('Mapping element must have attribute "data-object-name"');
        }
  
        var initialization = "const ".concat(objName, " = obj");
        this.map(elmContentNode, this.obj, initialization);
        this.releaseTemplate(elmContentNode);
        return this.elm;
      }
    }, {
      key: "releaseTemplate",
      value: function releaseTemplate(elmContentNode) {
        if (this.isTemplate(this.elm, 'e-reusable')) {
          if (this.elm.hasAttribute('data-prepend-to')) {
            var parentNode = document.querySelector(this.elm.getAttribute('data-prepend-to'));
  
            if (!parentNode) {
              throw new Error('element is not found by the selector in the attribute "data-prepend-to"');
            }
  
            parentNode.prepend(elmContentNode);
          } else if (this.elm.hasAttribute('data-append-to')) {
            var _parentNode = document.querySelector(this.elm.getAttribute('data-append-to'));
  
            if (!_parentNode) {
              throw new Error('element is not found by the selector in the attribute "data-append-to"');
            }
  
            _parentNode.append(elmContentNode);
          } else {
            this.elm.parentNode.insertBefore(elmContentNode, this.elm);
          }
        } else {
          this.elm.parentNode.replaceChild(elmContentNode, this.elm);
        }
      }
    }, {
      key: "map",
      value: function map(elm, obj, initialization) {
        var _this = this;
  
        this.iterateChildNodes(elm, function (node) {
          if (_this.isTemplate(node, 'e-for-each')) {
            _this.activateEForEach(node, obj, initialization);
          } else if (_this.isTemplate(node, 'e-if')) {
            _this.activateEIf(node, obj, initialization);
          } else {
            _this.iterateAttributes(node, function (attr) {
              if (_this.isForProcessing(attr)) {
                node.setAttribute(attr.name, // eslint-disable-next-line no-eval
                _this.appliedExpressionsInString(attr.value, initialization, obj));
              }
  
              if (attr.name === 'data-text') {
                var textNode = document.createTextNode(attr.value);
  
                if (node.childNodes.length === 0) {
                  node.appendChild(textNode);
                } else {
                  node.insertBefore(textNode, node.childNodes[0]);
                }
  
                node.removeAttribute('data-text');
              } else if (attr.name === 'data-value') {
                node.value = attr.value;
                node.removeAttribute('data-value');
              }
            });
          }
        });
      }
    }, {
      key: "iterateChildNodes",
      value: function iterateChildNodes(elm, func) {
        var _this2 = this;
  
        var childNodes = Array.from(elm.childNodes);
        childNodes.forEach(function (node) {
          func(node);
  
          if (node.childNodes.length !== 0) {
            _this2.iterateChildNodes(node, func);
          }
        });
      }
    }, {
      key: "iterateAttributes",
      value: function iterateAttributes(elm, func) {
        if (elm.attributes) {
          var elmAttributes = Array.from(elm.attributes);
          elmAttributes.forEach(function (attr) {
            func(attr);
          });
        }
      }
    }, {
      key: "isForProcessing",
      value: function isForProcessing(attr) {
        return ['data-actions-on-response', 'data-list-to-iterate', 'data-item-name'].indexOf(attr.name) === -1 && /\$\{([^${}]+)\}/g.test(attr.value);
      }
    }, {
      key: "isTemplate",
      value: function isTemplate(node, type) {
        var nodeName = node.nodeName.toLowerCase();
  
        if (!type) {
          return nodeName === 'template';
        }
  
        return nodeName === 'template' && node.getAttribute('is') === type;
      }
    }, {
      key: "activateEIf",
      value: function activateEIf(node, obj, initialization) {
        var toDisplayExpression = node.getAttribute('data-condition-to-display');
  
        if (!toDisplayExpression) {
          throw new Error('e-if must have "data-condition-to-display" attribute');
        }
  
        var toDisplay = this.appliedExpressionsInString(toDisplayExpression, initialization, obj);
  
        if (toDisplay === 'true') {
          var contentNode = document.importNode(node.content, true);
          this.map(contentNode, obj, initialization);
          node.parentNode.insertBefore(contentNode, node);
        }
  
        node.parentNode.removeChild(node);
      }
    }, {
      key: "activateEForEach",
      value: function activateEForEach(node, obj, initialization) {
        var _this3 = this;
  
        var listDefinitionExpression = node.getAttribute('data-list-to-iterate');
        var itemName = node.getAttribute('data-item-name');
  
        if (!listDefinitionExpression) {
          throw new Error('e-for-each must have "data-list-to-iterate" attribute');
        }
  
        if (!itemName) {
          throw new Error('e-for-each must have "data-item-name" attribute');
        }
  
        var listDefinitionExpressionBody = this.getBodyOfExpression(listDefinitionExpression); // eslint-disable-next-line no-eval
  
        var list = eval("\n        ".concat(initialization, "\n        ").concat(listDefinitionExpressionBody, "\n      "));
        var listFragment = document.createDocumentFragment();
        list.forEach(function (item, index) {
          item.index = index + 1;
          var itemInitialization = "\n        ".concat(initialization, "\n        const ").concat(itemName, " = ").concat(listDefinitionExpressionBody, "[").concat(index, "]\n      ");
          var itemContentNode = document.importNode(node.content, true);
  
          _this3.map(itemContentNode, obj, itemInitialization);
  
          listFragment.appendChild(itemContentNode);
        });
        node.parentNode.replaceChild(listFragment, node);
      }
    }, {
      key: "appliedExpressionsInString",
      value: function appliedExpressionsInString(string, initialization, obj) {
        return string.replace(/\$\{([^${}]+)\}/g, function (match, p1) {
          // eslint-disable-next-line no-eval
          var appliedExpression = eval("\n          ".concat(initialization, "\n          ").concat(p1, "\n        "));
  
          if (_typeof(appliedExpression) === 'object') {
            return JSON.stringify(appliedExpression);
          }
  
          return appliedExpression;
        });
      }
    }, {
      key: "getBodyOfExpression",
      value: function getBodyOfExpression(expression) {
        return expression.replace(/^\$\{([^${}]+)\}$/g, function (match, p1) {
          return p1;
        });
      }
    }]);
  
    return ElementWithMappedObject;
  }();
  
  module.exports = ElementWithMappedObject;
  
  },{}],103:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    ElementWithMappedObject: require('./ElementWithMappedObject')
  };
  
  },{"./ElementWithMappedObject":102}],104:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var ShowFileReaderEndEvent = function ShowFileReaderEndEvent(progressBar, filesRead, filesLength) {
    _classCallCheck(this, ShowFileReaderEndEvent);
  
    if (progressBar) {
      return function () {
        filesRead.count += 1;
  
        if (filesRead.count === filesLength) {
          progressBar.style.display = 'none';
        } else {
          progressBar.value = 0;
        }
      };
    }
  
    return function () {};
  };
  
  module.exports = ShowFileReaderEndEvent;
  
  },{}],105:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var ShowFileReaderProgressEvent = function ShowFileReaderProgressEvent(progressBar) {
    _classCallCheck(this, ShowFileReaderProgressEvent);
  
    if (progressBar) {
      return function (event) {
        if (event.lengthComputable) {
          progressBar.style.display = '';
          var percentComplete = parseInt(event.loaded / event.total * 100);
          progressBar.value = percentComplete;
        }
      };
    }
  
    return function () {};
  };
  
  module.exports = ShowFileReaderProgressEvent;
  
  },{}],106:[function(require,module,exports){
  'use strict';
  
  function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./../cutie/exports'),
      AsyncObject = _require.AsyncObject;
  
  var ShowProgressEvent =
  /*#__PURE__*/
  function (_AsyncObject) {
    _inherits(ShowProgressEvent, _AsyncObject);
  
    function ShowProgressEvent(progressBar) {
      var removeProgressBarAfter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
      _classCallCheck(this, ShowProgressEvent);
  
      return _possibleConstructorReturn(this, _getPrototypeOf(ShowProgressEvent).call(this, progressBar, removeProgressBarAfter));
    }
  
    _createClass(ShowProgressEvent, [{
      key: "syncCall",
      value: function syncCall() {
        return function (progressBar, removeProgressBarAfter) {
          if (progressBar) {
            return function (event) {
              if (event.lengthComputable) {
                progressBar.style.display = '';
                var percentComplete = parseInt(event.loaded / event.total * 100);
                progressBar.value = percentComplete;
  
                if (progressBar.value === 100) {
                  if (removeProgressBarAfter) {
                    progressBar.parentNode.removeChild(progressBar);
                  } else {
                    progressBar.style.display = 'none';
                  }
                }
              }
            };
          }
  
          return function () {};
        };
      }
    }]);
  
    return ShowProgressEvent;
  }(AsyncObject);
  
  module.exports = ShowProgressEvent;
  
  },{"./../cutie/exports":101}],107:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    ShowFileReaderEndEvent: require('./ShowFileReaderEndEvent'),
    ShowFileReaderProgressEvent: require('./ShowFileReaderProgressEvent'),
    ShowProgressEvent: require('./ShowProgressEvent')
  };
  
  },{"./ShowFileReaderEndEvent":104,"./ShowFileReaderProgressEvent":105,"./ShowProgressEvent":106}],108:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var FileInfo = function FileInfo(name, size, type, content, lastModifiedDate) {
    _classCallCheck(this, FileInfo);
  
    this.name = name;
    this.size = size;
    this.type = type;
    this.content = content;
    this.lastModifiedDate = lastModifiedDate;
  };
  
  module.exports = FileInfo;
  
  },{}],109:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    FileInfo: require('./FileInfo')
  };
  
  },{"./FileInfo":108}],110:[function(require,module,exports){
  'use strict';
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var StringBuffer =
  /*#__PURE__*/
  function () {
    function StringBuffer() {
      _classCallCheck(this, StringBuffer);
  
      this.strings = [];
    }
  
    _createClass(StringBuffer, [{
      key: "append",
      value: function append(string) {
        this.strings.push(string);
      }
    }, {
      key: "toString",
      value: function toString() {
        return this.strings.join('');
      }
    }]);
  
    return StringBuffer;
  }();
  
  module.exports = StringBuffer;
  
  },{}],111:[function(require,module,exports){
  "use strict";
  
  module.exports = {
    StringBuffer: require('./StringBuffer')
  };
  
  },{"./StringBuffer":110}],112:[function(require,module,exports){
  'use strict';
  
  function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  
  function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  var _require = require('./cutie/exports'),
      as = _require.as;
  
  var _require2 = require('./actions/exports'),
      ActionByNameWithParams = _require2.ActionByNameWithParams;
  
  var _require3 = require('./async-string/exports'),
      StringFromBuffer = _require3.StringFromBuffer;
  
  var _require4 = require('./async-ajax/exports'),
      ResponseFromAjaxRequest = _require4.ResponseFromAjaxRequest,
      ResponseBody = _require4.ResponseBody;
  
  var _require5 = require('./async-object/exports'),
      CreatedOptions = _require5.CreatedOptions;
  
  var _require6 = require('./async-dom/exports'),
      ReplacedElementWithAnotherOne = _require6.ReplacedElementWithAnotherOne,
      ExtractedDocument = _require6.ExtractedDocument,
      BodyOfDocument = _require6.BodyOfDocument,
      TitleOfDocument = _require6.TitleOfDocument,
      FaviconOfDocument = _require6.FaviconOfDocument,
      ChangedPageTitle = _require6.ChangedPageTitle,
      ChangedPageFavicon = _require6.ChangedPageFavicon;
  
  if (!window.customElements) {
    window.stop();
    throw new Error('Your browser does not support custom elements so you cannot use EHTML as it\'s based on them.');
  }
  
  if (!sessionStorage.getItem('isFirstStatePushedToHistory')) {
    sessionStorage.setItem('isFirstStatePushedToHistory', 'false');
  }
  
  var retrievedValue = function retrievedValue(target, value) {
    if (value instanceof Function) {
      return value(target);
    }
  
    return value;
  };
  
  window.onpopstate = function (event) {
    if (event.state) {
      new ExtractedDocument(new StringFromBuffer(new ResponseBody(new ResponseFromAjaxRequest(new CreatedOptions('url', event.state.url, 'method', 'GET', 'headers', event.state.headers))))).as('DOC').after(new ReplacedElementWithAnotherOne(document.body, new BodyOfDocument(as('DOC'))).after(new ChangedPageTitle(document, new TitleOfDocument(as('DOC'))).after(new ChangedPageFavicon(document, new FaviconOfDocument(as('DOC')))))).call();
    }
  };
  
  window.onbeforeunload = function () {
    sessionStorage.removeItem('isFirstStatePushedToHistory');
  };
  
  window.redirect = function (target, url) {
    new ActionByNameWithParams('redirect', retrievedValue(target, url)).value().call();
  };
  
  window.saveToLocalStorage = function (target, key, value) {
    new ActionByNameWithParams('saveToLocalStorage', retrievedValue(target, key), retrievedValue(target, value)).value().call();
  };
  
  window.saveToSessionStorage = function (target, key, value) {
    new ActionByNameWithParams('saveToSessionStorage', retrievedValue(target, key), retrievedValue(target, value)).value().call();
  };
  
  window.hideElms = function () {
    for (var _len = arguments.length, elmSelectors = new Array(_len), _key = 0; _key < _len; _key++) {
      elmSelectors[_key] = arguments[_key];
    }
  
    _construct(ActionByNameWithParams, ['hideElms'].concat(elmSelectors)).value().call();
  };
  
  window.showElms = function () {
    for (var _len2 = arguments.length, elmSelectors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      elmSelectors[_key2] = arguments[_key2];
    }
  
    _construct(ActionByNameWithParams, ['showElms'].concat(elmSelectors)).value().call();
  };
  
  window.disableElms = function () {
    for (var _len3 = arguments.length, elmSelectors = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      elmSelectors[_key3] = arguments[_key3];
    }
  
    _construct(ActionByNameWithParams, ['disableElms'].concat(elmSelectors)).value().call();
  };
  
  window.enableElms = function () {
    for (var _len4 = arguments.length, elmSelectors = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      elmSelectors[_key4] = arguments[_key4];
    }
  
    _construct(ActionByNameWithParams, ['enableElms'].concat(elmSelectors)).value().call();
  };
  
  window.removeElms = function () {
    for (var _len5 = arguments.length, elmSelectors = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
      elmSelectors[_key5] = arguments[_key5];
    }
  
    _construct(ActionByNameWithParams, ['removeElms'].concat(elmSelectors)).value().call();
  };
  
  window.innerHTML = function (target, elm, url, headers) {
    new ActionByNameWithParams('innerHTML', retrievedValue(target, elm), retrievedValue(target, url), retrievedValue(target, headers)).value().call();
  };
  
  window.addHTMLTo = function (target, elm, url, headers) {
    new ActionByNameWithParams('addHTMLTo', retrievedValue(target, elm), retrievedValue(target, url), retrievedValue(target, headers)).value().call();
  };
  
  window.textContent = function (target, elm, url, headers) {
    new ActionByNameWithParams('textContent', retrievedValue(target, elm), retrievedValue(target, url), retrievedValue(target, headers)).value().call();
  };
  
  window.changeValueOf = function (target, elmSelector, newValue) {
    new ActionByNameWithParams('changeValueOf', elmSelector, retrievedValue(target, newValue)).value().call();
  };
  
  window.updateAttribute = function (target, elmSelector, attrName, newValue) {
    new ActionByNameWithParams('updateAttribute', elmSelector, attrName, retrievedValue(target, newValue)).value().call();
  };
  
  window.mapToTemplate = function (target, obj, elmSelector) {
    new ActionByNameWithParams('mapToTemplate', retrievedValue(target, obj), elmSelector).value().call();
  };
  
  window.toggleElms = function (className) {
    for (var _len6 = arguments.length, elmSelectors = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {
      elmSelectors[_key6 - 1] = arguments[_key6];
    }
  
    _construct(ActionByNameWithParams, ['toggleElms', className].concat(elmSelectors)).value().call();
  };
  
  window.turboRedirect = function (target, href) {
    var headers = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  
    var _ref = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {},
        progressBarPlace = _ref.progressBarPlace,
        progressBarClassName = _ref.progressBarClassName,
        ajaxFavicon = _ref.ajaxFavicon;
  
    new ActionByNameWithParams('turboRedirect', retrievedValue(target, href), retrievedValue(target, headers), {
      progressBarPlace: progressBarPlace,
      progressBarClassName: progressBarClassName,
      ajaxFavicon: ajaxFavicon
    }).value().call();
  };
  
  },{"./actions/exports":20,"./async-ajax/exports":27,"./async-dom/exports":60,"./async-object/exports":79,"./async-string/exports":88,"./cutie/exports":101}]},{},[16,17,18,20,19,26,27,21,22,23,24,25,29,28,30,31,32,33,34,35,42,36,37,38,39,40,41,43,44,60,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,63,61,62,64,66,65,70,67,68,69,74,71,72,73,76,75,77,79,78,86,80,81,82,83,84,85,88,87,89,90,91,92,93,94,95,96,97,101,98,99,100,102,103,3,2,4,5,6,7,8,9,10,11,12,13,1,14,107,104,105,106,109,108,15,111,110,112]);
  