UNPKG

oxe/ideas/oxe.js

Version:
111 kBJavaScriptView Raw
1function _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); }
2
3(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());
5})(this, function () {
'use strict';
7
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);
15
    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;
23
      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);
29
        if (multiple) {
          result.push(value);
        } else {
          result = value;
          break;
        }
      }
37
      return result;
    } else if (type === 'select-one' || type === 'select-multiple') {
      var _multiple = this.multiple(element);
41
      var options = element.options;
43
      var _result = _multiple ? [] : undefined;
45
      for (var _i = 0, _l = options.length; _i < _l; _i++) {
        var option = options[_i];
        var selected = option.selected;
49
        var _value = this.value(option, model);
51
        var match = this[_multiple ? 'includes' : 'compare'](this.data, _value);
53
        if (selected && !match) {
          if (this.multiple) {
            _result.push(_value);
          } else {
            _result = _value;
          }
        } else if (!selected && match) {
          option.selected = true;
        }
      }
64
      return _result;
    } else {
      var attribute = element.attributes['o-value'];
68
      if (attribute) {
        var values = this.binderValues(attribute.value);
71
        var _value2 = this.getByPath(model, values);
73
        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;
112
        case 'true':
          return true;
115
        case null:
          return false;
118
        case '':
          return true;
121
        default:
          return false;
      }
    }
  },
  multiple: function multiple(element) {
    if (typeof element.multiple === 'boolean') {
      return element.multiple;
    } else {
      switch (element.getAttribute('multiple')) {
        case undefined:
          return false;
134
        case 'true':
          return true;
137
        case null:
          return false;
140
        case '':
          return true;
143
        default:
          return false;
      }
    }
  },
  disabled: function disabled(element) {
    if (typeof element.disabled === 'boolean') {
      return element.disabled;
    } else {
      switch (element.getAttribute('disabled')) {
        case undefined:
          return false;
156
        case 'true':
          return true;
159
        case null:
          return false;
162
        case '':
          return true;
165
        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;
      }
    }
177
    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;
      }
    }
186
    return false;
  },
  match: function match(source, target) {
    if (source === target) {
      return true;
    }
193
    if (_typeof(source) !== _typeof(target)) {
      return false;
    }
197
    if (source.constructor !== target.constructor) {
      return false;
    }
201
    if (_typeof(source) !== 'object' || _typeof(target) !== 'object') {
      return source === target;
    }
205
    var sourceKeys = Object.keys(source);
    var targetKeys = Object.keys(target);
208
    if (sourceKeys.length !== targetKeys.length) {
      return false;
    }
212
    for (var i = 0, l = sourceKeys.length; i < l; i++) {
      var name = sourceKeys[i];
215
      if (!this.match(source[name], target[name])) {
        return false;
      }
    }
220
    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;
    var element = data.scope.querySelector("".concat(data.name).concat(data.query));
239
    if (!element) {
      element = document.createElement(data.name);
242
      if (data.position === 'afterbegin') {
        data.scope.insertBefore(element, data.scope.firstChild);
      } else if (data.position === 'beforeend') {
        data.scope.appendChild(element);
      } else {
        data.scope.appendChild(element);
      }
    }
251
    for (var i = 0, l = data.attributes.length; i < l; i++) {
      var attribute = data.attributes[i];
      element.setAttribute(attribute.name, attribute.value);
    }
256
    return element;
  },
  setByPath: function setByPath(data, path, value) {
    var keys = typeof path === 'string' ? path.split('.') : path;
    var last = keys.length - 1;
262
    for (var i = 0; i < last; i++) {
      var key = keys[i];
265
      if (!(key in data)) {
        if (isNaN(keys[i + 1])) {
          data[key] = {};
        } else {
          data[key] = [];
        }
      }
273
      data = data[key];
    }
276
    return data[keys[last]] = value;
  },
  getByPath: function getByPath(data, path) {
    var keys = typeof path === 'string' ? path.split('.') : path;
    var last = keys.length - 1;
282
    if (keys[last] === '$key' || keys[last] === '$index') {
      return keys[last - 1];
    }
286
    for (var i = 0; i < last; i++) {
      var key = keys[i];
289
      if (key in data === false) {
        return undefined;
      } else {
        data = data[key];
      }
    }
296
    return data[keys[last]];
  },
  clone: function clone(source) {
    if (source === null || source === undefined || source.constructor !== Array && source.constructor !== Object) {
      return source;
    }
303
    var target = source.constructor();
305
    for (var name in source) {
      var descriptor = Object.getOwnPropertyDescriptor(source, name);
308
      if (descriptor) {
        if ('value' in descriptor) {
          descriptor.value = this.clone(descriptor.value);
        }
313
        Object.defineProperty(target, name, descriptor);
      }
    }
317
    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;
341
    if (this.writes.length === 0) {
      while (task = this.reads.shift()) {
        if (task) {
          task();
        }
347
        if (performance.now() - time > this.time) {
          return this.tick(this.flush);
        }
      }
    }
353
    while (task = this.writes.shift()) {
      if (task) {
        task();
      }
358
      if (performance.now() - time > this.time) {
        return this.tick(this.flush);
      }
    }
363
    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 || {};
384
    var read = function read() {
      var result;
387
      if (data.read) {
        result = data.read.call(data.context, data.context);
      }
391
      if (data.write && result !== false) {
        var write = data.write.bind(data.context, data.context);
        self.writes.push(write);
      }
    };
397
    self.reads.push(read);
    self.schedule();
  }
};
402
function Piper(binder, data) {
  if (binder.type === 'on') {
    return data;
  }
407
  if (!binder.pipes.length) {
    return data;
  }
411
  var methods = binder.container.methods;
413
  if (!methods) {
    return data;
  }
417
  for (var i = 0, l = binder.pipes.length; i < l; i++) {
    var name = binder.pipes[i];
420
    if (name in methods) {
      var method = methods[name];
423
      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"));
    }
  }
433
  return data;
}
436
function Class(binder) {
  return {
    read: function read() {
      this.data = binder.data;
441
      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);
        }
      }
    }
  };
}
463
function Default(binder) {
  return {
    read: function read() {
      this.data = binder.data;
468
      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();
      }
476
      if (this.data === binder.target[binder.type]) {
        return false;
      }
    },
    write: function write() {
      binder.target[binder.type] = this.data;
    }
  };
}
486
function Disable(binder) {
  return {
    read: function read() {
      this.data = binder.data;
491
      if (this.data === binder.target.disabled) {
        return false;
      }
    },
    write: function write() {
      binder.target.disabled = this.data;
    }
  };
}
501
function Each(binder) {
  var self = this;
  var render = {
    read: function read() {
      this.data = binder.data || [];
507
      if (binder.meta.keys === undefined) {
        binder.meta.keys = [];
        binder.meta.pending = false;
        binder.meta.targetLength = 0;
        binder.meta.currentLength = 0;
513
        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;
        }
      }
523
      binder.meta.keys = Object.keys(this.data);
      binder.meta.targetLength = binder.meta.keys.length;
526
      if (binder.meta.currentLength === binder.meta.targetLength) {
        return false;
      }
    },
    write: function write() {
      if (binder.meta.currentLength === binder.meta.targetLength) {
        binder.meta.pending = false;
        return;
      }
536
      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);
544
        var _index = binder.meta.currentLength++;
546
        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);
      }
557
      if (binder.meta.pending && render.read) {
        return;
      } else {
        binder.meta.pending = true;
      }
