UNPKG

oxe/dst/oxe.js

Version:
107 kBJavaScriptView Raw
1/*
  	Name: oxe
  	Version: 5.2.4
  	License: MPL-2.0
  	Author: Alexander Elias
  	Email: alex.steven.elis@gmail.com
  	This Source Code Form is subject to the terms of the Mozilla Public
  	License, v. 2.0. If a copy of the MPL was not distributed with this
  	file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
  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); }
12
13(function (global, factory) {
(typeof exports === "undefined" ? "undefined" : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = global || self, global.Oxe = factory());
15})(this, function () {
'use strict';
17
var Utility = {
  PIPE: /\s?\|\s?/,
  PIPES: /\s?,\s?|\s+/,
  value: function value(element, model) {
    if (!model) throw new Error('Utility.value - requires model argument');
    if (!element) throw new Error('Utility.value - requires element argument');
    var type = this.type(element);
25
    if (type === 'radio' || type === 'checkbox') {
      var name = this.name(element);
      var query = 'input[type="' + type + '"][name="' + name + '"]';
      var form = this.form(element);
      var elements = form ? this.form(element).querySelectorAll(query) : [element];
      var multiple = elements.length > 1;
      var result = multiple ? [] : undefined;
33
      for (var i = 0, l = elements.length; i < l; i++) {
        var child = elements[i];
        var checked = this.checked(child);
        if (!checked) continue;
        var value = this.value(child, model);
39
        if (multiple) {
          result.push(value);
        } else {
          result = value;
          break;
        }
      }
47
      return result;
    } else if (type === 'select-one' || type === 'select-multiple') {
      var _multiple = this.multiple(element);
51
      var options = element.options;
53
      var _result = _multiple ? [] : undefined;
55
      for (var _i = 0, _l = options.length; _i < _l; _i++) {
        var option = options[_i];
        var selected = option.selected;
59
        var _value = this.value(option, model);
61
        var match = this[_multiple ? 'includes' : 'compare'](this.data, _value);
63
        if (selected && !match) {
          if (this.multiple) {
            _result.push(_value);
          } else {
            _result = _value;
          }
        } else if (!selected && match) {
          option.selected = true;
        }
      }
74
      return _result;
    } else {
      var attribute = element.attributes['o-value'];
78
      if (attribute) {
        var values = this.binderValues(attribute.value);
81
        var _value2 = this.getByPath(model, values);
83
        return _value2 || element.value;
      } else {
        return element.value;
      }
    }
  },
  form: function form(element) {
    if (element.form) {
      return element.form;
    } else {
      while (element = element.parentElement) {
        if (element.nodeName === 'FORM' || element.nodeName.indexOf('-FORM') !== -1) {
          return element;
        }
      }
    }
  },
  type: function type(element) {
    if (typeof element.type === 'string') {
      return element.type;
    } else {
      return element.getAttribute('type');
    }
  },
  name: function name(element) {
    if (typeof element.name === 'string') {
      return element.name;
    } else {
      return element.getAttribute('name');
    }
  },
  checked: function checked(element) {
    if (typeof element.checked === 'boolean') {
      return element.checked;
    } else {
      switch (element.getAttribute('checked')) {
        case undefined:
          return false;
122
        case 'true':
          return true;
125
        case null:
          return false;
128
        case '':
          return true;
131
        default:
          return false;
      }
    }
  },
  multiple: function multiple(element) {
    if (typeof element.multiple === 'boolean') {
      return element.multiple;
    } else {
      switch (element.getAttribute('multiple')) {
        case undefined:
          return false;
144
        case 'true':
          return true;
147
        case null:
          return false;
150
        case '':
          return true;
153
        default:
          return false;
      }
    }
  },
  disabled: function disabled(element) {
    if (typeof element.disabled === 'boolean') {
      return element.disabled;
    } else {
      switch (element.getAttribute('disabled')) {
        case undefined:
          return false;
166
        case 'true':
          return true;
169
        case null:
          return false;
172
        case '':
          return true;
175
        default:
          return false;
      }
    }
  },
  index: function index(items, item) {
    for (var i = 0, l = items.length; i < l; i++) {
      if (this.match(items[i], item)) {
        return i;
      }
    }
187
    return -1;
  },
  includes: function includes(items, item) {
    for (var i = 0, l = items.length; i < l; i++) {
      if (this.match(items[i], item)) {
        return true;
      }
    }
196
    return false;
  },
  match: function match(source, target) {
    if (source === target) {
      return true;
    }
203
    if (_typeof(source) !== _typeof(target)) {
      return false;
    }
207
    if (source.constructor !== target.constructor) {
      return false;
    }
211
    if (_typeof(source) !== 'object' || _typeof(target) !== 'object') {
      return source === target;
    }
215
    var sourceKeys = Object.keys(source);
    var targetKeys = Object.keys(target);
218
    if (sourceKeys.length !== targetKeys.length) {
      return false;
    }
222
    for (var i = 0, l = sourceKeys.length; i < l; i++) {
      var name = sourceKeys[i];
225
      if (!this.match(source[name], target[name])) {
        return false;
      }
    }
230
    return true;
  },
  binderNames: function binderNames(data) {
    data = data.split('o-')[1];
    return data ? data.split('-') : [];
  },
  binderValues: function binderValues(data) {
    data = data.split(this.PIPE)[0];
    return data ? data.split('.') : [];
  },
  binderPipes: function binderPipes(data) {
    data = data.split(this.PIPE)[1];
    return data ? data.split(this.PIPES) : [];
  },
  ensureElement: function ensureElement(data) {
    data.query = data.query || '';
    data.scope = data.scope || document.body;
    data.position = data.position || 'beforeend';
    var element = data.scope.querySelector("".concat(data.name).concat(data.query));
250
    if (!element) {
      element = document.createElement(data.name);
      data.scope.insertAdjacentElement(data.position, element);
    }
255
    for (var i = 0, l = data.attributes.length; i < l; i++) {
      var _data$attributes$i = data.attributes[i],
          name = _data$attributes$i.name,
          value = _data$attributes$i.value;
      element.setAttribute(name, value);
    }
262
    return element;
  },
  setByPath: function setByPath(data, path, value) {
    var keys = typeof path === 'string' ? path.split('.') : path;
    var last = keys.length - 1;
268
    for (var i = 0; i < last; i++) {
      var key = keys[i];
271
      if (!(key in data)) {
        if (isNaN(keys[i + 1])) {
          data[key] = {};
        } else {
          data[key] = [];
        }
      }
279
      data = data[key];
    }
282
    return data[keys[last]] = value;
  },
  getByPath: function getByPath(data, path) {
    var keys = typeof path === 'string' ? path.split('.') : path;
    var last = keys.length - 1;
288
    if (keys[last] === '$key' || keys[last] === '$index') {
      return keys[last - 1];
    }
292
    for (var i = 0; i < last; i++) {
      var key = keys[i];
295
      if (key in data === false) {
        return undefined;
      } else {
        data = data[key];
      }
    }
302
    return data[keys[last]];
  },
  clone: function clone(source) {
    if (source === null || source === undefined || source.constructor !== Array && source.constructor !== Object) {
      return source;
    }
309
    var target = source.constructor();
311
    for (var name in source) {
      var descriptor = Object.getOwnPropertyDescriptor(source, name);
314
      if (descriptor) {
        if ('value' in descriptor) {
          descriptor.value = this.clone(descriptor.value);
        }
319
        Object.defineProperty(target, name, descriptor);
      }
    }
323
    return target;
  }
};
var Batcher = {
  reads: [],
  writes: [],
  time: 1000 / 30,
  pending: false,
  setup: function setup(options) {
    options = options || {};
    this.time = options.time || this.time;
  },
  tick: function tick(callback) {
    window.requestAnimationFrame(callback.bind(this, null));
  },
  schedule: function schedule() {
    if (this.pending) return;
    this.pending = true;
    this.tick(this.flush);
  },
  flush: function flush(time) {
    time = time || performance.now();
    var task;
347
    if (this.writes.length === 0) {
      while (task = this.reads.shift()) {
        if (task) {
          task();
        }
353
        if (performance.now() - time > this.time) {
          return this.tick(this.flush);
        }
      }
    }
359
    while (task = this.writes.shift()) {
      if (task) {
        task();
      }
364
      if (performance.now() - time > this.time) {
        return this.tick(this.flush);
      }
    }
369
    if (this.reads.length === 0 && this.writes.length === 0) {
      this.pending = false;
    } else if (performance.now() - time > this.time) {
      this.tick(this.flush);
    } else {
      this.flush(time);
    }
  },
  remove: function remove(tasks, task) {
    var index = tasks.indexOf(task);
    return !!~index && !!tasks.splice(index, 1);
  },
  clear: function clear(task) {
    return this.remove(this.reads, task) || this.remove(this.writes, task);
  },
  batch: function batch(data) {
    var self = this;
    if (!data) return;
    if (!data.read && !data.write) return;
    data.context = data.context || {};
390
    var read = function read() {
      var result;
393
      if (data.read) {
        result = data.read.call(data.context, data.context);
      }
397
      if (data.write && result !== false) {
        var write = data.write.bind(data.context, data.context);
        self.writes.push(write);
      }
    };
403
    self.reads.push(read);
    self.schedule();
  }
};
408
function Piper(binder, data) {
  if (binder.type === 'on') {
    return data;
  }
413
  if (!binder.pipes.length) {
    return data;
  }
417
  var methods = binder.container.methods;
419
  if (!methods) {
    return data;
  }
423
  for (var i = 0, l = binder.pipes.length; i < l; i++) {
    var name = binder.pipes[i];
426
    if (name in methods) {
      var method = methods[name];
429
      if (method && method.constructor === Function) {
        data = methods[name].call(binder.container, data);
      } else {
        console.warn("Oxe.piper - pipe ".concat(name, " invalid type"));
      }
    } else {
      console.warn("Oxe.piper - pipe ".concat(name, " not found"));
    }
  }
439
  return data;
}
442
function Class(binder) {
  return {
    read: function read() {
      this.data = binder.data;
447
      if (binder.names.length > 1) {
        this.name = binder.names.slice(1).join('-');
      }
    },
    write: function write() {
      if (this.name) {
        if (this.data === undefined || this.data === null) {
          binder.target.classList.remove(this.name);
        } else {
          binder.target.classList.toggle(this.name, this.data);
        }
      } else {
        if (this.data === undefined || this.data === null) {
          binder.target.setAttribute('class', '');
        } else {
          binder.target.setAttribute('class', this.data);
        }
      }
    }
  };
}
469
function Default(binder) {
  return {
    read: function read() {
      this.data = binder.data;
474
      if (this.data === undefined || this.data === null) {
        this.data = '';
      } else if (_typeof(this.data) === 'object') {
        this.data = JSON.stringify(this.data);
      } else if (typeof this.data !== 'string') {
        this.data = this.data.toString();
      }
482
      if (this.data === binder.target[binder.type]) {
        return false;
      }
    },
    write: function write() {
      binder.target[binder.type] = this.data;
    }
  };
}
492
function Disable(binder) {
  return {
    read: function read() {
      this.data = binder.data;
497
      if (this.data === binder.target.disabled) {
        return false;
      }
    },
    write: function write() {
      binder.target.disabled = this.data;
    }
  };
}
507
function Each(binder) {
  var self = this;
  var render = {
    read: function read() {
      this.data = binder.data || [];
513
      if (binder.meta.keys === undefined) {
        binder.meta.keys = [];
        binder.meta.pending = false;
        binder.meta.targetLength = 0;
        binder.meta.currentLength = 0;
519
        if (binder.target.firstElementChild) {
          binder.meta.template = binder.target.removeChild(binder.target.firstElementChild);
        } else {
          var element = document.createElement('div');
          var text = document.createTextNode("{{$".concat(binder.names[1], "}}"));
          element.appendChild(text);
          binder.meta.template = element;
        }
      }
529
      binder.meta.keys = Object.keys(this.data);
      binder.meta.targetLength = binder.meta.keys.length;
532
      if (binder.meta.currentLength === binder.meta.targetLength) {
        return false;
      }
    },
    write: function write() {
      if (binder.meta.currentLength === binder.meta.targetLength) {
        binder.meta.pending = false;
        return;
      }
542
      if (binder.meta.currentLength > binder.meta.targetLength) {
        var element = binder.target.lastElementChild;
        binder.target.removeChild(element);
        self.remove(element);
        binder.meta.currentLength--;
      } else if (binder.meta.currentLength < binder.meta.targetLength) {
        var _element = binder.meta.template.cloneNode(true);
550
        var _index = binder.meta.currentLength++;
552
        self.add(_element, {
          index: _index,
          path: binder.path,
          variable: binder.names[1],
          container: binder.container,
          scope: binder.container.scope,
          key: binder.meta.keys[_index]
        });
        binder.target.appendChild(_element);
      }
563
      if (binder.meta.pending && render.read) {
        return;
      } else {
        binder.meta.pending = true;
      }
569
      delete render.read;
      Batcher.batch(render);
    }
  };
  return render;
}
576
function Enable(binder) {
  return {
    read: function read() {
      this.data = !binder.data;
581
      if (this.data === binder.target.disabled) {
        return false;
      }
    },
    write: function write() {
      binder.target.disabled = this.data;
    }
  };
}
591
function Hide(binder) {
  return {
    read: function read() {
      this.data = binder.data;
596
      if (this.data === binder.target.hidden) {
        return false;
      }
    },
    write: function write() {
      binder.target.hidden = this.data;
    }
  };
}
606
function Href(binder) {
  return {
    read: function read() {
      this.data = binder.data || '';
611
      if (this.data === binder.target.href) {
        return false;
      }
    },
    write: function write() {
      binder.target.href = this.data;
    }
  };
}
621
function Html(binder) {
  var self = this;
  return {
    read: function read() {
      this.data = binder.data;
627
      if (this.data === undefined || this.data === null) {
        this.data = '';
      } else if (_typeof(this.data) === 'object') {
        this.data = JSON.stringify(this.data);
      } else if (typeof this.data !== 'string') {
        this.data = String(this.data);
      }
    },
    write: function write() {
      while (binder.target.firstChild) {
        var node = binder.target.removeChild(binder.target.firstChild);
        self.remove(node);
      }
641
      var fragment = document.createDocumentFragment();
      var parser = document.createElement('div');
      parser.innerHTML = this.data;
645
      while (parser.firstElementChild) {
        self.add(parser.firstElementChild, {
          container: binder.container,
          scope: binder.container.scope
        });
        fragment.appendChild(parser.firstElementChild);
      }
653
      binder.target.appendChild(fragment);
    }
  };
}
658
function Label(binder) {
  return {
    read: function read() {
      this.data = binder.data;
663
      if (this.data === undefined || this.data === null) {
        this.data = '';
      } else if (_typeof(this.data) === 'object') {
        this.data = JSON.stringify(this.data);
      } else if (typeof this.data !== 'string') {
        this.data = this.data.toString();
      }
671
      if (this.data === binder.target.getAttribute('label')) {
        return false;
      }
    },
    write: function write() {
      binder.target.setAttribute('label', this.data);
    }
  };
}
681
function On(binder) {
  return {
    read: function read(context) {
      context.data = binder.data;
686
      if (typeof context.data !== 'function') {
        console.warn("Oxe - binder o-on=\"".concat(binder.keys.join('.'), "\" invalid type function required"));
        return;
      }
691
      if (binder.meta.method) {
        binder.target.removeEventListener(binder.names[1], binder.meta.method);
      } else {
        binder.meta.method = function (events) {
          var parameters = [];
697
          for (var i = 0, l = binder.pipes.length; i < l; i++) {
            var keys = binder.pipes[i].split('.');
            var parameter = Utility.getByPath(binder.container.model, keys);
            parameters.push(parameter);
          }
703
          parameters.push(events);
          parameters.push(this);
          Promise.resolve(context.data.bind(binder.container).apply(null, parameters));
        };
      }
709
      binder.target.addEventListener(binder.names[1], binder.meta.method);
    }
  };
}
714
function Read(binder) {
  return {
    read: function read() {
      this.data = binder.data;
719
      if (this.data === binder.target.readOnly) {
        return false;
      }
    },
    write: function write() {
      binder.target.readOnly = this.data;
    }
  };
}
729
function Require(binder) {
  return {
    read: function read() {
      this.data = binder.data;
734
      if (this.data === binder.target.required) {
        return false;
      }
    },
    write: function write() {
      binder.target.required = this.data;
    }
  };
}
744
function Show(binder) {
  return {
    read: function read() {
      this.data = binder.data;
749
      if (!this.data === binder.target.hidden) {
        return false;
      }
    },
    write: function write() {
      binder.target.hidden = !this.data;
    }
  };
}
759
function Style(binder) {
  return {
    read: function read() {
      this.data = binder.data;
764
      if (binder.names.length > 1) {
        this.name = '';
        this.names = binder.names.slice(1);
768
        for (var i = 0, l = this.names.length; i < l; i++) {
          if (i === 0) {
            this.name = this.names[i].toLowerCase();
          } else {
            this.name += this.names[i].charAt(0).toUpperCase() + this.names[i].slice(1).toLowerCase();
          }
        }
      }
    },
    write: function write() {
      if (binder.names.length > 1) {
        if (this.data) {
          binder.target.style[this.name] = this.data;
        } else {
          binder.target.style[this.name] = '';
        }
      } else {
        if (this.data) {
          binder.target.style.cssText = this.data;
        } else {
          binder.target.style.cssText = '';
        }
      }
    }
  };
}
795
function Text(binder) {
  return {
    read: function read() {
      this.data = binder.data;
800
      if (this.data === undefined || this.data === null) {
        this.data = '';
      } else if (_typeof(this.data) === 'object') {
        this.data = JSON.stringify(this.data);
      } else if (typeof this.data !== 'string') {
        this.data = this.data.toString();
      }
808
      if (this.data === binder.target.textContent) {
        return false;
      }
    },
    write: function write() {
      binder.target.textContent = this.data;
    }
  };
}
818
function Value(binder, caller) {
  var self = this;
  var type = binder.target.type;
  if (binder.meta.busy) return;else binder.meta.busy = true;
823
  if (type === 'select-one' || type === 'select-multiple') {
    return {
      read: function read() {
        this.data = binder.data;
        this.model = binder.model;
        this.options = binder.target.options;
        this.multiple = Utility.multiple(binder.target);
831
        if (this.multiple && (!this.data || this.data.constructor !== Array)) {
          binder.meta.busy = false;
          throw new Error("Oxe - invalid o-value ".concat(binder.keys.join('.'), " multiple select requires array"));
        }
      },
      write: function write() {
        var fallback = false;
        var fallbackSelectedAtrribute = false;
        var fallbackValue = this.multiple ? [] : null;
        var fallbackOption = this.multiple ? [] : null;
842
        for (var i = 0, l = this.options.length; i < l; i++) {
          var option = this.options[i];
          var selected = option.selected;
          var optionBinder = self.get('attribute', option, 'o-value');
          var optionValue = optionBinder ? optionBinder.data : option.value;
          var selectedAtrribute = option.hasAttribute('selected');
849
          if (this.multiple) {
            if (selectedAtrribute) {
              fallback = true;
              fallbackOption.push(option);
              fallbackValue.push(optionValue);
            }
          } else {
            if (i === 0 || selectedAtrribute) {
              fallback = true;
              fallbackOption = option;
              fallbackValue = optionValue;
              fallbackSelectedAtrribute = selectedAtrribute;
            }
          }
864
          if (caller === 'view') {
            if (selected) {
              if (this.multiple) {
                var includes = Utility.includes(this.data, optionValue);
869
                if (!includes) {
                  this.selected = true;
                  binder.data.push(optionValue);
                }
              } else if (!this.selected) {
                this.selected = true;
                binder.data = optionValue;
              }
            } else {
              if (this.multiple) {
                var _index2 = Utility.index(this.data, optionValue);
881
                if (_index2 !== -1) {
                  binder.data.splice(_index2, 1);
                }
              } else if (!this.selected && i === l - 1) {
                binder.data = null;
              }
            }
          } else {
            if (this.multiple) {
              var _includes = Utility.includes(this.data, optionValue);
892
              if (_includes) {
                this.selected = true;
                option.selected = true;
              } else {
                option.selected = false;
              }
            } else {
              if (!this.selected) {
                var match = Utility.match(this.data, optionValue);
902
                if (match) {
                  this.selected = true;
                  option.selected = true;
                } else {
                  option.selected = false;
                }
              } else {
                option.selected = false;
              }
            }
          }
        }
915
        if (!this.selected && fallback) {
          if (this.multiple) {
            for (var _i2 = 0, _l2 = fallbackOption.length; _i2 < _l2; _i2++) {
              fallbackOption[_i2].selected = true;
              binder.data.push(fallbackValue[_i2]);
            }
          } else if (fallbackSelectedAtrribute || this.nodeName === 'OPTION') {
            binder.data = fallbackValue;
            fallbackOption.selected = true;
          }
        }
927
        binder.meta.busy = false;
      }
    };
  } else if (type === 'radio') {
    return {
      read: function read() {
        this.form = binder.target.form || binder.container;
        this.query = "input[type=\"radio\"][o-value=\"".concat(binder.value, "\"]");
        this.nodes = this.form.querySelectorAll(this.query);
        this.radios = Array.prototype.slice.call(this.nodes);
938
        if (caller === 'view') {
          binder.data = this.radios.indexOf(binder.target);
          binder.meta.busy = false;
          return false;
        }
944
        this.data = binder.data;
946
        if (typeof this.data !== 'number') {
          binder.meta.busy = false;
          return false;
        }
      },
      write: function write() {
        for (var i = 0, l = this.radios.length; i < l; i++) {
          var radio = this.radios[i];
955
          if (i === this.data) {
            radio.checked = true;
          } else {
            radio.checked = false;
          }
        }
962
        binder.meta.busy = false;
      }
    };
  } else if (type === 'checkbox') {
    return {
      read: function read() {
        if (caller === 'view') {
          binder.data = binder.target.checked;
          binder.meta.busy = false;
          return false;
        }
974
        this.data = binder.data;
976
        if (typeof this.data !== 'boolean') {
          binder.meta.busy = false;
          return false;
        }
      },
      write: function write() {
        binder.target.checked = this.data;
        binder.meta.busy = false;
      }
    };
  } else {
    return {
      read: function read() {
        if (caller === 'view') {
          binder.data = binder.target.value;
          binder.meta.busy = false;
          return false;
        }
995
        this.data = binder.data;
997
        if (this.data === binder.target.value) {
          binder.meta.busy = false;
          return false;
        }
      },
      write: function write() {
        binder.target.value = this.data === undefined || this.data === null ? '' : this.data;
        binder.meta.busy = false;
      }
    };
  }
}
1010
function Write(binder) {
  return {
    read: function read() {
      this.data = binder.data;
1015
      if (!this.data === binder.target.readOnly) {
        return false;
      }
    },
    write: function write() {
      binder.target.readOnly = !this.data;
    }
  };
}
1025
var DATA = new Map();
var BINDERS = {
  class: Class,
  css: Style,
  default: Default,
  disable: Disable,
  disabled: Disable,
  each: Each,
  enable: Enable,
  enabled: Enable,
  hide: Hide,
  hidden: Hide,
  href: Href,
  html: Html,
  label: Label,
  on: On,
  read: Read,
  require: Require,
  required: Require,
  show: Show,
  showed: Show,
  style: Style,
  text: Text,
  value: Value,
  write: Write
};
var Binder = {
  get data() {
    return DATA;
  },
1056
  get binders() {
    return BINDERS;
  },
1060
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      options = options || {};
      this.data.set('location', new Map());
      this.data.set('attribute', new Map());
1066
      for (var name in this.binders) {
        this.binders[name] = this.binders[name].bind(this);
      }
1070
      if (options.binders) {
        for (var _name in options.binders) {
          if (_name in this.binders === false) {
            this.binders[_name] = options.binders[_name].bind(this);
          }
        }
      }
1078
      return $return();
    }.bind(this));
  },
  get: function get(type) {
    if (!type) throw new Error('Oxe.binder.get - type argument required');
    var result = this.data.get(type);
    if (!result) return result;
1086
    for (var i = 1, l = arguments.length; i < l; i++) {
      var argument = arguments[i];
      result = result.get(argument);
1090
      if (!result) {
        return result;
      }
    }
1095
    return result;
  },
  create: function create(data) {
    if (data.name === undefined) throw new Error('Oxe.binder.create - missing name');
    if (data.value === undefined) throw new Error('Oxe.binder.create - missing value');
    if (data.target === undefined) throw new Error('Oxe.binder.create - missing target');
    if (data.container === undefined) throw new Error('Oxe.binder.create - missing container');
    var originalValue = data.value;
1104
    if (data.value.slice(0, 2) === '{{' && data.value.slice(-2) === '}}') {
      data.value = data.value.slice(2, -2);
    }
1108
    if (data.value.indexOf('$') !== -1 && data.context && data.context.variable && data.context.path && data.context.key) {
      var pattern = new RegExp("\\$".concat(data.context.variable, "(,|\\s+|\\.|\\|)?(.*)?$"), 'ig');
      data.value = data.value.replace(pattern, "".concat(data.context.path, ".").concat(data.context.key, "$1$2"));
    }
1113
    var scope = data.container.scope;
    var names = data.names || Utility.binderNames(data.name);
    var pipes = data.pipes || Utility.binderPipes(data.value);
    var values = data.values || Utility.binderValues(data.value);
    var type = names[0];
    var path = values.join('.');
    var keys = [scope].concat(values);
    var location = keys.join('.');
    var meta = data.meta || {};
    var context = data.context || {};
    var source = type === 'on' || type === 'submit' ? data.container.methods : data.container.model;
    return {
      get location() {
        return location;
      },
1129
      get type() {
        return type;
      },
1133
      get path() {
        return path;
      },
1137
      get scope() {
        return scope;
      },
1141
      get name() {
        return data.name;
      },
1145
      get value() {
        return data.value;
      },
1149
      get target() {
        return data.target;
      },
1153
      get container() {
        return data.container;
      },
1157
      get model() {
        return data.container.model;
      },
1161
      get methods() {
        return data.container.methods;
      },
1165
      get keys() {
        return keys;
      },
1169
      get names() {
        return names;
      },
1173
      get pipes() {
        return pipes;
      },
1177
      get values() {
        return values;
      },
1181
      get meta() {
        return meta;
      },
1185
      get context() {
        return context;
      },
1189
      get originalValue() {
        return originalValue;
      },
1193
      get data() {
        var data = Utility.getByPath(source, values);
        return Piper(this, data);
      },
1198
      set data(value) {
        var data = Piper(this, value);
        return Utility.setByPath(source, values, data);
      }
1203
    };
  },
  render: function render(binder, caller) {
    if (binder.type === 'submit') return;
    var type = binder.type in this.binders ? binder.type : 'default';
    var render = this.binders[type](binder, caller);
    Batcher.batch(render);
  },
  unbind: function unbind(node) {
    this.data.get('location').forEach(function (scopes) {
      scopes.forEach(function (binders) {
        binders.forEach(function (binder, index) {
          if (binder.target === node) {
            binders.splice(index, 1);
          }
        });
      });
    });
    this.data.get('attribute').delete(node);
  },
  bind: function bind(node, name, value, context) {
    if (value === "$".concat(context.variable, ".$key") || value === "{{$".concat(context.variable, ".$key}}")) {
      return Batcher.batch({
        write: function write() {
          node.textContent = context.key;
        }
      });
    }
1232
    if (value === "$".concat(context.variable, ".$index") || value === "{{$".concat(context.variable, ".$index}}")) {
      return Batcher.batch({
        write: function write() {
          node.textContent = context.index;
        }
      });
    }
1240
    var binder = this.create({
      name: name,
      value: value,
      target: node,
      context: context,
      container: context.container,
      scope: context.container.scope
    });
1249
    if (!this.data.get('attribute').has(binder.target)) {
      this.data.get('attribute').set(binder.target, new Map());
    }
1253
    if (!this.data.get('location').has(binder.scope)) {
      this.data.get('location').set(binder.scope, new Map());
    }
1257
    if (!this.data.get('location').get(binder.scope).has(binder.path)) {
      this.data.get('location').get(binder.scope).set(binder.path, []);
    }
1261
    this.data.get('attribute').get(binder.target).set(binder.name, binder);
    this.data.get('location').get(binder.scope).get(binder.path).push(binder);
    this.render(binder);
  },
  remove: function remove(node) {
    this.unbind(node);
1268
    for (var i = 0; i < node.childNodes.length; i++) {
      this.remove(node.childNodes[i]);
    }
  },
  add: function add(node, context) {
    if (node.nodeType === Node.TEXT_NODE) {
      if (node.textContent.indexOf('{{') === -1 || node.textContent.indexOf('}}') === -1) {
        return;
      }
1278
      var start = node.textContent.indexOf('{{');
1280
      if (start !== -1 && start !== 0) {
        node = node.splitText(start);
      }
1284
      var end = node.textContent.indexOf('}}');
      var length = node.textContent.length;
1287
      if (end !== -1 && end !== length - 2) {
        var split = node.splitText(end + 2);
        this.add(split, context);
      }
1292
      this.bind(node, 'o-text', node.textContent, context);
    } else if (node.nodeType === Node.ELEMENT_NODE) {
      var skipChildren = false;
      var attributes = node.attributes;
1297
      for (var i = 0, l = attributes.length; i < l; i++) {
        var attribute = attributes[i];
1300
        if (attribute.name === 'o-html' || attribute.name === 'o-scope' || attribute.name.indexOf('o-each') === 0) {
          skipChildren = true;
        }
1304
        if (attribute.name === 'o-value' || attribute.name === 'o-scope' || attribute.name === 'o-reset' || attribute.name === 'o-action' || attribute.name === 'o-method' || attribute.name === 'o-enctype' || attribute.name.indexOf('o-') !== 0) {
          continue;
        }
1308
        this.bind(node, attribute.name, attribute.value, context);
      }
1311
      if ('o-value' in attributes) {
        this.bind(node, 'o-value', attributes['o-value'].value, context);
      }
1315
      if (skipChildren) return;
1317
      for (var _i3 = 0; _i3 < node.childNodes.length; _i3++) {
        this.add(node.childNodes[_i3], context);
      }
    }
  }
};
1324
function Change(event) {
  return new Promise(function ($return, $error) {
    if ('attributes' in event.target && 'o-value' in event.target.attributes) {
      var binder = Binder.get('attribute', event.target, 'o-value');
      Binder.render(binder, 'view');
    }
1331
    return $return();
  });
}
1335
var Fetcher = {
  headers: null,
  method: 'get',
  mime: {
    xml: 'text/xml; charset=utf-8',
    html: 'text/html; charset=utf-8',
    text: 'text/plain; charset=utf-8',
    json: 'application/json; charset=utf-8',
    js: 'application/javascript; charset=utf-8'
  },
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      options = options || {};
      this.path = options.path;
      this.origin = options.origin;
      this.request = options.request;
      this.response = options.response;
      this.acceptType = options.acceptType;
      this.credentials = options.credentials;
      this.contentType = options.contentType;
      this.responseType = options.responseType;
      this.method = options.method || this.method;
      this.headers = options.headers || this.headers;
      return $return();
    }.bind(this));
  },
  serialize: function serialize(data) {
    return new Promise(function ($return, $error) {
      var query = '';
1365
      for (var name in data) {
        query = query.length > 0 ? query + '&' : query;
        query = query + encodeURIComponent(name) + '=' + encodeURIComponent(data[name]);
      }
1370
      return $return(query);
    });
  },
  fetch: function fetch(options) {
    return new Promise(function ($return, $error) {
      var data, copy, result, fetched, _copy, _result2;
1377
      data = Object.assign({}, options);
      data.path = data.path || this.path;
      data.origin = data.origin || this.origin;
      if (data.path && typeof data.path === 'string' && data.path.charAt(0) === '/') data.path = data.path.slice(1);
      if (data.origin && typeof data.origin === 'string' && data.origin.charAt(data.origin.length - 1) === '/') data.origin = data.origin.slice(0, -1);
      if (data.path && data.origin && !data.url) data.url = data.origin + '/' + data.path;
      if (!data.method) return $error(new Error('Oxe.fetcher - requires method option'));
      if (!data.url) return $error(new Error('Oxe.fetcher - requires url or origin and path option'));
      if (!data.headers && this.headers) data.headers = this.headers;
      if (typeof data.method === 'string') data.method = data.method.toUpperCase() || this.method;
      if (!data.acceptType && this.acceptType) data.acceptType = this.acceptType;
      if (!data.contentType && this.contentType) data.contentType = this.contentType;
      if (!data.responseType && this.responseType) data.responseType = this.responseType;
      if (!data.credentials && this.credentials) data.credentials = this.credentials;
      if (!data.mode && this.mode) data.mode = this.mode;
      if (!data.cache && this.cache) data.cahce = this.cache;
      if (!data.redirect && this.redirect) data.redirect = this.redirect;
      if (!data.referrer && this.referrer) data.referrer = this.referrer;
      if (!data.referrerPolicy && this.referrerPolicy) data.referrerPolicy = this.referrerPolicy;
      if (!data.signal && this.signal) data.signal = this.signal;
      if (!data.integrity && this.integrity) data.integrity = this.integrity;
      if (!data.keepAlive && this.keepAlive) data.keepAlive = this.keepAlive;
1400
      if (data.contentType) {
        data.headers = data.headers || {};
1403
        switch (data.contentType) {
          case 'js':
            data.headers['Content-Type'] = this.mime.js;
            break;
1408
          case 'xml':
            data.headers['Content-Type'] = this.mime.xml;
            break;
1412
          case 'html':
            data.headers['Content-Type'] = this.mime.html;
            break;
1416
          case 'json':
            data.headers['Content-Type'] = this.mime.json;
            break;
1420
          default:
            data.headers['Content-Type'] = data.contentType;
        }
      }
1425
      if (data.acceptType) {
        data.headers = data.headers || {};
1428
        switch (data.acceptType) {
          case 'js':
            data.headers['Accept'] = this.mime.js;
            break;
1433
          case 'xml':
            data.headers['Accept'] = this.mime.xml;
            break;
1437
          case 'html':
            data.headers['Accept'] = this.mime.html;
            break;
1441
          case 'json':
            data.headers['Accept'] = this.mime.json;
            break;
1445
          default:
            data.headers['Accept'] = data.acceptType;
        }
      }
1450
      if (typeof this.request === 'function') {
        copy = Object.assign({}, data);
        return Promise.resolve(this.request(copy)).then(function ($await_29) {
          try {
            result = $await_29;
1456
            if (result === false) {
              return $return(data);
            }
1460
            if (_typeof(result) === 'object') {
              Object.assign(data, result);
            }
1464
            return $If_1.call(this);
          } catch ($boundEx) {
            return $error($boundEx);
          }
        }.bind(this), $error);
      }
1471
      function $If_1() {
        if (data.body) {
          if (data.method === 'GET') {
            return Promise.resolve(this.serialize(data.body)).then(function ($await_30) {
              try {
                data.url = data.url + '?' + $await_30;
                return $If_5.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          } else {
            if (data.contentType === 'json') {
              data.body = JSON.stringify(data.body);
            }
1487
            return $If_5.call(this);
          }
1490
          function $If_5() {
            return $If_2.call(this);
          }
        }
1495
        function $If_2() {
          return Promise.resolve(window.fetch(data.url, Object.assign({}, data))).then(function ($await_31) {
            try {
              fetched = $await_31;
              data.code = fetched.status;
              data.message = fetched.statusText;
1502
              if (!data.responseType) {
                data.body = fetched.body;
                return $If_3.call(this);
              } else {
                return Promise.resolve(fetched[data.responseType === 'buffer' ? 'arrayBuffer' : data.responseType]()).then(function ($await_32) {
                  try {
                    data.body = $await_32;
                    return $If_3.call(this);
                  } catch ($boundEx) {
                    return $error($boundEx);
                  }
                }.bind(this), $error);
              }
1516
              function $If_3() {
                if (this.response) {
                  _copy = Object.assign({}, data);
                  return Promise.resolve(this.response(_copy)).then(function ($await_33) {
                    try {
                      _result2 = $await_33;
1523
                      if (_result2 === false) {
                        return $return(data);
                      }
1527
                      if (_typeof(_result2) === 'object') {
                        Object.assign(data, _result2);
                      }
1531
                      return $If_4.call(this);
                    } catch ($boundEx) {
                      return $error($boundEx);
                    }
                  }.bind(this), $error);
                }
1538
                function $If_4() {
                  return $return(data);
                }
1542
                return $If_4.call(this);
              }
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }
1550
        return $If_2.call(this);
      }
1553
      return $If_1.call(this);
    }.bind(this));
  },
  post: function post(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'post';
      return $return(this.fetch(data));
    }.bind(this));
  },
  get: function get(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'get';
      return $return(this.fetch(data));
    }.bind(this));
  },
  put: function put(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'put';
      return $return(this.fetch(data));
    }.bind(this));
  },
  head: function head(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'head';
      return $return(this.fetch(data));
    }.bind(this));
  },
  patch: function patch(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'patch';
      return $return(this.fetch(data));
    }.bind(this));
  },
  delete: function _delete(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'delete';
      return $return(this.fetch(data));
    }.bind(this));
  },
  options: function options(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'options';
      return $return(this.fetch(data));
    }.bind(this));
  },
  connect: function connect(data) {
    return new Promise(function ($return, $error) {
      data = typeof data === 'string' ? {
        url: data
      } : data;
      data.method = 'connect';
      return $return(this.fetch(data));
    }.bind(this));
  }
};
1630
function Submit(event) {
  return new Promise(function ($return, $error) {
    var data, elements, i, l, element, type, binder, value, name, submit, options, result;
1634
    if (event.target.hasAttribute('o-submit') === false) {
      return $return();
    }
1638
    event.preventDefault();
    data = {};
    elements = event.target.querySelectorAll('*');
1642
    for (i = 0, l = elements.length; i < l; i++) {
      element = elements[i];
      type = element.type;
1646
      if (!type && name !== 'TEXTAREA' || type === 'submit' || type === 'button' || !type) {
        continue;
      }
1650
      binder = Binder.get('attribute', element, 'o-value');
      value = binder ? binder.data : element.files ? Array.prototype.slice.call(element.files) : element.value;
      name = element.name || (binder ? binder.values[binder.values.length - 1] : null);
      if (!name) continue;
      data[name] = value;
    }
1657
    submit = Binder.get('attribute', event.target, 'o-submit');
    return Promise.resolve(submit.data.call(submit.container, data, event)).then(function ($await_34) {
      try {
        options = $await_34;
1662
        if (_typeof(options) === 'object') {
          options.url = options.url || event.target.getAttribute('o-action');
          options.method = options.method || event.target.getAttribute('o-method');
          options.contentType = options.contentType || event.target.getAttribute('o-enctype');
          return Promise.resolve(Fetcher.fetch(options)).then(function ($await_35) {
            try {
              result = $await_35;
1670
              if (options.handler) {
                return Promise.resolve(options.handler(result)).then(function ($await_36) {
                  try {
                    return $If_7.call(this);
                  } catch ($boundEx) {
                    return $error($boundEx);
                  }
                }.bind(this), $error);
              }
1680
              function $If_7() {
                return $If_6.call(this);
              }
1684
              return $If_7.call(this);
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }
1691
        function $If_6() {
          if (event.target.hasAttribute('o-reset') || _typeof(options) === 'object' && options.reset) {
            event.target.reset();
          }
1696
          return $return();
        }
1699
        return $If_6.call(this);
      } catch ($boundEx) {
        return $error($boundEx);
      }
    }.bind(this), $error);
  });
}
1707
function Input(event) {
  return new Promise(function ($return, $error) {
    if (event.target.type !== 'radio' && event.target.type !== 'option' && event.target.type !== 'checkbox' && event.target.type !== 'select-one' && event.target.type !== 'select-multiple' && 'attributes' in event.target && 'o-value' in event.target.attributes) {
      var binder = Binder.get('attribute', event.target, 'o-value');
      Binder.render(binder, 'view');
    }
1714
    return $return();
  });
}
1718
function Reset(event) {
  return new Promise(function ($return, $error) {
    if (event.target.hasAttribute('o-reset') === false) {
      return $return();
    }
1724
    event.preventDefault();
    var elements = event.target.querySelectorAll('*');
1727
    for (var i = 0, l = elements.length; i < l; i++) {
      var element = elements[i];
      var name = element.nodeName;
      var type = element.type;
1732
      if (!type && name !== 'TEXTAREA' || type === 'submit' || type === 'button' || !type) {
        continue;
      }
1736
      var binder = Binder.get('attribute', element, 'o-value');
1738
      if (!binder) {
        if (type === 'select-one' || type === 'select-multiple') {
          element.selectedIndex = null;
        } else if (type === 'radio' || type === 'checkbox') {
          element.checked = false;
        } else {
          element.value = null;
        }
      } else if (type === 'select-one') {
        binder.data = null;
      } else if (type === 'select-multiple') {
        binder.data = [];
      } else if (type === 'radio' || type === 'checkbox') {
        binder.data = false;
      } else {
        binder.data = '';
      }
    }
1757
    return $return();
  });
}
1761
var DATA$1 = {};
var Methods = {
  get data() {
    return DATA$1;
  },
1767
  get: function get(path) {
    return Utility.getByPath(this.data, path);
  },
  set: function set(path, data) {
    return Utility.setByPath(this.data, path, data);
  }
};
var BASE;
var Path = {
  get base() {
    if (!BASE) BASE = window.document.querySelector('base');
    if (BASE) return BASE.href;
    return window.location.origin + (window.location.pathname ? window.location.pathname : '/');
  },
1782
  setup: function setup(option) {
    return new Promise(function ($return, $error) {
      option = option || {};
1786
      if (option.base) {
        BASE = window.document.querySelector('base');
1789
        if (!BASE) {
          BASE = window.document.createElement('base');
          window.document.head.insertBefore(BASE, window.document.head.firstElementChild);
        }
1794
        BASE.href = option.base;
      }
1797
      return $return();
    });
  },
  extension: function extension(data) {
    var position = data.lastIndexOf('.');
    return position > 0 ? data.slice(position + 1) : '';
  },
  clean: function clean(data) {
    var hash = window.location.hash;
    var search = window.location.search;
    var origin = window.location.origin;
    var protocol = window.location.protocol + '//';
1810
    if (data.slice(0, origin.length) === origin) {
      data = data.slice(origin.length);
    }
1814
    if (data.slice(0, protocol.length) === protocol) {
      data = data.slice(protocol.length);
    }
1818
    if (data.slice(-hash.length) === hash) {
      data = data.slice(0, -hash.length);
    }
1822
    if (data.slice(-search.length) === search) {
      data = data.slice(0, -search.length);
    }
1826
    return data || '/';
  },
  normalize: function normalize(data) {
    var parser = window.document.createElement('a');
    data = this.clean(data);
    data = data.replace(/\/+/g, '/');
    parser.href = data;
    data = parser.pathname;
    data = data ? data : '/';
1836
    if (data !== '/' && data.slice(-1) === '/') {
      data = data.slice(0, -1);
    }
1840
    return data;
  },
  join: function join() {
    if (!arguments.length) {
      throw new Error('Oxe.path.join - argument required');
    }
1847
    var result = [];
1849
    for (var i = 0, l = arguments.length; i < l; i++) {
      result.push(arguments[i]);
    }
1853
    return this.normalize(result.join('/'));
  }
};
var Transformer = {
  innerHandler: function innerHandler(character, index, string) {
    if (string[index - 1] === '\\') return;
    if (character === '\'') return '\\\'';
    if (character === '\"') return '\\"';
    if (character === '\t') return '\\t';
    if (character === '\r') return '\\r';
    if (character === '\n') return '\\n';
    if (character === '\w') return '\\w';
    if (character === '\b') return '\\b';
  },
  updateString: function updateString(value, index, string) {
    return string.slice(0, index) + value + string.slice(index + 1);
  },
  updateIndex: function updateIndex(value, index) {
    return index + value.length - 1;
  },
  template: function template(data) {
    var first = data.indexOf('`');
    var second = data.indexOf('`', first + 1);
    if (first === -1 || second === -1) return data;
    var value;
    var ends = 0;
    var starts = 0;
    var string = data;
    var isInner = false;
1883
    for (var index = 0; index < string.length; index++) {
      var character = string[index];
1886
      if (character === '`' && string[index - 1] !== '\\') {
        if (isInner) {
          ends++;
          value = '\'';
          isInner = false;
          string = this.updateString(value, index, string);
          index = this.updateIndex(value, index);
        } else {
          starts++;
          value = '\'';
          isInner = true;
          string = this.updateString(value, index, string);
          index = this.updateIndex(value, index);
        }
      } else if (isInner) {
        if (value = this.innerHandler(character, index, string)) {
          string = this.updateString(value, index, string);
          index = this.updateIndex(value, index);
        }
      }
    }
1908
    string = string.replace(/\${(.*?)}/g, '\'+$1+\'');
1910
    if (starts === ends) {
      return string;
    } else {
      throw new Error('import transformer missing backtick');
    }
  },
  exp: /export\s+default\s*(var|let|const)?/,
  imps: /import(?:\s+(?:\*\s+as\s+)?\w+\s+from)?\s+(?:'|").*?(?:'|");?\n?/g,
  imp: /import(?:\s+(?:\*\s+as\s+)?(\w+)\s+from)?\s+(?:'|")(.*?)(?:'|");?\n?/,
  module: function module(code, url) {
    var before = 'return Promise.all([\n';
    var after = ']).then(function ($MODULES) {\n';
    var parentImport = url.slice(0, url.lastIndexOf('/') + 1);
    var imps = code.match(this.imps) || [];
1925
    for (var i = 0, l = imps.length; i < l; i++) {
      var imp = imps[i].match(this.imp);
      var rawImport = imp[0];
      var nameImport = imp[1];
      var pathImport = imp[2];
1931
      if (pathImport.slice(0, 1) !== '/') {
        pathImport = Path.normalize(parentImport + '/' + pathImport);
      } else {
        pathImport = Path.normalize(pathImport);
      }
1937
      before = before + '\t$LOADER.load("' + pathImport + '"),\n';
      after = after + 'var ' + nameImport + ' = $MODULES[' + i + '].default;\n';
      code = code.replace(rawImport, '');
    }
1942
    if (this.exp.test(code)) {
      code = code.replace(this.exp, 'var $DEFAULT = ');
      code = code + '\n\nreturn { default: $DEFAULT };\n';
    }
1947
    code = '"use strict";\n' + before + after + code + '}).catch(function (error) { return error; });';
    return code;
  }
};
var Loader = {
  data: {},
  type: 'esm',
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      var self = this;
      options = options || {};
      this.type = options.type || this.type;
1960
      if (options.loads) {
        return $return(Promise.all(options.loads.map(function (load) {
          return self.load(load);
        })));
      }
1966
      return $return();
    }.bind(this));
  },
  fetch: function fetch(url, type) {
    return new Promise(function ($return, $error) {
      var data, code, method, result;
      return Promise.resolve(window.fetch(url)).then(function ($await_37) {
        try {
          data = $await_37;
1976
          if (data.status == 404) {
            return $error(new Error('Oxe.loader.load - not found ' + url));
          }
1980
          if (data.status < 200 || data.status > 300 && data.status != 304) {
            return $error(new Error(data.statusText));
          }
1984
          return Promise.resolve(data.text()).then(function ($await_38) {
            try {
              code = $await_38;
1988
              if (type === 'es' || type === 'est') {
                code = Transformer.template(code);
              }
1992
              if (type === 'es' || type === 'esm') {
                code = Transformer.module(code, url);
              }
1996
              method = new Function('window', 'document', '$LOADER', code);
              return Promise.resolve(method(window, window.document, this)).then(function ($await_39) {
                try {
                  result = $await_39;
2001
                  if (result instanceof Error) {
                    return $error(new result.constructor("".concat(result.message, " - ").concat(url), result.fileName, result.lineNumber));
                  }
2005
                  return $return(this.data[url] = result);
                } catch ($boundEx) {
                  return $error($boundEx);
                }
              }.bind(this), $error);
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        } catch ($boundEx) {
          return $error($boundEx);
        }
      }.bind(this), $error);
    }.bind(this));
  },
  load: function load() {
    var $args = arguments;
    return new Promise(function ($return, $error) {
      var url, type;
2025
      if (_typeof($args[0]) === 'object') {
        url = $args[0]['url'];
        type = $args[0]['type'];
      } else {
        url = $args[0];
        type = $args[1] || this.type;
      }
2033
      if (!url) {
        return $error(new Error('Oxe.loader.load - url argument required'));
      }
2037
      url = Path.normalize(url);
2039
      if (url in this.data === false) {
        this.data[url] = this.fetch(url, type);
      }
2043
      return $return(this.data[url]);
    }.bind(this));
  }
};
var Observer = {
  splice: function splice() {
    var self = this;
    var startIndex = arguments[0];
    var deleteCount = arguments[1];
    var addCount = arguments.length > 2 ? arguments.length - 2 : 0;
2054
    if (typeof startIndex !== 'number' || typeof deleteCount !== 'number') {
      return [];
    }
2058
    if (startIndex < 0) {
      startIndex = self.length + startIndex;
      startIndex = startIndex > 0 ? startIndex : 0;
    } else {
      startIndex = startIndex < self.length ? startIndex : self.length;
    }
2065
    if (deleteCount < 0) {
      deleteCount = 0;
    } else if (deleteCount > self.length - startIndex) {
      deleteCount = self.length - startIndex;
    }
2071
    var totalCount = self.$meta.length;
    var argumentIndex = 2;
    var argumentsCount = arguments.length - argumentIndex;
    var result = self.slice(startIndex, deleteCount);
    var updateCount = totalCount - 1 - startIndex;
    var promises = [];
    var length = self.length + addCount - deleteCount;
2079
    if (self.length !== length) {
      promises.push(self.$meta.listener.bind(null, self, self.$meta.path.slice(0, -1), 'length'));
    }
2083
    if (updateCount > 0) {
      var value;
      var _index3 = startIndex;
2087
      while (updateCount--) {
        var key = _index3++;
2090
        if (argumentsCount && argumentIndex < argumentsCount) {
          value = arguments[argumentIndex++];
        } else {
          value = self.$meta[_index3];
        }
2096
        self.$meta[key] = Observer.create(value, self.$meta.listener, self.$meta.path + key);
        promises.push(self.$meta.listener.bind(null, self.$meta[key], self.$meta.path + key, key));
      }
    }
2101
    if (addCount > 0) {
      while (addCount--) {
        var _key = self.length;
2105
        if (_key in this === false) {
          Object.defineProperty(this, _key, Observer.descriptor(_key));
        }
2109
        self.$meta[_key] = Observer.create(arguments[argumentIndex++], self.$meta.listener, self.$meta.path + _key);
        promises.push(self.$meta.listener.bind(null, self.$meta[_key], self.$meta.path + _key, _key));
      }
    }
2114
    if (deleteCount > 0) {
      while (deleteCount--) {
        self.$meta.length--;
        self.length--;
        var _key2 = self.length;
        promises.push(self.$meta.listener.bind(null, undefined, self.$meta.path + _key2, _key2));
      }
    }
2123
    Promise.resolve().then(function () {
      promises.reduce(function (promise, item) {
        return promise.then(item);
      }, Promise.resolve());
    }).catch(console.error);
    return result;
  },
  arrayProperties: function arrayProperties() {
    var self = this;
    return {
      push: {
        value: function value() {
          if (!arguments.length) return this.length;
2137
          for (var i = 0, l = arguments.length; i < l; i++) {
            self.splice.call(this, this.length, 0, arguments[i]);
          }
2141
          return this.length;
        }
      },
      unshift: {
        value: function value() {
          if (!arguments.length) return this.length;
2148
          for (var i = 0, l = arguments.length; i < l; i++) {
            self.splice.call(this, 0, 0, arguments[i]);
          }
2152
          return this.length;
        }
      },
      pop: {
        value: function value() {
          if (!this.length) return;
          var result = self.splice.call(this, this.length - 1, 1);
          return result[0];
        }
      },
      shift: {
        value: function value() {
          if (!this.length) return;
          var result = self.splice.call(this, 0, 1);
          return result[0];
        }
      },
      splice: {
        value: self.splice
      }
    };
  },
  objectProperties: function objectProperties() {
    var self = this;
    return {
      $get: {
        value: function value(key) {
          return this.$meta[key];
        }
      },
      $set: {
        value: function value(key, _value3) {
          if (_value3 !== this.$meta[key]) {
            if (key in this === false) {
              Object.defineProperty(this, key, self.descriptor(key));
            }
2189
            this.$meta[key] = self.create(_value3, this.$meta.listener, this.$meta.path + key);
            this.$meta.listener(this.$meta[key], this.$meta.path + key, key, this);
          }
        }
      },
      $remove: {
        value: function value(key) {
          if (key in this) {
            if (this.constructor === Array) {
              return self.splice.call(this, key, 1);
            } else {
              var result = this[key];
              delete this.$meta[key];
              delete this[key];
              this.$meta.listener(undefined, this.$meta.path + key, key);
              return result;
            }
          }
        }
      }
    };
  },
  descriptor: function descriptor(key) {
    var self = this;
    return {
      enumerable: true,
      configurable: true,
      get: function get() {
        return this.$meta[key];
      },
      set: function set(value) {
        if (value !== this.$meta[key]) {
          this.$meta[key] = self.create(value, this.$meta.listener, this.$meta.path + key);
          this.$meta.listener(this.$meta[key], this.$meta.path + key, key, this);
        }
      }
    };
  },
  create: function create(source, listener, path) {
    if (!source || source.constructor !== Object && source.constructor !== Array) {
      return source;
    }
2232
    path = path ? path + '.' : '';
    var type = source.constructor;
    var target = source.constructor();
    var descriptors = {};
    descriptors.$meta = {
      value: source.constructor()
    };
    descriptors.$meta.value.path = path;
    descriptors.$meta.value.listener = listener;
2242
    if (type === Array) {
      for (var key = 0, length = source.length; key < length; key++) {
        descriptors.$meta.value[key] = this.create(source[key], listener, path + key);
        descriptors[key] = this.descriptor(key);
      }
    }
2249
    if (type === Object) {
      for (var _key3 in source) {
        descriptors.$meta.value[_key3] = this.create(source[_key3], listener, path + _key3);
        descriptors[_key3] = this.descriptor(_key3);
      }
    }
2256
    Object.defineProperties(target, descriptors);
    Object.defineProperties(target, this.objectProperties(source, listener, path));
2259
    if (type === Array) {
      Object.defineProperties(target, this.arrayProperties(source, listener, path));
    }
2263
    return target;
  }
};
var Model = {
  GET: 2,
  SET: 3,
  REMOVE: 4,
  data: null,
  tasks: [],
  target: {},
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      options = options || {};
      this.target = options.target || this.target;
      this.data = Observer.create(this.target, this.listener.bind(this));
      return $return();
    }.bind(this));
  },
  traverse: function traverse(type, keys, value) {
    var result;
2284
    if (typeof keys === 'string') {
      keys = keys.split('.');
    }
2288
    var data = this.data;
    var key = keys[keys.length - 1];
2291
    for (var i = 0, l = keys.length - 1; i < l; i++) {
      if (!(keys[i] in data)) {
        if (type === this.GET || type === this.REMOVE) {
          return undefined;
        } else if (type === this.SET) {
          data.$set(keys[i], isNaN(keys[i + 1]) ? {} : []);
        }
      }
2300
      data = data[keys[i]];
    }
2303
    if (type === this.SET) {
      result = data.$set(key, value);
    } else if (type === this.GET) {
      result = data[key];
    } else if (type === this.REMOVE) {
      result = data[key];
      data.$remove(key);
    }
2312
    return result;
  },
  get: function get(keys) {
    return this.traverse(this.GET, keys);
  },
  remove: function remove(keys) {
    return this.traverse(this.REMOVE, keys);
  },
  set: function set(keys, value) {
    return this.traverse(this.SET, keys, value);
  },
  listener: function listener(data, location, type) {
    var parts = location.split('.');
    var part = parts.slice(1).join('.');
    var scope = parts.slice(0, 1).join('.');
    var paths = Binder.get('location', scope);
    if (!paths) return;
    paths.forEach(function (binders, path) {
      if (part === '' || path === part || type !== 'length' && path.indexOf(part + '.') === 0) {
        binders.forEach(function (binder) {
          Binder.render(binder);
        });
      }
    });
  }
};
var STYLE = document.createElement('style');
var SHEET = STYLE.sheet;
STYLE.setAttribute('title', 'oxe');
STYLE.setAttribute('type', 'text/css');
var Style$1 = {
  get style() {
    return STYLE;
  },
2347
  get sheet() {
    return SHEET;
  },
2351
  add: function add(data) {
    this.sheet.insertRule(data);
  },
  append: function append(data) {
    this.style.appendChild(document.createTextNode(data));
  },
  setup: function setup(option) {
    return new Promise(function ($return, $error) {
      option = option || {};
2361
      if (option.style) {
        this.append(option.style);
      }
2365
      document.head.appendChild(this.style);
      return $return();
    }.bind(this));
  }
};
var Definer = {
  setup: function setup() {
    return new Promise(function ($return, $error) {
      if (window.Reflect === undefined) {
        window.Reflect = window.Reflect || {};
2376
        window.Reflect.construct = function (parent, args, child) {
          var target = child === undefined ? parent : child;
          var prototype = target.prototype || Object.prototype;
          var copy = Object.create(prototype);
          return Function.prototype.apply.call(parent, copy, args) || copy;
        };
      }
2384
      return $return();
    });
  },
  define: function define(name, constructor) {
    constructor = constructor || function () {};
2390
    var construct = function construct() {
      var instance = window.Reflect.construct(HTMLElement, [], this.constructor);
      constructor.call(instance);
      return instance;
    };
2396
    var prototypes = Object.getOwnPropertyDescriptors(constructor.prototype);
    construct.prototype = Object.create(HTMLElement.prototype);
    Object.defineProperties(construct.prototype, prototypes);
    Object.defineProperty(construct.prototype, 'constructor', {
      enumerable: false,
      writable: true,
      value: construct
    });
    window.customElements.define(name, construct);
  }
};
var Component = {
  data: {},
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      var self = this;
      options = options || {};
2414
      if (options.components) {
        return $return(Promise.all(options.components.map(function (component) {
          if (typeof component === 'string') {
            return Loader.load(component).then(function (load) {
              return self.define(load.default);
            });
          } else {
            return self.define(component);
          }
        })));
      }
2426
      return $return();
    }.bind(this));
  },
  style: function style(_style, name) {
    _style = _style.replace(/\n|\r|\t/g, '');
    _style = _style.replace(/:host/g, name);
2433
    if (!window.CSS || !window.CSS.supports || !window.CSS.supports('(--t: black)')) {
      var matches = _style.match(/--\w+(?:-+\w+)*:\s*.*?;/g) || [];
2436
      for (var i = 0, l = matches.length; i < l; i++) {
        var match = matches[i];
        var rule = match.match(/(--\w+(?:-+\w+)*):\s*(.*?);/);
        var pattern = new RegExp('var\\(' + rule[1] + '\\)', 'g');
        _style = _style.replace(rule[0], '');
        _style = _style.replace(pattern, rule[2]);
      }
    }
2445
    return _style;
  },
  slot: function slot(element, fragment) {
    var fragmentSlots = fragment.querySelectorAll('slot[name]');
    var defaultSlot = fragment.querySelector('slot:not([name])');
2451
    for (var i = 0, l = fragmentSlots.length; i < l; i++) {
      var fragmentSlot = fragmentSlots[i];
      var name = fragmentSlot.getAttribute('name');
      var elementSlot = element.querySelector('[slot="' + name + '"]');
2456
      if (elementSlot) {
        fragmentSlot.parentNode.replaceChild(elementSlot, fragmentSlot);
      } else {
        fragmentSlot.parentNode.removeChild(fragmentSlot);
      }
    }
2463
    if (defaultSlot) {
      if (element.children.length) {
        while (element.firstChild) {
          defaultSlot.parentNode.insertBefore(element.firstChild, defaultSlot);
        }
      }
2470
      defaultSlot.parentNode.removeChild(defaultSlot);
    }
  },
  fragment: function fragment(element, template, adopt) {
    var fragment = document.createDocumentFragment();
    var clone = template.cloneNode(true);
    var child = clone.firstElementChild;
2478
    while (child) {
      if (!adopt) {
        Binder.add(child, {
          container: element,
          scope: element.scope
        });
      }
2486
      fragment.appendChild(child);
      child = clone.firstElementChild;
    }
2490
    return fragment;
  },
  render: function render(element, template, adopt, shadow) {
    if (!template) {
      return;
    }
2497
    var fragment = this.fragment(element, template);
    var root;
2500
    if (shadow && 'attachShadow' in document.body) {
      root = element.attachShadow({
        mode: 'open'
      });
    } else if (shadow && 'createShadowRoot' in document.body) {
      root = element.createShadowRoot();
    } else {
      if (fragment) {
        this.slot(element, fragment);
      }
2511
      root = element;
    }
2514
    if (fragment) {
      root.appendChild(fragment);
    }
2518
    if (adopt) {
      var child = root.firstElementChild;
2521
      while (child) {
        Binder.add(child, {
          container: element,
          scope: element.scope
        });
        child = child.nextElementSibling;
      }
    }
  },
  define: function define(options) {
    var self = this;
2533
    if (_typeof(options) !== 'object') {
      return console.warn('Oxe.component.define - invalid argument type');
    }
2537
    if (options.constructor === Array) {
      for (var i = 0, l = options.length; i < l; i++) {
        self.define(options[i]);
      }
2542
      return;
    }
2545
    if (!options.name) {
      return console.warn('Oxe.component.define - requires name');
    }
2549
    options.name = options.name.toLowerCase();
2551
    if (options.name in self.data) {
      console.log(options.name);
      return console.warn('Oxe.component.define - component defined');
    }
2556
    self.data[options.name] = options;
    options.count = 0;
    options.model = options.model || {};
    options.adopt = options.adopt || false;
    options.methods = options.methods || {};
    options.shadow = options.shadow || false;
    options.attributes = options.attributes || [];
    options.properties = options.properties || {};
2565
    if (options.style) {
      options.style = this.style(options.style, options.name);
      Style$1.append(options.style);
    }
2570
    if (options.template && typeof options.template === 'string') {
      var data = document.createElement('div');
      data.innerHTML = options.template;
      options.template = data;
    }
2576
    var constructor = function constructor() {
      this._created = false;
      this._scope = options.name + '-' + options.count++;
      var properties = Utility.clone(options.properties);
      var methods = Utility.clone(options.methods);
      var model = Utility.clone(options.model);
      Object.defineProperties(this, properties);
      Methods.set(this.scope, methods);
      Model.set(this.scope, model);
    };
2587
    Object.defineProperties(constructor.prototype, {
      created: {
        get: function get() {
          return this._created;
        }
      },
      scope: {
        get: function get() {
          return this._scope;
        }
      },
      methods: {
        get: function get() {
          return Methods.get(this.scope);
        }
      },
      model: {
        get: function get() {
          return Model.get(this.scope);
        },
        set: function set(data) {
          return Model.set(this.scope, data && _typeof(data) === 'object' ? data : {});
        }
      },
      observedAttributes: {
        value: options.attributes
      },
      attributeChangedCallback: {
        value: function value() {
          if (options.attributed) options.attributed.apply(this, arguments);
        }
      },
      adoptedCallback: {
        value: function value() {
          if (options.adopted) options.adopted.apply(this, arguments);
        }
      },
      disconnectedCallback: {
        value: function value() {
          if (options.detached) options.detached.call(this);
        }
      },
      connectedCallback: {
        value: function value() {
          var instance = this;
2633
          if (instance.created) {
            if (options.attached) {
              options.attached.call(instance);
            }
          } else {
            instance._created = true;
            self.render(instance, options.template, options.adopt, options.shadow);
            Promise.resolve().then(function () {
              if (options.created) {
                return options.created.call(instance);
              }
            }).then(function () {
              if (options.attached) {
                return options.attached.call(instance);
              }
            });
          }
        }
      }
    });
    Definer.define(options.name, constructor);
  }
};
2657
function Listener(option, method, event) {
  var type = event.type;
  var before;
  var after;
2662
  if (type in option.listener) {
    before = typeof option.listener[type].before === 'function' ? option.listener[type].before.bind(null, event) : null;
    after = typeof option.listener[type].after === 'function' ? option.listener[type].after.bind(null, event) : null;
  }
2667
  Promise.resolve().then(before).then(method.bind(null, event)).then(after);
}
2670
var EVENTS = {};
var Events = {
  get events() {
    return EVENTS;
  },
2676
  on: function on(name, method) {
    if (!(name in this.events)) {
      this.events[name] = [];
    }
2681
    this.events[name].push(method);
  },
  off: function off(name, method) {
    if (name in this.events) {
      var _index4 = this.events[name].indexOf(method);
2687
      if (_index4 !== -1) {
        this.events[name].splice(_index4, 1);
      }
    }
  },
  emit: function emit(name) {
    if (name in this.events) {
      var methods = this.events[name];
      var args = Array.prototype.slice.call(arguments, 2);
      Promise.all(methods.map(function (method) {
        return method.apply(this, args);
      })).catch(console.error);
    }
  }
};
var Event = Object.create(Events);
var Router = {
  on: Event.on.bind(Event),
  off: Event.off.bind(Event),
  emit: Event.emit.bind(Event),
  data: [],
  ran: false,
  location: {},
  mode: 'push',
  target: null,
  contain: false,
  folder: './routes',
  setup: function setup(option) {
    return new Promise(function ($return, $error) {
      option = option || {};
      this.base = option.base === undefined ? this.base : option.base;
      this.mode = option.mode === undefined ? this.mode : option.mode;
      this.after = option.after === undefined ? this.after : option.after;
      this.folder = option.folder === undefined ? this.folder : option.folder;
      this.before = option.before === undefined ? this.before : option.before;
      this.change = option.change === undefined ? this.change : option.change;
      this.target = option.target === undefined ? this.target : option.target;
      this.contain = option.contain === undefined ? this.contain : option.contain;
      this.external = option.external === undefined ? this.external : option.external;
2727
      if (!this.target || typeof this.target === 'string') {
        this.target = document.body.querySelector(this.target || 'o-router');
      }
2731
      if (this.mode !== 'href') {
        window.addEventListener('popstate', this.state.bind(this), true);
        window.document.addEventListener('click', this.click.bind(this), true);
      }
2736
      Definer.define('o-router');
      return Promise.resolve(this.add(option.routes)).then(function ($await_40) {
        try {
          return Promise.resolve(this.route(window.location.href, {
            mode: 'replace'
          })).then(function ($await_41) {
            try {
              return $return();
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }, $error);
        } catch ($boundEx) {
          return $error($boundEx);
        }
      }.bind(this), $error);
    }.bind(this));
  },
  compareParts: function compareParts(routePath, userPath, split) {
    var compareParts = [];
    var routeParts = routePath.split(split);
    var userParts = userPath.split(split);
2759
    if (userParts.length > 1 && userParts[userParts.length - 1] === '') {
      userParts.pop();
    }
2763
    if (routeParts.length > 1 && routeParts[routeParts.length - 1] === '') {
      routeParts.pop();
    }
2767
    for (var i = 0, l = routeParts.length; i < l; i++) {
      if (routeParts[i].slice(0, 1) === '(' && routeParts[i].slice(-1) === ')') {
        if (routeParts[i] === '(~)') {
          return true;
        } else if (routeParts[i].indexOf('~') !== -1) {
          if (userParts[i]) {
            compareParts.push(userParts[i]);
          }
        } else {
          compareParts.push(userParts[i]);
        }
      } else if (routeParts[i] !== userParts[i]) {
        return false;
      } else {
        compareParts.push(routeParts[i]);
      }
    }
2785
    if (compareParts.join(split) === userParts.join(split)) {
      return true;
    } else {
      return false;
    }
  },
  compare: function compare(routePath, userPath) {
    var base = Path.normalize(Path.base);
    userPath = Path.normalize(userPath);
    routePath = Path.normalize(routePath);
2796
    if (userPath.slice(0, base.length) !== base) {
      userPath = Path.join(base, userPath);
    }
2800
    if (routePath.slice(0, base.length) !== base) {
      routePath = Path.join(base, routePath);
    }
2804
    if (this.compareParts(routePath, userPath, '/')) {
      return true;
    }
2808
    if (this.compareParts(routePath, userPath, '-')) {
      return true;
    }
2812
    return false;
  },
  toParameterObject: function toParameterObject(routePath, userPath) {
    var result = {};
    if (!routePath || !userPath || routePath === '/' || userPath === '/') return result;
    var userParts = userPath.split(/\/|-/);
    var routeParts = routePath.split(/\/|-/);
2820
    for (var i = 0, l = routeParts.length; i < l; i++) {
      var part = routeParts[i];
2823
      if (part.slice(0, 1) === '(' && part.slice(-1) === ')') {
        var name = part.slice(1, part.length - 1).replace('~', '');
        result[name] = userParts[i];
      }
    }
2829
    return result;
  },
  toQueryString: function toQueryString(data) {
    var result = '?';
2834
    for (var key in data) {
      var value = data[key];
      result += key + '=' + value + '&';
    }
2839
    if (result.slice(-1) === '&') {
      result = result.slice(0, -1);
    }
2843
    return result;
  },
  toQueryObject: function toQueryObject(path) {
    var result = {};
    if (path.indexOf('?') === 0) path = path.slice(1);
    var queries = path.split('&');
2850
    for (var i = 0, l = queries.length; i < l; i++) {
      var query = queries[i].split('=');
2853
      if (query[0] && query[1]) {
        result[query[0]] = query[1];
      }
    }
2858
    return result;
  },
  toLocationObject: function toLocationObject(href) {
    var location = {};
    var parser = document.createElement('a');
    parser.href = href;
    location.href = parser.href;
    location.host = parser.host;
    location.port = parser.port;
    location.hash = parser.hash;
    location.search = parser.search;
    location.protocol = parser.protocol;
    location.hostname = parser.hostname;
    location.pathname = parser.pathname[0] === '/' ? parser.pathname : '/' + parser.pathname;
    location.path = location.pathname + location.search + location.hash;
    return location;
  },
  scroll: function scroll(x, y) {
    window.scroll(x, y);
  },
  back: function back() {
    window.history.back();
  },
  forward: function forward() {
    window.history.forward();
  },
  redirect: function redirect(path) {
    window.location.href = path;
  },
  add: function add(data) {
    return new Promise(function ($return, $error) {
      var path, load, i, l;
2891
      if (!data) {
        return $return();
      } else {
        if (data.constructor === String) {
          path = data;
2897
          if (path.slice(-3) === '.js') {
            path = path.slice(0, -3);
          }
2901
          load = path;
2903
          if (path.slice(-5) === 'index') {
            path = path.slice(0, -5);
          }
2907
          if (path.slice(-6) === 'index/') {
            path = path.slice(0, -6);
          }
2911
          if (path.slice(0, 2) === './') {
            path = path.slice(2);
          }
2915
          if (path.slice(0, 1) !== '/') {
            path = '/' + path;
          }
2919
          load = load + '.js';
          load = Path.join(this.folder, load);
          this.data.push({
            path: path,
            load: load
          });
          return $If_9.call(this);
        } else {
          if (data.constructor === Object) {
            if (!data.path) {
              return $error(new Error('Oxe.router.add - route path required'));
            }
2932
            if (!data.name && !data.load && !data.component) {
              return $error(new Error('Oxe.router.add -  route requires name, load, or component property'));
            }
2936
            this.data.push(data);
            return $If_10.call(this);
          } else {
            if (data.constructor === Array) {
              i = 0, l = data.length;
              var $Loop_12_trampoline;
2943
              function $Loop_12_step() {
                i++;
                return $Loop_12;
              }
2948
              function $Loop_12() {
                if (i < l) {
                  return Promise.resolve(this.add(data[i])).then(function ($await_42) {
                    try {
                      return $Loop_12_step;
                    } catch ($boundEx) {
                      return $error($boundEx);
                    }
                  }, $error);
                } else return [1];
              }
2960
              return ($Loop_12_trampoline = function (q) {
                while (q) {
                  if (q.then) return void q.then($Loop_12_trampoline, $error);
2964
                  try {
                    if (q.pop) {
                      if (q.length) return q.pop() ? $Loop_12_exit.call(this) : q;else q = $Loop_12_step;
                    } else q = q.call(this);
                  } catch (_exception) {
                    return $error(_exception);
                  }
                }
              }.bind(this))($Loop_12);
2974
              function $Loop_12_exit() {
                return $If_11.call(this);
              }
            }
2979
            function $If_11() {
              return $If_10.call(this);
            }
2983
            return $If_11.call(this);
          }
2986
          function $If_10() {
            return $If_9.call(this);
          }
        }
2991
        function $If_9() {
          return $If_8.call(this);
        }
      }
2996
      function $If_8() {
        return $return();
      }
3000
      return $If_8.call(this);
    }.bind(this));
  },
  load: function load(route) {
    return new Promise(function ($return, $error) {
      var load, _load;
3007
      if (route.load) {
        return Promise.resolve(Loader.load(route.load)).then(function ($await_43) {
          try {
            load = $await_43;
            route = Object.assign({}, load.default, route);
            return $If_14.call(this);
          } catch ($boundEx) {
            return $error($boundEx);
          }
        }.bind(this), $error);
      }
3019
      function $If_14() {
        if (typeof route.component === 'string') {
          route.load = route.component;
          return Promise.resolve(Loader.load(route.load)).then(function ($await_44) {
            try {
              _load = $await_44;
              route.component = _load.default;
              return $If_15.call(this);
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }
3033
        function $If_15() {
          return $return(route);
        }
3037
        return $If_15.call(this);
      }
3040
      return $If_14.call(this);
    });
  },
  remove: function remove(path) {
    return new Promise(function ($return, $error) {
      for (var i = 0, l = this.data.length; i < l; i++) {
        if (this.data[i].path === path) {
          this.data.splice(i, 1);
        }
      }
3051
      return $return();
    }.bind(this));
  },
  get: function get(path) {
    return new Promise(function ($return, $error) {
      var i, l;
      i = 0, l = this.data.length;
      var $Loop_16_trampoline;
3060
      function $Loop_16_step() {
        i++;
        return $Loop_16;
      }
3065
      function $Loop_16() {
        if (i < l) {
          if (this.data[i].path === path) {
            return Promise.resolve(this.load(this.data[i])).then(function ($await_45) {
              try {
                this.data[i] = $await_45;
                return $return(this.data[i]);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3078
          return $Loop_16_step;
        } else return [1];
      }
3082
      return ($Loop_16_trampoline = function (q) {
        while (q) {
          if (q.then) return void q.then($Loop_16_trampoline, $error);
3086
          try {
            if (q.pop) {
              if (q.length) return q.pop() ? $Loop_16_exit.call(this) : q;else q = $Loop_16_step;
            } else q = q.call(this);
          } catch (_exception) {
            return $error(_exception);
          }
        }
      }.bind(this))($Loop_16);
3096
      function $Loop_16_exit() {
        return $return();
      }
    }.bind(this));
  },
  filter: function filter(path) {
    return new Promise(function ($return, $error) {
      var result, i, l;
      result = [];
      i = 0, l = this.data.length;
      var $Loop_19_trampoline;
3108
      function $Loop_19_step() {
        i++;
        return $Loop_19;
      }
3113
      function $Loop_19() {
        if (i < l) {
          if (this.compare(this.data[i].path, path)) {
            return Promise.resolve(this.load(this.data[i])).then(function ($await_46) {
              try {
                this.data[i] = $await_46;
                result.push(this.data[i]);
                return $If_21.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3127
          function $If_21() {
            return $Loop_19_step;
          }
3131
          return $If_21.call(this);
        } else return [1];
      }
3135
      return ($Loop_19_trampoline = function (q) {
        while (q) {
          if (q.then) return void q.then($Loop_19_trampoline, $error);
3139
          try {
            if (q.pop) {
              if (q.length) return q.pop() ? $Loop_19_exit.call(this) : q;else q = $Loop_19_step;
            } else q = q.call(this);
          } catch (_exception) {
            return $error(_exception);
          }
        }
      }.bind(this))($Loop_19);
3149
      function $Loop_19_exit() {
        return $return(result);
      }
    }.bind(this));
  },
  find: function find(path) {
    return new Promise(function ($return, $error) {
      var i, l;
      i = 0, l = this.data.length;
      var $Loop_22_trampoline;
3160
      function $Loop_22_step() {
        i++;
        return $Loop_22;
      }
3165
      function $Loop_22() {
        if (i < l) {
          if (this.compare(this.data[i].path, path)) {
            return Promise.resolve(this.load(this.data[i])).then(function ($await_47) {
              try {
                this.data[i] = $await_47;
                return $return(this.data[i]);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3178
          return $Loop_22_step;
        } else return [1];
      }
3182
      return ($Loop_22_trampoline = function (q) {
        while (q) {
          if (q.then) return void q.then($Loop_22_trampoline, $error);
3186
          try {
            if (q.pop) {
              if (q.length) return q.pop() ? $Loop_22_exit.call(this) : q;else q = $Loop_22_step;
            } else q = q.call(this);
          } catch (_exception) {
            return $error(_exception);
          }
        }
      }.bind(this))($Loop_22);
3196
      function $Loop_22_exit() {
        return $return();
      }
    }.bind(this));
  },
  render: function render(route) {
    return new Promise(function ($return, $error) {
      if (!route) {
        return $error(new Error('Oxe.render - route argument required. Missing object option.'));
      }
3207
      if (route.title) {
        document.title = route.title;
      }
3211
      var ensures = [];
3213
      if (route.keywords) {
        ensures.push({
          name: 'meta',
          query: '[name="keywords"]',
          attributes: [{
            name: 'name',
            value: 'keywords'
          }, {
            name: 'content',
            value: route.keywords
          }]
        });
      }
3227
      if (route.description) {
        ensures.push({
          name: 'meta',
          query: '[name="description"]',
          attributes: [{
            name: 'name',
            value: 'description'
          }, {
            name: 'content',
            value: route.description
          }]
        });
      }
3241
      if (route.canonical) {
        ensures.push({
          name: 'link',
          query: '[rel="canonical"]',
          attributes: [{
            name: 'rel',
            value: 'canonical'
          }, {
            name: 'href',
            value: route.canonical
          }]
        });
      }
3255
      if (ensures.length) {
        Promise.all(ensures.map(function (option) {
          return Promise.resolve().then(function () {
            option.position = 'afterbegin';
            option.scope = document.head;
            return Utility.ensureElement(option);
          });
        }));
      }
3265
      if (!route.target) {
        if (!route.component) {
          Component.define(route);
          route.target = window.document.createElement(route.name);
        } else if (route.component.constructor === String) {
          route.target = window.document.createElement(route.component);
        } else if (route.component.constructor === Object) {
          Component.define(route.component);
          route.target = window.document.createElement(route.component.name);
        } else {
          return $error(new Error('Oxe.router.render - route requires name, load, or component property'));
        }
      }
3279
      if (this.target) {
        while (this.target.firstChild) {
          this.target.removeChild(this.target.firstChild);
        }
3284
        this.target.appendChild(route.target);
      }
3287
      this.scroll(0, 0);
      return $return();
    }.bind(this));
  },
  route: function route(path, options) {
    return new Promise(function ($return, $error) {
      var mode, location, route;
      options = options || {};
3296
      if (options.query) {
        path += this.toQueryString(options.query);
      }
3300
      mode = options.mode || this.mode;
      location = this.toLocationObject(path);
      return Promise.resolve(this.find(location.pathname)).then(function ($await_48) {
        try {
          route = $await_48;
3306
          if (!route) {
            return $error(new Error("Oxe.router.route - missing route ".concat(location.pathname)));
          }
3310
          location.route = route;
          location.title = location.route.title;
          location.query = this.toQueryObject(location.search);
          location.parameters = this.toParameterObject(location.route.path, location.pathname);
3315
          if (location.route && location.route.handler) {
            return Promise.resolve(location.route.handler(location)).then($return, $error);
          }
3319
          if (location.route && location.route.redirect) {
            return Promise.resolve(this.redirect(location.route.redirect)).then($return, $error);
          }
3323
          function $If_26() {
            if (typeof this.before === 'function') {
              return Promise.resolve(this.before(location)).then(function ($await_51) {
                try {
                  return $If_27.call(this);
                } catch ($boundEx) {
                  return $error($boundEx);
                }
              }.bind(this), $error);
            }
3334
            function $If_27() {
              this.emit('route:before', location);
3337
              if (mode === 'href') {
                return $return(window.location.assign(location.path));
              }
3341
              window.history[mode + 'State']({
                path: location.path
              }, '', location.path);
              this.location = location;
              return Promise.resolve(this.render(location.route)).then(function ($await_52) {
                try {
                  if (typeof this.after === 'function') {
                    return Promise.resolve(this.after(location)).then(function ($await_53) {
                      try {
                        return $If_28.call(this);
                      } catch ($boundEx) {
                        return $error($boundEx);
                      }
                    }.bind(this), $error);
                  }
3357
                  function $If_28() {
                    this.emit('route:after', location);
                    return $return();
                  }
3362
                  return $If_28.call(this);
                } catch ($boundEx) {
                  return $error($boundEx);
                }
              }.bind(this), $error);
            }
3369
            return $If_27.call(this);
          }
3372
          if (typeof this.before === 'function') {
            return Promise.resolve(this.before(location)).then(function ($await_51) {
              try {
                return $If_27.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3382
          function $If_27() {
            this.emit('route:before', location);
3385
            if (mode === 'href') {
              return $return(window.location.assign(location.path));
            }
3389
            window.history[mode + 'State']({
              path: location.path
            }, '', location.path);
            this.location = location;
            return Promise.resolve(this.render(location.route)).then(function ($await_52) {
              try {
                if (typeof this.after === 'function') {
                  return Promise.resolve(this.after(location)).then(function ($await_53) {
                    try {
                      return $If_28.call(this);
                    } catch ($boundEx) {
                      return $error($boundEx);
                    }
                  }.bind(this), $error);
                }
3405
                function $If_28() {
                  this.emit('route:after', location);
                  return $return();
                }
3410
                return $If_28.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3417
          return $If_27.call(this);
        } catch ($boundEx) {
          return $error($boundEx);
        }
      }.bind(this), $error);
    }.bind(this));
  },
  state: function state(event) {
    return new Promise(function ($return, $error) {
      var path = event && event.state ? event.state.path : window.location.href;
      this.route(path, {
        mode: 'replace'
      });
      return $return();
    }.bind(this));
  },
  click: function click(event) {
    return new Promise(function ($return, $error) {
      if (event.target.type || event.button !== 0 || event.defaultPrevented || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) {
        return $return();
      }
3439
      var target = event.path ? event.path[0] : event.target;
      var parent = target.parentElement;
3442
      if (this.contain) {
        while (parent) {
          if (parent.nodeName === 'O-ROUTER') {
            break;
          } else {
            parent = parent.parentElement;
          }
        }
3451
        if (parent.nodeName !== 'O-ROUTER') {
          return $return();
        }
      }
3456
      while (target && 'A' !== target.nodeName) {
        target = target.parentElement;
      }
3460
      if (!target || 'A' !== target.nodeName) {
        return $return();
      }
3464
      if (target.hasAttribute('download') || target.hasAttribute('external') || target.hasAttribute('o-external') || target.href.indexOf('tel:') === 0 || target.href.indexOf('ftp:') === 0 || target.href.indexOf('file:') === 0 || target.href.indexOf('mailto:') === 0 || target.href.indexOf(window.location.origin) !== 0 || target.hash !== '' && target.origin === window.location.origin && target.pathname === window.location.pathname) return $return();
      if (this.external && (this.external.constructor === RegExp && this.external.test(target.href) || this.external.constructor === Function && this.external(target.href) || this.external.constructor === String && this.external === target.href)) return $return();
      event.preventDefault();
3468
      if (this.location.href !== target.href) {
        this.route(target.href);
      }
3472
      return $return();
    }.bind(this));
  }
};
document.head.insertAdjacentHTML('afterbegin', '<style>:not(:defined){visibility:hidden;}o-router,o-router>:first-child{display:block;}</style>');
var oSetup = document.querySelector('script[o-setup]');
3479
if (oSetup) {
  Promise.resolve().then(function () {
    var attribute = oSetup.getAttribute('o-setup');
3483
    if (!attribute) {
      throw new Error('Oxe - attribute o-setup requires arguments');
    }
3487
    var options = attribute.split(/\s+|\s*,+\s*/);
    Loader.type = options[1] || 'esm';
    return Loader.load(options[0]);
  });
}
3493
var SETUP = false;
var GLOBAL = {};
var index = Object.freeze({
  global: GLOBAL,
  component: Component,
  batcher: Batcher,
  definer: Definer,
  fetcher: Fetcher,
  methods: Methods,
  utility: Utility,
  binder: Binder,
  loader: Loader,
  router: Router,
  model: Model,
  style: Style$1,
  path: Path,
  setup: function setup(options) {
    var self = this;
    if (SETUP) return;else SETUP = true;
    options = options || {};
    options.listener = options.listener || {};
    document.addEventListener('input', Listener.bind(null, options, Input), true);
    document.addEventListener('reset', Listener.bind(null, options, Reset), true);
    document.addEventListener('change', Listener.bind(null, options, Change), true);
    document.addEventListener('submit', Listener.bind(null, options, Submit), true);
    return Promise.all([self.path.setup(options.path), self.style.setup(options.style), self.model.setup(options.model), self.binder.setup(options.binder), self.loader.setup(options.loader), self.definer.setup(options.definer), self.fetcher.setup(options.fetcher)]).then(function () {
      if (options.listener.before) {
        return options.listener.before();
      }
    }).then(function () {
      if (options.component) {
        return self.component.setup(options.component);
      }
    }).then(function () {
      if (options.router) {
        return self.router.setup(options.router);
      }
    }).then(function () {
      if (options.listener.after) {
        return options.listener.after();
      }
    });
  }
});
return index;
3539});
\No newline at end of file
1	`/*`
2	`Name: oxe`
3	`Version: 5.2.4`
4	`License: MPL-2.0`
5	`Author: Alexander Elias`
6	`Email: alex.steven.elis@gmail.com`
7	`This Source Code Form is subject to the terms of the Mozilla Public`
8	`License, v. 2.0. If a copy of the MPL was not distributed with this`
9	`file, You can obtain one at http://mozilla.org/MPL/2.0/.`
10	`*/`
11	`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); }`
12
13	`(function (global, factory) {`
14	`(typeof exports === "undefined" ? "undefined" : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : (global = global \|\| self, global.Oxe = factory());`
15	`})(this, function () {`
16	`'use strict';`
17
18	`var Utility = {`
19	`PIPE: /\s?\\|\s?/,`
20	`PIPES: /\s?,\s?\|\s+/,`
21	`value: function value(element, model) {`
22	`if (!model) throw new Error('Utility.value - requires model argument');`
23	`if (!element) throw new Error('Utility.value - requires element argument');`
24	`var type = this.type(element);`
25
26	`if (type === 'radio' \|\| type === 'checkbox') {`
27	`var name = this.name(element);`
28	`var query = 'input[type="' + type + '"][name="' + name + '"]';`
29	`var form = this.form(element);`
30	`var elements = form ? this.form(element).querySelectorAll(query) : [element];`
31	`var multiple = elements.length > 1;`
32	`var result = multiple ? [] : undefined;`
33
34	`for (var i = 0, l = elements.length; i < l; i++) {`
35	`var child = elements[i];`
36	`var checked = this.checked(child);`
37	`if (!checked) continue;`
38	`var value = this.value(child, model);`
39
40	`if (multiple) {`