diff --git a/.eslintrc b/.eslintrc
index c477d07..8f226ba 100644
--- a/.eslintrc
+++ b/.eslintrc
@@ -16,7 +16,10 @@
     "strict": "off",
     "quotes": [
       "error",
-      "single"
+      "single",
+      {
+        "allowTemplateLiterals": true
+      }
     ],
     "no-unused-vars": [
       "error",
diff --git a/test/route-beutifyLocation.js b/disabled-tests/history/route-beutifyLocation.js
similarity index 95%
rename from test/route-beutifyLocation.js
rename to disabled-tests/history/route-beutifyLocation.js
index 33d0cba..0a4d282 100644
--- a/test/route-beutifyLocation.js
+++ b/disabled-tests/history/route-beutifyLocation.js
@@ -1,11 +1,7 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
-const _ = require('underscore');
+import PushStateTree from '../../src/push-state-tree';
+import _ from 'underscore';
 
 describe('PushStateTree beutifyLocation', function() {
-
-  cleanHistoryAPI();
-
   let pstBeautify;
   let pst;
 
@@ -18,6 +14,8 @@ describe('PushStateTree beutifyLocation', function() {
       basePath: _.uniqueId('/beautify+path') + '/',
       beautifyLocation: true
     });
+    pst.hasPushState = true;
+    pstBeautify.hasPushState = true;
   });
 
   it('should be enabled by default', () => {
diff --git a/test/route.js b/disabled-tests/history/router-history-props.js
similarity index 70%
rename from test/route.js
rename to disabled-tests/history/router-history-props.js
index 3d6fae7..2c8df67 100644
--- a/test/route.js
+++ b/disabled-tests/history/router-history-props.js
@@ -1,23 +1,8 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../../../src/push-state-tree';
 
-describe('PushStateTree should', function() {
-  cleanHistoryAPI();
-
-  it('be available as UMD library', function() {
-    expect(PushStateTree).to.be.defined;
-  });
-
-  it('instances without "new" operator', function() {
-    /* jshint newcap: false*/
-    expect(PushStateTree()).to.be.instanceof(HTMLElement);
-  });
-
-  it('construct and became a HTMLElement instance', function(){
-    expect(new PushStateTree()).to.be.instanceof(HTMLElement);
-    expect(new PushStateTree({})).to.be.instanceof(HTMLElement);
-  });
+//TODO: Add the browser adapter and history plugin
 
+describe('PushStateTree should', function() {
   it('auto enable push state if browser support it', function(){
     var pst = new PushStateTree();
     expect(pst.usePushState).to.be.true;
@@ -63,5 +48,4 @@ describe('PushStateTree should', function() {
     var pst = new PushStateTree();
     expect(pst.uri).to.equal(location.pathname.slice(1));
   });
-
 });
diff --git a/test/route-createRules.js b/disabled-tests/route-createRules.js
similarity index 89%
rename from test/route-createRules.js
rename to disabled-tests/route-createRules.js
index 3cb436f..6155086 100644
--- a/test/route-createRules.js
+++ b/disabled-tests/route-createRules.js
@@ -1,8 +1,8 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
 
 describe('PushStateTree createRule', function() {
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   describe('when rule /^servers(\/)?(.*)/', function() {
     var pst;
diff --git a/test/route-force-hash-navigation.js b/disabled-tests/route-force-hash-navigation.js
similarity index 54%
rename from test/route-force-hash-navigation.js
rename to disabled-tests/route-force-hash-navigation.js
index e815f29..f94acce 100644
--- a/test/route-force-hash-navigation.js
+++ b/disabled-tests/route-force-hash-navigation.js
@@ -1,9 +1,9 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
 
-describe('PushStateTree hash-navigation should', function() {
+describe('PushStateTree hash-navigation', function() {
 
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   let cacheVal;
 
@@ -17,7 +17,7 @@ describe('PushStateTree hash-navigation should', function() {
     PushStateTree.hasPushState = cacheVal;
   });
 
-  it('force hash navigation if browser doesn\'t support pushState', () => {
+  it(`should force hash navigation if browser doesn't support pushState`, () => {
     var pst = new PushStateTree({
       usePushState: true
     });
diff --git a/test/route-hash-navigation.js b/disabled-tests/route-hash-navigation.js
similarity index 95%
rename from test/route-hash-navigation.js
rename to disabled-tests/route-hash-navigation.js
index 5dd024f..bcdd6c4 100644
--- a/test/route-hash-navigation.js
+++ b/disabled-tests/route-hash-navigation.js
@@ -1,6 +1,6 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
-const _ = require('underscore');
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import _ from 'underscore';
 
 describe('PushStateTree hash-navigation', () => {
   let pst;
@@ -10,7 +10,7 @@ describe('PushStateTree hash-navigation', () => {
     'assign'
   ];
 
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   beforeEach(() => {
     pst = new PushStateTree({
@@ -113,8 +113,8 @@ describe('PushStateTree hash-navigation', () => {
         pst[triggerMethod]('/');
         expect(pst.uri).to.equal('');
         expect(location.hash).to.equal('');
-      }); 
-      
+      });
+
     });
   });
 });
diff --git a/test/route-methods.js b/disabled-tests/route-methods.js
similarity index 82%
rename from test/route-methods.js
rename to disabled-tests/route-methods.js
index 3e54bed..6a56f1e 100644
--- a/test/route-methods.js
+++ b/disabled-tests/route-methods.js
@@ -1,10 +1,10 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
 
 describe('PushStateTree methods', function() {
   let pst;
 
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   beforeEach(() => {
     pst = new PushStateTree();
diff --git a/test/rule-events.js b/disabled-tests/rule-events.js
similarity index 89%
rename from test/rule-events.js
rename to disabled-tests/rule-events.js
index 83880bd..fc32a21 100644
--- a/test/rule-events.js
+++ b/disabled-tests/rule-events.js
@@ -1,6 +1,6 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
-const _ = require('underscore');
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import _ from 'underscore';
 
 describe('PushStateTree-rule', function () {
   let pst;
@@ -11,7 +11,7 @@ describe('PushStateTree-rule', function () {
     'assign'
   ];
 
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   beforeEach(function () {
     pst = new PushStateTree();
diff --git a/test/rule-properties.js b/disabled-tests/rule-properties.js
similarity index 95%
rename from test/rule-properties.js
rename to disabled-tests/rule-properties.js
index 0cc298e..a632398 100644
--- a/test/rule-properties.js
+++ b/disabled-tests/rule-properties.js
@@ -1,9 +1,9 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
 
 describe('PushStateTree properties', () => {
 
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   var expectedParentGroup = 2;
   var pst;
diff --git a/test/rule.js b/disabled-tests/rule.js
similarity index 90%
rename from test/rule.js
rename to disabled-tests/rule.js
index 9c5da78..443b2ac 100644
--- a/test/rule.js
+++ b/disabled-tests/rule.js
@@ -1,11 +1,11 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../src/push-state-tree';
+// import cleanHistoryAPI from './helper/cleanHistoryAPI';
 
 describe('PushStateTree-rule', function () {
   let pst;
   let rule;
 
-  cleanHistoryAPI();
+  // cleanHistoryAPI();
 
   beforeEach(function () {
     pst = new PushStateTree();
diff --git a/index.html b/index.html
index 228fd95..b87d990 100644
--- a/index.html
+++ b/index.html
@@ -39,15 +39,15 @@
     if (location.hostname.indexOf('github') === -1){
       basePath = '';
     }
-    
+
     // If no internet found (programming on travels...)
     // Load resources from offline folder
     if (typeof $ !== 'function' || !$.when){
-      
+
       function loadOffline(src, callback) {
         // Load a file and execute the callback, should be used to
         // load files in the right order and then boot the system
-        
+
         var type = src.substr(-3) === 'css' ? 'link' : 'script';
         var element = document.createElement(type);
         var path = location.origin + basePath + '/demo/offline/';
@@ -74,24 +74,26 @@
     } else {
       boot();
     }
-    
-    function boot(){
+
+    function boot() {
       // boot the demo page
 
       function load(src){
         // Simple script loader based on promises
-        
-        var defer = $.Deferred();;
+
+        var defer = $.Deferred();
         if (!$.support.leadingWhitespace) {
           $.getScript(location.protocol + '//' + location.host + src)
-            .then(defer.resolve, defer.reject);
+            .then(defer.resolve, defer.reject)
+          ;
         } else {
           $('<script>')
             .appendTo('head')
             // Get the origin compatible with IE8
             .attr('src', location.protocol + '//' + location.host + src)
             .on('load', defer.resolve)
-            .on('error', defer.reject);
+            .on('error', defer.reject)
+          ;
         }
 
         return defer.promise();
@@ -100,11 +102,11 @@
       window.load = load;
 
       $.when(load(basePath + '/build/push-state-tree.js'))
-        .then(function(){
+        .then(function () {
           return load(basePath + '/demo/main.js');
         })
-        .done(function (){
-          $('#loading').on('hidden.bs.modal', function(){
+        .done(function () {
+          $('#loading').on('hidden.bs.modal', function() {
             $('#main').toggleClass('in', true);
             $('#version').text(pushStateTree.VERSION);
           }).modal('hide');
@@ -132,7 +134,7 @@
     <!--[if lt IE 9]>
         <p class="browsehappy">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
     <![endif]-->
-    
+
     <div id="main" class="container fade">
 
       <!-- Static navbar -->
diff --git a/karma.conf.js b/karma.conf.js
index 034759f..28a317c 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -35,6 +35,13 @@ const WATCH = argv.watch;
 // so it's disabled by default, more info at https://webpack.github.io/docs/configuration.html#devtool
 const devtool = argv['fast-build'] ? 'cheap-module-eval-source-map' : 'inline-source-map';
 
+
+// For development server testing, it should not be a library, a devserver.js is including and assign the global
+// PushStateTree for the logic in the Demo work
+delete webpackConfig.output.library;
+delete webpackConfig.output.libraryTarget;
+delete webpackConfig.output.umdNamedDefine;
+
 if (WATCH) {
   let port = argv['dev-port'] || 8080;
 
@@ -47,21 +54,16 @@ if (WATCH) {
 
   webpackDevConfig.output.pathinfo = true;
   webpackDevConfig.resolve.alias = {
-    'push-state-tree': path.resolve(__dirname, webpackDevConfig.entry['push-state-tree'])
+    'push-state-tree': path.resolve(__dirname, webpackDevConfig.entry['push-state-tree'][0])
   };
 
   webpackDevConfig.entry['push-state-tree'] = [
     // Add inline webpack-dev-server client
     `webpack-dev-server/client?http://localhost:${port}/`,
     // Keep default lib
-    'expose?PushStateTree!' + webpackDevConfig.entry['push-state-tree']
+    'expose?PushStateTree!' + webpackDevConfig.entry['push-state-tree'][0]
   ];
 
-  // For development server testing, it should not be a library, a devserver.js is including and assign the global
-  // PushStateTree for the logic in the Demo work
-  delete webpackDevConfig.output.library;
-  delete webpackDevConfig.output.libraryTarget;
-  delete webpackDevConfig.output.umdNamedDefine;
   webpackDevConfig.module.preLoaders = [];
 
   var compiler = webpack(webpackDevConfig);
@@ -98,11 +100,13 @@ module.exports = function (config) {
 
     // list of files / patterns to load in the browser
     files: [
-      'test/*.js'
+      'test/**/*.js'
     ],
 
     // list of files to exclude
-    exclude: [],
+    exclude: [
+      'test/helper/**/*.js'
+    ],
 
     // test results reporter to use
     reporters: ['progress', 'coverage'],
@@ -150,25 +154,16 @@ module.exports = function (config) {
               exclude: /(node_modules)/,
               loader: 'json'
             }
-          ]
+          ],
+          // postLoaders: [
+          //   {
+          //     test: /\.js$/,
+          //     exclude: /(test|node_modules|bower_components|\.shim\.js$|\.json$)/,
+          //     loader: 'istanbul-instrumenter'
+          //   }
+          // ]
         };
 
-        if (WATCH) {
-          module.postLoaders = [
-            {
-              test: /\.js$/,
-              exclude: /(test|node_modules|bower_components|\.shim\.js$|\.json$)/,
-              loader: 'istanbul-instrumenter'
-            }
-          ]
-        } else {
-          module.preLoaders.unshift({
-            test: /\.js$/,
-            exclude: /(test|node_modules|bower_components|\.shim\.js$|\.json$)/,
-            loader: 'istanbul-instrumenter'
-          });
-        }
-
         return module;
       }())),
       plugins: webpackConfig.plugins,
diff --git a/src/adapter/browser.js b/src/adapter/browser.js
new file mode 100644
index 0000000..aa9ec7f
--- /dev/null
+++ b/src/adapter/browser.js
@@ -0,0 +1,176 @@
+import PushStateTree from '../push-state-tree';
+import { isIE } from '../ieOld.shim';
+import { isExternal, isRelative, convertToURI, resolveRelativePath } from './../helpers';
+
+const HASH_CHANGE = 'hashchange';
+const POP_STATE = 'popstate';
+
+const root = typeof window == 'object' ? window : global;
+
+let location = PushStateTree.adapter.location || root.location;
+PushStateTree.adapter.location = location;
+location = () => PushStateTree.adapter.location;
+
+export function BrowserAdapter() {
+
+  this.globalListeners = function() {
+    // Called when creating a new instance of the parent of the current prototype
+
+    // Start the browser global listeners and return a method to stop listening to them
+
+    let browserListener = () => {
+      let pathURI = convertToURI(location().href);
+      if (this.path != pathURI) {
+        this.path = pathURI;
+        this.dispatch();
+      }
+    };
+
+    root.addEventListener(POP_STATE, browserListener);
+    root.addEventListener(HASH_CHANGE, browserListener);
+
+    let ieWatch;
+    let loadListener = () => {
+      browserListener();
+
+      if (!isIE() || isIE() > 8) return;
+
+      // Watch for URL changes in the IE
+      ieWatch = setInterval(browserListener, 50);
+    };
+
+    // If the DOM is ready when running the PST, execute loadListeners and ignore others
+    if (document.readyState == 'complete') {
+      loadListener();
+    } else {
+      // Modern browsers
+      document.addEventListener('DOMContentLoaded', browserListener);
+      // Some IE browsers
+      root.addEventListener('readystatechange', browserListener);
+      // Almost all browsers
+      root.addEventListener('load', loadListener);
+    }
+
+    return () => {
+      // Method to stop watching
+      root.removeEventListener(POP_STATE, browserListener);
+      document.removeEventListener('DOMContentLoaded', browserListener);
+      root.removeEventListener('readystatechange', browserListener);
+      root.removeEventListener(HASH_CHANGE, browserListener);
+      root.removeEventListener('load', loadListener);
+      if (ieWatch) clearInterval(ieWatch);
+    };
+  };
+
+  this.pushState = function (uri, ignored, deprecatedUri) {
+    // Does a shim for pushState when history API doesn't support pushState,
+    // from version 0.15.x it ignores state and title definition since they are
+    // never used in any production project so far and seems to make harder to
+    // developers to use the method since they need to add 2 useless arguments
+    // before the really necessary one.
+    // However it keeps compatible with any implementation that already add the
+    // url as third argument.
+    if (typeof deprecatedUri == 'string') {
+      uri = deprecatedUri;
+    }
+    if (typeof uri != 'string') {
+      uri = '';
+    }
+
+    // Replace hash url
+    if (isExternal(uri)) {
+      // this will redirect the browser, so doesn't matters the rest...
+      location().href = uri;
+    }
+
+    // Remove the has if is it present
+    if (uri[0] === '#') {
+      uri = uri.slice(1);
+    }
+
+    if (isRelative(uri)) {
+      uri = location().hash.slice(1, location().hash.lastIndexOf('/') + 1) + uri;
+      uri = resolveRelativePath(uri);
+    }
+
+    // Include the basePath in the uri, if is already in the current router
+    // basePath, it will apply the assign without refresh, but if the basePath
+    // is different, it will refresh the browser to work in the current router
+    // basePath.
+    // The behavior is the same in browsers that support pushState, however they
+    // don't refresh when switching between basePath of different routers
+    this.path = this.basePath + uri;
+    if (location().pathname == this.basePath) {
+      location().hash = uri;
+    } else {
+      location().assign(uri);
+    }
+
+    return this;
+  };
+
+  this.replaceState = function (uri, ignored, deprecatedUri) {
+    // Does a shim for replaceState when history API doesn't support pushState,
+    // from version 0.15.x it ignores state and title definition since they are
+    // never used in any production project so far and seems to make harder to
+    // developers to use the method since they need to add 2 useless arguments
+    // before the really necessary one.
+    // However it keeps compatible with any implementation that already add the
+    // url as third argument.
+
+    if (typeof deprecatedUri == 'string') {
+      uri = deprecatedUri;
+    }
+    if (typeof uri != 'string') {
+      uri = '';
+    }
+
+    // Replace the url
+    if (isExternal(uri)) {
+      throw new Error('Invalid url replace.');
+    }
+
+    if (uri[0] === '#') {
+      uri = uri.slice(1);
+    }
+
+    if (isRelative(uri)) {
+      var relativePos = location().hash.lastIndexOf('/') + 1;
+      uri = location().hash.slice(1, relativePos) + uri;
+      uri = resolveRelativePath(uri);
+    }
+
+    // Always use hash navigation
+    uri = '#' + uri;
+
+    // Include the basePath in the uri, if is already in the current router
+    // basePath, it will apply the replace without refresh, but if the basePath
+    // is different, it will refresh the browser to work in the current router
+    // basePath.
+    // The behavior is the same in browsers that support pushState, however they
+    // don't refresh when switching between basePath of different routers
+    this.path = this.basePath + uri;
+    location().replace(uri);
+
+    return this;
+  };
+
+  this.create = function (router) {
+    if (typeof BrowserAdapter.prototype.create == 'function') {
+      BrowserAdapter.prototype.create.apply(this, arguments);
+    }
+
+    let globalListeners = () => {};
+    let enableListeners = () => {
+      globalListeners = this.globalListeners.apply(router);
+    };
+    router.addEventListener('disabled', globalListeners);
+    router.addEventListener('enabled', enableListeners);
+
+    if (!router.disabled) {
+      enableListeners();
+    }
+  };
+}
+
+export default BrowserAdapter;
\ No newline at end of file
diff --git a/src/adapter/pluginInjector.js b/src/adapter/pluginInjector.js
new file mode 100644
index 0000000..549b530
--- /dev/null
+++ b/src/adapter/pluginInjector.js
@@ -0,0 +1,12 @@
+export function AutoInjectHistory(Constructor, ...args) {
+  this.create = function (router, options) {
+    options.plugins = options.plugins || [];
+    options.plugins.push(new Constructor(...args));
+
+    if (typeof AutoInjectHistory.prototype.create == 'function') {
+      AutoInjectHistory.prototype.create.apply(this, arguments);
+    }
+  }
+}
+
+export default AutoInjectHistory;
\ No newline at end of file
diff --git a/src/constants.js b/src/constants.js
new file mode 100644
index 0000000..2e4cdba
--- /dev/null
+++ b/src/constants.js
@@ -0,0 +1,7 @@
+// Constants
+export const LEAVE = 'leave';
+export const UPDATE = 'update';
+export const ENTER = 'enter';
+export const CHANGE = 'change';
+export const MATCH = 'match';
+export const OLD_MATCH = 'oldMatch';
\ No newline at end of file
diff --git a/src/helpers.js b/src/helpers.js
new file mode 100644
index 0000000..ddd8103
--- /dev/null
+++ b/src/helpers.js
@@ -0,0 +1,83 @@
+export function isExternal(url) {
+  // Check if a URL is external
+  return (/^[a-z0-9]+:\/\//i).test(url);
+}
+
+export function isRelative(uri) {
+  // Check if a URI is relative path, when begin with # or / isn't relative uri
+  return (/^[^#/]/).test(uri);
+}
+
+export function convertToURI(url) {
+  // Remove unwanted data from url
+  // if it's a browser it will remove the location.origin
+  // else it will ignore first occurrence of / and return the rest
+  if (location && url == location.href) {
+    let host = location.host && `//${location.host}`;
+    return url.substr(`${location.protocol}${host}`.length);
+  } else {
+    let match = url.match(/([^\/]*)(\/+)?(.*)/);
+    return match[2] ? match[3] : match[1];
+  }
+}
+
+export function resolveRelativePath(path) {
+  // Resolve relative paths manually for browsers using hash navigation
+
+  var parts = path.split('/');
+  var i = 1;
+  while (i < parts.length) {
+    // if current part is `..` and previous part is different, remove both of them
+    if (parts[i] === '..' && i > 0 && parts[i-1] !== '..') {
+      parts.splice(i - 1, 2);
+      i -= 2;
+    }
+    i++;
+  }
+  return parts
+    .join('/')
+    .replace(/\/\.\/|\.\/|\.\.\//g, '/')
+    .replace(/^\/$/, '');
+}
+
+export function objectMixinProperties(destineObject, sourceObject) {
+  // Simple version of Object.assign
+  for (let property in sourceObject) {
+    if (sourceObject.hasOwnProperty(property)) {
+      destineObject[property] = sourceObject[property];
+    }
+  }
+}
+
+export function isInt(n) {
+  return typeof n != 'undefined' && !isNaN(parseFloat(n)) && n % 1 === 0 && isFinite(n);
+}
+
+export function proxyTo(context, prototypeContext) {
+  // It proxy the method, or property to the prototype
+
+  for (let property in prototypeContext) {
+    if (typeof prototypeContext[property] == 'function') {
+
+      // function wrapper, it doesn't use binding because it needs to execute the current version of the property in the
+      // prototype to conserve the prototype chain resource
+      context[property] = function proxyMethodToPrototype() {
+        return prototypeContext[property].apply(this, arguments);
+      };
+      continue;
+    }
+    // Proxy prototype properties to the instance, but if they're redefined in the instance, use the instance definition
+    // without change the prototype property value
+    if (typeof context[property] == 'undefined') {
+      Object.defineProperty(context, property, {
+        get() {
+          return prototypeContext[property];
+        },
+        set(value) {
+          prototypeContext[property] = value;
+        },
+        enumerable: true
+      });
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/main.js b/src/main.js
new file mode 100644
index 0000000..209e26e
--- /dev/null
+++ b/src/main.js
@@ -0,0 +1,20 @@
+// If you don't want support IE 7 and IE 8 you can remove the compatibility shim with `PST_NO_OLD_ID: false`
+//     new webpack.DefinePlugin({
+//       PST_NO_OLD_IE: false
+//     })
+// https://webpack.github.io/docs/list-of-plugins.html#defineplugin
+require('./es3.shim.js');
+
+// TODO: Use a PushStateTree.prototype.createEvent instead of shim native CustomEvents
+require('./customEvent.shim');
+
+import BrowserAdapter from './adapter/browser';
+
+import PushStateTree from './push-state-tree';
+PushStateTree.addAdapter(BrowserAdapter);
+
+import BrowserHistory from './plugin/history';
+import PluginInjector from './adapter/pluginInjector';
+PushStateTree.addAdapter(PluginInjector, BrowserHistory);
+
+module.exports = PushStateTree;
\ No newline at end of file
diff --git a/src/plugin/history.js b/src/plugin/history.js
new file mode 100644
index 0000000..2f7b5b3
--- /dev/null
+++ b/src/plugin/history.js
@@ -0,0 +1,177 @@
+import PushStateTree from '../push-state-tree';
+import { MATCH } from '../constants';
+import { isExternal, isRelative, resolveRelativePath, proxyTo } from './../helpers';
+
+const root = typeof window == 'object' ? window : global;
+
+function preProcessUriBeforeExecuteNativeHistoryMethods(history, location, method) {
+
+  // If not pushState or replaceState methods, execute it from history API
+  if (method !== 'pushState' && method !== 'replaceState') {
+    this[method] = function () {
+      history[method].apply(history, arguments);
+      return this;
+    };
+    return;
+  }
+
+  this[method] = function () {
+    // Wrap method
+
+    // remove the method from arguments
+    let args = Array.prototype.slice.call(arguments);
+    let uri = args[0] || '';
+    if (typeof args[2] === 'string') {
+      uri = args[2];
+    }
+
+    // if has a basePath translate the not relative paths to use the basePath
+    if (!isExternal(uri)) {
+      // When not external link, need to normalize the URI
+
+      if (isRelative(uri)) {
+        // Relative to the uri
+        var basePath = this.uri[MATCH](/^([^?#]*)\//);
+        basePath = basePath ? basePath[1] + '/' : '';
+        uri = basePath + uri;
+      } else {
+        // This isn't relative, will cleanup / and # from the begin and use the remain path
+        uri = uri[MATCH](/^([#/]*)?(.*)/)[2];
+      }
+
+      if (!this.usePushState) {
+
+        // Ignore basePath when using location.hash and resolve relative path and keep
+        // the current location.pathname, some browsers history API might apply the new pathname
+        // with the hash content if not explicit
+        uri = location.pathname + '#' + resolveRelativePath(uri);
+      } else {
+
+        // Add the basePath to your uri, not allowing to go by pushState outside the basePath
+        uri = this.basePath + uri;
+      }
+    }
+
+    // Ignore state and make the url be the current uri
+    args[0] = null;
+    args[2] = uri;
+
+    this.path = this.basePath + uri;
+    history[method].apply(history, args);
+    return this;
+  };
+}
+
+function BrowserHistory(options) {
+  const enumerable = true;
+
+  if (!(this instanceof BrowserHistory)) {
+    return new BrowserHistory(options);
+  }
+  options = options || {};
+
+  let location = this.location = options.location || root.location;
+  let history = this.history = options.history || root.history;
+
+  if (!location) {
+    throw new Error(DEV_ENV && 'BrowserHistory require Location API');
+  }
+
+  /*eslint guard-for-in: "off"*/
+  for (var method in history) {
+    if (typeof history[method] === 'function') {
+      preProcessUriBeforeExecuteNativeHistoryMethods.call(this, history, location, method);
+    }
+  }
+
+  this.hasPushState = !!(history && history.pushState);
+
+  if (!PushStateTree.hasOwnProperty('hasPushState')) {
+    let globalHasPushState = this.hasPushState;
+    Object.defineProperty(PushStateTree, 'hasPushState', {
+      get() {
+        if (DEV_ENV) console.info('The static property hasPushState is deprecated. Use BrowserHistory plugin.');
+        return globalHasPushState;
+      },
+      set(value) {
+        globalHasPushState = !!value;
+      },
+      enumerable
+    });
+  }
+
+  // Allow switch between pushState or hash navigation modes, in browser that doesn't support
+  // pushState it will always be false. and use hash navigation enforced.
+  // use backend non permanent redirect when old browsers are detected in the request.
+  let usePushState = false;
+  Object.defineProperty(this, 'usePushState', {
+    get() {
+      return usePushState;
+    },
+    set(val) {
+      usePushState = this.hasPushState ? val !== false : false;
+    },
+    enumerable
+  });
+  this.usePushState = options.usePushState;
+
+  // When enabled beautifyLocation will replace the location using history.replaceState
+  // to remove the hash from the URL
+  let beautifyLocation = false;
+  Object.defineProperty(this, 'beautifyLocation', {
+    get() {
+      return beautifyLocation && this.usePushState;
+    },
+    set(value) {
+      beautifyLocation = value === true;
+    },
+    enumerable
+  });
+
+  this.beautifyLocation = this.usePushState && options.beautifyLocation !== false;
+}
+
+BrowserHistory.create = function (router) {
+
+  // Proxy all plugins instance properties and methods
+  proxyTo(router, this);
+
+  let stopListeners = () => {};
+  let enableListeners = () => {
+
+    // Listen for path changes, and applyBeautifyLocation
+    let listener = (event) => {
+      if (router.applyBeautifyLocation()) {
+        event.preventDefault();
+      }
+    };
+    router.addEventListener('dispatch', listener);
+
+    stopListeners = () => {
+      router.removeEventListener(listener);
+    };
+  };
+  router.addEventListener('disabled', stopListeners);
+  router.addEventListener('enabled', enableListeners);
+
+  if (!router.disabled) {
+    router.applyBeautifyLocation();
+  }
+};
+
+BrowserHistory.prototype.applyBeautifyLocation = function () {
+  // apply pushState for a beautiful URL when beautifyLocation is enable and it's possible to do it
+  if (this.beautifyLocation
+    && this.usePushState
+    && this.isPathValid
+    && this.path.indexOf('#') != -1
+  ) {
+
+    // Execute after to pop_state again
+    this.replace(this.uri);
+    return true;
+  }
+  return false;
+};
+
+export default BrowserHistory;
\ No newline at end of file
diff --git a/src/push-state-tree.js b/src/push-state-tree.js
index 203b13a..68f927f 100644
--- a/src/push-state-tree.js
+++ b/src/push-state-tree.js
@@ -1,153 +1,20 @@
 const root = typeof window !== 'undefined' && window || global;
 
-let errorApiMessage = api => new Error(`PushStateTree ${VERSION} requires ${api} API to run.`);
+import { objectMixinProperties, proxyTo, isInt } from './helpers';
 
-if (!root.document) {
-  throw errorApiMessage('document');
-}
-const document = root.document;
-const location = root.location;
-const history = root.history;
-
-// If you have your own shim for ES3 and old IE browsers, you can remove all shim files from your package by adding a
-// webpack.DefinePlugin that translates `typeof PST_NO_SHIM === 'undefined'` to false, this will remove the section
-// in the minified version:
-//     new webpack.DefinePlugin({
-//       PST_NO_SHIM: false
-//     })
-// https://webpack.github.io/docs/list-of-plugins.html#defineplugin
-
-let isIE = require('./ieOld.shim').isIE;
-
-// If you don't want support IE 7 and IE 8 you can remove the compatibility shim with `PST_NO_OLD_ID: false`
-//     new webpack.DefinePlugin({
-//       PST_NO_OLD_IE: false
-//     })
-// https://webpack.github.io/docs/list-of-plugins.html#defineplugin
-require('./es3.shim.js');
-
-// TODO: Use a PushStateTree.prototype.createEvent instead of shim native CustomEvents
-require('./customEvent.shim');
-
-// Constants for uglifiers
-const HASH_CHANGE = 'hashchange';
-const POP_STATE = 'popstate';
-const LEAVE = 'leave';
-const UPDATE = 'update';
-const ENTER = 'enter';
-const CHANGE = 'change';
-const MATCH = 'match';
-const OLD_MATCH = 'oldMatch';
-
-function convertToURI(url) {
-  // Remove unwanted data from url
-  // if it's a browser it will remove the location.origin
-  // else it will ignore first occurrence of / and return the rest
-  if (location && url == location.href) {
-    let host = location.host && `//${location.host}`;
-    return url.substr(`${location.protocol}${host}`.length);
-  } else {
-    let match = url[MATCH](/([^\/]*)(\/+)?(.*)/);
-    return match[2] ? match[3] : match[1];
-  }
-}
-
-// Helpers
-function isInt(n) {
-  return typeof n != 'undefined' && !isNaN(parseFloat(n)) && n % 1 === 0 && isFinite(n);
-}
-
-function proxyReadOnlyProperty(context, property, targetObject) {
-  // Proxy the property with same name from the targetObject into the defined context
-  // if `targetObject` is `false` it will always return `false`.
-
-  Object.defineProperty(context, property, {
-    get() {
-      return targetObject && targetObject[property];
-    },
-    // Must have set to ignore when try to set a new value and not throw error.
-    set() {}
-  });
-}
-
-function proxyLikePrototype(context, prototypeContext) {
-  // It proxy the method, or property to the prototype
-
-  for (let property in prototypeContext) {
-    if (typeof prototypeContext[property] === 'function') {
-      // function wrapper, it doesn't use binding because it needs to execute the current version of the property in the
-      // prototype to conserve the prototype chain resource
-      context[property] = function proxyMethodToPrototype() {
-        return prototypeContext[property].apply(this, arguments);
-      };
-      continue;
-    }
-    // Proxy prototype properties to the instance, but if they're redefined in the instance, use the instance definition
-    // without change the prototype property value
-    if (typeof context[property] == 'undefined') {
-      let propertyValue;
-      Object.defineProperty(context, property, {
-        get() {
-          if (typeof propertyValue == 'undefined') {
-            return prototypeContext[property];
-          }
-          return propertyValue;
-        },
-        set(value) {
-          propertyValue = value;
-        }
-      });
-    }
-  }
-}
-
-function objectMixinProperties(destineObject, sourceObject) {
-  // Simple version of Object.assign
-  for (let property in sourceObject) {
-    if (sourceObject.hasOwnProperty(property)) {
-      destineObject[property] = sourceObject[property];
-    }
-  }
-}
-
-function isExternal(url) {
-  // Check if a URL is external
-  return (/^[a-z0-9]+:\/\//i).test(url);
-}
-
-function isRelative(uri) {
-  // Check if a URI is relative path, when begin with # or / isn't relative uri
-  return (/^[^#/]/).test(uri);
-}
-
-function resolveRelativePath(path) {
-  // Resolve relative paths manually for browsers using hash navigation
-
-  var parts = path.split('/');
-  var i = 1;
-  while (i < parts.length) {
-    // if current part is `..` and previous part is different, remove both of them
-    if (parts[i] === '..' && i > 0 && parts[i-1] !== '..') {
-      parts.splice(i - 1, 2);
-      i -= 2;
-    }
-    i++;
-  }
-  return parts
-    .join('/')
-    .replace(/\/\.\/|\.\/|\.\.\//g, '/')
-    .replace(/^\/$/, '');
-}
-
-// Add compatibility with old IE browsers
-var elementPrototype = typeof HTMLElement !== 'undefined' ? HTMLElement : Element;
+import { LEAVE, UPDATE, ENTER, CHANGE, MATCH, OLD_MATCH } from './constants';
 
 function PushStateTree(options) {
   options = options || {};
 
   // Force the instance to always return a HTMLElement
-  if (!(this instanceof elementPrototype)) {
-    return PushStateTree.apply(PushStateTree.createElement('pushstatetree-route'), arguments);
+  if (!(this instanceof PushStateTree.adapter.instanceof)) {
+
+    if (!this) return new PushStateTree(options);
+
+    // Allow plugins override the instance create
+    let instance = PushStateTree.create.apply(this, arguments);
+    return PushStateTree.apply(instance, arguments);
   }
 
   this.eventStack = {
@@ -157,38 +24,6 @@ function PushStateTree(options) {
     match: []
   };
 
-  proxyLikePrototype(this, PushStateTree.prototype);
-
-  // Allow switch between pushState or hash navigation modes, in browser that doesn't support
-  // pushState it will always be false. and use hash navigation enforced.
-  // use backend non permanent redirect when old browsers are detected in the request.
-  if (!PushStateTree.hasPushState) {
-    proxyReadOnlyProperty(this, 'usePushState', false);
-  } else {
-    let usePushState = true;
-    Object.defineProperty(this, 'usePushState', {
-      get() {
-        return usePushState;
-      },
-      set(val) {
-        usePushState = PushStateTree.hasPushState ? val !== false : false;
-      }
-    });
-    this.usePushState = options.usePushState;
-  }
-
-  // When enabled beautifyLocation will replace the location using history.replaceState
-  // to remove the hash from the URL
-  let beautifyLocation = true && this.usePushState;
-  Object.defineProperty(this, 'beautifyLocation', {
-    get() {
-      return beautifyLocation;
-    },
-    set(value) {
-      beautifyLocation = this.usePushState && value === true;
-    }
-  });
-
   let basePath;
   Object.defineProperty(this, 'basePath', {
     get() {
@@ -266,7 +101,14 @@ function PushStateTree(options) {
       if (holdDispatch || value == path) return;
       let wasBasePathValid = this.isPathValid;
 
-      if (this.dispatchEvent(new root.CustomEvent('path'))) {
+      let event = new root.CustomEvent('path', {
+        detail: {
+          value: value,
+          oldValue: path
+        }
+      });
+
+      if (this.dispatchEvent(event)) {
         path = value;
         length++;
 
@@ -292,7 +134,6 @@ function PushStateTree(options) {
 
   // Disabled must be the last thing before options, because it will start the listeners
   let disabled = true;
-  let disableMethod;
   Object.defineProperty(this, 'disabled', {
     get() {
       return disabled;
@@ -301,8 +142,7 @@ function PushStateTree(options) {
       value = value === true;
       if (value != disabled) {
         disabled = value;
-        if (disabled) disableMethod();
-        else disableMethod = this.startGlobalListeners();
+        this.dispatchEvent(new root.CustomEvent(disabled ? 'disabled' : 'enabled'));
       }
     }
   });
@@ -318,94 +158,79 @@ const eventsQueue = [];
 let holdingDispatch = false;
 let holdDispatch = false;
 
-let hasPushState = !!(history && history.pushState);
-
 objectMixinProperties(PushStateTree, {
   // VERSION is defined in the webpack build, it is replaced by package.version
   VERSION,
-  isInt,
-  hasPushState,
-  createElement(name) {
-    // When document is available, use it to create and return a HTMLElement
-    if (typeof document !== 'undefined') {
-      return document.createElement(name);
-    }
-    throw new Error('PushStateTree requires HTMLElement support from window to work.')
+  plugins: [],
+  adapter: {
+    // Add compatibility with old IE browsers
+    instanceof: typeof HTMLElement !== 'undefined' ? HTMLElement : Element
   },
+  addAdapter(Constructor, ...args) {
 
-  prototype: {
-    // VERSION is defined in the webpack build, it is replaced by package.version
-    VERSION,
-    hasPushState,
-
-    startGlobalListeners() {
-      // Start the browser global listeners and return a method to stop listening to them
-
-      let beautifyLocation = () => {
-        // apply pushState for a beautiful URL when beautifyLocation is enable and it's possible to do it
-        if (this.beautifyLocation
-          && this.usePushState
-          && this.isPathValid
-          && this.path.indexOf('#') != -1
-        ) {
-
-          // Execute after to pop_state again
-          this.replace(this.uri);
-          return true;
-        }
-      };
+    // Define the prototype from the constructor to be the PushStateTree.prototype
+    Constructor.prototype = PushStateTree.prototype;
 
-      let dispatchListener = event => {
-        this.path = convertToURI(location.href);
+    // Create a instance of the constructor with the arguments
+    let instance = new Constructor(...args);
 
-        if (beautifyLocation()) {
-          event.preventDefault();
-        }
-      };
-      this.addEventListener('dispatch', dispatchListener);
+    // Extend the prototype chain from PushStateTree with such instance
+    PushStateTree.prototype = instance;
 
-      let browserListener = () => {
-        if (this.path != convertToURI(location.href)) {
-          this.dispatch();
-        }
-      };
+    return instance;
+  },
+
+  create(options) {
+    if (!this) {
+      throw new Error(DEV_ENV && 'Method create requires a context.');
+    }
+    options = options || {};
+    options.plugins = Array.isArray(options.plugins) ? options.plugins : [];
+
+    let router = PushStateTree.createElement('pushstatetree-route');
 
-      root.addEventListener(POP_STATE, browserListener);
-      root.addEventListener(HASH_CHANGE, browserListener);
+    // Execute prototype create
+    if (typeof this.create == 'function') {
+      this.create(router, ...arguments);
+    }
 
-      let ieWatch;
-      let loadListener = () => {
-        browserListener();
+    // Proxy all PushStateTree prototype properties and methods to the current PST instance
+    proxyTo(router, PushStateTree.prototype);
 
-        if (!isIE() || isIE() > 8) return;
+    this.plugins = [];
+    let plugins = options.plugins;
+    let createArguments = arguments;
 
-        // Watch for URL changes in the IE
-        ieWatch = setInterval(browserListener, 50);
-      };
+    plugins.forEach(plugin => {
 
-      // If the DOM is ready when running the PST, execute loadListeners and ignore others
-      if (document.readyState == 'complete') {
-        loadListener();
-      } else {
-        // Modern browsers
-        document.addEventListener('DOMContentLoaded', browserListener);
-        // Some IE browsers
-        root.addEventListener('readystatechange', browserListener);
-        // Almost all browsers
-        root.addEventListener('load', loadListener);
+      // Execute the static create method
+      if (plugin.constructor && typeof plugin.constructor.create == 'function') {
+        plugin.constructor.create.call(plugin, router, ...createArguments);
       }
 
-      return () => {
-        // Method to stop watching
-        this.removeEventListener('dispatch', dispatchListener);
-        root.removeEventListener(POP_STATE, browserListener);
-        document.removeEventListener('DOMContentLoaded', browserListener);
-        root.removeEventListener('readystatechange', browserListener);
-        root.removeEventListener(HASH_CHANGE, browserListener);
-        root.removeEventListener('load', loadListener);
-        if (ieWatch) clearInterval(ieWatch);
-      };
-    },
+      // Execute the create method
+      if (typeof plugin.create == 'function') {
+        plugin.create(router, ...createArguments);
+      }
+
+      // Expose loaded plugins
+      this.plugins.push(plugin);
+    });
+
+    return router;
+  },
+
+  createElement(name) {
+    // When document is available, use it to create and return a HTMLElement
+    if (typeof document !== 'undefined') {
+      return document.createElement(name);
+    }
+    throw new Error('PushStateTree requires HTMLElement support from window to work.')
+  },
+
+  prototype: {
+    // VERSION is defined in the webpack build, it is replaced by package.version
+    VERSION,
 
     createRule(options) {
       // Create a pushstreamtree-rule element from a literal object
@@ -730,170 +555,5 @@ objectMixinProperties(PushStateTree, {
   }
 });
 
-function preProcessUriBeforeExecuteNativeHistoryMethods(method) {
-
-  // If not pushState or replaceState methods, execute it from history API
-  if (method !== 'pushState' && method !== 'replaceState') {
-    this[method] = function () {
-      history[method].apply(history, arguments);
-      return this;
-    };
-    return;
-  }
-
-  this[method] = function () {
-    // Wrap method
-
-    // remove the method from arguments
-    let args = Array.prototype.slice.call(arguments);
-    let uri = args[0] || '';
-    if (typeof args[2] === 'string') {
-      uri = args[2];
-    }
-
-    // if has a basePath translate the not relative paths to use the basePath
-    if (!isExternal(uri)) {
-      // When not external link, need to normalize the URI
-
-      if (isRelative(uri)) {
-        // Relative to the uri
-        var basePath = this.uri[MATCH](/^([^?#]*)\//);
-        basePath = basePath ? basePath[1] + '/' : '';
-        uri = basePath + uri;
-      } else {
-        // This isn't relative, will cleanup / and # from the begin and use the remain path
-        uri = uri[MATCH](/^([#/]*)?(.*)/)[2];
-      }
-
-      if (!this.usePushState) {
-
-        // Ignore basePath when using location.hash and resolve relative path and keep
-        // the current location.pathname, some browsers history API might apply the new pathname
-        // with the hash content if not explicit
-        uri = location.pathname + '#' + resolveRelativePath(uri);
-      } else {
-
-        // Add the basePath to your uri, not allowing to go by pushState outside the basePath
-        uri = this.basePath + uri;
-      }
-    }
-
-    // Ignore state and make the url be the current uri
-    args[0] = null;
-    args[2] = uri;
-
-    this.path = this.basePath + uri;
-    history[method].apply(history, args);
-    return this;
-  };
-}
-
-// Wrap history methods
-for (var method in history) {
-  if (typeof history[method] === 'function') {
-    preProcessUriBeforeExecuteNativeHistoryMethods.call(PushStateTree.prototype, method);
-  }
-}
-
-// Add support to pushState on old browsers that doesn't native support it
-if (typeof PST_NO_OLD_IE == 'undefined'
-  && typeof PST_NO_SHIM == 'undefined'
-  && !PushStateTree.hasPushState
-  && location
-) {
-  PushStateTree.prototype.pushState = function (uri, ignored, deprecatedUri) {
-    // Does a shim for pushState when history API doesn't support pushState,
-    // from version 0.15.x it ignores state and title definition since they are
-    // never used in any production project so far and seems to make harder to
-    // developers to use the method since they need to add 2 useless arguments
-    // before the really necessary one.
-    // However it keeps compatible with any implementation that already add the
-    // url as third argument.
-    if (typeof deprecatedUri == 'string') {
-      uri = deprecatedUri;
-    }
-    if (typeof uri != 'string') {
-      uri = '';
-    }
-
-    // Replace hash url
-    if (isExternal(uri)) {
-      // this will redirect the browser, so doesn't matters the rest...
-      location.href = uri;
-    }
-
-    // Remove the has if is it present
-    if (uri[0] === '#') {
-      uri = uri.slice(1);
-    }
-
-    if (isRelative(uri)) {
-      uri = location.hash.slice(1, location.hash.lastIndexOf('/') + 1) + uri;
-      uri = resolveRelativePath(uri);
-    }
-
-    // Include the basePath in the uri, if is already in the current router
-    // basePath, it will apply the assign without refresh, but if the basePath
-    // is different, it will refresh the browser to work in the current router
-    // basePath.
-    // The behavior is the same in browsers that support pushState, however they
-    // don't refresh when switching between basePath of different routers
-    this.path = this.basePath + uri;
-    if (location.pathname == this.basePath) {
-      location.hash = uri;
-    } else {
-      location.assign(uri);
-    }
-
-    return this;
-  };
-
-  PushStateTree.prototype.replaceState = function (uri, ignored, deprecatedUri) {
-    // Does a shim for replaceState when history API doesn't support pushState,
-    // from version 0.15.x it ignores state and title definition since they are
-    // never used in any production project so far and seems to make harder to
-    // developers to use the method since they need to add 2 useless arguments
-    // before the really necessary one.
-    // However it keeps compatible with any implementation that already add the
-    // url as third argument.
-
-    if (typeof deprecatedUri == 'string') {
-      uri = deprecatedUri;
-    }
-    if (typeof uri != 'string') {
-      uri = '';
-    }
-
-    // Replace the url
-    if (isExternal(uri)) {
-      throw new Error('Invalid url replace.');
-    }
-
-    if (uri[0] === '#') {
-      uri = uri.slice(1);
-    }
-
-    if (isRelative(uri)) {
-      var relativePos = location.hash.lastIndexOf('/') + 1;
-      uri = location.hash.slice(1, relativePos) + uri;
-      uri = resolveRelativePath(uri);
-    }
-
-    // Always use hash navigation
-    uri = '#' + uri;
-
-    // Include the basePath in the uri, if is already in the current router
-    // basePath, it will apply the replace without refresh, but if the basePath
-    // is different, it will refresh the browser to work in the current router
-    // basePath.
-    // The behavior is the same in browsers that support pushState, however they
-    // don't refresh when switching between basePath of different routers
-    this.path = this.basePath + uri;
-    location.replace(uri);
-
-    return this;
-  };
-}
-
 // Node import support
-module.exports = PushStateTree;
+export default PushStateTree;
diff --git a/src/route.js b/src/route.js
new file mode 100644
index 0000000..1b3827e
--- /dev/null
+++ b/src/route.js
@@ -0,0 +1,9 @@
+// Define the PushStateTree route elements
+
+export function Route() {
+
+}
+
+Route.adapter = document;
+
+export default Route;
\ No newline at end of file
diff --git a/test/helper/cleanHistoryAPI.js b/test/helper/cleanHistoryAPI.js
index a26f59d..fa849ee 100644
--- a/test/helper/cleanHistoryAPI.js
+++ b/test/helper/cleanHistoryAPI.js
@@ -1,15 +1,27 @@
-const PushStateTree = require('../../src/push-state-tree');
+import useBrowser from './useBrowser';
 
 export default function cleanHistoryAPI() {
 
-  let enabledInstances = [];
-  
+  useBrowser();
+
+  let originalWindowAddEventListener = window.addEventListener;
+  let windowEvents = [];
+  let originalDocumentAddEventListener = document.addEventListener;
+  let documentEvents = [];
+
   before(() => {
-    let cache = PushStateTree.prototype.startGlobalListeners;
-    PushStateTree.prototype.startGlobalListeners = function () {
-      enabledInstances.push(this);
-      return cache.apply(this, arguments);
-    }
+    window.addEventListener = function () {
+      windowEvents.push(arguments);
+      originalWindowAddEventListener.apply(this, arguments);
+    };
+    document.addEventListener = function () {
+      documentEvents.push(arguments);
+      originalDocumentAddEventListener.apply(this, arguments);
+    };
+  });
+
+  after(() => {
+    window.addEventListener = originalWindowAddEventListener;
   });
 
   beforeEach(() => {
@@ -19,8 +31,15 @@ export default function cleanHistoryAPI() {
   afterEach(() => {
     // Reset the URI before begin the tests
     history.pushState(null, null, '/');
-    while (enabledInstances.length) {
-      enabledInstances.shift().disabled = true;
-    }
+
+    // Reset window events
+    windowEvents.forEach(args => {
+      window.removeEventListener(...args);
+    });
+
+    // Reset document events
+    documentEvents.forEach(args => {
+      document.removeEventListener(...args);
+    });
   });
 }
\ No newline at end of file
diff --git a/test/helper/useBrowser.js b/test/helper/useBrowser.js
new file mode 100644
index 0000000..0195cd7
--- /dev/null
+++ b/test/helper/useBrowser.js
@@ -0,0 +1,19 @@
+import PushStateTree from '../../src/push-state-tree';
+import BrowserAdapter from '../../src/adapter/browser';
+import PluginInjector from '../../src/adapter/pluginInjector';
+import BrowserHistory from '../../src/plugin/history';
+
+let originalPrototype = PushStateTree.prototype;
+export default function useBrowser() {
+
+  before(() => {
+    // Add adapters as extension of the prototype
+    PushStateTree.addAdapter(BrowserAdapter);
+    PushStateTree.addAdapter(PluginInjector, BrowserHistory);
+  });
+
+  after(() => {
+    // Restore the original prototype
+    PushStateTree.prototype = originalPrototype;
+  });
+}
\ No newline at end of file
diff --git a/test/helpers/isInt.js b/test/helpers/isInt.js
new file mode 100644
index 0000000..8cedcf2
--- /dev/null
+++ b/test/helpers/isInt.js
@@ -0,0 +1,50 @@
+import { isInt } from '../../src/helpers';
+
+describe('PushStateTree isInt', function() {
+
+  it('should return true for valid numbers', function() {
+    expect(isInt(0)).to.be.true;
+    expect(isInt(1)).to.be.true;
+    expect(isInt(-1)).to.be.true;
+  });
+
+  it('should return true for valid number in string', function() {
+    expect(isInt('0')).to.be.true;
+    expect(isInt('1')).to.be.true;
+    expect(isInt('2')).to.be.true;
+  });
+
+  it('should return false for Boolean values', function() {
+    expect(isInt(true)).to.be.false;
+    expect(isInt(false)).to.be.false;
+  });
+
+  it('should return false for literal objects', function() {
+    expect(isInt({})).to.be.false;
+  });
+
+  it('should return false when no value is specified', function() {
+    expect(isInt()).to.be.false;
+  });
+
+  it('should return false for invalid strings', function() {
+    expect(isInt('1bc')).to.be.false;
+    expect(isInt('1.1')).to.be.false;
+    expect(isInt('-1.1')).to.be.false;
+  });
+
+  it('should return false for null', function() {
+    expect(isInt(null)).to.be.false;
+  });
+
+  it('should return false for infinity numbers', function() {
+    expect(isInt(Number.POSITIVE_INFINITY)).to.be.false;
+    expect(isInt(Number.NEGATIVE_INFINITY)).to.be.false;
+  });
+
+  it('should return false for invalid numbers', function() {
+    expect(isInt(1.1)).to.be.false;
+    expect(isInt(-1.1)).to.be.false;
+  });
+
+});
diff --git a/test/isInt.js b/test/isInt.js
deleted file mode 100644
index a6d5d39..0000000
--- a/test/isInt.js
+++ /dev/null
@@ -1,50 +0,0 @@
-var PushStateTree = require('../src/push-state-tree');
-
-describe('PushStateTree isInt', function() {
-
-  it('should return true for valid numbers', function() {
-    expect(PushStateTree.isInt(0)).to.be.true;
-    expect(PushStateTree.isInt(1)).to.be.true;
-    expect(PushStateTree.isInt(-1)).to.be.true;
-  });
-
-  it('should return true for valid number in string', function() {
-    expect(PushStateTree.isInt('0')).to.be.true;
-    expect(PushStateTree.isInt('1')).to.be.true;
-    expect(PushStateTree.isInt('2')).to.be.true;
-  });
-
-  it('should return false for Boolean values', function() {
-    expect(PushStateTree.isInt(true)).to.be.false;
-    expect(PushStateTree.isInt(false)).to.be.false;
-  });
-
-  it('should return false for literal objects', function() {
-    expect(PushStateTree.isInt({})).to.be.false;
-  });
-
-  it('should return false when no value is specified', function() {
-    expect(PushStateTree.isInt()).to.be.false;
-  });
-
-  it('should return false for invalid strings', function() {
-    expect(PushStateTree.isInt('1bc')).to.be.false;
-    expect(PushStateTree.isInt('1.1')).to.be.false;
-    expect(PushStateTree.isInt('-1.1')).to.be.false;
-  });
-
-  it('should return false for null', function() {
-    expect(PushStateTree.isInt(null)).to.be.false;
-  });
-
-  it('should return false for infinity numbers', function() {
-    expect(PushStateTree.isInt(Number.POSITIVE_INFINITY)).to.be.false;
-    expect(PushStateTree.isInt(Number.NEGATIVE_INFINITY)).to.be.false;
-  });
-
-  it('should return false for invalid numbers', function() {
-    expect(PushStateTree.isInt(1.1)).to.be.false;
-    expect(PushStateTree.isInt(-1.1)).to.be.false;
-  });
-
-});
diff --git a/test/route-basePath.js b/test/router-basePath.js
similarity index 79%
rename from test/route-basePath.js
rename to test/router-basePath.js
index e498c9d..de8ee33 100644
--- a/test/route-basePath.js
+++ b/test/router-basePath.js
@@ -1,18 +1,15 @@
-const PushStateTree = require('../src/push-state-tree');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
+import PushStateTree from '../src/push-state-tree';
 
-describe('PushStateTree Router basePath', function () {
+describe('PushStateTree Router basePath', () => {
 
-  cleanHistoryAPI();
-
-  it('should allow to set the base path', function () {
+  it('should allow to set the base path', () => {
     var pst = new PushStateTree({
       basePath: '/test/'
     });
     expect(pst.basePath).to.equal('/test/');
   });
 
-  it('should normalize basePath folder', function () {
+  it('should normalize basePath folder', () => {
     expect((new PushStateTree({
       basePath: 'folder/'
     })).basePath).to.equal('/folder/');
@@ -21,7 +18,7 @@ describe('PushStateTree Router basePath', function () {
     })).basePath).to.equal('/folder/sub-folder/');
   });
 
-  it('should normalize basePath file', function () {
+  it('should normalize basePath file', () => {
     expect((new PushStateTree({
       basePath: 'file'
     })).basePath).to.equal('/file');
@@ -57,9 +54,10 @@ describe('PushStateTree Router basePath', function () {
     var pst = new PushStateTree({
       basePath: 'file.html'
     });
-    history.pushState(null, null, '/file.html/test');
-    //TODO: history.pushState is not dispatching popstate event
+
+    pst.path = '/file.html/test';
     pst.dispatch();
+
     expect(pst.uri).to.equal('test');
   });
 
@@ -73,5 +71,4 @@ describe('PushStateTree Router basePath', function () {
     expect(pst1.basePath).to.equal('/1/');
     expect(pst2.basePath).to.equal('/2/');
   });
-
 });
diff --git a/test/router.js b/test/router.js
new file mode 100644
index 0000000..331975c
--- /dev/null
+++ b/test/router.js
@@ -0,0 +1,17 @@
+import PushStateTree from '../src/push-state-tree';
+
+describe('PushStateTree should', function() {
+  it('be available as UMD library', function() {
+    expect(PushStateTree).to.be.defined;
+  });
+
+  it('instances without "new" operator', function() {
+    /* jshint newcap: false*/
+    expect(PushStateTree()).to.be.instanceof(HTMLElement);
+  });
+
+  it('construct and became a HTMLElement instance', function(){
+    expect(new PushStateTree()).to.be.instanceof(HTMLElement);
+    expect(new PushStateTree({})).to.be.instanceof(HTMLElement);
+  });
+});
diff --git a/test/version.js b/test/version.js
index 196ccf6..713167e 100644
--- a/test/version.js
+++ b/test/version.js
@@ -1,11 +1,7 @@
-const PushStateTree = require('../src/push-state-tree');
+import PushStateTree from '../src/push-state-tree';
 const pkg = require('../package.json');
-import cleanHistoryAPI from './helper/cleanHistoryAPI';
 
 describe('PushStateTree', function () {
-
-  cleanHistoryAPI();
-
   it('should provide the version as static property in the function', () => {
     expect(PushStateTree.VERSION).to.be.a('string');
   });
diff --git a/webpack.config.js b/webpack.config.js
index 24c27e6..138453e 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -24,9 +24,11 @@ const BANNER = `${pkg.title} - v${pkg.version} - ${moment().format('YYYY-MM-DD')
  Copyright (c) ${moment().format('YYYY')} ${pkg.author.name}; Licensed ${pkg.licenses[0].type}`;
 
 let config = {
-  entry: !PUBLISH ? { 'push-state-tree': './src/push-state-tree' } : {
-    'push-state-tree': './src/push-state-tree',
-    'push-state-tree.min': './src/push-state-tree'
+  entry: PUBLISH ? {
+    'push-state-tree': ['./src/main'],
+    'push-state-tree.min': ['./src/main']
+  } : {
+    'push-state-tree': ['./src/main']
   },
   output: {
     path: path.join(BASE_PATH, 'build'),