563
      delete render.read;
      Batcher.batch(render);
    }
  };
  return render;
}
570
function Enable(binder) {
  return {
    read: function read() {
      this.data = !binder.data;
575
      if (this.data === binder.target.disabled) {
        return false;
      }
    },
    write: function write() {
      binder.target.disabled = this.data;
    }
  };
}
585
function Hide(binder) {
  return {
    read: function read() {
      this.data = binder.data;
590
      if (this.data === binder.target.hidden) {
        return false;
      }
    },
    write: function write() {
      binder.target.hidden = this.data;
    }
  };
}
600
function Href(binder) {
  return {
    read: function read() {
      this.data = binder.data || '';
605
      if (this.data === binder.target.href) {
        return false;
      }
    },
    write: function write() {
      binder.target.href = this.data;
    }
  };
}
615
function Html(binder) {
  var self = this;
  return {
    read: function read() {
      this.data = binder.data;
621
      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.removeNode(binder.target.firstChild);
        self.remove(node);
      }
635
      var fragment = document.createDocumentFragment();
      var parser = document.createElement('div');
      parser.innerHTML = this.data;
639
      while (parser.firstElementChild) {
        self.add(parser.firstElementChild, {
          container: binder.container,
          scope: binder.container.scope
        });
        fragment.appendChild(parser.firstElementChild);
      }
647
      binder.target.appendChild(fragment);
    }
  };
}
652
function Label(binder) {
  return {
    read: function read() {
      this.data = binder.data;
657
      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();
      }
665
      if (this.data === binder.target.getAttribute('label')) {
        return false;
      }
    },
    write: function write() {
      binder.target.setAttribute('label', this.data);
    }
  };
}
675
function On(binder) {
  return {
    read: function read(context) {
      context.data = binder.data;
680
      if (typeof context.data !== 'function') {
        console.warn("Oxe - binder o-on=\"".concat(binder.keys.join('.'), "\" invalid type function required"));
        return;
      }
685
      if (binder.meta.method) {
        binder.target.removeEventListener(binder.names[1], binder.meta.method);
      } else {
        binder.meta.method = function (events) {
          var parameters = [];
691
          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);
          }
697
          parameters.push(events);
          parameters.push(this);
          Promise.resolve(context.data.bind(binder.container).apply(null, parameters));
        };
      }
703
      binder.target.addEventListener(binder.names[1], binder.meta.method);
    }
  };
}
708
function Read(binder) {
  return {
    read: function read() {
      this.data = binder.data;
713
      if (this.data === binder.target.readOnly) {
        return false;
      }
    },
    write: function write() {
      binder.target.readOnly = this.data;
    }
  };
}
723
function Require(binder) {
  return {
    read: function read() {
      this.data = binder.data;
728
      if (this.data === binder.target.required) {
        return false;
      }
    },
    write: function write() {
      binder.target.required = this.data;
    }
  };
}
738
function Show(binder) {
  return {
    read: function read() {
      this.data = binder.data;
743
      if (!this.data === binder.target.hidden) {
        return false;
      }
    },
    write: function write() {
      binder.target.hidden = !this.data;
    }
  };
}
753
function Style(binder) {
  return {
    read: function read() {
      this.data = binder.data;
758
      if (binder.names.length > 1) {
        this.name = '';
        this.names = binder.names.slice(1);
762
        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 = '';
        }
      }
    }
  };
}
789
function Text(binder) {
  return {
    read: function read() {
      this.data = binder.data;
794
      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();
      }
802
      if (this.data === binder.target.textContent) {
        return false;
      }
    },
    write: function write() {
      binder.target.textContent = this.data;
    }
  };
}
812
function Value(binder, caller) {
  var self = this;
  var type = binder.target.type;
  if (binder.meta.busy) return;else binder.meta.busy = true;
817
  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);
825
        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 fallbackValue = this.multiple ? [] : null;
        var fallbackOption = this.multiple ? [] : null;
835
        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');
842
          if (this.multiple) {
            if (selectedAtrribute) {
              fallback = true;
              fallbackOption.push(option);
              fallbackValue.push(optionValue);
            }
          } else {
            if (i === 0 || selectedAtrribute) {
              fallback = true;
              fallbackOption = option;
              fallbackValue = optionValue;
            }
          }
856
          if (caller === 'view') {
            if (selected) {
              if (this.multiple) {
                var includes = Utility.includes(this.data, optionValue);
861
                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);
873
                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);
884
              if (_includes) {
                this.selected = true;
                option.selected = true;
              } else {
                option.selected = false;
              }
            } else {
              if (!this.selected) {
                var match = Utility.match(this.data, optionValue);
894
                if (match) {
                  this.selected = true;
                  option.selected = true;
                } else {
                  option.selected = false;
                }
              } else {
                option.selected = false;
              }
            }
          }
        }
907
        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 {
            binder.data = fallbackValue;
            fallbackOption.selected = true;
          }
        }
919
        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);
930
        if (caller === 'view') {
          binder.data = this.radios.indexOf(binder.target);
          binder.meta.busy = false;
          return false;
        }
936
        this.data = binder.data;
938
        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];
947
          if (i === this.data) {
            radio.checked = true;
          } else {
            radio.checked = false;
          }
        }
954
        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;
        }
966
        this.data = binder.data;
968
        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;
        }
987
        this.data = binder.data;
989
        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;
      }
    };
  }
}
1002
function Write(binder) {
  return {
    read: function read() {
      this.data = binder.data;
1007
      if (!this.data === binder.target.readOnly) {
        return false;
      }
    },
    write: function write() {
      binder.target.readOnly = !this.data;
    }
  };
}
1017
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;
  },
1048
  get binders() {
    return BINDERS;
  },
1052
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      options = options || {};
      this.data.set('location', new Map());
      this.data.set('attribute', new Map());
1058
      for (var name in this.binders) {
        this.binders[name] = this.binders[name].bind(this);
      }
1062
      if (options.binders) {
        for (var _name in options.binders) {
          if (_name in this.binders === false) {
            this.binders[_name] = options.binders[_name].bind(this);
          }
        }
      }
1070
      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;
1078
    for (var i = 1, l = arguments.length; i < l; i++) {
      var argument = arguments[i];
      result = result.get(argument);
1082
      if (!result) {
        return result;
      }
    }
1087
    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;
1096
    if (data.value.slice(0, 2) === '{{' && data.value.slice(-2) === '}}') {
      data.value = data.value.slice(2, -2);
    }
1100
    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"));
    }
1105
    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;
      },
1121
      get type() {
        return type;
      },
1125
      get path() {
        return path;
      },
1129
      get scope() {
        return scope;
      },
1133
      get name() {
        return data.name;
      },
1137
      get value() {
        return data.value;
      },
1141
      get target() {
        return data.target;
      },
1145
      get container() {
        return data.container;
      },
1149
      get model() {
        return data.container.model;
      },
1153
      get methods() {
        return data.container.methods;
      },
1157
      get keys() {
        return keys;
      },
1161
      get names() {
        return names;
      },
1165
      get pipes() {
        return pipes;
      },
1169
      get values() {
        return values;
      },
1173
      get meta() {
        return meta;
      },
1177
      get context() {
        return context;
      },
1181
      get originalValue() {
        return originalValue;
      },
1185
      get data() {
        var data = Utility.getByPath(source, values);
        return Piper(this, data);
      },
1190
      set data(value) {
        return Utility.setByPath(source, values, value);
      }
1194
    };
  },
  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;
        }
      });
    }
