| |
| // CommonJS require() |
| |
| function require(p){ |
| if ('fs' == p) return {}; |
| var path = require.resolve(p) |
| , mod = require.modules[path]; |
| if (!mod) throw new Error('failed to require "' + p + '"'); |
| if (!mod.exports) { |
| mod.exports = {}; |
| mod.call(mod.exports, mod, mod.exports, require.relative(path)); |
| } |
| return mod.exports; |
| } |
| |
| require.modules = {}; |
| |
| require.resolve = function (path){ |
| var orig = path |
| , reg = path + '.js' |
| , index = path + '/index.js'; |
| return require.modules[reg] && reg |
| || require.modules[index] && index |
| || orig; |
| }; |
| |
| require.register = function (path, fn){ |
| require.modules[path] = fn; |
| }; |
| |
| require.relative = function (parent) { |
| return function(p){ |
| if ('.' != p.substr(0, 1)) return require(p); |
| |
| var path = parent.split('/') |
| , segs = p.split('/'); |
| path.pop(); |
| |
| for (var i = 0; i < segs.length; i++) { |
| var seg = segs[i]; |
| if ('..' == seg) path.pop(); |
| else if ('.' != seg) path.push(seg); |
| } |
| |
| return require(path.join('/')); |
| }; |
| }; |
| |
| |
| require.register("ejs.js", function(module, exports, require){ |
| |
| /*! |
| * EJS |
| * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca> |
| * MIT Licensed |
| */ |
| |
| /** |
| * Module dependencies. |
| */ |
| |
| var utils = require('./utils') |
| , fs = require('fs'); |
| |
| /** |
| * Library version. |
| */ |
| |
| exports.version = '0.6.1'; |
| |
| /** |
| * Filters. |
| * |
| * @type Object |
| */ |
| |
| var filters = exports.filters = require('./filters'); |
| |
| /** |
| * Intermediate js cache. |
| * |
| * @type Object |
| */ |
| |
| var cache = {}; |
| |
| /** |
| * Clear intermediate js cache. |
| * |
| * @api public |
| */ |
| |
| exports.clearCache = function(){ |
| cache = {}; |
| }; |
| |
| /** |
| * Translate filtered code into function calls. |
| * |
| * @param {String} js |
| * @return {String} |
| * @api private |
| */ |
| |
| function filtered(js) { |
| return js.substr(1).split('|').reduce(function(js, filter){ |
| var parts = filter.split(':') |
| , name = parts.shift() |
| , args = parts.shift() || ''; |
| if (args) args = ', ' + args; |
| return 'filters.' + name + '(' + js + args + ')'; |
| }); |
| }; |
| |
| /** |
| * Re-throw the given `err` in context to the |
| * `str` of ejs, `filename`, and `lineno`. |
| * |
| * @param {Error} err |
| * @param {String} str |
| * @param {String} filename |
| * @param {String} lineno |
| * @api private |
| */ |
| |
| function rethrow(err, str, filename, lineno){ |
| var lines = str.split('\n') |
| , start = Math.max(lineno - 3, 0) |
| , end = Math.min(lines.length, lineno + 3); |
| |
| // Error context |
| var context = lines.slice(start, end).map(function(line, i){ |
| var curr = i + start + 1; |
| return (curr == lineno ? ' >> ' : ' ') |
| + curr |
| + '| ' |
| + line; |
| }).join('\n'); |
| |
| // Alter exception message |
| err.path = filename; |
| err.message = (filename || 'ejs') + ':' |
| + lineno + '\n' |
| + context + '\n\n' |
| + err.message; |
| |
| throw err; |
| } |
| |
| /** |
| * Parse the given `str` of ejs, returning the function body. |
| * |
| * @param {String} str |
| * @return {String} |
| * @api public |
| */ |
| |
| var parse = exports.parse = function(str, options){ |
| var options = options || {} |
| , open = options.open || exports.open || '<%' |
| , close = options.close || exports.close || '%>'; |
| |
| var buf = [ |
| "var buf = [];" |
| , "\nwith (locals) {" |
| , "\n buf.push('" |
| ]; |
| |
| var lineno = 1; |
| |
| for (var i = 0, len = str.length; i < len; ++i) { |
| if (str.slice(i, open.length + i) == open) { |
| i += open.length |
| |
| var prefix, postfix, line = '__stack.lineno=' + lineno; |
| switch (str.substr(i, 1)) { |
| case '=': |
| prefix = "', escape((" + line + ', '; |
| postfix = ")), '"; |
| ++i; |
| break; |
| case '-': |
| prefix = "', (" + line + ', '; |
| postfix = "), '"; |
| ++i; |
| break; |
| default: |
| prefix = "');" + line + ';'; |
| postfix = "; buf.push('"; |
| } |
| |
| var end = str.indexOf(close, i) |
| , js = str.substring(i, end) |
| , start = i |
| , n = 0; |
| |
| while (~(n = js.indexOf("\n", n))) n++, lineno++; |
| if (js.substr(0, 1) == ':') js = filtered(js); |
| buf.push(prefix, js, postfix); |
| i += end - start + close.length - 1; |
| |
| } else if (str.substr(i, 1) == "\\") { |
| buf.push("\\\\"); |
| } else if (str.substr(i, 1) == "'") { |
| buf.push("\\'"); |
| } else if (str.substr(i, 1) == "\r") { |
| buf.push(" "); |
| } else if (str.substr(i, 1) == "\n") { |
| buf.push("\\n"); |
| lineno++; |
| } else { |
| buf.push(str.substr(i, 1)); |
| } |
| } |
| |
| buf.push("');\n}\nreturn buf.join('');"); |
| return buf.join(''); |
| }; |
| |
| /** |
| * Compile the given `str` of ejs into a `Function`. |
| * |
| * @param {String} str |
| * @param {Object} options |
| * @return {Function} |
| * @api public |
| */ |
| |
| var compile = exports.compile = function(str, options){ |
| options = options || {}; |
| |
| var input = JSON.stringify(str) |
| , filename = options.filename |
| ? JSON.stringify(options.filename) |
| : 'undefined'; |
| |
| // Adds the fancy stack trace meta info |
| str = [ |
| 'var __stack = { lineno: 1, input: ' + input + ', filename: ' + filename + ' };', |
| rethrow.toString(), |
| 'try {', |
| exports.parse(str, options), |
| '} catch (err) {', |
| ' rethrow(err, __stack.input, __stack.filename, __stack.lineno);', |
| '}' |
| ].join("\n"); |
| |
| if (options.debug) console.log(str); |
| var fn = new Function('locals, filters, escape', str); |
| return function(locals){ |
| return fn.call(this, locals, filters, utils.escape); |
| } |
| }; |
| |
| /** |
| * Render the given `str` of ejs. |
| * |
| * Options: |
| * |
| * - `locals` Local variables object |
| * - `cache` Compiled functions are cached, requires `filename` |
| * - `filename` Used by `cache` to key caches |
| * - `scope` Function execution context |
| * - `debug` Output generated function body |
| * - `open` Open tag, defaulting to "<%" |
| * - `close` Closing tag, defaulting to "%>" |
| * |
| * @param {String} str |
| * @param {Object} options |
| * @return {String} |
| * @api public |
| */ |
| |
| exports.render = function(str, options){ |
| var fn |
| , options = options || {}; |
| |
| if (options.cache) { |
| if (options.filename) { |
| fn = cache[options.filename] || (cache[options.filename] = compile(str, options)); |
| } else { |
| throw new Error('"cache" option requires "filename".'); |
| } |
| } else { |
| fn = compile(str, options); |
| } |
| |
| options.__proto__ = options.locals; |
| return fn.call(options.scope, options); |
| }; |
| |
| /** |
| * Render an EJS file at the given `path` and callback `fn(err, str)`. |
| * |
| * @param {String} path |
| * @param {Object|Function} options or callback |
| * @param {Function} fn |
| * @api public |
| */ |
| |
| exports.renderFile = function(path, options, fn){ |
| var key = path + ':string'; |
| |
| if ('function' == typeof options) { |
| fn = options, options = {}; |
| } |
| |
| options.filename = path; |
| |
| try { |
| var str = options.cache |
| ? exports.cache[key] || (exports.cache[key] = fs.readFileSync(path, 'utf8')) |
| : fs.readFileSync(path, 'utf8'); |
| |
| fn(null, exports.render(str, options)); |
| } catch (err) { |
| fn(err); |
| } |
| }; |
| |
| // express support |
| |
| exports.__express = exports.renderFile; |
| |
| /** |
| * Expose to require(). |
| */ |
| |
| if (require.extensions) { |
| require.extensions['.ejs'] = function(module, filename) { |
| source = require('fs').readFileSync(filename, 'utf-8'); |
| module._compile(compile(source, {}), filename); |
| }; |
| } else if (require.registerExtension) { |
| require.registerExtension('.ejs', function(src) { |
| return compile(src, {}); |
| }); |
| } |
| |
| }); // module: ejs.js |
| |
| require.register("filters.js", function(module, exports, require){ |
| |
| /*! |
| * EJS - Filters |
| * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca> |
| * MIT Licensed |
| */ |
| |
| /** |
| * First element of the target `obj`. |
| */ |
| |
| exports.first = function(obj) { |
| return obj[0]; |
| }; |
| |
| /** |
| * Last element of the target `obj`. |
| */ |
| |
| exports.last = function(obj) { |
| return obj[obj.length - 1]; |
| }; |
| |
| /** |
| * Capitalize the first letter of the target `str`. |
| */ |
| |
| exports.capitalize = function(str){ |
| str = String(str); |
| return str[0].toUpperCase() + str.substr(1, str.length); |
| }; |
| |
| /** |
| * Downcase the target `str`. |
| */ |
| |
| exports.downcase = function(str){ |
| return String(str).toLowerCase(); |
| }; |
| |
| /** |
| * Uppercase the target `str`. |
| */ |
| |
| exports.upcase = function(str){ |
| return String(str).toUpperCase(); |
| }; |
| |
| /** |
| * Sort the target `obj`. |
| */ |
| |
| exports.sort = function(obj){ |
| return Object.create(obj).sort(); |
| }; |
| |
| /** |
| * Sort the target `obj` by the given `prop` ascending. |
| */ |
| |
| exports.sort_by = function(obj, prop){ |
| return Object.create(obj).sort(function(a, b){ |
| a = a[prop], b = b[prop]; |
| if (a > b) return 1; |
| if (a < b) return -1; |
| return 0; |
| }); |
| }; |
| |
| /** |
| * Size or length of the target `obj`. |
| */ |
| |
| exports.size = exports.length = function(obj) { |
| return obj.length; |
| }; |
| |
| /** |
| * Add `a` and `b`. |
| */ |
| |
| exports.plus = function(a, b){ |
| return Number(a) + Number(b); |
| }; |
| |
| /** |
| * Subtract `b` from `a`. |
| */ |
| |
| exports.minus = function(a, b){ |
| return Number(a) - Number(b); |
| }; |
| |
| /** |
| * Multiply `a` by `b`. |
| */ |
| |
| exports.times = function(a, b){ |
| return Number(a) * Number(b); |
| }; |
| |
| /** |
| * Divide `a` by `b`. |
| */ |
| |
| exports.divided_by = function(a, b){ |
| return Number(a) / Number(b); |
| }; |
| |
| /** |
| * Join `obj` with the given `str`. |
| */ |
| |
| exports.join = function(obj, str){ |
| return obj.join(str || ', '); |
| }; |
| |
| /** |
| * Truncate `str` to `len`. |
| */ |
| |
| exports.truncate = function(str, len){ |
| str = String(str); |
| return str.substr(0, len); |
| }; |
| |
| /** |
| * Truncate `str` to `n` words. |
| */ |
| |
| exports.truncate_words = function(str, n){ |
| var str = String(str) |
| , words = str.split(/ +/); |
| return words.slice(0, n).join(' '); |
| }; |
| |
| /** |
| * Replace `pattern` with `substitution` in `str`. |
| */ |
| |
| exports.replace = function(str, pattern, substitution){ |
| return String(str).replace(pattern, substitution || ''); |
| }; |
| |
| /** |
| * Prepend `val` to `obj`. |
| */ |
| |
| exports.prepend = function(obj, val){ |
| return Array.isArray(obj) |
| ? [val].concat(obj) |
| : val + obj; |
| }; |
| |
| /** |
| * Append `val` to `obj`. |
| */ |
| |
| exports.append = function(obj, val){ |
| return Array.isArray(obj) |
| ? obj.concat(val) |
| : obj + val; |
| }; |
| |
| /** |
| * Map the given `prop`. |
| */ |
| |
| exports.map = function(arr, prop){ |
| return arr.map(function(obj){ |
| return obj[prop]; |
| }); |
| }; |
| |
| /** |
| * Reverse the given `obj`. |
| */ |
| |
| exports.reverse = function(obj){ |
| return Array.isArray(obj) |
| ? obj.reverse() |
| : String(obj).split('').reverse().join(''); |
| }; |
| |
| /** |
| * Get `prop` of the given `obj`. |
| */ |
| |
| exports.get = function(obj, prop){ |
| return obj[prop]; |
| }; |
| |
| /** |
| * Packs the given `obj` into json string |
| */ |
| exports.json = function(obj){ |
| return JSON.stringify(obj); |
| }; |
| }); // module: filters.js |
| |
| require.register("utils.js", function(module, exports, require){ |
| |
| /*! |
| * EJS |
| * Copyright(c) 2010 TJ Holowaychuk <tj@vision-media.ca> |
| * MIT Licensed |
| */ |
| |
| /** |
| * Escape the given string of `html`. |
| * |
| * @param {String} html |
| * @return {String} |
| * @api private |
| */ |
| |
| exports.escape = function(html){ |
| return String(html) |
| .replace(/&(?!\w+;)/g, '&') |
| .replace(/</g, '<') |
| .replace(/>/g, '>') |
| .replace(/"/g, '"'); |
| }; |
| |
| }); // module: utils.js |