riot_js-rails 0.6.2 → 0.7.0

data/vendor/assets/javascripts/compiler/parsers/less.js

@@ -0,0 +1,31 @@
+/*
+  Less CSS plugin.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+*/
+var
+  mixobj = require('./_utils').mixobj,
+  parser = require('less')
+
+var defopts = {
+  sync: true,
+  syncImport: true,
+  compress: true
+}
+
+module.exports = function _less (tag, css, opts, url) {
+  var ret
+
+  opts = mixobj(defopts, { filename: url }, opts)
+
+  parser.render(css, opts, function (err, result) {
+    // istanbul ignore next
+    if (err) throw err
+    ret = result.css
+  })
+
+  return ret
+}

data/vendor/assets/javascripts/compiler/parsers/livescript.js

@@ -0,0 +1,20 @@
+/*
+  LiveScript JS plugin.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+*/
+var
+  mixobj = require('./_utils').mixobj,
+  parser = require('livescript')
+
+var defopts = {
+  bare: true,
+  header: false
+}
+
+module.exports = function _livescript (js, opts) {
+  return parser.compile(js, mixobj(defopts, opts))
+}

data/vendor/assets/javascripts/compiler/parsers/pug.js

@@ -0,0 +1,23 @@
+/*
+  Jade HTML plugin.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+*/
+var
+  mixobj = require('./_utils').mixobj,
+  parser = require('pug')
+
+var defopts = {
+  pretty: true,
+  doctype: 'html'
+}
+
+module.exports = function _pug (html, opts, url) {
+
+  opts = mixobj(defopts, { filename: url }, opts)
+
+  return parser.render(html, opts)
+}

data/vendor/assets/javascripts/compiler/parsers/sass.js

@@ -0,0 +1,34 @@
+/*
+  Sass CSS plugin.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+  2016-08-30: Fixed issues with indentation
+*/
+var
+  mixobj = require('./_utils').mixobj,
+  getdir = require('path').dirname,
+  parser = require('node-sass')
+
+var defopts = {
+  indentedSyntax: true,
+  omitSourceMapUrl: true,
+  outputStyle: 'compact'
+}
+
+module.exports = function _sass (tag, css, opts, url) {
+  var spc = css.match(/^\s+/)
+
+  if (spc) {
+    css = css.replace(RegExp('^' + spc[0], 'gm'), '')
+    if (/^\t/gm.test(css)) {
+      opts.indentType = 'tab'
+    }
+  }
+
+  opts = mixobj(defopts, { data: css, includePaths: [getdir(url)] }, opts)
+
+  return parser.renderSync(opts).css + ''
+}

data/vendor/assets/javascripts/compiler/parsers/scss.js

@@ -0,0 +1,25 @@
+/*
+  Scss CSS plugin.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+*/
+var
+  mixobj = require('./_utils').mixobj,
+  getdir = require('path').dirname,
+  parser = require('node-sass')
+
+var defopts = {
+  indentedSyntax: false,
+  omitSourceMapUrl: true,
+  outputStyle: 'compact'
+}
+
+module.exports = function _scss (tag, css, opts, url) {
+
+  opts = mixobj(defopts, { data: css, includePaths: [getdir(url)] }, opts)
+
+  return parser.renderSync(opts).css + ''
+}

data/vendor/assets/javascripts/compiler/parsers/stylus.js

@@ -0,0 +1,26 @@
+/*
+  Stylus CSS plugin, with optional nib support.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+*/
+var
+  mixobj = require('./_utils').mixobj,
+  tryreq = require('./_utils').tryreq,
+  parser = require('stylus')
+
+// Optional nib support
+var nib = tryreq('nib')
+
+// istanbul ignore next: can't run both
+module.exports = nib
+  ? function _stylus (tag, css, opts, url) {
+    opts = mixobj({ filename: url }, opts)
+    return parser(css, opts).use(nib()).import('nib').render()
+  }
+  : function _stylus (tag, css, opts, url) {
+    opts = mixobj({ filename: url }, opts)
+    return parser.render(css, opts)
+  }

data/vendor/assets/javascripts/compiler/parsers/typescript.js

@@ -0,0 +1,9 @@
+/*
+  TypeScript JS plugin.
+  Part of the riot-compiler, license MIT
+
+  History
+  -------
+  2016-03-09: Initital release
+*/
+module.exports = require('typescript-simple')

data/vendor/assets/javascripts/compiler/safe-regex.js

@@ -0,0 +1,19 @@
+
+'use strict'
+
+// istanbul ignore next
+function safeRegex (re) {
+  var src = re.source
+  var opt = re.global ? 'g' : ''
+
+  if (re.ignoreCase) opt += 'i'
+  if (re.multiline)  opt += 'm'
+
+  for (var i = 1; i < arguments.length; i++) {
+    src = src.replace('@', '\\' + arguments[i])
+  }
+
+  return new RegExp(src, opt)
+}
+
+module.exports = safeRegex

data/vendor/assets/javascripts/riot.js

@@ -1,539 +1,377 @@
-/* Riot v2.6.1, @license MIT */
-
-;(function(window, undefined) {
-  'use strict';
-var riot = { version: 'v2.6.1', settings: {} },
-  // be aware, internal usage
-  // ATTENTION: prefix the global dynamic variables with `__`
-
-  // counter to give a unique id to all the Tag instances
-  __uid = 0,
-  // tags instances cache
-  __virtualDom = [],
-  // tags implementation cache
-  __tagImpl = {},
-
-  /**
-   * Const
-   */
-  GLOBAL_MIXIN = '__global_mixin',
-
-  // riot specific prefixes
-  RIOT_PREFIX = 'riot-',
-  RIOT_TAG = RIOT_PREFIX + 'tag',
-  RIOT_TAG_IS = 'data-is',
-
-  // for typeof == '' comparisons
-  T_STRING = 'string',
-  T_OBJECT = 'object',
-  T_UNDEF  = 'undefined',
-  T_FUNCTION = 'function',
-  XLINK_NS = 'http://www.w3.org/1999/xlink',
-  XLINK_REGEX = /^xlink:(\w+)/,
-  // special native tags that cannot be treated like the others
-  SPECIAL_TAGS_REGEX = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,
-  RESERVED_WORDS_BLACKLIST = /^(?:_(?:item|id|parent)|update|root|(?:un)?mount|mixin|is(?:Mounted|Loop)|tags|parent|opts|trigger|o(?:n|ff|ne))$/,
-  // SVG tags list https://www.w3.org/TR/SVG/attindex.html#PresentationAttributes
-  SVG_TAGS_LIST = ['altGlyph', 'animate', 'animateColor', 'circle', 'clipPath', 'defs', 'ellipse', 'feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feFlood', 'feGaussianBlur', 'feImage', 'feMerge', 'feMorphology', 'feOffset', 'feSpecularLighting', 'feTile', 'feTurbulence', 'filter', 'font', 'foreignObject', 'g', 'glyph', 'glyphRef', 'image', 'line', 'linearGradient', 'marker', 'mask', 'missing-glyph', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'switch', 'symbol', 'text', 'textPath', 'tref', 'tspan', 'use'],
-
-  // version# for IE 8-11, 0 for others
-  IE_VERSION = (window && window.document || {}).documentMode | 0,
-
-  // detect firefox to fix #1374
-  FIREFOX = window && !!window.InstallTrigger
-/* istanbul ignore next */
-riot.observable = function(el) {
-
-  /**
-   * Extend the original object or create a new empty one
-   * @type { Object }
-   */
-
-  el = el || {}
-
-  /**
-   * Private variables
-   */
-  var callbacks = {},
-    slice = Array.prototype.slice
-
-  /**
-   * Private Methods
-   */
-
-  /**
-   * Helper function needed to get and loop all the events in a string
-   * @param   { String }   e - event string
-   * @param   {Function}   fn - callback
-   */
-  function onEachEvent(e, fn) {
-    var es = e.split(' '), l = es.length, i = 0
-    for (; i < l; i++) {
-      var name = es[i]
-      if (name) fn(name, i)
-    }
-  }
-
-  /**
-   * Public Api
-   */
-
-  // extend the el object adding the observable methods
-  Object.defineProperties(el, {
-    /**
-     * Listen to the given space separated list of `events` and
-     * execute the `callback` each time an event is triggered.
-     * @param  { String } events - events ids
-     * @param  { Function } fn - callback function
-     * @returns { Object } el
-     */
-    on: {
-      value: function(events, fn) {
-        if (typeof fn != 'function')  return el
-
-        onEachEvent(events, function(name, pos) {
-          (callbacks[name] = callbacks[name] || []).push(fn)
-          fn.typed = pos > 0
-        })
-
-        return el
-      },
-      enumerable: false,
-      writable: false,
-      configurable: false
-    },
-
-    /**
-     * Removes the given space separated list of `events` listeners
-     * @param   { String } events - events ids
-     * @param   { Function } fn - callback function
-     * @returns { Object } el
-     */
-    off: {
-      value: function(events, fn) {
-        if (events == '*' && !fn) callbacks = {}
-        else {
-          onEachEvent(events, function(name, pos) {
-            if (fn) {
-              var arr = callbacks[name]
-              for (var i = 0, cb; cb = arr && arr[i]; ++i) {
-                if (cb == fn) arr.splice(i--, 1)
-              }
-            } else delete callbacks[name]
-          })
-        }
-        return el
-      },
-      enumerable: false,
-      writable: false,
-      configurable: false
-    },
-
-    /**
-     * Listen to the given space separated list of `events` and
-     * execute the `callback` at most once
-     * @param   { String } events - events ids
-     * @param   { Function } fn - callback function
-     * @returns { Object } el
-     */
-    one: {
-      value: function(events, fn) {
-        function on() {
-          el.off(events, on)
-          fn.apply(el, arguments)
-        }
-        return el.on(events, on)
-      },
-      enumerable: false,
-      writable: false,
-      configurable: false
-    },
-
-    /**
-     * Execute all callback functions that listen to
-     * the given space separated list of `events`
-     * @param   { String } events - events ids
-     * @returns { Object } el
-     */
-    trigger: {
-      value: function(events) {
-
-        // getting the arguments
-        var arglen = arguments.length - 1,
-          args = new Array(arglen),
-          fns
-
-        for (var i = 0; i < arglen; i++) {
-          args[i] = arguments[i + 1] // skip first argument
-        }
-
-        onEachEvent(events, function(name, pos) {
-
-          fns = slice.call(callbacks[name] || [], 0)
-
-          for (var i = 0, fn; fn = fns[i]; ++i) {
-            if (fn.busy) continue
-            fn.busy = 1
-            fn.apply(el, fn.typed ? [name].concat(args) : args)
-            if (fns[i] !== fn) { i-- }
-            fn.busy = 0
-          }
-
-          if (callbacks['*'] && name != '*')
-            el.trigger.apply(el, ['*', name].concat(args))
-
-        })
-
-        return el
-      },
-      enumerable: false,
-      writable: false,
-      configurable: false
-    }
-  })
-
-  return el
-
+/* Riot v3.0.7, @license MIT */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (factory((global.riot = global.riot || {})));
+}(this, (function (exports) { 'use strict';
+
+var __TAGS_CACHE = [];
+var __TAG_IMPL = {};
+var GLOBAL_MIXIN = '__global_mixin';
+var ATTRS_PREFIX = 'riot-';
+var REF_DIRECTIVES = ['data-ref', 'ref'];
+var IS_DIRECTIVE = 'data-is';
+var CONDITIONAL_DIRECTIVE = 'if';
+var LOOP_DIRECTIVE = 'each';
+var LOOP_NO_REORDER_DIRECTIVE = 'no-reorder';
+var SHOW_DIRECTIVE = 'show';
+var HIDE_DIRECTIVE = 'hide';
+var T_STRING = 'string';
+var T_OBJECT = 'object';
+var T_UNDEF  = 'undefined';
+var T_FUNCTION = 'function';
+var XLINK_NS = 'http://www.w3.org/1999/xlink';
+var XLINK_REGEX = /^xlink:(\w+)/;
+var WIN = typeof window === T_UNDEF ? undefined : window;
+var RE_SPECIAL_TAGS = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/;
+var RE_SPECIAL_TAGS_NO_OPTION = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/;
+var RE_RESERVED_NAMES = /^(?:_(?:item|id|parent)|update|root|(?:un)?mount|mixin|is(?:Mounted|Loop)|tags|refs|parent|opts|trigger|o(?:n|ff|ne))$/;
+var RE_SVG_TAGS = /^(altGlyph|animate(?:Color)?|circle|clipPath|defs|ellipse|fe(?:Blend|ColorMatrix|ComponentTransfer|Composite|ConvolveMatrix|DiffuseLighting|DisplacementMap|Flood|GaussianBlur|Image|Merge|Morphology|Offset|SpecularLighting|Tile|Turbulence)|filter|font|foreignObject|g(?:lyph)?(?:Ref)?|image|line(?:arGradient)?|ma(?:rker|sk)|missing-glyph|path|pattern|poly(?:gon|line)|radialGradient|rect|stop|svg|switch|symbol|text(?:Path)?|tref|tspan|use)$/;
+var RE_HTML_ATTRS = /([-\w]+) ?= ?(?:"([^"]*)|'([^']*)|({[^}]*}))/g;
+var CASE_SENSITIVE_ATTRIBUTES = { 'viewbox': 'viewBox' };
+var RE_BOOL_ATTRS = /^(?:disabled|checked|readonly|required|allowfullscreen|auto(?:focus|play)|compact|controls|default|formnovalidate|hidden|ismap|itemscope|loop|multiple|muted|no(?:resize|shade|validate|wrap)?|open|reversed|seamless|selected|sortable|truespeed|typemustmatch)$/;
+var IE_VERSION = (WIN && WIN.document || {}).documentMode | 0;
+
+/**
+ * Check whether a DOM node must be considered a part of an svg document
+ * @param   { String } name -
+ * @returns { Boolean } -
+ */
+function isSVGTag(name) {
+  return RE_SVG_TAGS.test(name)
 }