1223
    if (value === "$".concat(context.variable, ".$index") || value === "{{$".concat(context.variable, ".$index}}")) {
      return Batcher.batch({
        write: function write() {
          node.textContent = context.index;
        }
      });
    }
1231
    var binder = this.create({
      name: name,
      value: value,
      target: node,
      context: context,
      container: context.container,
      scope: context.container.scope
    });
1240
    if (!this.data.get('attribute').has(binder.target)) {
      this.data.get('attribute').set(binder.target, new Map());
    }
1244
    if (!this.data.get('location').has(binder.scope)) {
      this.data.get('location').set(binder.scope, new Map());
    }
1248
    if (!this.data.get('location').get(binder.scope).has(binder.path)) {
      this.data.get('location').get(binder.scope).set(binder.path, []);
    }
1252
    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);
1259
    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;
      }
1269
      var start = node.textContent.indexOf('{{');
1271
      if (start !== -1 && start !== 0) {
        node = node.splitText(start);
      }
1275
      var end = node.textContent.indexOf('}}');
      var length = node.textContent.length;
1278
      if (end !== -1 && end !== length - 2) {
        var split = node.splitText(end + 2);
        this.add(split, context);
      }
1283
      this.bind(node, 'o-text', node.textContent, context);
    } else if (node.nodeType === Node.ELEMENT_NODE) {
      var skipChildren = false;
      var attributes = node.attributes;
1288
      for (var i = 0, l = attributes.length; i < l; i++) {
        var attribute = attributes[i];
1291
        if (attribute.name === 'o-html' || attribute.name === 'o-scope' || attribute.name.indexOf('o-each') === 0) {
          skipChildren = true;
        }
1295
        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;
        }
1299
        this.bind(node, attribute.name, attribute.value, context);
      }
1302
      if ('o-value' in attributes) {
        this.bind(node, 'o-value', attributes['o-value'].value, context);
      }
1306
      if (skipChildren) return;
1308
      for (var _i3 = 0; _i3 < node.childNodes.length; _i3++) {
        this.add(node.childNodes[_i3], context);
      }
    }
  }
};
1315
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');
    }
1322
    return $return();
  });
}
1326
var Fetcher = {
  header: 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 = '';
1356
      for (var name in data) {
        query = query.length > 0 ? query + '&' : query;
        query = query + encodeURIComponent(name) + '=' + encodeURIComponent(data[name]);
      }
1361
      return $return(query);
    });
  },
  fetch: function fetch(options) {
    return new Promise(function ($return, $error) {
      var data, copy, result, fetched, _copy, _result2;
1368
      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;
1391
      if (data.contentType) {
        data.headers = data.headers || {};
1394
        switch (data.contentType) {
          case 'js':
            data.headers['Content-Type'] = this.mime.js;
            break;
1399
          case 'xml':
            data.headers['Content-Type'] = this.mime.xml;
            break;
1403
          case 'html':
            data.headers['Content-Type'] = this.mime.html;
            break;
1407
          case 'json':
            data.headers['Content-Type'] = this.mime.json;
            break;
1411
          default:
            data.headers['Content-Type'] = data.contentType;
        }
      }
1416
      if (data.acceptType) {
        data.headers = data.headers || {};
1419
        switch (data.acceptType) {
          case 'js':
            data.headers['Accept'] = this.mime.js;
            break;
1424
          case 'xml':
            data.headers['Accept'] = this.mime.xml;
            break;
1428
          case 'html':
            data.headers['Accept'] = this.mime.html;
            break;
1432
          case 'json':
            data.headers['Accept'] = this.mime.json;
            break;
1436
          default:
            data.headers['Accept'] = data.acceptType;
        }
      }
1441
      if (typeof this.request === 'function') {
        copy = Object.assign({}, data);
        return Promise.resolve(this.request(copy)).then(function ($await_40) {
          try {
            result = $await_40;
1447
            if (result === false) {
              return $return(data);
            }
1451
            if (_typeof(result) === 'object') {
              Object.assign(data, result);
            }
1455
            return $If_1.call(this);
          } catch ($boundEx) {
            return $error($boundEx);
          }
        }.bind(this), $error);
      }
1462
      function $If_1() {
        if (data.body) {
          if (data.method === 'GET') {
            return Promise.resolve(this.serialize(data.body)).then(function ($await_41) {
              try {
                data.url = data.url + '?' + $await_41;
                return $If_5.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          } else {
            if (data.contentType === 'json') {
              data.body = JSON.stringify(data.body);
            }
1478
            return $If_5.call(this);
          }
1481
          function $If_5() {
            return $If_2.call(this);
          }
        }
1486
        function $If_2() {
          return Promise.resolve(window.fetch(data.url, Object.assign({}, data))).then(function ($await_42) {
            try {
              fetched = $await_42;
              data.code = fetched.status;
              data.message = fetched.statusText;
1493
              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_43) {
                  try {
                    data.body = $await_43;
                    return $If_3.call(this);
                  } catch ($boundEx) {
                    return $error($boundEx);
                  }
                }.bind(this), $error);
              }
1507
              function $If_3() {
                if (this.response) {
                  _copy = Object.assign({}, data);
                  return Promise.resolve(this.response(_copy)).then(function ($await_44) {
                    try {
                      _result2 = $await_44;
1514
                      if (_result2 === false) {
                        return $return(data);
                      }
1518
                      if (_typeof(_result2) === 'object') {
                        Object.assign(data, _result2);
                      }
1522
                      return $If_4.call(this);
                    } catch ($boundEx) {
                      return $error($boundEx);
                    }
                  }.bind(this), $error);
                }
1529
                function $If_4() {
                  return $return(data);
                }
1533
                return $If_4.call(this);
              }
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }
1541
        return $If_2.call(this);
      }
1544
      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));
  }
};
1621
function Submit(event) {
  return new Promise(function ($return, $error) {
    var data, elements, i, l, element, type, binder, value, name, submit, options, result;
1625
    if (event.target.hasAttribute('o-submit') === false) {
      return $return();
    }
1629
    event.preventDefault();
    data = {};
    elements = event.target.querySelectorAll('*');
1633
    for (i = 0, l = elements.length; i < l; i++) {
      element = elements[i];
      type = element.type;
1637
      if (!type && name !== 'TEXTAREA' || type === 'submit' || type === 'button' || !type) {
          continue;
        }
1641
      binder = Binder.get('attribute', element, 'o-value');
      value = binder ? binder.data : element.value;
      name = element.name || (binder ? binder.values[binder.values.length - 1] : i);
      if (!name) continue;
      data[name] = value;
    }
1648
    submit = Binder.get('attribute', event.target, 'o-submit');
    return Promise.resolve(submit.data.call(submit.container, data, event)).then(function ($await_45) {
      try {
        options = $await_45;
1653
        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_46) {
            try {
              result = $await_46;
1661
              if (options.handler) {
                return Promise.resolve(options.handler(result)).then(function ($await_47) {
                  try {
                    return $If_7.call(this);
                  } catch ($boundEx) {
                    return $error($boundEx);
                  }
                }.bind(this), $error);
              }
1671
              function $If_7() {
                return $If_6.call(this);
              }
1675
              return $If_7.call(this);
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }
1682
        function $If_6() {
          if (event.target.hasAttribute('o-reset') || _typeof(options) === 'object' && options.reset) {
            event.target.reset();
          }
1687
          return $return();
        }
1690
        return $If_6.call(this);
      } catch ($boundEx) {
        return $error($boundEx);
      }
    }.bind(this), $error);
  });
}
1698
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');
    }
1705
    return $return();
  });
}
1709
function Reset(event) {
  return new Promise(function ($return, $error) {
    if (event.target.hasAttribute('o-reset') === false) {
      return $return();
    }
1715
    event.preventDefault();
    var elements = event.target.querySelectorAll('*');
1718
    for (var i = 0, l = elements.length; i < l; i++) {
      var element = elements[i];
      var name = element.nodeName;
      var type = element.type;
1723
      if (!type && name !== 'TEXTAREA' || type === 'submit' || type === 'button' || !type) {
          continue;
        }
1727
      var binder = Binder.get('attribute', element, 'o-value');
1729
      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 = '';
      }
    }
1748
    return $return();
  });
}
1752
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 : '/');
  },
