├── .gitignore
├── CHANGELOG.md
├── LICENSE
├── README.md
├── package.json
├── require.js
└── test
    ├── a.js
    ├── b.js
    ├── c
        └── c.js
    ├── d.js
    ├── lib
        └── jade.js
    ├── page.jade
    ├── riot
        ├── compiler.js
        ├── riot.js
        ├── test.riot.html
        ├── todo.css
        └── todo.tag
    ├── style.css
    ├── test.html
    └── text.txt


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | *.log
3 | .DS_Store


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | 1.0.2
2 | =====
3 | 
4 | * added working tests for jade, riot, css
5 | 
6 | 1.01
7 | ====
8 | 
9 | * Added compiler handler based on extension


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 weepy
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # require
 2 | 
 3 | Dropin `require` polyfill for the browser
 4 | 
 5 | Really useful in development for when you don't want to crank up browserify.
 6 | 
 7 | Super simple.
 8 | 
 9 | Fully swappable with browserify and friends in production.
10 | 
11 | # Installation
12 | 
13 | 1) Include the script and serve it (it won't work direct from the filesystem due to browser security)
14 | 
15 | 
16 | ```
17 | <script src='require.js'></script>
18 | ```
19 | 
20 | or use it direct from rawgit
21 | 
22 | ```
23 | <script src='//rawgit.com/weepy/brequire/master/require.js'></script>
24 | ```
25 | 
26 | 
27 | 2) Code like a boss
28 | 
29 | 3) You can optionally include the PARSEJS library which will help point point any syntax errors in your code whilst
30 | 
31 | # Compilers
32 | 
33 | You can add compilers for coffeescript, css, JSX or whatever in very simply by registering a handler like 
34 | 
35 | ```
36 | require.compilers.css = function(text) {
37 | 
38 |     var style = document.createElement('style');
39 | 	style.appendChild(document.createTextNode(text));
40 | 	document.head.appendChild(style);
41 | }
42 | ```
43 | 
44 | This will allow you to include css on page like :
45 | 
46 | ```
47 | require("./style.css")
48 | ```
49 | 
50 | 
51 | # Production
52 | 
53 | It uses Sync XHR which is great for development, but not so much in production.
54 | 
55 | Forunately, you can swap out this library with browserify or similar in production.
56 | 
57 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "brequire",
 3 |   "version": "1.0.2",
 4 |   "repo": "https://github.com/weepy/brequire",
 5 |   "description": "Dropin require polyfill for the browser. Also supports compilation, e.g. babel, css, JSX",
 6 |   "main": "require.js",
 7 |   "author": "weepy",
 8 |   "license": "MIT"
 9 | }
10 | 


--------------------------------------------------------------------------------
/require.js:
--------------------------------------------------------------------------------
  1 | 
  2 | ;(function(root) {
  3 | 
  4 |   function require(p) {
  5 |       var path = require.resolve(p)
  6 |         , mod = require.modules[path];
  7 | 
  8 |       // weepy: following line added
  9 |       if (!mod) mod = require.load(path); 
 10 | 
 11 |       if (!mod) throw new Error('failed to require "' + p + '"');
 12 | 
 13 |       if (!mod.exports) {
 14 |         mod.exports = {};
 15 | 
 16 |         // weepy: added __filename and __dirname
 17 |         var bits = path.split('/')
 18 |           , __filename = bits.pop() + '.js'
 19 |           , __dirname = bits.join('/')
 20 | 
 21 |         
 22 |         mod.call(null, mod, mod.exports, require.relative(path), __filename, __dirname);
 23 |       }
 24 |       return mod.exports;
 25 |     }
 26 | 
 27 |   require.modules = {};
 28 | 
 29 |   require.prefix = ""
 30 | 
 31 |   require.resolve = function (path){
 32 |       path = require.prefix + path
 33 |       var orig = path
 34 |         , reg = path + '.js'
 35 |         , index = path + '/index.js';
 36 |       return require.modules[reg] && reg
 37 |         || require.modules[index] && index
 38 |         || orig;
 39 |     };
 40 | 
 41 |   require.register = function (path, fn){
 42 |       require.modules[path] = fn;
 43 |     };
 44 | 
 45 |   require.relative = function (parent) {
 46 |       return function(p){
 47 |         if ('.' != p.charAt(0)) return require(p);
 48 | 
 49 |         var path = parent.split('/')
 50 |           , segs = p.split('/');
 51 |         path.pop();
 52 | 
 53 | 
 54 |         var relative_path = path.concat(segs)
 55 |         var normalized = []
 56 | 
 57 |         for (var i = 0; i < relative_path.length; i++) {
 58 |           var seg = relative_path[i];
 59 | 
 60 |           if ('..' == seg && normalized.length && normalized[normalized.length-1].charAt(0) != ".") {
 61 |             normalized.pop();
 62 |           }
 63 |           else if('.' == seg && normalized.length) {
 64 |             //
 65 |           }
 66 |           else
 67 |             normalized.push(seg)
 68 |         }
 69 | 
 70 |         return require(normalized.join('/'));
 71 |       };
 72 |     };
 73 | 
 74 | 
 75 |   var compilers = require.compilers = {
 76 |     js: function(text) {
 77 |       return text
 78 |     },
 79 |     json: function(text) {
 80 |         try {
 81 |           JSON.parse(text)
 82 |         } catch(e) {
 83 |           console.error("BAD JSON @ " + text, e)
 84 |           return  
 85 |         }
 86 |         return "module.exports = " + text
 87 |     },
 88 |     txt: function(text) {
 89 |         return "module.exports = " + JSON.stringify(text)
 90 |     }
 91 |   }
 92 | 
 93 |   // weepy: following added
 94 |   require.load = function( path ) {
 95 | 
 96 |       var orig_path = path
 97 |       var request = new XMLHttpRequest();
 98 |       
 99 |       if(path.match(/\.[^./]+$/)) {
100 |         // has extension
101 | 
102 |       } else {
103 |         path += ".js"
104 |       }
105 | 
106 |       var ext = path.split(".").pop()
107 | 
108 |       request.open('GET', path, false);
109 |       request.send();          
110 |       var data = request.responseText;
111 | 
112 |       if(!request.responseText || !request.responseText.length)
113 |         console.log("FAILED to load ", path)
114 |       
115 |       console.log("xhr: ", path, " loaded ", request.responseText.length, " bytes")
116 | 
117 |       var compiler = compilers[ext] || compilers.txt
118 | 
119 |       var output = compiler(data) || ""
120 | 
121 |     
122 |       var text = "require.register('" + orig_path + "', \
123 |               function(module, exports, require, __filename, __dirname) {\n\n" 
124 |               + output+ "\n\n\
125 |             }); //@ sourceURL=" + path;    
126 | 
127 |       try {
128 |         (window.execScript || function(text) {
129 |             return window["eval"].call(window, text)
130 |         })(text)
131 |         
132 |       }
133 |       catch(e) {
134 |         if(root.PARSEJS) {
135 |           try {
136 |             root.PARSEJS.parse(text)  
137 |           } catch(e) {
138 |             console.error('Syntax error in file ' + path + ' at line:' + (e.line-2) + ', col:' + e.col + '. ' + e.message) //, e.stack) //, e)
139 |           }
140 |         } else {
141 |           console.error( "Syntax Error in file " + path + ": " + e.toString() )
142 |         }
143 |       }        
144 |     
145 | 
146 | 
147 | 
148 | 
149 |       return require.modules[ orig_path ];
150 |     }
151 | 
152 |   root.require = require; 
153 | 
154 | })(window);
155 | 


--------------------------------------------------------------------------------
/test/a.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   hello: "world",
3 |   boo: require('./c/c')
4 | }


--------------------------------------------------------------------------------
/test/b.js:
--------------------------------------------------------------------------------
1 | require("./a")
2 | 
3 | module.exports = require('./a')


--------------------------------------------------------------------------------
/test/c/c.js:
--------------------------------------------------------------------------------
1 | exports.boo = "boo"


--------------------------------------------------------------------------------
/test/d.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   a: 1
3 | }


--------------------------------------------------------------------------------
/test/page.jade:
--------------------------------------------------------------------------------
1 | h1
2 | 	| jade
3 | 	b FTW


