text: /* */ 
  define(['exports', 'aurelia-pal'], function (exports, _aureliaPal) {
    'use strict';
  
    Object.defineProperty(exports, "__esModule", {
      value: true
    });
    exports._DOM = exports._FEATURE = exports._PLATFORM = undefined;
    exports.initialize = initialize;
  
    var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  
    var _PLATFORM = exports._PLATFORM = {
      location: window.location,
      history: window.history,
      addEventListener: function addEventListener(eventName, callback, capture) {
        this.global.addEventListener(eventName, callback, capture);
      },
      removeEventListener: function removeEventListener(eventName, callback, capture) {
        this.global.removeEventListener(eventName, callback, capture);
      },
  
      performance: window.performance,
      requestAnimationFrame: function requestAnimationFrame(callback) {
        return this.global.requestAnimationFrame(callback);
      }
    };
  
    if (typeof FEATURE_NO_IE === 'undefined') {
      var test = function test() {};
  
      if (test.name === undefined) {
        Object.defineProperty(Function.prototype, 'name', {
          get: function get() {
            var name = this.toString().match(/^\s*function\s*(\S*)\s*\(/)[1];
  
            Object.defineProperty(this, 'name', { value: name });
            return name;
          }
        });
      }
    }
  
    if (typeof FEATURE_NO_IE === 'undefined') {
      if (!('classList' in document.createElement('_')) || document.createElementNS && !('classList' in document.createElementNS('http://www.w3.org/2000/svg', 'g'))) {
        (function () {
          var protoProp = 'prototype';
          var strTrim = String.prototype.trim;
          var arrIndexOf = Array.prototype.indexOf;
          var emptyArray = [];
  
          var DOMEx = function DOMEx(type, message) {
            this.name = type;
            this.code = DOMException[type];
            this.message = message;
          };
  
          var checkTokenAndGetIndex = function checkTokenAndGetIndex(classList, token) {
            if (token === '') {
              throw new DOMEx('SYNTAX_ERR', 'An invalid or illegal string was specified');
            }
  
            if (/\s/.test(token)) {
              throw new DOMEx('INVALID_CHARACTER_ERR', 'String contains an invalid character');
            }
  
            return arrIndexOf.call(classList, token);
          };
  
          var ClassList = function ClassList(elem) {
            var trimmedClasses = strTrim.call(elem.getAttribute('class') || '');
            var classes = trimmedClasses ? trimmedClasses.split(/\s+/) : emptyArray;
  
            for (var i = 0, ii = classes.length; i < ii; ++i) {
              this.push(classes[i]);
            }
  
            this._updateClassName = function () {
              elem.setAttribute('class', this.toString());
            };
          };
  
          var classListProto = ClassList[protoProp] = [];
  
          DOMEx[protoProp] = Error[protoProp];
  
          classListProto.item = function (i) {
            return this[i] || null;
          };
  
          classListProto.contains = function (token) {
            token += '';
            return checkTokenAndGetIndex(this, token) !== -1;
          };
  
          classListProto.add = function () {
            var tokens = arguments;
            var i = 0;
            var ii = tokens.length;
            var token = void 0;
            var updated = false;
  
            do {
              token = tokens[i] + '';
              if (checkTokenAndGetIndex(this, token) === -1) {
                this.push(token);
                updated = true;
              }
            } while (++i < ii);
  
            if (updated) {
              this._updateClassName();
            }
          };
  
          classListProto.remove = function () {
            var tokens = arguments;
            var i = 0;
            var ii = tokens.length;
            var token = void 0;
            var updated = false;
            var index = void 0;
  
            do {
              token = tokens[i] + '';
              index = checkTokenAndGetIndex(this, token);
              while (index !== -1) {
                this.splice(index, 1);
                updated = true;
                index = checkTokenAndGetIndex(this, token);
              }
            } while (++i < ii);
  
            if (updated) {
              this._updateClassName();
            }
          };
  
          classListProto.toggle = function (token, force) {
            token += '';
  
            var result = this.contains(token);
            var method = result ? force !== true && 'remove' : force !== false && 'add';
  
            if (method) {
              this[method](token);
            }
  
            if (force === true || force === false) {
              return force;
            }
  
            return !result;
          };
  
          classListProto.toString = function () {
            return this.join(' ');
          };
  
          Object.defineProperty(Element.prototype, 'classList', {
            get: function get() {
              return new ClassList(this);
            },
            enumerable: true,
            configurable: true
          });
        })();
      } else {
        var testElement = document.createElement('_');
        testElement.classList.add('c1', 'c2');
  
        if (!testElement.classList.contains('c2')) {
          var createMethod = function createMethod(method) {
            var original = DOMTokenList.prototype[method];
  
            DOMTokenList.prototype[method] = function (token) {
              for (var i = 0, ii = arguments.length; i < ii; ++i) {
                token = arguments[i];
                original.call(this, token);
              }
            };
          };
  
          createMethod('add');
          createMethod('remove');
        }
  
        testElement.classList.toggle('c3', false);
  
        if (testElement.classList.contains('c3')) {
          (function () {
            var _toggle = DOMTokenList.prototype.toggle;
  
            DOMTokenList.prototype.toggle = function (token, force) {
              if (1 in arguments && !this.contains(token) === !force) {
                return force;
              }
  
              return _toggle.call(this, token);
            };
          })();
        }
  
        testElement = null;
      }
    }
  
    if (typeof FEATURE_NO_IE === 'undefined') {
      // @license http://opensource.org/licenses/MIT
      if ('performance' in window === false) {
        window.performance = {};
      }
  
      if ('now' in window.performance === false) {
        (function () {
          var nowOffset = Date.now();
  
          if (performance.timing && performance.timing.navigationStart) {
            nowOffset = performance.timing.navigationStart;
          }
  
          window.performance.now = function now() {
            return Date.now() - nowOffset;
          };
        })();
      }
  
      _PLATFORM.performance = window.performance;
    }
  
    if (typeof FEATURE_NO_IE === 'undefined') {
      (function () {
        var con = window.console = window.console || {};
        var nop = function nop() {};
  
        if (!con.memory) con.memory = {};
        ('assert,clear,count,debug,dir,dirxml,error,exception,group,' + 'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' + 'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',').forEach(function (m) {
          if (!con[m]) con[m] = nop;
        });
  
        if (_typeof(con.log) === 'object') {
          'log,info,warn,error,assert,dir,clear,profile,profileEnd'.split(',').forEach(function (method) {
            console[method] = this.bind(console[method], console);
          }, Function.prototype.call);
        }
      })();
    }
  
    if (typeof FEATURE_NO_IE === 'undefined') {
      if (!window.CustomEvent || typeof window.CustomEvent !== 'function') {
        var _CustomEvent = function _CustomEvent(event, params) {
          params = params || {
            bubbles: false,
            cancelable: false,
            detail: undefined
          };
  
          var evt = document.createEvent('CustomEvent');
          evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
          return evt;
        };
  
        _CustomEvent.prototype = window.Event.prototype;
        window.CustomEvent = _CustomEvent;
      }
    }
  
    if (Element && !Element.prototype.matches) {
      var proto = Element.prototype;
      proto.matches = proto.matchesSelector || proto.mozMatchesSelector || proto.msMatchesSelector || proto.oMatchesSelector || proto.webkitMatchesSelector;
    }
  
    var _FEATURE = exports._FEATURE = {
      shadowDOM: !!HTMLElement.prototype.attachShadow,
      scopedCSS: 'scoped' in document.createElement('style'),
      htmlTemplateElement: 'content' in document.createElement('template'),
      mutationObserver: !!(window.MutationObserver || window.WebKitMutationObserver),
      ensureHTMLTemplateElement: function ensureHTMLTemplateElement(t) {
        return t;
      }
    };
  
    if (typeof FEATURE_NO_IE === 'undefined') {
      (function () {
        var isSVGTemplate = function isSVGTemplate(el) {
          return el.tagName === 'template' && el.namespaceURI === 'http://www.w3.org/2000/svg';
        };
  
        var fixSVGTemplateElement = function fixSVGTemplateElement(el) {
          var template = el.ownerDocument.createElement('template');
          var attrs = el.attributes;
          var length = attrs.length;
          var attr = void 0;
  
          el.parentNode.insertBefore(template, el);
  
          while (length-- > 0) {
            attr = attrs[length];
            template.setAttribute(attr.name, attr.value);
            el.removeAttribute(attr.name);
          }
  
          el.parentNode.removeChild(el);
  
          return fixHTMLTemplateElement(template);
        };
  
        var fixHTMLTemplateElement = function fixHTMLTemplateElement(template) {
          var content = template.content = document.createDocumentFragment();
          var child = void 0;
  
          while (child = template.firstChild) {
            content.appendChild(child);
          }
  
          return template;
        };
  
        var fixHTMLTemplateElementRoot = function fixHTMLTemplateElementRoot(template) {
          var content = fixHTMLTemplateElement(template).content;
          var childTemplates = content.querySelectorAll('template');
  
          for (var i = 0, ii = childTemplates.length; i < ii; ++i) {
            var child = childTemplates[i];
  
            if (isSVGTemplate(child)) {
              fixSVGTemplateElement(child);
            } else {
              fixHTMLTemplateElement(child);
            }
          }
  
          return template;
        };
  
        if (!_FEATURE.htmlTemplateElement) {
          _FEATURE.ensureHTMLTemplateElement = fixHTMLTemplateElementRoot;
        }
      })();
    }
  
    var shadowPoly = window.ShadowDOMPolyfill || null;
  
    var _DOM = exports._DOM = {
      Element: Element,
      SVGElement: SVGElement,
      boundary: 'aurelia-dom-boundary',
      addEventListener: function addEventListener(eventName, callback, capture) {
        document.addEventListener(eventName, callback, capture);
      },
      removeEventListener: function removeEventListener(eventName, callback, capture) {
        document.removeEventListener(eventName, callback, capture);
      },
      adoptNode: function adoptNode(node) {
        return document.adoptNode(node, true);
      },
      createElement: function createElement(tagName) {
        return document.createElement(tagName);
      },
      createTextNode: function createTextNode(text) {
        return document.createTextNode(text);
      },
      createComment: function createComment(text) {
        return document.createComment(text);
      },
      createDocumentFragment: function createDocumentFragment() {
        return document.createDocumentFragment();
      },
      createMutationObserver: function createMutationObserver(callback) {
        return new (window.MutationObserver || window.WebKitMutationObserver)(callback);
      },
      createCustomEvent: function createCustomEvent(eventType, options) {
        return new window.CustomEvent(eventType, options);
      },
      dispatchEvent: function dispatchEvent(evt) {
        document.dispatchEvent(evt);
      },
      getComputedStyle: function getComputedStyle(element) {
        return window.getComputedStyle(element);
      },
      getElementById: function getElementById(id) {
        return document.getElementById(id);
      },
      querySelectorAll: function querySelectorAll(query) {
        return document.querySelectorAll(query);
      },
      nextElementSibling: function nextElementSibling(element) {
        if (element.nextElementSibling) {
          return element.nextElementSibling;
        }
        do {
          element = element.nextSibling;
        } while (element && element.nodeType !== 1);
        return element;
      },
      createTemplateFromMarkup: function createTemplateFromMarkup(markup) {
        var parser = document.createElement('div');
        parser.innerHTML = markup;
  
        var temp = parser.firstElementChild;
        if (!temp || temp.nodeName !== 'TEMPLATE') {
          throw new Error('Template markup must be wrapped in a <template> element e.g. <template> <!-- markup here --> </template>');
        }
  
        return _FEATURE.ensureHTMLTemplateElement(temp);
      },
      appendNode: function appendNode(newNode, parentNode) {
        (parentNode || document.body).appendChild(newNode);
      },
      replaceNode: function replaceNode(newNode, node, parentNode) {
        if (node.parentNode) {
          node.parentNode.replaceChild(newNode, node);
        } else if (shadowPoly !== null) {
          shadowPoly.unwrap(parentNode).replaceChild(shadowPoly.unwrap(newNode), shadowPoly.unwrap(node));
        } else {
          parentNode.replaceChild(newNode, node);
        }
      },
      removeNode: function removeNode(node, parentNode) {
        if (node.parentNode) {
          node.parentNode.removeChild(node);
        } else if (parentNode) {
          if (shadowPoly !== null) {
            shadowPoly.unwrap(parentNode).removeChild(shadowPoly.unwrap(node));
          } else {
            parentNode.removeChild(node);
          }
        }
      },
      injectStyles: function injectStyles(styles, destination, prepend) {
        var node = document.createElement('style');
        node.innerHTML = styles;
        node.type = 'text/css';
  
        destination = destination || document.head;
  
        if (prepend && destination.childNodes.length > 0) {
          destination.insertBefore(node, destination.childNodes[0]);
        } else {
          destination.appendChild(node);
        }
  
        return node;
      }
    };
  
    function initialize() {
      if (_aureliaPal.isInitialized) {
        return;
      }
  
      (0, _aureliaPal.initializePAL)(function (platform, feature, dom) {
        Object.assign(platform, _PLATFORM);
        Object.assign(feature, _FEATURE);
        Object.assign(dom, _DOM);
  
        Object.defineProperty(dom, 'title', {
          get: function get() {
            return document.title;
          },
          set: function set(value) {
            document.title = value;
          }
        });
  
        Object.defineProperty(dom, 'activeElement', {
          get: function get() {
            return document.activeElement;
          }
        });
  
        Object.defineProperty(platform, 'XMLHttpRequest', {
          get: function get() {
            return platform.global.XMLHttpRequest;
          }
        });
      });
    }
  });