1760
  setup: function setup(option) {
    return new Promise(function ($return, $error) {
      option = option || {};
1764
      if (option.base) {
        BASE = window.document.querySelector('base');
1767
        if (!BASE) {
          BASE = window.document.createElement('base');
          window.document.head.insertBefore(BASE, window.document.head.firstElementChild);
        }
1772
        BASE.href = option.base;
      }
1775
      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 + '//';
1788
    if (data.slice(0, origin.length) === origin) {
      data = data.slice(origin.length);
    }
1792
    if (data.slice(0, protocol.length) === protocol) {
      data = data.slice(protocol.length);
    }
1796
    if (data.slice(-hash.length) === hash) {
      data = data.slice(0, -hash.length);
    }
1800
    if (data.slice(-search.length) === search) {
      data = data.slice(0, -search.length);
    }
1804
    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 : '/';
1814
    if (data !== '/' && data.slice(-1) === '/') {
      data = data.slice(0, -1);
    }
1818
    return data;
  },
  join: function join() {
    if (!arguments.length) {
      throw new Error('Oxe.path.join - argument required');
    }
1825
    var result = [];
1827
    for (var i = 0, l = arguments.length; i < l; i++) {
      result.push(arguments[i]);
    }
1831
    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;
1861
    for (var index = 0; index < string.length; index++) {
      var character = string[index];
1864
      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);
        }
      }
    }
1886
    string = string.replace(/\${(.*?)}/g, '\'+$1+\'');
1888
    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) || [];
1903
    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];
1909
      if (pathImport.slice(0, 1) !== '/') {
        pathImport = Path.normalize(parentImport + '/' + pathImport);
      } else {
        pathImport = Path.normalize(pathImport);
      }
1915
      before = before + '\t$LOADER.load("' + pathImport + '"),\n';
      after = after + 'var ' + nameImport + ' = $MODULES[' + i + '].default;\n';
      code = code.replace(rawImport, '');
    }
1920
    if (this.exp.test(code)) {
      code = code.replace(this.exp, 'var $DEFAULT = ');
      code = code + '\n\nreturn { default: $DEFAULT };\n';
    }
1925
    code = '"use strict";\n' + before + after + code + '});';
    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;
1938
      if (options.loads) {
        return $return(Promise.all(options.loads.map(function (load) {
          return self.load(load);
        })));
      }
1944
      return $return();
    }.bind(this));
  },
  fetch: function fetch(url, type) {
    return new Promise(function ($return, $error) {
      var data, code;
      return Promise.resolve(window.fetch(url)).then(function ($await_48) {
        try {
          data = $await_48;
1954
          if (data.status == 404) {
            return $error(new Error('Oxe.loader.load - not found ' + url));
          }
1958
          if (data.status < 200 || data.status > 300 && data.status != 304) {
            return $error(new Error(data.statusText));
          }
1962
          return Promise.resolve(data.text()).then(function ($await_49) {
            try {
              code = $await_49;
1966
              if (type === 'es' || type === 'est') {
                code = Transformer.template(code);
              }
1970
              if (type === 'es' || type === 'esm') {
                code = Transformer.module(code, url);
              }
1974
              code = new Function('window', 'document', '$LOADER', code);
              this.data[url] = code(window, window.document, this);
              return $return(this.data[url]);
            } 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;
1992
      if (_typeof($args[0]) === 'object') {
        url = $args[0]['url'];
        type = $args[0]['type'];
      } else {
        url = $args[0];
        type = $args[1] || this.type;
      }
2000
      if (!url) {
        return $error(new Error('Oxe.loader.load - url argument required'));
      }
2004
      url = Path.normalize(url);
2006
      if (url in this.data === false) {
        this.data[url] = this.fetch(url, type);
      }
2010
      return $return(this.data[url]);
    }.bind(this));
  }
};
var EVENTS = {};
var Events = {
  get events() {
    return EVENTS;
  },
2020
  on: function on(name, method) {
    if (!(name in this.events)) {
      this.events[name] = [];
    }
2025
    this.events[name].push(method);
  },
  off: function off(name, method) {
    if (name in this.events) {
      var _index3 = this.events[name].indexOf(method);
2031
      if (_index3 !== -1) {
        this.events[name].splice(_index3, 1);
      }
    }
  },
  emit: function emit(name) {
    if (name in this.events) {
      var methods = this.events[name];
      var args = Array.prototype.slice.call(arguments, 1);
2041
      for (var i = 0, l = methods.length; i < l; i++) {
        methods[i].apply(this, args);
      }
    }
  }
};
var DATA$1 = {};
var Methods = {
  get data() {
    return DATA$1;
  },
2053
  get: function get(path) {
    return Utility.getByPath(this.data, path);
  },
  set: function set(path, data) {
    return Utility.setByPath(this.data, path, data);
  }
};
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;
2067
    if (typeof startIndex !== 'number' || typeof deleteCount !== 'number') {
      return [];
    }
2071
    if (startIndex < 0) {
      startIndex = self.length + startIndex;
      startIndex = startIndex > 0 ? startIndex : 0;
    } else {
      startIndex = startIndex < self.length ? startIndex : self.length;
    }
2078
    if (deleteCount < 0) {
      deleteCount = 0;
    } else if (deleteCount > self.length - startIndex) {
      deleteCount = self.length - startIndex;
    }
2084
    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;
2092
    if (self.length !== length) {
      promises.push(self.$meta.listener.bind(null, self, self.$meta.path.slice(0, -1), 'length'));
    }
2096
    if (updateCount > 0) {
      var value;
      var _index4 = startIndex;
2100
      while (updateCount--) {
        var key = _index4++;
2103
        if (argumentsCount && argumentIndex < argumentsCount) {
          value = arguments[argumentIndex++];
        } else {
          value = self.$meta[_index4];
        }
2109
        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));
      }
    }
2114
    if (addCount > 0) {
      while (addCount--) {
        var _key = self.length;
2118
        if (_key in this === false) {
          Object.defineProperty(this, _key, Observer.descriptor(_key));
        }
2122
        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));
      }
    }
2127
    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));
      }
    }
2136
    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;
2150
          for (var i = 0, l = arguments.length; i < l; i++) {
            self.splice.call(this, this.length, 0, arguments[i]);
          }
2154
          return this.length;
        }
      },
      unshift: {
        value: function value() {
          if (!arguments.length) return this.length;
2161
          for (var i = 0, l = arguments.length; i < l; i++) {
            self.splice.call(this, 0, 0, arguments[i]);
          }
2165
          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));
            }
2202
            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;
    }
2245
    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;
2255
    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);
      }
    }
2262
    if (type === Object) {
      for (var _key3 in source) {
        descriptors.$meta.value[_key3] = this.create(source[_key3], listener, path + _key3);
        descriptors[_key3] = this.descriptor(_key3);
      }
    }
