riot_js-rails 0.3.0 → 0.4.0

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

@@ -1,32 +1,206 @@
-var parsers = {
+/**
+ * The compiler.parsers object holds the compiler's predefined parsers
+ * @module
+ */
+
+var path = require('path')    // for sass
+
+// dummy function for the none and javascript parsers
+function _none (src) { return src }
+
+/** Cache of required modules */
+var _mods = {
+  none: _none,
+  javascript: _none
+}
+
+/**
+ * Returns the module name for the given parser's name.
+ *
+ * @param   {string} name - one of the `html`, `css`, or `js` parsers.
+ * @returns {string} The module name for using with `require()`
+ * @static
+*/
+function _modname (name) {
+  switch (name) {
+    case 'es6':
+      return 'babel'
+    case 'babel':
+      return 'babel-core'
+    case 'javascript':
+      return 'none'
+    case 'coffee':
+    case 'coffeescript':
+      return 'coffee-script'
+    case 'scss':
+    case 'sass':
+      return 'node-sass'
+    case 'typescript':
+      return 'typescript-simple'
+    default:
+      return name
+  }
+}
+
+/**
+ * Loads a parser instance via `require`, without generating error.
+ *
+ * @param   {string}   name       - one of the `html`, `css`, or `js` parsers.
+ * @param   {string}   [req=name] - name for `require()`
+ * @returns {function} parser function, or null if error
+ */
+function _try (name, req) {
+
+  function fn (r) {
+    try { return require(r) } catch (_) {/**/}
+    return null
+  }
+
+  var p = _mods[name] = fn(req || _modname(name))
+
+  // istanbul ignore next: babel-core v5.8.x is not loaded by CI
+  if (!p && name === 'es6') {
+    p = _mods[name] = fn('babel-core')
+  }
+  return p
+}
+
+/**
+ * Returns a parser instance by its name, require the module if necessary.
+ * Public through the `parsers._req` function.
+ *
+ * @param   {string} name  - The parser's name, as registered in the parsers object
+ * @param   {string} [req] - To be used by `_try` with `require`
+ * @returns {function} The parser instance, null if the parser is not found
+ * @static
+ */
+function _req (name, req) {
+  return name in _mods ? _mods[name] : _try(name, req)
+}
+
+/**
+ * Merge the properties of the first object with the properties of the second.
+ *
+ * @param   {object} target - Target object
+ * @param   {object} source - Source of the extra properties
+ * @returns {object} Target object containing the new properties
+ */
+function extend (target, source) {
+  if (source) {
+    for (var prop in source) {
+      /* istanbul ignore next */
+      if (source.hasOwnProperty(prop)) {
+        target[prop] = source[prop]
+      }
+    }
+  }
+  return target
+}
+
+module.exports = {
+  /**
+   * The HTML parsers.
+   * @prop {function} jade - http://jade-lang.com
+   */
   html: {
-    jade: function(html) {
-      return require('jade').render(html, {pretty: true, doctype: 'html'})
+    jade: function (html, opts, url) {
+      opts = extend({
+        pretty: true,
+        filename: url,
+        doctype: 'html'
+      }, opts)
+      return _req('jade').render(html, opts)
+    }
+  },
+  /**
+   * Style parsers. In browsers, only less is supported.
+   * @prop {function} sass   - http://sass-lang.com
+   * @prop {function} scss   - http://sass-lang.com
+   * @prop {function} less   - http://lesscss.org
+   * @prop {function} stylus - http://stylus-lang.com
+   */
+  css: {
+    sass: function (tag, css, opts, url) {
+      opts = extend({
+        data: css,
+        includePaths: [path.dirname(url)],
+        indentedSyntax: true,
+        omitSourceMapUrl: true,
+        outputStyle: 'compact'
+      }, opts)
+      return _req('sass').renderSync(opts).css + ''
+    },
+    scss: function (tag, css, opts, url) {
+      opts = extend({
+        data: css,
+        includePaths: [path.dirname(url)],
+        indentedSyntax: false,
+        omitSourceMapUrl: true,
+        outputStyle: 'compact'
+      }, opts)
+      return _req('scss').renderSync(opts).css + ''
+    },
+    less: function (tag, css, opts, url) {
+      var ret
+
+      opts = extend({
+        sync: true,
+        syncImport: true,
+        filename: url
+      }, opts)
+      _req('less').render(css, opts, function (err, result) {
+        /* istanbul ignore next */
+        if (err) throw err
+        ret = result.css
+      })
+      return ret
+    },
+    stylus: function (tag, css, opts, url) {
+      var
+        stylus = _req('stylus'),
+        nib = _req('nib') // optional nib support
+
+      opts = extend({ filename: url }, opts)
+      /* istanbul ignore next: can't run both */
+      return nib
+        ? stylus(css, opts).use(nib()).import('nib').render() : stylus.render(css, opts)
     }
   },
-  css: {},
+  /**
+   * The JavaScript parsers.
+   * @prop {function} es6    - https://babeljs.io - babel or babel-core up to v5.8
+   * @prop {function} babel  - https://babeljs.io - for v6.x or later
+   * @prop {function} coffee - http://coffeescript.org
+   * @prop {function} livescript - http://livescript.net
+   * @prop {function} typescript - http://www.typescriptlang.org
+   */
   js: {
-    none: function(js) {
-      return js
+    es6: function (js, opts) {
+      opts = extend({
+        blacklist: ['useStrict', 'strict', 'react'],
+        sourceMaps: false,
+        comments: false
+      }, opts)
+      return _req('es6').transform(js, opts).code
     },
-    livescript: function(js) {
-      return require('livescript').compile(js, { bare: true, header: false })
+    babel: function (js, opts, url) {
+      return _req('babel').transform(js, extend({ filename: url }, opts)).code
     },
-    typescript: function(js) {
-      return require('typescript-simple')(js)
+    coffee: function (js, opts) {
+      return _req('coffee').compile(js, extend({ bare: true }, opts))
     },
-    es6: function(js) {
-      return require('babel').transform(js, { blacklist: ['useStrict'] }).code
+    livescript: function (js, opts) {
+      return _req('livescript').compile(js, extend({ bare: true, header: false }, opts))
     },
-    coffee: function(js) {
-      return require('coffee-script').compile(js, { bare: true })
-    }
-  }
+    typescript: function (js, opts) {
+      return _req('typescript')(js, opts)
+    },
+    none: _none, javascript: _none
+  },
+  _modname: _modname,
+  _req: _req
 }
 
-// fix 913
-parsers.js.javascript = parsers.js.none
-// 4 the nostalgics
-parsers.js.coffeescript = parsers.js.coffee
+exports = module.exports
+exports.js.coffeescript = exports.js.coffee     // 4 the nostalgics
 
-module.exports = parsers

data/vendor/assets/javascripts/riot.js

@@ -1,13 +1,21 @@
-/* Riot v2.2.4, @license MIT, (c) 2015 Muut Inc. + contributors */
+/* Riot v2.3.15, @license MIT, (c) 2015 Muut Inc. + contributors */
 
 ;(function(window, undefined) {
   'use strict';
-var riot = { version: 'v2.2.4', settings: {} },
-  //// be aware, internal usage
+var riot = { version: 'v2.3.15', 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
+   */
   // riot specific prefixes
   RIOT_PREFIX = 'riot-',
   RIOT_TAG = RIOT_PREFIX + 'tag',
@@ -18,470 +26,984 @@ var riot = { version: 'v2.2.4', settings: {} },
   T_UNDEF  = 'undefined',
   T_FUNCTION = 'function',
   // special native tags that cannot be treated like the others
-  SPECIAL_TAGS_REGEX = /^(?:opt(ion|group)|tbody|col|t[rhd])$/,
-  RESERVED_WORDS_BLACKLIST = ['_item', '_id', 'update', 'root', 'mount', 'unmount', 'mixin', 'isMounted', 'isLoop', 'tags', 'parent', 'opts', 'trigger', 'on', 'off', 'one'],
+  SPECIAL_TAGS_REGEX = /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?|opt(?:ion|group))$/,
+  RESERVED_WORDS_BLACKLIST = ['_item', '_id', '_parent', 'update', 'root', 'mount', 'unmount', 'mixin', 'isMounted', 'isLoop', 'tags', 'parent', 'opts', 'trigger', 'on', 'off', 'one'],
 
   // version# for IE 8-11, 0 for others
-  IE_VERSION = (window && window.document || {}).documentMode | 0,
-
-  // Array.isArray for IE8 is in the polyfills
-  isArray = Array.isArray
-
+  IE_VERSION = (window && window.document || {}).documentMode | 0
+/* istanbul ignore next */
 riot.observable = function(el) {
 
+  /**
+   * Extend the original object or create a new empty one
+   * @type { Object }
+   */
+
   el = el || {}
 
+  /**
+   * Private variables and methods
+   */
   var callbacks = {},
-      _id = 0
-
-  el.on = function(events, fn) {
-    if (isFunction(fn)) {
-      if (typeof fn.id === T_UNDEF) fn._id = _id++
-
-      events.replace(/\S+/g, function(name, pos) {
-        (callbacks[name] = callbacks[name] || []).push(fn)
-        fn.typed = pos > 0
+    slice = Array.prototype.slice,
+    onEachEvent = function(e, fn) { e.replace(/\S+/g, fn) },
+    defineProperty = function (key, value) {
+      Object.defineProperty(el, key, {
+        value: value,
+        enumerable: false,
+        writable: false,
+        configurable: false
       })
     }
+
+  /**
+   * 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
+   */
+  defineProperty('on', 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
-  }
+  })
 
-  el.off = function(events, fn) {
-    if (events == '*') callbacks = {}
+  /**
+   * Removes the given space separated list of `events` listeners
+   * @param   { String } events - events ids
+   * @param   { Function } fn - callback function
+   * @returns { Object } el
+   */
+  defineProperty('off', function(events, fn) {
+    if (events == '*' && !fn) callbacks = {}
     else {
-      events.replace(/\S+/g, function(name) {
+      onEachEvent(events, function(name) {
         if (fn) {
           var arr = callbacks[name]
-          for (var i = 0, cb; (cb = arr && arr[i]); ++i) {
-            if (cb._id == fn._id) arr.splice(i--, 1)
+          for (var i = 0, cb; cb = arr && arr[i]; ++i) {
+            if (cb == fn) arr.splice(i--, 1)
           }
-        } else {
-          callbacks[name] = []
-        }
+        } else delete callbacks[name]
       })
     }
     return el
-  }
+  })
 
-  // only single event supported
-  el.one = function(name, fn) {
+  /**
+   * 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
+   */
+  defineProperty('one', function(events, fn) {
     function on() {
-      el.off(name, on)
+      el.off(events, on)
       fn.apply(el, arguments)
     }
-    return el.on(name, on)
-  }
+    return el.on(events, on)
+  })
+
+  /**
+   * Execute all callback functions that listen to the given space separated list of `events`
+   * @param   { String } events - events ids
+   * @returns { Object } el
+   */
+  defineProperty('trigger', function(events) {
+
+    // getting the arguments
+    // skipping the first one
+    var args = slice.call(arguments, 1),
+      fns
+
+    onEachEvent(events, function(name) {
 
-  el.trigger = function(name) {
-    var args = [].slice.call(arguments, 1),
-        fns = callbacks[name] || []
+      fns = slice.call(callbacks[name] || [], 0)
 
-    for (var i = 0, fn; (fn = fns[i]); ++i) {
-      if (!fn.busy) {
+      for (var i = 0, fn; fn = fns[i]; ++i) {
+        if (fn.busy) return
         fn.busy = 1
         fn.apply(el, fn.typed ? [name].concat(args) : args)
         if (fns[i] !== fn) { i-- }
         fn.busy = 0
       }
-    }
 
-    if (callbacks.all && name != 'all') {
-      el.trigger.apply(el, ['all', name].concat(args))
-    }
+      if (callbacks['*'] && name != '*')
+        el.trigger.apply(el, ['*', name].concat(args))
+
+    })
 
     return el
-  }
+  })
 
   return el
 
 }
-riot.mixin = (function() {
-  var mixins = {}
+/* istanbul ignore next */
+;(function(riot) {
+
+/**
+ * Simple client-side router
+ * @module riot-route
+ */
+
+
+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
+
+/**
+ * Default parser. You can replace it via router.parser method.
+ * @param {string} path - current path (normalized)
+ * @returns {array} array
+ */
+function DEFAULT_PARSER(path) {
+  return path.split(/[/?#]/)
+}
 
-  return function(name, mixin) {
-    if (!mixin) return mixins[name]
-    mixins[name] = mixin
+/**
+ * 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
+ */
+function DEFAULT_SECOND_PARSER(path, filter) {
+  var re = new RegExp('^' + filter[REPLACE](/\*/g, '([^/?#]+?)')[REPLACE](/\.\./, '.*') + '$'),
+    args = path.match(re)
+
+  if (args) return args.slice(1)
+}
+
+/**
+ * Simple/cheap debounce implementation
+ * @param   {function} fn - callback
+ * @param   {number} delay - delay in seconds
+ * @returns {function} debounced function
+ */
+function debounce(fn, delay) {
+  var t
+  return function () {
+    clearTimeout(t)
+    t = setTimeout(fn, delay)
   }
+}
 
-})()
+/**
+ * Set the window listeners to trigger the routes
+ * @param {boolean} autoExec - see route.start
+ */
+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(riot, evt, win) {
+/**
+ * Router class
+ */
+function Router() {
+  this.$ = []
+  riot.observable(this) // make it observable
+  central.on('stop', this.s.bind(this))
+  central.on('emit', this.e.bind(this))
+}
 
-  // browsers only
-  if (!win) return
+function normalize(path) {
+  return path[REPLACE](/^\/|\/$/, '')
+}
 
-  var loc = win.location,
-      fns = riot.observable(),
-      started = false,
-      current
+function isString(str) {
+  return typeof str == 'string'
+}
 
-  function hash() {
-    return loc.href.split('#')[1] || ''   // why not loc.hash.splice(1) ?
-  }
+/**
+ * Get the part after domain name
+ * @param {string} href - fullpath
+ * @returns {string} path from root
+ */
+function getPathFromRoot(href) {
+  return (href || loc.href || '')[REPLACE](RE_ORIGIN, '')
+}
 
-  function parser(path) {
-    return path.split('/')
-  }
+/**
+ * Get the part after base
+ * @param {string} href - fullpath
+ * @returns {string} path from base
+ */
+function getPathFromBase(href) {
+  return base[0] == '#'
+    ? (href || loc.href || '').split(base)[1] || ''
+    : getPathFromRoot(href)[REPLACE](base, '')
+}
 
-  function emit(path) {
-    if (path.type) path = hash()
+function emit(force) {
+  // the stack is needed for redirections
+  var isRoot = emitStackLevel == 0
+  if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) return
 
-    if (path != current) {
-      fns.trigger.apply(null, ['H'].concat(parser(path)))
+  emitStackLevel++
+  emitStack.push(function() {
+    var path = getPathFromBase()
+    if (force || path != current) {
+      central[TRIGGER]('emit', path)
       current = path
     }
-  }
-
-  var r = riot.route = function(arg) {
-    // string
-    if (arg[0]) {
-      loc.hash = arg
-      emit(arg)
-
-    // function
-    } else {
-      fns.on('H', arg)
+  })
+  if (isRoot) {
+    while (emitStack.length) {
+      emitStack[0]()
+      emitStack.shift()
     }
+    emitStackLevel = 0
   }
+}
 
-  r.exec = function(fn) {
-    fn.apply(null, parser(hash()))
+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
+  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) {
+    if (
+      el.href.split('#')[0] == loc.href.split('#')[0] // internal jump
+      || base != '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base
+      || !go(getPathFromBase(el.href), el.title || doc.title) // route not found
+    ) return
   }
 
-  r.parser = function(fn) {
-    parser = fn
-  }
+  e.preventDefault()
+}
 
-  r.stop = function () {
-    if (started) {
-      if (win.removeEventListener) win.removeEventListener(evt, emit, false) //@IE8 - the if()
-      else win.detachEvent('on' + evt, emit) //@IE8
-      fns.off('*')
-      started = false
-    }
+/**
+ * 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
+ */
+function go(path, title, shouldReplace) {
+  if (hist) { // if a browser
+    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
   }
 
-  r.start = function () {
-    if (!started) {
-      if (win.addEventListener) win.addEventListener(evt, emit, false) //@IE8 - the if()
-      else win.attachEvent('on' + evt, emit) //IE8
-      started = true
+  // Server-side usage: directly execute handlers for the path
+  return central[TRIGGER]('emit', getPathFromBase(path))
+}
+
+/**
+ * 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
+ */
+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)
+}
+
+/**
+ * Stop routing
+ */
+prot.s = function() {
+  this.off('*')
+  this.$ = []
+}
+
+/**
+ * Emit
+ * @param {string} path - path
+ */
+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)
+}
+
+/**
+ * Register route
+ * @param {string} filter - filter for matching to url
+ * @param {function} action - action to register
+ */
+prot.r = function(filter, action) {
+  if (filter != '@') {
+    filter = '/' + normalize(filter)
+    this.$.push(filter)
   }
+  this.on(filter, action)
+}
 
-  // autostart the router
-  r.start()
+var mainRouter = new Router()
+var route = mainRouter.m.bind(mainRouter)
+
+/**
+ * Create a sub router
+ * @returns {function} the method of a new Router object
+ */
+route.create = function() {
+  var newSubRouter = new Router()
+  // stop only this sub-router
+  newSubRouter.m.stop = newSubRouter.s.bind(newSubRouter)
+  // return sub-router's main method
+  return newSubRouter.m.bind(newSubRouter)
+}
 
-})(riot, 'hashchange', window)
-/*
+/**
+ * Set the base of url
+ * @param {(str|RegExp)} arg - a new base or '#' or '#!'
+ */
+route.base = function(arg) {
+  base = arg || '#'
+  current = getPathFromBase() // recalculate current path
+}
 
-//// How it works?
+/** Exec routing right now **/
+route.exec = function() {
+  emit(true)
+}
+
+/**
+ * Replace the default router to yours
+ * @param {function} fn - your parser function
+ * @param {function} fn2 - your secondParser function
+ */
+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
+}
+
+/**
+ * Helper function to get url query as an object
+ * @returns {object} parsed query
+ */
+route.query = function() {
+  var q = {}
+  var href = loc.href || current
+  href[REPLACE](/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v })
+  return q
+}
+
+/** 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
+  }
+}
 
+/**
+ * Start routing
+ * @param {boolean} autoExec - automatically exec after starting if true
+ */
+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)
+      })
+    }
+    started = true
+  }
+}
 
-Three ways:
+/** Prepare the router **/
+route.base()
+route.parser()
+
+riot.route = route
+})(riot)
+/* istanbul ignore next */
+
+/**
+ * The riot template engine
+ * @version v2.3.21
+ */
+
+/**
+ * riot.util.brackets
+ *
+ * - `brackets    ` - Returns a string or regex based on its parameter
+ * - `brackets.set` - Change the current riot brackets
+ *
+ * @module
+ */
+
+var brackets = (function (UNDEF) {
+
+  var
+    REGLOB = 'g',
+
+    R_MLCOMMS = /\/\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//g,
+
+    R_STRINGS = /"[^"\\]*(?:\\[\S\s][^"\\]*)*"|'[^'\\]*(?:\\[\S\s][^'\\]*)*'/g,
+
+    S_QBLOCKS = R_STRINGS.source + '|' +
+      /(?:\breturn\s+|(?:[$\w\)\]]|\+\+|--)\s*(\/)(?![*\/]))/.source + '|' +
+      /\/(?=[^*\/])[^[\/\\]*(?:(?:\[(?:\\.|[^\]\\]*)*\]|\\.)[^[\/\\]*)*?(\/)[gim]*/.source,
+
+    FINDBRACES = {
+      '(': RegExp('([()])|'   + S_QBLOCKS, REGLOB),
+      '[': RegExp('([[\\]])|' + S_QBLOCKS, REGLOB),
+      '{': RegExp('([{}])|'   + S_QBLOCKS, REGLOB)
+    },
+
+    DEFAULT = '{ }'
+
+  var _pairs = [
+    '{', '}',
+    '{', '}',
+    /{[^}]*}/,
+    /\\([{}])/g,
+    /\\({)|{/g,
+    RegExp('\\\\(})|([[({])|(})|' + S_QBLOCKS, REGLOB),
+    DEFAULT,
+    /^\s*{\^?\s*([$\w]+)(?:\s*,\s*(\S+))?\s+in\s+(\S.*)\s*}/,
+    /(^|[^\\]){=[\S\s]*?}/
+  ]
+
+  var
+    cachedBrackets = UNDEF,
+    _regex,
+    _cache = [],
+    _settings
+
+  function _loopback (re) { return re }
+
+  function _rewrite (re, bp) {
+    if (!bp) bp = _cache
+    return new RegExp(
+      re.source.replace(/{/g, bp[2]).replace(/}/g, bp[3]), re.global ? REGLOB : ''
+    )
+  }
 
-1. Expressions: tmpl('{ value }', data).
-   Returns the result of evaluated expression as a raw object.
+  function _create (pair) {
+    if (pair === DEFAULT) return _pairs
 
-2. Templates: tmpl('Hi { name } { surname }', data).
-   Returns a string with evaluated expressions.
+    var arr = pair.split(' ')
 
-3. Filters: tmpl('{ show: !done, highlight: active }', data).
-   Returns a space separated list of trueish keys (mainly
-   used for setting html classes), e.g. "show highlight".
+    if (arr.length !== 2 || /[\x00-\x1F<>a-zA-Z0-9'",;\\]/.test(pair)) {
+      throw new Error('Unsupported brackets "' + pair + '"')
+    }
+    arr = arr.concat(pair.replace(/(?=[[\]()*+?.^$|])/g, '\\').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
+    return arr
+  }
 
+  function _brackets (reOrIdx) {
+    return reOrIdx instanceof RegExp ? _regex(reOrIdx) : _cache[reOrIdx]
+  }
 
-// Template examples
+  _brackets.split = function split (str, tmpl, _bp) {
+    // istanbul ignore next: _bp is for the compiler
+    if (!_bp) _bp = _cache
 
-tmpl('{ title || "Untitled" }', data)
-tmpl('Results are { results ? "ready" : "loading" }', data)
-tmpl('Today is { new Date() }', data)
-tmpl('{ message.length > 140 && "Message is too long" }', data)
-tmpl('This item got { Math.round(rating) } stars', data)
-tmpl('<h1>{ title }</h1>{ body }', data)
+    var
+      parts = [],
+      match,
+      isexpr,
+      start,
+      pos,
+      re = _bp[6]
 
+    isexpr = start = re.lastIndex = 0
 
-// Falsy expressions in templates
+    while (match = re.exec(str)) {
 
-In templates (as opposed to single expressions) all falsy values
-except zero (undefined/null/false) will default to empty string:
+      pos = match.index
 
-tmpl('{ undefined } - { false } - { null } - { 0 }', {})
-// will return: " - - - 0"
+      if (isexpr) {
 
-*/
+        if (match[2]) {
+          re.lastIndex = skipBraces(str, match[2], re.lastIndex)
+          continue
+        }
+        if (!match[3])
+          continue
+      }
 
+      if (!match[1]) {
+        unescapeStr(str.slice(start, pos))
+        start = re.lastIndex
+        re = _bp[6 + (isexpr ^= 1)]
+        re.lastIndex = start
+      }
+    }
 
-var brackets = (function(orig) {
+    if (str && start < str.length) {
+      unescapeStr(str.slice(start))
+    }
 
-  var cachedBrackets,
-      r,
-      b,
-      re = /[{}]/g
+    return parts
 
-  return function(x) {
+    function unescapeStr (s) {
+      if (tmpl || isexpr)
+        parts.push(s && s.replace(_bp[5], '$1'))
+      else
+        parts.push(s)
+    }
 
-    // make sure we use the current setting
-    var s = riot.settings.brackets || orig
+    function skipBraces (s, ch, ix) {
+      var
+        match,
+        recch = FINDBRACES[ch]
 
-    // recreate cached vars if needed
-    if (cachedBrackets !== s) {
-      cachedBrackets = s
-      b = s.split(' ')
-      r = b.map(function (e) { return e.replace(/(?=.)/g, '\\') })
+      recch.lastIndex = ix
+      ix = 1
+      while (match = recch.exec(s)) {
+        if (match[1] &&
+          !(match[1] === ch ? ++ix : --ix)) break
+      }
+      return ix ? s.length : recch.lastIndex
     }
+  }
 
-    // if regexp given, rewrite it with current brackets (only if differ from default)
-    return x instanceof RegExp ? (
-        s === orig ? x :
-        new RegExp(x.source.replace(re, function(b) { return r[~~(b === '}')] }), x.global ? 'g' : '')
-      ) :
-      // else, get specific bracket
-      b[x]
+  _brackets.hasExpr = function hasExpr (str) {
+    return _cache[4].test(str)
   }
-})('{ }')
 
+  _brackets.loopKeys = function loopKeys (expr) {
+    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() }
+  }
 
-var tmpl = (function() {
+  _brackets.hasRaw = function (src) {
+    return _cache[10].test(src)
+  }
 
-  var cache = {},
-      OGLOB = '"in d?d:' + (window ? 'window).' : 'global).'),
-      reVars =
-      /(['"\/])(?:[^\\]*?|\\.|.)*?\1|\.\w*|\w*:|\b(?:(?:new|typeof|in|instanceof) |(?:this|true|false|null|undefined)\b|function\s*\()|([A-Za-z_$]\w*)/g
+  _brackets.array = function array (pair) {
+    return pair ? _create(pair) : _cache
+  }
 
-  // build a template (or get it from cache), render with data
-  return function(str, data) {
-    return str && (cache[str] || (cache[str] = tmpl(str)))(data)
+  function _reset (pair) {
+    if ((pair || (pair = DEFAULT)) !== _cache[8]) {
+      _cache = _create(pair)
+      _regex = pair === DEFAULT ? _loopback : _rewrite
+      _cache[9] = _regex(_pairs[9])
+      _cache[10] = _regex(_pairs[10])
+    }
+    cachedBrackets = pair
   }
 
+  function _setSettings (o) {
+    var b
+    o = o || {}
+    b = o.brackets
+    Object.defineProperty(o, 'brackets', {
+      set: _reset,
+      get: function () { return cachedBrackets },
+      enumerable: true
+    })
+    _settings = o
+    _reset(b)
+  }
 
-  // create a template instance
+  Object.defineProperty(_brackets, 'settings', {
+    set: _setSettings,
+    get: function () { return _settings }
+  })
 
-  function tmpl(s, p) {
+  /* istanbul ignore next: in the browser riot is always in the scope */
+  _brackets.settings = typeof riot !== 'undefined' && riot.settings || {}
+  _brackets.set = _reset
 
-    if (s.indexOf(brackets(0)) < 0) {
-      // return raw text
-      s = s.replace(/\n|\r\n?/g, '\n')
-      return function () { return s }
-    }
+  _brackets.R_STRINGS = R_STRINGS
+  _brackets.R_MLCOMMS = R_MLCOMMS
+  _brackets.S_QBLOCKS = S_QBLOCKS
 
-    // temporarily convert \{ and \} to a non-character
-    s = s
-      .replace(brackets(/\\{/g), '\uFFF0')
-      .replace(brackets(/\\}/g), '\uFFF1')
+  return _brackets
 
-    // split string to expression and non-expresion parts
-    p = split(s, extract(s, brackets(/{/), brackets(/}/)))
+})()
 
-    // is it a single expression or a template? i.e. {x} or <b>{x}</b>
-    s = (p.length === 2 && !p[0]) ?
+/**
+ * @module tmpl
+ *
+ * tmpl          - Root function, returns the template value, render with data
+ * tmpl.hasExpr  - Test the existence of a expression inside a string
+ * tmpl.loopKeys - Get the keys for an 'each' loop (used by `_each`)
+ */
 
-      // if expression, evaluate it
-      expr(p[1]) :
+var tmpl = (function () {
 
-      // if template, evaluate all expressions in it
-      '[' + p.map(function(s, i) {
+  var _cache = {}
 
-        // is it an expression or a string (every second part is an expression)
-        return i % 2 ?
+  function _tmpl (str, data) {
+    if (!str) return str
 
-          // evaluate the expressions
-          expr(s, true) :
+    return (_cache[str] || (_cache[str] = _create(str))).call(data, _logErr)
+  }
 
-          // process string parts of the template:
-          '"' + s
+  _tmpl.haveRaw = brackets.hasRaw
 
-            // preserve new lines
-            .replace(/\n|\r\n?/g, '\\n')
+  _tmpl.hasExpr = brackets.hasExpr
 
-            // escape quotes
-            .replace(/"/g, '\\"') +
+  _tmpl.loopKeys = brackets.loopKeys
 
-          '"'
+  _tmpl.errorHandler = null
 
-      }).join(',') + '].join("")'
+  function _logErr (err, ctx) {
 
-    return new Function('d', 'return ' + s
-      // bring escaped { and } back
-      .replace(/\uFFF0/g, brackets(0))
-      .replace(/\uFFF1/g, brackets(1)) + ';')
+    if (_tmpl.errorHandler) {
 
+      err.riotData = {
+        tagName: ctx && ctx.root && ctx.root.tagName,
+        _riot_id: ctx && ctx._riot_id  //eslint-disable-line camelcase
+      }
+      _tmpl.errorHandler(err)
+    }
   }
 
+  function _create (str) {
 
-  // parse { ... } expression
+    var expr = _getTmpl(str)
+    if (expr.slice(0, 11) !== 'try{return ') expr = 'return ' + expr
 
-  function expr(s, n) {
-    s = s
+    return new Function('E', expr + ';')
+  }
 
-      // convert new lines to spaces
-      .replace(/\n|\r\n?/g, ' ')
+  var
+    RE_QBLOCK = RegExp(brackets.S_QBLOCKS, 'g'),
+    RE_QBMARK = /\x01(\d+)~/g
 
-      // trim whitespace, brackets, strip comments
-      .replace(brackets(/^[{ ]+|[ }]+$|\/\*.+?\*\//g), '')
+  function _getTmpl (str) {
+    var
+      qstr = [],
+      expr,
+      parts = brackets.split(str.replace(/\u2057/g, '"'), 1)
 
-    // is it an object literal? i.e. { key : value }
-    return /^\s*[\w- "']+ *:/.test(s) ?
+    if (parts.length > 2 || parts[0]) {
+      var i, j, list = []
 
-      // if object literal, return trueish keys
-      // e.g.: { show: isOpen(), done: item.done } -> "show done"
-      '[' +
+      for (i = j = 0; i < parts.length; ++i) {
 
-          // extract key:val pairs, ignoring any nested objects
-          extract(s,
+        expr = parts[i]
 
-              // name part: name:, "name":, 'name':, name :
-              /["' ]*[\w- ]+["' ]*:/,
+        if (expr && (expr = i & 1 ?
 
-              // expression part: everything upto a comma followed by a name (see above) or end of line
-              /,(?=["' ]*[\w- ]+["' ]*:)|}|$/
-              ).map(function(pair) {
+              _parseExpr(expr, 1, qstr) :
 
-                // get key, val parts
-                return pair.replace(/^[ "']*(.+?)[ "']*: *(.+?),? *$/, function(_, k, v) {
+              '"' + expr
+                .replace(/\\/g, '\\\\')
+                .replace(/\r\n?|\n/g, '\\n')
+                .replace(/"/g, '\\"') +
+              '"'
 
-                  // wrap all conditional parts to ignore errors
-                  return v.replace(/[^&|=!><]+/g, wrap) + '?"' + k + '":"",'
+          )) list[j++] = expr
 
-                })
+      }
 
-              }).join('') +
+      expr = j < 2 ? list[0] :
+             '[' + list.join(',') + '].join("")'
 
-        '].join(" ").trim()' :
+    } else {
 
-      // if js expression, evaluate as javascript
-      wrap(s, n)
+      expr = _parseExpr(parts[1], 0, qstr)
+    }
 
+    if (qstr[0])
+      expr = expr.replace(RE_QBMARK, function (_, pos) {
+        return qstr[pos]
+          .replace(/\r/g, '\\r')
+          .replace(/\n/g, '\\n')
+      })
+
+    return expr
   }
 
+  var
+    RE_BREND = {
+      '(': /[()]/g,
+      '[': /[[\]]/g,
+      '{': /[{}]/g
+    },
+    CS_IDENT = /^(?:(-?[_A-Za-z\xA0-\xFF][-\w\xA0-\xFF]*)|\x01(\d+)~):/
 
-  // execute js w/o breaking on errors or undefined vars
+  function _parseExpr (expr, asText, qstr) {
 
-  function wrap(s, nonull) {
-    s = s.trim()
-    return !s ? '' : '(function(v){try{v=' +
+    if (expr[0] === '=') expr = expr.slice(1)
 
-      // prefix vars (name => data.name)
-      s.replace(reVars, function(s, _, v) { return v ? '(("' + v + OGLOB + v + ')' : s }) +
+    expr = expr
+          .replace(RE_QBLOCK, function (s, div) {
+            return s.length > 2 && !div ? '\x01' + (qstr.push(s) - 1) + '~' : s
+          })
+          .replace(/\s+/g, ' ').trim()
+          .replace(/\ ?([[\({},?\.:])\ ?/g, '$1')
 
-      // default to empty string for falsy values except zero
-      '}catch(e){}return ' + (nonull === true ? '!v&&v!==0?"":v' : 'v') + '}).call(d)'
-  }
+    if (expr) {
+      var
+        list = [],
+        cnt = 0,
+        match
 
+      while (expr &&
+            (match = expr.match(CS_IDENT)) &&
+            !match.index
+        ) {
+        var
+          key,
+          jsb,
+          re = /,|([[{(])|$/g
 
-  // split string by an array of substrings
+        expr = RegExp.rightContext
+        key  = match[2] ? qstr[match[2]].slice(1, -1).trim().replace(/\s+/g, ' ') : match[1]
 
-  function split(str, substrings) {
-    var parts = []
-    substrings.map(function(sub, i) {
+        while (jsb = (match = re.exec(expr))[1]) skipBraces(jsb, re)
 
-      // push matched expression and part before it
-      i = str.indexOf(sub)
-      parts.push(str.slice(0, i), sub)
-      str = str.slice(i + sub.length)
-    })
-    if (str) parts.push(str)
+        jsb  = expr.slice(0, match.index)
+        expr = RegExp.rightContext
 
-    // push the remaining part
-    return parts
+        list[cnt++] = _wrapExpr(jsb, 1, key)
+      }
+
+      expr = !cnt ? _wrapExpr(expr, asText) :
+          cnt > 1 ? '[' + list.join(',') + '].join(" ").trim()' : list[0]
+    }
+    return expr
+
+    function skipBraces (ch, re) {
+      var
+        mm,
+        lv = 1,
+        ir = RE_BREND[ch]
+
+      ir.lastIndex = re.lastIndex
+      while (mm = ir.exec(expr)) {
+        if (mm[0] === ch) ++lv
+        else if (!--lv) break
+      }
+      re.lastIndex = lv ? expr.length : ir.lastIndex
+    }
   }
 
+  // istanbul ignore next: not both
+  var
+    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(?:[^.[(]|$)/
 
-  // match strings between opening and closing regexp, skipping any inner/nested matches
+  function _wrapExpr (expr, asText, key) {
+    var tb
 
-  function extract(str, open, close) {
+    expr = expr.replace(JS_VARNAME, function (match, p, mvar, pos, s) {
+      if (mvar) {
+        pos = tb ? 0 : pos + match.length
 
-    var start,
-        level = 0,
-        matches = [],
-        re = new RegExp('(' + open.source + ')|(' + close.source + ')', 'g')
+        if (mvar !== 'this' && mvar !== 'global' && mvar !== 'window') {
+          match = p + '("' + mvar + JS_CONTEXT + mvar
+          if (pos) tb = (s = s[pos]) === '.' || s === '(' || s === '['
+        } else if (pos) {
+          tb = !JS_NOPROPS.test(s.slice(pos))
+        }
+      }
+      return match
+    })
 
-    str.replace(re, function(_, open, close, pos) {
+    if (tb) {
+      expr = 'try{return ' + expr + '}catch(e){E(e,this)}'
+    }
 
-      // if outer inner bracket, mark position
-      if (!level && open) start = pos
+    if (key) {
 
-      // in(de)crease bracket level
-      level += open ? 1 : -1
+      expr = (tb ?
+          'function(){' + expr + '}.call(this)' : '(' + expr + ')'
+        ) + '?"' + key + '":""'
 
-      // if outer closing bracket, grab the match
-      if (!level && close != null) matches.push(str.slice(start, pos + close.length))
+    } else if (asText) {
 
-    })
+      expr = 'function(v){' + (tb ?
+          expr.replace('return ', 'v=') : 'v=(' + expr + ')'
+        ) + ';return v||v===0?v:""}.call(this)'
+    }
 
-    return matches
+    return expr
   }
 
+  // istanbul ignore next: compatibility fix for beta versions
+  _tmpl.parse = function (s) { return s }
+
+  _tmpl.version = brackets.version = 'v2.3.21'
+
+  return _tmpl
+
 })()
 
 /*
   lib/browser/tag/mkdom.js
 
-  Includes hacks needed for the Internet Explorer version 9 and bellow
-
+  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/
 */
-// http://kangax.github.io/compat-table/es5/#ie8
-// http://codeplanet.io/dropping-ie8/
-
 var mkdom = (function (checkIE) {
 
-  var rootEls = {
-        'tr': 'tbody',
-        'th': 'tr',
-        'td': 'tr',
-        'tbody': 'table',
-        'col': 'colgroup'
-      },
-      GENERIC = 'div'
+  var
+    reToSrc = /<yield\s+to=(['"])?@\1\s*>([\S\s]+?)<\/yield\s*>/.source,
+    rootEls = { tr: 'tbody', th: 'tr', td: 'tr', col: 'colgroup' },
+    GENERIC = 'div'
 
   checkIE = checkIE && checkIE < 10
+  var tblTags = checkIE
+    ? SPECIAL_TAGS_REGEX : /^(?:t(?:body|head|foot|[rhd])|caption|col(?:group)?)$/
 
   // creates any dom element in a div, table, or colgroup container
-  function _mkdom(html) {
+  function _mkdom(templ, html) {
 
-    var match = html && html.match(/^\s*<([-\w]+)/),
-        tagName = match && match[1].toLowerCase(),
-        rootTag = rootEls[tagName] || GENERIC,
-        el = mkEl(rootTag)
+    var match = templ && templ.match(/^\s*<([-\w]+)/),
+      tagName = match && match[1].toLowerCase(),
+      el = mkEl(GENERIC)
 
-    el.stub = true
+    // replace all the yield tags with the tag inner html
+    templ = replaceYield(templ, html || '')
 
-    if (checkIE && tagName && (match = tagName.match(SPECIAL_TAGS_REGEX)))
-      ie9elem(el, html, tagName, !!match[1])
+    /* istanbul ignore next */
+    //if ((checkIE || !startsWith(tagName, 'opt')) && SPECIAL_TAGS_REGEX.test(tagName))
+    if (tblTags.test(tagName))
+      el = specialTags(el, templ, tagName)
     else
-      el.innerHTML = html
+      el.innerHTML = templ
+
+    el.stub = true
 
     return el
   }
 
-  // creates tr, th, td, option, optgroup element for IE8-9
-  /* istanbul ignore next */
-  function ie9elem(el, html, tagName, select) {
-
-    var div = mkEl(GENERIC),
-        tag = select ? 'select>' : 'table>',
-        child
-
-    div.innerHTML = '<' + tag + html + '</' + tag
+  // creates the root element for table and 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 {
+      var tname = rootEls[tagName]
+      if (tname && parent.children.length === 1) parent = $(tname, parent)
+    }
+    return parent
+  }
 
-    child = div.getElementsByTagName(tagName)[0]
-    if (child)
-      el.appendChild(child)
+  /**
+   * Replace the yield tag from any tag template with the innerHTML of the
+   * original tag in the page
+   * @param   { String } templ - tag implementation template
+   * @param   { String } html  - original content of the tag in the DOM
+   * @returns { String } tag template updated without the yield tag
+   */
+  function replaceYield(templ, html) {
+    // do nothing if no yield
+    if (!/<yield\b/i.test(templ)) return templ
+
+    // be careful with #1343 - string on the source having `$1`
+    var n = 0
+    templ = templ.replace(/<yield\s+from=['"]([-\w]+)['"]\s*(?:\/>|>\s*<\/yield\s*>)/ig,
+      function (str, ref) {
+        var m = html.match(RegExp(reToSrc.replace('@', ref), 'i'))
+        ++n
+        return m && m[2] || ''
+      })
 
+    // yield without any "from", replace yield in templ with the innerHTML
+    return n ? templ : templ.replace(/<yield\s*(?:\/>|>\s*<\/yield\s*>)/gi, html)
   }
-  // end ie9elem()
 
   return _mkdom
 
 })(IE_VERSION)
 
-// { key, i in items} -> { key, i, items }
-function loopKeys(expr) {
-  var b0 = brackets(0),
-      els = expr.trim().slice(b0.length).match(/^\s*(\S+?)\s*(?:,\s*(\S+))?\s+in\s+(.+)$/)
-  return els ? { key: els[1], pos: els[2], val: b0 + els[3] } : { val: expr }
-}
-
+/**
+ * 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
+ * @returns { Object } - new object containing the values of the original item
+ *
+ * The variables 'key' and 'val' are arbitrary.
+ * They depend on the collection type looped (Array, Object)
+ * and on the expression used on the each tag
+ *
+ */
 function mkitem(expr, key, val) {
   var item = {}
   item[expr.key] = key
@@ -489,114 +1011,305 @@ function mkitem(expr, key, val) {
   return item
 }
 
+/**
+ * Unmount the redundant tags
+ * @param   { Array } items - array containing the current items to loop
+ * @param   { Array } tags - array containing all the children tags
+ */
+function unmountRedundant(items, tags) {
+
+  var i = tags.length,
+    j = items.length,
+    t
+
+  while (i > j) {
+    t = tags[--i]
+    tags.splice(i, 1)
+    t.unmount()
+  }
+}
 
-/* Beware: heavy stuff */
+/**
+ * Move the nested custom tags in non custom loop tags
+ * @param   { Object } child - non custom loop 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]
+    if (isArray(tag))
+      each(tag, function (t) {
+        moveChildTag(t, tagName, i)
+      })
+    else
+      moveChildTag(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
+ */
+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
+  }
+}
+
+/**
+ * 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
+  }
+}
+
+
+/**
+ * Manage tags having the 'each'
+ * @param   { Object } 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
+ */
 function _each(dom, parent, expr) {
 
+  // remove the each property from the original tag
   remAttr(dom, 'each')
 
-  var tagName = getTagName(dom),
-      template = dom.outerHTML,
-      hasImpl = !!tagImpl[tagName],
-      impl = tagImpl[tagName] || {
-        tmpl: template
-      },
-      root = dom.parentNode,
-      placeholder = document.createComment('riot placeholder'),
-      tags = [],
-      child = getTag(dom),
-      checksum
+  var mustReorder = typeof getAttr(dom, 'no-reorder') !== T_STRING || remAttr(dom, 'no-reorder'),
+    tagName = getTagName(dom),
+    impl = __tagImpl[tagName] || { tmpl: dom.outerHTML },
+    useRoot = SPECIAL_TAGS_REGEX.test(tagName),
+    root = dom.parentNode,
+    ref = document.createTextNode(''),
+    child = getTag(dom),
+    isOption = /^option$/i.test(tagName), // the option tags must be treated differently
+    tags = [],
+    oldItems = [],
+    hasKeys,
+    isVirtual = dom.tagName == 'VIRTUAL'
+
+  // parse the each expression
+  expr = tmpl.loopKeys(expr)
+
+  // insert a marked where the loop tags will be injected
+  root.insertBefore(ref, dom)
 
-  root.insertBefore(placeholder, dom)
+  // clean template code
+  parent.one('before-mount', function () {
 
-  expr = loopKeys(expr)
+    // remove the original DOM node
+    dom.parentNode.removeChild(dom)
+    if (root.stub) root = parent.root
 
-  // clean template code
-  parent
-    .one('premount', function () {
-      if (root.stub) root = parent.root
-      // remove the original DOM node
-      dom.parentNode.removeChild(dom)
-    })
-    .on('update', function () {
-      var items = tmpl(expr.val, parent)
+  }).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()
 
-      // object loop. any changes cause full redraw
-      if (!isArray(items)) {
 
-        checksum = items ? JSON.stringify(items) : ''
 
-        items = !items ? [] :
-          Object.keys(items).map(function (key) {
-            return mkitem(expr, key, items[key])
-          })
-      }
+    // object loop. any changes cause full redraw
+    if (!isArray(items)) {
+      hasKeys = items || false
+      items = hasKeys ?
+        Object.keys(items).map(function (key) {
+          return mkitem(expr, key, items[key])
+        }) : []
+    }
 
-      var frag = document.createDocumentFragment(),
-          i = tags.length,
-          j = items.length
+    // loop all the new items
+    items.forEach(function(item, i) {
+      // reorder only if the items are objects
+      var _mustReorder = mustReorder && item instanceof Object,
+        oldPos = oldItems.indexOf(item),
+        pos = ~oldPos && _mustReorder ? oldPos : i,
+        // does a tag exist in this position?
+        tag = tags[pos]
+
+      item = !hasKeys && expr.key ? mkitem(expr, item, i) : item
+
+      // new tag
+      if (
+        !_mustReorder && !tag // with no-reorder we just update the old tags
+        ||
+        _mustReorder && !~oldPos || !tag // by default we always try to reorder the DOM elements
+      ) {
+
+        tag = new Tag(impl, {
+          parent: parent,
+          isLoop: true,
+          hasImpl: !!__tagImpl[tagName],
+          root: useRoot ? root : dom.cloneNode(),
+          item: item
+        }, dom.innerHTML)
+
+        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) {
+          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)
+          oldItems.splice(i, 0, item)
+        }
 
-      // unmount leftover items
-      while (i > j) {
-        tags[--i].unmount()
-        tags.splice(i, 1)
+        tags.splice(i, 0, tag)
+        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) {
+        // update the DOM
+        if (isVirtual)
+          moveVirtual(tag, root, tags[i], dom.childNodes.length)
+        else root.insertBefore(tag.root, tags[i].root)
+        // update the position attribute if it exists
+        if (expr.pos)
+          tag[expr.pos] = i
+        // move the old tag instance
+        tags.splice(i, 0, tags.splice(pos, 1)[0])
+        // move the old item
+        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)
       }
 
-      for (i = 0; i < j; ++i) {
-        var _item = !checksum && !!expr.key ? mkitem(expr, items[i], i) : items[i]
+      // cache the original item to use it in the events bound to this node
+      // and its children
+      tag._item = item
+      // cache the real parent tag internally
+      defineProperty(tag, '_parent', parent)
 
-        if (!tags[i]) {
-          // mount new
-          (tags[i] = new Tag(impl, {
-              parent: parent,
-              isLoop: true,
-              hasImpl: hasImpl,
-              root: SPECIAL_TAGS_REGEX.test(tagName) ? root : dom.cloneNode(),
-              item: _item
-            }, dom.innerHTML)
-          ).mount()
+    })
 
-          frag.appendChild(tags[i].root)
-        } else
-          tags[i].update(_item)
+    // remove the redundant tags
+    unmountRedundant(items, tags)
 
-        tags[i]._item = _item
+    // insert the new nodes
+    if (isOption) root.appendChild(frag)
+    else root.insertBefore(frag, ref)
 
-      }
+    // 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
 
-      root.insertBefore(frag, placeholder)
+    // clone the items array
+    oldItems = items.slice()
 
-      if (child) parent.tags[tagName] = tags
-
-    }).one('updated', function() {
-      var keys = Object.keys(parent)// only set new values
-      walk(root, function(node) {
-        // only set element node and not isLoop
-        if (node.nodeType == 1 && !node.isLoop && !node._looped) {
-          node._visited = false // reset _visited for loop node
-          node._looped = true // avoid set multiple each
-          setNamed(node, parent, keys)
-        }
-      })
-    })
+  })
 
 }
+/**
+ * Object that will be used to inject and manage the css of every tag instance
+ */
+var styleManager = (function(_riot) {
+
+  if (!window) return { // skip injection on the server
+    add: function () {},
+    inject: function () {}
+  }
+
+  var 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
+  })()
 
-function parseNamedElements(root, tag, childTags) {
+  // Create cache and shortcut to the correct property
+  var cssTextProp = styleNode.styleSheet,
+    stylesToInject = ''
+
+  // Expose the style node in a non-modificable property
+  Object.defineProperty(_riot, 'styleNode', {
+    value: styleNode,
+    writable: true
+  })
+
+  /**
+   * 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 = ''
+      }
+    }
+  }
+
+})(riot)
+
+
+function parseNamedElements(root, tag, childTags, forceParsingNamed) {
 
   walk(root, function(dom) {
     if (dom.nodeType == 1) {
-      dom.isLoop = dom.isLoop || (dom.parentNode && dom.parentNode.isLoop || dom.getAttribute('each')) ? 1 : 0
+      dom.isLoop = dom.isLoop ||
+                  (dom.parentNode && dom.parentNode.isLoop || getAttr(dom, 'each'))
+                    ? 1 : 0
 
       // custom child tag
-      var child = getTag(dom)
+      if (childTags) {
+        var child = getTag(dom)
 
-      if (child && !dom.isLoop) {
-        childTags.push(initChildTag(child, dom, tag))
+        if (child && !dom.isLoop)
+          childTags.push(initChildTag(child, {root: dom, parent: tag}, dom.innerHTML, tag))
       }
 
-      if (!dom.isLoop)
+      if (!dom.isLoop || forceParsingNamed)
         setNamed(dom, tag, [])
     }
 
@@ -607,14 +1320,14 @@ function parseNamedElements(root, tag, childTags) {
 function parseExpressions(root, tag, expressions) {
 
   function addExpr(dom, val, extra) {
-    if (val.indexOf(brackets(0)) >= 0) {
-      var expr = { dom: dom, expr: val }
-      expressions.push(extend(expr, extra))
+    if (tmpl.hasExpr(val)) {
+      expressions.push(extend({ dom: dom, expr: val }, extra))
     }
   }
 
   walk(root, function(dom) {
-    var type = dom.nodeType
+    var type = dom.nodeType,
+      attr
 
     // text node
     if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)
@@ -623,7 +1336,7 @@ function parseExpressions(root, tag, expressions) {
     /* element */
 
     // loop
-    var attr = dom.getAttribute('each')
+    attr = getAttr(dom, 'each')
 
     if (attr) { _each(dom, tag, attr); return false }
 
@@ -646,23 +1359,21 @@ function parseExpressions(root, tag, expressions) {
 function Tag(impl, conf, innerHTML) {
 
   var self = riot.observable(this),
-      opts = inherit(conf.opts) || {},
-      dom = mkdom(impl.tmpl),
-      parent = conf.parent,
-      isLoop = conf.isLoop,
-      hasImpl = conf.hasImpl,
-      item = cleanUpData(conf.item),
-      expressions = [],
-      childTags = [],
-      root = conf.root,
-      fn = impl.fn,
-      tagName = root.tagName.toLowerCase(),
-      attr = {},
-      propsInSyncWithParent = []
-
-  if (fn && root._tag) {
-    root._tag.unmount(true)
-  }
+    opts = inherit(conf.opts) || {},
+    parent = conf.parent,
+    isLoop = conf.isLoop,
+    hasImpl = conf.hasImpl,
+    item = cleanUpData(conf.item),
+    expressions = [],
+    childTags = [],
+    root = conf.root,
+    fn = impl.fn,
+    tagName = root.tagName.toLowerCase(),
+    attr = {},
+    propsInSyncWithParent = [],
+    dom
+
+  if (fn && root._tag) root._tag.unmount(true)
 
   // not yet mounted
   this.isMounted = false
@@ -674,7 +1385,7 @@ function Tag(impl, conf, innerHTML) {
 
   // create a unique id to this tag
   // it could be handy to use it also to improve the virtual dom rendering speed
-  this._id = __uid++
+  defineProperty(this, '_riot_id', ++__uid) // base 1 allows test !t._riot_id
 
   extend(this, { parent: parent, root: root, opts: opts, tags: {} }, item)
 
@@ -682,12 +1393,10 @@ function Tag(impl, conf, innerHTML) {
   each(root.attributes, function(el) {
     var val = el.value
     // remember attributes with expressions only
-    if (brackets(/{.*}/).test(val)) attr[el.name] = val
+    if (tmpl.hasExpr(val)) attr[el.name] = val
   })
 
-  if (dom.innerHTML && !/^(select|optgroup|table|tbody|tr|col(?:group)?)$/.test(tagName))
-    // replace all the yield tags with the tag inner html
-    dom.innerHTML = replaceYield(dom.innerHTML, innerHTML)
+  dom = mkdom(impl.tmpl, innerHTML)
 
   // options
   function updateOpts() {
@@ -695,17 +1404,18 @@ function Tag(impl, conf, innerHTML) {
 
     // update opts from current DOM attributes
     each(root.attributes, function(el) {
-      opts[el.name] = tmpl(el.value, ctx)
+      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[name] = tmpl(attr[name], ctx)
+      opts[toCamel(name)] = tmpl(attr[name], ctx)
     })
   }
 
   function normalizeData(data) {
     for (var key in item) {
-      if (typeof self[key] !== T_UNDEF)
+      if (typeof self[key] !== T_UNDEF && isWritable(self, key))
         self[key] = data[key]
     }
   }
@@ -714,7 +1424,7 @@ function Tag(impl, conf, innerHTML) {
     if (!self.parent || !isLoop) return
     each(Object.keys(self.parent), function(k) {
       // some properties must be always in sync with the parent tag
-      var mustSync = !~RESERVED_WORDS_BLACKLIST.indexOf(k) && ~propsInSyncWithParent.indexOf(k)
+      var mustSync = !contains(RESERVED_WORDS_BLACKLIST, k) && contains(propsInSyncWithParent, k)
       if (typeof self[k] === T_UNDEF || mustSync) {
         // track the property to keep in sync
         // so we can keep it updated
@@ -724,7 +1434,8 @@ function Tag(impl, conf, innerHTML) {
     })
   }
 
-  this.update = function(data) {
+  defineProperty(this, 'update', function(data) {
+
     // make sure the data passed will not override
     // the component core methods
     data = cleanUpData(data)
@@ -739,23 +1450,44 @@ function Tag(impl, conf, innerHTML) {
     updateOpts()
     self.trigger('update', data)
     update(expressions, self)
-    self.trigger('updated')
-  }
+    // the updated event will be triggered
+    // once the DOM will be ready and all the reflows are completed
+    // this is useful if you want to get the "real" root properties
+    // 4 ex: root.offsetWidth ...
+    rAF(function() { self.trigger('updated') })
+    return this
+  })
 
-  this.mixin = function() {
+  defineProperty(this, 'mixin', function() {
     each(arguments, function(mix) {
+      var instance
+
       mix = typeof mix === T_STRING ? riot.mixin(mix) : mix
-      each(Object.keys(mix), function(key) {
+
+      // check if the mixin is a function
+      if (isFunction(mix)) {
+        // create the new mixin instance
+        instance = new mix()
+        // save the prototype to loop it afterwards
+        mix = mix.prototype
+      } else instance = mix
+
+      // loop the keys in the function prototype or the all object keys
+      each(Object.getOwnPropertyNames(mix), function(key) {
         // bind methods to self
         if (key != 'init')
-          self[key] = isFunction(mix[key]) ? mix[key].bind(self) : mix[key]
+          self[key] = isFunction(instance[key]) ?
+                        instance[key].bind(self) :
+                        instance[key]
       })
+
       // init method will be called automatically
-      if (mix.init) mix.init.bind(self)()
+      if (instance.init) instance.init.bind(self)()
     })
-  }
+    return this
+  })
 
-  this.mount = function() {
+  defineProperty(this, 'mount', function() {
 
     updateOpts()
 
@@ -771,14 +1503,14 @@ function Tag(impl, conf, innerHTML) {
     // update the root adding custom attributes coming from the compiler
     // it fixes also #1087
     if (impl.attrs || hasImpl) {
-      walkAttributes(impl.attrs, function (k, v) { root.setAttribute(k, v) })
+      walkAttributes(impl.attrs, function (k, v) { setAttr(root, k, v) })
       parseExpressions(self.root, self, expressions)
     }
 
     if (!self.parent || isLoop) self.update(item)
 
     // internal use only, fixes #403
-    self.trigger('premount')
+    self.trigger('before-mount')
 
     if (isLoop && !hasImpl) {
       // update the root attribute for the looped elements
@@ -788,6 +1520,12 @@ function Tag(impl, conf, innerHTML) {
       while (dom.firstChild) root.appendChild(dom.firstChild)
       if (root.stub) self.root = root = parent.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)
+
     // if it's not a child tag we can trigger its mount event
     if (!self.parent || self.parent.isMounted) {
       self.isMounted = true
@@ -802,13 +1540,26 @@ function Tag(impl, conf, innerHTML) {
         self.trigger('mount')
       }
     })
-  }
+  })
 
 
-  this.unmount = function(keepRootTag) {
+  defineProperty(this, 'unmount', function(keepRootTag) {
     var el = root,
-        p = el.parentNode,
-        ptag
+      p = el.parentNode,
+      ptag,
+      tagIndex = __virtualDom.indexOf(self)
+
+    self.trigger('before-unmount')
+
+    // remove this tag instance from the global virtualDom variable
+    if (~tagIndex)
+      __virtualDom.splice(tagIndex, 1)
+
+    if (this._virts) {
+      each(this._virts, function(v) {
+        if (v.parentNode) v.parentNode.removeChild(v)
+      })
+    }
 
     if (p) {
 
@@ -819,7 +1570,7 @@ function Tag(impl, conf, innerHTML) {
         // remove this element form the array
         if (isArray(ptag.tags[tagName]))
           each(ptag.tags[tagName], function(tag, i) {
-            if (tag._id == self._id)
+            if (tag._riot_id == self._riot_id)
               ptag.tags[tagName].splice(i, 1)
           })
         else
@@ -834,17 +1585,17 @@ function Tag(impl, conf, innerHTML) {
         p.removeChild(el)
       else
         // the riot-tag attribute isn't needed anymore, remove it
-        p.removeAttribute('riot-tag')
+        remAttr(p, 'riot-tag')
     }
 
 
     self.trigger('unmount')
     toggle()
     self.off('*')
-    // somehow ie8 does not like `delete root._tag`
-    root._tag = null
+    self.isMounted = false
+    delete root._tag
 
-  }
+  })
 
   function toggle(isMount) {
 
@@ -852,46 +1603,48 @@ function Tag(impl, conf, innerHTML) {
     each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })
 
     // listen/unlisten parent (events flow one way from parent to children)
-    if (parent) {
-      var evt = isMount ? 'on' : 'off'
+    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', self.update)[evt]('unmount', self.unmount)
-    }
+    // the loop tags will be always in sync with the parent automatically
+    if (isLoop)
+      parent[evt]('unmount', self.unmount)
+    else
+      parent[evt]('update', self.update)[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 item = tag._item,
-        ptag = tag.parent,
-        el
+    var ptag = tag._parent,
+      item = tag._item,
+      el
 
     if (!item)
       while (ptag && !item) {
         item = ptag._item
-        ptag = ptag.parent
+        ptag = ptag._parent
       }
 
     // cross browser event fix
     e = e || window.event
 
-    // ignore error on some browsers
-    try {
-      e.currentTarget = dom
-      if (!e.target) e.target = e.srcElement
-      if (!e.which) e.which = e.charCode || e.keyCode
-    } catch (ignored) { /**/ }
+    // 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
 
@@ -910,22 +1663,32 @@ function setEventHandler(name, handler, dom, tag) {
 
 }
 
-// used by if- attribute
+
+/**
+ * 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) {
-    root.insertBefore(before, node)
-    root.removeChild(node)
-  }
+  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.dom.parentNode
+      attrName = expr.attr,
+      value = tmpl(expr.expr, tag),
+      parent = expr.dom.parentNode
 
     if (expr.bool)
       value = value ? attrName : false
@@ -934,7 +1697,11 @@ function update(expressions, tag) {
 
     // leave out riot- prefixes from strings inside textarea
     // fix #815: any value -> string
-    if (parent && parent.tagName == 'TEXTAREA') value = ('' + value).replace(/riot-/g, '')
+    if (parent && parent.tagName == 'TEXTAREA') {
+      value = ('' + value).replace(/riot-/g, '')
+      // change textarea's value
+      parent.value = value
+    }
 
     // no change
     if (expr.value === value) return
@@ -955,8 +1722,8 @@ function update(expressions, 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 = function() { insertTo(stub.parentNode, stub, dom) },
+        remove = function() { insertTo(dom.parentNode, dom, stub) }
 
       // add to DOM
       if (value) {
@@ -967,7 +1734,8 @@ function update(expressions, tag) {
           // 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')
+              if (el._tag && !el._tag.isMounted)
+                el._tag.isMounted = !!el._tag.trigger('mount')
             })
           }
         }
@@ -977,9 +1745,8 @@ function update(expressions, tag) {
         // if the parentNode is defined we can easily replace the tag
         if (dom.parentNode)
           remove()
-        else
         // otherwise we need to wait the updated event
-          (tag.parent || tag).one('updated', remove)
+        else (tag.parent || tag).one('updated', remove)
 
         dom.inStub = true
       }
@@ -995,7 +1762,7 @@ function update(expressions, tag) {
     // <img src="{ expr }">
     } else if (startsWith(attrName, RIOT_PREFIX) && attrName != RIOT_TAG) {
       if (value)
-        dom.setAttribute(attrName.slice(RIOT_PREFIX.length), value)
+        setAttr(dom, attrName.slice(RIOT_PREFIX.length), value)
 
     } else {
       if (expr.bool) {
@@ -1003,65 +1770,168 @@ function update(expressions, tag) {
         if (!value) return
       }
 
-      if (typeof value !== T_OBJECT) dom.setAttribute(attrName, value)
+      if (value === 0 || value && typeof value !== T_OBJECT)
+        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) {
-  for (var i = 0, len = (els || []).length, el; i < len; i++) {
+  var len = els ? els.length : 0
+
+  for (var i = 0, el; i < len; i++) {
     el = els[i]
-    // return false -> remove current item during loop
+    // 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
 }
 
+/**
+ * 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)
 }
 
-function getTag(dom) {
-  return dom.tagName && tagImpl[dom.getAttribute(RIOT_TAG) || dom.tagName.toLowerCase()]
+/**
+ * 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()
+  })
 }
 
-function initChildTag(child, dom, parent) {
-  var tag = new Tag(child, { root: dom, parent: parent }, dom.innerHTML),
-      tagName = getTagName(dom),
-      ptag = getImmediateCustomParentTag(parent),
-      cachedTag
+/**
+ * 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)
+}
 
-  // fix for the parent attribute in the looped elements
-  tag.parent = ptag
+/**
+ * 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
+ */
+function setAttr(dom, name, val) {
+  dom.setAttribute(name, val)
+}
 
-  cachedTag = ptag.tags[tagName]
+/**
+ * Detect the tag implementation by a DOM node
+ * @param   { Object } dom - DOM node we need to parse to get its tag implementation
+ * @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) || 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))
-      ptag.tags[tagName] = [cachedTag]
+      // don't add the same tag twice
+      if (cachedTag !== tag)
+        parent.tags[tagName] = [cachedTag]
     // add the new nested tag to the array
-    if (!~ptag.tags[tagName].indexOf(tag))
-      ptag.tags[tagName].push(tag)
+    if (!contains(parent.tags[tagName], tag))
+      parent.tags[tagName].push(tag)
   } else {
-    ptag.tags[tagName] = tag
+    parent.tags[tagName] = tag
   }
+}
+
+/**
+ * Move the position of a custom tag in its parent tag
+ * @param   { Object } tag - child tag instance
+ * @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
+  // no parent no move
+  if (!parent) return
+
+  tags = parent.tags[tagName]
+
+  if (isArray(tags))
+    tags.splice(newPos, 0, tags.splice(tags.indexOf(tag), 1)[0])
+  else addChildTag(tag, tagName, parent)
+}
 
+/**
+ * Create a new child tag including it correctly into its parent
+ * @param   { Object } child - child tag implementation
+ * @param   { Object } opts - tag options containing the DOM node where the tag will be mounted
+ * @param   { String } innerHTML - inner html of the child node
+ * @param   { Object } parent - instance of the parent tag including the child custom tag
+ * @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)
+  // fix for the parent attribute in the looped elements
+  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
+
+  // add this tag to the custom parent tag
+  addChildTag(tag, tagName, ptag)
+  // and also to the real parent tag
+  if (ptag !== parent)
+    addChildTag(tag, tagName, parent)
   // empty the child node once we got its template
   // to avoid that its children get compiled multiple times
-  dom.innerHTML = ''
+  opts.root.innerHTML = ''
 
   return tag
 }
 
+/**
+ * Loop backward all the parents tree to detect the first custom parent tag
+ * @param   { Object } tag - a Tag instance
+ * @returns { Object } the instance of the first custom parent tag found
+ */
 function getImmediateCustomParentTag(tag) {
   var ptag = tag
   while (!getTag(ptag.root)) {
@@ -1071,40 +1941,117 @@ function getImmediateCustomParentTag(tag) {
   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
+ */
+function defineProperty(el, key, value, options) {
+  Object.defineProperty(el, key, extend({
+    value: value,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  }, options))
+  return el
+}
+
+/**
+ * Get the tag name of any DOM node
+ * @param   { Object } dom - DOM node we want to parse
+ * @returns { String } name to identify this dom node in riot
+ */
 function getTagName(dom) {
   var child = getTag(dom),
-    namedTag = dom.getAttribute('name'),
-    tagName = namedTag && namedTag.indexOf(brackets(0)) < 0 ? namedTag : child ? child.name : dom.tagName.toLowerCase()
+    namedTag = getAttr(dom, 'name'),
+    tagName = 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) {      // eslint-disable-line guard-for-in
-        src[key] = obj[key]
+    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
 }
 
-// with this function we avoid that the current Tag methods get overridden
+/**
+ * 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) && !(data && typeof data.trigger == T_FUNCTION))
+    return data
 
   var o = {}
   for (var key in data) {
-    if (!~RESERVED_WORDS_BLACKLIST.indexOf(key))
+    if (!contains(RESERVED_WORDS_BLACKLIST, 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
+ */
 function walk(dom, fn) {
   if (dom) {
+    // stop the recursion
     if (fn(dom) === false) return
     else {
       dom = dom.firstChild
@@ -1117,16 +2064,25 @@ function walk(dom, fn) {
   }
 }
 
-// minimize risk: only zero or one _space_ between attr & 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
+    re = /([-\w]+) ?= ?(?:"([^"]*)|'([^']*)|({[^}]*}))/g
 
-  while ((m = re.exec(html))) {
+  while (m = re.exec(html)) {
     fn(m[1].toLowerCase(), m[2] || m[3] || m[4])
   }
 }
 
+/**
+ * Check whether a DOM node is in stub mode, useful for the riot 'if' directive
+ * @param   { Object }  dom - DOM node we want to parse
+ * @returns { Boolean } -
+ */
 function isInStub(dom) {
   while (dom) {
     if (dom.inStub) return true
@@ -1135,97 +2091,141 @@ function isInStub(dom) {
   return false
 }
 
+/**
+ * Create a generic DOM node
+ * @param   { String } name - name of the DOM node we want to create
+ * @returns { Object } DOM node just created
+ */
 function mkEl(name) {
   return document.createElement(name)
 }
 
-function replaceYield(tmpl, innerHTML) {
-  return tmpl.replace(/<(yield)\/?>(<\/\1>)?/gi, innerHTML || '')
-}
-
+/**
+ * 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) {
-  if (dom._visited) return
-  var p,
-      v = dom.getAttribute('id') || dom.getAttribute('name')
-
-  if (v) {
-    if (keys.indexOf(v) < 0) {
-      p = parent[v]
-      if (!p)
-        parent[v] = dom
-      else if (isArray(p))
-        p.push(dom)
-      else
-        parent[v] = [p, dom]
+  // 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]
+      }
     }
-    dom._visited = true
-  }
+
+  // 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
+/**
+ * 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
 }
 
-/*
- Virtual dom is an array of custom tags on the document.
- Updates and unmounts propagate downwards from parent to children.
-*/
-
-var virtualDom = [],
-    tagImpl = {},
-    styleNode
-
-function injectStyle(css) {
-
-  if (riot.render) return // skip injection on the server
-
-  if (!styleNode) {
-    styleNode = mkEl('style')
-    styleNode.setAttribute('type', 'text/css')
-  }
-
-  var head = document.head || document.getElementsByTagName('head')[0]
-
-  if (styleNode.styleSheet)
-    styleNode.styleSheet.cssText += css
-  else
-    styleNode.innerHTML += css
+/**
+ * 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 (!styleNode._rendered)
-    if (styleNode.styleSheet) {
-      document.body.appendChild(styleNode)
-    } else {
-      var rs = $('style[type=riot]')
-      if (rs) {
-        rs.parentNode.insertBefore(styleNode, rs)
-        rs.parentNode.removeChild(rs)
-      } else head.appendChild(styleNode)
+  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
 
-  styleNode._rendered = true
-
-}
+})(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
+ * @returns { Tag } a new Tag instance
+ */
 function mountTo(root, tagName, opts) {
-  var tag = tagImpl[tagName],
-      // cache the inner HTML to fix #855
-      innerHTML = root._innerHTML = root._innerHTML || root.innerHTML
+  var tag = __tagImpl[tagName],
+    // cache the inner HTML to fix #855
+    innerHTML = root._innerHTML = root._innerHTML || root.innerHTML
 
   // clear the inner html
   root.innerHTML = ''
@@ -1234,14 +2234,47 @@ function mountTo(root, tagName, opts) {
 
   if (tag && tag.mount) {
     tag.mount()
-    virtualDom.push(tag)
-    return tag.on('unmount', function() {
-      virtualDom.splice(virtualDom.indexOf(tag), 1)
-    })
+    // add this tag to the virtualDom variable
+    if (!contains(__virtualDom, tag)) __virtualDom.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
+ */
+riot.mixin = (function() {
+  var mixins = {}
 
+  /**
+   * Create/Return a mixin by its name
+   * @param   { String } name - mixin name
+   * @param   { Object } mixin - mixin logic
+   * @returns { Object } the mixin logic
+   */
+  return function(name, mixin) {
+    if (!mixin) return mixins[name]
+    mixins[name] = mixin
+  }
+
+})()
+
+/**
+ * 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
@@ -1252,51 +2285,78 @@ riot.tag = function(name, html, css, attrs, fn) {
   }
   if (css) {
     if (isFunction(css)) fn = css
-    else injectStyle(css)
+    else styleManager.add(css)
   }
-  tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
+  __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
+ * @param   { string }  [bpair] - brackets used in the compilation
+ * @returns { String } name/id of the tag just created
+ */
+riot.tag2 = function(name, html, css, attrs, fn, bpair) {
+  if (css) styleManager.add(css)
+  //if (bpair) riot.settings.brackets = bpair
+  __tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
   return name
 }
 
+/**
+ * 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
+ */
 riot.mount = function(selector, tagName, opts) {
 
   var els,
-      allTags,
-      tags = []
+    allTags,
+    tags = []
 
   // helper functions
 
   function addRiotTags(arr) {
     var list = ''
     each(arr, function (e) {
-      list += ', *[' + RIOT_TAG + '="' + e.trim() + '"]'
+      if (!/[^-\w]/.test(e))
+        list += ',*[' + RIOT_TAG + '=' + e.trim() + ']'
     })
     return list
   }
 
   function selectAllTags() {
-    var keys = Object.keys(tagImpl)
+    var keys = Object.keys(__tagImpl)
     return keys + addRiotTags(keys)
   }
 
   function pushTags(root) {
     var last
+
     if (root.tagName) {
-      if (tagName && (!(last = root.getAttribute(RIOT_TAG)) || last != tagName))
-        root.setAttribute(RIOT_TAG, tagName)
+      if (tagName && (!(last = getAttr(root, RIOT_TAG)) || last != tagName))
+        setAttr(root, RIOT_TAG, tagName)
 
-      var tag = mountTo(root,
-        tagName || root.getAttribute(RIOT_TAG) || root.tagName.toLowerCase(), opts)
+      var tag = mountTo(root, tagName || root.getAttribute(RIOT_TAG) || root.tagName.toLowerCase(), opts)
 
       if (tag) tags.push(tag)
-    }
-    else if (root.length) {
+    } else if (root.length)
       each(root, pushTags)   // assume nodeList
-    }
+
   }
 
   // ----- mount code -----
 
+  // inject styles into DOM
+  styleManager.inject()
+
   if (typeof tagName === T_OBJECT) {
     opts = tagName
     tagName = 0
@@ -1312,7 +2372,9 @@ riot.mount = function(selector, tagName, opts) {
       // or just the ones named like the selector
       selector += addRiotTags(selector.split(','))
 
-    els = $$(selector)
+    // 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
@@ -1345,25 +2407,26 @@ riot.mount = function(selector, tagName, opts) {
   return tags
 }
 
-// update everything
+/**
+ * Update all the tags instances created
+ * @returns { Array } all the tags instances
+ */
 riot.update = function() {
-  return each(virtualDom, function(tag) {
+  return each(__virtualDom, function(tag) {
     tag.update()
   })
 }
 
-// @deprecated
-riot.mountTo = riot.mount
-
-  // share methods for other riot parts, e.g. compiler
-  riot.util = { brackets: brackets, tmpl: tmpl }
-
+/**
+ * Export the Tag constructor
+ */
+riot.Tag = Tag
   // support CommonJS, AMD & browser
   /* istanbul ignore next */
   if (typeof exports === T_OBJECT)
     module.exports = riot
-  else if (typeof define === 'function' && define.amd)
-    define(function() { return (window.riot = riot) })
+  else if (typeof define === T_FUNCTION && typeof define.amd !== T_UNDEF)
+    define(function() { return riot })
   else
     window.riot = riot