--------------------------------------------------------------------------------
/test/riot/compiler.js:
--------------------------------------------------------------------------------
  1 | ;(function(window) {
  2 | riot.parsers = {
  3 |   html: {},
  4 |   css: {},
  5 |   js: {
  6 |     coffee: function(js) {
  7 |       return CoffeeScript.compile(js, { bare: true })
  8 |     },
  9 |     es6: function(js) {
 10 |       return babel.transform(js, { blacklist: ['useStrict'] }).code
 11 |     },
 12 |     none: function(js) {
 13 |       return js
 14 |     }
 15 |   }
 16 | }
 17 | // 4 the nostalgics
 18 | riot.parsers.js.coffeescript = riot.parsers.js.coffee
 19 | 
 20 | 
 21 | var BOOL_ATTR = ('allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,default,'+
 22 |   'defaultchecked,defaultmuted,defaultselected,defer,disabled,draggable,enabled,formnovalidate,hidden,'+
 23 |   'indeterminate,inert,ismap,itemscope,loop,multiple,muted,nohref,noresize,noshade,novalidate,nowrap,open,'+
 24 |   'pauseonexit,readonly,required,reversed,scoped,seamless,selected,sortable,spellcheck,translate,truespeed,'+
 25 |   'typemustmatch,visible').split(','),
 26 |   // these cannot be auto-closed
 27 |   VOID_TAGS = 'area,base,br,col,command,embed,hr,img,input,keygen,link,meta,param,source,track,wbr'.split(','),
 28 |   /*
 29 |     Following attributes give error when parsed on browser with { exrp_values }
 30 | 
 31 |     'd' describes the SVG <path>, Chrome gives error if the value is not valid format
 32 |     https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d
 33 |   */
 34 |   PREFIX_ATTR = ['style', 'src', 'd'],
 35 | 
 36 |   LINE_TAG = /^<([\w\-]+)>(.*)<\/\1>/gim,
 37 |   QUOTE = /=({[^}]+})([\s\/\>])/g,
 38 |   SET_ATTR = /([\w\-]+)=(["'])([^\2]+?)\2/g,
 39 |   EXPR = /{\s*([^}]+)\s*}/g,
 40 |   // (tagname) (html) (javascript) endtag
 41 |   CUSTOM_TAG = /^<([\w\-]+)\s?([^>]*)>([^\x00]*[\w\/}"']>$)?([^\x00]*?)^<\/\1>/gim,
 42 |   SCRIPT = /<script(\s+type=['"]?([^>'"]+)['"]?)?>([^\x00]*?)<\/script>/gm,
 43 |   STYLE = /<style(\s+type=['"]?([^>'"]+)['"]?|\s+scoped)?>([^\x00]*?)<\/style>/gm,
 44 |   CSS_SELECTOR = /(^|\}|\{)\s*([^\{\}]+)\s*(?=\{)/g,
 45 |   CSS_COMMENT = /\/\*[^\x00]*?\*\//gm,
 46 |   HTML_COMMENT = /<!--.*?-->/g,
 47 |   CLOSED_TAG = /<([\w\-]+)([^>]*)\/\s*>/g,
 48 |   LINE_COMMENT = /^\s*\/\/.*$/gm,
 49 |   JS_COMMENT = /\/\*[^\x00]*?\*\//gm,
 50 |   INPUT_NUMBER = /(<input\s[^>]*?)type=['"]number['"]/gm
 51 | 
 52 | function mktag(name, html, css, attrs, js) {
 53 |   return 'riot.tag(\''
 54 |     + name + '\', \''
 55 |     + html + '\''
 56 |     + (css ? ', \'' + css + '\'' : '')
 57 |     + (attrs ? ', \'' + attrs.replace(/'/g, "\\'") + '\'' : '')
 58 |     + ', function(opts) {' + js + '\n});'
 59 | }
 60 | 
 61 | function compileHTML(html, opts, type) {
 62 | 
 63 |   var brackets = riot.util.brackets
 64 | 
 65 |   // foo={ bar } --> foo="{ bar }"
 66 |   html = html.replace(brackets(QUOTE), '="$1"$2')
 67 | 
 68 |   // whitespace
 69 |   html = opts.whitespace ? html.replace(/\n/g, '\\n') : html.replace(/\s+/g, ' ')
 70 | 
 71 |   // strip comments
 72 |   html = html.trim().replace(HTML_COMMENT, '')
 73 | 
 74 |   // input type=numbr
 75 |   html = html.replace(INPUT_NUMBER, '$1riot-type='+brackets(0)+'"number"'+brackets(1)) // fake expression
 76 | 
 77 |   // alter special attribute names
 78 |   html = html.replace(SET_ATTR, function(full, name, _, expr) {
 79 |     if (expr.indexOf(brackets(0)) >= 0) {
 80 |       name = name.toLowerCase()
 81 | 
 82 |       if (PREFIX_ATTR.indexOf(name) >= 0) name = 'riot-' + name
 83 | 
 84 |       // IE8 looses boolean attr values: `checked={ expr }` --> `__checked={ expr }`
 85 |       else if (BOOL_ATTR.indexOf(name) >= 0) name = '__' + name
 86 |     }
 87 | 
 88 |     return name + '="' + expr + '"'
 89 |   })
 90 | 
 91 |   // run expressions trough parser
 92 |   if (opts.expr) {
 93 |     html = html.replace(brackets(EXPR), function(_, expr) {
 94 |       var ret = compileJS(expr, opts, type).trim().replace(/\r?\n|\r/g, '').trim()
 95 |       if (ret.slice(-1) == ';') ret = ret.slice(0, -1)
 96 |       return brackets(0) + ret + brackets(1)
 97 |     })
 98 |   }
 99 | 
100 |   // <foo/> -> <foo></foo>
101 |   html = html.replace(CLOSED_TAG, function(_, name, attr) {
102 |     var tag = '<' + name + (attr ? ' ' + attr.trim() : '') + '>'
103 | 
104 |     // Do not self-close HTML5 void tags
105 |     if (VOID_TAGS.indexOf(name.toLowerCase()) == -1) tag += '</' + name + '>'
106 |     return tag
107 |   })
108 | 
109 |   // escape single quotes
110 |   html = html.replace(/'/g, "\\'")
111 | 
112 |   // \{ jotain \} --> \\{ jotain \\}
113 |   html = html.replace(brackets(/\\{|\\}/g), '\\$&')
114 | 
115 |   // compact: no whitespace between tags
116 |   if (opts.compact) html = html.replace(/> </g, '><')
117 | 
118 |   return html
119 | 
120 | }
121 | 
122 | 
123 | function riotjs(js) {
124 | 
125 |   // strip comments
126 |   js = js.replace(LINE_COMMENT, '').replace(JS_COMMENT, '')
127 | 
128 |   // ES6 method signatures
129 |   var lines = js.split('\n'),
130 |       es6Ident = ''
131 | 
132 |   lines.forEach(function(line, i) {
133 |     var l = line.trim()
134 | 
135 |     // method start
136 |     if (l[0] != '}' && l.indexOf('(') > 0 && l.indexOf('function') == -1) {
137 |       var end = /[{}]/.exec(l.slice(-1)),
138 |           m = end && /(\s+)([\w]+)\s*\(([\w,\s]*)\)\s*\{/.exec(line)
139 | 
140 |       if (m && !/^(if|while|switch|for|catch)$/.test(m[2])) {
141 |         lines[i] = m[1] + 'this.' + m[2] + ' = function(' + m[3] + ') {'
142 | 
143 |         // foo() { }
144 |         if (end[0] == '}') {
145 |           lines[i] += ' ' + l.slice(m[0].length - 1, -1) + '}.bind(this)'
146 | 
147 |         } else {
148 |           es6Ident = m[1]
149 |         }
150 |       }
151 | 
152 |     }
153 | 
154 |     // method end
155 |     if (line.slice(0, es6Ident.length + 1) == es6Ident + '}') {
156 |       lines[i] = es6Ident + '}.bind(this);'
157 |       es6Ident = ''
158 |     }
159 | 
160 |   })
161 | 
162 |   return lines.join('\n')
163 | 
164 | }
165 | 
166 | function scopedCSS (tag, style, type) {
167 |   return style.replace(CSS_COMMENT, '').replace(CSS_SELECTOR, function (m, p1, p2) {
168 |     return p1 + ' ' + p2.split(/\s*,\s*/g).map(function(sel) {
169 |       var s = sel.trim().replace(/:scope\s*/, '')
170 |       return s[0] == '@' || s == 'from' || s == 'to' || /%$/.test(s) ? s :
171 |         tag + ' ' + s + ', [riot-tag="' + tag + '"] ' + s
172 |     }).join(',')
173 |   }).trim()
174 | }
175 | 
176 | function compileJS(js, opts, type) {
177 |   var parser = opts.parser || (type ? riot.parsers.js[type] : riotjs)
178 |   if (!parser) throw new Error('Parser not found "' + type + '"')
179 |   return parser(js, opts)
180 | }
181 | 
182 | function compileTemplate(lang, html) {
183 |   var parser = riot.parsers.html[lang]
184 |   if (!parser) throw new Error('Template parser not found "' + lang + '"')
185 |   return parser(html)
186 | }
187 | 
188 | function compileCSS(style, tag, type) {
189 |   if (type == 'scoped-css') style = scopedCSS(tag, style)
190 |   else if (riot.parsers.css[type]) style = riot.parsers.css[type](tag, style)
191 |   return style.replace(/\s+/g, ' ').replace(/\\/g, '\\\\').replace(/'/g, "\\'").trim()
192 | }
193 | 
194 | function compile(src, opts) {
195 | 
196 |   opts = opts || {}
197 | 
198 |   if (opts.brackets) riot.settings.brackets = opts.brackets
199 | 
200 |   if (opts.template) src = compileTemplate(opts.template, src)
201 | 
202 |   src = src.replace(LINE_TAG, function(_, tagName, html) {
203 |     return mktag(tagName, compileHTML(html, opts), '', '', '')
204 |   })
205 | 
206 |   return src.replace(CUSTOM_TAG, function(_, tagName, attrs, html, js) {
207 | 
208 |     html = html || ''
209 | 
210 |     // js wrapped inside <script> tag
211 |     var type = opts.type
212 | 
213 |     if (!js.trim()) {
214 |       html = html.replace(SCRIPT, function(_, fullType, _type, script) {
215 |         if (_type) type = _type.replace('text/', '')
216 |         js = script
217 |         return ''
218 |       })
219 |     }
220 | 
221 |     // styles in <style> tag
222 |     var styleType = 'css',
223 |         style = ''
224 | 
225 |     html = html.replace(STYLE, function(_, fullType, _type, _style) {
226 |       if (fullType && fullType.trim() == 'scoped') styleType = 'scoped-css'
227 |         else if (_type) styleType = _type.replace('text/', '')
228 |       style = _style
229 |       return ''
230 |     })
231 | 
232 |     return mktag(
233 |       tagName,
234 |       compileHTML(html, opts, type),
235 |       compileCSS(style, tagName, styleType),
236 |       attrs,
237 |       compileJS(js, opts, type)
238 |     )
239 | 
240 |   })
241 | 
242 | }
243 | var doc = window.document,
244 |     promise,
245 |     ready
246 | 
247 | 
248 | function GET(url, fn) {
249 |   var req = new XMLHttpRequest()
250 | 
251 |   req.onreadystatechange = function() {
252 |     if (req.readyState == 4 && req.status == 200) fn(req.responseText)
253 |   }
254 |   req.open('GET', url, true)
255 |   req.send('')
256 | }
257 | 
258 | function unindent(src) {
259 |   var ident = /[ \t]+/.exec(src)
260 |   if (ident) src = src.replace(new RegExp('^' + ident[0], 'gm'), '')
261 |   return src
262 | }
263 | 
264 | function globalEval(js) {
265 |   var node = doc.createElement('script'),
266 |       root = doc.documentElement
267 | 
268 |   node.text = compile(js)
269 |   root.appendChild(node)
270 |   root.removeChild(node)
271 | }
272 | 
273 | function compileScripts(fn) {
274 |   var scripts = doc.querySelectorAll('script[type="riot/tag"]'),
275 |       scriptsAmount = scripts.length
276 | 
277 |   function done() {
278 |     promise.trigger('ready')
279 |     ready = true
280 |     fn && fn()
281 |   }
282 | 
283 |   if (!scriptsAmount) {
284 |     done()
285 |   } else {
286 |     ;[].map.call(scripts, function(script) {
287 |       var url = script.getAttribute('src')
288 | 
289 |       function compileTag(source) {
290 |         globalEval(source)
291 |         scriptsAmount--
292 |         if (!scriptsAmount) {
293 |           done()
294 |         }
295 |       }
296 | 
297 |       return url ? GET(url, compileTag) : compileTag(unindent(script.innerHTML))
298 |     })
299 |   }
300 | }
301 | 
302 | 
303 | riot.compile = function(arg, fn) {
304 | 
305 |   // string
306 |   if (typeof arg == 'string') {
307 | 
308 |     // compile & return
309 |     if (arg.trim()[0] == '<') {
310 |       var js = unindent(compile(arg))
311 |       if (!fn) 
312 |         globalEval(js)
313 |       return js
314 | 
315 |     // URL
316 |     } else {
317 |       return GET(arg, function(str) {
318 |         var js = unindent(compile(str))
319 |         globalEval(js)
320 |         fn && fn(js, str)
321 |       })
322 |     }
323 |   }
324 | 
325 |   // must be a function
326 |   if (typeof arg != 'function') arg = undefined
327 | 
328 |   // all compiled
329 |   if (ready) return arg && arg()
330 | 
331 |   // add to queue
332 |   if (promise) {
333 |     arg && promise.on('ready', arg)
334 | 
335 |   // grab riot/tag elements + load & execute them
336 |   } else {
337 |     promise = riot.observable()
338 |     compileScripts(arg)
339 |   }
340 | 
341 | }
342 | 
343 | // reassign mount methods
344 | var mount = riot.mount
345 | 
346 | riot.mount = function(a, b, c) {
347 |   var ret
348 |   riot.compile(function() { ret = mount(a, b, c) })
349 |   return ret
350 | }
351 | 
352 | // @deprecated
353 | riot.mountTo = riot.mount
354 | })(this)


--------------------------------------------------------------------------------
/test/riot/riot.js:
--------------------------------------------------------------------------------
   1 | /* Riot v2.2.1, @license MIT, (c) 2015 Muut Inc. + contributors */
   2 | 
   3 | ;(function(window) {
   4 |   'use strict'
   5 |   var riot = { version: 'v2.2.1', settings: {} }
   6 | 
   7 |   // This globals 'const' helps code size reduction
   8 | 
   9 |   // for typeof == '' comparisons
  10 |   var T_STRING = 'string'
  11 |   var T_OBJECT = 'object'
  12 | 
  13 |   // for IE8 and rest of the world
  14 |   var isArray = Array.isArray || (function () {
  15 |     var _ts = Object.prototype.toString
  16 |     return function (v) { return _ts.call(v) === '[object Array]' }
  17 |   })()
  18 | 
  19 |   // Version# for IE 8-11, 0 for others
  20 |   var ieVersion = (function (win) {
  21 |     return (win && win.document || {}).documentMode | 0
  22 |   })(window)
  23 | 
  24 | riot.observable = function(el) {
  25 | 
  26 |   el = el || {}
  27 | 
  28 |   var callbacks = {},
  29 |       _id = 0
  30 | 
  31 |   el.on = function(events, fn) {
  32 |     if (isFunction(fn)) {
  33 |       fn._id = typeof fn._id == 'undefined' ? _id++ : fn._id
  34 | 
  35 |       events.replace(/\S+/g, function(name, pos) {
  36 |         (callbacks[name] = callbacks[name] || []).push(fn)
  37 |         fn.typed = pos > 0
  38 |       })
  39 |     }
  40 |     return el
  41 |   }
  42 | 
  43 |   el.off = function(events, fn) {
  44 |     if (events == '*') callbacks = {}
  45 |     else {
  46 |       events.replace(/\S+/g, function(name) {
  47 |         if (fn) {
  48 |           var arr = callbacks[name]
  49 |           for (var i = 0, cb; (cb = arr && arr[i]); ++i) {
  50 |             if (cb._id == fn._id) { arr.splice(i, 1); i-- }
  51 |           }
  52 |         } else {
  53 |           callbacks[name] = []
  54 |         }
  55 |       })
  56 |     }
  57 |     return el
  58 |   }
  59 | 
  60 |   // only single event supported
  61 |   el.one = function(name, fn) {
  62 |     function on() {
  63 |       el.off(name, on)
  64 |       fn.apply(el, arguments)
  65 |     }
  66 |     return el.on(name, on)
  67 |   }
  68 | 
  69 |   el.trigger = function(name) {
  70 |     var args = [].slice.call(arguments, 1),
  71 |         fns = callbacks[name] || []
  72 | 
  73 |     for (var i = 0, fn; (fn = fns[i]); ++i) {
  74 |       if (!fn.busy) {
  75 |         fn.busy = 1
  76 |         fn.apply(el, fn.typed ? [name].concat(args) : args)
  77 |         if (fns[i] !== fn) { i-- }
  78 |         fn.busy = 0
  79 |       }
  80 |     }
  81 | 
  82 |     if (callbacks.all && name != 'all') {
  83 |       el.trigger.apply(el, ['all', name].concat(args))
  84 |     }
  85 | 
  86 |     return el
  87 |   }
  88 | 
  89 |   return el
  90 | 
  91 | }
  92 | riot.mixin = (function() {
  93 |   var mixins = {}
  94 | 
  95 |   return function(name, mixin) {
  96 |     if (!mixin) return mixins[name]
  97 |     mixins[name] = mixin
  98 |   }
  99 | 
 100 | })()
 101 | 
 102 | ;(function(riot, evt, window) {
 103 | 
 104 |   // browsers only
 105 |   if (!window) return
 106 | 
 107 |   var loc = window.location,
 108 |       fns = riot.observable(),
 109 |       win = window,
 110 |       started = false,
 111 |       current
 112 | 
 113 |   function hash() {
 114 |     return loc.href.split('#')[1] || ''
 115 |   }
 116 | 
 117 |   function parser(path) {
 118 |     return path.split('/')
 119 |   }
 120 | 
 121 |   function emit(path) {
 122 |     if (path.type) path = hash()
 123 | 
 124 |     if (path != current) {
 125 |       fns.trigger.apply(null, ['H'].concat(parser(path)))
 126 |       current = path
 127 |     }
 128 |   }
 129 | 
 130 |   var r = riot.route = function(arg) {
 131 |     // string
 132 |     if (arg[0]) {
 133 |       loc.hash = arg
 134 |       emit(arg)
 135 | 
 136 |     // function
 137 |     } else {
 138 |       fns.on('H', arg)
 139 |     }
 140 |   }
 141 | 
 142 |   r.exec = function(fn) {
 143 |     fn.apply(null, parser(hash()))
 144 |   }
 145 | 
 146 |   r.parser = function(fn) {
 147 |     parser = fn
 148 |   }
 149 | 
 150 |   r.stop = function () {
 151 |     if (!started) return
 152 |     win.removeEventListener ? win.removeEventListener(evt, emit, false) : win.detachEvent('on' + evt, emit)
 153 |     fns.off('*')
 154 |     started = false
 155 |   }
 156 | 
 157 |   r.start = function () {
 158 |     if (started) return
 159 |     win.addEventListener ? win.addEventListener(evt, emit, false) : win.attachEvent('on' + evt, emit)
 160 |     started = true
 161 |   }
 162 | 
 163 |   // autostart the router
 164 |   r.start()
 165 | 
 166 | })(riot, 'hashchange', window)
 167 | /*
 168 | 
 169 | //// How it works?
 170 | 
 171 | 
 172 | Three ways:
 173 | 
 174 | 1. Expressions: tmpl('{ value }', data).
 175 |    Returns the result of evaluated expression as a raw object.
 176 | 
 177 | 2. Templates: tmpl('Hi { name } { surname }', data).
 178 |    Returns a string with evaluated expressions.
 179 | 
 180 | 3. Filters: tmpl('{ show: !done, highlight: active }', data).
 181 |    Returns a space separated list of trueish keys (mainly
 182 |    used for setting html classes), e.g. "show highlight".
 183 | 
 184 | 
 185 | // Template examples
 186 | 
 187 | tmpl('{ title || "Untitled" }', data)
 188 | tmpl('Results are { results ? "ready" : "loading" }', data)
 189 | tmpl('Today is { new Date() }', data)
 190 | tmpl('{ message.length > 140 && "Message is too long" }', data)
 191 | tmpl('This item got { Math.round(rating) } stars', data)
 192 | tmpl('<h1>{ title }</h1>{ body }', data)
 193 | 
 194 | 
 195 | // Falsy expressions in templates
 196 | 
 197 | In templates (as opposed to single expressions) all falsy values
 198 | except zero (undefined/null/false) will default to empty string:
 199 | 
 200 | tmpl('{ undefined } - { false } - { null } - { 0 }', {})
 201 | // will return: " - - - 0"
 202 | 
 203 | */
 204 | 
 205 | 
 206 | var brackets = (function(orig) {
 207 | 
 208 |   var cachedBrackets,
 209 |       r,
 210 |       b,
 211 |       re = /[{}]/g
 212 | 
 213 |   return function(x) {
 214 | 
 215 |     // make sure we use the current setting
 216 |     var s = riot.settings.brackets || orig
 217 | 
 218 |     // recreate cached vars if needed
 219 |     if (cachedBrackets !== s) {
 220 |       cachedBrackets = s
 221 |       b = s.split(' ')
 222 |       r = b.map(function (e) { return e.replace(/(?=.)/g, '\\') })
 223 |     }
 224 | 
 225 |     // if regexp given, rewrite it with current brackets (only if differ from default)
 226 |     return x instanceof RegExp ? (
 227 |         s === orig ? x :
 228 |         new RegExp(x.source.replace(re, function(b) { return r[~~(b === '}')] }), x.global ? 'g' : '')
 229 |       ) :
 230 |       // else, get specific bracket
 231 |       b[x]
 232 |   }
 233 | })('{ }')
 234 | 
 235 | 
 236 | var tmpl = (function() {
 237 | 
 238 |   var cache = {},
 239 |       reVars = /(['"\/]).*?[^\\]\1|\.\w*|\w*:|\b(?:(?:new|typeof|in|instanceof) |(?:this|true|false|null|undefined)\b|function *\()|([a-z_$]\w*)/gi
 240 |               // [ 1               ][ 2  ][ 3 ][ 4                                                                                  ][ 5       ]
 241 |               // find variable names:
 242 |               // 1. skip quoted strings and regexps: "a b", 'a b', 'a \'b\'', /a b/
 243 |               // 2. skip object properties: .name
 244 |               // 3. skip object literals: name:
 245 |               // 4. skip javascript keywords
 246 |               // 5. match var name
 247 | 
 248 |   // build a template (or get it from cache), render with data
 249 |   return function(str, data) {
 250 |     return str && (cache[str] = cache[str] || tmpl(str))(data)
 251 |   }
 252 | 
 253 | 
 254 |   // create a template instance
 255 | 
 256 |   function tmpl(s, p) {
 257 | 
 258 |     // default template string to {}
 259 |     s = (s || (brackets(0) + brackets(1)))
 260 | 
 261 |       // temporarily convert \{ and \} to a non-character
 262 |       .replace(brackets(/\\{/g), '\uFFF0')
 263 |       .replace(brackets(/\\}/g), '\uFFF1')
 264 | 
 265 |     // split string to expression and non-expresion parts
 266 |     p = split(s, extract(s, brackets(/{/), brackets(/}/)))
 267 | 
 268 |     return new Function('d', 'return ' + (
 269 | 
 270 |       // is it a single expression or a template? i.e. {x} or <b>{x}</b>
 271 |       !p[0] && !p[2] && !p[3]
 272 | 
 273 |         // if expression, evaluate it
 274 |         ? expr(p[1])
 275 | 
 276 |         // if template, evaluate all expressions in it
 277 |         : '[' + p.map(function(s, i) {
 278 | 
 279 |             // is it an expression or a string (every second part is an expression)
 280 |           return i % 2
 281 | 
 282 |               // evaluate the expressions
 283 |               ? expr(s, true)
 284 | 
 285 |               // process string parts of the template:
 286 |               : '"' + s
 287 | 
 288 |                   // preserve new lines
 289 |                   .replace(/\n/g, '\\n')
 290 | 
 291 |                   // escape quotes
 292 |                   .replace(/"/g, '\\"')
 293 | 
 294 |                 + '"'
 295 | 
 296 |         }).join(',') + '].join("")'
 297 |       )
 298 | 
 299 |       // bring escaped { and } back
 300 |       .replace(/\uFFF0/g, brackets(0))
 301 |       .replace(/\uFFF1/g, brackets(1))
 302 | 
 303 |     + ';')
 304 | 
 305 |   }
 306 | 
 307 | 
 308 |   // parse { ... } expression
 309 | 
 310 |   function expr(s, n) {
 311 |     s = s
 312 | 
 313 |       // convert new lines to spaces
 314 |       .replace(/\n/g, ' ')
 315 | 
 316 |       // trim whitespace, brackets, strip comments
 317 |       .replace(brackets(/^[{ ]+|[ }]+$|\/\*.+?\*\//g), '')
 318 | 
 319 |     // is it an object literal? i.e. { key : value }
 320 |     return /^\s*[\w- "']+ *:/.test(s)
 321 | 
 322 |       // if object literal, return trueish keys
 323 |       // e.g.: { show: isOpen(), done: item.done } -> "show done"
 324 |       ? '[' +
 325 | 
 326 |           // extract key:val pairs, ignoring any nested objects
 327 |           extract(s,
 328 | 
 329 |               // name part: name:, "name":, 'name':, name :
 330 |               /["' ]*[\w- ]+["' ]*:/,
 331 | 
 332 |               // expression part: everything upto a comma followed by a name (see above) or end of line
 333 |               /,(?=["' ]*[\w- ]+["' ]*:)|}|$/
 334 |               ).map(function(pair) {
 335 | 
 336 |                 // get key, val parts
 337 |                 return pair.replace(/^[ "']*(.+?)[ "']*: *(.+?),? *$/, function(_, k, v) {
 338 | 
 339 |                   // wrap all conditional parts to ignore errors
 340 |                   return v.replace(/[^&|=!><]+/g, wrap) + '?"' + k + '":"",'
 341 | 
 342 |                 })
 343 | 
 344 |               }).join('')
 345 | 
 346 |         + '].join(" ").trim()'
 347 | 
 348 |       // if js expression, evaluate as javascript
 349 |       : wrap(s, n)
 350 | 
 351 |   }
 352 | 
 353 | 
 354 |   // execute js w/o breaking on errors or undefined vars
 355 | 
 356 |   function wrap(s, nonull) {
 357 |     s = s.trim()
 358 |     return !s ? '' : '(function(v){try{v='
 359 | 
 360 |         // prefix vars (name => data.name)
 361 |         + (s.replace(reVars, function(s, _, v) { return v ? '(d.'+v+'===undefined?'+(typeof window == 'undefined' ? 'global.' : 'window.')+v+':d.'+v+')' : s })
 362 | 
 363 |           // break the expression if its empty (resulting in undefined value)
 364 |           || 'x')
 365 |       + '}catch(e){'
 366 |       + '}finally{return '
 367 | 
 368 |         // default to empty string for falsy values except zero
 369 |         + (nonull === true ? '!v&&v!==0?"":v' : 'v')
 370 | 
 371 |       + '}}).call(d)'
 372 |   }
 373 | 
 374 | 
 375 |   // split string by an array of substrings
 376 | 
 377 |   function split(str, substrings) {
 378 |     var parts = []
 379 |     substrings.map(function(sub, i) {
 380 | 
 381 |       // push matched expression and part before it
 382 |       i = str.indexOf(sub)
 383 |       parts.push(str.slice(0, i), sub)
 384 |       str = str.slice(i + sub.length)
 385 |     })
 386 | 
 387 |     // push the remaining part
 388 |     return parts.concat(str)
 389 |   }
 390 | 
 391 | 
 392 |   // match strings between opening and closing regexp, skipping any inner/nested matches
 393 | 
 394 |   function extract(str, open, close) {
 395 | 
 396 |     var start,
 397 |         level = 0,
 398 |         matches = [],
 399 |         re = new RegExp('('+open.source+')|('+close.source+')', 'g')
 400 | 
 401 |     str.replace(re, function(_, open, close, pos) {
 402 | 
 403 |       // if outer inner bracket, mark position
 404 |       if (!level && open) start = pos
 405 | 
 406 |       // in(de)crease bracket level
 407 |       level += open ? 1 : -1
 408 | 
 409 |       // if outer closing bracket, grab the match
 410 |       if (!level && close != null) matches.push(str.slice(start, pos+close.length))
 411 | 
 412 |     })
 413 | 
 414 |     return matches
 415 |   }
 416 | 
 417 | })()
 418 | 
 419 | // { key, i in items} -> { key, i, items }
 420 | function loopKeys(expr) {
 421 |   var b0 = brackets(0),
 422 |       els = expr.slice(b0.length).match(/\s*(\S+?)\s*(?:,\s*(\S)+)?\s+in\s+(.+)/)
 423 |   return els ? { key: els[1], pos: els[2], val: b0 + els[3] } : { val: expr }
 424 | }
 425 | 
 426 | function mkitem(expr, key, val) {
 427 |   var item = {}
 428 |   item[expr.key] = key
 429 |   if (expr.pos) item[expr.pos] = val
 430 |   return item
 431 | }
 432 | 
 433 | 
 434 | /* Beware: heavy stuff */
 435 | function _each(dom, parent, expr) {
 436 | 
 437 |   remAttr(dom, 'each')
 438 | 
 439 |   var template = dom.outerHTML,
 440 |       root = dom.parentNode,
 441 |       placeholder = document.createComment('riot placeholder'),
 442 |       tags = [],
 443 |       child = getTag(dom),
 444 |       checksum
 445 | 
 446 |   root.insertBefore(placeholder, dom)
 447 | 
 448 |   expr = loopKeys(expr)
 449 | 
 450 |   // clean template code
 451 |   parent
 452 |     .one('premount', function () {
 453 |       if (root.stub) root = parent.root
 454 |       // remove the original DOM node
 455 |       dom.parentNode.removeChild(dom)
 456 |     })
 457 |     .on('update', function () {
 458 |       var items = tmpl(expr.val, parent),
 459 |           test
 460 | 
 461 |       // object loop. any changes cause full redraw
 462 |       if (!isArray(items)) {
 463 |         test = checksum
 464 |         checksum = items ? JSON.stringify(items) : ''
 465 |         if (checksum === test) return
 466 | 
 467 |         items = !items ? [] :
 468 |           Object.keys(items).map(function (key) {
 469 |             return mkitem(expr, key, items[key])
 470 |           })
 471 |       }
 472 | 
 473 |       var frag = document.createDocumentFragment(),
 474 |           i = tags.length,
 475 |           j = items.length
 476 | 
 477 |       // unmount leftover items
 478 |       while (i > j) tags[--i].unmount()
 479 |       tags.length = j
 480 | 
 481 |       test = !checksum && !!expr.key
 482 |       for (i = 0; i < j; ++i) {
 483 |         var _item = test ? mkitem(expr, items[i], i) : items[i]
 484 | 
 485 |         if (!tags[i]) {
 486 |           // mount new
 487 |           (tags[i] = new Tag({ tmpl: template }, {
 488 |               parent: parent,
 489 |               isLoop: true,
 490 |               root: root,
 491 |               item: _item
 492 |             })
 493 |           ).mount()
 494 | 
 495 |           frag.appendChild(tags[i].root)
 496 |         }
 497 |         tags[i]._item = _item
 498 |         tags[i].update(_item)
 499 |       }
 500 | 
 501 |       root.insertBefore(frag, placeholder)
 502 | 
 503 |       if (child) parent.tags[getTagName(dom)] = tags
 504 | 
 505 |     }).one('updated', function() {
 506 |       var keys = Object.keys(parent)// only set new values
 507 |       walk(root, function(node) {
 508 |         // only set element node and not isLoop
 509 |         if (node.nodeType == 1 && !node.isLoop && !node._looped) {
 510 |           node._visited = false // reset _visited for loop node
 511 |           node._looped = true // avoid set multiple each
 512 |           setNamed(node, parent, keys)
 513 |         }
 514 |       })
 515 |     })
 516 | 
 517 | }
 518 | 
 519 | 
 520 | function parseNamedElements(root, parent, childTags) {
 521 | 
 522 |   walk(root, function(dom) {
 523 |     if (dom.nodeType == 1) {
 524 |       dom.isLoop = (dom.parentNode && dom.parentNode.isLoop || dom.getAttribute('each')) ? 1 : 0
 525 | 
 526 |       // custom child tag
 527 |       var child = getTag(dom)
 528 | 
 529 |       if (child && !dom.isLoop) {
 530 |         var tag = new Tag(child, { root: dom, parent: parent }, dom.innerHTML),
 531 |             tagName = getTagName(dom),
 532 |             ptag = parent,
 533 |             cachedTag
 534 | 
 535 |         while (!getTag(ptag.root)) {
 536 |           if (!ptag.parent) break
 537 |           ptag = ptag.parent
 538 |         }
 539 | 
 540 |         // fix for the parent attribute in the looped elements
 541 |         tag.parent = ptag
 542 | 
 543 |         cachedTag = ptag.tags[tagName]
 544 | 
 545 |         // if there are multiple children tags having the same name
 546 |         if (cachedTag) {
 547 |           // if the parent tags property is not yet an array
 548 |           // create it adding the first cached tag
 549 |           if (!isArray(cachedTag))
 550 |             ptag.tags[tagName] = [cachedTag]
 551 |           // add the new nested tag to the array
 552 |           ptag.tags[tagName].push(tag)
 553 |         } else {
 554 |           ptag.tags[tagName] = tag
 555 |         }
 556 | 
 557 |         // empty the child node once we got its template
 558 |         // to avoid that its children get compiled multiple times
 559 |         dom.innerHTML = ''
 560 |         childTags.push(tag)
 561 |       }
 562 | 
 563 |       if (!dom.isLoop)
 564 |         setNamed(dom, parent, [])
 565 |     }
 566 | 
 567 |   })
 568 | 
 569 | }
 570 | 
 571 | function parseExpressions(root, tag, expressions) {
 572 | 
 573 |   function addExpr(dom, val, extra) {
 574 |     if (val.indexOf(brackets(0)) >= 0) {
 575 |       var expr = { dom: dom, expr: val }
 576 |       expressions.push(extend(expr, extra))
 577 |     }
 578 |   }
 579 | 
 580 |   walk(root, function(dom) {
 581 |     var type = dom.nodeType
 582 | 
 583 |     // text node
 584 |     if (type == 3 && dom.parentNode.tagName != 'STYLE') addExpr(dom, dom.nodeValue)
 585 |     if (type != 1) return
 586 | 
 587 |     /* element */
 588 | 
 589 |     // loop
 590 |     var attr = dom.getAttribute('each')
 591 | 
 592 |     if (attr) { _each(dom, tag, attr); return false }
 593 | 
 594 |     // attribute expressions
 595 |     each(dom.attributes, function(attr) {
 596 |       var name = attr.name,
 597 |         bool = name.split('__')[1]
 598 | 
 599 |       addExpr(dom, attr.value, { attr: bool || name, bool: bool })
 600 |       if (bool) { remAttr(dom, name); return false }
 601 | 
 602 |     })
 603 | 
 604 |     // skip custom tags
 605 |     if (getTag(dom)) return false
 606 | 
 607 |   })
 608 | 
 609 | }
 610 | function Tag(impl, conf, innerHTML) {
 611 | 
 612 |   var self = riot.observable(this),
 613 |       opts = inherit(conf.opts) || {},
 614 |       dom = mkdom(impl.tmpl),
 615 |       parent = conf.parent,
 616 |       isLoop = conf.isLoop,
 617 |       item = conf.item,
 618 |       expressions = [],
 619 |       childTags = [],
 620 |       root = conf.root,
 621 |       fn = impl.fn,
 622 |       tagName = root.tagName.toLowerCase(),
 623 |       attr = {},
 624 |       loopDom,
 625 |       TAG_ATTRIBUTES = /([\w\-]+)\s?=\s?['"]([^'"]+)["']/gim
 626 | 
 627 | 
 628 |   if (fn && root._tag) {
 629 |     root._tag.unmount(true)
 630 |   }
 631 | 
 632 |   // not yet mounted
 633 |   this.isMounted = false
 634 | 
 635 |   if (impl.attrs) {
 636 |     var attrs = impl.attrs.match(TAG_ATTRIBUTES)
 637 | 
 638 |     each(attrs, function(a) {
 639 |       var kv = a.split(/\s?=\s?/)
 640 |       root.setAttribute(kv[0], kv[1].replace(/['"]/g, ''))
 641 |     })
 642 | 
 643 |   }
 644 | 
 645 |   // keep a reference to the tag just created
 646 |   // so we will be able to mount this tag multiple times
 647 |   root._tag = this
 648 | 
 649 |   // create a unique id to this tag
 650 |   // it could be handy to use it also to improve the virtual dom rendering speed
 651 |   this._id = fastAbs(~~(new Date().getTime() * Math.random()))
 652 | 
 653 |   extend(this, { parent: parent, root: root, opts: opts, tags: {} }, item)
 654 | 
 655 |   // grab attributes
 656 |   each(root.attributes, function(el) {
 657 |     var val = el.value
 658 |     // remember attributes with expressions only
 659 |     if (brackets(/\{.*\}/).test(val)) attr[el.name] = val
 660 |   })
 661 | 
 662 |   if (dom.innerHTML && !/select|select|optgroup|tbody|tr/.test(tagName))
 663 |     // replace all the yield tags with the tag inner html
 664 |     dom.innerHTML = replaceYield(dom.innerHTML, innerHTML)
 665 | 
 666 |   // options
 667 |   function updateOpts() {
 668 |     // update opts from current DOM attributes
 669 |     each(root.attributes, function(el) {
 670 |       opts[el.name] = tmpl(el.value, parent || self)
 671 |     })
 672 |     // recover those with expressions
 673 |     each(Object.keys(attr), function(name) {
 674 |       opts[name] = tmpl(attr[name], parent || self)
 675 |     })
 676 |   }
 677 | 
 678 |   this.update = function(data) {
 679 |     extend(self, data)
 680 |     updateOpts()
 681 |     self.trigger('update', data)
 682 |     update(expressions, self, data)
 683 |     self.trigger('updated')
 684 |   }
 685 | 
 686 |   this.mixin = function() {
 687 |     each(arguments, function(mix) {
 688 |       mix = typeof mix == 'string' ? riot.mixin(mix) : mix
 689 |       each(Object.keys(mix), function(key) {
 690 |         // bind methods to self
 691 |         if (key != 'init')
 692 |           self[key] = typeof mix[key] == 'function' ? mix[key].bind(self) : mix[key]
 693 |       })
 694 |       // init method will be called automatically
 695 |       if (mix.init) mix.init.bind(self)()
 696 |     })
 697 |   }
 698 | 
 699 |   this.mount = function() {
 700 | 
 701 |     updateOpts()
 702 | 
 703 |     // initialiation
 704 |     fn && fn.call(self, opts)
 705 | 
 706 |     toggle(true)
 707 | 
 708 | 
 709 |     // parse layout after init. fn may calculate args for nested custom tags
 710 |     parseExpressions(dom, self, expressions)
 711 | 
 712 |     if (!self.parent) self.update()
 713 | 
 714 |     // internal use only, fixes #403
 715 |     self.trigger('premount')
 716 | 
 717 |     if (isLoop) {
 718 |       // update the root attribute for the looped elements
 719 |       self.root = root = loopDom = dom.firstChild
 720 |     } else {
 721 |       while (dom.firstChild) root.appendChild(dom.firstChild)
 722 |       if (root.stub) self.root = root = parent.root
 723 |     }
 724 |     // if it's not a child tag we can trigger its mount event
 725 |     if (!self.parent || self.parent.isMounted) {
 726 |       self.isMounted = true
 727 |       self.trigger('mount')
 728 |     }
 729 |     // otherwise we need to wait that the parent event gets triggered
 730 |     else self.parent.one('mount', function() {
 731 |       // avoid to trigger the `mount` event for the tags
 732 |       // not visible included in an if statement
 733 |       if (!isInStub(self.root)) {
 734 |         self.parent.isMounted = self.isMounted = true
 735 |         self.trigger('mount')
 736 |       }
 737 |     })
 738 |   }
 739 | 
 740 | 
 741 |   this.unmount = function(keepRootTag) {
 742 |     var el = loopDom || root,
 743 |         p = el.parentNode
 744 | 
 745 |     if (p) {
 746 | 
 747 |       if (parent) {
 748 |         // remove this tag from the parent tags object
 749 |         // if there are multiple nested tags with same name..
 750 |         // remove this element form the array
 751 |         if (isArray(parent.tags[tagName])) {
 752 |           each(parent.tags[tagName], function(tag, i) {
 753 |             if (tag._id == self._id)
 754 |               parent.tags[tagName].splice(i, 1)
 755 |           })
 756 |         } else
 757 |           // otherwise just delete the tag instance
 758 |           parent.tags[tagName] = undefined
 759 |       } else {
 760 |         while (el.firstChild) el.removeChild(el.firstChild)
 761 |       }
 762 | 
 763 |       if (!keepRootTag)
 764 |         p.removeChild(el)
 765 | 
 766 |     }
 767 | 
 768 | 
 769 |     self.trigger('unmount')
 770 |     toggle()
 771 |     self.off('*')
 772 |     // somehow ie8 does not like `delete root._tag`
 773 |     root._tag = null
 774 | 
 775 |   }
 776 | 
 777 |   function toggle(isMount) {
 778 | 
 779 |     // mount/unmount children
 780 |     each(childTags, function(child) { child[isMount ? 'mount' : 'unmount']() })
 781 | 
 782 |     // listen/unlisten parent (events flow one way from parent to children)
 783 |     if (parent) {
 784 |       var evt = isMount ? 'on' : 'off'
 785 | 
 786 |       // the loop tags will be always in sync with the parent automatically
 787 |       if (isLoop)
 788 |         parent[evt]('unmount', self.unmount)
 789 |       else
 790 |         parent[evt]('update', self.update)[evt]('unmount', self.unmount)
 791 |     }
 792 |   }
 793 | 
 794 |   // named elements available for fn
 795 |   parseNamedElements(dom, this, childTags)
 796 | 
 797 | 
 798 | }
 799 | 
 800 | function setEventHandler(name, handler, dom, tag, item) {
 801 | 
 802 |   dom[name] = function(e) {
 803 | 
 804 |     // cross browser event fix
 805 |     e = e || window.event
 806 | 
 807 |     if (!e.which) e.which = e.charCode || e.keyCode
 808 |     if (!e.target) e.target = e.srcElement
 809 | 
 810 |     // ignore error on some browsers
 811 |     try {
 812 |       e.currentTarget = dom
 813 |     } catch (ignored) { '' }
 814 | 
 815 |     e.item = tag._item ? tag._item : item
 816 | 
 817 |     // prevent default behaviour (by default)
 818 |     if (handler.call(tag, e) !== true && !/radio|check/.test(dom.type)) {
 819 |       e.preventDefault && e.preventDefault()
 820 |       e.returnValue = false
 821 |     }
 822 | 
 823 |     if (!e.preventUpdate) {
 824 |       var el = item ? tag.parent : tag
 825 |       el.update()
 826 |     }
 827 | 
 828 |   }
 829 | 
 830 | }
 831 | 
 832 | // used by if- attribute
 833 | function insertTo(root, node, before) {
 834 |   if (root) {
 835 |     root.insertBefore(before, node)
 836 |     root.removeChild(node)
 837 |   }
 838 | }
 839 | 
 840 | // item = currently looped item
 841 | function update(expressions, tag, item) {
 842 | 
 843 |   each(expressions, function(expr, i) {
 844 | 
 845 |     var dom = expr.dom,
 846 |         attrName = expr.attr,
 847 |         value = tmpl(expr.expr, tag),
 848 |         parent = expr.dom.parentNode
 849 | 
 850 |     if (value == null) value = ''
 851 | 
 852 |     // leave out riot- prefixes from strings inside textarea
 853 |     if (parent && parent.tagName == 'TEXTAREA') value = value.replace(/riot-/g, '')
 854 | 
 855 |     // no change
 856 |     if (expr.value === value) return
 857 |     expr.value = value
 858 | 
 859 |     // text node
 860 |     if (!attrName) return dom.nodeValue = value.toString()
 861 | 
 862 |     // remove original attribute
 863 |     remAttr(dom, attrName)
 864 | 
 865 |     // event handler
 866 |     if (typeof value == 'function') {
 867 |       setEventHandler(attrName, value, dom, tag, item)
 868 | 
 869 |     // if- conditional
 870 |     } else if (attrName == 'if') {
 871 |       var stub = expr.stub
 872 | 
 873 |       // add to DOM
 874 |       if (value) {
 875 |         if (stub) {
 876 |           insertTo(stub.parentNode, stub, dom)
 877 |           dom.inStub = false
 878 |           // avoid to trigger the mount event if the tags is not visible yet
 879 |           // maybe we can optimize this avoiding to mount the tag at all
 880 |           if (!isInStub(dom)) {
 881 |             walk(dom, function(el) {
 882 |               if (el._tag && !el._tag.isMounted) el._tag.isMounted = !!el._tag.trigger('mount')
 883 |             })
 884 |           }
 885 |         }
 886 |       // remove from DOM
 887 |       } else {
 888 |         stub = expr.stub = stub || document.createTextNode('')
 889 |         insertTo(dom.parentNode, dom, stub)
 890 |         dom.inStub = true
 891 |       }
 892 |     // show / hide
 893 |     } else if (/^(show|hide)$/.test(attrName)) {
 894 |       if (attrName == 'hide') value = !value
 895 |       dom.style.display = value ? '' : 'none'
 896 | 
 897 |     // field value
 898 |     } else if (attrName == 'value') {
 899 |       dom.value = value
 900 | 
 901 |     // <img src="{ expr }">
 902 |     } else if (attrName.slice(0, 5) == 'riot-' && attrName != 'riot-tag') {
 903 |       attrName = attrName.slice(5)
 904 |       value ? dom.setAttribute(attrName, value) : remAttr(dom, attrName)
 905 | 
 906 |     } else {
 907 |       if (expr.bool) {
 908 |         dom[attrName] = value
 909 |         if (!value) return
 910 |         value = attrName
 911 |       }
 912 | 
 913 |       if (typeof value != 'object') dom.setAttribute(attrName, value)
 914 | 
 915 |     }
 916 | 
 917 |   })
 918 | 
 919 | }
 920 | 
 921 | function each(els, fn) {
 922 |   for (var i = 0, len = (els || []).length, el; i < len; i++) {
 923 |     el = els[i]
 924 |     // return false -> remove current item during loop
 925 |     if (el != null && fn(el, i) === false) i--
 926 |   }
 927 |   return els
 928 | }
 929 | 
 930 | function isFunction(v) {
 931 |   return typeof v === 'function' || false   // avoid IE problems
 932 | }
 933 | 
 934 | function remAttr(dom, name) {
 935 |   dom.removeAttribute(name)
 936 | }
 937 | 
 938 | function fastAbs(nr) {
 939 |   return (nr ^ (nr >> 31)) - (nr >> 31)
 940 | }
 941 | 
 942 | function getTagName(dom) {
 943 |   var child = getTag(dom),
 944 |     namedTag = dom.getAttribute('name'),
 945 |     tagName = namedTag && namedTag.indexOf(brackets(0)) < 0 ? namedTag : child.name
 946 | 
 947 |   return tagName
 948 | }
 949 | 
 950 | function extend(src) {
 951 |   var obj, args = arguments
 952 |   for (var i = 1; i < args.length; ++i) {
 953 |     if ((obj = args[i])) {
 954 |       for (var key in obj) {      // eslint-disable-line guard-for-in
 955 |         src[key] = obj[key]
 956 |       }
 957 |     }
 958 |   }
 959 |   return src
 960 | }
 961 | 
 962 | function mkdom(template) {
 963 |   var checkie = ieVersion && ieVersion < 10,
 964 |       matches = /^\s*<([\w-]+)/.exec(template),
 965 |       tagName = matches ? matches[1].toLowerCase() : '',
 966 |       rootTag = (tagName === 'th' || tagName === 'td') ? 'tr' :
 967 |                 (tagName === 'tr' ? 'tbody' : 'div'),
 968 |       el = mkEl(rootTag)
 969 | 
 970 |   el.stub = true
 971 | 
 972 |   if (checkie) {
 973 |     if (tagName === 'optgroup')
 974 |       optgroupInnerHTML(el, template)
 975 |     else if (tagName === 'option')
 976 |       optionInnerHTML(el, template)
 977 |     else if (rootTag !== 'div')
 978 |       tbodyInnerHTML(el, template, tagName)
 979 |     else
 980 |       checkie = 0
 981 |   }
 982 |   if (!checkie) el.innerHTML = template
 983 | 
 984 |   return el
 985 | }
 986 | 
 987 | function walk(dom, fn) {
 988 |   if (dom) {
 989 |     if (fn(dom) === false) walk(dom.nextSibling, fn)
 990 |     else {
 991 |       dom = dom.firstChild
 992 | 
 993 |       while (dom) {
 994 |         walk(dom, fn)
 995 |         dom = dom.nextSibling
 996 |       }
 997 |     }
 998 |   }
 999 | }
1000 | 
1001 | function isInStub(dom) {
1002 |   while (dom) {
1003 |     if (dom.inStub) return true
1004 |     dom = dom.parentNode
1005 |   }
1006 |   return false
1007 | }
1008 | 
1009 | function mkEl(name) {
1010 |   return document.createElement(name)
1011 | }
1012 | 
1013 | function replaceYield (tmpl, innerHTML) {
1014 |   return tmpl.replace(/<(yield)\/?>(<\/\1>)?/gim, innerHTML || '')
1015 | }
1016 | 
1017 | function $$(selector, ctx) {
1018 |   return (ctx || document).querySelectorAll(selector)
1019 | }
1020 | 
1021 | function inherit(parent) {
1022 |   function Child() {}
1023 |   Child.prototype = parent
1024 |   return new Child()
1025 | }
1026 | 
1027 | function setNamed(dom, parent, keys) {
1028 |   each(dom.attributes, function(attr) {
1029 |     if (dom._visited) return
1030 |     if (attr.name === 'id' || attr.name === 'name') {
1031 |       dom._visited = true
1032 |       var p, v = attr.value
1033 |       if (~keys.indexOf(v)) return
1034 | 
1035 |       p = parent[v]
1036 |       if (!p)
1037 |         parent[v] = dom
1038 |       else
1039 |         isArray(p) ? p.push(dom) : (parent[v] = [p, dom])
1040 |     }
1041 |   })
1042 | }
1043 | /**
1044 |  *
1045 |  * Hacks needed for the old internet explorer versions [lower than IE10]
1046 |  *
1047 |  */
1048 | 
1049 | function tbodyInnerHTML(el, html, tagName) {
1050 |   var div = mkEl('div'),
1051 |       loops = /td|th/.test(tagName) ? 3 : 2,
1052 |       child
1053 | 
1054 |   div.innerHTML = '<table>' + html + '</table>'
1055 |   child = div.firstChild
1056 | 
1057 |   while (loops--) {
1058 |     child = child.firstChild
1059 |   }
1060 | 
1061 |   el.appendChild(child)
1062 | 
1063 | }
1064 | 
1065 | function optionInnerHTML(el, html) {
1066 |   var opt = mkEl('option'),
1067 |       valRegx = /value=[\"'](.+?)[\"']/,
1068 |       selRegx = /selected=[\"'](.+?)[\"']/,
1069 |       eachRegx = /each=[\"'](.+?)[\"']/,
1070 |       ifRegx = /if=[\"'](.+?)[\"']/,
1071 |       innerRegx = />([^<]*)</,
1072 |       valuesMatch = html.match(valRegx),
1073 |       selectedMatch = html.match(selRegx),
1074 |       innerValue = html.match(innerRegx),
1075 |       eachMatch = html.match(eachRegx),
1076 |       ifMatch = html.match(ifRegx)
1077 | 
1078 |   if (innerValue) {
1079 |     opt.innerHTML = innerValue[1]
1080 |   } else {
1081 |     opt.innerHTML = html
1082 |   }
1083 | 
1084 |   if (valuesMatch) {
1085 |     opt.value = valuesMatch[1]
1086 |   }
1087 | 
1088 |   if (selectedMatch) {
1089 |     opt.setAttribute('riot-selected', selectedMatch[1])
1090 |   }
1091 | 
1092 |   if (eachMatch) {
1093 |     opt.setAttribute('each', eachMatch[1])
1094 |   }
1095 | 
1096 |   if (ifMatch) {
1097 |     opt.setAttribute('if', ifMatch[1])
1098 |   }
1099 | 
1100 |   el.appendChild(opt)
1101 | }
1102 | 
1103 | function optgroupInnerHTML(el, html) {
1104 |   var opt = mkEl('optgroup'),
1105 |       labelRegx = /label=[\"'](.+?)[\"']/,
1106 |       elementRegx = /^<([^>]*)>/,
1107 |       tagRegx = /^<([^ \>]*)/,
1108 |       labelMatch = html.match(labelRegx),
1109 |       elementMatch = html.match(elementRegx),
1110 |       tagMatch = html.match(tagRegx),
1111 |       innerContent = html
1112 | 
1113 |   if (elementMatch) {
1114 |     var options = html.slice(elementMatch[1].length+2, -tagMatch[1].length-3).trim()
1115 |     innerContent = options
1116 |   }
1117 | 
1118 |   if (labelMatch) {
1119 |     opt.setAttribute('riot-label', labelMatch[1])
1120 |   }
1121 | 
1122 |   if (innerContent) {
1123 |     var innerOpt = mkEl('div')
1124 | 
1125 |     optionInnerHTML(innerOpt, innerContent)
1126 | 
1127 |     opt.appendChild(innerOpt.firstChild)
1128 |   }
1129 | 
1130 |   el.appendChild(opt)
1131 | }
1132 | 
1133 | /*
1134 |  Virtual dom is an array of custom tags on the document.
1135 |  Updates and unmounts propagate downwards from parent to children.
1136 | */
1137 | 
1138 | var virtualDom = [],
1139 |     tagImpl = {},
1140 |     styleNode
1141 | 
1142 | var RIOT_TAG = 'riot-tag'
1143 | 
1144 | function getTag(dom) {
1145 |   return tagImpl[dom.getAttribute(RIOT_TAG) || dom.tagName.toLowerCase()]
1146 | }
1147 | 
1148 | function injectStyle(css) {
1149 | 
1150 |   styleNode = styleNode || mkEl('style')
1151 | 
1152 |   if (!document.head) return
1153 | 
1154 |   if (styleNode.styleSheet)
1155 |     styleNode.styleSheet.cssText += css
1156 |   else
1157 |     styleNode.innerHTML += css
1158 | 
1159 |   if (!styleNode._rendered)
1160 |     if (styleNode.styleSheet) {
1161 |       document.body.appendChild(styleNode)
1162 |     } else {
1163 |       var rs = $$('style[type=riot]')[0]
1164 |       if (rs) {
1165 |         rs.parentNode.insertBefore(styleNode, rs)
1166 |         rs.parentNode.removeChild(rs)
1167 |       } else {
1168 |         document.head.appendChild(styleNode)
1169 |       }
1170 |     }
1171 | 
1172 |   styleNode._rendered = true
1173 | 
1174 | }
1175 | 
1176 | function mountTo(root, tagName, opts) {
1177 |   var tag = tagImpl[tagName],
1178 |       // cache the inner HTML to fix #855
1179 |       innerHTML = root._innerHTML = root._innerHTML || root.innerHTML
1180 | 
1181 |   // clear the inner html
1182 |   root.innerHTML = ''
1183 | 
1184 |   if (tag && root) tag = new Tag(tag, { root: root, opts: opts }, innerHTML)
1185 | 
1186 |   if (tag && tag.mount) {
1187 |     tag.mount()
1188 |     virtualDom.push(tag)
1189 |     return tag.on('unmount', function() {
1190 |       virtualDom.splice(virtualDom.indexOf(tag), 1)
1191 |     })
1192 |   }
1193 | 
1194 | }
1195 | 
1196 | riot.tag = function(name, html, css, attrs, fn) {
1197 |   if (isFunction(attrs)) {
1198 |     fn = attrs
1199 |     if (/^[\w\-]+\s?=/.test(css)) {
1200 |       attrs = css
1201 |       css = ''
1202 |     } else attrs = ''
1203 |   }
1204 |   if (css) {
1205 |     if (isFunction(css)) fn = css
1206 |     else injectStyle(css)
1207 |   }
1208 |   tagImpl[name] = { name: name, tmpl: html, attrs: attrs, fn: fn }
1209 |   return name
1210 | }
1211 | 
1212 | riot.mount = function(selector, tagName, opts) {
1213 | 
1214 |   var els,
1215 |       allTags,
1216 |       tags = []
1217 | 
1218 |   // helper functions
1219 | 
1220 |   function addRiotTags(arr) {
1221 |     var list = ''
1222 |     each(arr, function (e) {
1223 |       list += ', *[riot-tag="'+ e.trim() + '"]'
1224 |     })
1225 |     return list
1226 |   }
1227 | 
1228 |   function selectAllTags() {
1229 |     var keys = Object.keys(tagImpl)
1230 |     return keys + addRiotTags(keys)
1231 |   }
1232 | 
1233 |   function pushTags(root) {
1234 |     if (root.tagName) {
1235 |       if (tagName && !root.getAttribute(RIOT_TAG))
1236 |         root.setAttribute(RIOT_TAG, tagName)
1237 | 
1238 |       var tag = mountTo(root,
1239 |         tagName || root.getAttribute(RIOT_TAG) || root.tagName.toLowerCase(), opts)
1240 | 
1241 |       if (tag) tags.push(tag)
1242 |     }
1243 |     else if (root.length) {
1244 |       each(root, pushTags)   // assume nodeList
1245 |     }
1246 |   }
1247 | 
1248 |   // ----- mount code -----
1249 | 
1250 |   if (typeof tagName === T_OBJECT) {
1251 |     opts = tagName
1252 |     tagName = 0
1253 |   }
1254 | 
1255 |   // crawl the DOM to find the tag
1256 |   if (typeof selector === T_STRING) {
1257 |     if (selector === '*') {
1258 |       // select all the tags registered
1259 |       // and also the tags found with the riot-tag attribute set
1260 |       selector = allTags = selectAllTags()
1261 |     } else {
1262 |       // or just the ones named like the selector
1263 |       selector += addRiotTags(selector.split(','))
1264 |     }
1265 |     els = $$(selector)
1266 |   }
1267 |   else
1268 |     // probably you have passed already a tag or a NodeList
1269 |     els = selector
1270 | 
1271 |   // select all the registered and mount them inside their root elements
1272 |   if (tagName === '*') {
1273 |     // get all custom tags
1274 |     tagName = allTags || selectAllTags()
1275 |     // if the root els it's just a single tag
1276 |     if (els.tagName) {
1277 |       els = $$(tagName, els)
1278 |     } else {
1279 |       // select all the children for all the different root elements
1280 |       var nodeList = []
1281 |       each(els, function (_el) {
1282 |         nodeList.push($$(tagName, _el))
1283 |       })
1284 |       els = nodeList
1285 |     }
1286 |     // get rid of the tagName
1287 |     tagName = 0
1288 |   }
1289 | 
1290 |   if (els.tagName)
1291 |     pushTags(els)
1292 |   else
1293 |     each(els, pushTags)
1294 | 
1295 |   return tags
1296 | }
1297 | 
1298 | // update everything
1299 | riot.update = function() {
1300 |   return each(virtualDom, function(tag) {
1301 |     tag.update()
1302 |   })
1303 | }
1304 | 
1305 | // @deprecated
1306 | riot.mountTo = riot.mount
1307 | 
1308 | 
1309 |   // share methods for other riot parts, e.g. compiler
1310 |   riot.util = { brackets: brackets, tmpl: tmpl }
1311 | 
1312 |   // support CommonJS, AMD & browser
1313 |   if (typeof exports === 'object')
1314 |     module.exports = riot
1315 |   else if (typeof define === 'function' && define.amd)
1316 |     define(function() { return riot })
1317 |   else
1318 |     window.riot = riot
1319 | 
1320 | })(typeof window != 'undefined' ? window : undefined);


--------------------------------------------------------------------------------
/test/riot/test.riot.html:
--------------------------------------------------------------------------------
 1 | <body></body>
 2 | <script src="../../require.js"></script>
 3 | 
 4 | <todo></todo>
 5 | 
 6 | <script>
 7 | var jade = require("../lib/jade")
 8 | 
 9 | var riot = require("./riot")
10 | require("./compiler")
11 | 
12 | require.compilers.css = function(text) {
13 |   var style = document.createElement('style');
14 | 	style.appendChild(document.createTextNode(text));
15 | 	document.head.appendChild(style);
16 | }
17 | 
18 | require.compilers.tag = function(text) {
19 |   return "module.exports = " + riot.compile(text, true)
20 | }
21 | 
22 | require("todo.css")
23 | require("todo.tag")
24 | 
25 | 
26 | riot.mount('todo', {
27 |   title: 'I want to behave!',
28 |   items: [
29 |     { title: 'Avoid excessive coffeine', done: true },
30 |     { title: 'Hidden item', hidden: true },
31 |     { title: 'Be less provocative' },
32 |     { title: 'Be nice to people' }
33 |   ]
34 | })
35 | 	
36 | 
37 | 
38 | </script>


--------------------------------------------------------------------------------
/test/riot/todo.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |   font-family: 'myriad pro', sans-serif;
 3 |   font-size: 20px;
 4 |   border: 0;
 5 | }
 6 | 
 7 | todo {
 8 |   display: block;
 9 |   max-width: 400px;
10 |   margin: 5% auto;
11 | }
12 | 
13 | form input {
14 |   font-size: 100%;
15 |   padding: .6em;
16 |   border: 1px solid #ccc;
17 |   border-radius: 3px;
18 | }
19 | 
20 | button {
21 |   background-color: #1FADC5;
22 |   border: 1px solid rgba(0,0,0,.2);
23 |   font-size: 100%;
24 |   color: #fff;
25 |   padding: .6em 1.2em;
26 |   border-radius: 3em;
27 |   cursor: pointer;
28 |   margin: 0 .3em;
29 |   outline: none;
30 | }
31 | 
32 | button[disabled] {
33 |   background-color: #ddd;
34 |   color: #aaa;
35 | }
36 | 
37 | ul {
38 |   padding: 0;
39 | }
40 | 
41 | li {
42 |   list-style-type: none;
43 |   padding: .2em 0;
44 | }
45 | 
46 | .completed {
47 |   text-decoration: line-through;
48 |   color: #ccc;
49 | }
50 | 
51 | label {
52 |   cursor: pointer;
53 | }
54 | 


--------------------------------------------------------------------------------
/test/riot/todo.tag:
--------------------------------------------------------------------------------
 1 | <todo>
 2 | 
 3 |   <h3>{ opts.title }</h3>
 4 | 
 5 |   <ul>
 6 |     <li each={ items }>
 7 |       <label class={ completed: done }>
 8 |         <input type="checkbox" checked={ done } onclick={ parent.toggle }> { title }
 9 |       </label>
10 |     </li>
11 |   </ul>
12 | 
13 |   <form onsubmit={ add }>
14 |     <input name="input" onkeyup={ edit }>
15 |     <button disabled={ !text }>Add #{ items.length + 1 }</button>
16 |   </form>
17 | 
18 |   <script>
19 |     this.disabled = true
20 | 
21 |     this.items = opts.items
22 | 
23 |     edit(e) {
24 |       this.text = e.target.value
25 |     }
26 | 
27 |     add(e) {
28 |       if (this.text) {
29 |         this.items.push({ title: this.text })
30 |         this.text = this.input.value = ''
31 |       }
32 |     }
33 | 
34 |     toggle(e) {
35 |       var item = e.item
36 |       item.done = !item.done
37 |       return true
38 |     }
39 |   </script>
40 | 
41 | </todo>
42 | 


--------------------------------------------------------------------------------
/test/style.css:
--------------------------------------------------------------------------------
1 |  body {
2 |  	background : red;
3 |  }


--------------------------------------------------------------------------------
/test/test.html:
--------------------------------------------------------------------------------
 1 | <body></body>
 2 | <script src="../require.js"></script>
 3 | <script src="./lib/jade.js"></script>
 4 | 
 5 | <script>
 6 | 
 7 | 
 8 | 
 9 | require.compilers.css = function(text) {
10 | 
11 |     var style = document.createElement('style');
12 | 	style.appendChild(document.createTextNode(text));
13 | 	document.head.appendChild(style);
14 | }
15 | 
16 | require.compilers.jade = function(text) {
17 | 	return "module.exports = " + JSON.stringify(jade.render(text))
18 | }
19 | 
20 | 
21 | </script>
22 | 
23 | <script>
24 | var b = require('b')
25 | console.assert(b.hello == 'world')
26 | console.assert(b.boo.boo == 'boo')
27 | 
28 | var text = require("text.txt")
29 | console.assert( text, "HELLO!")
30 | 
31 | // INCLUDE CSS
32 | require("style.css")
33 | 
34 | 
35 | document.body.innerHTML += require("page.jade")
36 | 
37 | 
38 | </script>


--------------------------------------------------------------------------------
/test/text.txt:
--------------------------------------------------------------------------------
1 | HELLO!


--------------------------------------------------------------------------------