2269
    Object.defineProperties(target, descriptors);
    Object.defineProperties(target, this.objectProperties(source, listener, path));
2272
    if (type === Array) {
      Object.defineProperties(target, this.arrayProperties(source, listener, path));
    }
2276
    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;
2297
    if (typeof keys === 'string') {
      keys = keys.split('.');
    }
2301
    var data = this.data;
    var key = keys[keys.length - 1];
2304
    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]) ? {} : []);
        }
      }
2313
      data = data[keys[i]];
    }
2316
    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);
    }
2325
    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;
  },
2360
  get sheet() {
    return SHEET;
  },
2364
  add: function add(data) {
    this.sheet.insertRule(data);
  },
  append: function append(data) {
    this.style.appendChild(document.createTextNode(data));
  },
  setup: function setup() {
    return new Promise(function ($return, $error) {
      this.append("\n\t\t\t*[hidden] {\n\t\t\t\tdisplay: none !important;\n\t\t\t}\n\t\t\to-router, o-router > :first-child {\n\t\t\t\tdisplay: block;\n\t\t\t\tanimation: o-transition var(--o-transition) ease-in-out;\n\t\t\t}\n\t\t\t@keyframes o-transition {\n\t\t\t\t0% { opacity: 0; }\n\t\t\t\t100% { opacity: 1; }\n\t\t\t}\n\t\t");
      document.head.appendChild(this.style);
      return $return();
    }.bind(this));
  }
};
var Component = {
  data: {},
  compiled: false,
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      var self, i, l, component, load;
      self = this;
      options = options || {};
2387
      if (options.components) {
        i = 0, l = options.components.length;
        var $Loop_9_trampoline;
2391
        function $Loop_9_step() {
          i++;
          return $Loop_9;
        }
2396
        function $Loop_9() {
          if (i < l) {
            component = options.components[i];
2400
            if (typeof component === 'string') {
              return Promise.resolve(Loader.load(component)).then(function ($await_50) {
                try {
                  load = $await_50;
                  component = load.default;
                  return $If_11.call(this);
                } catch ($boundEx) {
                  return $error($boundEx);
                }
              }.bind(this), $error);
            }
2412
            function $If_11() {
              self.define(component);
              return $Loop_9_step;
            }
2417
            return $If_11.call(this);
          } else return [1];
        }
2421
        return ($Loop_9_trampoline = function (q) {
          while (q) {
            if (q.then) return void q.then($Loop_9_trampoline, $error);
2425
            try {
              if (q.pop) {
                if (q.length) return q.pop() ? $Loop_9_exit.call(this) : q;else q = $Loop_9_step;
              } else q = q.call(this);
            } catch (_exception) {
              return $error(_exception);
            }
          }
        }.bind(this))($Loop_9);
2435
        function $Loop_9_exit() {
          return $If_8.call(this);
        }
      }
2440
      function $If_8() {
        return $return();
      }
2444
      return $If_8.call(this);
    }.bind(this));
  },
  style: function style(_style, name) {
    if (!window.CSS || !window.CSS.supports || !window.CSS.supports('(--t: black)')) {
      var matches = _style.match(/--\w+(?:-+\w+)*:\s*.*?;/g) || [];
2451
      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]);
      }
    }
2460
    if (!window.CSS || !window.CSS.supports || !window.CSS.supports(':host')) {
      _style = _style.replace(/:host/g, name);
    }
2464
    return _style;
  },
  slot: function slot(element, fragment) {
    var fragmentSlots = fragment.querySelectorAll('slot[name]');
    var defaultSlot = fragment.querySelector('slot:not([name])');
2470
    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 + '"]');
2475
      if (elementSlot) {
        fragmentSlot.parentNode.replaceChild(elementSlot, fragmentSlot);
      } else {
        fragmentSlot.parentNode.removeChild(fragmentSlot);
      }
    }
2482
    if (defaultSlot) {
      if (element.children.length) {
        while (element.firstChild) {
          defaultSlot.parentNode.insertBefore(element.firstChild, defaultSlot);
        }
      }
2489
      defaultSlot.parentNode.removeChild(defaultSlot);
    }
  },
  fragment: function fragment(element, options) {
    var fragment = document.createDocumentFragment();
    var clone = options.clone.cloneNode(true);
2496
    while (clone.firstElementChild) {
      if (!options.adopt) {
        Binder.add(clone.firstElementChild, {
          container: element,
          scope: element.scope
        });
      }
2504
      fragment.appendChild(clone.firstElementChild);
    }
2507
    return fragment;
  },
  render: function render(element, options) {
    if (this.compiled && element.parentElement.nodeName === 'O-ROUTER') {
      return;
    }
2514
    if (!options.template) {
      return;
    }
2518
    var fragment;
2520
    if (options.template) {
      fragment = this.fragment(element, options);
    }
2524
    var root;
2526
    if (options.shadow && 'attachShadow' in document.body) {
      root = element.attachShadow({
        mode: 'open'
      });
    } else if (options.shadow && 'createShadowRoot' in document.body) {
      root = element.createShadowRoot();
    } else {
      if (fragment) {
        this.slot(element, fragment);
      }
2537
      root = element;
    }
2540
    if (fragment) {
      root.appendChild(fragment);
    }
2544
    if (options.adopt) {
      var e = root.firstElementChild;
2547
      while (e) {
        Binder.add(e, {
          container: element,
          scope: element.scope
        });
        e = e.nextElementSibling;
      }
    }
  },
  define: function define(options) {
    var self = this;
2559
    if (_typeof(options) !== 'object') {
      return console.warn('Oxe.component.define - invalid argument type');
    }
2563
    if (options.constructor === Array) {
      for (var i = 0, l = options.length; i < l; i++) {
        self.define(options[i]);
      }
2568
      return;
    }
2571
    if (!options.name) throw new Error('Oxe.component.define - requires name');
    options.name = options.name.toLowerCase();
    if (options.name in self.data) throw new Error('Oxe.component.define - component previously defined');
    self.data[options.name] = options;
    options.count = 0;
    options.style = options.style || '';
    options.model = options.model || {};
    options.methods = options.methods || {};
    options.adopt = options.adopt || false;
    options.shadow = options.shadow || false;
    options.template = options.template || '';
    options.attributes = options.attributes || [];
    options.properties = options.properties || {};
2585
    if (options.style) {
      var style = this.style(options.style, options.name);
      Style$1.append(style);
    }
2590
    if (options.template) {
      options.clone = document.createElement('div');
      options.clone.innerHTML = options.template;
    }
2595
    var construct = function construct() {
      var instance = window.Reflect.construct(HTMLElement, [], this.constructor);
      var properties = Utility.clone(options.properties);
      var methods = Utility.clone(options.methods);
      var model = Utility.clone(options.model);
      var scope = options.name + '-' + options.count++;
      properties.created = {
        value: false,
        enumerable: true,
        configurable: true
      };
      properties.scope = {
        enumerable: true,
        value: scope
      };
      properties.model = {
        enumerable: true,
        get: function get() {
          return Model.get(scope);
        },
        set: function set(data) {
          return Model.set(scope, data && _typeof(data) === 'object' ? data : {});
        }
      };
      properties.methods = {
        enumerable: true,
        get: function get() {
          return Methods.get(scope);
        }
      };
      Object.defineProperties(instance, properties);
      Methods.set(scope, methods);
      Model.set(scope, model);
      return instance;
    };
2631
    construct.observedAttributes = options.attributes;
2633
    construct.prototype.attributeChangedCallback = function () {
      if (options.attributed) options.attributed.apply(this, arguments);
    };
2637
    construct.prototype.adoptedCallback = function () {
      if (options.adopted) options.adopted.call(this);
    };
2641
    construct.prototype.connectedCallback = function () {
      if (!this.created) {
        self.render(this, options);
        Object.defineProperty(this, 'created', {
          value: true,
          enumerable: true,
          configurable: false
        });
2650
        if (options.created) {
          options.created.call(this);
        }
      }
2655
      if (options.attached) {
        options.attached.call(this);
      }
    };
2660
    construct.prototype.disconnectedCallback = function () {
      if (options.detached) {
        options.detached.call(this);
      }
    };
2666
    Object.setPrototypeOf(construct.prototype, HTMLElement.prototype);
    Object.setPrototypeOf(construct, HTMLElement);
    window.customElements.define(options.name, construct);
  }
};
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,
  compiled: false,
  folder: './routes',
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      var ORouter;
      options = options || {};
      this.base = options.base === undefined ? this.base : options.base;
      this.mode = options.mode === undefined ? this.mode : options.mode;
      this.after = options.after === undefined ? this.after : options.after;
      this.folder = options.folder === undefined ? this.folder : options.folder;
      this.before = options.before === undefined ? this.before : options.before;
      this.change = options.change === undefined ? this.change : options.change;
      this.target = options.target === undefined ? this.target : options.target;
      this.contain = options.contain === undefined ? this.contain : options.contain;
      this.external = options.external === undefined ? this.external : options.external;