-/* istanbul ignore next */
-;(function(riot) {
 
 /**
- * Simple client-side router
- * @module riot-route
+ * Check Check if the passed argument is undefined
+ * @param   { String } value -
+ * @returns { Boolean } -
  */
-
-
-var RE_ORIGIN = /^.+?\/\/+[^\/]+/,
-  EVENT_LISTENER = 'EventListener',
-  REMOVE_EVENT_LISTENER = 'remove' + EVENT_LISTENER,
-  ADD_EVENT_LISTENER = 'add' + EVENT_LISTENER,
-  HAS_ATTRIBUTE = 'hasAttribute',
-  REPLACE = 'replace',
-  POPSTATE = 'popstate',
-  HASHCHANGE = 'hashchange',
-  TRIGGER = 'trigger',
-  MAX_EMIT_STACK_LEVEL = 3,
-  win = typeof window != 'undefined' && window,
-  doc = typeof document != 'undefined' && document,
-  hist = win && history,
-  loc = win && (hist.location || win.location), // see html5-history-api
-  prot = Router.prototype, // to minify more
-  clickEvent = doc && doc.ontouchstart ? 'touchstart' : 'click',
-  started = false,
-  central = riot.observable(),
-  routeFound = false,
-  debouncedEmit,
-  base, current, parser, secondParser, emitStack = [], emitStackLevel = 0
+function isBoolAttr(value) {
+  return RE_BOOL_ATTRS.test(value)
+}
 
 /**
- * Default parser. You can replace it via router.parser method.
- * @param {string} path - current path (normalized)
- * @returns {array} array
+ * Check if passed argument is a function
+ * @param   { * } value -
+ * @returns { Boolean } -
  */
-function DEFAULT_PARSER(path) {
-  return path.split(/[/?#]/)
+function isFunction(value) {
+  return typeof value === T_FUNCTION
 }
 
 /**
- * Default parser (second). You can replace it via router.parser method.
- * @param {string} path - current path (normalized)
- * @param {string} filter - filter string (normalized)
- * @returns {array} array
+ * Check if passed argument is an object, exclude null
+ * NOTE: use isObject(x) && !isArray(x) to excludes arrays.
+ * @param   { * } value -
+ * @returns { Boolean } -
  */
-function DEFAULT_SECOND_PARSER(path, filter) {
-  var re = new RegExp('^' + filter[REPLACE](/\*/g, '([^/?#]+?)')[REPLACE](/\.\./, '.*') + '$'),
-    args = path.match(re)
-
-  if (args) return args.slice(1)
+function isObject(value) {
+  return value && typeof value === T_OBJECT // typeof null is 'object'
 }
 
 /**
- * Simple/cheap debounce implementation
- * @param   {function} fn - callback
- * @param   {number} delay - delay in seconds
- * @returns {function} debounced function
+ * Check if passed argument is undefined
+ * @param   { * } value -
+ * @returns { Boolean } -
  */
-function debounce(fn, delay) {
-  var t
-  return function () {
-    clearTimeout(t)
-    t = setTimeout(fn, delay)
-  }
+function isUndefined(value) {
+  return typeof value === T_UNDEF
 }
 
 /**
- * Set the window listeners to trigger the routes
- * @param {boolean} autoExec - see route.start
+ * Check if passed argument is a string
+ * @param   { * } value -
+ * @returns { Boolean } -
  */
-function start(autoExec) {
-  debouncedEmit = debounce(emit, 1)
-  win[ADD_EVENT_LISTENER](POPSTATE, debouncedEmit)
-  win[ADD_EVENT_LISTENER](HASHCHANGE, debouncedEmit)
-  doc[ADD_EVENT_LISTENER](clickEvent, click)
-  if (autoExec) emit(true)
+function isString(value) {
+  return typeof value === T_STRING
 }
 
 /**
- * Router class
+ * Check if passed argument is empty. Different from falsy, because we dont consider 0 or false to be blank
+ * @param { * } value -
+ * @returns { Boolean } -
  */
-function Router() {
-  this.$ = []
-  riot.observable(this) // make it observable
-  central.on('stop', this.s.bind(this))
-  central.on('emit', this.e.bind(this))
-}
-
-function normalize(path) {
-  return path[REPLACE](/^\/|\/$/, '')
-}
-
-function isString(str) {
-  return typeof str == 'string'
+function isBlank(value) {
+  return isUndefined(value) || value === null || value === ''
 }
 
 /**
- * Get the part after domain name
- * @param {string} href - fullpath
- * @returns {string} path from root
+ * Check if passed argument is a kind of array
+ * @param   { * } value -
+ * @returns { Boolean } -
  */
-function getPathFromRoot(href) {
-  return (href || loc.href)[REPLACE](RE_ORIGIN, '')
+function isArray(value) {
+  return Array.isArray(value) || value instanceof Array
 }
 
 /**
- * Get the part after base
- * @param {string} href - fullpath
- * @returns {string} path from base
+ * Check whether object's property could be overridden
+ * @param   { Object }  obj - source object
+ * @param   { String }  key - object property
+ * @returns { Boolean } -
  */
-function getPathFromBase(href) {
-  return base[0] == '#'
-    ? (href || loc.href || '').split(base)[1] || ''
-    : (loc ? getPathFromRoot(href) : href || '')[REPLACE](base, '')
+function isWritable(obj, key) {
+  var descriptor = Object.getOwnPropertyDescriptor(obj, key);
+  return isUndefined(obj[key]) || descriptor && descriptor.writable
 }
 
-function emit(force) {
-  // the stack is needed for redirections
-  var isRoot = emitStackLevel == 0, first
-  if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) return
-
-  emitStackLevel++
-  emitStack.push(function() {
-    var path = getPathFromBase()
-    if (force || path != current) {
-      central[TRIGGER]('emit', path)
-      current = path
-    }
-  })
-  if (isRoot) {
-    while (first = emitStack.shift()) first() // stack increses within this call
-    emitStackLevel = 0
-  }
+/**
+ * Check if passed argument is a reserved name
+ * @param   { String } value -
+ * @returns { Boolean } -
+ */
+function isReservedName(value) {
+  return RE_RESERVED_NAMES.test(value)
 }
 
-function click(e) {
-  if (
-    e.which != 1 // not left click
-    || e.metaKey || e.ctrlKey || e.shiftKey // or meta keys
-    || e.defaultPrevented // or default prevented
-  ) return
-
-  var el = e.target
-  while (el && el.nodeName != 'A') el = el.parentNode
+var check = Object.freeze({
+	isSVGTag: isSVGTag,
+	isBoolAttr: isBoolAttr,
+	isFunction: isFunction,
+	isObject: isObject,
+	isUndefined: isUndefined,
+	isString: isString,
+	isBlank: isBlank,
+	isArray: isArray,
+	isWritable: isWritable,
+	isReservedName: isReservedName
+});
 
-  if (
-    !el || el.nodeName != 'A' // not A tag
-    || el[HAS_ATTRIBUTE]('download') // has download attr
-    || !el[HAS_ATTRIBUTE]('href') // has no href attr
-    || el.target && el.target != '_self' // another window or frame
-    || el.href.indexOf(loc.href.match(RE_ORIGIN)[0]) == -1 // cross origin
-  ) return
-
-  if (el.href != loc.href
-    && (
-      el.href.split('#')[0] == loc.href.split('#')[0] // internal jump
-      || base[0] != '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base
-      || base[0] == '#' && el.href.split(base)[0] != loc.href.split(base)[0] // outside of #base
-      || !go(getPathFromBase(el.href), el.title || doc.title) // route not found
-    )) return
-
-  e.preventDefault()
+/**
+ * Shorter and fast way to select multiple nodes in the DOM
+ * @param   { String } selector - DOM selector
+ * @param   { Object } ctx - DOM node where the targets of our search will is located
+ * @returns { Object } dom nodes found
+ */
+function $$(selector, ctx) {
+  return (ctx || document).querySelectorAll(selector)
 }
 
 /**
- * Go to the path
- * @param {string} path - destination path
- * @param {string} title - page title
- * @param {boolean} shouldReplace - use replaceState or pushState
- * @returns {boolean} - route not found flag
+ * Shorter and fast way to select a single node in the DOM
+ * @param   { String } selector - unique dom selector
+ * @param   { Object } ctx - DOM node where the target of our search will is located
+ * @returns { Object } dom node found
  */
-function go(path, title, shouldReplace) {
-  // Server-side usage: directly execute handlers for the path
-  if (!hist) return central[TRIGGER]('emit', getPathFromBase(path))
-
-  path = base + normalize(path)
-  title = title || doc.title
-  // browsers ignores the second parameter `title`
-  shouldReplace
-    ? hist.replaceState(null, title, path)
-    : hist.pushState(null, title, path)
-  // so we need to set it manually
-  doc.title = title
-  routeFound = false
-  emit()
-  return routeFound
+function $(selector, ctx) {
+  return (ctx || document).querySelector(selector)
 }
 
 /**
- * Go to path or set action
- * a single string:                go there
- * two strings:                    go there with setting a title
- * two strings and boolean:        replace history with setting a title
- * a single function:              set an action on the default route
- * a string/RegExp and a function: set an action on the route
- * @param {(string|function)} first - path / action / filter
- * @param {(string|RegExp|function)} second - title / action
- * @param {boolean} third - replace flag
+ * Create a document fragment
+ * @returns { Object } document fragment
  */
-prot.m = function(first, second, third) {
-  if (isString(first) && (!second || isString(second))) go(first, second, third || false)
-  else if (second) this.r(first, second)
-  else this.r('@', first)
+function createFrag() {
+  return document.createDocumentFragment()
 }
 
 /**
- * Stop routing
+ * Create a document text node
+ * @returns { Object } create a text node to use as placeholder
  */
-prot.s = function() {
-  this.off('*')
-  this.$ = []
+function createDOMPlaceholder() {
+  return document.createTextNode('')
 }
 
 /**
- * Emit
- * @param {string} path - path
+ * Create a generic DOM node
+ * @param   { String } name - name of the DOM node we want to create
+ * @param   { Boolean } isSvg - should we use a SVG as parent node?
+ * @returns { Object } DOM node just created
  */
-prot.e = function(path) {
-  this.$.concat('@').some(function(filter) {
-    var args = (filter == '@' ? parser : secondParser)(normalize(path), normalize(filter))
-    if (typeof args != 'undefined') {
-      this[TRIGGER].apply(null, [filter].concat(args))
-      return routeFound = true // exit from loop
-    }
-  }, this)
+function mkEl(name, isSvg) {
+  return isSvg ?
+    document.createElementNS('http://www.w3.org/2000/svg', 'svg') :
+    document.createElement(name)
 }
 
 /**
- * Register route
- * @param {string} filter - filter for matching to url
- * @param {function} action - action to register
+ * Get the outer html of any DOM node SVGs included
+ * @param   { Object } el - DOM node to parse
+ * @returns { String } el.outerHTML
  */
-prot.r = function(filter, action) {
-  if (filter != '@') {
-    filter = '/' + normalize(filter)
-    this.$.push(filter)
+function getOuterHTML(el) {
+  if (el.outerHTML)
+    { return el.outerHTML }
+  // some browsers do not support outerHTML on the SVGs tags
+  else {
+    var container = mkEl('div');
+    container.appendChild(el.cloneNode(true));
+    return container.innerHTML
   }
-  this.on(filter, action)
 }
 
-var mainRouter = new Router()
-var route = mainRouter.m.bind(mainRouter)
-
 /**
- * Create a sub router
- * @returns {function} the method of a new Router object
+ * Set the inner html of any DOM node SVGs included
+ * @param { Object } container - DOM node where we'll inject new html
+ * @param { String } html - html to inject
  */
-route.create = function() {
-  var newSubRouter = new Router()
-  // assign sub-router's main method
-  var router = newSubRouter.m.bind(newSubRouter)
-  // stop only this sub-router
-  router.stop = newSubRouter.s.bind(newSubRouter)
-  return router
+function setInnerHTML(container, html) {
+  if (!isUndefined(container.innerHTML))
+    { container.innerHTML = html; }
+    // some browsers do not support innerHTML on the SVGs tags
+  else {
+    var doc = new DOMParser().parseFromString(html, 'application/xml');
+    var node = container.ownerDocument.importNode(doc.documentElement, true);
+    container.appendChild(node);
+  }
 }
 
 /**
- * Set the base of url
- * @param {(str|RegExp)} arg - a new base or '#' or '#!'
+ * Remove any DOM attribute from a node
+ * @param   { Object } dom - DOM node we want to update
+ * @param   { String } name - name of the property we want to remove
  */
-route.base = function(arg) {
-  base = arg || '#'
-  current = getPathFromBase() // recalculate current path
+function remAttr(dom, name) {
+  dom.removeAttribute(name);
 }
 
-/** Exec routing right now **/
-route.exec = function() {
-  emit(true)
+/**
+ * Get the value of any DOM attribute on a node
+ * @param   { Object } dom - DOM node we want to parse
+ * @param   { String } name - name of the attribute we want to get
+ * @returns { String | undefined } name of the node attribute whether it exists
+ */
+function getAttr(dom, name) {
+  return dom.getAttribute(name)
 }
 
 /**
- * Replace the default router to yours
- * @param {function} fn - your parser function
- * @param {function} fn2 - your secondParser function
+ * Set any DOM attribute
+ * @param { Object } dom - DOM node we want to update
+ * @param { String } name - name of the property we want to set
+ * @param { String } val - value of the property we want to set
  */
-route.parser = function(fn, fn2) {
-  if (!fn && !fn2) {
-    // reset parser for testing...
-    parser = DEFAULT_PARSER
-    secondParser = DEFAULT_SECOND_PARSER
-  }
-  if (fn) parser = fn
-  if (fn2) secondParser = fn2
+function setAttr(dom, name, val) {
+  var xlink = XLINK_REGEX.exec(name);
+  if (xlink && xlink[1])
+    { dom.setAttributeNS(XLINK_NS, xlink[1], val); }
+  else
+    { dom.setAttribute(name, val); }
 }
 
 /**
- * Helper function to get url query as an object
- * @returns {object} parsed query
+ * Insert safely a tag to fix #1962 #1649
+ * @param   { HTMLElement } root - children container
+ * @param   { HTMLElement } curr - node to insert
+ * @param   { HTMLElement } next - node that should preceed the current node inserted
  */
-route.query = function() {
-  var q = {}
-  var href = loc.href || current
-  href[REPLACE](/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v })
-  return q
+function safeInsert(root, curr, next) {
+  root.insertBefore(curr, next.parentNode && next);
 }
 
-/** Stop routing **/
-route.stop = function () {
-  if (started) {
-    if (win) {
-      win[REMOVE_EVENT_LISTENER](POPSTATE, debouncedEmit)
-      win[REMOVE_EVENT_LISTENER](HASHCHANGE, debouncedEmit)
-      doc[REMOVE_EVENT_LISTENER](clickEvent, click)
-    }
-    central[TRIGGER]('stop')
-    started = false
-  }
+/**
+ * Minimize risk: only zero or one _space_ between attr & value
+ * @param   { String }   html - html string we want to parse
+ * @param   { Function } fn - callback function to apply on any attribute found
+ */
+function walkAttrs(html, fn) {
+  if (!html)
+    { return }
+  var m;
+  while (m = RE_HTML_ATTRS.exec(html))
+    { fn(m[1].toLowerCase(), m[2] || m[3] || m[4]); }
 }
 
 /**
- * Start routing
- * @param {boolean} autoExec - automatically exec after starting if true
+ * Walk down recursively all the children tags starting dom node
+ * @param   { Object }   dom - starting node where we will start the recursion
+ * @param   { Function } fn - callback to transform the child node just found
+ * @param   { Object }   context - fn can optionally return an object, which is passed to children
  */
-route.start = function (autoExec) {
-  if (!started) {
-    if (win) {
-      if (document.readyState == 'complete') start(autoExec)
-      // the timeout is needed to solve
-      // a weird safari bug https://github.com/riot/route/issues/33
-      else win[ADD_EVENT_LISTENER]('load', function() {
-        setTimeout(function() { start(autoExec) }, 1)
-      })
+function walkNodes(dom, fn, context) {
+  if (dom) {
+    var res = fn(dom, context);
+    var next;
+    // stop the recursion
+    if (res === false) { return }
+
+    dom = dom.firstChild;
+
+    while (dom) {
+      next = dom.nextSibling;
+      walkNodes(dom, fn, res);
+      dom = next;
     }
-    started = true
   }
 }
 
-/** Prepare the router **/
-route.base()
-route.parser()
+var dom = Object.freeze({
+	$$: $$,
+	$: $,
+	createFrag: createFrag,
+	createDOMPlaceholder: createDOMPlaceholder,
+	mkEl: mkEl,
+	getOuterHTML: getOuterHTML,
+	setInnerHTML: setInnerHTML,
+	remAttr: remAttr,
+	getAttr: getAttr,
+	setAttr: setAttr,
+	safeInsert: safeInsert,
+	walkAttrs: walkAttrs,
+	walkNodes: walkNodes
+});
+
+var styleNode;
+var cssTextProp;
+var byName = {};
+var remainder = [];
+var needsInject = false;
+
+// skip the following code on the server
+if (WIN) {
+  styleNode = (function () {
+    // create a new style element with the correct type
+    var newNode = mkEl('style');
+    setAttr(newNode, 'type', 'text/css');
+
+    // replace any user node or insert the new one into the head
+    var userNode = $('style[type=riot]');
+    if (userNode) {
+      if (userNode.id) { newNode.id = userNode.id; }
+      userNode.parentNode.replaceChild(newNode, userNode);
+    }
+    else { document.getElementsByTagName('head')[0].appendChild(newNode); }
+
+    return newNode
+  })();
+  cssTextProp = styleNode.styleSheet;
+}
 
-riot.route = route
-})(riot)
-/* istanbul ignore next */
+/**
+ * Object that will be used to inject and manage the css of every tag instance
+ */
+var styleManager = {
+  styleNode: styleNode,
+  /**
+   * Save a tag style to be later injected into DOM
+   * @param { String } css - css string
+   * @param { String } name - if it's passed we will map the css to a tagname
+   */
+  add: function add(css, name) {
+    if (name) { byName[name] = css; }
+    else { remainder.push(css); }
+    needsInject = true;
+  },
+  /**
+   * Inject all previously saved tag styles into DOM
+   * innerHTML seems slow: http://jsperf.com/riot-insert-style
+   */
+  inject: function inject() {
+    if (!WIN || !needsInject) { return }
+    needsInject = false;
+    var style = Object.keys(byName)
+      .map(function(k) { return byName[k] })
+      .concat(remainder).join('\n');
+    if (cssTextProp) { cssTextProp.cssText = style; }
+    else { styleNode.innerHTML = style; }
+  }
+};
 
 /**
  * The riot template engine
- * @version v2.4.1
+ * @version v3.0.1
  */
 /**
  * riot.util.brackets
@@ -544,6 +382,8 @@ riot.route = route
  * @module
  */
 
+/* global riot */
+
 var brackets = (function (UNDEF) {
 
   var
@@ -567,7 +407,7 @@ var brackets = (function (UNDEF) {
       '{': RegExp('([{}])|'   + S_QBLOCKS, REGLOB)
     },
 
-    DEFAULT = '{ }'
+    DEFAULT = '{ }';
 
   var _pairs = [
     '{', '}',
@@ -579,38 +419,38 @@ var brackets = (function (UNDEF) {
     DEFAULT,
     /^\s*{\^?\s*([$\w]+)(?:\s*,\s*(\S+))?\s+in\s+(\S.*)\s*}/,
     /(^|[^\\]){=[\S\s]*?}/
-  ]
+  ];
 
   var
     cachedBrackets = UNDEF,
     _regex,
     _cache = [],
-    _settings
+    _settings;
 
   function _loopback (re) { return re }
 
   function _rewrite (re, bp) {
-    if (!bp) bp = _cache
+    if (!bp) { bp = _cache; }
     return new RegExp(
       re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''
     )
   }
 
   function _create (pair) {
-    if (pair === DEFAULT) return _pairs
+    if (pair === DEFAULT) { return _pairs }
 
-    var arr = pair.split(' ')
+    var arr = pair.split(' ');
 
     if (arr.length !== 2 || UNSUPPORTED.test(pair)) {
       throw new Error('Unsupported brackets "' + pair + '"')
     }
-    arr = arr.concat(pair.replace(NEED_ESCAPE, '\\').split(' '))
+    arr = arr.concat(pair.replace(NEED_ESCAPE, '\\').split(' '));
 
-    arr[4] = _rewrite(arr[1].length > 1 ? /{[\S\s]*?}/ : _pairs[4], arr)
-    arr[5] = _rewrite(pair.length > 3 ? /\\({|})/g : _pairs[5], arr)
-    arr[6] = _rewrite(_pairs[6], arr)
-    arr[7] = RegExp('\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCKS, REGLOB)
-    arr[8] = pair
+    arr[4] = _rewrite(arr[1].length > 1 ? /{[\S\s]*?}/ : _pairs[4], arr);
+    arr[5] = _rewrite(pair.length > 3 ? /\\({|})/g : _pairs[5], arr);
+    arr[6] = _rewrite(_pairs[6], arr);
+    arr[7] = RegExp('\\\\(' + arr[3] + ')|([[({])|(' + arr[3] + ')|' + S_QBLOCKS, REGLOB);
+    arr[8] = pair;
     return arr
   }
 
@@ -620,7 +460,7 @@ var brackets = (function (UNDEF) {
 
   _brackets.split = function split (str, tmpl, _bp) {
     // istanbul ignore next: _bp is for the compiler
-    if (!_bp) _bp = _cache
+    if (!_bp) { _bp = _cache; }
 
     var
       parts = [],
@@ -628,18 +468,18 @@ var brackets = (function (UNDEF) {
       isexpr,
       start,
       pos,
-      re = _bp[6]
+      re = _bp[6];
 
-    isexpr = start = re.lastIndex = 0
+    isexpr = start = re.lastIndex = 0;
 
     while ((match = re.exec(str))) {
 
-      pos = match.index
+      pos = match.index;
 
       if (isexpr) {
 
         if (match[2]) {
-          re.lastIndex = skipBraces(str, match[2], re.lastIndex)
+          re.lastIndex = skipBraces(str, match[2], re.lastIndex);
           continue
         }
         if (!match[3]) {
@@ -648,97 +488,97 @@ var brackets = (function (UNDEF) {
       }
 
       if (!match[1]) {
-        unescapeStr(str.slice(start, pos))
-        start = re.lastIndex
-        re = _bp[6 + (isexpr ^= 1)]
-        re.lastIndex = start
+        unescapeStr(str.slice(start, pos));
+        start = re.lastIndex;
+        re = _bp[6 + (isexpr ^= 1)];
+        re.lastIndex = start;
       }
     }
 
     if (str && start < str.length) {
-      unescapeStr(str.slice(start))
+      unescapeStr(str.slice(start));
     }
 
     return parts
 
     function unescapeStr (s) {
       if (tmpl || isexpr) {
-        parts.push(s && s.replace(_bp[5], '$1'))
+        parts.push(s && s.replace(_bp[5], '$1'));
       } else {
-        parts.push(s)
+        parts.push(s);
       }
     }
 
     function skipBraces (s, ch, ix) {
       var
         match,
-        recch = FINDBRACES[ch]
+        recch = FINDBRACES[ch];
 
-      recch.lastIndex = ix
-      ix = 1
+      recch.lastIndex = ix;
+      ix = 1;
       while ((match = recch.exec(s))) {
         if (match[1] &&
-          !(match[1] === ch ? ++ix : --ix)) break
+          !(match[1] === ch ? ++ix : --ix)) { break }
       }
       return ix ? s.length : recch.lastIndex
     }
-  }
+  };
 
   _brackets.hasExpr = function hasExpr (str) {
     return _cache[4].test(str)
-  }
+  };
 
   _brackets.loopKeys = function loopKeys (expr) {
-    var m = expr.match(_cache[9])
+    var m = expr.match(_cache[9]);
 
     return m
       ? { key: m[1], pos: m[2], val: _cache[0] + m[3].trim() + _cache[1] }
       : { val: expr.trim() }
-  }
+  };
 
   _brackets.array = function array (pair) {
     return pair ? _create(pair) : _cache
-  }
+  };
 
   function _reset (pair) {
     if ((pair || (pair = DEFAULT)) !== _cache[8]) {
-      _cache = _create(pair)
-      _regex = pair === DEFAULT ? _loopback : _rewrite
-      _cache[9] = _regex(_pairs[9])
+      _cache = _create(pair);
+      _regex = pair === DEFAULT ? _loopback : _rewrite;
+      _cache[9] = _regex(_pairs[9]);
     }
-    cachedBrackets = pair
+    cachedBrackets = pair;
   }
 
   function _setSettings (o) {
-    var b
+    var b;
 
-    o = o || {}
-    b = o.brackets
+    o = o || {};
+    b = o.brackets;
     Object.defineProperty(o, 'brackets', {
       set: _reset,
       get: function () { return cachedBrackets },
       enumerable: true
-    })
-    _settings = o
-    _reset(b)
+    });
+    _settings = o;
+    _reset(b);
   }
 
   Object.defineProperty(_brackets, 'settings', {
     set: _setSettings,
     get: function () { return _settings }
-  })
+  });
 
   /* istanbul ignore next: in the browser riot is always in the scope */
-  _brackets.settings = typeof riot !== 'undefined' && riot.settings || {}
-  _brackets.set = _reset
+  _brackets.settings = typeof riot !== 'undefined' && riot.settings || {};
+  _brackets.set = _reset;
 
-  _brackets.R_STRINGS = R_STRINGS
-  _brackets.R_MLCOMMS = R_MLCOMMS
-  _brackets.S_QBLOCKS = S_QBLOCKS
+  _brackets.R_STRINGS = R_STRINGS;
+  _brackets.R_MLCOMMS = R_MLCOMMS;
+  _brackets.S_QBLOCKS = S_QBLOCKS;
 
   return _brackets
 
-})()
+})();
 
 /**
  * @module tmpl
@@ -750,64 +590,69 @@ var brackets = (function (UNDEF) {
 
 var tmpl = (function () {
 
-  var _cache = {}
+  var _cache = {};
 
   function _tmpl (str, data) {
-    if (!str) return str
+    if (!str) { return str }
 
     return (_cache[str] || (_cache[str] = _create(str))).call(data, _logErr)
   }
 
-  _tmpl.haveRaw = brackets.hasRaw
+  _tmpl.hasExpr = brackets.hasExpr;
 
-  _tmpl.hasExpr = brackets.hasExpr
-
-  _tmpl.loopKeys = brackets.loopKeys
+  _tmpl.loopKeys = brackets.loopKeys;
 
   // istanbul ignore next
-  _tmpl.clearCache = function () { _cache = {} }
+  _tmpl.clearCache = function () { _cache = {}; };
 
-  _tmpl.errorHandler = null
+  _tmpl.errorHandler = null;
 
   function _logErr (err, ctx) {
 
-    if (_tmpl.errorHandler) {
-
-      err.riotData = {
-        tagName: ctx && ctx.root && ctx.root.tagName,
-        _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase
+    err.riotData = {
+      tagName: ctx && ctx.root && ctx.root.tagName,
+      _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase
+    };
+
+    if (_tmpl.errorHandler) { _tmpl.errorHandler(err); }
+    else if (
+      typeof console !== 'undefined' &&
+      typeof console.error === 'function'
+    ) {
+      if (err.riotData.tagName) {
+        console.error('Riot template error thrown in the <%s> tag', err.riotData.tagName.toLowerCase());
       }
-      _tmpl.errorHandler(err)
+      console.error(err);
     }
   }
 
   function _create (str) {
-    var expr = _getTmpl(str)
+    var expr = _getTmpl(str);
 
-    if (expr.slice(0, 11) !== 'try{return ') expr = 'return ' + expr
+    if (expr.slice(0, 11) !== 'try{return ') { expr = 'return ' + expr; }
 
     return new Function('E', expr + ';')    // eslint-disable-line no-new-func
   }
 
   var
-    CH_IDEXPR = '\u2057',
+    CH_IDEXPR = String.fromCharCode(0x2057),
     RE_CSNAME = /^(?:(-?[_A-Za-z\xA0-\xFF][-\w\xA0-\xFF]*)|\u2057(\d+)~):/,
     RE_QBLOCK = RegExp(brackets.S_QBLOCKS, 'g'),
     RE_DQUOTE = /\u2057/g,
-    RE_QBMARK = /\u2057(\d+)~/g
+    RE_QBMARK = /\u2057(\d+)~/g;
 
   function _getTmpl (str) {
     var
       qstr = [],
       expr,
-      parts = brackets.split(str.replace(RE_DQUOTE, '"'), 1)
+      parts = brackets.split(str.replace(RE_DQUOTE, '"'), 1);
 
     if (parts.length > 2 || parts[0]) {
-      var i, j, list = []
+      var i, j, list = [];
 
       for (i = j = 0; i < parts.length; ++i) {
 
-        expr = parts[i]
+        expr = parts[i];
 
         if (expr && (expr = i & 1
 
@@ -819,16 +664,16 @@ var tmpl = (function () {
                 .replace(/"/g, '\\"') +
               '"'
 
-          )) list[j++] = expr
+          )) { list[j++] = expr; }
 
       }
 
       expr = j < 2 ? list[0]
-           : '[' + list.join(',') + '].join("")'
+           : '[' + list.join(',') + '].join("")';
 
     } else {
 
-      expr = _parseExpr(parts[1], 0, qstr)
+      expr = _parseExpr(parts[1], 0, qstr);
     }
 
     if (qstr[0]) {
@@ -836,7 +681,7 @@ var tmpl = (function () {
         return qstr[pos]
           .replace(/\r/g, '\\r')
           .replace(/\n/g, '\\n')
-      })
+      });
     }
     return expr
   }
@@ -846,7 +691,7 @@ var tmpl = (function () {
       '(': /[()]/g,
       '[': /[[\]]/g,
       '{': /[{}]/g
-    }
+    };
 
   function _parseExpr (expr, asText, qstr) {
 
@@ -855,13 +700,13 @@ var tmpl = (function () {
             return s.length > 2 && !div ? CH_IDEXPR + (qstr.push(s) - 1) + '~' : s
           })
           .replace(/\s+/g, ' ').trim()
-          .replace(/\ ?([[\({},?\.:])\ ?/g, '$1')
+          .replace(/\ ?([[\({},?\.:])\ ?/g, '$1');
 
     if (expr) {
       var
         list = [],
         cnt = 0,
-        match
+        match;
 
       while (expr &&
             (match = expr.match(RE_CSNAME)) &&
@@ -870,21 +715,21 @@ var tmpl = (function () {
         var
           key,
           jsb,
-          re = /,|([[{(])|$/g
+          re = /,|([[{(])|$/g;
 
-        expr = RegExp.rightContext
-        key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\s+/g, ' ') : match[1]
+        expr = RegExp.rightContext;
+        key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\s+/g, ' ') : match[1];
 
-        while (jsb = (match = re.exec(expr))[1]) skipBraces(jsb, re)
+        while (jsb = (match = re.exec(expr))[1]) { skipBraces(jsb, re); }
 
-        jsb  = expr.slice(0, match.index)
-        expr = RegExp.rightContext
+        jsb  = expr.slice(0, match.index);
+        expr = RegExp.rightContext;
 
-        list[cnt++] = _wrapExpr(jsb, 1, key)
+        list[cnt++] = _wrapExpr(jsb, 1, key);
       }
 
       expr = !cnt ? _wrapExpr(expr, asText)
-           : cnt > 1 ? '[' + list.join(',') + '].join(" ").trim()' : list[0]
+           : cnt > 1 ? '[' + list.join(',') + '].join(" ").trim()' : list[0];
     }
     return expr
 
@@ -892,173 +737,607 @@ var tmpl = (function () {
       var
         mm,
         lv = 1,
-        ir = RE_BREND[ch]
+        ir = RE_BREND[ch];
 
-      ir.lastIndex = re.lastIndex
+      ir.lastIndex = re.lastIndex;
       while (mm = ir.exec(expr)) {
-        if (mm[0] === ch) ++lv
-        else if (!--lv) break
+        if (mm[0] === ch) { ++lv; }
+        else if (!--lv) { break }
       }
-      re.lastIndex = lv ? expr.length : ir.lastIndex
+      re.lastIndex = lv ? expr.length : ir.lastIndex;
     }
   }
 
   // istanbul ignore next: not both
   var // eslint-disable-next-line max-len
     JS_CONTEXT = '"in this?this:' + (typeof window !== 'object' ? 'global' : 'window') + ').',
-    JS_VARNAME = /[,{][$\w]+(?=:)|(^ *|[^$\w\.])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\w]))([$_A-Za-z][$\w]*)/g,
-    JS_NOPROPS = /^(?=(\.[$\w]+))\1(?:[^.[(]|$)/
+    JS_VARNAME = /[,{][\$\w]+(?=:)|(^ *|[^$\w\.{])(?!(?:typeof|true|false|null|undefined|in|instanceof|is(?:Finite|NaN)|void|NaN|new|Date|RegExp|Math)(?![$\w]))([$_A-Za-z][$\w]*)/g,
+    JS_NOPROPS = /^(?=(\.[$\w]+))\1(?:[^.[(]|$)/;
 
   function _wrapExpr (expr, asText, key) {
-    var tb
+    var tb;
 
     expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {
       if (mvar) {
-        pos = tb ? 0 : pos + match.length
+        pos = tb ? 0 : pos + match.length;
 
         if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {
-          match = p + '("' + mvar + JS_CONTEXT + mvar
-          if (pos) tb = (s = s[pos]) === '.' || s === '(' || s === '['
+          match = p + '("' + mvar + JS_CONTEXT + mvar;
+          if (pos) { tb = (s = s[pos]) === '.' || s === '(' || s === '['; }
         } else if (pos) {
-          tb = !JS_NOPROPS.test(s.slice(pos))
+          tb = !JS_NOPROPS.test(s.slice(pos));
         }
       }
       return match
-    })
+    });
 
     if (tb) {
-      expr = 'try{return ' + expr + '}catch(e){E(e,this)}'
+      expr = 'try{return ' + expr + '}catch(e){E(e,this)}';
     }
 
     if (key) {
 
       expr = (tb
           ? 'function(){' + expr + '}.call(this)' : '(' + expr + ')'
-        ) + '?"' + key + '":""'
+        ) + '?"' + key + '":""';
 
     } else if (asText) {
 
       expr = 'function(v){' + (tb
           ? expr.replace('return ', 'v=') : 'v=(' + expr + ')'
-        ) + ';return v||v===0?v:""}.call(this)'
+        ) + ';return v||v===0?v:""}.call(this)';
     }
 
     return expr
   }
 
-  _tmpl.version = brackets.version = 'v2.4.1'
+  _tmpl.version = brackets.version = 'v3.0.1';
 
   return _tmpl
 
-})()
-
-/*
-  lib/browser/tag/mkdom.js
+})();
 
-  Includes hacks needed for the Internet Explorer version 9 and below
-  See: http://kangax.github.io/compat-table/es5/#ie8
-       http://codeplanet.io/dropping-ie8/
-*/
-var mkdom = (function _mkdom() {
-  var
-    reHasYield  = /<yield\b/i,
-    reYieldAll  = /<yield\s*(?:\/>|>([\S\s]*?)<\/yield\s*>|>)/ig,
-    reYieldSrc  = /<yield\s+to=['"]([^'">]*)['"]\s*>([\S\s]*?)<\/yield\s*>/ig,
-    reYieldDest = /<yield\s+from=['"]?([-\w]+)['"]?\s*(?:\/>|>([\S\s]*?)<\/yield\s*>)/ig
-  var
-    rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },
-    tblTags = IE_VERSION && IE_VERSION < 10
-      ? SPECIAL_TAGS_REGEX : /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/
+var observable$1 = function(el) {
 
   /**
-   * Creates a DOM element to wrap the given content. Normally an `DIV`, but can be
-   * also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.
-   *
-   * @param   {string} templ  - The template coming from the custom tag definition
-   * @param   {string} [html] - HTML content that comes from the DOM element where you
-   *           will mount the tag, mostly the original tag in the page
-   * @returns {HTMLElement} DOM element with _templ_ merged through `YIELD` with the _html_.
+   * Extend the original object or create a new empty one
+   * @type { Object }
    */
-  function _mkdom(templ, html) {
-    var
-      match   = templ && templ.match(/^\s*<([-\w]+)/),
-      tagName = match && match[1].toLowerCase(),
-      el = mkEl('div', isSVGTag(tagName))
-
-    // replace all the yield tags with the tag inner html
-    templ = replaceYield(templ, html)
-
-    /* istanbul ignore next */
-    if (tblTags.test(tagName))
-      el = specialTags(el, templ, tagName)
-    else
-      setInnerHTML(el, templ)
 
-    el.stub = true
+  el = el || {};
 
-    return el
-  }
+  /**
+   * Private variables
+   */
+  var callbacks = {},
+    slice = Array.prototype.slice;
 
-  /*
-    Creates the root element for table or select child elements:
-    tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup
-  */
-  function specialTags(el, templ, tagName) {
-    var
-      select = tagName[0] === 'o',
-      parent = select ? 'select>' : 'table>'
-
-    // trim() is important here, this ensures we don't have artifacts,
-    // so we can check if we have only one element inside the parent
-    el.innerHTML = '<' + parent + templ.trim() + '</' + parent
-    parent = el.firstChild
-
-    // returns the immediate parent if tr/th/td/col is the only element, if not
-    // returns the whole tree, as this can include additional elements
-    if (select) {
-      parent.selectedIndex = -1  // for IE9, compatible w/current riot behavior
-    } else {
-      // avoids insertion of cointainer inside container (ex: tbody inside tbody)
-      var tname = rootEls[tagName]
-      if (tname && parent.childElementCount === 1) parent = $(tname, parent)
-    }
-    return parent
-  }
+  /**
+   * Public Api
+   */
 
-  /*
-    Replace the yield tag from any tag template with the innerHTML of the
-    original tag in the page
-  */
-  function replaceYield(templ, html) {
-    // do nothing if no yield
-    if (!reHasYield.test(templ)) return templ
-
-    // be careful with #1343 - string on the source having `$1`
-    var src = {}
-
-    html = html && html.replace(reYieldSrc, function (_, ref, text) {
-      src[ref] = src[ref] || text   // preserve first definition
-      return ''
-    }).trim()
-
-    return templ
-      .replace(reYieldDest, function (_, ref, def) {  // yield with from - to attrs
-        return src[ref] || def || ''
-      })
-      .replace(reYieldAll, function (_, def) {        // yield without any "from"
-        return html || def || ''
-      })
+  // extend the el object adding the observable methods
+  Object.defineProperties(el, {
+    /**
+     * Listen to the given `event` ands
+     * execute the `callback` each time an event is triggered.
+     * @param  { String } event - event id
+     * @param  { Function } fn - callback function
+     * @returns { Object } el
+     */
+    on: {
+      value: function(event, fn) {
+        if (typeof fn == 'function')
+          { (callbacks[event] = callbacks[event] || []).push(fn); }
+        return el
+      },
+      enumerable: false,
+      writable: false,
+      configurable: false
+    },
+
+    /**
+     * Removes the given `event` listeners
+     * @param   { String } event - event id
+     * @param   { Function } fn - callback function
+     * @returns { Object } el
+     */
+    off: {
+      value: function(event, fn) {
+        if (event == '*' && !fn) { callbacks = {}; }
+        else {
+          if (fn) {
+            var arr = callbacks[event];
+            for (var i = 0, cb; cb = arr && arr[i]; ++i) {
+              if (cb == fn) { arr.splice(i--, 1); }
+            }
+          } else { delete callbacks[event]; }
+        }
+        return el
+      },
+      enumerable: false,
+      writable: false,
+      configurable: false
+    },
+
+    /**
+     * Listen to the given `event` and
+     * execute the `callback` at most once
+     * @param   { String } event - event id
+     * @param   { Function } fn - callback function
+     * @returns { Object } el
+     */
+    one: {
+      value: function(event, fn) {
+        function on() {
+          el.off(event, on);
+          fn.apply(el, arguments);
+        }
+        return el.on(event, on)
+      },
+      enumerable: false,
+      writable: false,
+      configurable: false
+    },
+
+    /**
+     * Execute all callback functions that listen to
+     * the given `event`
+     * @param   { String } event - event id
+     * @returns { Object } el
+     */
+    trigger: {
+      value: function(event) {
+        var arguments$1 = arguments;
+
+
+        // getting the arguments
+        var arglen = arguments.length - 1,
+          args = new Array(arglen),
+          fns,
+          fn,
+          i;
+
+        for (i = 0; i < arglen; i++) {
+          args[i] = arguments$1[i + 1]; // skip first argument
+        }
+
+        fns = slice.call(callbacks[event] || [], 0);
+
+        for (i = 0; fn = fns[i]; ++i) {
+          fn.apply(el, args);
+        }
+
+        if (callbacks['*'] && event != '*')
+          { el.trigger.apply(el, ['*', event].concat(args)); }
+
+        return el
+      },
+      enumerable: false,
+      writable: false,
+      configurable: false
+    }
+  });
+
+  return el
+
+};
+
+/**
+ * Specialized function for looping an array-like collection with `each={}`
+ * @param   { Array } list - collection of items
+ * @param   {Function} fn - callback function
+ * @returns { Array } the array looped
+ */
+function each(list, fn) {
+  var len = list ? list.length : 0;
+
+  for (var i = 0, el; i < len; ++i) {
+    el = list[i];
+    // return false -> current item was removed by fn during the loop
+    if (fn(el, i) === false)
+      { i--; }
+  }
+  return list
+}
+
+/**
+ * Check whether an array contains an item
+ * @param   { Array } array - target array
+ * @param   { * } item - item to test
+ * @returns { Boolean } -
+ */
+function contains(array, item) {
+  return ~array.indexOf(item)
+}
+
+/**
+ * Convert a string containing dashes to camel case
+ * @param   { String } str - input string
+ * @returns { String } my-string -> myString
+ */
+function toCamel(str) {
+  return str.replace(/-(\w)/g, function (_, c) { return c.toUpperCase(); })
+}
+
+/**
+ * Faster String startsWith alternative
+ * @param   { String } str - source string
+ * @param   { String } value - test string
+ * @returns { Boolean } -
+ */
+function startsWith(str, value) {
+  return str.slice(0, value.length) === value
+}
+
+/**
+ * Helper function to set an immutable property
+ * @param   { Object } el - object where the new property will be set
+ * @param   { String } key - object key where the new property will be stored
+ * @param   { * } value - value of the new property
+ * @param   { Object } options - set the propery overriding the default options
+ * @returns { Object } - the initial object
+ */
+function defineProperty(el, key, value, options) {
+  Object.defineProperty(el, key, extend({
+    value: value,
+    enumerable: false,
+    writable: false,
+    configurable: true
+  }, options));
+  return el
+}
+
+/**
+ * Extend any object with other properties
+ * @param   { Object } src - source object
+ * @returns { Object } the resulting extended object
+ *
+ * var obj = { foo: 'baz' }
+ * extend(obj, {bar: 'bar', foo: 'bar'})
+ * console.log(obj) => {bar: 'bar', foo: 'bar'}
+ *
+ */
+function extend(src) {
+  var obj, args = arguments;
+  for (var i = 1; i < args.length; ++i) {
+    if (obj = args[i]) {
+      for (var key in obj) {
+        // check if this property of the source object could be overridden
+        if (isWritable(src, key))
+          { src[key] = obj[key]; }
+      }
+    }
+  }
+  return src
+}
+
+var misc = Object.freeze({
+	each: each,
+	contains: contains,
+	toCamel: toCamel,
+	startsWith: startsWith,
+	defineProperty: defineProperty,
+	extend: extend
+});
+
+var EVENTS_PREFIX_REGEX = /^on/;
+
+/**
+ * Trigger DOM events
+ * @param   { HTMLElement } dom - dom element target of the event
+ * @param   { Function } handler - user function
+ * @param   { Object } e - event object
+ */
+function handleEvent(dom, handler, e) {
+  var ptag = this._parent,
+    item = this._item;
+
+  if (!item)
+    { while (ptag && !item) {
+      item = ptag._item;
+      ptag = ptag._parent;
+    } }
+
+  // override the event properties
+  if (isWritable(e, 'currentTarget')) { e.currentTarget = dom; }
+  if (isWritable(e, 'target')) { e.target = e.srcElement; }
+  if (isWritable(e, 'which')) { e.which = e.charCode || e.keyCode; }
+
+  e.item = item;
+
+  handler.call(this, e);
+
+  if (!e.preventUpdate) {
+    var p = getImmediateCustomParentTag(this);
+    // fixes #2083
+    if (p.isMounted) { p.update(); }
+  }
+}
+
+/**
+ * Attach an event to a DOM node
+ * @param { String } name - event name
+ * @param { Function } handler - event callback
+ * @param { Object } dom - dom node
+ * @param { Tag } tag - tag instance
+ */
+function setEventHandler(name, handler, dom, tag) {
+  var eventName,
+    cb = handleEvent.bind(tag, dom, handler);
+
+  if (!dom.addEventListener) {
+    dom[name] = cb;
+    return
   }
 
-  return _mkdom
+  // avoid to bind twice the same event
+  dom[name] = null;
 
-})()
+  // normalize event name
+  eventName = name.replace(EVENTS_PREFIX_REGEX, '');
+
+  // cache the callback directly on the DOM node
+  if (!dom._riotEvents) { dom._riotEvents = {}; }
+
+  if (dom._riotEvents[name])
+    { dom.removeEventListener(eventName, dom._riotEvents[name]); }
+
+  dom._riotEvents[name] = cb;
+  dom.addEventListener(eventName, cb, false);
+}
+
+/**
+ * Update dynamically created data-is tags with changing expressions
+ * @param { Object } expr - expression tag and expression info
+ * @param { Tag } parent - parent for tag creation
+ */
+function updateDataIs(expr, parent) {
+  var tagName = tmpl(expr.value, parent),
+    conf;
+
+  if (expr.tag && expr.tagName === tagName) {
+    expr.tag.update();
+    return
+  }
+
+  // sync _parent to accommodate changing tagnames
+  if (expr.tag) {
+    each(expr.attrs, function (a) { return setAttr(expr.tag.root, a.name, a.value); });
+    expr.tag.unmount(true);
+  }
+
+  expr.impl = __TAG_IMPL[tagName];
+  conf = {root: expr.dom, parent: parent, hasImpl: true, tagName: tagName};
+  expr.tag = initChildTag(expr.impl, conf, expr.dom.innerHTML, parent);
+  expr.tagName = tagName;
+  expr.tag.mount();
+
+  // parent is the placeholder tag, not the dynamic tag so clean up
+  parent.on('unmount', function () {
+    var delName = expr.tag.opts.dataIs,
+      tags = expr.tag.parent.tags,
+      _tags = expr.tag._parent.tags;
+    arrayishRemove(tags, delName, expr.tag);
+    arrayishRemove(_tags, delName, expr.tag);
+    expr.tag.unmount();
+  });
+}
+
+/**
+ * Update on single tag expression
+ * @this Tag
+ * @param { Object } expr - expression logic
+ * @returns { undefined }
+ */
+function updateExpression(expr) {
+  var dom = expr.dom,
+    attrName = expr.attr,
+    isToggle = contains([SHOW_DIRECTIVE, HIDE_DIRECTIVE], attrName),
+    value = tmpl(expr.expr, this),
+    isValueAttr = attrName === 'riot-value',
+    isVirtual = expr.root && expr.root.tagName === 'VIRTUAL',
+    parent = dom && (expr.parent || dom.parentNode),
+    old;
+
+  if (expr.bool)
+    { value = value ? attrName : false; }
+  else if (isUndefined(value) || value === null)
+    { value = ''; }
+
+  if (expr._riot_id) { // if it's a tag
+    if (expr.isMounted) {
+      expr.update();
+
+    // if it hasn't been mounted yet, do that now.
+    } else {
+      expr.mount();
+
+      if (isVirtual) {
+        var frag = document.createDocumentFragment();
+        makeVirtual.call(expr, frag);
+        expr.root.parentElement.replaceChild(frag, expr.root);
+      }
+    }
+    return
+  }
+
+  old = expr.value;
+  expr.value = value;
+
+  if (expr.update) {
+    expr.update();
+    return
+  }
+
+  if (expr.isRtag && value) { return updateDataIs(expr, this) }
+  if (old === value) { return }
+  // no change, so nothing more to do
+  if (isValueAttr && dom.value === value) { return }
+
+  // textarea and text nodes have no attribute name
+  if (!attrName) {
+    // about #815 w/o replace: the browser converts the value to a string,
+    // the comparison by "==" does too, but not in the server
+    value += '';
+    // test for parent avoids error with invalid assignment to nodeValue
+    if (parent) {
+      // cache the parent node because somehow it will become null on IE
+      // on the next iteration
+      expr.parent = parent;
+      if (parent.tagName === 'TEXTAREA') {
+        parent.value = value;                    // #1113
+        if (!IE_VERSION) { dom.nodeValue = value; }  // #1625 IE throws here, nodeValue
+      }                                         // will be available on 'updated'
+      else { dom.nodeValue = value; }
+    }
+    return
+  }
+
+  // remove original attribute
+  if (!expr.isAttrRemoved || !value) {
+    remAttr(dom, attrName);
+    expr.isAttrRemoved = true;
+  }
+
+  // event handler
+  if (isFunction(value)) {
+    setEventHandler(attrName, value, dom, this);
+  // show / hide
+  } else if (isToggle) {
+    if (attrName === HIDE_DIRECTIVE) { value = !value; }
+    dom.style.display = value ? '' : 'none';
+  // field value
+  } else if (isValueAttr) {
+    dom.value = value;
+  // <img src="{ expr }">
+  } else if (startsWith(attrName, ATTRS_PREFIX) && attrName !== IS_DIRECTIVE) {
+    attrName = attrName.slice(ATTRS_PREFIX.length);
+    if (CASE_SENSITIVE_ATTRIBUTES[attrName])
+      { attrName = CASE_SENSITIVE_ATTRIBUTES[attrName]; }
+    if (value != null)
+      { setAttr(dom, attrName, value); }
+  } else {
+    // <select> <option selected={true}> </select>
+    if (attrName === 'selected' && parent && /^(SELECT|OPTGROUP)$/.test(parent.tagName) && value) {
+      parent.value = dom.value;
+    } if (expr.bool) {
+      dom[attrName] = value;
+      if (!value) { return }
+    } if (value === 0 || value && typeof value !== T_OBJECT) {
+      setAttr(dom, attrName, value);
+    }
+  }
+}
+
+/**
+ * Update all the expressions in a Tag instance
+ * @this Tag
+ * @param { Array } expressions - expression that must be re evaluated
+ */
+function updateAllExpressions(expressions) {
+  each(expressions, updateExpression.bind(this));
+}
+
+var IfExpr = {
+  init: function init(dom, tag, expr) {
+    remAttr(dom, CONDITIONAL_DIRECTIVE);
+    this.tag = tag;
+    this.expr = expr;
+    this.stub = document.createTextNode('');
+    this.pristine = dom;
+
+    var p = dom.parentNode;
+    p.insertBefore(this.stub, dom);
+    p.removeChild(dom);
+
+    return this
+  },
+  update: function update() {
+    var newValue = tmpl(this.expr, this.tag);
+
+    if (newValue && !this.current) { // insert
+      this.current = this.pristine.cloneNode(true);
+      this.stub.parentNode.insertBefore(this.current, this.stub);
+
+      this.expressions = [];
+      parseExpressions.apply(this.tag, [this.current, this.expressions, true]);
+    } else if (!newValue && this.current) { // remove
+      unmountAll(this.expressions);
+      if (this.current._tag) {
+        this.current._tag.unmount();
+      } else if (this.current.parentNode)
+        { this.current.parentNode.removeChild(this.current); }
+      this.current = null;
+      this.expressions = [];
+    }
+
+    if (newValue) { updateAllExpressions.call(this.tag, this.expressions); }
+  },
+  unmount: function unmount() {
+    unmountAll(this.expressions || []);
+    delete this.pristine;
+    delete this.parentNode;
+    delete this.stub;
+  }
+};
+
+var RefExpr = {
+  init: function init(dom, parent, attrName, attrValue) {
+    this.dom = dom;
+    this.attr = attrName;
+    this.rawValue = attrValue;
+    this.parent = parent;
+    this.hasExp = tmpl.hasExpr(attrValue);
+    this.firstRun = true;
+
+    return this
+  },
+  update: function update() {
+    var value = this.rawValue;
+    if (this.hasExp)
+      { value = tmpl(this.rawValue, this.parent); }
+
+    // if nothing changed, we're done
+    if (!this.firstRun && value === this.value) { return }
+
+    var customParent = this.parent && getImmediateCustomParentTag(this.parent);
+
+    // if the referenced element is a custom tag, then we set the tag itself, rather than DOM
+    var tagOrDom = this.tag || this.dom;
+
+    // the name changed, so we need to remove it from the old key (if present)
+    if (!isBlank(this.value) && customParent)
+      { arrayishRemove(customParent.refs, this.value, tagOrDom); }
+
+    if (isBlank(value)) {
+      // if the value is blank, we remove it
+      remAttr(this.dom, this.attr);
+    } else {
+      // add it to the refs of parent tag (this behavior was changed >=3.0)
+      if (customParent) { arrayishAdd(customParent.refs, value, tagOrDom); }
+      // set the actual DOM attr
+      setAttr(this.dom, this.attr, value);
+    }
+    this.value = value;
+    this.firstRun = false;
+  },
+  unmount: function unmount() {
+    var tagOrDom = this.tag || this.dom;
+    var customParent = this.parent && getImmediateCustomParentTag(this.parent);
+    if (!isBlank(this.value) && customParent)
+      { arrayishRemove(customParent.refs, this.value, tagOrDom); }
+    delete this.dom;
+    delete this.parent;
+  }
+};
 
 /**
  * Convert the item looped into an object used to extend the child tag properties
  * @param   { Object } expr - object containing the keys used to extend the children tags
  * @param   { * } key - value to assign to the new object returned
  * @param   { * } val - value containing the position of the item in the array
+ * @param   { Object } base - prototype object for the new item
  * @returns { Object } - new object containing the values of the original item
  *
  * The variables 'key' and 'val' are arbitrary.
@@ -1066,10 +1345,10 @@ var mkdom = (function _mkdom() {
  * and on the expression used on the each tag
  *
  */
-function mkitem(expr, key, val) {
-  var item = {}
-  item[expr.key] = key
-  if (expr.pos) item[expr.pos] = val
+function mkitem(expr, key, val, base) {
+  var item = base ? Object.create(base) : {};
+  item[expr.key] = key;
+  if (expr.pos) { item[expr.pos] = val; }
   return item
 }
 
@@ -1077,973 +1356,927 @@ function mkitem(expr, key, val) {
  * Unmount the redundant tags
  * @param   { Array } items - array containing the current items to loop
  * @param   { Array } tags - array containing all the children tags
+ * @param   { String } tagName - key used to identify the type of tag
  */
-function unmountRedundant(items, tags) {
-
+function unmountRedundant(items, tags, tagName) {
   var i = tags.length,
     j = items.length,
-    t
+    t;
 
   while (i > j) {
-    t = tags[--i]
-    tags.splice(i, 1)
-    t.unmount()
+    t = tags[--i];
+    tags.splice(i, 1);
+    t.unmount();
+    arrayishRemove(t.parent, tagName, t, true);
   }
 }
 
 /**
  * Move the nested custom tags in non custom loop tags
- * @param   { Object } child - non custom loop tag
+ * @this Tag
  * @param   { Number } i - current position of the loop tag
  */
-function moveNestedTags(child, i) {
-  Object.keys(child.tags).forEach(function(tagName) {
-    var tag = child.tags[tagName]
+function moveNestedTags(i) {
+  var this$1 = this;
+
+  each(Object.keys(this.tags), function (tagName) {
+    var tag = this$1.tags[tagName];
     if (isArray(tag))
-      each(tag, function (t) {
-        moveChildTag(t, tagName, i)
-      })
+      { each(tag, function (t) {
+        moveChildTag.apply(t, [tagName, i]);
+      }); }
     else
-      moveChildTag(tag, tagName, i)
-  })
+      { moveChildTag.apply(tag, [tagName, i]); }
+  });
 }
 
 /**
- * Adds the elements for a virtual tag
- * @param { Tag } tag - the tag whose root's children will be inserted or appended
- * @param { Node } src - the node that will do the inserting or appending
- * @param { Tag } target - only if inserting, insert before this tag's first child
+ * Move a child tag
+ * @this Tag
+ * @param   { HTMLElement } root - dom node containing all the loop children
+ * @param   { Tag } nextTag - instance of the next tag preceding the one we want to move
+ * @param   { Boolean } isVirtual - is it a virtual tag?
  */
-function addVirtual(tag, src, target) {
-  var el = tag._root, sib
-  tag._virts = []
-  while (el) {
-    sib = el.nextSibling
-    if (target)
-      src.insertBefore(el, target._root)
-    else
-      src.appendChild(el)
-
-    tag._virts.push(el) // hold for unmounting
-    el = sib
-  }
+function move(root, nextTag, isVirtual) {
+  if (isVirtual)
+    { moveVirtual.apply(this, [root, nextTag]); }
+  else
+    { safeInsert(root, this.root, nextTag.root); }
 }
 
 /**
- * Move virtual tag and all child nodes
- * @param { Tag } tag - first child reference used to start move
- * @param { Node } src  - the node that will do the inserting
- * @param { Tag } target - insert before this tag's first child
- * @param { Number } len - how many child nodes to move
- */
-function moveVirtual(tag, src, target, len) {
-  var el = tag._root, sib, i = 0
-  for (; i < len; i++) {
-    sib = el.nextSibling
-    src.insertBefore(el, target._root)
-    el = sib
-  }
+ * Insert and mount a child tag
+ * @this Tag
+ * @param   { HTMLElement } root - dom node containing all the loop children
+ * @param   { Tag } nextTag - instance of the next tag preceding the one we want to insert
+ * @param   { Boolean } isVirtual - is it a virtual tag?
+ */
+function insert(root, nextTag, isVirtual) {
+  if (isVirtual)
+    { makeVirtual.apply(this, [root, nextTag]); }
+  else
+    { safeInsert(root, this.root, nextTag.root); }
 }
 
+/**
+ * Append a new tag into the DOM
+ * @this Tag
+ * @param   { HTMLElement } root - dom node containing all the loop children
+ * @param   { Boolean } isVirtual - is it a virtual tag?
+ */
+function append(root, isVirtual) {
+  if (isVirtual)
+    { makeVirtual.call(this, root); }
+  else
+    { root.appendChild(this.root); }
+}
 
 /**
  * Manage tags having the 'each'
- * @param   { Object } dom - DOM node we need to loop
+ * @param   { HTMLElement } dom - DOM node we need to loop
  * @param   { Tag } parent - parent tag instance where the dom node is contained
  * @param   { String } expr - string contained in the 'each' attribute
+ * @returns { Object } expression object for this each loop
  */
 function _each(dom, parent, expr) {
 
   // remove the each property from the original tag
-  remAttr(dom, 'each')
+  remAttr(dom, LOOP_DIRECTIVE);
 
-  var mustReorder = typeof getAttr(dom, 'no-reorder') !== T_STRING || remAttr(dom, 'no-reorder'),
+  var mustReorder = typeof getAttr(dom, LOOP_NO_REORDER_DIRECTIVE) !== T_STRING || remAttr(dom, LOOP_NO_REORDER_DIRECTIVE),
     tagName = getTagName(dom),
-    impl = __tagImpl[tagName] || { tmpl: getOuterHTML(dom) },
-    useRoot = SPECIAL_TAGS_REGEX.test(tagName),
-    root = dom.parentNode,
-    ref = document.createTextNode(''),
+    impl = __TAG_IMPL[tagName] || { tmpl: getOuterHTML(dom) },
+    useRoot = RE_SPECIAL_TAGS.test(tagName),
+    parentNode = dom.parentNode,
+    ref = createDOMPlaceholder(),
     child = getTag(dom),
-    isOption = tagName.toLowerCase() === 'option', // the option tags must be treated differently
+    ifExpr = getAttr(dom, CONDITIONAL_DIRECTIVE),
     tags = [],
     oldItems = [],
     hasKeys,
-    isVirtual = dom.tagName == 'VIRTUAL'
+    isLoop = true,
+    isAnonymous = !__TAG_IMPL[tagName],
+    isVirtual = dom.tagName === 'VIRTUAL';
 
   // parse the each expression
-  expr = tmpl.loopKeys(expr)
+  expr = tmpl.loopKeys(expr);
+  expr.isLoop = true;
 
-  // insert a marked where the loop tags will be injected
-  root.insertBefore(ref, dom)
+  if (ifExpr) { remAttr(dom, CONDITIONAL_DIRECTIVE); }
 
-  // clean template code
-  parent.one('before-mount', function () {
+  // insert a marked where the loop tags will be injected
+  parentNode.insertBefore(ref, dom);
+  parentNode.removeChild(dom);
 
-    // remove the original DOM node
-    dom.parentNode.removeChild(dom)
-    if (root.stub) root = parent.root
+  expr.update = function updateEach() {
 
-  }).on('update', function () {
     // get the new items collection
     var items = tmpl(expr.val, parent),
-      // create a fragment to hold the new DOM nodes to inject in the parent tag
-      frag = document.createDocumentFragment()
+      frag = createFrag(),
+      isObject$$1 = !isArray(items),
+      root = ref.parentNode;
 
     // object loop. any changes cause full redraw
-    if (!isArray(items)) {
-      hasKeys = items || false
+    if (isObject$$1) {
+      hasKeys = items || false;
       items = hasKeys ?
         Object.keys(items).map(function (key) {
-          return mkitem(expr, key, items[key])
-        }) : []
+          return mkitem(expr, items[key], key)
+        }) : [];
+    } else {
+      hasKeys = false;
     }
 
-    // loop all the new items
-    var i = 0,
-      itemsLength = items.length
+    if (ifExpr) {
+      items = items.filter(function(item, i) {
+        if (expr.key && !isObject$$1)
+          { return !!tmpl(ifExpr, mkitem(expr, item, i, parent)) }
 
-    for (; i < itemsLength; i++) {
+        return !!tmpl(ifExpr, extend(Object.create(parent), item))
+      });
+    }
+
+    // loop all the new items
+    each(items, function(item, i) {
       // reorder only if the items are objects
       var
-        item = items[i],
-        _mustReorder = mustReorder && typeof item == T_OBJECT && !hasKeys,
+        doReorder = mustReorder && typeof item === T_OBJECT && !hasKeys,
         oldPos = oldItems.indexOf(item),
-        pos = ~oldPos && _mustReorder ? oldPos : i,
+        isNew = !~oldPos,
+        mustAppend = i <= tags.length,
+        pos = !isNew && doReorder ? oldPos : i,
         // does a tag exist in this position?
-        tag = tags[pos]
+        tag = tags[pos];
 
-      item = !hasKeys && expr.key ? mkitem(expr, item, i) : item
+      item = !hasKeys && expr.key ? mkitem(expr, item, i) : item;
 
       // new tag
       if (
-        !_mustReorder && !tag // with no-reorder we just update the old tags
+        doReorder && isNew // by default we always try to reorder the DOM elements
         ||
-        _mustReorder && !~oldPos || !tag // by default we always try to reorder the DOM elements
+        !doReorder && !tag // with no-reorder we just update the old tags
       ) {
-
-        tag = new Tag(impl, {
+        tag = new Tag$1(impl, {
           parent: parent,
-          isLoop: true,
-          hasImpl: !!__tagImpl[tagName],
+          isLoop: isLoop,
+          isAnonymous: isAnonymous,
           root: useRoot ? root : dom.cloneNode(),
           item: item
-        }, dom.innerHTML)
+        }, dom.innerHTML);
 
-        tag.mount()
+        // mount the tag
+        tag.mount();
 
-        if (isVirtual) tag._root = tag.root.firstChild // save reference for further moves or inserts
-        // this tag must be appended
-        if (i == tags.length || !tags[i]) { // fix 1581
-          if (isVirtual)
-            addVirtual(tag, frag)
-          else frag.appendChild(tag.root)
-        }
-        // this tag must be insert
-        else {
-          if (isVirtual)
-            addVirtual(tag, root, tags[i])
-          else root.insertBefore(tag.root, tags[i].root) // #1374 some browsers reset selected here
-          oldItems.splice(i, 0, item)
-        }
+        if (mustAppend)
+          { append.apply(tag, [frag || root, isVirtual]); }
+        else
+          { insert.apply(tag, [root, tags[i], isVirtual]); }
 
-        tags.splice(i, 0, tag)
-        pos = i // handled here so no move
-      } else tag.update(item, true)
+        if (!mustAppend) { oldItems.splice(i, 0, item); }
+        tags.splice(i, 0, tag);
+        if (child) { arrayishAdd(parent.tags, tagName, tag, true); }
+        pos = i; // handled here so no move
+      } else { tag.update(item); }
 
       // reorder the tag if it's not located in its previous position
-      if (
-        pos !== i && _mustReorder &&
-        tags[i] // fix 1581 unable to reproduce it in a test!
-      ) {
-        // update the DOM
-        if (isVirtual)
-          moveVirtual(tag, root, tags[i], dom.childNodes.length)
-        else if (tags[i].root.parentNode) root.insertBefore(tag.root, tags[i].root)
+      if (pos !== i && doReorder) {
+        // #closes 2040
+        if (contains(items, oldItems[i])) {
+          move.apply(tag, [root, tags[i], isVirtual]);
+        }
         // update the position attribute if it exists
-        if (expr.pos)
-          tag[expr.pos] = i
+        if (expr.pos) { tag[expr.pos] = i; }
         // move the old tag instance
-        tags.splice(i, 0, tags.splice(pos, 1)[0])
+        tags.splice(i, 0, tags.splice(pos, 1)[0]);
         // move the old item
-        oldItems.splice(i, 0, oldItems.splice(pos, 1)[0])
+        oldItems.splice(i, 0, oldItems.splice(pos, 1)[0]);
         // if the loop tags are not custom
         // we need to move all their custom tags into the right position
-        if (!child && tag.tags) moveNestedTags(tag, i)
+        if (!child && tag.tags) { moveNestedTags.call(tag, i); }
       }
 
       // cache the original item to use it in the events bound to this node
       // and its children
-      tag._item = item
+      tag._item = item;
       // cache the real parent tag internally
-      defineProperty(tag, '_parent', parent)
-    }
+      defineProperty(tag, '_parent', parent);
+    });
 
     // remove the redundant tags
-    unmountRedundant(items, tags)
-
-    // insert the new nodes
-    root.insertBefore(frag, ref)
-    if (isOption) {
-
-      // #1374 FireFox bug in <option selected={expression}>
-      if (FIREFOX && !root.multiple) {
-        for (var n = 0; n < root.length; n++) {
-          if (root[n].__riot1374) {
-            root.selectedIndex = n  // clear other options
-            delete root[n].__riot1374
-            break
-          }
-        }
+    unmountRedundant(items, tags, tagName);
+
+    // clone the items array
+    oldItems = items.slice();
+
+    root.insertBefore(frag, ref);
+  };
+
+  expr.unmount = function() {
+    each(tags, function(t) { t.unmount(); });
+  };
+
+  return expr
+}
+
+/**
+ * Walk the tag DOM to detect the expressions to evaluate
+ * @this Tag
+ * @param   { HTMLElement } root - root tag where we will start digging the expressions
+ * @param   { Array } expressions - empty array where the expressions will be added
+ * @param   { Boolean } mustIncludeRoot - flag to decide whether the root must be parsed as well
+ * @returns { Object } an object containing the root noode and the dom tree
+ */
+function parseExpressions(root, expressions, mustIncludeRoot) {
+  var this$1 = this;
+
+  var tree = {parent: {children: expressions}};
+
+  walkNodes(root, function (dom, ctx) {
+    var type = dom.nodeType, parent = ctx.parent, attr, expr, tagImpl;
+    if (!mustIncludeRoot && dom === root) { return {parent: parent} }
+
+    // text node
+    if (type === 3 && dom.parentNode.tagName !== 'STYLE' && tmpl.hasExpr(dom.nodeValue))
+      { parent.children.push({dom: dom, expr: dom.nodeValue}); }
+
+    if (type !== 1) { return ctx } // not an element
+
+    // loop. each does it's own thing (for now)
+    if (attr = getAttr(dom, LOOP_DIRECTIVE)) {
+      parent.children.push(_each(dom, this$1, attr));
+      return false
+    }
+
+    // if-attrs become the new parent. Any following expressions (either on the current
+    // element, or below it) become children of this expression.
+    if (attr = getAttr(dom, CONDITIONAL_DIRECTIVE)) {
+      parent.children.push(Object.create(IfExpr).init(dom, this$1, attr));
+      return false
+    }
+
+    if (expr = getAttr(dom, IS_DIRECTIVE)) {
+      if (tmpl.hasExpr(expr)) {
+        parent.children.push({isRtag: true, expr: expr, dom: dom, attrs: [].slice.call(dom.attributes)});
+        return false
       }
     }
 
-    // set the 'tags' property of the parent tag
-    // if child is 'undefined' it means that we don't need to set this property
-    // for example:
-    // we don't need store the `myTag.tags['div']` property if we are looping a div tag
-    // but we need to track the `myTag.tags['child']` property looping a custom child node named `child`
-    if (child) parent.tags[tagName] = tags
+    // if this is a tag, stop traversing here.
+    // we ignore the root, since parseExpressions is called while we're mounting that root
+    tagImpl = getTag(dom);
+    if (tagImpl && (dom !== root || mustIncludeRoot)) {
+      var conf = {root: dom, parent: this$1, hasImpl: true};
+      parent.children.push(initChildTag(tagImpl, conf, dom.innerHTML, this$1));
+      return false
+    }
 
-    // clone the items array
-    oldItems = items.slice()
+    // attribute expressions
+    parseAttributes.apply(this$1, [dom, dom.attributes, function(attr, expr) {
+      if (!expr) { return }
+      parent.children.push(expr);
+    }]);
 
-  })
+    // whatever the parent is, all child elements get the same parent.
+    // If this element had an if-attr, that's the parent for all child elements
+    return {parent: parent}
+  }, tree);
 
+  return { tree: tree, root: root }
 }
+
 /**
- * Object that will be used to inject and manage the css of every tag instance
+ * Calls `fn` for every attribute on an element. If that attr has an expression,
+ * it is also passed to fn.
+ * @this Tag
+ * @param   { HTMLElement } dom - dom node to parse
+ * @param   { Array } attrs - array of attributes
+ * @param   { Function } fn - callback to exec on any iteration
+ */
+function parseAttributes(dom, attrs, fn) {
+  var this$1 = this;
+
+  each(attrs, function (attr) {
+    var name = attr.name, bool = isBoolAttr(name), expr;
+
+    if (contains(REF_DIRECTIVES, name)) {
+      expr =  Object.create(RefExpr).init(dom, this$1, name, attr.value);
+    } else if (tmpl.hasExpr(attr.value)) {
+      expr = {dom: dom, expr: attr.value, attr: attr.name, bool: bool};
+    }
+
+    fn(attr, expr);
+  });
+}
+
+/*
+  Includes hacks needed for the Internet Explorer version 9 and below
+  See: http://kangax.github.io/compat-table/es5/#ie8
+       http://codeplanet.io/dropping-ie8/
+*/
+
+var reHasYield  = /<yield\b/i;
+var reYieldAll  = /<yield\s*(?:\/>|>([\S\s]*?)<\/yield\s*>|>)/ig;
+var reYieldSrc  = /<yield\s+to=['"]([^'">]*)['"]\s*>([\S\s]*?)<\/yield\s*>/ig;
+var reYieldDest = /<yield\s+from=['"]?([-\w]+)['"]?\s*(?:\/>|>([\S\s]*?)<\/yield\s*>)/ig;
+var rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' };
+var tblTags = IE_VERSION && IE_VERSION < 10 ? RE_SPECIAL_TAGS : RE_SPECIAL_TAGS_NO_OPTION;
+var GENERIC = 'div';
+
+
+/*
+  Creates the root element for table or select child elements:
+  tr/th/td/thead/tfoot/tbody/caption/col/colgroup/option/optgroup
+*/
+function specialTags(el, tmpl, tagName) {
+
+  var
+    select = tagName[0] === 'o',
+    parent = select ? 'select>' : 'table>';
+
+  // trim() is important here, this ensures we don't have artifacts,
+  // so we can check if we have only one element inside the parent
+  el.innerHTML = '<' + parent + tmpl.trim() + '</' + parent;
+  parent = el.firstChild;
+
+  // returns the immediate parent if tr/th/td/col is the only element, if not
+  // returns the whole tree, as this can include additional elements
+  if (select) {
+    parent.selectedIndex = -1;  // for IE9, compatible w/current riot behavior
+  } else {
+    // avoids insertion of cointainer inside container (ex: tbody inside tbody)
+    var tname = rootEls[tagName];
+    if (tname && parent.childElementCount === 1) { parent = $(tname, parent); }
+  }
+  return parent
+}
+
+/*
+  Replace the yield tag from any tag template with the innerHTML of the
+  original tag in the page
+*/
+function replaceYield(tmpl, html) {
+  // do nothing if no yield
+  if (!reHasYield.test(tmpl)) { return tmpl }
+
+  // be careful with #1343 - string on the source having `$1`
+  var src = {};
+
+  html = html && html.replace(reYieldSrc, function (_, ref, text) {
+    src[ref] = src[ref] || text;   // preserve first definition
+    return ''
+  }).trim();
+
+  return tmpl
+    .replace(reYieldDest, function (_, ref, def) {  // yield with from - to attrs
+      return src[ref] || def || ''
+    })
+    .replace(reYieldAll, function (_, def) {        // yield without any "from"
+      return html || def || ''
+    })
+}
+
+/**
+ * Creates a DOM element to wrap the given content. Normally an `DIV`, but can be
+ * also a `TABLE`, `SELECT`, `TBODY`, `TR`, or `COLGROUP` element.
+ *
+ * @param   { String } tmpl  - The template coming from the custom tag definition
+ * @param   { String } html - HTML content that comes from the DOM element where you
+ *           will mount the tag, mostly the original tag in the page
+ * @param   { Boolean } checkSvg - flag needed to know if we need to force the svg rendering in case of loop nodes
+ * @returns { HTMLElement } DOM element with _tmpl_ merged through `YIELD` with the _html_.
+ */
+function mkdom(tmpl, html, checkSvg) {
+  var match   = tmpl && tmpl.match(/^\s*<([-\w]+)/),
+    tagName = match && match[1].toLowerCase(),
+    el = mkEl(GENERIC, checkSvg && isSVGTag(tagName));
+
+  // replace all the yield tags with the tag inner html
+  tmpl = replaceYield(tmpl, html);
+
+  /* istanbul ignore next */
+  if (tblTags.test(tagName))
+    { el = specialTags(el, tmpl, tagName); }
+  else
+    { setInnerHTML(el, tmpl); }
+
+  el.stub = true;
+
+  return el
+}
+
+/**
+ * Another way to create a riot tag a bit more es6 friendly
+ * @param { HTMLElement } el - tag DOM selector or DOM node/s
+ * @param { Object } opts - tag logic
+ * @returns { Tag } new riot tag instance
+ */
+function Tag$2(el, opts) {
+  // get the tag properties from the class constructor
+  var ref = this;
+  var name = ref.name;
+  var tmpl = ref.tmpl;
+  var css = ref.css;
+  var attrs = ref.attrs;
+  var onCreate = ref.onCreate;
+  // register a new tag and cache the class prototype
+  if (!__TAG_IMPL[name]) {
+    tag$1(name, tmpl, css, attrs, onCreate);
+    // cache the class constructor
+    __TAG_IMPL[name].class = this.constructor;
+  }
+
+  // mount the tag using the class instance
+  mountTo(el, name, opts, this);
+  // inject the component css
+  if (css) { styleManager.inject(); }
+
+  return this
+}
+
+/**
+ * Create a new riot tag implementation
+ * @param   { String }   name - name/id of the new riot tag
+ * @param   { String }   tmpl - tag template
+ * @param   { String }   css - custom tag css
+ * @param   { String }   attrs - root tag attributes
+ * @param   { Function } fn - user function
+ * @returns { String } name/id of the tag just created
+ */
+function tag$1(name, tmpl, css, attrs, fn) {
+  if (isFunction(attrs)) {
+    fn = attrs;
+
+    if (/^[\w\-]+\s?=/.test(css)) {
+      attrs = css;
+      css = '';
+    } else
+      { attrs = ''; }
+  }
+
+  if (css) {
+    if (isFunction(css))
+      { fn = css; }
+    else
+      { styleManager.add(css); }
+  }
+
+  name = name.toLowerCase();
+  __TAG_IMPL[name] = { name: name, tmpl: tmpl, attrs: attrs, fn: fn };
+
+  return name
+}
+
+/**
+ * Create a new riot tag implementation (for use by the compiler)
+ * @param   { String }   name - name/id of the new riot tag
+ * @param   { String }   tmpl - tag template
+ * @param   { String }   css - custom tag css
+ * @param   { String }   attrs - root tag attributes
+ * @param   { Function } fn - user function
+ * @returns { String } name/id of the tag just created
+ */
+function tag2$1(name, tmpl, css, attrs, fn) {
+  if (css)
+    { styleManager.add(css, name); }
+
+  var exists = !!__TAG_IMPL[name];
+  __TAG_IMPL[name] = { name: name, tmpl: tmpl, attrs: attrs, fn: fn };
+
+  if (exists && util.hotReloader)
+    { util.hotReloader(name); }
+
+  return name
+}
+
+/**
+ * Mount a tag using a specific tag implementation
+ * @param   { * } selector - tag DOM selector or DOM node/s
+ * @param   { String } tagName - tag implementation name
+ * @param   { Object } opts - tag logic
+ * @returns { Array } new tags instances
  */
-var styleManager = (function(_riot) {
-
-  if (!window) return { // skip injection on the server
-    add: function () {},
-    inject: function () {}
-  }
+function mount$1(selector, tagName, opts) {
+  var tags = [];
 
-  var styleNode = (function () {
-    // create a new style element with the correct type
-    var newNode = mkEl('style')
-    setAttr(newNode, 'type', 'text/css')
+  function pushTagsTo(root) {
+    if (root.tagName) {
+      var riotTag = getAttr(root, IS_DIRECTIVE);
 
-    // replace any user node or insert the new one into the head
-    var userNode = $('style[type=riot]')
-    if (userNode) {
-      if (userNode.id) newNode.id = userNode.id
-      userNode.parentNode.replaceChild(newNode, userNode)
-    }
-    else document.getElementsByTagName('head')[0].appendChild(newNode)
+      // have tagName? force riot-tag to be the same
+      if (tagName && riotTag !== tagName) {
+        riotTag = tagName;
+        setAttr(root, IS_DIRECTIVE, tagName);
+      }
 
-    return newNode
-  })()
+      var tag$$1 = mountTo(root, riotTag || root.tagName.toLowerCase(), opts);
 
-  // Create cache and shortcut to the correct property
-  var cssTextProp = styleNode.styleSheet,
-    stylesToInject = ''
+      if (tag$$1)
+        { tags.push(tag$$1); }
+    } else if (root.length)
+      { each(root, pushTagsTo); } // assume nodeList
+  }
 
-  // Expose the style node in a non-modificable property
-  Object.defineProperty(_riot, 'styleNode', {
-    value: styleNode,
-    writable: true
-  })
+  // inject styles into DOM
+  styleManager.inject();
 
-  /**
-   * Public api
-   */
-  return {
-    /**
-     * Save a tag style to be later injected into DOM
-     * @param   { String } css [description]
-     */
-    add: function(css) {
-      stylesToInject += css
-    },
-    /**
-     * Inject all previously saved tag styles into DOM
-     * innerHTML seems slow: http://jsperf.com/riot-insert-style
-     */
-    inject: function() {
-      if (stylesToInject) {
-        if (cssTextProp) cssTextProp.cssText += stylesToInject
-        else styleNode.innerHTML += stylesToInject
-        stylesToInject = ''
-      }
-    }
+  if (isObject(tagName)) {
+    opts = tagName;
+    tagName = 0;
   }
 
-})(riot)
+  var elem;
+  var allTags;
 
+  // crawl the DOM to find the tag
+  if (isString(selector)) {
+    selector = selector === '*' ?
+      // select all registered tags
+      // & tags found with the riot-tag attribute set
+      allTags = selectTags() :
+      // or just the ones named like the selector
+      selector + selectTags(selector.split(/, */));
 
-function parseNamedElements(root, tag, childTags, forceParsingNamed) {
-
-  walk(root, function(dom) {
-    if (dom.nodeType == 1) {
-      dom.isLoop = dom.isLoop ||
-                  (dom.parentNode && dom.parentNode.isLoop || getAttr(dom, 'each'))
-                    ? 1 : 0
+    // make sure to pass always a selector
+    // to the querySelectorAll function
+    elem = selector ? $$(selector) : [];
+  }
+  else
+    // probably you have passed already a tag or a NodeList
+    { elem = selector; }
 
-      // custom child tag
-      if (childTags) {
-        var child = getTag(dom)
+  // select all the registered and mount them inside their root elements
+  if (tagName === '*') {
+    // get all custom tags
+    tagName = allTags || selectTags();
+    // if the root els it's just a single tag
+    if (elem.tagName)
+      { elem = $$(tagName, elem); }
+    else {
+      // select all the children for all the different root elements
+      var nodeList = [];
 
-        if (child && !dom.isLoop)
-          childTags.push(initChildTag(child, {root: dom, parent: tag}, dom.innerHTML, tag))
-      }
+      each(elem, function (_el) { return nodeList.push($$(tagName, _el)); });
 
-      if (!dom.isLoop || forceParsingNamed)
-        setNamed(dom, tag, [])
+      elem = nodeList;
     }
+    // get rid of the tagName
+    tagName = 0;
+  }
 
-  })
+  pushTagsTo(elem);
 
+  return tags
 }
 
-function parseExpressions(root, tag, expressions) {
+// Create a mixin that could be globally shared across all the tags
+var mixins = {};
+var globals = mixins[GLOBAL_MIXIN] = {};
+var _id = 0;
 
-  function addExpr(dom, val, extra) {
-    if (tmpl.hasExpr(val)) {
-      expressions.push(extend({ dom: dom, expr: val }, extra))
-    }
+/**
+ * Create/Return a mixin by its name
+ * @param   { String }  name - mixin name (global mixin if object)
+ * @param   { Object }  mix - mixin logic
+ * @param   { Boolean } g - is global?
+ * @returns { Object }  the mixin logic
+ */
+function mixin$1(name, mix, g) {
+  // Unnamed global
+  if (isObject(name)) {
+    mixin$1(("__unnamed_" + (_id++)), name, true);
+    return
   }
 
-  walk(root, function(dom) {
-    var type = dom.nodeType,
-      attr
+  var store = g ? globals : mixins;
 
-    // text node
-    if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)
-    if (type != 1) return
+  // Getter
+  if (!mix) {
+    if (isUndefined(store[name]))
+      { throw new Error('Unregistered mixin: ' + name) }
 
-    /* element */
+    return store[name]
+  }
 
-    // loop
-    attr = getAttr(dom, 'each')
+  // Setter
+  store[name] = isFunction(mix) ?
+    extend(mix.prototype, store[name] || {}) && mix :
+    extend(store[name] || {}, mix);
+}
 
-    if (attr) { _each(dom, tag, attr); return false }
+/**
+ * Update all the tags instances created
+ * @returns { Array } all the tags instances
+ */
+function update$1() {
+  return each(__TAGS_CACHE, function (tag$$1) { return tag$$1.update(); })
+}
 
-    // attribute expressions
-    each(dom.attributes, function(attr) {
-      var name = attr.name,
-        bool = name.split('__')[1]
+function unregister$1(name) {
+  delete __TAG_IMPL[name];
+}
 
-      addExpr(dom, attr.value, { attr: bool || name, bool: bool })
-      if (bool) { remAttr(dom, name); return false }
+// counter to give a unique id to all the Tag instances
+var __uid = 0;
 
-    })
+/**
+ * We need to update opts for this tag. That requires updating the expressions
+ * in any attributes on the tag, and then copying the result onto opts.
+ * @this Tag
+ * @param   {Boolean} isLoop - is it a loop tag?
+ * @param   { Tag }  parent - parent tag node
+ * @param   { Boolean }  isAnonymous - is it a tag without any impl? (a tag not registered)
+ * @param   { Object }  opts - tag options
+ * @param   { Array }  instAttrs - tag attributes array
+ */
+function updateOpts(isLoop, parent, isAnonymous, opts, instAttrs) {
+  // isAnonymous `each` tags treat `dom` and `root` differently. In this case
+  // (and only this case) we don't need to do updateOpts, because the regular parse
+  // will update those attrs. Plus, isAnonymous tags don't need opts anyway
+  if (isLoop && isAnonymous) { return }
 
-    // skip custom tags
-    if (getTag(dom)) return false
+  var ctx = !isAnonymous && isLoop ? this : parent || this;
+  each(instAttrs, function (attr) {
+    if (attr.expr) { updateAllExpressions.call(ctx, [attr.expr]); }
+    opts[toCamel(attr.name)] = attr.expr ? attr.expr.value : attr.value;
+  });
+}
 
-  })
 
-}
-function Tag(impl, conf, innerHTML) {
+/**
+ * Tag class
+ * @constructor
+ * @param { Object } impl - it contains the tag template, and logic
+ * @param { Object } conf - tag options
+ * @param { String } innerHTML - html that eventually we need to inject in the tag
+ */
+function Tag$1(impl, conf, innerHTML) {
 
-  var self = riot.observable(this),
-    opts = inherit(conf.opts) || {},
+  var opts = extend({}, conf.opts),
     parent = conf.parent,
     isLoop = conf.isLoop,
-    hasImpl = conf.hasImpl,
+    isAnonymous = conf.isAnonymous,
     item = cleanUpData(conf.item),
+    instAttrs = [], // All attributes on the Tag when it's first parsed
+    implAttrs = [], // expressions on this type of Tag
     expressions = [],
-    childTags = [],
     root = conf.root,
-    tagName = root.tagName.toLowerCase(),
-    attr = {},
+    tagName = conf.tagName || getTagName(root),
+    isVirtual = tagName === 'virtual',
     propsInSyncWithParent = [],
-    dom
+    dom;
 
-  // only call unmount if we have a valid __tagImpl (has name property)
-  if (impl.name && root._tag) root._tag.unmount(true)
+  // make this tag observable
+  observable$1(this);
+  // only call unmount if we have a valid __TAG_IMPL (has name property)
+  if (impl.name && root._tag) { root._tag.unmount(true); }
 
   // not yet mounted
-  this.isMounted = false
-  root.isLoop = isLoop
-
-  // keep a reference to the tag just created
-  // so we will be able to mount this tag multiple times
-  root._tag = this
+  this.isMounted = false;
+  root.isLoop = isLoop;
+
+  defineProperty(this, '_internal', {
+    isAnonymous: isAnonymous,
+    instAttrs: instAttrs,
+    innerHTML: innerHTML,
+    // these vars will be needed only for the virtual tags
+    virts: [],
+    tail: null,
+    head: null
+  });
 
   // create a unique id to this tag
   // it could be handy to use it also to improve the virtual dom rendering speed
-  defineProperty(this, '_riot_id', ++__uid) // base 1 allows test !t._riot_id
-
-  extend(this, { parent: parent, root: root, opts: opts}, item)
-  // protect the "tags" property from being overridden
-  defineProperty(this, 'tags', {})
-
-  // grab attributes
-  each(root.attributes, function(el) {
-    var val = el.value
-    // remember attributes with expressions only
-    if (tmpl.hasExpr(val)) attr[el.name] = val
-  })
-
-  dom = mkdom(impl.tmpl, innerHTML)
-
-  // options
-  function updateOpts() {
-    var ctx = hasImpl && isLoop ? self : parent || self
-
-    // update opts from current DOM attributes
-    each(root.attributes, function(el) {
-      var val = el.value
-      opts[toCamel(el.name)] = tmpl.hasExpr(val) ? tmpl(val, ctx) : val
-    })
-    // recover those with expressions
-    each(Object.keys(attr), function(name) {
-      opts[toCamel(name)] = tmpl(attr[name], ctx)
-    })
-  }
-
-  function normalizeData(data) {
-    for (var key in item) {
-      if (typeof self[key] !== T_UNDEF && isWritable(self, key))
-        self[key] = data[key]
-    }
-  }
+  defineProperty(this, '_riot_id', ++__uid); // base 1 allows test !t._riot_id
 
-  function inheritFrom(target) {
-    each(Object.keys(target), function(k) {
-      // some properties must be always in sync with the parent tag
-      var mustSync = !RESERVED_WORDS_BLACKLIST.test(k) && contains(propsInSyncWithParent, k)
+  extend(this, { root: root, opts: opts }, item);
+  // protect the "tags" and "refs" property from being overridden
+  defineProperty(this, 'parent', parent || null);
+  defineProperty(this, 'tags', {});
+  defineProperty(this, 'refs', {});
 
-      if (typeof self[k] === T_UNDEF || mustSync) {
-        // track the property to keep in sync
-        // so we can keep it updated
-        if (!mustSync) propsInSyncWithParent.push(k)
-        self[k] = target[k]
-      }
-    })
-  }
+  dom = mkdom(impl.tmpl, innerHTML, isLoop);
 
   /**
    * Update the tag expressions and options
    * @param   { * }  data - data we want to use to extend the tag properties
-   * @param   { Boolean } isInherited - is this update coming from a parent tag?
-   * @returns { self }
+   * @returns { Tag } the current tag instance
    */
-  defineProperty(this, 'update', function(data, isInherited) {
+  defineProperty(this, 'update', function tagUpdate(data) {
+    if (isFunction(this.shouldUpdate) && !this.shouldUpdate(data)) { return this }
 
     // make sure the data passed will not override
     // the component core methods
-    data = cleanUpData(data)
-    // inherit properties from the parent in loop
-    if (isLoop) {
-      inheritFrom(self.parent)
-    }
-    // normalize the tag properties in case an item object was initially passed
-    if (data && isObject(item)) {
-      normalizeData(data)
-      item = data
-    }
-    extend(self, data)
-    updateOpts()
-    self.trigger('update', data)
-    update(expressions, self)
-
-    // the updated event will be triggered
-    // once the DOM will be ready and all the re-flows are completed
-    // this is useful if you want to get the "real" root properties
-    // 4 ex: root.offsetWidth ...
-    if (isInherited && self.parent)
-      // closes #1599
-      self.parent.one('updated', function() { self.trigger('updated') })
-    else rAF(function() { self.trigger('updated') })
+    data = cleanUpData(data);
+
+    // inherit properties from the parent, but only for isAnonymous tags
+    if (isLoop && isAnonymous) { inheritFrom.apply(this, [this.parent, propsInSyncWithParent]); }
+    extend(this, data);
+    updateOpts.apply(this, [isLoop, parent, isAnonymous, opts, instAttrs]);
+    if (this.isMounted) { this.trigger('update', data); }
+    updateAllExpressions.call(this, expressions);
+    if (this.isMounted) { this.trigger('updated'); }
 
     return this
-  })
 
-  defineProperty(this, 'mixin', function() {
-    each(arguments, function(mix) {
+  }.bind(this));
+
+  /**
+   * Add a mixin to this tag
+   * @returns { Tag } the current tag instance
+   */
+  defineProperty(this, 'mixin', function tagMixin() {
+    var this$1 = this;
+
+    each(arguments, function (mix) {
       var instance,
         props = [],
-        obj
+        obj;
 
-      mix = typeof mix === T_STRING ? riot.mixin(mix) : mix
+      mix = isString(mix) ? mixin$1(mix) : mix;
 
       // check if the mixin is a function
       if (isFunction(mix)) {
         // create the new mixin instance
-        instance = new mix()
-      } else instance = mix
+        instance = new mix();
+      } else { instance = mix; }
+
+      var proto = Object.getPrototypeOf(instance);
 
       // build multilevel prototype inheritance chain property list
-      do props = props.concat(Object.getOwnPropertyNames(obj || instance))
+      do { props = props.concat(Object.getOwnPropertyNames(obj || instance)); }
       while (obj = Object.getPrototypeOf(obj || instance))
 
       // loop the keys in the function prototype or the all object keys
-      each(props, function(key) {
-        // bind methods to self
+      each(props, function (key) {
+        // bind methods to this
         // allow mixins to override other properties/parent mixins
-        if (key != 'init') {
+        if (key !== 'init') {
           // check for getters/setters
-          var descriptor = Object.getOwnPropertyDescriptor(instance, key)
-          var hasGetterSetter = descriptor && (descriptor.get || descriptor.set)
+          var descriptor = Object.getOwnPropertyDescriptor(instance, key) || Object.getOwnPropertyDescriptor(proto, key);
+          var hasGetterSetter = descriptor && (descriptor.get || descriptor.set);
 
           // apply method only if it does not already exist on the instance
-          if (!self.hasOwnProperty(key) && hasGetterSetter) {
-            Object.defineProperty(self, key, descriptor)
+          if (!this$1.hasOwnProperty(key) && hasGetterSetter) {
+            Object.defineProperty(this$1, key, descriptor);
           } else {
-            self[key] = isFunction(instance[key]) ?
-              instance[key].bind(self) :
-              instance[key]
+            this$1[key] = isFunction(instance[key]) ?
+              instance[key].bind(this$1) :
+              instance[key];
           }
         }
-      })
+      });
 
       // init method will be called automatically
-      if (instance.init) instance.init.bind(self)()
-    })
+      if (instance.init)
+        { instance.init.bind(this$1)(); }
+    });
     return this
-  })
+  }.bind(this));
 
-  defineProperty(this, 'mount', function() {
+  /**
+   * Mount the current tag instance
+   * @returns { Tag } the current tag instance
+   */
+  defineProperty(this, 'mount', function tagMount() {
+    var this$1 = this;
 
-    updateOpts()
+    root._tag = this; // keep a reference to the tag just created
 
-    // add global mixins
-    var globalMixin = riot.mixin(GLOBAL_MIXIN)
+    // Read all the attrs on this instance. This give us the info we need for updateOpts
+    parseAttributes.apply(parent, [root, root.attributes, function (attr, expr) {
+      if (!isAnonymous && RefExpr.isPrototypeOf(expr)) { expr.tag = this$1; }
+      attr.expr = expr;
+      instAttrs.push(attr);
+    }]);
 
-    if (globalMixin)
-      for (var i in globalMixin)
-        if (globalMixin.hasOwnProperty(i))
-          self.mixin(globalMixin[i])
+    // update the root adding custom attributes coming from the compiler
+    implAttrs = [];
+    walkAttrs(impl.attrs, function (k, v) { implAttrs.push({name: k, value: v}); });
+    parseAttributes.apply(this, [root, implAttrs, function (attr, expr) {
+      if (expr) { expressions.push(expr); }
+      else { setAttr(root, attr.name, attr.value); }
+    }]);
 
     // children in loop should inherit from true parent
-    if (self._parent) {
-      inheritFrom(self._parent)
-    }
+    if (this._parent && isAnonymous) { inheritFrom.apply(this, [this._parent, propsInSyncWithParent]); }
 
     // initialiation
-    if (impl.fn) impl.fn.call(self, opts)
+    updateOpts.apply(this, [isLoop, parent, isAnonymous, opts, instAttrs]);
 
-    // parse layout after init. fn may calculate args for nested custom tags
-    parseExpressions(dom, self, expressions)
+    // add global mixins
+    var globalMixin = mixin$1(GLOBAL_MIXIN);
+
+    if (globalMixin) {
+      for (var i in globalMixin) {
+        if (globalMixin.hasOwnProperty(i)) {
+          this$1.mixin(globalMixin[i]);
+        }
+      }
+    }
 
-    // mount the child tags
-    toggle(true)
+    if (impl.fn) { impl.fn.call(this, opts); }
 
-    // update the root adding custom attributes coming from the compiler
-    // it fixes also #1087
-    if (impl.attrs)
-      walkAttributes(impl.attrs, function (k, v) { setAttr(root, k, v) })
-    if (impl.attrs || hasImpl)
-      parseExpressions(self.root, self, expressions)
+    this.trigger('before-mount');
 
-    if (!self.parent || isLoop) self.update(item)
+    // parse layout after init. fn may calculate args for nested custom tags
+    parseExpressions.apply(this, [dom, expressions, false]);
 
-    // internal use only, fixes #403
-    self.trigger('before-mount')
+    this.update(item);
 
-    if (isLoop && !hasImpl) {
+    if (isLoop && isAnonymous) {
       // update the root attribute for the looped elements
-      root = dom.firstChild
+      this.root = root = dom.firstChild;
     } else {
-      while (dom.firstChild) root.appendChild(dom.firstChild)
-      if (root.stub) root = parent.root
+      while (dom.firstChild) { root.appendChild(dom.firstChild); }
+      if (root.stub) { root = parent.root; }
     }
 
-    defineProperty(self, 'root', root)
-
-    // parse the named dom nodes in the looped child
-    // adding them to the parent as well
-    if (isLoop)
-      parseNamedElements(self.root, self.parent, null, true)
+    defineProperty(this, 'root', root);
+    this.isMounted = true;
 
     // if it's not a child tag we can trigger its mount event
-    if (!self.parent || self.parent.isMounted) {
-      self.isMounted = true
-      self.trigger('mount')
+    if (!this.parent || this.parent.isMounted) {
+      this.trigger('mount');
     }
     // otherwise we need to wait that the parent event gets triggered
-    else self.parent.one('mount', function() {
-      // avoid to trigger the `mount` event for the tags
-      // not visible included in an if statement
-      if (!isInStub(self.root)) {
-        self.parent.isMounted = self.isMounted = true
-        self.trigger('mount')
-      }
-    })
-  })
+    else { this.parent.one('mount', function () {
+      this$1.trigger('mount');
+    }); }
 
+    return this
+
+  }.bind(this));
+
+  /**
+   * Unmount the tag instance
+   * @param { Boolean } mustKeepRoot - if it's true the root node will not be removed
+   * @returns { Tag } the current tag instance
+   */
+  defineProperty(this, 'unmount', function tagUnmount(mustKeepRoot) {
+    var this$1 = this;
 
-  defineProperty(this, 'unmount', function(keepRootTag) {
-    var el = root,
+    var el = this.root,
       p = el.parentNode,
       ptag,
-      tagIndex = __virtualDom.indexOf(self)
+      tagIndex = __TAGS_CACHE.indexOf(this);
+
+    this.trigger('before-unmount');
 
-    self.trigger('before-unmount')
+    // clear all attributes coming from the mounted tag
+    walkAttrs(impl.attrs, function (name) {
+      if (startsWith(name, ATTRS_PREFIX))
+        { name = name.slice(ATTRS_PREFIX.length); }
+      remAttr(root, name);
+    });
 
     // remove this tag instance from the global virtualDom variable
     if (~tagIndex)
-      __virtualDom.splice(tagIndex, 1)
+      { __TAGS_CACHE.splice(tagIndex, 1); }
 
     if (p) {
-
-      if (parent) {
-        ptag = getImmediateCustomParentTag(parent)
-        // remove this tag from the parent tags object
-        // if there are multiple nested tags with same name..
-        // remove this element form the array
-        if (isArray(ptag.tags[tagName]))
-          each(ptag.tags[tagName], function(tag, i) {
-            if (tag._riot_id == self._riot_id)
-              ptag.tags[tagName].splice(i, 1)
-          })
-        else
-          // otherwise just delete the tag instance
-          ptag.tags[tagName] = undefined
-      }
-
-      else
-        while (el.firstChild) el.removeChild(el.firstChild)
-
-      if (!keepRootTag)
-        p.removeChild(el)
-      else {
-        // the riot-tag and the data-is attributes aren't needed anymore, remove them
-        remAttr(p, RIOT_TAG_IS)
-        remAttr(p, RIOT_TAG) // this will be removed in riot 3.0.0
-      }
-
-    }
-
-    if (this._virts) {
-      each(this._virts, function(v) {
-        if (v.parentNode) v.parentNode.removeChild(v)
-      })
-    }
-
-    self.trigger('unmount')
-    toggle()
-    self.off('*')
-    self.isMounted = false
-    delete root._tag
-
-  })
-
-  // proxy function to bind updates
-  // dispatched from a parent tag
-  function onChildUpdate(data) { self.update(data, true) }
-
-  function toggle(isMount) {
-
-    // mount/unmount children
-    each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })
-
-    // listen/unlisten parent (events flow one way from parent to children)
-    if (!parent) return
-    var evt = isMount ? 'on' : 'off'
-
-    // the loop tags will be always in sync with the parent automatically
-    if (isLoop)
-      parent[evt]('unmount', self.unmount)
-    else {
-      parent[evt]('update', onChildUpdate)[evt]('unmount', self.unmount)
-    }
-  }
-
-
-  // named elements available for fn
-  parseNamedElements(dom, this, childTags)
-
-}
-/**
- * Attach an event to a DOM node
- * @param { String } name - event name
- * @param { Function } handler - event callback
- * @param { Object } dom - dom node
- * @param { Tag } tag - tag instance
- */
-function setEventHandler(name, handler, dom, tag) {
-
-  dom[name] = function(e) {
-
-    var ptag = tag._parent,
-      item = tag._item,
-      el
-
-    if (!item)
-      while (ptag && !item) {
-        item = ptag._item
-        ptag = ptag._parent
-      }
-
-    // cross browser event fix
-    e = e || window.event
-
-    // override the event properties
-    if (isWritable(e, 'currentTarget')) e.currentTarget = dom
-    if (isWritable(e, 'target')) e.target = e.srcElement
-    if (isWritable(e, 'which')) e.which = e.charCode || e.keyCode
-
-    e.item = item
-
-    // prevent default behaviour (by default)
-    if (handler.call(tag, e) !== true && !/radio|check/.test(dom.type)) {
-      if (e.preventDefault) e.preventDefault()
-      e.returnValue = false
-    }
-
-    if (!e.preventUpdate) {
-      el = item ? getImmediateCustomParentTag(ptag) : tag
-      el.update()
-    }
-
-  }
-
-}
-
-
-/**
- * Insert a DOM node replacing another one (used by if- attribute)
- * @param   { Object } root - parent node
- * @param   { Object } node - node replaced
- * @param   { Object } before - node added
- */
-function insertTo(root, node, before) {
-  if (!root) return
-  root.insertBefore(before, node)
-  root.removeChild(node)
-}
-
-/**
- * Update the expressions in a Tag instance
- * @param   { Array } expressions - expression that must be re evaluated
- * @param   { Tag } tag - tag instance
- */
-function update(expressions, tag) {
-
-  each(expressions, function(expr, i) {
-
-    var dom = expr.dom,
-      attrName = expr.attr,
-      value = tmpl(expr.expr, tag),
-      parent = expr.parent || expr.dom.parentNode
-
-    if (expr.bool) {
-      value = !!value
-    } else if (value == null) {
-      value = ''
-    }
-
-    // #1638: regression of #1612, update the dom only if the value of the
-    // expression was changed
-    if (expr.value === value) {
-      return
-    }
-    expr.value = value
-
-    // textarea and text nodes has no attribute name
-    if (!attrName) {
-      // about #815 w/o replace: the browser converts the value to a string,
-      // the comparison by "==" does too, but not in the server
-      value += ''
-      // test for parent avoids error with invalid assignment to nodeValue
       if (parent) {
-        // cache the parent node because somehow it will become null on IE
-        // on the next iteration
-        expr.parent = parent
-        if (parent.tagName === 'TEXTAREA') {
-          parent.value = value                    // #1113
-          if (!IE_VERSION) dom.nodeValue = value  // #1625 IE throws here, nodeValue
-        }                                         // will be available on 'updated'
-        else dom.nodeValue = value
-      }
-      return
-    }
-
-    // ~~#1612: look for changes in dom.value when updating the value~~
-    if (attrName === 'value') {
-      if (dom.value !== value) {
-        dom.value = value
-        setAttr(dom, attrName, value)
-      }
-      return
-    } else {
-      // remove original attribute
-      remAttr(dom, attrName)
-    }
-
-    // event handler
-    if (isFunction(value)) {
-      setEventHandler(attrName, value, dom, tag)
-
-    // if- conditional
-    } else if (attrName == 'if') {
-      var stub = expr.stub,
-        add = function() { insertTo(stub.parentNode, stub, dom) },
-        remove = function() { insertTo(dom.parentNode, dom, stub) }
-
-      // add to DOM
-      if (value) {
-        if (stub) {
-          add()
-          dom.inStub = false
-          // avoid to trigger the mount event if the tags is not visible yet
-          // maybe we can optimize this avoiding to mount the tag at all
-          if (!isInStub(dom)) {
-            walk(dom, function(el) {
-              if (el._tag && !el._tag.isMounted)
-                el._tag.isMounted = !!el._tag.trigger('mount')
-            })
-          }
+        ptag = getImmediateCustomParentTag(parent);
+
+        if (isVirtual) {
+          Object.keys(this.tags).forEach(function (tagName) {
+            arrayishRemove(ptag.tags, tagName, this$1.tags[tagName]);
+          });
+        } else {
+          arrayishRemove(ptag.tags, tagName, this);
+          if(parent !== ptag) // remove from _parent too
+            { arrayishRemove(parent.tags, tagName, this); }
         }
-      // remove from DOM
       } else {
-        stub = expr.stub = stub || document.createTextNode('')
-        // if the parentNode is defined we can easily replace the tag
-        if (dom.parentNode)
-          remove()
-        // otherwise we need to wait the updated event
-        else (tag.parent || tag).one('updated', remove)
-
-        dom.inStub = true
-      }
-    // show / hide
-    } else if (attrName === 'show') {
-      dom.style.display = value ? '' : 'none'
-
-    } else if (attrName === 'hide') {
-      dom.style.display = value ? 'none' : ''
-
-    } else if (expr.bool) {
-      dom[attrName] = value
-      if (value) setAttr(dom, attrName, attrName)
-      if (FIREFOX && attrName === 'selected' && dom.tagName === 'OPTION') {
-        dom.__riot1374 = value   // #1374
+        while (el.firstChild) { el.removeChild(el.firstChild); }
       }
 
-    } else if (value === 0 || value && typeof value !== T_OBJECT) {
-      // <img src="{ expr }">
-      if (startsWith(attrName, RIOT_PREFIX) && attrName != RIOT_TAG) {
-        attrName = attrName.slice(RIOT_PREFIX.length)
+      if (!mustKeepRoot) {
+        p.removeChild(el);
+      } else {
+        // the riot-tag and the data-is attributes aren't needed anymore, remove them
+        remAttr(p, IS_DIRECTIVE);
       }
-      setAttr(dom, attrName, value)
     }
 
-  })
-
-}
-/**
- * Specialized function for looping an array-like collection with `each={}`
- * @param   { Array } els - collection of items
- * @param   {Function} fn - callback function
- * @returns { Array } the array looped
- */
-function each(els, fn) {
-  var len = els ? els.length : 0
-
-  for (var i = 0, el; i < len; i++) {
-    el = els[i]
-    // return false -> current item was removed by fn during the loop
-    if (el != null && fn(el, i) === false) i--
-  }
-  return els
-}
-
-/**
- * Detect if the argument passed is a function
- * @param   { * } v - whatever you want to pass to this function
- * @returns { Boolean } -
- */
-function isFunction(v) {
-  return typeof v === T_FUNCTION || false   // avoid IE problems
-}
-
-/**
- * Get the outer html of any DOM node SVGs included
- * @param   { Object } el - DOM node to parse
- * @returns { String } el.outerHTML
- */
-function getOuterHTML(el) {
-  if (el.outerHTML) return el.outerHTML
-  // some browsers do not support outerHTML on the SVGs tags
-  else {
-    var container = mkEl('div')
-    container.appendChild(el.cloneNode(true))
-    return container.innerHTML
-  }
-}
-
-/**
- * Set the inner html of any DOM node SVGs included
- * @param { Object } container - DOM node where we will inject the new html
- * @param { String } html - html to inject
- */
-function setInnerHTML(container, html) {
-  if (typeof container.innerHTML != T_UNDEF) container.innerHTML = html
-  // some browsers do not support innerHTML on the SVGs tags
-  else {
-    var doc = new DOMParser().parseFromString(html, 'application/xml')
-    container.appendChild(
-      container.ownerDocument.importNode(doc.documentElement, true)
-    )
-  }
-}
-
-/**
- * Checks wether a DOM node must be considered part of an svg document
- * @param   { String }  name - tag name
- * @returns { Boolean } -
- */
-function isSVGTag(name) {
-  return ~SVG_TAGS_LIST.indexOf(name)
-}
+    if (this._internal.virts) {
+      each(this._internal.virts, function (v) {
+        if (v.parentNode) { v.parentNode.removeChild(v); }
+      });
+    }
 
-/**
- * Detect if the argument passed is an object, exclude null.
- * NOTE: Use isObject(x) && !isArray(x) to excludes arrays.
- * @param   { * } v - whatever you want to pass to this function
- * @returns { Boolean } -
- */
-function isObject(v) {
-  return v && typeof v === T_OBJECT         // typeof null is 'object'
-}
+    // allow expressions to unmount themselves
+    unmountAll(expressions);
+    each(instAttrs, function (a) { return a.expr && a.expr.unmount && a.expr.unmount(); });
 
-/**
- * Remove any DOM attribute from a node
- * @param   { Object } dom - DOM node we want to update
- * @param   { String } name - name of the property we want to remove
- */
-function remAttr(dom, name) {
-  dom.removeAttribute(name)
-}
+    this.trigger('unmount');
+    this.off('*');
+    this.isMounted = false;
 
-/**
- * Convert a string containing dashes to camel case
- * @param   { String } string - input string
- * @returns { String } my-string -> myString
- */
-function toCamel(string) {
-  return string.replace(/-(\w)/g, function(_, c) {
-    return c.toUpperCase()
-  })
-}
+    delete this.root._tag;
 
-/**
- * Get the value of any DOM attribute on a node
- * @param   { Object } dom - DOM node we want to parse
- * @param   { String } name - name of the attribute we want to get
- * @returns { String | undefined } name of the node attribute whether it exists
- */
-function getAttr(dom, name) {
-  return dom.getAttribute(name)
-}
+    return this
 
-/**
- * Set any DOM/SVG attribute
- * @param { Object } dom - DOM node we want to update
- * @param { String } name - name of the property we want to set
- * @param { String } val - value of the property we want to set
- */
-function setAttr(dom, name, val) {
-  var xlink = XLINK_REGEX.exec(name)
-  if (xlink && xlink[1])
-    dom.setAttributeNS(XLINK_NS, xlink[1], val)
-  else
-    dom.setAttribute(name, val)
+  }.bind(this));
 }
 
 /**
@@ -2052,51 +2285,49 @@ function setAttr(dom, name, val) {
  * @returns { Object } it returns an object containing the implementation of a custom tag (template and boot function)
  */
 function getTag(dom) {
-  return dom.tagName && __tagImpl[getAttr(dom, RIOT_TAG_IS) ||
-    getAttr(dom, RIOT_TAG) || dom.tagName.toLowerCase()]
-}
-/**
- * Add a child tag to its parent into the `tags` object
- * @param   { Object } tag - child tag instance
- * @param   { String } tagName - key where the new tag will be stored
- * @param   { Object } parent - tag instance where the new child tag will be included
- */
-function addChildTag(tag, tagName, parent) {
-  var cachedTag = parent.tags[tagName]
-
-  // if there are multiple children tags having the same name
-  if (cachedTag) {
-    // if the parent tags property is not yet an array
-    // create it adding the first cached tag
-    if (!isArray(cachedTag))
-      // don't add the same tag twice
-      if (cachedTag !== tag)
-        parent.tags[tagName] = [cachedTag]
-    // add the new nested tag to the array
-    if (!contains(parent.tags[tagName], tag))
-      parent.tags[tagName].push(tag)
-  } else {
-    parent.tags[tagName] = tag
-  }
+  return dom.tagName && __TAG_IMPL[getAttr(dom, IS_DIRECTIVE) ||
+    getAttr(dom, IS_DIRECTIVE) || dom.tagName.toLowerCase()]
+}
+
+/**
+ * Inherit properties from a target tag instance
+ * @this Tag
+ * @param   { Tag } target - tag where we will inherit properties
+ * @param   { Array } propsInSyncWithParent - array of properties to sync with the target
+ */
+function inheritFrom(target, propsInSyncWithParent) {
+  var this$1 = this;
+
+  each(Object.keys(target), function (k) {
+    // some properties must be always in sync with the parent tag
+    var mustSync = !isReservedName(k) && contains(propsInSyncWithParent, k);
+
+    if (isUndefined(this$1[k]) || mustSync) {
+      // track the property to keep in sync
+      // so we can keep it updated
+      if (!mustSync) { propsInSyncWithParent.push(k); }
+      this$1[k] = target[k];
+    }
+  });
 }
 
 /**
  * Move the position of a custom tag in its parent tag
- * @param   { Object } tag - child tag instance
+ * @this Tag
  * @param   { String } tagName - key where the tag was stored
  * @param   { Number } newPos - index where the new tag will be stored
  */
-function moveChildTag(tag, tagName, newPos) {
-  var parent = tag.parent,
-    tags
+function moveChildTag(tagName, newPos) {
+  var parent = this.parent,
+    tags;
   // no parent no move
-  if (!parent) return
+  if (!parent) { return }
 
-  tags = parent.tags[tagName]
+  tags = parent.tags[tagName];
 
   if (isArray(tags))
-    tags.splice(newPos, 0, tags.splice(tags.indexOf(tag), 1)[0])
-  else addChildTag(tag, tagName, parent)
+    { tags.splice(newPos, 0, tags.splice(tags.indexOf(this), 1)[0]); }
+  else { arrayishAdd(parent.tags, tagName, this); }
 }
 
 /**
@@ -2108,24 +2339,26 @@ function moveChildTag(tag, tagName, newPos) {
  * @returns { Object } instance of the new child tag just created
  */
 function initChildTag(child, opts, innerHTML, parent) {
-  var tag = new Tag(child, opts, innerHTML),
-    tagName = getTagName(opts.root),
-    ptag = getImmediateCustomParentTag(parent)
+  var tag = new Tag$1(child, opts, innerHTML),
+    tagName = opts.tagName || getTagName(opts.root, true),
+    ptag = getImmediateCustomParentTag(parent);
   // fix for the parent attribute in the looped elements
-  tag.parent = ptag
+  defineProperty(tag, 'parent', ptag);
   // store the real parent tag
   // in some cases this could be different from the custom parent tag
   // for example in nested loops
-  tag._parent = parent
+  tag._parent = parent;
 
   // add this tag to the custom parent tag
-  addChildTag(tag, tagName, ptag)
+  arrayishAdd(ptag.tags, tagName, tag);
+
   // and also to the real parent tag
   if (ptag !== parent)
-    addChildTag(tag, tagName, parent)
+    { arrayishAdd(parent.tags, tagName, tag); }
+
   // empty the child node once we got its template
   // to avoid that its children get compiled multiple times
-  opts.root.innerHTML = ''
+  opts.root.innerHTML = '';
 
   return tag
 }
@@ -2136,148 +2369,96 @@ function initChildTag(child, opts, innerHTML, parent) {
  * @returns { Object } the instance of the first custom parent tag found
  */
 function getImmediateCustomParentTag(tag) {
-  var ptag = tag
-  while (!getTag(ptag.root)) {
-    if (!ptag.parent) break
-    ptag = ptag.parent
+  var ptag = tag;
+  while (ptag._internal.isAnonymous) {
+    if (!ptag.parent) { break }
+    ptag = ptag.parent;
   }
   return ptag
 }
 
 /**
- * Helper function to set an immutable property
- * @param   { Object } el - object where the new property will be set
- * @param   { String } key - object key where the new property will be stored
- * @param   { * } value - value of the new property
-* @param   { Object } options - set the propery overriding the default options
- * @returns { Object } - the initial object
+ * Trigger the unmount method on all the expressions
+ * @param   { Array } expressions - DOM expressions
  */
-function defineProperty(el, key, value, options) {
-  Object.defineProperty(el, key, extend({
-    value: value,
-    enumerable: false,
-    writable: false,
-    configurable: true
-  }, options))
-  return el
+function unmountAll(expressions) {
+  each(expressions, function(expr) {
+    if (expr instanceof Tag$1) { expr.unmount(true); }
+    else if (expr.unmount) { expr.unmount(); }
+  });
 }
 
 /**
  * Get the tag name of any DOM node
  * @param   { Object } dom - DOM node we want to parse
+ * @param   { Boolean } skipDataIs - hack to ignore the data-is attribute when attaching to parent
  * @returns { String } name to identify this dom node in riot
  */
-function getTagName(dom) {
+function getTagName(dom, skipDataIs) {
   var child = getTag(dom),
-    namedTag = getAttr(dom, 'name'),
-    tagName = namedTag && !tmpl.hasExpr(namedTag) ?
+    namedTag = !skipDataIs && getAttr(dom, IS_DIRECTIVE);
+  return namedTag && !tmpl.hasExpr(namedTag) ?
                 namedTag :
               child ? child.name : dom.tagName.toLowerCase()
-
-  return tagName
-}
-
-/**
- * Extend any object with other properties
- * @param   { Object } src - source object
- * @returns { Object } the resulting extended object
- *
- * var obj = { foo: 'baz' }
- * extend(obj, {bar: 'bar', foo: 'bar'})
- * console.log(obj) => {bar: 'bar', foo: 'bar'}
- *
- */
-function extend(src) {
-  var obj, args = arguments
-  for (var i = 1; i < args.length; ++i) {
-    if (obj = args[i]) {
-      for (var key in obj) {
-        // check if this property of the source object could be overridden
-        if (isWritable(src, key))
-          src[key] = obj[key]
-      }
-    }
-  }
-  return src
-}
-
-/**
- * Check whether an array contains an item
- * @param   { Array } arr - target array
- * @param   { * } item - item to test
- * @returns { Boolean } Does 'arr' contain 'item'?
- */
-function contains(arr, item) {
-  return ~arr.indexOf(item)
-}
-
-/**
- * Check whether an object is a kind of array
- * @param   { * } a - anything
- * @returns {Boolean} is 'a' an array?
- */
-function isArray(a) { return Array.isArray(a) || a instanceof Array }
-
-/**
- * Detect whether a property of an object could be overridden
- * @param   { Object }  obj - source object
- * @param   { String }  key - object property
- * @returns { Boolean } is this property writable?
- */
-function isWritable(obj, key) {
-  var props = Object.getOwnPropertyDescriptor(obj, key)
-  return typeof obj[key] === T_UNDEF || props && props.writable
 }
 
-
 /**
  * With this function we avoid that the internal Tag methods get overridden
  * @param   { Object } data - options we want to use to extend the tag instance
  * @returns { Object } clean object without containing the riot internal reserved words
  */
 function cleanUpData(data) {
-  if (!(data instanceof Tag) && !(data && typeof data.trigger == T_FUNCTION))
-    return data
+  if (!(data instanceof Tag$1) && !(data && isFunction(data.trigger)))
+    { return data }
 
-  var o = {}
+  var o = {};
   for (var key in data) {
-    if (!RESERVED_WORDS_BLACKLIST.test(key)) o[key] = data[key]
+    if (!RE_RESERVED_NAMES.test(key)) { o[key] = data[key]; }
   }
   return o
 }
 
 /**
- * Walk down recursively all the children tags starting dom node
- * @param   { Object }   dom - starting node where we will start the recursion
- * @param   { Function } fn - callback to transform the child node just found
+ * Set the property of an object for a given key. If something already
+ * exists there, then it becomes an array containing both the old and new value.
+ * @param { Object } obj - object on which to set the property
+ * @param { String } key - property name
+ * @param { Object } value - the value of the property to be set
+ * @param { Boolean } ensureArray - ensure that the property remains an array
  */
-function walk(dom, fn) {
-  if (dom) {
-    // stop the recursion
-    if (fn(dom) === false) return
-    else {
-      dom = dom.firstChild
+function arrayishAdd(obj, key, value, ensureArray) {
+  var dest = obj[key];
+  var isArr = isArray(dest);
 
-      while (dom) {
-        walk(dom, fn)
-        dom = dom.nextSibling
-      }
-    }
+  if (dest && dest === value) { return }
+
+  // if the key was never set, set it once
+  if (!dest && ensureArray) { obj[key] = [value]; }
+  else if (!dest) { obj[key] = value; }
+  // if it was an array and not yet set
+  else if (!isArr || isArr && !contains(dest, value)) {
+    if (isArr) { dest.push(value); }
+    else { obj[key] = [dest, value]; }
   }
 }
 
 /**
- * Minimize risk: only zero or one _space_ between attr & value
- * @param   { String }   html - html string we want to parse
- * @param   { Function } fn - callback function to apply on any attribute found
- */
-function walkAttributes(html, fn) {
-  var m,
-    re = /([-\w]+) ?= ?(?:"([^"]*)|'([^']*)|({[^}]*}))/g
-
-  while (m = re.exec(html)) {
-    fn(m[1].toLowerCase(), m[2] || m[3] || m[4])
-  }
+ * Removes an item from an object at a given key. If the key points to an array,
+ * then the item is just removed from the array.
+ * @param { Object } obj - object on which to remove the property
+ * @param { String } key - property name
+ * @param { Object } value - the value of the property to be removed
+ * @param { Boolean } ensureArray - ensure that the property remains an array
+*/
+function arrayishRemove(obj, key, value, ensureArray) {
+  if (isArray(obj[key])) {
+    each(obj[key], function(item, i) {
+      if (item === value) { obj[key].splice(i, 1); }
+    });
+    if (!obj[key].length) { delete obj[key]; }
+    else if (obj[key].length === 1 && !ensureArray) { obj[key] = obj[key][0]; }
+  } else
+    { delete obj[key]; } // otherwise just delete the key
 }
 
 /**
@@ -2287,383 +2468,196 @@ function walkAttributes(html, fn) {
  */
 function isInStub(dom) {
   while (dom) {
-    if (dom.inStub) return true
-    dom = dom.parentNode
+    if (dom.inStub)
+      { return true }
+    dom = dom.parentNode;
   }
   return false
 }
 
-/**
- * Create a generic DOM node
- * @param   { String } name - name of the DOM node we want to create
- * @param   { Boolean } isSvg - should we use a SVG as parent node?
- * @returns { Object } DOM node just created
- */
-function mkEl(name, isSvg) {
-  return isSvg ?
-    document.createElementNS('http://www.w3.org/2000/svg', 'svg') :
-    document.createElement(name)
-}
-
-/**
- * Shorter and fast way to select multiple nodes in the DOM
- * @param   { String } selector - DOM selector
- * @param   { Object } ctx - DOM node where the targets of our search will is located
- * @returns { Object } dom nodes found
- */
-function $$(selector, ctx) {
-  return (ctx || document).querySelectorAll(selector)
-}
-
-/**
- * Shorter and fast way to select a single node in the DOM
- * @param   { String } selector - unique dom selector
- * @param   { Object } ctx - DOM node where the target of our search will is located
- * @returns { Object } dom node found
- */
-function $(selector, ctx) {
-  return (ctx || document).querySelector(selector)
-}
-
-/**
- * Simple object prototypal inheritance
- * @param   { Object } parent - parent object
- * @returns { Object } child instance
- */
-function inherit(parent) {
-  function Child() {}
-  Child.prototype = parent
-  return new Child()
-}
-
-/**
- * Get the name property needed to identify a DOM node in riot
- * @param   { Object } dom - DOM node we need to parse
- * @returns { String | undefined } give us back a string to identify this dom node
- */
-function getNamedKey(dom) {
-  return getAttr(dom, 'id') || getAttr(dom, 'name')
-}
-
-/**
- * Set the named properties of a tag element
- * @param { Object } dom - DOM node we need to parse
- * @param { Object } parent - tag instance where the named dom element will be eventually added
- * @param { Array } keys - list of all the tag instance properties
- */
-function setNamed(dom, parent, keys) {
-  // get the key value we want to add to the tag instance
-  var key = getNamedKey(dom),
-    isArr,
-    // add the node detected to a tag instance using the named property
-    add = function(value) {
-      // avoid to override the tag properties already set
-      if (contains(keys, key)) return
-      // check whether this value is an array
-      isArr = isArray(value)
-      // if the key was never set
-      if (!value)
-        // set it once on the tag instance
-        parent[key] = dom
-      // if it was an array and not yet set
-      else if (!isArr || isArr && !contains(value, dom)) {
-        // add the dom node into the array
-        if (isArr)
-          value.push(dom)
-        else
-          parent[key] = [value, dom]
-      }
-    }
-
-  // skip the elements with no named properties
-  if (!key) return
-
-  // check whether this key has been already evaluated
-  if (tmpl.hasExpr(key))
-    // wait the first updated event only once
-    parent.one('mount', function() {
-      key = getNamedKey(dom)
-      add(parent[key])
-    })
-  else
-    add(parent[key])
-
-}
-
-/**
- * Faster String startsWith alternative
- * @param   { String } src - source string
- * @param   { String } str - test string
- * @returns { Boolean } -
- */
-function startsWith(src, str) {
-  return src.slice(0, str.length) === str
-}
-
-/**
- * requestAnimationFrame function
- * Adapted from https://gist.github.com/paulirish/1579671, license MIT
- */
-var rAF = (function (w) {
-  var raf = w.requestAnimationFrame    ||
-            w.mozRequestAnimationFrame || w.webkitRequestAnimationFrame
-
-  if (!raf || /iP(ad|hone|od).*OS 6/.test(w.navigator.userAgent)) {  // buggy iOS6
-    var lastTime = 0
-
-    raf = function (cb) {
-      var nowtime = Date.now(), timeout = Math.max(16 - (nowtime - lastTime), 0)
-      setTimeout(function () { cb(lastTime = nowtime + timeout) }, timeout)
-    }
-  }
-  return raf
-
-})(window || {})
-
 /**
  * Mount a tag creating new Tag instance
  * @param   { Object } root - dom node where the tag will be mounted
  * @param   { String } tagName - name of the riot tag we want to mount
  * @param   { Object } opts - options to pass to the Tag instance
+ * @param   { Object } ctx - optional context that will be used to extend an existing class ( used in riot.Tag )
  * @returns { Tag } a new Tag instance
  */
-function mountTo(root, tagName, opts) {
-  var tag = __tagImpl[tagName],
+function mountTo(root, tagName, opts, ctx) {
+  var impl = __TAG_IMPL[tagName],
+    implClass = __TAG_IMPL[tagName].class,
+    tag = ctx || (implClass ? Object.create(implClass.prototype) : {}),
     // cache the inner HTML to fix #855
-    innerHTML = root._innerHTML = root._innerHTML || root.innerHTML
+    innerHTML = root._innerHTML = root._innerHTML || root.innerHTML;
 
   // clear the inner html
-  root.innerHTML = ''
+  root.innerHTML = '';
+
+  var conf = { root: root, opts: opts };
+  if (opts && opts.parent) { conf.parent = opts.parent; }
 
-  if (tag && root) tag = new Tag(tag, { root: root, opts: opts }, innerHTML)
+  if (impl && root) { Tag$1.apply(tag, [impl, conf, innerHTML]); }
 
   if (tag && tag.mount) {
-    tag.mount()
+    tag.mount(true);
     // add this tag to the virtualDom variable
-    if (!contains(__virtualDom, tag)) __virtualDom.push(tag)
+    if (!contains(__TAGS_CACHE, tag)) { __TAGS_CACHE.push(tag); }
   }
 
   return tag
 }
-/**
- * Riot public api
- */
 
-// share methods for other riot parts, e.g. compiler
-riot.util = { brackets: brackets, tmpl: tmpl }
 
 /**
- * Create a mixin that could be globally shared across all the tags
+ * Adds the elements for a virtual tag
+ * @this Tag
+ * @param { Node } src - the node that will do the inserting or appending
+ * @param { Tag } target - only if inserting, insert before this tag's first child
  */
-riot.mixin = (function() {
-  var mixins = {},
-    globals = mixins[GLOBAL_MIXIN] = {},
-    _id = 0
+function makeVirtual(src, target) {
+  var this$1 = this;
 
-  /**
-   * Create/Return a mixin by its name
-   * @param   { String }  name - mixin name (global mixin if object)
-   * @param   { Object }  mixin - mixin logic
-   * @param   { Boolean } g - is global?
-   * @returns { Object }  the mixin logic
-   */
-  return function(name, mixin, g) {
-    // Unnamed global
-    if (isObject(name)) {
-      riot.mixin('__unnamed_'+_id++, name, true)
-      return
-    }
-
-    var store = g ? globals : mixins
+  var head = createDOMPlaceholder(),
+    tail = createDOMPlaceholder(),
+    frag = createFrag(),
+    sib, el;
 
-    // Getter
-    if (!mixin) {
-      if (typeof store[name] === T_UNDEF) {
-        throw new Error('Unregistered mixin: ' + name)
-      }
-      return store[name]
-    }
-    // Setter
-    if (isFunction(mixin)) {
-      extend(mixin.prototype, store[name] || {})
-      store[name] = mixin
-    }
-    else {
-      store[name] = extend(store[name] || {}, mixin)
-    }
-  }
+  this._internal.head = this.root.insertBefore(head, this.root.firstChild);
+  this._internal.tail = this.root.appendChild(tail);
 
-})()
+  el = this._internal.head;
 
-/**
- * Create a new riot tag implementation
- * @param   { String }   name - name/id of the new riot tag
- * @param   { String }   html - tag template
- * @param   { String }   css - custom tag css
- * @param   { String }   attrs - root tag attributes
- * @param   { Function } fn - user function
- * @returns { String } name/id of the tag just created
- */
-riot.tag = function(name, html, css, attrs, fn) {
-  if (isFunction(attrs)) {
-    fn = attrs
-    if (/^[\w\-]+\s?=/.test(css)) {
-      attrs = css
-      css = ''
-    } else attrs = ''
-  }
-  if (css) {
-    if (isFunction(css)) fn = css
-    else styleManager.add(css)
+  while (el) {
+    sib = el.nextSibling;
+    frag.appendChild(el);
+    this$1._internal.virts.push(el); // hold for unmounting
+    el = sib;
   }
-  name = name.toLowerCase()
-  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
-  return name
-}
 
-/**
- * Create a new riot tag implementation (for use by the compiler)
- * @param   { String }   name - name/id of the new riot tag
- * @param   { String }   html - tag template
- * @param   { String }   css - custom tag css
- * @param   { String }   attrs - root tag attributes
- * @param   { Function } fn - user function
- * @returns { String } name/id of the tag just created
- */
-riot.tag2 = function(name, html, css, attrs, fn) {
-  if (css) styleManager.add(css)
-  //if (bpair) riot.settings.brackets = bpair
-  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
-  return name
+  if (target)
+    { src.insertBefore(frag, target._internal.head); }
+  else
+    { src.appendChild(frag); }
 }
 
 /**
- * Mount a tag using a specific tag implementation
- * @param   { String } selector - tag DOM selector
- * @param   { String } tagName - tag implementation name
- * @param   { Object } opts - tag logic
- * @returns { Array } new tags instances
+ * Move virtual tag and all child nodes
+ * @this Tag
+ * @param { Node } src  - the node that will do the inserting
+ * @param { Tag } target - insert before this tag's first child
  */
-riot.mount = function(selector, tagName, opts) {
-
-  var els,
-    allTags,
-    tags = []
-
-  // helper functions
-
-  function addRiotTags(arr) {
-    var list = ''
-    each(arr, function (e) {
-      if (!/[^-\w]/.test(e)) {
-        e = e.trim().toLowerCase()
-        list += ',[' + RIOT_TAG_IS + '="' + e + '"],[' + RIOT_TAG + '="' + e + '"]'
-      }
-    })
-    return list
-  }
-
-  function selectAllTags() {
-    var keys = Object.keys(__tagImpl)
-    return keys + addRiotTags(keys)
-  }
-
-  function pushTags(root) {
-    if (root.tagName) {
-      var riotTag = getAttr(root, RIOT_TAG_IS) || getAttr(root, RIOT_TAG)
-
-      // have tagName? force riot-tag to be the same
-      if (tagName && riotTag !== tagName) {
-        riotTag = tagName
-        setAttr(root, RIOT_TAG_IS, tagName)
-        setAttr(root, RIOT_TAG, tagName) // this will be removed in riot 3.0.0
-      }
-      var tag = mountTo(root, riotTag || root.tagName.toLowerCase(), opts)
-
-      if (tag) tags.push(tag)
-    } else if (root.length) {
-      each(root, pushTags)   // assume nodeList
-    }
-  }
-
-  // ----- mount code -----
-
-  // inject styles into DOM
-  styleManager.inject()
-
-  if (isObject(tagName)) {
-    opts = tagName
-    tagName = 0
-  }
-
-  // crawl the DOM to find the tag
-  if (typeof selector === T_STRING) {
-    if (selector === '*')
-      // select all the tags registered
-      // and also the tags found with the riot-tag attribute set
-      selector = allTags = selectAllTags()
-    else
-      // or just the ones named like the selector
-      selector += addRiotTags(selector.split(/, */))
+function moveVirtual(src, target) {
+  var this$1 = this;
 
-    // make sure to pass always a selector
-    // to the querySelectorAll function
-    els = selector ? $$(selector) : []
-  }
-  else
-    // probably you have passed already a tag or a NodeList
-    els = selector
+  var el = this._internal.head,
+    frag = createFrag(),
+    sib;
 
-  // select all the registered and mount them inside their root elements
-  if (tagName === '*') {
-    // get all custom tags
-    tagName = allTags || selectAllTags()
-    // if the root els it's just a single tag
-    if (els.tagName)
-      els = $$(tagName, els)
-    else {
-      // select all the children for all the different root elements
-      var nodeList = []
-      each(els, function (_el) {
-        nodeList.push($$(tagName, _el))
-      })
-      els = nodeList
+  while (el) {
+    sib = el.nextSibling;
+    frag.appendChild(el);
+    el = sib;
+    if (el === this$1._internal.tail) {
+      frag.appendChild(el);
+      src.insertBefore(frag, target._internal.head);
+      break
     }
-    // get rid of the tagName
-    tagName = 0
   }
-
-  pushTags(els)
-
-  return tags
 }
 
 /**
- * Update all the tags instances created
- * @returns { Array } all the tags instances
+ * Get selectors for tags
+ * @param   { Array } tags - tag names to select
+ * @returns { String } selector
  */
-riot.update = function() {
-  return each(__virtualDom, function(tag) {
-    tag.update()
-  })
-}
+function selectTags(tags) {
+  // select all tags
+  if (!tags) {
+    var keys = Object.keys(__TAG_IMPL);
+    return keys + selectTags(keys)
+  }
 
-/**
- * Export the Virtual DOM
- */
-riot.vdom = __virtualDom
+  return tags
+    .filter(function (t) { return !/[^-\w]/.test(t); })
+    .reduce(function (list, t) {
+      var name = t.trim().toLowerCase();
+      return list + ",[" + IS_DIRECTIVE + "=\"" + name + "\"]"
+    }, '')
+}
+
+
+var tags = Object.freeze({
+	getTag: getTag,
+	inheritFrom: inheritFrom,
+	moveChildTag: moveChildTag,
+	initChildTag: initChildTag,
+	getImmediateCustomParentTag: getImmediateCustomParentTag,
+	unmountAll: unmountAll,
+	getTagName: getTagName,
+	cleanUpData: cleanUpData,
+	arrayishAdd: arrayishAdd,
+	arrayishRemove: arrayishRemove,
+	isInStub: isInStub,
+	mountTo: mountTo,
+	makeVirtual: makeVirtual,
+	moveVirtual: moveVirtual,
+	selectTags: selectTags
+});
 
 /**
- * Export the Tag constructor
+ * Riot public api
  */
-riot.Tag = Tag
-  // support CommonJS, AMD & browser
-  /* istanbul ignore next */
-  if (typeof exports === T_OBJECT)
-    module.exports = riot
-  else if (typeof define === T_FUNCTION && typeof define.amd !== T_UNDEF)
-    define(function() { return riot })
-  else
-    window.riot = riot
-
-})(typeof window != 'undefined' ? window : void 0);
+var settings = Object.create(brackets.settings);
+
+var util = {
+  tmpl: tmpl,
+  brackets: brackets,
+  styleManager: styleManager,
+  vdom: __TAGS_CACHE,
+  styleNode: styleManager.styleNode,
+  // export the riot internal utils as well
+  dom: dom,
+  check: check,
+  misc: misc,
+  tags: tags
+};
+
+// export the core props/methods
+var Tag$$1 = Tag$2;
+var tag$$1 = tag$1;
+var tag2$$1 = tag2$1;
+var mount$$1 = mount$1;
+var mixin$$1 = mixin$1;
+var update$$1 = update$1;
+var unregister$$1 = unregister$1;
+var observable = observable$1;
+
+var riot$1 = {
+  settings: settings,
+  util: util,
+  // core
+  Tag: Tag$$1,
+  tag: tag$$1,
+  tag2: tag2$$1,
+  mount: mount$$1,
+  mixin: mixin$$1,
+  update: update$$1,
+  unregister: unregister$$1,
+  observable: observable
+};
+
+exports.settings = settings;
+exports.util = util;
+exports.Tag = Tag$$1;
+exports.tag = tag$$1;
+exports.tag2 = tag2$$1;
+exports.mount = mount$$1;
+exports.mixin = mixin$$1;
+exports.update = update$$1;
+exports.unregister = unregister$$1;
+exports.observable = observable;
+exports['default'] = riot$1;
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+})));