2698
      if (!this.target || typeof this.target === 'string') {
        this.target = document.body.querySelector(this.target || 'o-router');
      }
2702
      if (!this.target) return $error(new Error('Oxe.router.setup - target option required'));
2704
      ORouter = function ORouter() {
        return window.Reflect.construct(HTMLElement, [], this.constructor);
      };
2708
      Object.setPrototypeOf(ORouter.prototype, HTMLElement.prototype);
      Object.setPrototypeOf(ORouter, HTMLElement);
      window.customElements.define('o-router', ORouter);
      return Promise.resolve(this.add(options.routes)).then(function ($await_51) {
        try {
          return Promise.resolve(this.route(window.location.href, {
            mode: 'replace'
          })).then(function ($await_52) {
            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);
2733
    if (userParts.length > 1 && userParts[userParts.length - 1] === '') {
      userParts.pop();
    }
2737
    if (routeParts.length > 1 && routeParts[routeParts.length - 1] === '') {
      routeParts.pop();
    }
2741
    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]);
      }
    }
2759
    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);
2770
    if (userPath.slice(0, base.length) !== base) {
      userPath = Path.join(base, userPath);
    }
2774
    if (routePath.slice(0, base.length) !== base) {
      routePath = Path.join(base, routePath);
    }
2778
    if (this.compareParts(routePath, userPath, '/')) {
      return true;
    }
2782
    if (this.compareParts(routePath, userPath, '-')) {
      return true;
    }
2786
    return false;
  },
  toParameterObject: function toParameterObject(routePath, userPath) {
    var result = {};
    if (!routePath || !userPath || routePath === '/' || userPath === '/') return result;
    var userParts = userPath.split(/\/|-/);
    var routeParts = routePath.split(/\/|-/);
2794
    for (var i = 0, l = routeParts.length; i < l; i++) {
      var part = routeParts[i];
2797
      if (part.slice(0, 1) === '(' && part.slice(-1) === ')') {
        var name = part.slice(1, part.length - 1).replace('~', '');
        result[name] = userParts[i];
      }
    }
2803
    return result;
  },
  toQueryString: function toQueryString(data) {
    var result = '?';
2808
    for (var key in data) {
      var value = data[key];
      result += key + '=' + value + '&';
    }
2813
    if (result.slice(-1) === '&') {
      result = result.slice(0, -1);
    }
2817
    return result;
  },
  toQueryObject: function toQueryObject(path) {
    var result = {};
    if (path.indexOf('?') === 0) path = path.slice(1);
    var queries = path.split('&');
2824
    for (var i = 0, l = queries.length; i < l; i++) {
      var query = queries[i].split('=');
2827
      if (query[0] && query[1]) {
        result[query[0]] = query[1];
      }
    }
2832
    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;
2865
      if (!data) {
        return $return();
      } else {
        if (data.constructor === String) {
          path = data;
2871
          if (path.slice(-3) === '.js') {
            path = path.slice(0, -3);
          }
2875
          load = path;
2877
          if (path.slice(-5) === 'index') {
            path = path.slice(0, -5);
          }
2881
          if (path.slice(-6) === 'index/') {
            path = path.slice(0, -6);
          }
2885
          if (path.slice(0, 2) === './') {
            path = path.slice(2);
          }
2889
          if (path.slice(0, 1) !== '/') {
            path = '/' + path;
          }
2893
          load = load + '.js';
          load = Path.join(this.folder, load);
          this.data.push({
            path: path,
            load: load
          });
          return $If_13.call(this);
        } else {
          if (data.constructor === Object) {
            if (!data.path) {
              return $error(new Error('Oxe.router.add - route path required'));
            }
2906
            if (!data.load && !data.component) {
              return $error(new Error('Oxe.router.add -  route.component or route.load required'));
            }
2910
            this.data.push(data);
            return $If_14.call(this);
          } else {
            if (data.constructor === Array) {
              i = 0, l = data.length;
              var $Loop_16_trampoline;
2917
              function $Loop_16_step() {
                i++;
                return $Loop_16;
              }
2922
              function $Loop_16() {
                if (i < l) {
                  return Promise.resolve(this.add(data[i])).then(function ($await_53) {
                    try {
                      return $Loop_16_step;
                    } catch ($boundEx) {
                      return $error($boundEx);
                    }
                  }, $error);
                } else return [1];
              }
2934
              return ($Loop_16_trampoline = function (q) {
                while (q) {
                  if (q.then) return void q.then($Loop_16_trampoline, $error);
2938
                  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);
2948
              function $Loop_16_exit() {
                return $If_15.call(this);
              }
            }
2953
            function $If_15() {
              return $If_14.call(this);
            }
2957
            return $If_15.call(this);
          }
2960
          function $If_14() {
            return $If_13.call(this);
          }
        }
2965
        function $If_13() {
          return $If_12.call(this);
        }
      }
2970
      function $If_12() {
        return $return();
      }
2974
      return $If_12.call(this);
    }.bind(this));
  },
  load: function load(route) {
    return new Promise(function ($return, $error) {
      var load, _load;
2981
      if (route.load) {
        return Promise.resolve(Loader.load(route.load)).then(function ($await_54) {
          try {
            load = $await_54;
            route = Object.assign({}, load.default, route);
            return $If_18.call(this);
          } catch ($boundEx) {
            return $error($boundEx);
          }
        }.bind(this), $error);
      }
2993
      function $If_18() {
        if (typeof route.component === 'string') {
          route.load = route.component;
          return Promise.resolve(Loader.load(route.load)).then(function ($await_55) {
            try {
              _load = $await_55;
              route.component = _load.default;
              return $If_19.call(this);
            } catch ($boundEx) {
              return $error($boundEx);
            }
          }.bind(this), $error);
        }
3007
        function $If_19() {
          return $return(route);
        }
3011
        return $If_19.call(this);
      }
3014
      return $If_18.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);
        }
      }
3025
      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_20_trampoline;
3034
      function $Loop_20_step() {
        i++;
        return $Loop_20;
      }
3039
      function $Loop_20() {
        if (i < l) {
          if (this.data[i].path === path) {
            return Promise.resolve(this.load(this.data[i])).then(function ($await_56) {
              try {
                this.data[i] = $await_56;
                return $return(this.data[i]);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3052
          return $Loop_20_step;
        } else return [1];
      }
3056
      return ($Loop_20_trampoline = function (q) {
        while (q) {
          if (q.then) return void q.then($Loop_20_trampoline, $error);
3060
          try {
            if (q.pop) {
              if (q.length) return q.pop() ? $Loop_20_exit.call(this) : q;else q = $Loop_20_step;
            } else q = q.call(this);
          } catch (_exception) {
            return $error(_exception);
          }
        }
      }.bind(this))($Loop_20);
3070
      function $Loop_20_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_23_trampoline;
3082
      function $Loop_23_step() {
        i++;
        return $Loop_23;
      }
3087
      function $Loop_23() {
        if (i < l) {
          if (this.compare(this.data[i].path, path)) {
            return Promise.resolve(this.load(this.data[i])).then(function ($await_57) {
              try {
                this.data[i] = $await_57;
                result.push(this.data[i]);
                return $If_25.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3101
          function $If_25() {
            return $Loop_23_step;
          }
3105
          return $If_25.call(this);
        } else return [1];
      }
3109
      return ($Loop_23_trampoline = function (q) {
        while (q) {
          if (q.then) return void q.then($Loop_23_trampoline, $error);
3113
          try {
            if (q.pop) {
              if (q.length) return q.pop() ? $Loop_23_exit.call(this) : q;else q = $Loop_23_step;
            } else q = q.call(this);
          } catch (_exception) {
            return $error(_exception);
          }
        }
      }.bind(this))($Loop_23);
3123
      function $Loop_23_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_26_trampoline;
3134
      function $Loop_26_step() {
        i++;
        return $Loop_26;
      }
3139
      function $Loop_26() {
        if (i < l) {
          if (this.compare(this.data[i].path, path)) {
            return Promise.resolve(this.load(this.data[i])).then(function ($await_58) {
              try {
                this.data[i] = $await_58;
                return $return(this.data[i]);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3152
          return $Loop_26_step;
        } else return [1];
      }
3156
      return ($Loop_26_trampoline = function (q) {
        while (q) {
          if (q.then) return void q.then($Loop_26_trampoline, $error);
3160
          try {
            if (q.pop) {
              if (q.length) return q.pop() ? $Loop_26_exit.call(this) : q;else q = $Loop_26_step;
            } else q = q.call(this);
          } catch (_exception) {
            return $error(_exception);
          }
        }
      }.bind(this))($Loop_26);
3170
      function $Loop_26_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.'));
      }
3181
      if (!route.component && !route.target) {
        return $error(new Error('Oxe.render - route property required. Missing component or target option.'));
      }
3185
      if (route.title) {
        document.title = route.title;
      }
3189
      if (route.description) {
        Utility.ensureElement({
          name: 'meta',
          scope: document.head,
          position: 'afterbegin',
          query: '[name="description"]',
          attributes: [{
            name: 'name',
            value: 'description'
          }, {
            name: 'content',
            value: route.description
          }]
        });
      }
3205
      if (route.keywords) {
        Utility.ensureElement({
          name: 'meta',
          scope: document.head,
          position: 'afterbegin',
          query: '[name="keywords"]',
          attributes: [{
            name: 'name',
            value: 'keywords'
          }, {
            name: 'content',
            value: route.keywords
          }]
        });
      }
3221
      if (!route.target) {
        if (route.component.constructor === String) {
          route.target = window.document.createElement(route.component);
        } else if (route.component.constructor === Object) {
          Component.define(route.component);
3227
          if (this.compiled) {
            route.target = this.target.firstElementChild;
            this.scroll(0, 0);
            return $return();
          } else {
            route.target = window.document.createElement(route.component.name);
          }
        }
      }
3237
      while (this.target.firstChild) {
        this.target.removeChild(this.target.firstChild);
      }
3241
      this.target.appendChild(route.target);
      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 || {};
3251
      if (options.query) {
        path += this.toQueryString(options.query);
      }
3255
      mode = options.mode || this.mode;
      location = this.toLocationObject(path);
      return Promise.resolve(this.find(location.pathname)).then(function ($await_59) {
        try {
          route = $await_59;
3261
          if (!route) {
            return $error(new Error("Oxe.router.route - missing route ".concat(location.pathname)));
          }
3265
          location.route = route;
          location.title = location.route.title;
          location.query = this.toQueryObject(location.search);
          location.parameters = this.toParameterObject(location.route.path, location.pathname);
3270
          if (location.route && location.route.handler) {
            return Promise.resolve(location.route.handler(location)).then($return, $error);
          }
3274
          if (location.route && location.route.redirect) {
            return Promise.resolve(this.redirect(location.route.redirect)).then($return, $error);
          }
3278
          function $If_30() {
            if (typeof this.before === 'function') {
              return Promise.resolve(this.before(location)).then(function ($await_62) {
                try {
                  return $If_31.call(this);
                } catch ($boundEx) {
                  return $error($boundEx);
                }
              }.bind(this), $error);
            }
3289
            function $If_31() {
              this.emit('route:before', location);
3292
              if (mode === 'href' || this.compiled) {
                return $return(window.location.assign(location.path));
              }
3296
              window.history[mode + 'State']({
                path: location.path
              }, '', location.path);
              this.location = location;
              return Promise.resolve(this.render(location.route)).then(function ($await_63) {
                try {
                  if (typeof this.after === 'function') {
                    return Promise.resolve(this.after(location)).then(function ($await_64) {
                      try {
                        return $If_32.call(this);
                      } catch ($boundEx) {
                        return $error($boundEx);
                      }
                    }.bind(this), $error);
                  }
3312
                  function $If_32() {
                    this.emit('route:after', location);
                    return $return();
                  }
3317
                  return $If_32.call(this);
                } catch ($boundEx) {
                  return $error($boundEx);
                }
              }.bind(this), $error);
            }
3324
            return $If_31.call(this);
          }
3327
          if (typeof this.before === 'function') {
            return Promise.resolve(this.before(location)).then(function ($await_62) {
              try {
                return $If_31.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3337
          function $If_31() {
            this.emit('route:before', location);
3340
            if (mode === 'href' || this.compiled) {
              return $return(window.location.assign(location.path));
            }
3344
            window.history[mode + 'State']({
              path: location.path
            }, '', location.path);
            this.location = location;
            return Promise.resolve(this.render(location.route)).then(function ($await_63) {
              try {
                if (typeof this.after === 'function') {
                  return Promise.resolve(this.after(location)).then(function ($await_64) {
                    try {
                      return $If_32.call(this);
                    } catch ($boundEx) {
                      return $error($boundEx);
                    }
                  }.bind(this), $error);
                }
3360
                function $If_32() {
                  this.emit('route:after', location);
                  return $return();
                }
3365
                return $If_32.call(this);
              } catch ($boundEx) {
                return $error($boundEx);
              }
            }.bind(this), $error);
          }
3372
          return $If_31.call(this);
        } catch ($boundEx) {
          return $error($boundEx);
        }
      }.bind(this), $error);
    }.bind(this));
  }
};
3381
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();
    }
3387
    var target = event.path ? event.path[0] : event.target;
    var parent = target.parentElement;
3390
    if (Router.contain) {
      while (parent) {
        if (parent.nodeName === 'O-ROUTER') {
          break;
        } else {
          parent = parent.parentElement;
        }
      }
3399
      if (parent.nodeName !== 'O-ROUTER') {
        return $return();
      }
    }
3404
    while (target && 'A' !== target.nodeName) {
      target = target.parentElement;
    }
3408
    if (!target || 'A' !== target.nodeName) {
      return $return();
    }
3412
    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 (Router.external && (Router.external.constructor === RegExp && Router.external.test(target.href) || Router.external.constructor === Function && Router.external(target.href) || Router.external.constructor === String && Router.external === target.href)) return $return();
    event.preventDefault();
3416
    if (Router.location.href !== target.href) {
      Router.route(target.href);
    }
3420
    return $return();
  });
}
3424
function State(event) {
  return new Promise(function ($return, $error) {
    var path = event && event.state ? event.state.path : window.location.href;
    Router.route(path, {
      mode: 'replace'
    });
    return $return();
  });
}
3434
function Listener(option, method, event) {
  var type = event.type;
  var before;
  var after;
3439
  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;
  }
3444
  Promise.resolve().then(before).then(method.bind(null, event)).then(after);
}
3447
if (window.Reflect === undefined) {
  window.Reflect = window.Reflect || {};
3450
  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;
  };
}
3458
var oSetup = document.querySelector('script[o-setup]');
3460
if (oSetup) {
  var options = oSetup.getAttribute('o-setup').split(/\s+|\s*,+\s*/);
  var meta = document.querySelector('meta[name="oxe"]');
3464
  if (meta && meta.getAttribute('content') === 'compiled') {
    Router.compiled = true;
    Component.compiled = true;
  }
3469
  if (!options[0]) {
    throw new Error('Oxe - script attribute o-setup requires path');
  }
3473
  Loader.type = options[1] || 'esm';
  Promise.resolve(Loader.load(options[0]));
}
3477
var SETUP = false;
var GLOBAL = {};
var index = {
  get global() {
    return GLOBAL;
  },
3484
  get window() {
    return window;
  },
3488
  get document() {
    return window.document;
  },
3492
  get body() {
    return window.document.body;
  },
3496
  get head() {
    return window.document.head;
  },
3500
  get location() {
    return this.router.location;
  },
3504
  get currentScript() {
    return window.document._currentScript || window.document.currentScript;
  },
3508
  get ownerDocument() {
    return (window.document._currentScript || window.document.currentScript).ownerDocument;
  },
3512
  get component() {
    return Component;
  },
3516
  get batcher() {
    return Batcher;
  },
3520
  get fetcher() {
    return Fetcher;
  },
3524
  get methods() {
    return Methods;
  },
3528
  get utility() {
    return Utility;
  },
3532
  get binder() {
    return Binder;
  },
3536
  get loader() {
    return Loader;
  },
3540
  get router() {
    return Router;
  },
3544
  get model() {
    return Model;
  },
3548
  get style() {
    return Style$1;
  },
3552
  get path() {
    return Path;
  },
3556
  setup: function setup(options) {
    return new Promise(function ($return, $error) {
      if (SETUP) return $return();else SETUP = true;
      options = options || {};
      options.listener = options.listener || {};
      return Promise.resolve(this.style.setup(options.style)).then(function ($await_65) {
        try {
          return Promise.resolve(this.model.setup(options.model)).then(function ($await_66) {
            try {
              return Promise.resolve(this.binder.setup(options.binder)).then(function ($await_67) {
                try {
                  document.addEventListener('click', Listener.bind(null, options, Click), true);
                  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);
                  window.addEventListener('popstate', Listener.bind(null, options, State), true);
3574
                  if (options.listener.before) {
                    return Promise.resolve(options.listener.before()).then(function ($await_68) {
                      try {
                        return $If_33.call(this);
                      } catch ($boundEx) {
                        return $error($boundEx);
                      }
                    }.bind(this), $error);
                  }
3584
                  function $If_33() {
                    if (options.path) {
                      return Promise.resolve(this.path.setup(options.path)).then(function ($await_69) {
                        try {
                          return $If_34.call(this);
                        } catch ($boundEx) {
                          return $error($boundEx);
                        }
                      }.bind(this), $error);
                    }
3595
                    function $If_34() {
                      if (options.fetcher) {
                        return Promise.resolve(this.fetcher.setup(options.fetcher)).then(function ($await_70) {
                          try {
                            return $If_35.call(this);
                          } catch ($boundEx) {
                            return $error($boundEx);
                          }
                        }.bind(this), $error);
                      }
3606
                      function $If_35() {
                        if (options.loader) {
                          return Promise.resolve(this.loader.setup(options.loader)).then(function ($await_71) {
                            try {
                              return $If_36.call(this);
                            } catch ($boundEx) {
                              return $error($boundEx);
                            }
                          }.bind(this), $error);
                        }
3617
                        function $If_36() {
                          if (options.component) {
                            return Promise.resolve(this.component.setup(options.component)).then(function ($await_72) {
                              try {
                                return $If_37.call(this);
                              } catch ($boundEx) {
                                return $error($boundEx);
                              }
                            }.bind(this), $error);
                          }
3628
                          function $If_37() {
                            if (options.router) {
                              return Promise.resolve(this.router.setup(options.router)).then(function ($await_73) {
                                try {
                                  return $If_38.call(this);
                                } catch ($boundEx) {
                                  return $error($boundEx);
                                }
                              }.bind(this), $error);
                            }
3639
                            function $If_38() {
                              if (options.listener.after) {
                                return Promise.resolve(options.listener.after()).then(function ($await_74) {
                                  try {
                                    return $If_39.call(this);
                                  } catch ($boundEx) {
                                    return $error($boundEx);
                                  }
                                }.bind(this), $error);
                              }
3650
                              function $If_39() {
                                return $return();
                              }
3654
                              return $If_39.call(this);
                            }
3657
                            return $If_38.call(this);
                          }
3660
                          return $If_37.call(this);
                        }
3663
                        return $If_36.call(this);
                      }
3666
                      return $If_35.call(this);
                    }
3669
                    return $If_34.call(this);
                  }
3672
                  return $If_33.call(this);
                } 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));
  }
};
return index;
3690});
\No newline at end of file
1	`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); }`
2
3	`(function (global, factory) {`
4	`(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());`
5	`})(this, function () {`
6	`'use strict';`
7
8	`var Utility = {`
9	`PIPE: /\s?\\|\s?/,`
10	`PIPES: /\s?,\s?\|\s+/,`
11	`value: function value(element, model) {`
12	`if (!model) throw new Error('Utility.value - requires model argument');`
13	`if (!element) throw new Error('Utility.value - requires element argument');`
14	`var type = this.type(element);`
15
16	`if (type === 'radio' \|\| type === 'checkbox') {`
17	`var name = this.name(element);`
18	`var query = 'input[type="' + type + '"][name="' + name + '"]';`
19	`var form = this.form(element);`
20	`var elements = form ? this.form(element).querySelectorAll(query) : [element];`
21	`var multiple = elements.length > 1;`
22	`var result = multiple ? [] : undefined;`
23
24	`for (var i = 0, l = elements.length; i < l; i++) {`
25	`var child = elements[i];`
26	`var checked = this.checked(child);`
27	`if (!checked) continue;`
28	`var value = this.value(child, model);`
29
30	`if (multiple) {`
31	`result.push(value);`
32	`} else {`
33	`result = value;`
34	`break;`
35	`}`
36	`}`
37
38	`return result;`
39	`} else if (type === 'select-one' \|\| type === 'select-multiple') {`
40	`var _multiple = this.multiple(element);`