diff --git a/node_modules/.bin/stylus b/node_modules/.bin/stylus new file mode 120000 index 0000000..4113f9b --- /dev/null +++ b/node_modules/.bin/stylus @@ -0,0 +1 @@ +../stylus/bin/stylus \ No newline at end of file diff --git a/node_modules/stylus/LICENSE b/node_modules/stylus/LICENSE new file mode 100644 index 0000000..a206b68 --- /dev/null +++ b/node_modules/stylus/LICENSE @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2010 LearnBoost + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/node_modules/stylus/bin/stylus b/node_modules/stylus/bin/stylus new file mode 100755 index 0000000..33da780 --- /dev/null +++ b/node_modules/stylus/bin/stylus @@ -0,0 +1,596 @@ +#!/usr/bin/env node + +/** + * Module dependencies. + */ + +var fs = require('fs') + , stylus = require('../lib/stylus') + , basename = require('path').basename + , dirname = require('path').dirname + , resolve = require('path').resolve + , join = require('path').join + , isWindows = process.platform === 'win32'; + +/** + * Arguments. + */ + +var args = process.argv.slice(2); + +/** + * Compare flag. + */ + +var compare = false; + +/** + * Compress flag. + */ + +var compress = false; + +/** + * CSS conversion flag. + */ + +var convertCSS = false; + +/** + * Line numbers flag. + */ + +var linenos = false; + +/** + * Firebug flag + */ + +var firebug = false; + +/** + * Files to processes. + */ + +var files = []; + +/** + * Import paths. + */ + +var paths = []; + +/** + * Destination directory. + */ + +var dest; + +/** + * Watcher hash. + */ + +var watchers; + +/** + * Enable REPL. + */ + +var interactive; + +/** + * Plugins. + */ + +var plugins = []; + +/** + * Optional url() function. + */ + +var urlFunction = false; + +/** + * Include css on import. + */ + +var includeCSS = false; + +/** + * Usage docs. + */ + +var usage = [ + '' + , ' Usage: stylus [options] [command] [< in [> out]]' + , ' [file|dir ...]' + , '' + , ' Commands:' + , '' + , ' help [:] Opens help info at MDC for in' + , ' your default browser. Optionally' + , ' searches other resources of :' + , ' safari opera w3c ms caniuse quirksmode' + , '' + , ' Options:' + , '' + , ' -i, --interactive Start interactive REPL' + , ' -u, --use Utilize the stylus plugin at ' + , ' -U, --inline Utilize image inlining via data uri support' + , ' -w, --watch Watch file(s) for changes and re-compile' + , ' -o, --out Output to when passing files' + , ' -C, --css [dest] Convert css input to stylus' + , ' -I, --include Add to lookup paths' + , ' -c, --compress Compress css output' + , ' -d, --compare Display input along with output' + , ' -f, --firebug Emits debug infos in the generated css that' + , ' can be used by the FireStylus Firebug plugin' + , ' -l, --line-numbers Emits comments in the generated css' + , ' indicating the corresponding stylus line' + , ' --include-css Include regular css on @import' + , ' -V, --version Display the version of stylus' + , ' -h, --help Display help information' + , '' +].join('\n'); + +/** + * Handle arguments. + */ + +var arg; +while (args.length) { + arg = args.shift(); + switch (arg) { + case '-h': + case '--help': + console.error(usage); + process.exit(1); + case '-d': + case '--compare': + compare = true; + break; + case '-c': + case '--compress': + compress = true; + break; + case '-C': + case '--css': + convertCSS = true; + break; + case '-f': + case '--firebug': + firebug = true; + break; + case '-l': + case '--line-numbers': + linenos = true; + break; + case '-V': + case '--version': + console.log(stylus.version); + process.exit(0); + break; + case '-o': + case '--out': + dest = args.shift(); + if (!dest) throw new Error('--out required'); + break; + case 'help': + var name = args.shift() + , browser = name.split(':'); + if (browser.length > 1) { + name = [].slice.call(browser, 1).join(':'); + browser = browser[0]; + } else { + name = browser[0]; + browser = ''; + } + if (!name) throw new Error('help required'); + help(name); + break; + case '--include-css': + includeCSS = true; + break; + case '-i': + case '--repl': + case '--interactive': + interactive = true; + break; + case '-I': + case '--include': + var path = args.shift(); + if (!path) throw new Error('--include required'); + paths.push(path); + break; + case '-w': + case '--watch': + watchers = {}; + break; + case '-U': + case '--inline': + args.unshift('--use', 'url'); + break; + case '-u': + case '--use': + var options; + var path = args.shift(); + if (!path) throw new Error('--use required'); + + // options + if ('--with' == args[0]) { + args.shift(); + options = args.shift(); + if (!options) throw new Error('--with required'); + options = eval('(' + options + ')'); + } + + // url support + if ('url' == path) { + urlFunction = options || {}; + } else { + paths.push(dirname(path)); + plugins.push({ path: path, options: options }); + } + break; + default: + files.push(arg); + } +} + +// if --watch is used, assume we are +// not working with stdio + +if (watchers && !files.length) { + files = fs.readdirSync(process.cwd()) + .filter(function(file){ + return file.match(/\.styl$/); + }); +} + +/** + * Open the default browser to the CSS property `name`. + * + * @param {String} name + */ + +function help(name) { + var url + , exec = require('child_process').exec + , command; + + name = encodeURIComponent(name); + + switch (browser) { + case 'safari': + case 'webkit': + url = 'https://developer.apple.com/library/safari/search/?q=' + name; + break; + case 'opera': + url = 'http://dev.opera.com/search/?term=' + name; + break; + case 'w3c': + url = 'http://www.google.com/search?q=site%3Awww.w3.org%2FTR+' + name; + break; + case 'ms': + url = 'http://social.msdn.microsoft.com/search/en-US/ie?query=' + name + '&refinement=59%2c61'; + break; + case 'caniuse': + url = 'http://caniuse.com/#search=' + name; + break; + case 'quirksmode': + url = 'http://www.google.com/search?q=site%3Awww.quirksmode.org+' + name; + break; + default: + url = 'https://developer.mozilla.org/en/CSS/' + name; + } + + switch (process.platform) { + case 'linux': command = 'x-www-browser'; break; + default: command = 'open'; + } + + exec(command + ' "' + url + '"', function(){ + process.exit(0); + }); +} + +// Compilation options + +var options = { + filename: 'stdin' + , compress: compress + , firebug: firebug + , linenos: linenos + , paths: [process.cwd()].concat(paths) +}; + +// Buffer stdin + +var str = ''; + +// Convert css to stylus + +if (convertCSS) { + switch (files.length) { + case 2: + compileCSSFile(files[0], files[1]); + break; + case 1: + compileCSSFile(files[0], files[0].replace('.css', '.styl')); + break; + default: + var stdin = process.openStdin(); + stdin.setEncoding('utf8'); + stdin.on('data', function(chunk){ str += chunk; }); + stdin.on('end', function(){ + var out = stylus.convertCSS(str); + console.log(out); + }); + } +} else if (interactive) { + repl(); +} else { + if (files.length) { + compileFiles(files); + } else { + compileStdio(); + } +} + +/** + * Start stylus REPL. + */ + +function repl() { + var options = { filename: 'stdin', imports: [join(__dirname, '..', 'lib', 'functions')] } + , parser = new stylus.Parser('', options) + , evaluator = new stylus.Evaluator(parser.parse(), options) + , rl = require('readline') + , repl = rl.createInterface(process.stdin, process.stdout, autocomplete) + , global = evaluator.global.scope; + + // expose BIFs + evaluator.evaluate(); + + // readline + repl.setPrompt('> '); + repl.prompt(); + + // HACK: flat-list auto-complete + function autocomplete(line){ + var out = process.stdout + , keys = Object.keys(global.locals) + , len = keys.length + , words = line.split(/\s+/) + , word = words.pop() + , names = [] + , name + , node + , key; + + // find words that match + for (var i = 0; i < len; ++i) { + key = keys[i]; + if (0 == key.indexOf(word)) { + node = global.lookup(key); + switch (node.nodeName) { + case 'function': + names.push(node.toString()); + break; + default: + names.push(key); + } + } + } + + return [names, line]; + }; + + repl.on('line', function(line){ + if (!line.trim().length) return repl.prompt(); + parser = new stylus.Parser(line, options); + parser.state.push('expression'); + evaluator.return = true; + try { + var expr = parser.parse(); + var ret = evaluator.visit(expr); + ret = ret.nodes[ret.nodes.length - 1]; + ret = ret.toString(); + if ('(' == ret[0]) ret = ret.replace(/^\(|\)$/g, ''); + console.log('\033[90m=> \033[0m' + highlight(ret)); + repl.prompt(); + } catch (err) { + console.error('\033[31merror: %s\033[0m', err.message || err.stack); + repl.prompt(); + } + }); + + repl.on('SIGINT', function(){ + console.log(); + process.exit(0); + }); +} + +/** + * Highlight the given string of stylus. + */ + +function highlight(str) { + return str + .replace(/(#)?(\d+(\.\d+)?)/g, function($0, $1, $2){ + return $1 ? $0 : '\033[36m' + $2 + '\033[0m'; + }) + .replace(/(#[\da-fA-F]+)/g, '\033[33m$1\033[0m') + .replace(/('.*?'|".*?")/g, '\033[32m$1\033[0m'); +} + +/** + * Convert a CSS file to a Styl file + */ + +function compileCSSFile(file, fileOut) { + fs.lstat(file, function(err, stat){ + if (err) throw err; + if (stat.isFile()) { + fs.readFile(file, 'utf8', function(err, str){ + if (err) throw err; + var styl = stylus.convertCSS(str); + fs.writeFile(fileOut, styl, function(err){ + if (err) throw err; + }); + }); + } + }); +} + +/** + * Compile with stdio. + */ + +function compileStdio() { + process.stdin.setEncoding('utf8'); + process.stdin.on('data', function(chunk){ str += chunk; }); + process.stdin.on('end', function(){ + // Compile to css + var style = stylus(str, options); + if (includeCSS) style.set('include css', true); + usePlugins(style); + style.render(function(err, css){ + if (err) throw err; + if (compare) { + console.log('\n\x1b[1mInput:\x1b[0m'); + console.log(str); + console.log('\n\x1b[1mOutput:\x1b[0m'); + } + console.log(css); + if (compare) console.log(); + }); + }).resume(); +} + +/** + * Compile the given files. + */ + +function compileFiles(files) { + files.forEach(compileFile); +} + +/** + * Compile the given file. + */ + +function compileFile(file) { + // ensure file exists + fs.lstat(file, function(err, stat){ + if (err) throw err; + // file + if (stat.isFile()) { + fs.readFile(file, 'utf8', function(err, str){ + if (err) throw err; + options.filename = file; + options._imports = []; + var style = stylus(str, options); + if (includeCSS) style.set('include css', true); + usePlugins(style); + style.render(function(err, css){ + watchImports(file, options._imports); + if (err) { + if (watchers) { + console.error(err.stack || err.message); + } else { + throw err; + } + } else { + writeFile(file, css); + } + }); + }); + // directory + } else if (stat.isDirectory()) { + fs.readdir(file, function(err, files){ + if (err) throw err; + files.filter(function(path){ + return path.match(/\.styl$/); + }).map(function(path){ + return join(file, path); + }).forEach(compileFile); + }); + } + }); +} + +/** + * Write the given css output. + */ + +function writeFile(file, css) { + // --out support + var path = dest + ? join(dest, basename(file, '.styl') + '.css') + : file.replace('.styl', '.css'); + fs.writeFile(path, css, function(err){ + if (err) throw err; + console.log(' \033[90mcompiled\033[0m %s', path); + // --watch support + watch(file, compileFile); + }); +} + +/** + * Watch the given `file` and invoke `fn` when modified. + */ + +function watch(file, fn) { + // not watching + if (!watchers) return; + + // already watched + if (watchers[file]) return; + + // watch the file itself + watchers[file] = true; + console.log(' \033[90mwatching\033[0m %s', file); + // if is windows use fs.watch api instead + // TODO: remove watchFile when fs.watch() works on osx etc + if (isWindows) { + fs.watch(file, function(event) { + if (event === 'change') fn(file); + }); + } else { + fs.watchFile(file, { interval: 50 }, function(curr, prev) { + if (curr.mtime > prev.mtime) fn(file); + }); + } +} + +/** + * Watch `imports`, re-compiling `file` when they change. + */ + +function watchImports(file, imports) { + imports.forEach(function(imported){ + if (!imported.path) return; + watch(imported.path, function(){ + compileFile(file); + }); + }); +} + +/** + * Utilize plugins. + */ + +function usePlugins(style) { + plugins.forEach(function(plugin){ + var path = plugin.path; + var options = plugin.options; + fn = require(/^\.+\//.test(path) ? resolve(path) : path); + if ('function' != typeof fn) { + throw new Error('plugin ' + path + ' does not export a function'); + } + style.use(fn(options)); + }); + + if (urlFunction) style.define('url', stylus.url(urlFunction)); +} diff --git a/node_modules/stylus/bm.js b/node_modules/stylus/bm.js new file mode 100644 index 0000000..ce1acfa --- /dev/null +++ b/node_modules/stylus/bm.js @@ -0,0 +1,22 @@ + +/** + * Module dependencies. + */ + +var stylus = require('./'); + +var times = 200 + , n = times + , start = new Date; + +console.log('compiling %d times', times); + +while (n--) { + stylus('body\n color: white;\n background: url(/images/foo.png)\n a\n &:hover\n text-decoration: underline;') + .render(function(err, css){}); +} + +var duration = new Date - start; +console.log(' duration: %dms', duration); +console.log(' average: %dms', duration / times); +console.log(' per second: %d', (times / (duration / 1000)).toFixed(1)); diff --git a/node_modules/stylus/index.js b/node_modules/stylus/index.js new file mode 100644 index 0000000..ab58d3e --- /dev/null +++ b/node_modules/stylus/index.js @@ -0,0 +1,4 @@ + +module.exports = process.env.STYLUS_COV + ? require('./lib-cov/stylus') + : require('./lib/stylus'); \ No newline at end of file diff --git a/node_modules/stylus/lib/colors.js b/node_modules/stylus/lib/colors.js new file mode 100644 index 0000000..9f465a2 --- /dev/null +++ b/node_modules/stylus/lib/colors.js @@ -0,0 +1,156 @@ + +/*! + * Stylus - colors + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +module.exports = { + aliceblue: [240, 248, 255] + , antiquewhite: [250, 235, 215] + , aqua: [0, 255, 255] + , aquamarine: [127, 255, 212] + , azure: [240, 255, 255] + , beige: [245, 245, 220] + , bisque: [255, 228, 196] + , black: [0, 0, 0] + , blanchedalmond: [255, 235, 205] + , blue: [0, 0, 255] + , blueviolet: [138, 43, 226] + , brown: [165, 42, 42] + , burlywood: [222, 184, 135] + , cadetblue: [95, 158, 160] + , chartreuse: [127, 255, 0] + , chocolate: [210, 105, 30] + , coral: [255, 127, 80] + , cornflowerblue: [100, 149, 237] + , cornsilk: [255, 248, 220] + , crimson: [220, 20, 60] + , cyan: [0, 255, 255] + , darkblue: [0, 0, 139] + , darkcyan: [0, 139, 139] + , darkgoldenrod: [184, 132, 11] + , darkgray: [169, 169, 169] + , darkgreen: [0, 100, 0] + , darkgrey: [169, 169, 169] + , darkkhaki: [189, 183, 107] + , darkmagenta: [139, 0, 139] + , darkolivegreen: [85, 107, 47] + , darkorange: [255, 140, 0] + , darkorchid: [153, 50, 204] + , darkred: [139, 0, 0] + , darksalmon: [233, 150, 122] + , darkseagreen: [143, 188, 143] + , darkslateblue: [72, 61, 139] + , darkslategray: [47, 79, 79] + , darkslategrey: [47, 79, 79] + , darkturquoise: [0, 206, 209] + , darkviolet: [148, 0, 211] + , deeppink: [255, 20, 147] + , deepskyblue: [0, 191, 255] + , dimgray: [105, 105, 105] + , dimgrey: [105, 105, 105] + , dodgerblue: [30, 144, 255] + , firebrick: [178, 34, 34] + , floralwhite: [255, 255, 240] + , forestgreen: [34, 139, 34] + , fuchsia: [255, 0, 255] + , gainsboro: [220, 220, 220] + , ghostwhite: [248, 248, 255] + , gold: [255, 215, 0] + , goldenrod: [218, 165, 32] + , gray: [128, 128, 128] + , green: [0, 128, 0] + , greenyellow: [173, 255, 47] + , grey: [128, 128, 128] + , honeydew: [240, 255, 240] + , hotpink: [255, 105, 180] + , indianred: [205, 92, 92] + , indigo: [75, 0, 130] + , ivory: [255, 255, 240] + , khaki: [240, 230, 140] + , lavender: [230, 230, 250] + , lavenderblush: [255, 240, 245] + , lawngreen: [124, 252, 0] + , lemonchiffon: [255, 250, 205] + , lightblue: [173, 216, 230] + , lightcoral: [240, 128, 128] + , lightcyan: [224, 255, 255] + , lightgoldenrodyellow: [250, 250, 210] + , lightgray: [211, 211, 211] + , lightgreen: [144, 238, 144] + , lightgrey: [211, 211, 211] + , lightpink: [255, 182, 193] + , lightsalmon: [255, 160, 122] + , lightseagreen: [32, 178, 170] + , lightskyblue: [135, 206, 250] + , lightslategray: [119, 136, 153] + , lightslategrey: [119, 136, 153] + , lightsteelblue: [176, 196, 222] + , lightyellow: [255, 255, 224] + , lime: [0, 255, 0] + , limegreen: [50, 205, 50] + , linen: [250, 240, 230] + , magenta: [255, 0, 255] + , maroon: [128, 0, 0] + , mediumaquamarine: [102, 205, 170] + , mediumblue: [0, 0, 205] + , mediumorchid: [186, 85, 211] + , mediumpurple: [147, 112, 219] + , mediumseagreen: [60, 179, 113] + , mediumslateblue: [123, 104, 238] + , mediumspringgreen: [0, 250, 154] + , mediumturquoise: [72, 209, 204] + , mediumvioletred: [199, 21, 133] + , midnightblue: [25, 25, 112] + , mintcream: [245, 255, 250] + , mistyrose: [255, 228, 225] + , moccasin: [255, 228, 181] + , navajowhite: [255, 222, 173] + , navy: [0, 0, 128] + , oldlace: [253, 245, 230] + , olive: [128, 128, 0] + , olivedrab: [107, 142, 35] + , orange: [255, 165, 0] + , orangered: [255, 69, 0] + , orchid: [218, 112, 214] + , palegoldenrod: [238, 232, 170] + , palegreen: [152, 251, 152] + , paleturquoise: [175, 238, 238] + , palevioletred: [219, 112, 147] + , papayawhip: [255, 239, 213] + , peachpuff: [255, 218, 185] + , peru: [205, 133, 63] + , pink: [255, 192, 203] + , plum: [221, 160, 203] + , powderblue: [176, 224, 230] + , purple: [128, 0, 128] + , red: [255, 0, 0] + , rosybrown: [188, 143, 143] + , royalblue: [65, 105, 225] + , saddlebrown: [139, 69, 19] + , salmon: [250, 128, 114] + , sandybrown: [244, 164, 96] + , seagreen: [46, 139, 87] + , seashell: [255, 245, 238] + , sienna: [160, 82, 45] + , silver: [192, 192, 192] + , skyblue: [135, 206, 235] + , slateblue: [106, 90, 205] + , slategray: [119, 128, 144] + , slategrey: [119, 128, 144] + , snow: [255, 255, 250] + , springgreen: [0, 255, 127] + , steelblue: [70, 130, 180] + , tan: [210, 180, 140] + , teal: [0, 128, 128] + , thistle: [216, 191, 216] + , tomato: [255, 99, 71] + , turquoise: [64, 224, 208] + , violet: [238, 130, 238] + , wheat: [245, 222, 179] + , white: [255, 255, 255] + , whitesmoke: [245, 245, 245] + , yellow: [255, 255, 0] + , yellowgreen: [154, 205, 5] +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/convert/css.js b/node_modules/stylus/lib/convert/css.js new file mode 100644 index 0000000..503cbbf --- /dev/null +++ b/node_modules/stylus/lib/convert/css.js @@ -0,0 +1,130 @@ + +/*! + * Stylus - css to stylus conversion + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Convert the given `css` to stylus source. + * + * @param {String} css + * @return {String} + * @api public + */ + +module.exports = function(css){ + return new Converter(css).stylus(); +}; + +/** + * Initialize a new `Converter` with the given `css`. + * + * @param {String} css + * @api private + */ + +function Converter(css) { + var cssom = require('cssom'); + this.css = css; + this.types = cssom.CSSRule; + this.root = cssom.parse(css); + this.indents = 0; +} + +/** + * Convert to stylus. + * + * @return {String} + * @api private + */ + +Converter.prototype.stylus = function(){ + return this.visitRules(this.root.cssRules); +}; + +/** + * Return indent string. + * + * @return {String} + * @api private + */ + +Converter.prototype.__defineGetter__('indent', function(){ + return Array(this.indents + 1).join(' '); +}); + +/** + * Visit `node`. + * + * @param {CSSRule} node + * @return {String} + * @api private + */ + +Converter.prototype.visit = function(node){ + switch (node.type) { + case this.types.STYLE_RULE: + return this.visitStyle(node); + case this.types.MEDIA_RULE: + return this.visitMedia(node); + } +}; + +/** + * Visit the rules on `node`. + * + * @param {CSSRule} node + * @return {String} + * @api private + */ + +Converter.prototype.visitRules = function(node){ + var buf = ''; + for (var i = 0, len = node.length; i < len; ++i) { + buf += this.visit(node[i]); + } + return buf; +}; + +/** + * Visit CSSMediaRule `node`. + * + * @param {CSSMediaRule} node + * @return {String} + * @api private + */ + +Converter.prototype.visitMedia = function(node){ + var buf = this.indent + '@media '; + for (var i = 0, len = node.media.length; i < len; ++i) { + buf += node.media[i]; + } + buf += '\n'; + ++this.indents; + buf += this.visitRules(node.cssRules); + --this.indents; + return buf; +}; + +/** + * Visit CSSStyleRule `node`.` + * + * @param {CSSStyleRule} node + * @return {String} + * @api private + */ + +Converter.prototype.visitStyle = function(node){ + var buf = this.indent + node.selectorText + '\n'; + ++this.indents; + for (var i = 0, len = node.style.length; i < len; ++i) { + var prop = node.style[i] + , val = node.style[prop]; + if (prop) { + buf += this.indent + prop + ': ' + val + '\n'; + } + } + --this.indents; + return buf + '\n'; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/errors.js b/node_modules/stylus/lib/errors.js new file mode 100644 index 0000000..d3a6842 --- /dev/null +++ b/node_modules/stylus/lib/errors.js @@ -0,0 +1,58 @@ + +/*! + * Stylus - errors + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Expose constructors. + */ + +exports.ParseError = ParseError; +exports.SyntaxError = SyntaxError; + +/** + * Inherit from `Error.prototype`. + */ + +SyntaxError.prototype.__proto__ = Error.prototype; + +/** + * Initialize a new `ParseError` with the given `msg`. + * + * @param {String} msg + * @api private + */ + +function ParseError(msg) { + this.name = 'ParseError'; + this.message = msg; + Error.captureStackTrace(this, ParseError); +} + +/** + * Inherit from `Error.prototype`. + */ + +ParseError.prototype.__proto__ = Error.prototype; + +/** + * Initialize a new `SyntaxError` with the given `msg`. + * + * @param {String} msg + * @api private + */ + +function SyntaxError(msg) { + this.name = 'SyntaxError'; + this.message = msg; + Error.captureStackTrace(this, ParseError); +} + +/** + * Inherit from `Error.prototype`. + */ + +SyntaxError.prototype.__proto__ = Error.prototype; + diff --git a/node_modules/stylus/lib/functions/image.js b/node_modules/stylus/lib/functions/image.js new file mode 100644 index 0000000..cac0405 --- /dev/null +++ b/node_modules/stylus/lib/functions/image.js @@ -0,0 +1,121 @@ + + +/*! + * Stylus - plugin - url + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var utils = require('../utils') + , nodes = require('../nodes') + , fs = require('fs'); + +/** + * Initialize a new `Image` with the given `ctx` and `path. + * + * @param {Evaluator} ctx + * @param {String} path + * @api private + */ + +var Image = module.exports = function Image(ctx, path) { + this.ctx = ctx; + this.path = utils.lookup(path, ctx.paths); + if (!this.path) throw new Error('failed to locate file ' + path); +}; + +/** + * Open the image for reading. + * + * @api private + */ + +Image.prototype.open = function(){ + this.fd = fs.openSync(this.path, 'r'); +}; + +/** + * Close the file. + * + * @api private + */ + +Image.prototype.close = function(){ + if (this.fd) fs.closeSync(this.fd); +}; + +/** + * Return the type of image, supports: + * + * - gif + * - png + * - jpeg + * + * @return {String} + * @api private + */ + +Image.prototype.type = function(){ + var type + , buf = new Buffer(4); + + fs.readSync(this.fd, buf, 0, 4, 0); + + // GIF + if (0x47 == buf[0] && 0x49 == buf[1] && 0x46 == buf[2]) type = 'gif'; + + // PNG + else if (0x50 == buf[1] && 0x4E == buf[2] && 0x47 == buf[3]) type = 'png'; + + // JPEG + else if (0xff == buf[0] && 0xd8 == buf[1]) type = 'jpeg'; + + return type; +}; + +/** + * Return image dimensions `[width, height]`. + * + * @return {Array} + * @api private + */ + +Image.prototype.size = function(){ + var type = this.type() + , width + , height + , buf; + + function uint16(b) { return b[1] << 8 | b[0]; } + function uint32(b) { return b[0] << 24 | b[1] << 16 | b[2] << 8 | b[3]; } + + // Determine dimensions + switch (type) { + case 'jpeg': + throw new Error('image-size() jpeg support not yet implemented'); + break; + case 'png': + buf = new Buffer(8); + // IHDR chunk width / height uint32_t big-endian + fs.readSync(this.fd, buf, 0, 8, 16); + width = uint32(buf); + height = uint32(buf.slice(4, 8)); + break; + case 'gif': + buf = new Buffer(4); + // width / height uint16_t little-endian + fs.readSync(this.fd, buf, 0, 4, 6); + width = uint16(buf); + height = uint16(buf.slice(2, 4)); + break; + } + + if ('number' != typeof width) throw new Error('failed to find width of "' + this.path + '"'); + if ('number' != typeof height) throw new Error('failed to find height of "' + this.path + '"'); + + return [width, height]; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/functions/index.js b/node_modules/stylus/lib/functions/index.js new file mode 100644 index 0000000..3d6fca6 --- /dev/null +++ b/node_modules/stylus/lib/functions/index.js @@ -0,0 +1,727 @@ + +/*! + * Stylus - Evaluator - built-in functions + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Compiler = require('../visitor/compiler') + , nodes = require('../nodes') + , utils = require('../utils') + , Image = require('./image'); + +/** + * Color component name map. + */ + +var componentMap = { + red: 'r' + , green: 'g' + , blue: 'b' + , alpha: 'a' + , hue: 'h' + , saturation: 's' + , lightness: 'l' +}; + +/** + * Color component unit type map. + */ + +var unitMap = { + hue: 'deg' + , saturation: '%' + , lightness: '%' +}; + +/** + * Color type map. + */ + +var typeMap = { + red: 'rgba' + , blue: 'rgba' + , green: 'rgba' + , alpha: 'rgba' + , hue: 'hsla' + , saturation: 'hsla' + , lightness: 'hsla' +}; + +/** + * Convert the given `color` to an `HSLA` node, + * or h,s,l,a component values. + * + * Examples: + * + * hsla(10deg, 50%, 30%, 0.5) + * // => HSLA + * + * hsla(#ffcc00) + * // => HSLA + * + * @param {RGBA|HSLA|Unit} hue + * @param {Unit} saturation + * @param {Unit} lightness + * @param {Unit} alpha + * @return {HSLA} + * @api public + */ + +exports.hsla = function hsla(hue, saturation, lightness, alpha){ + if (alpha && '%' == alpha.type) alpha.val /= 100; + switch (arguments.length) { + case 1: + utils.assertColor(hue); + return hue.hsla; + default: + utils.assertType(hue, 'unit', 'hue'); + utils.assertType(saturation, 'unit', 'saturation'); + utils.assertType(lightness, 'unit', 'lightness'); + utils.assertType(alpha, 'unit', 'alpha'); + return new nodes.HSLA( + hue.val + , saturation.val + , lightness.val + , alpha.val); + } +}; + +/** + * Convert the given `color` to an `HSLA` node, + * or h,s,l component values. + * + * Examples: + * + * hsl(10, 50, 30) + * // => HSLA + * + * hsl(#ffcc00) + * // => HSLA + * + * @param {Unit|HSLA|RGBA} hue + * @param {Unit} saturation + * @param {Unit} lightness + * @return {HSLA} + * @api public + */ + +exports.hsl = function hsl(hue, saturation, lightness){ + if (1 == arguments.length) { + utils.assertColor(hue, 'color'); + return hue.hsla; + } else { + return exports.hsla( + hue + , saturation + , lightness + , new nodes.Unit(1)); + } +}; + +/** + * Return type of `node`. + * + * Examples: + * + * type(12) + * // => 'unit' + * + * type(#fff) + * // => 'color' + * + * type(type) + * // => 'function' + * + * type(unbound) + * typeof(unbound) + * type-of(unbound) + * // => 'ident' + * + * @param {Node} node + * @return {String} + * @api public + */ + +exports.type = +exports.typeof = +exports['type-of'] = function type(node){ + utils.assertPresent(node, 'expression'); + return node.nodeName; +}; + +/** + * Return component `name` for the given `color`. + * + * @param {RGBA|HSLA} color + * @param {String} na,e + * @return {Unit} + * @api public + */ + +exports.component = function component(color, name) { + utils.assertColor(color, 'color'); + utils.assertString(name, 'name'); + var name = name.string + , unit = unitMap[name] + , type = typeMap[name] + , name = componentMap[name]; + if (!name) throw new Error('invalid color component "' + name + '"'); + return new nodes.Unit(color[type][name], unit); +}; + +/** + * Return the red component of the given `color`. + * + * Examples: + * + * red(#c00) + * // => 204 + * + * @param {RGBA|HSLA} color + * @return {Unit} + * @api public + */ + +exports.red = function red(color){ + return exports.component(color, new nodes.String('red')); +}; + +/** + * Return the green component of the given `color`. + * + * Examples: + * + * green(#0c0) + * // => 204 + * + * @param {RGBA|HSLA} color + * @return {Unit} + * @api public + */ + +exports.green = function green(color){ + return exports.component(color, new nodes.String('green')); +}; + +/** + * Return the blue component of the given `color`. + * + * Examples: + * + * blue(#00c) + * // => 204 + * + * @param {RGBA|HSLA} color + * @return {Unit} + * @api public + */ + +exports.blue = function blue(color){ + return exports.component(color, new nodes.String('blue')); +}; + +/** + * Return a `RGBA` from the r,g,b,a channels. + * + * Examples: + * + * rgba(255,0,0,0.5) + * // => rgba(255,0,0,0.5) + * + * rgba(255,0,0,1) + * // => #ff0000 + * + * rgba(#ffcc00, 0.5) + * // rgba(255,204,0,0.5) + * + * @param {Unit|RGBA|HSLA} red + * @param {Unit} green + * @param {Unit} blue + * @param {Unit} alpha + * @return {RGBA} + * @api public + */ + +exports.rgba = function rgba(red, green, blue, alpha){ + if (alpha && '%' == alpha.type) alpha.val /= 100; + switch (arguments.length) { + case 1: + utils.assertColor(red); + var color = red.rgba; + return new nodes.RGBA( + color.r + , color.g + , color.b + , color.a); + case 2: + utils.assertColor(red); + var color = red.rgba; + utils.assertType(green, 'unit', 'alpha'); + return new nodes.RGBA( + color.r + , color.g + , color.b + , green.val); + default: + utils.assertType(red, 'unit', 'red'); + utils.assertType(green, 'unit', 'green'); + utils.assertType(blue, 'unit', 'blue'); + utils.assertType(alpha, 'unit', 'alpha'); + var r = '%' == red.type ? Math.round(red.val * 2.55) : red.val; + var g = '%' == green.type ? Math.round(green.val * 2.55) : green.val; + var b = '%' == blue.type ? Math.round(blue.val * 2.55) : blue.val; + return new nodes.RGBA( + r + , g + , b + , alpha.val); + } +}; + +/** + * Return a `RGBA` from the r,g,b channels. + * + * Examples: + * + * rgb(255,204,0) + * // => #ffcc00 + * + * rgb(#fff) + * // => #fff + * + * @param {Unit|RGBA|HSLA} red + * @param {Unit} green + * @param {Unit} blue + * @return {RGBA} + * @api public + */ + +exports.rgb = function rgb(red, green, blue){ + switch (arguments.length) { + case 1: + utils.assertColor(red); + var color = red.rgba; + return new nodes.RGBA( + color.r + , color.g + , color.b + , 1); + default: + return exports.rgba( + red + , green + , blue + , new nodes.Unit(1)); + } +}; + +/** + * Unquote the given `str`. + * + * Examples: + * + * unquote("sans-serif") + * // => sans-serif + * + * unquote(sans-serif) + * // => sans-serif + * + * @param {String|Ident} string + * @return {Literal} + * @api public + */ + +exports.unquote = function unquote(string){ + utils.assertString(string, 'string'); + return new nodes.Literal(string.string); +}; + +/** + * Assign `type` to the given `unit` or return `unit`'s type. + * + * @param {Unit} unit + * @param {String|Ident} type + * @return {Unit} + * @api public + */ + +exports.unit = function unit(unit, type){ + utils.assertType(unit, 'unit', 'unit'); + + // Assign + if (type) { + utils.assertString(type, 'type'); + return new nodes.Unit(unit.val, type.string); + } else { + return unit.type || ''; + } +}; + +/** + * Lookup variable `name` or return Null. + * + * @param {String} name + * @return {Mixed} + * @api public + */ + +exports.lookup = function lookup(name){ + utils.assertType(name, 'string', 'name'); + var node = this.lookup(name.val); + if (!node) return nodes.null; + return this.visit(node); +}; + +/** + * Perform `op` on the `left` and `right` operands. + * + * @param {String} op + * @param {Node} left + * @param {Node} right + * @return {Node} + * @api public + */ + +exports.operate = function operate(op, left, right){ + utils.assertType(op, 'string', 'op'); + utils.assertPresent(left, 'left'); + utils.assertPresent(right, 'right'); + return left.operate(op.val, right); +}; + +/** + * Test if `val` matches the given `pattern`. + * + * Examples: + * + * match('^foo(bar)?', foo) + * match('^foo(bar)?', foobar) + * match('^foo(bar)?', 'foo') + * match('^foo(bar)?', 'foobar') + * // => true + * + * match('^foo(bar)?', 'bar') + * // => false + * + * @param {String} pattern + * @param {String|Ident} val + * @return {Boolean} + * @api public + */ + +exports.match = function match(pattern, val){ + utils.assertType(pattern, 'string', 'pattern'); + utils.assertString(val, 'val'); + var re = new RegExp(pattern.val); + return nodes.Boolean(re.test(val.string)); +}; + +/** + * Return length of the given `expr`. + * + * @param {Expression} expr + * @return {Unit} + * @api public + */ + +(exports.length = function length(expr){ + if (expr) { + return expr.nodes + ? utils.unwrap(expr).nodes.length + : 1; + } + return 0; +}).raw = true; + +/** + * Inspect the given `expr`. + * + * @param {Expression} expr + * @api public + */ + +(exports.p = function p(){ + [].slice.call(arguments).forEach(function(expr){ + expr = utils.unwrap(expr); + if (!expr.nodes.length) return; + console.log('\033[90minspect:\033[0m %s', expr.toString().replace(/^\(|\)$/g, '')); + }) + return nodes.null; +}).raw = true; + +/** + * Throw an error with the given `msg`. + * + * @param {String} msg + * @api public + */ + +exports.error = function error(msg){ + utils.assertType(msg, 'string', 'msg'); + throw new Error(msg.val); +}; + +/** + * Warn with the given `msg` prefixed by "Warning: ". + * + * @param {String} msg + * @api public + */ + +exports.warn = function warn(msg){ + utils.assertType(msg, 'string', 'msg'); + console.warn('Warning: %s', msg.val); + return nodes.null; +}; + +/** + * Output stack trace. + * + * @api public + */ + +exports.trace = function trace(){ + console.log(this.stack); + return nodes.null; +}; + +/** + * Push the given args to `expr`. + * + * @param {Expression} expr + * @param {Node} ... + * @return {Unit} + * @api public + */ + +(exports.push = exports.append = function(expr){ + expr = utils.unwrap(expr); + for (var i = 1, len = arguments.length; i < len; ++i) { + expr.nodes.push(utils.unwrap(arguments[i])); + } + return expr.nodes.length; +}).raw = true; + +/** + * Unshift the given args to `expr`. + * + * @param {Expression} expr + * @param {Node} ... + * @return {Unit} + * @api public + */ + +(exports.unshift = exports.prepend = function(expr){ + expr = utils.unwrap(expr); + for (var i = 1, len = arguments.length; i < len; ++i) { + expr.nodes.unshift(utils.unwrap(arguments[i])); + } + return expr.nodes.length; +}).raw = true; + +/** + * Return a `Literal` with the given `fmt`, and + * variable number of arguments. + * + * @param {String} fmt + * @param {Node} ... + * @return {Literal} + * @api public + */ + +(exports.s = function s(fmt){ + fmt = utils.unwrap(fmt).nodes[0]; + utils.assertString(fmt); + var self = this + , str = fmt.string + , args = arguments + , i = 1; + + // format + str = str.replace(/%(s|d)/g, function(_, specifier){ + var arg = args[i++] || nodes.null; + switch (specifier) { + case 's': + return new Compiler(arg, self.options).compile(); + case 'd': + arg = utils.unwrap(arg).first; + if ('unit' != arg.nodeName) throw new Error('%d requires a unit'); + return arg.val; + } + }); + + return new nodes.Literal(str); +}).raw = true; + +/** + * Return the opposites of the given `positions`. + * + * Examples: + * + * opposite-position(top left) + * // => bottom right + * + * @param {Expression} positions + * @return {Expression} + * @api public + */ + +(exports['opposite-position'] = function oppositePosition(positions){ + var expr = []; + utils.unwrap(positions).nodes.forEach(function(pos, i){ + utils.assertString(pos, 'position ' + i); + pos = (function(){ switch (pos.string) { + case 'top': return 'bottom'; + case 'bottom': return 'top'; + case 'left': return 'right'; + case 'right': return 'left'; + case 'center': return 'center'; + default: throw new Error('invalid position ' + pos); + }})(); + expr.push(new nodes.Literal(pos)); + }); + return expr; +}).raw = true; + +/** + * Return the width and height of the given `img` path. + * + * Examples: + * + * image-size('foo.png') + * // => 200px 100px + * + * image-size('foo.png')[0] + * // => 200px + * + * image-size('foo.png')[1] + * // => 100px + * + * @param {String} img + * @return {Expression} + * @api public + */ + +exports['image-size'] = function imageSize(img) { + utils.assertType(img, 'string', 'img'); + var img = new Image(this, img.string); + + // Read size + img.open(); + var size = img.size(); + img.close(); + + // Return (w h) + var expr = []; + expr.push(new nodes.Unit(size[0], 'px')); + expr.push(new nodes.Unit(size[1], 'px')); + + return expr; +}; + +/** + * Apply Math `fn` to `n`. + * + * @param {Unit} n + * @param {String} fn + * @return {Unit} + * @api private + */ + +exports['-math'] = function math(n, fn){ + return new nodes.Unit(Math[fn.string](n.val), n.type); +}; + +/** + * Get Math `prop`. + * + * @param {String} prop + * @return {Unit} + * @api private + */ + +exports['-math-prop'] = function math(prop){ + return new nodes.Unit(Math[prop.string]); +}; + +/** + * Buffer the given js `str`. + * + * @param {String} str + * @return {JSLiteral} + * @api private + */ + +exports.js = function js(str){ + utils.assertString(str, 'str'); + return new nodes.JSLiteral(str.val); +}; + +/** + * Adjust HSL `color` `prop` by `amount`. + * + * @param {RGBA|HSLA} color + * @param {String} prop + * @param {Unit} amount + * @return {RGBA} + * @api private + */ + +exports['-adjust'] = function adjust(color, prop, amount){ + var hsl = color.hsla.clone(); + prop = { hue: 'h', saturation: 's', lightness: 'l' }[prop.string]; + if (!prop) throw new Error('invalid adjustment property'); + var val = amount.val; + if ('%' == amount.type){ + val = 'l' == prop && val > 0 + ? (100 - hsl[prop]) * val / 100 + : hsl[prop] * (val / 100); + } + hsl[prop] += val; + return hsl.rgba; +}; + +/** + * Return a clone of the given `expr`. + * + * @param {Expression} expr + * @return {Node} + * @api public + */ + +(exports.clone = function clone(expr){ + utils.assertPresent(expr, 'expr'); + return expr.clone(); +}).raw = true; + +/** + * Add property `name` with the given `expr` + * to the mixin-able block. + * + * @param {String|Ident|Literal} name + * @param {Expression} expr + * @return {Property} + * @api public + */ + +(exports['add-property'] = function addProperty(name, expr){ + utils.assertType(name, 'expression', 'name'); + name = utils.unwrap(name).first; + utils.assertString(name, 'name'); + utils.assertType(expr, 'expression', 'expr'); + var prop = new nodes.Property([name], expr); + var block = this.closestBlock; + + var len = block.nodes.length + , head = block.nodes.slice(0, block.index) + , tail = block.nodes.slice(block.index++, len); + head.push(prop); + block.nodes = head.concat(tail); + + return prop; +}).raw = true; diff --git a/node_modules/stylus/lib/functions/index.styl b/node_modules/stylus/lib/functions/index.styl new file mode 100644 index 0000000..5d2536b --- /dev/null +++ b/node_modules/stylus/lib/functions/index.styl @@ -0,0 +1,198 @@ +vendors = moz webkit o ms official + +// stringify the given arg + +-string(arg) + type(arg) + ' ' + arg + +// require a color + +require-color(color) + unless color is a 'color' + error('RGB or HSL value expected, got a ' + -string(color)) + +// require a unit + +require-unit(n) + unless n is a 'unit' + error('unit expected, got a ' + -string(n)) + +// require a string + +require-string(str) + unless str is a 'string' or str is a 'ident' + error('string expected, got a ' + -string(str)) + +// apply js Math function + +math(n, fn) + require-unit(n) + require-string(fn) + -math(n, fn) + +// adjust the given color's property by amount + +adjust(color, prop, amount) + require-color(color) + require-string(prop) + require-unit(amount) + -adjust(color, prop, amount) + +// Math functions + +abs(n) { math(n, 'abs') } +ceil(n) { math(n, 'ceil') } +floor(n) { math(n, 'floor') } +round(n) { math(n, 'round') } +sin(n) { math(n, 'sin') } +cos(n) { math(n, 'cos') } +min(a, b) { a < b ? a : b } +max(a, b) { a > b ? a : b } +PI = -math-prop('PI') + +// return the sum of the given numbers + +sum(nums) + sum = 0 + sum += n for n in nums + +// return the average of the given numbers + +avg(nums) + sum(nums) / length(nums) + +// color components + +alpha(color) { component(hsl(color), 'alpha') } +hue(color) { component(hsl(color), 'hue') } +saturation(color) { component(hsl(color), 'saturation') } +lightness(color) { component(hsl(color), 'lightness') } + +// check if n is an odd number + +odd(n) + 1 == n % 2 + +// check if n is an even number + +even(n) + 0 == n % 2 + +// check if color is light + +light(color) + lightness(color) >= 50% + +// check if color is dark + +dark(color) + lightness(color) < 50% + +// desaturate color by amount + +desaturate(color, amount) + adjust(color, 'saturation', - amount) + +// saturate color by amount + +saturate(color, amount) + adjust(color, 'saturation', amount) + +// darken by the given amount + +darken(color, amount) + adjust(color, 'lightness', - amount) + +// lighten by the given amount + +lighten(color, amount) + adjust(color, 'lightness', amount) + +// decerase opacity by amount + +fade-out(color, amount) + color - rgba(black, amount) + +// increase opacity by amount + +fade-in(color, amount) + color + rgba(black, amount) + +// spin hue by a given amount + +spin(color, amount) + color + unit(amount, deg) + +// mix two colors by a given amount + +mix(color1, color2, weight = 50%) + unless weight in 0..100 + error("Weight must be between 0% and 100%") + + if length(color1) == 2 + weight = color1[0] + color1 = color1[1] + + else if length(color2) == 2 + weight = 100 - color2[0] + color2 = color2[1] + + require-color(color1) + require-color(color2) + + p = unit(weight / 100, '') + w = p * 2 - 1 + + a = alpha(color1) - alpha(color2) + + w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2 + w2 = 1 - w1 + + channels = (red(color1) red(color2)) (green(color1) green(color2)) (blue(color1) blue(color2)) + rgb = () + + for pair in channels + push(rgb, floor(pair[0] * w1 + pair[1] * w2)) + + a1 = alpha(color1) * p + a2 = alpha(color1) * (1 - p) + alpha = a1 + a2 + + rgba(rgb[0], rgb[1], rgb[2], alpha) + +// invert colors, leave alpha intact + +invert(color) + r = 255 - red(color) + g = 255 - green(color) + b = 255 - blue(color) + rgba(r,g,b,alpha(color)) + +// return the last value in the given expr + +last(expr) + expr[length(expr) - 1] + +// return keys in the given pairs + +keys(pairs) + ret = () + for pair in pairs + push(ret, pair[0]); + ret + +// return values in the given pairs + +values(pairs) + ret = () + for pair in pairs + push(ret, pair[1]); + ret + +// join values with the given delimiter + +join(delim, vals...) + buf = '' + vals = vals[0] if length(vals) == 1 + for val, i in vals + buf += i ? delim + val : val diff --git a/node_modules/stylus/lib/functions/url.js b/node_modules/stylus/lib/functions/url.js new file mode 100644 index 0000000..26e1fe2 --- /dev/null +++ b/node_modules/stylus/lib/functions/url.js @@ -0,0 +1,98 @@ + +/*! + * Stylus - plugin - url + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Compiler = require('../visitor/compiler') + , nodes = require('../nodes') + , parse = require('url').parse + , extname = require('path').extname + , utils = require('../utils') + , fs = require('fs'); + +/** + * Mime table. + */ + +var mimes = { + '.gif': 'image/gif' + , '.png': 'image/png' + , '.jpg': 'image/jpeg' + , '.jpeg': 'image/jpeg' + , '.svg': 'image/svg+xml' +}; + +/** + * Return a url() function with the given `options`. + * + * Options: + * + * - `limit` bytesize limit defaulting to 30Kb + * - `paths` image resolution path(s), merged with general lookup paths + * + * Examples: + * + * stylus(str) + * .set('filename', __dirname + '/css/test.styl') + * .define('url', stylus.url({ paths: [__dirname + '/public'] })) + * .render(function(err, css){ ... }) + * + * @param {Object} options + * @return {Function} + * @api public + */ + +module.exports = function(options) { + options = options || {}; + + var sizeLimit = options.limit || 30000 + , _paths = options.paths || []; + + function url(url){ + // Compile the url + var compiler = new Compiler(url); + compiler.isURL = true; + var url = url.nodes.map(function(node){ + return compiler.visit(node); + }).join(''); + + // Parse literal + var url = parse(url) + , ext = extname(url.pathname) + , mime = mimes[ext] + , literal = new nodes.Literal('url("' + url.href + '")') + , paths = _paths.concat(this.paths) + , founds + , buf; + + // Not supported + if (!mime) return literal; + + // Absolute + if (url.protocol) return literal; + + // Lookup + var found = utils.lookup(url.pathname, paths); + + // Failed to lookup + if (!found) return literal; + + // Read data + buf = fs.readFileSync(found); + + // To large + if (buf.length > sizeLimit) return literal; + + // Encode + return new nodes.Literal('url("data:' + mime + ';base64,' + buf.toString('base64') + '")'); + }; + + url.raw = true; + return url; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/lexer.js b/node_modules/stylus/lib/lexer.js new file mode 100644 index 0000000..18c203a --- /dev/null +++ b/node_modules/stylus/lib/lexer.js @@ -0,0 +1,790 @@ + +/*! + * Stylus - Lexer + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Token = require('./token') + , nodes = require('./nodes') + , errors = require('./errors') + , units = require('./units'); + +/** + * Expose `Lexer`. + */ + +exports = module.exports = Lexer; + +/** + * Operator aliases. + */ + +var alias = { + 'and': '&&' + , 'or': '||' + , 'is': '==' + , 'isnt': '!=' + , 'is not': '!=' + , ':=': '?=' +}; + +/** + * Units. + */ + +units = units.join('|'); + +/** + * Unit RegExp. + */ + +var unit = new RegExp('^(-)?(\\d+\\.\\d+|\\d+|\\.\\d+)(' + units + ')?[ \\t]*'); + +/** + * Initialize a new `Lexer` with the given `str` and `options`. + * + * @param {String} str + * @param {Object} options + * @api private + */ + +function Lexer(str, options) { + options = options || {}; + this.stash = []; + this.indentStack = []; + this.indentRe = null; + this.lineno = 1; + + function comment(str, val, offset, s) { + return s.lastIndexOf('/*', offset) > s.lastIndexOf('*/', offset) + ? str + : val; + }; + + this.str = str + .replace(/\r\n?/g, '\n') + .replace(/\\ *\n/g, ' ') + .replace(/([,:(]) *\n\s*/g, comment) + .replace(/\s*\n *([,)])/g, comment); +}; + +/** + * Lexer prototype. + */ + +Lexer.prototype = { + + /** + * Custom inspect. + */ + + inspect: function(){ + var tok + , tmp = this.str + , buf = []; + while ('eos' != (tok = this.next()).type) { + buf.push(tok.inspect()); + } + this.str = tmp; + this.prevIndents = 0; + return buf.concat(tok.inspect()).join('\n'); + }, + + /** + * Lookahead `n` tokens. + * + * @param {Number} n + * @return {Object} + * @api private + */ + + lookahead: function(n){ + var fetch = n - this.stash.length; + while (fetch-- > 0) this.stash.push(this.advance()); + return this.stash[--n]; + }, + + /** + * Consume the given `len`. + * + * @param {Number|Array} len + * @api private + */ + + skip: function(len){ + this.str = this.str.substr(Array.isArray(len) + ? len[0].length + : len); + }, + + /** + * Fetch next token including those stashed by peek. + * + * @return {Token} + * @api private + */ + + next: function() { + var tok = this.stashed() || this.advance(); + switch (tok.type) { + case 'newline': + case 'indent': + ++this.lineno; + break; + case 'outdent': + if ('outdent' != this.prev.type) ++this.lineno; + } + this.prev = tok; + tok.lineno = this.lineno; + return tok; + }, + + /** + * Fetch next token. + * + * @return {Token} + * @api private + */ + + advance: function() { + return this.eos() + || this.null() + || this.sep() + || this.keyword() + || this.urlchars() + || this.atrule() + || this.scope() + || this.extends() + || this.media() + || this.comment() + || this.newline() + || this.escaped() + || this.important() + || this.literal() + || this.function() + || this.brace() + || this.paren() + || this.color() + || this.string() + || this.unit() + || this.namedop() + || this.boolean() + || this.ident() + || this.op() + || this.space() + || this.selector(); + }, + + /** + * Lookahead a single token. + * + * @return {Token} + * @api private + */ + + peek: function() { + return this.lookahead(1); + }, + + /** + * Return the next possibly stashed token. + * + * @return {Token} + * @api private + */ + + stashed: function() { + return this.stash.shift(); + }, + + /** + * EOS | trailing outdents. + */ + + eos: function() { + if (this.str.length) return; + if (this.indentStack.length) { + this.indentStack.shift(); + return new Token('outdent'); + } else { + return new Token('eos'); + } + }, + + /** + * url char + */ + + urlchars: function() { + var captures; + if (!this.isURL) return; + if (captures = /^[\/:@.;?&=*!,<>#%0-9]+/.exec(this.str)) { + this.skip(captures); + return new Token('literal', new nodes.Literal(captures[0])); + } + }, + + /** + * ';' [ \t]* + */ + + sep: function() { + var captures; + if (captures = /^;[ \t]*/.exec(this.str)) { + this.skip(captures); + return new Token(';'); + } + }, + + /** + * ' '+ + */ + + space: function() { + var captures; + if (captures = /^([ \t]+)/.exec(this.str)) { + this.skip(captures); + return new Token('space'); + } + }, + + /** + * '\\' . ' '* + */ + + escaped: function() { + var captures; + if (captures = /^\\(.)[ \t]*/.exec(this.str)) { + var c = captures[1]; + this.skip(captures); + return new Token('ident', new nodes.Literal(c)); + } + }, + + /** + * '@css' ' '* '{' .* '}' ' '* + */ + + literal: function() { + // HACK attack !!! + var captures; + if (captures = /^@css[ \t]*\{/.exec(this.str)) { + this.skip(captures); + var c + , braces = 1 + , css = ''; + while (c = this.str[0]) { + this.str = this.str.substr(1); + switch (c) { + case '{': ++braces; break; + case '}': --braces; break; + } + css += c; + if (!braces) break; + } + css = css.replace(/\s*}$/, ''); + return new Token('literal', new nodes.Literal(css)); + } + }, + + /** + * '!important' ' '* + */ + + important: function() { + var captures; + if (captures = /^!important[ \t]*/.exec(this.str)) { + this.skip(captures); + return new Token('ident', new nodes.Literal('!important')); + } + }, + + /** + * '{' | '}' + */ + + brace: function() { + var captures; + if (captures = /^([{}])/.exec(this.str)) { + this.skip(1); + var brace = captures[1]; + return new Token(brace, brace); + } + }, + + /** + * '(' | ')' ' '* + */ + + paren: function() { + var captures; + if (captures = /^([()])([ \t]*)/.exec(this.str)) { + var paren = captures[1]; + this.skip(captures); + if (')' == paren) this.isURL = false; + var tok = new Token(paren, paren); + tok.space = captures[2]; + return tok; + } + }, + + /** + * 'null' + */ + + null: function() { + var captures; + if (captures = /^(null)\b[ \t]*/.exec(this.str)) { + this.skip(captures); + return new Token('null', nodes.null); + } + }, + + /** + * 'if' + * | 'else' + * | 'unless' + * | 'return' + * | 'for' + * | 'in' + */ + + keyword: function() { + var captures; + if (captures = /^(return|if|else|unless|for|in)\b[ \t]*/.exec(this.str)) { + var keyword = captures[1]; + this.skip(captures); + return new Token(keyword, keyword); + } + }, + + /** + * 'not' + * | 'and' + * | 'or' + * | 'is' + * | 'is not' + * | 'isnt' + * | 'is a' + * | 'is defined' + */ + + namedop: function() { + var captures; + if (captures = /^(not|and|or|is a|is defined|isnt|is not|is)(?!-)\b([ \t]*)/.exec(this.str)) { + var op = captures[1]; + this.skip(captures); + op = alias[op] || op; + var tok = new Token(op, op); + tok.space = captures[2]; + return tok; + } + }, + + /** + * ',' + * | '+' + * | '+=' + * | '-' + * | '-=' + * | '*' + * | '*=' + * | '/' + * | '/=' + * | '%' + * | '%=' + * | '**' + * | '!' + * | '&' + * | '&&' + * | '||' + * | '>' + * | '>=' + * | '<' + * | '<=' + * | '=' + * | '==' + * | '!=' + * | '!' + * | '~' + * | '?=' + * | ':=' + * | '?' + * | ':' + * | '[' + * | ']' + * | '..' + * | '...' + */ + + op: function() { + var captures; + if (captures = /^([.]{2,3}|&&|\|\||[!<>=?:]=|\*\*|[-+*\/%]=?|[,=?:!~<>&\[\]])([ \t]*)/.exec(this.str)) { + var op = captures[1]; + this.skip(captures); + op = alias[op] || op; + var tok = new Token(op, op); + tok.space = captures[2]; + return tok; + } + }, + + /** + * '@extends' ([^{\n]+) + */ + + extends: function() { + var captures; + if (captures = /^@extends?[ \t]*([^\/{\n;]+)/.exec(this.str)) { + this.skip(captures); + return new Token('extend', captures[1].trim()); + } + }, + + /** + * '@media' ([^{\n]+) + */ + + media: function() { + var captures; + if (captures = /^@media[ \t]*([^\/{\n]+)/.exec(this.str)) { + this.skip(captures); + return new Token('media', captures[1].trim()); + } + }, + + /** + * '@scope' ([^{\n]+) + */ + + scope: function() { + var captures; + if (captures = /^@scope[ \t]*([^\/{\n]+)/.exec(this.str)) { + this.skip(captures); + return new Token('scope', captures[1].trim()); + } + }, + + /** + * '@' ('import' | 'keyframes' | 'charset' | 'page' | 'font-face') + */ + + atrule: function() { + var captures; + if (captures = /^@(import|(?:-(\w+)-)?keyframes|charset|font-face|page)[ \t]*/.exec(this.str)) { + this.skip(captures); + var vendor = captures[2] + , type = captures[1]; + if (vendor) type = 'keyframes'; + return new Token(type, vendor); + } + }, + + /** + * '//' * + */ + + comment: function() { + // Single line + if ('/' == this.str[0] && '/' == this.str[1]) { + var end = this.str.indexOf('\n'); + if (-1 == end) end = this.str.length; + this.skip(end); + return this.advance(); + } + + // Multi-line + if ('/' == this.str[0] && '*' == this.str[1]) { + var end = this.str.indexOf('*/'); + if (-1 == end) end = this.str.length; + var str = this.str.substr(0, end + 2) + , lines = str.split('\n').length - 1 + , suppress = true; + this.lineno += lines; + this.skip(end + 2); + // output + if ('!' == str[2]) { + str = str.replace('*!', '*'); + suppress = false; + } + return new Token('comment', new nodes.Comment(str, suppress)); + } + }, + + /** + * 'true' | 'false' + */ + + boolean: function() { + var captures; + if (captures = /^(true|false)\b([ \t]*)/.exec(this.str)) { + var val = nodes.Boolean('true' == captures[1]); + this.skip(captures); + var tok = new Token('boolean', val); + tok.space = captures[2]; + return tok; + } + }, + + /** + * -*[_a-zA-Z$] [-\w\d$]* '(' + */ + + function: function() { + var captures; + if (captures = /^(-*[_a-zA-Z$][-\w\d$]*)\(([ \t]*)/.exec(this.str)) { + var name = captures[1]; + this.skip(captures); + this.isURL = 'url' == name; + var tok = new Token('function', new nodes.Ident(name)); + tok.space = captures[2]; + return tok; + } + }, + + /** + * -*[_a-zA-Z$] [-\w\d$]* + */ + + ident: function() { + var captures; + if (captures = /^(@)?(-*[_a-zA-Z$][-\w\d$]*)/.exec(this.str)) { + var at = captures[1] + , name = captures[2] + , id = new nodes.Ident(name); + this.skip(captures); + id.property = !! at; + return new Token('ident', id); + } + }, + + /** + * '\n' ' '+ + */ + + newline: function() { + var captures, re; + + // we have established the indentation regexp + if (this.indentRe){ + captures = this.indentRe.exec(this.str); + // figure out if we are using tabs or spaces + } else { + // try tabs + re = /^\n([\t]*)[ \t]*/; + captures = re.exec(this.str); + + // nope, try spaces + if (captures && !captures[1].length) { + re = /^\n([ \t]*)/; + captures = re.exec(this.str); + } + + // established + if (captures && captures[1].length) this.indentRe = re; + } + + + if (captures) { + var tok + , indents = captures[1].length; + + this.skip(captures); + if (this.str[0] === ' ' || this.str[0] === '\t') { + throw new errors.SyntaxError('Invalid indentation. You can use tabs or spaces to indent, but not both.'); + } + + // Reset state + this.isVariable = false; + + // Blank line + if ('\n' == this.str[0]) { + ++this.lineno; + return this.advance(); + } + + // Outdent + if (this.indentStack.length && indents < this.indentStack[0]) { + while (this.indentStack.length && this.indentStack[0] > indents) { + this.stash.push(new Token('outdent')); + this.indentStack.shift(); + } + tok = this.stash.pop(); + // Indent + } else if (indents && indents != this.indentStack[0]) { + this.indentStack.unshift(indents); + tok = new Token('indent'); + // Newline + } else { + tok = new Token('newline'); + } + + return tok; + } + }, + + /** + * '-'? (digit+ | digit* '.' digit+) unit + */ + + unit: function() { + var captures; + if (captures = unit.exec(this.str)) { + this.skip(captures); + var n = parseFloat(captures[2]); + if ('-' == captures[1]) n = -n; + var node = new nodes.Unit(n, captures[3]); + return new Token('unit', node); + } + }, + + /** + * '"' [^"]+ '"' | "'"" [^']+ "'" + */ + + string: function() { + var captures; + if (captures = /^("[^"]*"|'[^']*')[ \t]*/.exec(this.str)) { + var str = captures[1] + , quote = captures[0][0]; + this.skip(captures); + str = str.slice(1,-1).replace(/\\n/g, '\n'); + return new Token('string', new nodes.String(str, quote)); + } + }, + + /** + * #rrggbbaa | #rrggbb | #rgba | #rgb | #nn | #n + */ + + color: function() { + return this.rrggbbaa() + || this.rrggbb() + || this.rgba() + || this.rgb() + || this.nn() + || this.n() + }, + + /** + * #n + */ + + n: function() { + var captures; + if (captures = /^#([a-fA-F0-9]{1})[ \t]*/.exec(this.str)) { + this.skip(captures); + var n = parseInt(captures[1] + captures[1], 16) + , color = new nodes.RGBA(n, n, n, 1); + color.raw = captures[0]; + return new Token('color', color); + } + }, + + /** + * #nn + */ + + nn: function() { + var captures; + if (captures = /^#([a-fA-F0-9]{2})[ \t]*/.exec(this.str)) { + this.skip(captures); + var n = parseInt(captures[1], 16) + , color = new nodes.RGBA(n, n, n, 1); + color.raw = captures[0]; + return new Token('color', color); + } + }, + + /** + * #rgb + */ + + rgb: function() { + var captures; + if (captures = /^#([a-fA-F0-9]{3})[ \t]*/.exec(this.str)) { + this.skip(captures); + var rgb = captures[1] + , r = parseInt(rgb[0] + rgb[0], 16) + , g = parseInt(rgb[1] + rgb[1], 16) + , b = parseInt(rgb[2] + rgb[2], 16) + , color = new nodes.RGBA(r, g, b, 1); + color.raw = captures[0]; + return new Token('color', color); + } + }, + + /** + * #rgba + */ + + rgba: function() { + var captures; + if (captures = /^#([a-fA-F0-9]{4})[ \t]*/.exec(this.str)) { + this.skip(captures); + var rgb = captures[1] + , r = parseInt(rgb[0] + rgb[0], 16) + , g = parseInt(rgb[1] + rgb[1], 16) + , b = parseInt(rgb[2] + rgb[2], 16) + , a = parseInt(rgb[3] + rgb[3], 16) + , color = new nodes.RGBA(r, g, b, a/255); + color.raw = captures[0]; + return new Token('color', color); + } + }, + + /** + * #rrggbb + */ + + rrggbb: function() { + var captures; + if (captures = /^#([a-fA-F0-9]{6})[ \t]*/.exec(this.str)) { + this.skip(captures); + var rgb = captures[1] + , r = parseInt(rgb.substr(0, 2), 16) + , g = parseInt(rgb.substr(2, 2), 16) + , b = parseInt(rgb.substr(4, 2), 16) + , color = new nodes.RGBA(r, g, b, 1); + color.raw = captures[0]; + return new Token('color', color); + } + }, + + /** + * #rrggbbaa + */ + + rrggbbaa: function() { + var captures; + if (captures = /^#([a-fA-F0-9]{8})[ \t]*/.exec(this.str)) { + this.skip(captures); + var rgb = captures[1] + , r = parseInt(rgb.substr(0, 2), 16) + , g = parseInt(rgb.substr(2, 2), 16) + , b = parseInt(rgb.substr(4, 2), 16) + , a = parseInt(rgb.substr(6, 2), 16) + , color = new nodes.RGBA(r, g, b, a/255); + color.raw = captures[0]; + return new Token('color', color); + } + }, + + /** + * [^\n,;]+ + */ + + selector: function() { + var captures; + if (captures = /^[^{\n,]+/.exec(this.str)) { + var selector = captures[0]; + this.skip(captures); + return new Token('selector', selector); + } + } +}; diff --git a/node_modules/stylus/lib/middleware.js b/node_modules/stylus/lib/middleware.js new file mode 100644 index 0000000..18145da --- /dev/null +++ b/node_modules/stylus/lib/middleware.js @@ -0,0 +1,228 @@ +/*! + * Stylus - middleware + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var stylus = require('./stylus') + , fs = require('fs') + , url = require('url') + , basename = require('path').basename + , dirname = require('path').dirname + , mkdirp = require('mkdirp') + , join = require('path').join; + +/** + * Import map. + */ + +var imports = {}; + +/** + * Return Connect middleware with the given `options`. + * + * Options: + * + * `force` Always re-compile + * `debug` Output debugging information + * `src` Source directory used to find .styl files + * `dest` Destination directory used to output .css files + * when undefined defaults to `src`. + * `compile` Custom compile function, accepting the arguments + * `(str, path)`. + * `compress` Whether the output .css files should be compressed + * `firebug` Emits debug infos in the generated css that can + * be used by the FireStylus Firebug plugin + * `linenos` Emits comments in the generated css indicating + * the corresponding stylus line + * + * Examples: + * + * Here we set up the custom compile function so that we may + * set the `compress` option, or define additional functions. + * + * By default the compile function simply sets the `filename` + * and renders the CSS. + * + * function compile(str, path) { + * return stylus(str) + * .set('filename', path) + * .set('compress', true); + * } + * + * Pass the middleware to Connect, grabbing .styl files from this directory + * and saving .css files to _./public_. Also supplying our custom `compile` function. + * + * Following that we have a `staticProvider` layer setup to serve the .css + * files generated by Stylus. + * + * var server = connect.createServer( + * stylus.middleware({ + * src: __dirname + * , dest: __dirname + '/public' + * , compile: compile + * }) + * , connect.static(__dirname + '/public') + * ); + * + * @param {Object} options + * @return {Function} + * @api public + */ + +module.exports = function(options){ + options = options || {}; + + // Accept src/dest dir + if ('string' == typeof options) { + options = { src: options }; + } + + // Force compilation + var force = options.force; + + // Debug option + var debug = options.debug; + + // Source dir required + var src = options.src; + if (!src) throw new Error('stylus.middleware() requires "src" directory'); + + // Default dest dir to source + var dest = options.dest + ? options.dest + : src; + + // Default compile callback + options.compile = options.compile || function(str, path){ + return stylus(str) + .set('filename', path) + .set('compress', options.compress) + .set('firebug', options.firebug) + .set('linenos', options.linenos); + }; + + // Middleware + return function stylus(req, res, next){ + if ('GET' != req.method && 'HEAD' != req.method) return next(); + var path = url.parse(req.url).pathname; + if (/\.css$/.test(path)) { + var cssPath = join(dest, path) + , stylusPath = join(src, path.replace('.css', '.styl')); + + if (debug) { + log('source', stylusPath); + log('dest', cssPath); + } + + // Ignore ENOENT to fall through as 404 + function error(err) { + next('ENOENT' == err.code + ? null + : err); + } + + // Force + if (force) return compile(); + + // Compile to cssPath + function compile() { + if (debug) log('read', cssPath); + fs.readFile(stylusPath, 'utf8', function(err, str){ + if (err) return error(err); + var style = options.compile(str, stylusPath); + var paths = style.options._imports = []; + delete imports[stylusPath]; + style.render(function(err, css){ + if (err) return next(err); + if (debug) log('render', stylusPath); + imports[stylusPath] = paths; + mkdirp(dirname(cssPath), 0700, function(err){ + if (err) return error(err); + fs.writeFile(cssPath, css, 'utf8', next); + }); + }); + }); + } + + // Re-compile on server restart, disregarding + // mtimes since we need to map imports + if (!imports[stylusPath]) return compile(); + + // Compare mtimes + fs.stat(stylusPath, function(err, stylusStats){ + if (err) return error(err); + fs.stat(cssPath, function(err, cssStats){ + // CSS has not been compiled, compile it! + if (err) { + if ('ENOENT' == err.code) { + if (debug) log('not found', cssPath); + compile(); + } else { + next(err); + } + } else { + // Source has changed, compile it + if (stylusStats.mtime > cssStats.mtime) { + if (debug) log('modified', cssPath); + compile(); + // Already compiled, check imports + } else { + checkImports(stylusPath, function(changed){ + if (debug && changed.length) { + changed.forEach(function(path) { + log('modified import %s', path); + }); + } + changed.length ? compile() : next(); + }); + } + } + }); + }); + } else { + next(); + } + } +}; + +/** + * Check `path`'s imports to see if they have been altered. + * + * @param {String} path + * @param {Function} fn + * @api private + */ + +function checkImports(path, fn) { + var nodes = imports[path]; + if (!nodes) return fn(); + if (!nodes.length) return fn(); + + var pending = nodes.length + , changed = []; + + nodes.forEach(function(imported){ + fs.stat(imported.path, function(err, stat){ + // error or newer mtime + if (err || !imported.mtime || stat.mtime > imported.mtime) { + changed.push(imported.path); + } + --pending || fn(changed); + }); + }); +} + +/** + * Log a message. + * + * @api private + */ + +function log(key, val) { + console.error(' \033[90m%s :\033[0m \033[36m%s\033[0m', key, val); +} diff --git a/node_modules/stylus/lib/nodes/arguments.js b/node_modules/stylus/lib/nodes/arguments.js new file mode 100644 index 0000000..d0a00c0 --- /dev/null +++ b/node_modules/stylus/lib/nodes/arguments.js @@ -0,0 +1,65 @@ + +/*! + * Stylus - Arguments + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('../nodes') + , utils = require('../utils'); + +/** + * Initialize a new `Arguments`. + * + * @api public + */ + +var Arguments = module.exports = function Arguments(){ + nodes.Expression.call(this); + this.map = {}; +}; + +/** + * Inherit from `nodes.Expression.prototype`. + */ + +Arguments.prototype.__proto__ = nodes.Expression.prototype; + +/** + * Initialize an `Arguments` object with the nodes + * from the given `expr`. + * + * @param {Expression} expr + * @return {Arguments} + * @api public + */ + +Arguments.fromExpression = function(expr){ + var args = new Arguments + , len = expr.nodes.length; + args.lineno = expr.lineno; + args.isList = expr.isList; + for (var i = 0; i < len; ++i) { + args.push(expr.nodes[i]); + } + return args; +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Arguments.prototype.clone = function(){ + var clone = nodes.Expression.prototype.clone.call(this); + clone.map = this.map; + return clone; +}; + diff --git a/node_modules/stylus/lib/nodes/binop.js b/node_modules/stylus/lib/nodes/binop.js new file mode 100644 index 0000000..78c4a6a --- /dev/null +++ b/node_modules/stylus/lib/nodes/binop.js @@ -0,0 +1,54 @@ + +/*! + * Stylus - BinOp + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `BinOp` with `op`, `left` and `right`. + * + * @param {String} op + * @param {Node} left + * @param {Node} right + * @api public + */ + +var BinOp = module.exports = function BinOp(op, left, right){ + Node.call(this); + this.op = op; + this.left = left; + this.right = right; +}; + +/** + * Inherit from `Node.prototype`. + */ + +BinOp.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +BinOp.prototype.clone = function(){ + var clone = new BinOp( + this.op + , this.left.clone() + , this.right ? + this.right.clone() + : null); + clone.lineno = this.lineno; + clone.filename = this.filename; + if (this.val) clone.val = this.val.clone(); + return clone; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/block.js b/node_modules/stylus/lib/nodes/block.js new file mode 100644 index 0000000..71e7542 --- /dev/null +++ b/node_modules/stylus/lib/nodes/block.js @@ -0,0 +1,99 @@ + +/*! + * Stylus - Block + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Block` node with `parent` Block. + * + * @param {Block} parent + * @api public + */ + +var Block = module.exports = function Block(parent, node){ + Node.call(this); + this.nodes = []; + this.parent = parent; + this.node = node; + this.scope = true; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Block.prototype.__proto__ = Node.prototype; + +/** + * Check if this block has properties.. + * + * @return {Boolean} + * @api public + */ + +Block.prototype.__defineGetter__('hasProperties', function(){ + for (var i = 0, len = this.nodes.length; i < len; ++i) { + if ('property' == this.nodes[i].nodeName) { + return true; + } + } +}); + +/** + * Check if this block is empty. + * + * @return {Boolean} + * @api public + */ + +Block.prototype.__defineGetter__('isEmpty', function(){ + return !this.nodes.length; +}); + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Block.prototype.clone = function(){ + var clone = new Block(this.parent, this.node); + clone.lineno = this.lineno; + clone.filename = this.filename; + clone.scope = this.scope; + this.nodes.forEach(function(node){ + node = node.clone(); + switch (node.nodeName) { + case 'each': + case 'group': + node.block.parent = clone; + break; + case 'ident': + if ('function' == node.val.nodeName) { + node.val.block.parent = clone; + } + } + clone.push(node); + }); + return clone; +}; + +/** + * Push a `node` to this block. + * + * @param {Node} node + * @api public + */ + +Block.prototype.push = function(node){ + this.nodes.push(node); +}; diff --git a/node_modules/stylus/lib/nodes/boolean.js b/node_modules/stylus/lib/nodes/boolean.js new file mode 100644 index 0000000..d07b5ab --- /dev/null +++ b/node_modules/stylus/lib/nodes/boolean.js @@ -0,0 +1,103 @@ + +/*! + * Stylus - Boolean + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Boolean` node with the given `val`. + * + * @param {Boolean} val + * @api public + */ + +var Boolean = module.exports = function Boolean(val){ + Node.call(this); + if (this.nodeName) { + this.val = !!val; + } else { + return new Boolean(val); + } +}; + +/** + * Inherit from `Node.prototype`. + */ + +Boolean.prototype.__proto__ = Node.prototype; + +/** + * Return `this` node. + * + * @return {Boolean} + * @api public + */ + +Boolean.prototype.toBoolean = function(){ + return this; +}; + +/** + * Return `true` if this node represents `true`. + * + * @return {Boolean} + * @api public + */ + +Boolean.prototype.__defineGetter__('isTrue', function(){ + return this.val; +}); + +/** + * Return `true` if this node represents `false`. + * + * @return {Boolean} + * @api public + */ + +Boolean.prototype.__defineGetter__('isFalse', function(){ + return ! this.val; +}); + +/** + * Negate the value. + * + * @return {Boolean} + * @api public + */ + +Boolean.prototype.negate = function(){ + return new Boolean(!this.val); +}; + +/** + * Return 'Boolean'. + * + * @return {String} + * @api public + */ + +Boolean.prototype.inspect = function(){ + return '[Boolean ' + this.val + ']'; +}; + +/** + * Return 'true' or 'false'. + * + * @return {String} + * @api public + */ + +Boolean.prototype.toString = function(){ + return this.val + ? 'true' + : 'false'; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/call.js b/node_modules/stylus/lib/nodes/call.js new file mode 100644 index 0000000..e3ef355 --- /dev/null +++ b/node_modules/stylus/lib/nodes/call.js @@ -0,0 +1,57 @@ + +/*! + * Stylus - Call + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Call` with `name` and `args`. + * + * @param {String} name + * @param {Expression} args + * @api public + */ + +var Call = module.exports = function Call(name, args){ + Node.call(this); + this.name = name; + this.args = args; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Call.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Call.prototype.clone = function(){ + var clone = new Call(this.name, this.args.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Return (). + * + * @return {String} + * @api public + */ + +Call.prototype.toString = function(){ + return this.name + '()'; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/charset.js b/node_modules/stylus/lib/nodes/charset.js new file mode 100644 index 0000000..2e95c34 --- /dev/null +++ b/node_modules/stylus/lib/nodes/charset.js @@ -0,0 +1,42 @@ + +/*! + * Stylus - Charset + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Charset` with the given `val` + * + * @param {String} val + * @api public + */ + +var Charset = module.exports = function Charset(val){ + Node.call(this); + this.val = val; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Charset.prototype.__proto__ = Node.prototype; + +/** + * Return @charset "val". + * + * @return {String} + * @api public + */ + +Charset.prototype.toString = function(){ + return '@charset ' + this.val; +}; diff --git a/node_modules/stylus/lib/nodes/comment.js b/node_modules/stylus/lib/nodes/comment.js new file mode 100644 index 0000000..d36b0eb --- /dev/null +++ b/node_modules/stylus/lib/nodes/comment.js @@ -0,0 +1,32 @@ + +/*! + * Stylus - Comment + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Comment` with the given `str`. + * + * @param {String} str + * @param {Boolean} suppress + * @api public + */ + +var Comment = module.exports = function Comment(str, suppress){ + Node.call(this); + this.str = str; + this.suppress = suppress; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Comment.prototype.__proto__ = Node.prototype; diff --git a/node_modules/stylus/lib/nodes/each.js b/node_modules/stylus/lib/nodes/each.js new file mode 100644 index 0000000..b06777f --- /dev/null +++ b/node_modules/stylus/lib/nodes/each.js @@ -0,0 +1,56 @@ + +/*! + * Stylus - Each + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Each` node with the given `val` name, + * `key` name, `expr`, and `block`. + * + * @param {String} val + * @param {String} key + * @param {Expression} expr + * @param {Block} block + * @api public + */ + +var Each = module.exports = function Each(val, key, expr, block){ + Node.call(this); + this.val = val; + this.key = key; + this.expr = expr; + this.block = block; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Each.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Each.prototype.clone = function(){ + var clone = new Each( + this.val + , this.key + , this.expr.clone() + , this.block.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/expression.js b/node_modules/stylus/lib/nodes/expression.js new file mode 100644 index 0000000..8fd70d4 --- /dev/null +++ b/node_modules/stylus/lib/nodes/expression.js @@ -0,0 +1,193 @@ + +/*! + * Stylus - Expression + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('../nodes') + , utils = require('../utils'); + +/** + * Initialize a new `Expression`. + * + * @param {Boolean} isList + * @api public + */ + +var Expression = module.exports = function Expression(isList){ + Node.call(this); + this.nodes = []; + this.isList = isList; +}; + +/** + * Check if the variable has a value. + * + * @return {Boolean} + * @api public + */ + +Expression.prototype.__defineGetter__('isEmpty', function(){ + return !this.nodes.length; +}); + +/** + * Return the first node in this expression. + * + * @return {Node} + * @api public + */ + +Expression.prototype.__defineGetter__('first', function(){ + return this.nodes[0] + ? this.nodes[0].first + : nodes.null; +}); + +/** + * Hash all the nodes in order. + * + * @return {String} + * @api public + */ + +Expression.prototype.__defineGetter__('hash', function(){ + return this.nodes.map(function(node){ + return node.hash; + }).join('::'); +}); + +/** + * Inherit from `Node.prototype`. + */ + +Expression.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Expression.prototype.clone = function(){ + var clone = new this.constructor(this.isList); + clone.preserve = this.preserve; + clone.lineno = this.lineno; + clone.filename = this.filename; + for (var i = 0; i < this.nodes.length; ++i) { + clone.push(this.nodes[i].clone()); + } + return clone; +}; + +/** + * Push the given `node`. + * + * @param {Node} node + * @api public + */ + +Expression.prototype.push = function(node){ + this.nodes.push(node); +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +Expression.prototype.operate = function(op, right, val){ + switch (op) { + case '[]=': + var self = this + , range = utils.unwrap(right).nodes + , val = utils.unwrap(val) + , len; + range.forEach(function(unit){ + len = self.nodes.length; + if ('unit' == unit.nodeName) { + var i = unit.val; + while (i-- > len) self.nodes[i] = nodes.null; + self.nodes[unit.val] = val; + } + }); + return val; + case '[]': + var expr = new nodes.Expression + , vals = utils.unwrap(this).nodes + , range = utils.unwrap(right).nodes; + range.forEach(function(unit){ + if ('unit' == unit.nodeName) { + var node = vals[unit.val]; + if (node) expr.push(node); + } + }); + return expr.isEmpty + ? nodes.null + : utils.unwrap(expr); + case '||': + return this.toBoolean().isTrue + ? this + : right; + case 'in': + return Node.prototype.operate.call(this, op, right); + case '!=': + return this.operate('==', right, val).negate(); + case '==': + var len = this.nodes.length + , right = right.toExpression() + , a + , b; + if (len != right.nodes.length) return nodes.false; + for (var i = 0; i < len; ++i) { + a = this.nodes[i]; + b = right.nodes[i]; + if (a.operate(op, b).isTrue) continue; + return nodes.false; + } + return nodes.true; + break; + default: + return this.first.operate(op, right, val); + } +}; + +/** + * Expressions with length > 1 are truthy, + * otherwise the first value's toBoolean() + * method is invoked. + * + * @return {Boolean} + * @api public + */ + +Expression.prototype.toBoolean = function(){ + if (this.nodes.length > 1) return nodes.true; + return this.first.toBoolean(); +}; + +/** + * Return " " or ", , " if + * the expression represents a list. + * + * @return {String} + * @api public + */ + +Expression.prototype.toString = function(){ + return '(' + this.nodes.map(function(node){ + return node.toString(); + }).join(this.isList ? ', ' : ' ') + ')'; +}; + diff --git a/node_modules/stylus/lib/nodes/extend.js b/node_modules/stylus/lib/nodes/extend.js new file mode 100644 index 0000000..5c22a73 --- /dev/null +++ b/node_modules/stylus/lib/nodes/extend.js @@ -0,0 +1,52 @@ + +/*! + * Stylus - Extend + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Extend` with the given `selector`. + * + * @param {Selector} selector + * @api public + */ + +var Extend = module.exports = function Extend(selector){ + Node.call(this); + this.selector = selector; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Extend.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Extend.prototype.clone = function(){ + return new Extend(this.selector); +}; + +/** + * Return `@extend selector`. + * + * @return {String} + * @api public + */ + +Extend.prototype.toString = function(){ + return '@extend ' + this.selector; +}; diff --git a/node_modules/stylus/lib/nodes/fontface.js b/node_modules/stylus/lib/nodes/fontface.js new file mode 100644 index 0000000..8a8bfaf --- /dev/null +++ b/node_modules/stylus/lib/nodes/fontface.js @@ -0,0 +1,55 @@ + +/*! + * Stylus - FontFace + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `FontFace` with the given `block`. + * + * @param {Block} block + * @api public + */ + +var FontFace = module.exports = function FontFace(block){ + Node.call(this); + this.block = block; +}; + +/** + * Inherit from `Node.prototype`. + */ + +FontFace.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +FontFace.prototype.clone = function(){ + var clone = new FontFace(this.block.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Return `@oage name`. + * + * @return {String} + * @api public + */ + +FontFace.prototype.toString = function(){ + return '@font-face'; +}; diff --git a/node_modules/stylus/lib/nodes/function.js b/node_modules/stylus/lib/nodes/function.js new file mode 100644 index 0000000..42e3275 --- /dev/null +++ b/node_modules/stylus/lib/nodes/function.js @@ -0,0 +1,104 @@ + +/*! + * Stylus - Function + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Function` with `name`, `params`, and `body`. + * + * @param {String} name + * @param {Params|Function} params + * @param {Block} body + * @api public + */ + +var Function = module.exports = function Function(name, params, body){ + Node.call(this); + this.name = name; + this.params = params; + this.block = body; + if ('function' == typeof params) this.fn = params; +}; + +/** + * Check function arity. + * + * @return {Boolean} + * @api public + */ + +Function.prototype.__defineGetter__('arity', function(){ + return this.params.length; +}); + +/** + * Inherit from `Node.prototype`. + */ + +Function.prototype.__proto__ = Node.prototype; + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +Function.prototype.__defineGetter__('hash', function(){ + return 'function ' + this.name; +}); + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Function.prototype.clone = function(){ + if (this.fn) { + var clone = new Function( + this.name + , this.fn); + } else { + var clone = new Function( + this.name + , this.params.clone() + , this.block.clone()); + } + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Return (param1, param2, ...). + * + * @return {String} + * @api public + */ + +Function.prototype.toString = function(){ + if (this.fn) { + return this.name + + '(' + + this.fn.toString() + .match(/^function *\((.*?)\)/) + .slice(1) + .join(', ') + + ')'; + } else { + return this.name + + '(' + + this.params.nodes.join(', ') + + ')'; + } +}; diff --git a/node_modules/stylus/lib/nodes/group.js b/node_modules/stylus/lib/nodes/group.js new file mode 100644 index 0000000..a1bb57a --- /dev/null +++ b/node_modules/stylus/lib/nodes/group.js @@ -0,0 +1,80 @@ + +/*! + * Stylus - Group + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Group`. + * + * @api public + */ + +var Group = module.exports = function Group(){ + Node.call(this); + this.nodes = []; + this.extends = []; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Group.prototype.__proto__ = Node.prototype; + +/** + * Push the given `selector` node. + * + * @param {Selector} selector + * @api public + */ + +Group.prototype.push = function(selector){ + this.nodes.push(selector); +}; + +/** + * Return this set's `Block`. + */ + +Group.prototype.__defineGetter__('block', function(){ + return this.nodes[0].block; +}); + +/** + * Assign `block` to each selector in this set. + * + * @param {Block} block + * @api public + */ + +Group.prototype.__defineSetter__('block', function(block){ + for (var i = 0, len = this.nodes.length; i < len; ++i) { + this.nodes[i].block = block; + } +}); + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Group.prototype.clone = function(){ + var clone = new Group; + clone.lineno = this.lineno; + this.nodes.forEach(function(node){ + clone.push(node.clone()); + }); + clone.filename = this.filename; + clone.block = this.block.clone(); + return clone; +}; diff --git a/node_modules/stylus/lib/nodes/hsla.js b/node_modules/stylus/lib/nodes/hsla.js new file mode 100644 index 0000000..2ee2ebf --- /dev/null +++ b/node_modules/stylus/lib/nodes/hsla.js @@ -0,0 +1,256 @@ + +/*! + * Stylus - HSLA + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `HSLA` with the given h,s,l,a component values. + * + * @param {Number} h + * @param {Number} s + * @param {Number} l + * @param {Number} a + * @api public + */ + +var HSLA = exports = module.exports = function HSLA(h,s,l,a){ + Node.call(this); + this.h = clampDegrees(h); + this.s = clampPercentage(s); + this.l = clampPercentage(l); + this.a = clampAlpha(a); + this.hsla = this; +}; + +/** + * Inherit from `Node.prototype`. + */ + +HSLA.prototype.__proto__ = Node.prototype; + +/** + * Return hsla(n,n,n,n). + * + * @return {String} + * @api public + */ + +HSLA.prototype.toString = function(){ + return 'hsla(' + + this.h + ',' + + this.s.toFixed(0) + ',' + + this.l.toFixed(0) + ',' + + this.a + ')'; +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +HSLA.prototype.clone = function(){ + var clone = new HSLA( + this.h + , this.s + , this.l + , this.a); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Return rgba `RGBA` representation. + * + * @return {RGBA} + * @api public + */ + +HSLA.prototype.__defineGetter__('rgba', function(){ + return nodes.RGBA.fromHSLA(this); +}); + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +HSLA.prototype.__defineGetter__('hash', function(){ + return this.rgba.toString(); +}); + +/** + * Add h,s,l to the current component values. + * + * @param {Number} h + * @param {Number} s + * @param {Number} l + * @return {HSLA} new node + * @api public + */ + +HSLA.prototype.add = function(h,s,l){ + return new HSLA( + this.h + h + , this.s + s + , this.l + l + , this.a); +}; + +/** + * Subtract h,s,l from the current component values. + * + * @param {Number} h + * @param {Number} s + * @param {Number} l + * @return {HSLA} new node + * @api public + */ + +HSLA.prototype.sub = function(h,s,l){ + return this.add(-h, -s, -l); +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +HSLA.prototype.operate = function(op, right){ + switch (op) { + case '==': + case '!=': + case '<=': + case '>=': + case '<': + case '>': + case 'is a': + case '||': + case '&&': + return this.rgba.operate(op, right); + default: + return this.rgba.operate(op, right).hsla; + } +}; + +/** + * Return `HSLA` representation of the given `color`. + * + * @param {RGBA} color + * @return {HSLA} + * @api public + */ + +exports.fromRGBA = function(rgba){ + var r = rgba.r / 255 + , g = rgba.g / 255 + , b = rgba.b / 255 + , a = rgba.a; + + var min = Math.min(r,g,b) + , max = Math.max(r,g,b) + , l = (max + min) / 2 + , d = max - min + , h, s; + + switch (max) { + case min: h = 0; break; + case r: h = 60 * (g-b) / d; break; + case g: h = 60 * (b-r) / d + 120; break; + case b: h = 60 * (r-g) / d + 240; break; + } + + if (max == min) { + s = 0; + } else if (l < .5) { + s = d / (2 * l); + } else { + s = d / (2 - 2 * l); + } + + h %= 360; + s *= 100; + l *= 100; + + return new HSLA(h,s,l,a); +}; + +/** + * Adjust lightness by `percent`. + * + * @param {Number} percent + * @return {HSLA} for chaining + * @api public + */ + +HSLA.prototype.adjustLightness = function(percent){ + this.l = clampPercentage(this.l + this.l * (percent / 100)); + return this; +}; + +/** + * Adjust hue by `deg`. + * + * @param {Number} deg + * @return {HSLA} for chaining + * @api public + */ + +HSLA.prototype.adjustHue = function(deg){ + this.h = clampDegrees(this.h + deg); + return this; +}; + +/** + * Clamp degree `n` >= 0 and <= 360. + * + * @param {Number} n + * @return {Number} + * @api private + */ + +function clampDegrees(n) { + n = n % 360; + return n >= 0 ? n : 360 + n; +} + +/** + * Clamp percentage `n` >= 0 and <= 100. + * + * @param {Number} n + * @return {Number} + * @api private + */ + +function clampPercentage(n) { + return Math.max(0, Math.min(n, 100)); +} + +/** + * Clamp alpha `n` >= 0 and <= 1. + * + * @param {Number} n + * @return {Number} + * @api private + */ + +function clampAlpha(n) { + return Math.max(0, Math.min(n, 1)); +} diff --git a/node_modules/stylus/lib/nodes/ident.js b/node_modules/stylus/lib/nodes/ident.js new file mode 100644 index 0000000..c2c8039 --- /dev/null +++ b/node_modules/stylus/lib/nodes/ident.js @@ -0,0 +1,127 @@ + +/*! + * Stylus - Ident + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Ident` by `name` with the given `val` node. + * + * @param {String} name + * @param {Node} val + * @api public + */ + +var Ident = module.exports = function Ident(name, val){ + Node.call(this); + this.name = name; + this.string = name; + this.val = val || nodes.null; +}; + +/** + * Check if the variable has a value. + * + * @return {Boolean} + * @api public + */ + +Ident.prototype.__defineGetter__('isEmpty', function(){ + return undefined == this.val; +}); + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +Ident.prototype.__defineGetter__('hash', function(){ + return this.name; +}); + +/** + * Inherit from `Node.prototype`. + */ + +Ident.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Ident.prototype.clone = function(){ + var clone = new Ident(this.name, this.val.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + clone.property = this.property; + return clone; +}; + +/** + * Return . + * + * @return {String} + * @api public + */ + +Ident.prototype.toString = function(){ + return this.name; +}; + +/** + * Coerce `other` to an ident. + * + * @param {Node} other + * @return {String} + * @api public + */ + +Ident.prototype.coerce = function(other){ + switch (other.nodeName) { + case 'ident': + case 'string': + case 'literal': + return new Ident(other.string); + default: + return Node.prototype.coerce.call(this, other); + } +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +Ident.prototype.operate = function(op, right){ + var val = right.first; + switch (op) { + case '-': + if ('unit' == val.nodeName) { + var expr = new nodes.Expression; + val.val = -val.val; + expr.push(this); + expr.push(val); + return expr; + } + case '+': + return new nodes.Ident(this.string + this.coerce(val).string); + } + return Node.prototype.operate.call(this, op, right); +}; diff --git a/node_modules/stylus/lib/nodes/if.js b/node_modules/stylus/lib/nodes/if.js new file mode 100644 index 0000000..9f4db8c --- /dev/null +++ b/node_modules/stylus/lib/nodes/if.js @@ -0,0 +1,56 @@ + +/*! + * Stylus - If + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `If` with the given `cond`. + * + * @param {Expression} cond + * @param {Boolean|Block} negate, block + * @api public + */ + +var If = module.exports = function If(cond, negate){ + Node.call(this); + this.cond = cond; + this.elses = []; + if (negate && negate.nodeName) { + this.block = negate; + } else { + this.negate = negate; + } +}; + +/** + * Inherit from `Node.prototype`. + */ + +If.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +If.prototype.clone = function(){ + var cond = this.cond.clone() + , block = this.block.clone(); + var clone = new If(cond, block); + clone.elses = this.elses.map(function(node){ return node.clone(); }); + clone.negate = this.negate; + clone.postfix = this.postfix; + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; diff --git a/node_modules/stylus/lib/nodes/import.js b/node_modules/stylus/lib/nodes/import.js new file mode 100644 index 0000000..9356c30 --- /dev/null +++ b/node_modules/stylus/lib/nodes/import.js @@ -0,0 +1,30 @@ + +/*! + * Stylus - Import + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Import` with the given `expr`. + * + * @param {Expression} expr + * @api public + */ + +var Import = module.exports = function Import(expr){ + Node.call(this); + this.path = expr; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Import.prototype.__proto__ = Node.prototype; diff --git a/node_modules/stylus/lib/nodes/index.js b/node_modules/stylus/lib/nodes/index.js new file mode 100644 index 0000000..a060edb --- /dev/null +++ b/node_modules/stylus/lib/nodes/index.js @@ -0,0 +1,53 @@ + +/*! + * Stylus - nodes + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Constructors + */ + +exports.Node = require('./node'); +exports.Root = require('./root'); +exports.Null = require('./null'); +exports.Each = require('./each'); +exports.If = require('./if'); +exports.Call = require('./call'); +exports.Page = require('./page'); +exports.FontFace = require('./fontface'); +exports.UnaryOp = require('./unaryop'); +exports.BinOp = require('./binop'); +exports.Ternary = require('./ternary'); +exports.Block = require('./block'); +exports.Unit = require('./unit'); +exports.String = require('./string'); +exports.HSLA = require('./hsla'); +exports.RGBA = require('./rgba'); +exports.Ident = require('./ident'); +exports.Group = require('./group'); +exports.Literal = require('./literal'); +exports.JSLiteral = require('./jsliteral'); +exports.Boolean = require('./boolean'); +exports.Return = require('./return'); +exports.Media = require('./media'); +exports.Params = require('./params'); +exports.Comment = require('./comment'); +exports.Keyframes = require('./keyframes'); +exports.Charset = require('./charset'); +exports.Import = require('./import'); +exports.Extend = require('./extend'); +exports.Function = require('./function'); +exports.Property = require('./property'); +exports.Selector = require('./selector'); +exports.Expression = require('./expression'); +exports.Arguments = require('./arguments'); + +/** + * Singletons. + */ + +exports.true = new exports.Boolean(true); +exports.false = new exports.Boolean(false); +exports.null = new exports.Null; diff --git a/node_modules/stylus/lib/nodes/jsliteral.js b/node_modules/stylus/lib/nodes/jsliteral.js new file mode 100644 index 0000000..08cdcb2 --- /dev/null +++ b/node_modules/stylus/lib/nodes/jsliteral.js @@ -0,0 +1,32 @@ + +/*! + * Stylus - JSLiteral + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `JSLiteral` with the given `str`. + * + * @param {String} str + * @api public + */ + +var JSLiteral = module.exports = function JSLiteral(str){ + Node.call(this); + this.val = str; + this.string = str; +}; + +/** + * Inherit from `Node.prototype`. + */ + +JSLiteral.prototype.__proto__ = Node.prototype; diff --git a/node_modules/stylus/lib/nodes/keyframes.js b/node_modules/stylus/lib/nodes/keyframes.js new file mode 100644 index 0000000..8b8a169 --- /dev/null +++ b/node_modules/stylus/lib/nodes/keyframes.js @@ -0,0 +1,78 @@ + +/*! + * Stylus - Keyframes + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Keyframes` with the given `name`, + * and optional vendor `prefix`. + * + * @param {String} name + * @param {String} prefix + * @api public + */ + +var Keyframes = module.exports = function Keyframes(name, prefix){ + Node.call(this); + this.name = name; + this.frames = []; + this.prefix = prefix || 'official'; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Keyframes.prototype.__proto__ = Node.prototype; + +/** + * Push the given `block` at `pos`. + * + * @param {Array} pos + * @param {Block} block + * @api public + */ + +Keyframes.prototype.push = function(pos, block){ + this.frames.push({ + pos: pos + , block: block + }); +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Keyframes.prototype.clone = function(){ + var clone = new Keyframes(this.name); + clone.lineno = this.lineno; + clone.prefix = this.prefix; + clone.frames = this.frames.map(function(node){ + node.block = node.block.clone(); + return node; + }); + return clone; +}; + +/** + * Return `@keyframes name`. + * + * @return {String} + * @api public + */ + +Keyframes.prototype.toString = function(){ + return '@keyframes ' + this.name; +}; diff --git a/node_modules/stylus/lib/nodes/literal.js b/node_modules/stylus/lib/nodes/literal.js new file mode 100644 index 0000000..314329c --- /dev/null +++ b/node_modules/stylus/lib/nodes/literal.js @@ -0,0 +1,92 @@ + +/*! + * Stylus - Literal + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Literal` with the given `str`. + * + * @param {String} str + * @api public + */ + +var Literal = module.exports = function Literal(str){ + Node.call(this); + this.val = str; + this.string = str; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Literal.prototype.__proto__ = Node.prototype; + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +Literal.prototype.__defineGetter__('hash', function(){ + return this.val; +}); + +/** + * Return literal value. + * + * @return {String} + * @api public + */ + +Literal.prototype.toString = function(){ + return this.val; +}; + +/** + * Coerce `other` to a literal. + * + * @param {Node} other + * @return {String} + * @api public + */ + +Literal.prototype.coerce = function(other){ + switch (other.nodeName) { + case 'ident': + case 'string': + case 'literal': + return new Literal(other.string); + default: + return Node.prototype.coerce.call(this, other); + } +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +Literal.prototype.operate = function(op, right){ + var val = right.first; + switch (op) { + case '+': + return new nodes.Literal(this.string + this.coerce(val).string); + default: + return Node.prototype.operate.call(this, op, right); + } +}; diff --git a/node_modules/stylus/lib/nodes/media.js b/node_modules/stylus/lib/nodes/media.js new file mode 100644 index 0000000..142fb24 --- /dev/null +++ b/node_modules/stylus/lib/nodes/media.js @@ -0,0 +1,42 @@ + +/*! + * Stylus - Media + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Media` with the given `val` + * + * @param {String} val + * @api public + */ + +var Media = module.exports = function Media(val){ + Node.call(this); + this.val = val; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Media.prototype.__proto__ = Node.prototype; + +/** + * Return @media "val". + * + * @return {String} + * @api public + */ + +Media.prototype.toString = function(){ + return '@media ' + this.val; +}; diff --git a/node_modules/stylus/lib/nodes/node.js b/node_modules/stylus/lib/nodes/node.js new file mode 100644 index 0000000..47cd37d --- /dev/null +++ b/node_modules/stylus/lib/nodes/node.js @@ -0,0 +1,223 @@ + +/*! + * Stylus - Node + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Evaluator = require('../visitor/evaluator') + , utils = require('../utils') + , nodes = require('./'); + +/** + * Node constructor. + * + * @api public + */ + +var Node = module.exports = function Node(){ + this.lineno = nodes.lineno; + Object.defineProperty(this, 'filename', { writable: true, value: nodes.filename }); +}; + +/** + * Return this node. + * + * @return {Node} + * @api public + */ + +Node.prototype.__defineGetter__('first', function(){ + return this; +}); + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +Node.prototype.__defineGetter__('hash', function(){ + return this.val; +}); + +/** + * Return node name. + * + * @return {String} + * @api public + */ + +Node.prototype.__defineGetter__('nodeName', function(){ + return this.constructor.name.toLowerCase(); +}); + +/** + * Return this node. + * + * @return {Node} + * @api public + */ + +Node.prototype.clone = function(){ + return this; +}; + +/** + * Nodes by default evaluate to themselves. + * + * @return {Node} + * @api public + */ + +Node.prototype.eval = function(){ + return new Evaluator(this).evaluate(); +}; + +/** + * Return true. + * + * @return {Boolean} + * @api public + */ + +Node.prototype.toBoolean = function(){ + return nodes.true; +}; + +/** + * Return the expression, or wrap this node in an expression. + * + * @return {Expression} + * @api public + */ + +Node.prototype.toExpression = function(){ + if ('expression' == this.nodeName) return this; + var expr = new nodes.Expression; + expr.push(this); + return expr; +}; + +/** + * Return false if `op` is generally not coerced. + * + * @param {String} op + * @return {Boolean} + * @api private + */ + +Node.prototype.shouldCoerce = function(op){ + switch (op) { + case 'is a': + case 'in': + case '||': + case '&&': + return false; + default: + return true; + } +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +Node.prototype.operate = function(op, right){ + switch (op) { + case 'is a': + if ('string' == right.nodeName) { + return nodes.Boolean(this.nodeName == right.val); + } else { + throw new Error('"is a" expects a string, got ' + right.toString()); + } + case '==': + return nodes.Boolean(this.hash == right.hash); + case '!=': + return nodes.Boolean(this.hash != right.hash); + case '>=': + return nodes.Boolean(this.hash >= right.hash); + case '<=': + return nodes.Boolean(this.hash <= right.hash); + case '>': + return nodes.Boolean(this.hash > right.hash); + case '<': + return nodes.Boolean(this.hash < right.hash); + case '||': + return this.toBoolean().isTrue + ? this + : right; + case 'in': + var vals = utils.unwrap(right).nodes + , hash = this.hash; + if (!vals) throw new Error('"in" given invalid right-hand operand, expecting an expression'); + for (var i = 0, len = vals.length; i < len; ++i) { + if (hash == vals[i].hash) { + return nodes.true; + } + } + return nodes.false; + case '&&': + var a = this.toBoolean() + , b = right.toBoolean(); + return a.isTrue && b.isTrue + ? right + : a.isFalse + ? this + : right; + default: + if ('[]' == op) { + var msg = 'cannot perform ' + + this + + '[' + right + ']'; + } else { + var msg = 'cannot perform' + + ' ' + this + + ' ' + op + + ' ' + right; + } + throw new Error(msg); + } +}; + +/** + * Initialize a new `CoercionError` with the given `msg`. + * + * @param {String} msg + * @api private + */ + +function CoercionError(msg) { + this.name = 'CoercionError' + this.message = msg + Error.captureStackTrace(this, CoercionError); +} + +/** + * Inherit from `Error.prototype`. + */ + +CoercionError.prototype.__proto__ = Error.prototype; + +/** + * Default coercion throws. + * + * @param {Node} other + * @return {Node} + * @api public + */ + +Node.prototype.coerce = function(other){ + if (other.nodeName == this.nodeName) return other; + throw new CoercionError('cannot coerce ' + other + ' to ' + this.nodeName); +}; diff --git a/node_modules/stylus/lib/nodes/null.js b/node_modules/stylus/lib/nodes/null.js new file mode 100644 index 0000000..dea78bc --- /dev/null +++ b/node_modules/stylus/lib/nodes/null.js @@ -0,0 +1,72 @@ + +/*! + * Stylus - Null + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Null` node. + * + * @api public + */ + +var Null = module.exports = function Null(){}; + +/** + * Inherit from `Node.prototype`. + */ + +Null.prototype.__proto__ = Node.prototype; + +/** + * Return 'Null'. + * + * @return {String} + * @api public + */ + +Null.prototype.inspect = +Null.prototype.toString = function(){ + return 'null'; +}; + +/** + * Return false. + * + * @return {Boolean} + * @api public + */ + +Null.prototype.toBoolean = function(){ + return nodes.false; +}; + +/** + * Check if the node is a null node. + * + * @return {Boolean} + * @api public + */ + +Null.prototype.__defineGetter__('isNull', function(){ + return true; +}); + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +Null.prototype.__defineGetter__('hash', function(){ + return null; +}); \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/page.js b/node_modules/stylus/lib/nodes/page.js new file mode 100644 index 0000000..2a14595 --- /dev/null +++ b/node_modules/stylus/lib/nodes/page.js @@ -0,0 +1,43 @@ + +/*! + * Stylus - Page + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Page` with the given `selector` and `block`. + * + * @param {Selector} selector + * @param {Block} block + * @api public + */ + +var Page = module.exports = function Page(selector, block){ + Node.call(this); + this.selector = selector; + this.block = block; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Page.prototype.__proto__ = Node.prototype; + +/** + * Return `@page name`. + * + * @return {String} + * @api public + */ + +Page.prototype.toString = function(){ + return '@page ' + this.selector; +}; diff --git a/node_modules/stylus/lib/nodes/params.js b/node_modules/stylus/lib/nodes/params.js new file mode 100644 index 0000000..be67e65 --- /dev/null +++ b/node_modules/stylus/lib/nodes/params.js @@ -0,0 +1,72 @@ + +/*! + * Stylus - Params + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Params` with `name`, `params`, and `body`. + * + * @param {String} name + * @param {Params} params + * @param {Expression} body + * @api public + */ + +var Params = module.exports = function Params(){ + Node.call(this); + this.nodes = []; +}; + +/** + * Check function arity. + * + * @return {Boolean} + * @api public + */ + +Params.prototype.__defineGetter__('length', function(){ + return this.nodes.length; +}); + +/** + * Inherit from `Node.prototype`. + */ + +Params.prototype.__proto__ = Node.prototype; + +/** + * Push the given `node`. + * + * @param {Node} node + * @api public + */ + +Params.prototype.push = function(node){ + this.nodes.push(node); +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Params.prototype.clone = function(){ + var clone = new Params; + clone.lineno = this.lineno; + clone.filename = this.filename; + this.nodes.forEach(function(node){ + clone.push(node.clone()); + }); + return clone; +}; + diff --git a/node_modules/stylus/lib/nodes/property.js b/node_modules/stylus/lib/nodes/property.js new file mode 100644 index 0000000..363a347 --- /dev/null +++ b/node_modules/stylus/lib/nodes/property.js @@ -0,0 +1,73 @@ + +/*! + * Stylus - Property + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Property` with the given `segs` and optional `expr`. + * + * @param {Array} segs + * @param {Expression} expr + * @api public + */ + +var Property = module.exports = function Property(segs, expr){ + Node.call(this); + this.segments = segs; + this.expr = expr; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Property.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Property.prototype.clone = function(){ + var clone = new Property(this.segments); + clone.name = this.name; + clone.lineno = this.lineno; + clone.filename = this.filename; + clone.segments = this.segments.map(function(node){ return node.clone(); }); + if (this.expr) clone.expr = this.expr.clone(); + return clone; +}; + +/** + * Return string representation of this node. + * + * @return {String} + * @api public + */ + +Property.prototype.toString = function(){ + return 'property(' + this.segments.join('') + ', ' + this.expr + ')'; +}; + +/** + * Operate on the property expression. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +Property.prototype.operate = function(op, right, val){ + return this.expr.operate(op, right, val); +}; diff --git a/node_modules/stylus/lib/nodes/return.js b/node_modules/stylus/lib/nodes/return.js new file mode 100644 index 0000000..73680ae --- /dev/null +++ b/node_modules/stylus/lib/nodes/return.js @@ -0,0 +1,44 @@ + +/*! + * Stylus - Return + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Return` node with the given `expr`. + * + * @param {Expression} expr + * @api public + */ + +var Return = module.exports = function Return(expr){ + this.expr = expr || nodes.null; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Return.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Return.prototype.clone = function(){ + var clone = new Return(this.expr.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/rgba.js b/node_modules/stylus/lib/nodes/rgba.js new file mode 100644 index 0000000..f0d96db --- /dev/null +++ b/node_modules/stylus/lib/nodes/rgba.js @@ -0,0 +1,337 @@ + +/*! + * Stylus - RGBA + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , HSLA = require('./hsla') + , functions = require('../functions') + , adjust = functions['-adjust'] + , nodes = require('./'); + +/** + * Initialize a new `RGBA` with the given r,g,b,a component values. + * + * @param {Number} r + * @param {Number} g + * @param {Number} b + * @param {Number} a + * @api public + */ + +var RGBA = exports = module.exports = function RGBA(r,g,b,a){ + Node.call(this); + this.r = clamp(r); + this.g = clamp(g); + this.b = clamp(b); + this.a = clampAlpha(a); + this.rgba = this; +}; + +/** + * Inherit from `Node.prototype`. + */ + +RGBA.prototype.__proto__ = Node.prototype; + +/** + * Return an `RGBA` without clamping values. + * + * @param {Number} r + * @param {Number} g + * @param {Number} b + * @param {Number} a + * @return {RGBA} + * @api public + */ + +RGBA.withoutClamping = function(r,g,b,a){ + var rgba = new RGBA(0,0,0,0); + rgba.r = r; + rgba.g = g; + rgba.b = b; + rgba.a = a; + return rgba; +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +RGBA.prototype.clone = function(){ + var clone = new RGBA( + this.r + , this.g + , this.b + , this.a); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Return true. + * + * @return {Boolean} + * @api public + */ + +RGBA.prototype.toBoolean = function(){ + return nodes.true; +}; + +/** + * Return `HSLA` representation. + * + * @return {HSLA} + * @api public + */ + +RGBA.prototype.__defineGetter__('hsla', function(){ + return HSLA.fromRGBA(this); +}); + +/** + * Return hash. + * + * @return {String} + * @api public + */ + +RGBA.prototype.__defineGetter__('hash', function(){ + return this.toString(); +}); + +/** + * Add r,g,b,a to the current component values. + * + * @param {Number} r + * @param {Number} g + * @param {Number} b + * @param {Number} a + * @return {RGBA} new node + * @api public + */ + +RGBA.prototype.add = function(r,g,b,a){ + return new RGBA( + this.r + r + , this.g + g + , this.b + b + , this.a + a); +}; + +/** + * Subtract r,g,b,a from the current component values. + * + * @param {Number} r + * @param {Number} g + * @param {Number} b + * @param {Number} a + * @return {RGBA} new node + * @api public + */ + +RGBA.prototype.sub = function(r,g,b,a){ + return new RGBA( + this.r - r + , this.g - g + , this.b - b + , a == 1 ? this.a : this.a - a); +}; + +/** + * Multiply rgb components by `n`. + * + * @param {String} n + * @return {RGBA} new node + * @api public + */ + +RGBA.prototype.multiply = function(n){ + return new RGBA( + this.r * n + , this.g * n + , this.b * n + , this.a); +}; + +/** + * Divide rgb components by `n`. + * + * @param {String} n + * @return {RGBA} new node + * @api public + */ + +RGBA.prototype.divide = function(n){ + return new RGBA( + this.r / n + , this.g / n + , this.b / n + , this.a); +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +RGBA.prototype.operate = function(op, right){ + right = right.first; + + switch (op) { + case 'is a': + if ('string' == right.nodeName && 'color' == right.string) { + return nodes.true; + } + break; + case '+': + switch (right.nodeName) { + case 'unit': + var n = right.val; + switch (right.type) { + case '%': return adjust(this, new nodes.String('lightness'), right); + case 'deg': return this.hsla.adjustHue(n).rgba; + default: return this.add(n,n,n,0); + } + case 'rgba': + return this.add(right.r, right.g, right.b, right.a); + case 'hsla': + return this.hsla.add(right.h, right.s, right.l); + } + break; + case '-': + switch (right.nodeName) { + case 'unit': + var n = right.val; + switch (right.type) { + case '%': return adjust(this, new nodes.String('lightness'), new nodes.Unit(-n, '%')); + case 'deg': return this.hsla.adjustHue(-n).rgba; + default: return this.sub(n,n,n,0); + } + case 'rgba': + return this.sub(right.r, right.g, right.b, right.a); + case 'hsla': + return this.hsla.sub(right.h, right.s, right.l); + } + break; + case '*': + switch (right.nodeName) { + case 'unit': + return this.multiply(right.val); + } + break; + case '/': + switch (right.nodeName) { + case 'unit': + return this.divide(right.val); + } + break; + } + return Node.prototype.operate.call(this, op, right); +}; + +/** + * Return #nnnnnn, #nnn, or rgba(n,n,n,n) string representation of the color. + * + * @return {String} + * @api public + */ + +RGBA.prototype.toString = function(){ + function pad(n) { + return n < 16 + ? '0' + n.toString(16) + : n.toString(16); + } + + if (1 == this.a) { + var r = pad(this.r) + , g = pad(this.g) + , b = pad(this.b); + + // Compress + if (r[0] == r[1] && g[0] == g[1] && b[0] == b[1]) { + return '#' + r[0] + g[0] + b[0]; + } else { + return '#' + r + g + b; + } + } else { + return 'rgba(' + + this.r + ',' + + this.g + ',' + + this.b + ',' + + this.a.toFixed(2) + ')'; + } +}; + +/** + * Return a `RGBA` from the given `hsla`. + * + * @param {HSLA} hsla + * @return {RGBA} + * @api public + */ + +exports.fromHSLA = function(hsla){ + var h = hsla.h / 360 + , s = hsla.s / 100 + , l = hsla.l / 100 + , a = hsla.a; + + var m2 = l <= .5 ? l * (s + 1) : l + s - l * s + , m1 = l * 2 - m2; + + var r = hue(h + 1/3) * 0xff + , g = hue(h) * 0xff + , b = hue(h - 1/3) * 0xff; + + function hue(h) { + if (h < 0) ++h; + if (h > 1) --h; + if (h * 6 < 1) return m1 + (m2 - m1) * h * 6; + if (h * 2 < 1) return m2; + if (h * 3 < 2) return m1 + (m2 - m1) * (2/3 - h) * 6; + return m1; + } + + return new RGBA(r,g,b,a); +}; + +/** + * Clamp `n` >= 0 and <= 255. + * + * @param {Number} n + * @return {Number} + * @api private + */ + +function clamp(n) { + return Math.max(0, Math.min(n.toFixed(0), 255)); +} + +/** + * Clamp alpha `n` >= 0 and <= 1. + * + * @param {Number} n + * @return {Number} + * @api private + */ + +function clampAlpha(n) { + return Math.max(0, Math.min(n, 1)); +} diff --git a/node_modules/stylus/lib/nodes/root.js b/node_modules/stylus/lib/nodes/root.js new file mode 100644 index 0000000..d5e14c5 --- /dev/null +++ b/node_modules/stylus/lib/nodes/root.js @@ -0,0 +1,50 @@ + +/*! + * Stylus - Root + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Root` node. + * + * @api public + */ + +var Root = module.exports = function Root(){ + this.nodes = []; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Root.prototype.__proto__ = Node.prototype; + +/** + * Push a `node` to this block. + * + * @param {Node} node + * @api public + */ + +Root.prototype.push = function(node){ + this.nodes.push(node); +}; + +/** + * Return "root". + * + * @return {String} + * @api public + */ + +Root.prototype.toString = function(){ + return '[Root]'; +}; diff --git a/node_modules/stylus/lib/nodes/selector.js b/node_modules/stylus/lib/nodes/selector.js new file mode 100644 index 0000000..5789796 --- /dev/null +++ b/node_modules/stylus/lib/nodes/selector.js @@ -0,0 +1,58 @@ + +/*! + * Stylus - Selector + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Block = require('./block') + , Node = require('./node'); + +/** + * Initialize a new `Selector` with the given `segs`. + * + * @param {Array} segs + * @api public + */ + +var Selector = module.exports = function Selector(segs){ + Node.call(this); + this.inherits = true; + this.segments = segs; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Selector.prototype.__proto__ = Node.prototype; + +/** + * Return the selector string. + * + * @return {String} + * @api public + */ + +Selector.prototype.toString = function(){ + return this.segments.join(''); +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Selector.prototype.clone = function(){ + var clone = new Selector; + clone.lineno = this.lineno; + clone.filename = this.filename; + clone.segments = this.segments.map(function(node){ return node.clone(); }); + return clone; +}; diff --git a/node_modules/stylus/lib/nodes/string.js b/node_modules/stylus/lib/nodes/string.js new file mode 100644 index 0000000..538f5ba --- /dev/null +++ b/node_modules/stylus/lib/nodes/string.js @@ -0,0 +1,122 @@ + +/*! + * Stylus - String + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , sprintf = require('../functions').s + , utils = require('../utils') + , nodes = require('./'); + +/** + * Initialize a new `String` with the given `val`. + * + * @param {String} val + * @param {String} quote + * @api public + */ + +var String = module.exports = function String(val, quote){ + Node.call(this); + this.val = val; + this.string = val; + this.quote = quote || "'"; +}; + +/** + * Inherit from `Node.prototype`. + */ + +String.prototype.__proto__ = Node.prototype; + +/** + * Return quoted string. + * + * @return {String} + * @api public + */ + +String.prototype.toString = function(){ + return this.quote + this.val + this.quote; +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +String.prototype.clone = function(){ + var clone = new String(this.val, this.quote); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Return Boolean based on the length of this string. + * + * @return {Boolean} + * @api public + */ + +String.prototype.toBoolean = function(){ + return nodes.Boolean(this.val.length); +}; + +/** + * Coerce `other` to a string. + * + * @param {Node} other + * @return {String} + * @api public + */ + +String.prototype.coerce = function(other){ + switch (other.nodeName) { + case 'string': + return other; + case 'expression': + return new String(other.nodes.map(function(node){ + return this.coerce(node).val; + }, this).join(' ')); + default: + return new String(other.toString()); + } +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +String.prototype.operate = function(op, right){ + switch (op) { + case '%': + var expr = new nodes.Expression; + expr.push(this); + + // constructargs + var args = 'expression' == right.nodeName + ? utils.unwrap(right).nodes + : [right]; + + // apply + return sprintf.apply(null, [expr].concat(args)); + case '+': + return new String(this.val + this.coerce(right).val); + default: + return Node.prototype.operate.call(this, op, right); + } +}; diff --git a/node_modules/stylus/lib/nodes/ternary.js b/node_modules/stylus/lib/nodes/ternary.js new file mode 100644 index 0000000..118fe19 --- /dev/null +++ b/node_modules/stylus/lib/nodes/ternary.js @@ -0,0 +1,51 @@ + +/*! + * Stylus - Ternary + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `Ternary` with `cond`, `trueExpr` and `falseExpr`. + * + * @param {Expression} cond + * @param {Expression} trueExpr + * @param {Expression} falseExpr + * @api public + */ + +var Ternary = module.exports = function Ternary(cond, trueExpr, falseExpr){ + Node.call(this); + this.cond = cond; + this.trueExpr = trueExpr; + this.falseExpr = falseExpr; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Ternary.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Ternary.prototype.clone = function(){ + var clone = new Ternary( + this.cond.clone() + , this.trueExpr.clone() + , this.falseExpr.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/unaryop.js b/node_modules/stylus/lib/nodes/unaryop.js new file mode 100644 index 0000000..6d10bd6 --- /dev/null +++ b/node_modules/stylus/lib/nodes/unaryop.js @@ -0,0 +1,46 @@ + +/*! + * Stylus - UnaryOp + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node'); + +/** + * Initialize a new `UnaryOp` with `op`, and `expr`. + * + * @param {String} op + * @param {Node} expr + * @api public + */ + +var UnaryOp = module.exports = function UnaryOp(op, expr){ + Node.call(this); + this.op = op; + this.expr = expr; +}; + +/** + * Inherit from `Node.prototype`. + */ + +UnaryOp.prototype.__proto__ = Node.prototype; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +UnaryOp.prototype.clone = function(){ + var clone = new UnaryOp(this.op, this.expr.clone()); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/nodes/unit.js b/node_modules/stylus/lib/nodes/unit.js new file mode 100644 index 0000000..6892ab2 --- /dev/null +++ b/node_modules/stylus/lib/nodes/unit.js @@ -0,0 +1,207 @@ + +/*! + * Stylus - Unit + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Node = require('./node') + , nodes = require('./'); + +/** + * Initialize a new `Unit` with the given `val` and unit `type` + * such as "px", "pt", "in", etc. + * + * @param {String} val + * @param {String} type + * @api public + */ + +var Unit = module.exports = function Unit(val, type){ + Node.call(this); + this.val = val; + this.type = type; +}; + +/** + * Inherit from `Node.prototype`. + */ + +Unit.prototype.__proto__ = Node.prototype; + +/** + * Return Boolean based on the unit value. + * + * @return {Boolean} + * @api public + */ + +Unit.prototype.toBoolean = function(){ + return nodes.Boolean(this.type + ? true + : this.val); +}; + +/** + * Return unit string. + * + * @return {String} + * @api public + */ + +Unit.prototype.toString = function(){ + var n = this.val; + if ('px' == this.type) n = n.toFixed(0); + return n + (this.type || ''); +}; + +/** + * Return a clone of this node. + * + * @return {Node} + * @api public + */ + +Unit.prototype.clone = function(){ + var clone = new Unit(this.val, this.type); + clone.lineno = this.lineno; + clone.filename = this.filename; + return clone; +}; + +/** + * Operate on `right` with the given `op`. + * + * @param {String} op + * @param {Node} right + * @return {Node} + * @api public + */ + +Unit.prototype.operate = function(op, right){ + var type = this.type || right.first.type; + + // swap color + if ('rgba' == right.nodeName || 'hsla' == right.nodeName) { + return right.operate(op, this); + } + + // operate + if (this.shouldCoerce(op)) { + // percentages + if (('-' == op || '+' == op) && '%' == right.type) { + right.val = this.val * (right.val / 100); + } else { + right = this.coerce(right.first); + } + + switch (op) { + case '-': + return new Unit(this.val - right.val, type); + case '+': + return new Unit(this.val + right.val, type); + case '/': + return new Unit(this.val / right.val, type); + case '*': + return new Unit(this.val * right.val, type); + case '%': + return new Unit(this.val % right.val, type); + case '**': + return new Unit(Math.pow(this.val, right.val), type); + case '..': + case '...': + var start = this.val + , end = right.val + , expr = new nodes.Expression + , inclusive = '..' == op; + do { + expr.push(new nodes.Unit(start)); + } while (inclusive ? ++start <= end : ++start < end); + return expr; + } + } + + return Node.prototype.operate.call(this, op, right); +}; + +/** + * Coerce `other` unit to the same type as `this` unit. + * + * Supports: + * + * mm -> cm | in + * cm -> mm | in + * in -> mm | cm + * + * ms -> s + * s -> ms + * + * Hz -> kHz + * kHz -> Hz + * + * @param {Unit} other + * @return {Unit} + * @api public + */ + +Unit.prototype.coerce = function(other){ + if ('unit' == other.nodeName) { + var a = this + , b = other; + switch (a.type) { + case 'mm': + switch (b.type) { + case 'cm': + return new nodes.Unit(b.val * 2.54, 'mm'); + case 'in': + return new nodes.Unit(b.val * 25.4, 'mm'); + } + case 'cm': + switch (b.type) { + case 'mm': + return new nodes.Unit(b.val / 10, 'cm'); + case 'in': + return new nodes.Unit(b.val * 2.54, 'cm'); + } + case 'in': + switch (b.type) { + case 'mm': + return new nodes.Unit(b.val / 25.4, 'in'); + case 'cm': + return new nodes.Unit(b.val / 2.54, 'in'); + } + case 'ms': + switch (b.type) { + case 's': + return new nodes.Unit(b.val * 1000, 'ms'); + } + case 's': + switch (b.type) { + case 'ms': + return new nodes.Unit(b.val / 1000, 's'); + } + case 'Hz': + switch (b.type) { + case 'kHz': + return new nodes.Unit(b.val * 1000, 'Hz'); + } + case 'kHz': + switch (b.type) { + case 'Hz': + return new nodes.Unit(b.val / 1000, 'kHz'); + } + default: + return new nodes.Unit(b.val, a.type); + } + } else if ('string' == other.nodeName) { + var val = parseInt(other.val, 10); + if (isNaN(val)) Node.prototype.coerce.call(this, other); + return new nodes.Unit(val); + } else { + return Node.prototype.coerce.call(this, other); + } +}; diff --git a/node_modules/stylus/lib/parser.js b/node_modules/stylus/lib/parser.js new file mode 100644 index 0000000..3e62074 --- /dev/null +++ b/node_modules/stylus/lib/parser.js @@ -0,0 +1,1581 @@ + +/*! + * Stylus - Parser + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Lexer = require('./lexer') + , nodes = require('./nodes') + , Token = require('./token') + , inspect = require('util').inspect + , errors = require('./errors'); + +// debuggers + +var debug = { + lexer: require('debug')('stylus:lexer') + , selector: require('debug')('stylus:parser:selector') +}; + +/** + * Selector composite tokens. + */ + +var selectorTokens = [ + 'ident' + , 'string' + , 'selector' + , 'function' + , 'comment' + , 'boolean' + , 'space' + , 'color' + , 'unit' + , 'for' + , 'in' + , '[' + , ']' + , '(' + , ')' + , '+' + , '-' + , '*' + , '*=' + , '<' + , '>' + , '=' + , ':' + , '&' + , '~' + , '{' + , '}' +]; + +/** + * CSS3 pseudo-selectors. + */ + +var pseudoSelectors = [ + 'root' + , 'nth-child' + , 'nth-last-child' + , 'nth-of-type' + , 'nth-last-of-type' + , 'first-child' + , 'last-child' + , 'first-of-type' + , 'last-of-type' + , 'only-child' + , 'only-of-type' + , 'empty' + , 'link' + , 'visited' + , 'active' + , 'hover' + , 'focus' + , 'target' + , 'lang' + , 'enabled' + , 'disabled' + , 'checked' + , 'not' +]; + +/** + * Initialize a new `Parser` with the given `str` and `options`. + * + * @param {String} str + * @param {Object} options + * @api private + */ + +var Parser = module.exports = function Parser(str, options) { + var self = this; + options = options || {}; + this.lexer = new Lexer(str, options); + this.root = options.root || new nodes.Root; + this.state = ['root']; + this.stash = []; + this.parens = 0; + this.css = 0; + this.state.pop = function(){ + self.prevState = [].pop.call(this); + }; +}; + +/** + * Parser prototype. + */ + +Parser.prototype = { + + /** + * Constructor. + */ + + constructor: Parser, + + /** + * Return current state. + * + * @return {String} + * @api private + */ + + currentState: function() { + return this.state[this.state.length - 1]; + }, + + /** + * Parse the input, then return the root node. + * + * @return {Node} + * @api private + */ + + parse: function(){ + var block = this.parent = this.root; + while ('eos' != this.peek().type) { + if (this.accept('newline')) continue; + var stmt = this.statement(); + this.accept(';'); + if (!stmt) this.error('unexpected token {peek}, not allowed at the root level'); + block.push(stmt); + } + return block; + }, + + /** + * Throw an `Error` with the given `msg`. + * + * @param {String} msg + * @api private + */ + + error: function(msg){ + var type = this.peek().type + , val = undefined == this.peek().val + ? '' + : ' ' + this.peek().toString(); + if (val.trim() == type.trim()) val = ''; + throw new errors.ParseError(msg.replace('{peek}', '"' + type + val + '"')); + }, + + /** + * Accept the given token `type`, and return it, + * otherwise return `undefined`. + * + * @param {String} type + * @return {Token} + * @api private + */ + + accept: function(type){ + if (type == this.peek().type) { + return this.next(); + } + }, + + /** + * Expect token `type` and return it, throw otherwise. + * + * @param {String} type + * @return {Token} + * @api private + */ + + expect: function(type){ + if (type != this.peek().type) { + this.error('expected "' + type + '", got {peek}'); + } + return this.next(); + }, + + /** + * Get the next token. + * + * @return {Token} + * @api private + */ + + next: function() { + var tok = this.stash.length + ? this.stash.pop() + : this.lexer.next(); + nodes.lineno = tok.lineno; + debug.lexer('%s %s', tok.type, tok.val || ''); + return tok; + }, + + /** + * Peek with lookahead(1). + * + * @return {Token} + * @api private + */ + + peek: function() { + return this.lexer.peek(); + }, + + /** + * Lookahead `n` tokens. + * + * @param {Number} n + * @return {Token} + * @api private + */ + + lookahead: function(n){ + return this.lexer.lookahead(n); + }, + + /** + * Check if the token at `n` is a valid selector token. + * + * @param {Number} n + * @return {Boolean} + * @api private + */ + + isSelectorToken: function(n) { + var la = this.lookahead(n).type; + switch (la) { + case 'for': + return this.bracketed; + case '[': + this.bracketed = true; + return true; + case ']': + this.bracketed = false; + return true; + default: + return ~selectorTokens.indexOf(la); + } + }, + + /** + * Check if the token at `n` is a pseudo selector. + * + * @param {Number} n + * @return {Boolean} + * @api private + */ + + isPseudoSelector: function(n){ + return ~pseudoSelectors.indexOf(this.lookahead(n).val.name); + }, + + /** + * Check if the current line contains `type`. + * + * @param {String} type + * @return {Boolean} + * @api private + */ + + lineContains: function(type){ + var i = 1 + , la; + + while (la = this.lookahead(i++)) { + if (~['indent', 'outdent', 'newline'].indexOf(la.type)) return; + if (type == la.type) return true; + } + }, + + /** + * Valid selector tokens. + */ + + selectorToken: function() { + if (this.isSelectorToken(1)) { + if ('{' == this.peek().type) { + // unclosed, must be a block + if (!this.lineContains('}')) return; + // check if ':' is within the braces. + // though not required by stylus, chances + // are if someone is using {} they will + // use css-style props, helping us with + // the ambiguity in this case + var i = 0 + , la; + while (la = this.lookahead(++i)) { + if ('}' == la.type) break; + if (':' == la.type) return; + } + } + return this.next(); + } + }, + + /** + * Consume whitespace. + */ + + skipWhitespace: function() { + while (~['space', 'indent', 'outdent', 'newline'].indexOf(this.peek().type)) + this.next(); + }, + + /** + * Consume newlines. + */ + + skipNewlines: function() { + while ('newline' == this.peek().type) + this.next(); + }, + + /** + * Consume spaces. + */ + + skipSpaces: function() { + while ('space' == this.peek().type) + this.next(); + }, + + /** + * Check if the following sequence of tokens + * forms a function definition, ie trailing + * `{` or indentation. + */ + + looksLikeFunctionDefinition: function(i) { + return 'indent' == this.lookahead(i).type + || '{' == this.lookahead(i).type; + }, + + /** + * Check if the following sequence of tokens + * forms a selector. + */ + + looksLikeSelector: function() { + var i = 1 + , brace; + + // Assume selector when an ident is + // followed by a selector + while ('ident' == this.lookahead(i).type + && 'newline' == this.lookahead(i + 1).type) i += 2; + + while (this.isSelectorToken(i) + || ',' == this.lookahead(i).type) { + + if ('selector' == this.lookahead(i).type) + return true; + + // the ':' token within braces signifies + // a selector. ex: "foo{bar:'baz'}" + if ('{' == this.lookahead(i).type) brace = true; + else if ('}' == this.lookahead(i).type) brace = false; + if (brace && ':' == this.lookahead(i).type) return true; + + // '}' preceded by a space is considered a selector. + // for example "foo{bar}{baz}" may be a property, + // however "foo{bar} {baz}" is a selector + if ('space' == this.lookahead(i).type + && '{' == this.lookahead(i + 1).type) + return true; + + // Assume pseudo selectors are NOT properties + // as 'td:th-child(1)' may look like a property + // and function call to the parser otherwise + if (':' == this.lookahead(i++).type + && this.isPseudoSelector(i)) + return true; + + if (',' == this.lookahead(i).type + && 'newline' == this.lookahead(i + 1).type) + return true; + } + + // Trailing comma + if (',' == this.lookahead(i).type + && 'newline' == this.lookahead(i + 1).type) + return true; + + // Trailing brace + if ('{' == this.lookahead(i).type + && 'newline' == this.lookahead(i + 1).type) + return true; + + // css-style mode, false on ; } + if (this.css) { + if (';' == this.lookahead(i) || + '}' == this.lookahead(i)) + return false; + } + + // Trailing separators + while (!~[ + 'indent' + , 'outdent' + , 'newline' + , 'for' + , 'if' + , ';' + , '}'].indexOf(this.lookahead(i).type)) + ++i; + + if ('indent' == this.lookahead(i).type) + return true; + }, + + /** + * Check if the current state supports selectors. + */ + + stateAllowsSelector: function() { + switch (this.currentState()) { + case 'root': + case 'selector': + case 'conditional': + case 'keyframe': + case 'function': + case 'font-face': + case 'media': + case 'for': + return true; + } + }, + + /** + * statement + * | statement 'if' expression + * | statement 'unless' expression + */ + + statement: function() { + var stmt = this.stmt() + , state = this.prevState + , block + , op; + + // special-case statements since it + // is not an expression. We could + // implement postfix conditionals at + // the expression level, however they + // would then fail to enclose properties + if (this.allowPostfix) { + delete this.allowPostfix; + state = 'expression'; + } + + switch (state) { + case 'assignment': + case 'expression': + case 'function arguments': + while (op = + this.accept('if') + || this.accept('unless') + || this.accept('for')) { + switch (op.type) { + case 'if': + case 'unless': + stmt = new nodes.If(this.expression(), stmt); + stmt.postfix = true; + stmt.negate = 'unless' == op.type; + this.accept(';'); + break; + case 'for': + var key + , val = this.id().name; + if (this.accept(',')) key = this.id().name; + this.expect('in'); + var each = new nodes.Each(val, key, this.expression()); + block = new nodes.Block; + block.push(stmt); + each.block = block; + stmt = each; + } + } + } + + return stmt; + }, + + /** + * ident + * | selector + * | literal + * | charset + * | import + * | media + * | scope + * | keyframes + * | page + * | for + * | if + * | unless + * | comment + * | expression + * | 'return' expression + */ + + stmt: function() { + var type = this.peek().type; + switch (type) { + case '-webkit-keyframes': + case 'keyframes': + return this.keyframes(); + case 'font-face': + return this.fontface(); + case 'comment': + case 'selector': + case 'literal': + case 'charset': + case 'import': + case 'extend': + case 'media': + case 'page': + case 'ident': + case 'scope': + case 'unless': + case 'function': + case 'for': + case 'if': + return this[type](); + case 'return': + return this.return(); + case '{': + return this.property(); + default: + // Contextual selectors + if (this.stateAllowsSelector()) { + switch (type) { + case 'color': + case '~': + case '+': + case '>': + case '<': + case ':': + case '&': + case '[': + return this.selector(); + case '*': + return this.property(); + case '-': + if ('{' == this.lookahead(2).type) + return this.property(); + } + } + + // Expression fallback + var expr = this.expression(); + if (expr.isEmpty) this.error('unexpected {peek}'); + return expr; + } + }, + + /** + * indent (!outdent)+ outdent + */ + + block: function(node, scope) { + var delim + , stmt + , block = this.parent = new nodes.Block(this.parent, node); + + if (false === scope) block.scope = false; + + // css-style + if (this.accept('{')) { + this.css++; + delim = '}'; + this.skipWhitespace(); + } else { + delim = 'outdent'; + this.expect('indent'); + } + + while (delim != this.peek().type) { + // css-style + if (this.css) { + if (this.accept('newline')) continue; + stmt = this.statement(); + this.accept(';'); + this.skipWhitespace(); + } else { + if (this.accept('newline')) continue; + stmt = this.statement(); + this.accept(';'); + } + if (!stmt) this.error('unexpected token {peek} in block'); + block.push(stmt); + } + + // css-style + if (this.css) { + this.skipWhitespace(); + this.expect('}'); + this.skipSpaces(); + this.css--; + } else { + this.expect('outdent'); + } + + this.parent = block.parent; + return block; + }, + + /** + * comment space* + */ + + comment: function(){ + var node = this.next().val; + this.skipSpaces(); + return node; + }, + + /** + * for val (',' key) in expr + */ + + for: function() { + this.expect('for'); + var key + , val = this.id().name; + if (this.accept(',')) key = this.id().name; + this.expect('in'); + var each = new nodes.Each(val, key, this.expression()); + this.state.push('for'); + each.block = this.block(each, false); + this.state.pop(); + return each; + }, + + /** + * return expression + */ + + return: function() { + this.expect('return'); + var expr = this.expression(); + return expr.isEmpty + ? new nodes.Return + : new nodes.Return(expr); + }, + + /** + * unless expression block + */ + + unless: function() { + this.expect('unless'); + var node = new nodes.If(this.expression(), true); + this.state.push('conditional'); + node.block = this.block(node, false); + this.state.pop(); + return node; + }, + + /** + * if expression block (else block)? + */ + + if: function() { + this.expect('if'); + var node = new nodes.If(this.expression()); + this.state.push('conditional'); + node.block = this.block(node, false); + while (this.accept('else')) { + if (this.accept('if')) { + var cond = this.expression() + , block = this.block(node, false); + node.elses.push(new nodes.If(cond, block)); + } else { + node.elses.push(this.block(node, false)); + break; + } + } + this.state.pop(); + return node; + }, + + /** + * scope + */ + + scope: function(){ + var val = this.expect('scope').val; + this.selectorScope = val; + return nodes.null; + }, + + /** + * extend + */ + + extend: function(){ + var val = this.expect('extend').val; + return new nodes.Extend(val); + }, + + /** + * media + */ + + media: function() { + var val = this.expect('media').val + , media = new nodes.Media(val); + this.state.push('media'); + media.block = this.block(media); + this.state.pop(); + return media; + }, + + /** + * fontface + */ + + fontface: function() { + this.expect('font-face'); + var node = new nodes.FontFace; + this.state.push('font-face'); + node.block = this.block(node); + this.state.pop(); + return node; + }, + + /** + * import expression + */ + + import: function() { + this.expect('import'); + this.allowPostfix = true; + return new nodes.Import(this.expression()); + }, + + /** + * charset string + */ + + charset: function() { + this.expect('charset'); + var str = this.expect('string').val; + this.allowPostfix = true; + return new nodes.Charset(str); + }, + + /** + * page selector? block + */ + + page: function() { + var selector; + this.expect('page'); + if (this.accept(':')) { + var str = this.expect('ident').val.name; + selector = new nodes.Literal(':' + str); + } + var page = new nodes.Page(selector); + this.skipSpaces(); + this.state.push('page'); + page.block = this.block(page); + this.state.pop(); + return page; + }, + + /** + * keyframes name ( + * (unit | from | to) + * (',' (unit | from | to)*) + * block)+ + */ + + keyframes: function() { + var pos + , tok = this.expect('keyframes') + , keyframes = new nodes.Keyframes(this.id(), tok.val) + , vals = []; + + // css-style + if (this.accept('{')) { + this.css++; + this.skipWhitespace(); + } else { + this.expect('indent'); + } + + this.skipNewlines(); + + while (pos = this.accept('unit') || this.accept('ident')) { + // from | to + if ('ident' == pos.type) { + this.accept('space'); + switch (pos.val.name) { + case 'from': + pos = new nodes.Unit(0, '%'); + break; + case 'to': + pos = new nodes.Unit(100, '%'); + break; + default: + this.error('"' + pos.val.name + '" is invalid, use "from" or "to"'); + } + } else { + pos = pos.val; + } + + vals.push(pos); + + // ',' + if (this.accept(',') || this.accept('newline')) continue; + + // block + this.state.push('keyframe'); + var block = this.block(keyframes); + keyframes.push(vals, block); + vals = []; + this.state.pop(); + if (this.css) this.skipWhitespace(); + this.skipNewlines(); + } + + // css-style + if (this.css) { + this.skipWhitespace(); + this.expect('}'); + this.css--; + } else { + this.expect('outdent'); + } + + return keyframes; + }, + + /** + * literal + */ + + literal: function() { + return this.expect('literal').val; + }, + + /** + * ident space? + */ + + id: function() { + var tok = this.expect('ident'); + this.accept('space'); + return tok.val; + }, + + /** + * ident + * | assignment + * | property + * | selector + */ + + ident: function() { + var i = 2 + , la = this.lookahead(i).type; + + while ('space' == la) la = this.lookahead(++i).type; + + switch (la) { + // Assignment + case '=': + case '?=': + case '-=': + case '+=': + case '*=': + case '/=': + case '%=': + return this.assignment(); + // Assignment []= + case '[': + if (this._ident == this.peek()) return this.id(); + while (']' != this.lookahead(i++).type + && 'selector' != this.lookahead(i).type) ; + if ('=' == this.lookahead(i).type) { + this._ident = this.peek(); + return this.expression(); + } else if (this.looksLikeSelector() && this.stateAllowsSelector()) { + return this.selector(); + } + // Operation + case '-': + case '+': + case '/': + case '*': + case '%': + case '**': + case 'and': + case 'or': + case '&&': + case '||': + case '>': + case '<': + case '>=': + case '<=': + case '!=': + case '==': + case '?': + case 'in': + case 'is a': + case 'is defined': + // Prevent cyclic .ident, return literal + if (this._ident == this.peek()) { + return this.id(); + } else { + this._ident = this.peek(); + switch (this.currentState()) { + // unary op or selector in property / for + case 'for': + case 'selector': + return this.property(); + // Part of a selector + case 'root': + case 'media': + case 'font-face': + return this.selector(); + case 'function': + return this.looksLikeSelector() + ? this.selector() + : this.expression(); + // Do not disrupt the ident when an operand + default: + return this.operand + ? this.id() + : this.expression(); + } + } + // Selector or property + default: + switch (this.currentState()) { + case 'root': + return this.selector(); + case 'for': + case 'page': + case 'media': + case 'font-face': + case 'selector': + case 'function': + case 'keyframe': + case 'conditional': + return this.property(); + default: + return this.id(); + } + } + }, + + /** + * '*'? (ident | '{' expression '}')+ + */ + + interpolate: function() { + var node + , segs = [] + , star; + + star = this.accept('*'); + if (star) segs.push(new nodes.Literal('*')); + + while (true) { + if (this.accept('{')) { + this.state.push('interpolation'); + segs.push(this.expression()); + this.expect('}'); + this.state.pop(); + } else if (node = this.accept('-')){ + segs.push(new nodes.Literal('-')); + } else if (node = this.accept('ident')){ + segs.push(node.val); + } else { + break; + } + } + if (!segs.length) this.expect('ident'); + return segs; + }, + + /** + * property ':'? expression + * | ident + */ + + property: function() { + if (this.looksLikeSelector()) return this.selector(); + + // property + var ident = this.interpolate() + , prop = new nodes.Property(ident) + , ret = prop; + + // optional ':' + this.accept('space'); + if (this.accept(':')) this.accept('space'); + + this.state.push('property'); + this.inProperty = true; + prop.expr = this.list(); + if (prop.expr.isEmpty) ret = ident[0]; + this.inProperty = false; + this.allowPostfix = true; + this.state.pop(); + + // optional ';' + this.accept(';'); + + return ret; + }, + + /** + * selector ',' selector + * | selector newline selector + * | selector block + */ + + selector: function() { + var tok + , arr + , group = new nodes.Group + , scope = this.selectorScope + , isRoot = 'root' == this.currentState(); + + do { + arr = []; + + // Clobber newline after , + this.accept('newline'); + + // Selector candidates, + // stitched together to + // form a selector. + while (tok = this.selectorToken()) { + debug.selector('%s', tok); + // Selector component + switch (tok.type) { + case '{': + this.skipSpaces(); + var expr = this.expression(); + this.skipSpaces(); + this.expect('}'); + arr.push(expr); + break; + case 'comment': + arr.push(new nodes.Literal(tok.val.str)); + break; + case 'color': + arr.push(new nodes.Literal(tok.val.raw)); + break; + case 'space': + arr.push(new nodes.Literal(' ')); + break; + case 'function': + arr.push(new nodes.Literal(tok.val.name + '(')); + break; + case 'ident': + arr.push(new nodes.Literal(tok.val.name)); + break; + default: + arr.push(new nodes.Literal(tok.val)); + if (tok.space) arr.push(new nodes.Literal(' ')); + } + } + + // Push the selector + if (isRoot && scope) arr.unshift(new nodes.Literal(scope + ' ')); + group.push(new nodes.Selector(arr)); + } while (this.accept(',') || this.accept('newline')); + + this.lexer.allowComments = false; + this.state.push('selector'); + group.block = this.block(group); + this.state.pop(); + + + return group; + }, + + /** + * ident ('=' | '?=') expression + */ + + assignment: function() { + var op + , node + , name = this.id().name; + + if (op = + this.accept('=') + || this.accept('?=') + || this.accept('+=') + || this.accept('-=') + || this.accept('*=') + || this.accept('/=') + || this.accept('%=')) { + this.state.push('assignment'); + var expr = this.list(); + if (expr.isEmpty) this.error('invalid right-hand side operand in assignment, got {peek}') + node = new nodes.Ident(name, expr); + this.state.pop(); + + switch (op.type) { + case '?=': + var defined = new nodes.BinOp('is defined', node) + , lookup = new nodes.Ident(name); + node = new nodes.Ternary(defined, lookup, node); + break; + case '+=': + case '-=': + case '*=': + case '/=': + case '%=': + node.val = new nodes.BinOp(op.type[0], new nodes.Ident(name), expr); + break; + } + } + + return node; + }, + + /** + * definition + * | call + */ + + function: function() { + var parens = 1 + , i = 2 + , tok; + + // Lookahead and determine if we are dealing + // with a function call or definition. Here + // we pair parens to prevent false negatives + out: + while (tok = this.lookahead(i++)) { + switch (tok.type) { + case 'function': + case '(': + ++parens; + break; + case ')': + if (!--parens) break out; + break; + case 'eos': + this.error('failed to find closing paren ")"'); + } + } + + // Definition or call + switch (this.currentState()) { + case 'expression': + return this.functionCall(); + default: + return this.looksLikeFunctionDefinition(i) + ? this.functionDefinition() + : this.expression(); + } + }, + + /** + * url '(' (expression | urlchars)+ ')' + */ + + url: function() { + this.expect('function'); + this.state.push('function arguments'); + var args = this.args(); + this.expect(')'); + this.state.pop(); + return new nodes.Call('url', args); + }, + + /** + * ident '(' expression ')' + */ + + functionCall: function() { + if ('url' == this.peek().val.name) return this.url(); + var name = this.expect('function').val.name; + this.state.push('function arguments'); + this.parens++; + var args = this.args(); + this.expect(')'); + this.parens--; + this.state.pop(); + return new nodes.Call(name, args); + }, + + /** + * ident '(' params ')' block + */ + + functionDefinition: function() { + var name = this.expect('function').val.name; + + // params + this.state.push('function params'); + this.skipWhitespace(); + var params = this.params(); + this.skipWhitespace(); + this.expect(')'); + this.state.pop(); + + // Body + this.state.push('function'); + var fn = new nodes.Function(name, params); + fn.block = this.block(fn); + this.state.pop(); + return new nodes.Ident(name, fn); + }, + + /** + * ident + * | ident '...' + * | ident '=' expression + * | ident ',' ident + */ + + params: function() { + var tok + , node + , params = new nodes.Params; + while (tok = this.accept('ident')) { + this.accept('space'); + params.push(node = tok.val); + if (this.accept('...')) { + node.rest = true; + } else if (this.accept('=')) { + node.val = this.expression(); + } + this.skipWhitespace(); + this.accept(','); + this.skipWhitespace(); + } + return params; + }, + + /** + * (ident ':')? expression (',' (ident ':')? expression)* + */ + + args: function() { + var args = new nodes.Arguments + , keyword; + + do { + // keyword + if ('ident' == this.peek().type && ':' == this.lookahead(2).type) { + keyword = this.next().val.string; + this.expect(':'); + args.map[keyword] = this.expression(); + // arg + } else { + args.push(this.expression()); + } + } while (this.accept(',')); + + return args; + }, + + /** + * expression (',' expression)* + */ + + list: function() { + var node = this.expression(); + while (this.accept(',')) { + if (node.isList) { + list.push(this.expression()); + } else { + var list = new nodes.Expression(true); + list.push(node); + list.push(this.expression()); + node = list; + } + } + return node; + }, + + /** + * negation+ + */ + + expression: function() { + var node + , expr = new nodes.Expression; + this.state.push('expression'); + while (node = this.negation()) { + if (!node) this.error('unexpected token {peek} in expression'); + expr.push(node); + } + this.state.pop(); + return expr; + }, + + /** + * 'not' ternary + * | ternary + */ + + negation: function() { + if (this.accept('not')) { + return new nodes.UnaryOp('!', this.negation()); + } + return this.ternary(); + }, + + /** + * logical ('?' expression ':' expression)? + */ + + ternary: function() { + var node = this.logical(); + if (this.accept('?')) { + var trueExpr = this.expression(); + this.expect(':'); + var falseExpr = this.expression(); + node = new nodes.Ternary(node, trueExpr, falseExpr); + } + return node; + }, + + /** + * typecheck (('&&' | '||') typecheck)* + */ + + logical: function() { + var op + , node = this.typecheck(); + while (op = this.accept('&&') || this.accept('||')) { + node = new nodes.BinOp(op.type, node, this.typecheck()); + } + return node; + }, + + /** + * equality ('is a' equality)* + */ + + typecheck: function() { + var op + , node = this.equality(); + while (op = this.accept('is a')) { + this.operand = true; + if (!node) this.error('illegal unary "' + op + '", missing left-hand operand'); + node = new nodes.BinOp(op.type, node, this.equality()); + this.operand = false; + } + return node; + }, + + /** + * in (('==' | '!=') in)* + */ + + equality: function() { + var op + , node = this.in(); + while (op = this.accept('==') || this.accept('!=')) { + this.operand = true; + if (!node) this.error('illegal unary "' + op + '", missing left-hand operand'); + node = new nodes.BinOp(op.type, node, this.in()); + this.operand = false; + } + return node; + }, + + /** + * relational ('in' relational)* + */ + + in: function() { + var node = this.relational(); + while (this.accept('in')) { + this.operand = true; + if (!node) this.error('illegal unary "in", missing left-hand operand'); + node = new nodes.BinOp('in', node, this.relational()); + this.operand = false; + } + return node; + }, + + /** + * range (('>=' | '<=' | '>' | '<') range)* + */ + + relational: function() { + var op + , node = this.range(); + while (op = + this.accept('>=') + || this.accept('<=') + || this.accept('<') + || this.accept('>') + ) { + this.operand = true; + if (!node) this.error('illegal unary "' + op + '", missing left-hand operand'); + node = new nodes.BinOp(op.type, node, this.range()); + this.operand = false; + } + return node; + }, + + /** + * additive (('..' | '...') additive)* + */ + + range: function() { + var op + , node = this.additive(); + if (op = this.accept('...') || this.accept('..')) { + this.operand = true; + if (!node) this.error('illegal unary "' + op + '", missing left-hand operand'); + node = new nodes.BinOp(op.val, node, this.additive()); + this.operand = false; + } + return node; + }, + + /** + * multiplicative (('+' | '-') multiplicative)* + */ + + additive: function() { + var op + , node = this.multiplicative(); + while (op = this.accept('+') || this.accept('-')) { + this.operand = true; + node = new nodes.BinOp(op.type, node, this.multiplicative()); + this.operand = false; + } + return node; + }, + + /** + * defined (('**' | '*' | '/' | '%') defined)* + */ + + multiplicative: function() { + var op + , node = this.defined(); + while (op = + this.accept('**') + || this.accept('*') + || this.accept('/') + || this.accept('%')) { + this.operand = true; + if ('/' == op && this.inProperty && !this.parens) { + this.stash.push(new Token('literal', new nodes.Literal('/'))); + this.operand = false; + return node; + } else { + if (!node) this.error('illegal unary "' + op + '", missing left-hand operand'); + node = new nodes.BinOp(op.type, node, this.defined()); + this.operand = false; + } + } + return node; + }, + + /** + * unary 'is defined' + * | unary + */ + + defined: function() { + var node = this.unary(); + if (this.accept('is defined')) { + if (!node) this.error('illegal unary "is defined", missing left-hand operand'); + node = new nodes.BinOp('is defined', node); + } + return node; + }, + + /** + * ('!' | '~' | '+' | '-') unary + * | subscript + */ + + unary: function() { + var op + , node; + if (op = + this.accept('!') + || this.accept('~') + || this.accept('+') + || this.accept('-')) { + this.operand = true; + node = new nodes.UnaryOp(op.type, this.unary()); + this.operand = false; + return node; + } + return this.subscript(); + }, + + /** + * primary ('[' expression ']' '='?)+ + * | primary + */ + + subscript: function() { + var node = this.primary(); + while (this.accept('[')) { + node = new nodes.BinOp('[]', node, this.expression()); + this.expect(']'); + // TODO: TernaryOp :) + if (this.accept('=')) { + node.op += '='; + node.val = this.expression(); + } + } + return node; + }, + + /** + * unit + * | null + * | color + * | string + * | ident + * | boolean + * | literal + * | '(' expression ')' '%'? + */ + + primary: function() { + var op + , node; + + // Parenthesis + if (this.accept('(')) { + ++this.parens; + var expr = this.expression(); + this.expect(')'); + --this.parens; + if (this.accept('%')) expr.push(new nodes.Ident('%')); + return expr; + } + + // Primitive + switch (this.peek().type) { + case 'null': + case 'unit': + case 'color': + case 'string': + case 'literal': + case 'boolean': + return this.next().val; + case 'ident': + return this.ident(); + case 'function': + return this.functionCall(); + } + } +}; diff --git a/node_modules/stylus/lib/renderer.js b/node_modules/stylus/lib/renderer.js new file mode 100644 index 0000000..e2cd386 --- /dev/null +++ b/node_modules/stylus/lib/renderer.js @@ -0,0 +1,183 @@ + +/*! + * Stylus - Renderer + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Parser = require('./parser') + , EventEmitter = require('events').EventEmitter + , Compiler = require('./visitor/compiler') + , Evaluator = require('./visitor/evaluator') + , Normalizer = require('./visitor/normalizer') + , utils = require('./utils') + , nodes = require('./nodes') + , path = require('path') + , join = path.join; + +/** + * Expose `Renderer`. + */ + +module.exports = Renderer; + +/** + * Initialize a new `Renderer` with the given `str` and `options`. + * + * @param {String} str + * @param {Object} options + * @api public + */ + +function Renderer(str, options) { + options = options || {}; + options.globals = {}; + options.functions = {}; + options.imports = [join(__dirname, 'functions')]; + options.paths = options.paths || []; + options.filename = options.filename || 'stylus'; + this.options = options; + this.str = str; +}; + +/** + * Inherit from `EventEmitter.prototype`. + */ + +Renderer.prototype.__proto__ = EventEmitter.prototype; + +/** + * Parse and evaluate AST, then callback `fn(err, css, js)`. + * + * @param {Function} fn + * @api public + */ + +Renderer.prototype.render = function(fn){ + var parser = this.parser = new Parser(this.str, this.options); + try { + nodes.filename = this.options.filename; + // parse + var ast = parser.parse(); + + // evaluate + this.evaluator = new Evaluator(ast, this.options); + ast = this.evaluator.evaluate(); + + // normalize + var normalizer = new Normalizer(ast, this.options); + ast = normalizer.normalize(); + + // compile + var compiler = new Compiler(ast, this.options) + , css = compiler.compile(); + + this.emit('end', css); + fn(null, css); + } catch (err) { + var options = {}; + options.input = err.input || this.str; + options.filename = err.filename || this.options.filename; + options.lineno = err.lineno || parser.lexer.lineno; + fn(utils.formatException(err, options)); + } +}; + +/** + * Set option `key` to `val`. + * + * @param {String} key + * @param {Mixed} val + * @return {Renderer} for chaining + * @api public + */ + +Renderer.prototype.set = function(key, val){ + this.options[key] = val; + return this; +}; + +/** + * Get option `key`. + * + * @param {String} key + * @return {Mixed} val + * @api public + */ + +Renderer.prototype.get = function(key){ + return this.options[key]; +}; + +/** + * Include the given `path` to the lookup paths array. + * + * @param {String} path + * @return {Renderer} for chaining + * @api public + */ + +Renderer.prototype.include = function(path){ + this.options.paths.push(path); + return this; +}; + +/** + * Use the given `fn`. + * + * This allows for plugins to alter the renderer in + * any way they wish, exposing paths etc. + * + * @param {Function} + * @return {Renderer} for chaining + * @api public + */ + +Renderer.prototype.use = function(fn){ + fn.call(this, this); + return this; +}; + +/** + * Define function or global var with the given `name`. Optionally + * the function may accept full expressions, by setting `raw` + * to `true`. + * + * @param {String} name + * @param {Function|Node} fn + * @return {Renderer} for chaining + * @api public + */ + +Renderer.prototype.define = function(name, fn, raw){ + fn = utils.coerce(fn); + + if (fn.nodeName) { + this.options.globals[name] = fn; + return this; + } + + // function + this.options.functions[name] = fn; + if (undefined != raw) fn.raw = raw; + return this; +}; + +/** + * Import the given `file`. + * + * @param {String} file + * @return {Renderer} for chaining + * @api public + */ + +Renderer.prototype.import = function(file){ + this.options.imports.push(file); + return this; +}; + + diff --git a/node_modules/stylus/lib/stack/frame.js b/node_modules/stylus/lib/stack/frame.js new file mode 100644 index 0000000..580f9cb --- /dev/null +++ b/node_modules/stylus/lib/stack/frame.js @@ -0,0 +1,66 @@ + +/*! + * Stylus - stack - Frame + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Scope = require('./scope') + , blocks = require('../nodes'); + +/** + * Initialize a new `Frame` with the given `block`. + * + * @param {Block} block + * @api private + */ + +var Frame = module.exports = function Frame(block) { + this._scope = false === block.scope + ? null + : new Scope; + this.block = block; +}; + +/** + * Return this frame's scope or the parent scope + * for scope-less blocks. + * + * @return {Scope} + * @api public + */ + +Frame.prototype.__defineGetter__('scope', function(){ + return this._scope || this.parent.scope; +}); + +/** + * Lookup the given local variable `name`. + * + * @param {String} name + * @return {Node} + * @api private + */ + +Frame.prototype.lookup = function(name){ + return this.scope.lookup(name) +}; + +/** + * Custom inspect. + * + * @return {String} + * @api public + */ + +Frame.prototype.inspect = function(){ + return '[Frame ' + + (false === this.block.scope + ? 'scope-less' + : this.scope.inspect()) + + ']'; +}; diff --git a/node_modules/stylus/lib/stack/index.js b/node_modules/stylus/lib/stack/index.js new file mode 100644 index 0000000..5c59458 --- /dev/null +++ b/node_modules/stylus/lib/stack/index.js @@ -0,0 +1,146 @@ + +/*! + * Stylus - Stack + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Frame = require('./frame'); + +/** + * Initialize a new `Stack`. + * + * @api private + */ + +var Stack = module.exports = function Stack() { + Array.apply(this, arguments); +}; + +/** + * Inherit from `Array.prototype`. + */ + +Stack.prototype.__proto__ = Array.prototype; + +/** + * Push the given `frame`. + * + * @param {Frame} frame + * @api public + */ + +Stack.prototype.push = function(frame){ + frame.stack = this; + frame.parent = this.currentFrame; + return [].push.apply(this, arguments); +}; + +/** + * Return the current stack `Frame`. + * + * @return {Frame} + * @api private + */ + +Stack.prototype.__defineGetter__('currentFrame', function(){ + return this[this.length - 1]; +}); + +/** + * Lookup stack frame for the given `block`. + * + * @param {Block} block + * @return {Frame} + * @api private + */ + +Stack.prototype.getBlockFrame = function(block){ + for (var i = 0; i < this.length; ++i) { + if (block == this[i].block) { + return this[i]; + } + } +}; + +/** + * Lookup the given local variable `name`, relative + * to the lexical scope of the current frame's `Block`. + * + * When the result of a lookup is an identifier + * a recursive lookup is performed, defaulting to + * returning the identifier itself. + * + * @param {String} name + * @return {Node} + * @api private + */ + +Stack.prototype.lookup = function(name){ + var block = this.currentFrame.block + , val + , ret; + + do { + var frame = this.getBlockFrame(block); + if (frame && (val = frame.lookup(name))) { + switch (val.first.nodeName) { + case 'ident': + return this.lookup(val.first.name) || val; + default: + return val; + } + } + } while (block = block.parent); +}; + +/** + * Custom inspect. + * + * @return {String} + * @api private + */ + +Stack.prototype.inspect = function(){ + return this.reverse().map(function(frame){ + return frame.inspect(); + }).join('\n'); +}; + +/** + * Return stack string formatted as: + * + * at (:) + * + * @return {String} + * @api private + */ + +Stack.prototype.toString = function(){ + var block + , node + , buf = [] + , location + , len = this.length; + + while (len--) { + block = this[len].block; + if (node = block.node) { + location = '(' + node.filename + ':' + (node.lineno + 1) + ')'; + switch (node.nodeName) { + case 'function': + buf.push(' at ' + node.name + '() ' + location); + break; + case 'group': + buf.push(' at "' + node.nodes[0].val + '" ' + location); + break; + } + } + } + + return buf.join('\n'); +}; \ No newline at end of file diff --git a/node_modules/stylus/lib/stack/scope.js b/node_modules/stylus/lib/stack/scope.js new file mode 100644 index 0000000..e2dc4da --- /dev/null +++ b/node_modules/stylus/lib/stack/scope.js @@ -0,0 +1,53 @@ + +/*! + * Stylus - stack - Scope + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Initialize a new `Scope`. + * + * @api private + */ + +var Scope = module.exports = function Scope() { + this.locals = {}; +}; + +/** + * Add `ident` node to the current scope. + * + * @param {Ident} ident + * @api private + */ + +Scope.prototype.add = function(ident){ + this.locals[ident.name] = ident.val; +}; + +/** + * Lookup the given local variable `name`. + * + * @param {String} name + * @return {Node} + * @api private + */ + +Scope.prototype.lookup = function(name){ + return this.locals[name]; +}; + +/** + * Custom inspect. + * + * @return {String} + * @api public + */ + +Scope.prototype.inspect = function(){ + var keys = Object.keys(this.locals).map(function(key){ return '@' + key; }); + return '[Scope' + + (keys.length ? ' ' + keys.join(', ') : '') + + ']'; +}; diff --git a/node_modules/stylus/lib/stylus.js b/node_modules/stylus/lib/stylus.js new file mode 100644 index 0000000..573e6a8 --- /dev/null +++ b/node_modules/stylus/lib/stylus.js @@ -0,0 +1,103 @@ + +/*! + * Stylus + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Renderer = require('./renderer') + , Parser = require('./parser') + , nodes = require('./nodes') + , utils = require('./utils'); + +/** + * Export render as the module. + */ + +exports = module.exports = render; + +/** + * Library version. + */ + +exports.version = '0.25.0'; + +/** + * Expose nodes. + */ + +exports.nodes = nodes; + +/** + * Expose BIFs. + */ + +exports.functions = require('./functions'); + +/** + * Expose utils. + */ + +exports.utils = require('./utils'); + +/** + * Expose middleware. + */ + +exports.middleware = require('./middleware'); + +/** + * Expose constructors. + */ + +exports.Visitor = require('./visitor'); +exports.Parser = require('./parser'); +exports.Evaluator = require('./visitor/evaluator'); +exports.Compiler = require('./visitor/compiler'); + +/** + * Convert the given `css` to `stylus` source. + * + * @param {String} css + * @return {String} + * @api public + */ + +exports.convertCSS = require('./convert/css'); + +/** + * Render the given `str` with `options` and callback `fn(err, css)`. + * + * @param {String} str + * @param {Object|Function} options + * @param {Function} fn + * @api public + */ + +exports.render = function(str, options, fn){ + if ('function' == typeof options) fn = options, options = {}; + new Renderer(str, options).render(fn); +}; + +/** + * Return a new `Renderer` for the given `str` and `options`. + * + * @param {String} str + * @param {Object} options + * @return {Renderer} + * @api public + */ + +function render(str, options) { + return new Renderer(str, options); +} + +/** + * Expose optional functions. + */ + +exports.url = require('./functions/url'); diff --git a/node_modules/stylus/lib/token.js b/node_modules/stylus/lib/token.js new file mode 100644 index 0000000..8e95e60 --- /dev/null +++ b/node_modules/stylus/lib/token.js @@ -0,0 +1,53 @@ + +/*! + * Stylus - Token + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var inspect = require('util').inspect; + +/** + * Initialize a new `Token` with the given `type` and `val`. + * + * @param {String} type + * @param {Mixed} val + * @api private + */ + +var Token = exports = module.exports = function Token(type, val) { + this.type = type; + this.val = val; +}; + +/** + * Custom inspect. + * + * @return {String} + * @api public + */ + +Token.prototype.inspect = function(){ + var val = ' ' + inspect(this.val); + return '[Token:' + this.lineno + ' ' + + '\x1b[32m' + this.type + '\x1b[0m' + + '\x1b[33m' + (this.val ? val : '') + '\x1b[0m' + + ']'; +}; + +/** + * Return type or val. + * + * @return {String} + * @api public + */ + +Token.prototype.toString = function(){ + return (undefined === this.val + ? this.type + : this.val).toString(); +}; diff --git a/node_modules/stylus/lib/units.js b/node_modules/stylus/lib/units.js new file mode 100644 index 0000000..0287ae4 --- /dev/null +++ b/node_modules/stylus/lib/units.js @@ -0,0 +1,26 @@ + +/*! + * Stylus - units + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +module.exports = [ + 'em' + , 'ex' + , 'px' + , 'mm' + , 'cm' + , 'in' + , 'pt' + , 'pc' + , 'deg' + , 'rad' + , 'grad' + , 'ms' + , 's' + , 'Hz' + , 'kHz' + , 'rem' + , '%' +]; \ No newline at end of file diff --git a/node_modules/stylus/lib/utils.js b/node_modules/stylus/lib/utils.js new file mode 100644 index 0000000..24caff4 --- /dev/null +++ b/node_modules/stylus/lib/utils.js @@ -0,0 +1,303 @@ + +/*! + * Stylus - utils + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var nodes = require('./nodes') + , join = require('path').join + , fs = require('fs'); + +/** + * Check if `path` looks absolute. + * + * @param {String} path + * @return {Boolean} + * @api private + */ + +exports.absolute = function(path){ + return /^([a-z]:\\)|\//i.test(path); +}; + +/** + * Attempt to lookup `path` within `paths` from tail to head. + * Optionally a path to `ignore` may be passed. + * + * @param {String} path + * @param {String} paths + * @param {String} ignore + * @return {String} + * @api private + */ + +exports.lookup = function(path, paths, ignore){ + var lookup + , i = paths.length; + + // Absolute + if (exports.absolute(path)) { + try { + fs.statSync(path); + return path; + } catch (err) { + // Ignore, continue on + // to trying relative lookup. + // Needed for url(/images/foo.png) + // for example + } + } + + // Relative + while (i--) { + try { + lookup = join(paths[i], path); + if (ignore == lookup) continue; + fs.statSync(lookup); + return lookup; + } catch (err) { + // Ignore + } + } +}; + +/** + * Format the given `err` with the given `options`. + * + * Options: + * + * - `filename` context filename + * - `context` context line count [8] + * - `lineno` context line number + * - `input` input string + * + * @param {Error} err + * @param {Object} options + * @return {Error} + * @api private + */ + +exports.formatException = function(err, options){ + var lineno = options.lineno + , filename = options.filename + , str = options.input + , context = options.context || 8 + , context = context / 2 + , lines = ('\n' + str).split('\n') + , start = Math.max(lineno - context, 1) + , end = Math.min(lines.length, lineno + context) + , pad = end.toString().length; + + var context = lines.slice(start, end).map(function(line, i){ + var curr = i + start; + return (curr == lineno ? ' > ' : ' ') + + Array(pad - curr.toString().length + 1).join(' ') + + curr + + '| ' + + line; + }).join('\n'); + + err.message = filename + + ':' + lineno + + '\n' + context + + '\n\n' + err.message + '\n' + + (err.stylusStack ? err.stylusStack + '\n' : ''); + + return err; +}; + +/** + * Assert that `node` is of the given `type`, or throw. + * + * @param {Node} node + * @param {Function} type + * @param {String} param + * @api public + */ + +exports.assertType = function(node, type, param){ + exports.assertPresent(node, param); + if (node.nodeName == type) return; + var actual = node.nodeName + , msg = 'expected "' + + param + '" to be a ' + + type + ', but got ' + + actual + ':' + node; + throw new Error('TypeError: ' + msg); +}; + +/** + * Assert that `node` is a `String` or `Ident`. + * + * @param {Node} node + * @param {String} param + * @api public + */ + +exports.assertString = function(node, param){ + exports.assertPresent(node, param); + switch (node.nodeName) { + case 'string': + case 'ident': + case 'literal': + return; + default: + var actual = node.nodeName + , msg = 'expected string, ident or literal, but got ' + actual + ':' + node; + throw new Error('TypeError: ' + msg); + } +}; + +/** + * Assert that `node` is a `RGBA` or `HSLA`. + * + * @param {Node} node + * @param {String} param + * @api public + */ + +exports.assertColor = function(node, param){ + exports.assertPresent(node, param); + switch (node.nodeName) { + case 'rgba': + case 'hsla': + return; + default: + var actual = node.nodeName + , msg = 'expected rgba or hsla, but got ' + actual + ':' + node; + throw new Error('TypeError: ' + msg); + } +}; + +/** + * Assert that param `name` is given, aka the `node` is passed. + * + * @param {Node} node + * @param {String} name + * @api public + */ + +exports.assertPresent = function(node, name){ + if (node) return; + if (name) throw new Error('"' + name + '" argument required'); + throw new Error('argument missing'); +}; + +/** + * Unwrap `expr`. + * + * Takes an expressions with length of 1 + * such as `((1 2 3))` and unwraps it to `(1 2 3)`. + * + * @param {Expression} expr + * @return {Node} + * @api public + */ + +exports.unwrap = function(expr){ + // explicitly preserve the expression + if (expr.preserve) return expr; + if ('arguments' != expr.nodeName && 'expression' != expr.nodeName) return expr; + if (1 != expr.nodes.length) return expr; + if ('arguments' != expr.nodes[0].nodeName && 'expression' != expr.nodes[0].nodeName) return expr; + return exports.unwrap(expr.nodes[0]); +}; + +/** + * Coerce JavaScript values to their Stylus equivalents. + * + * @param {Mixed} val + * @return {Node} + * @api public + */ + +exports.coerce = function(val){ + switch (typeof val) { + case 'function': + return val; + case 'string': + return new nodes.String(val); + case 'boolean': + return new nodes.Boolean(val); + case 'number': + return new nodes.Unit(val); + default: + if (null == val) return nodes.null; + if (Array.isArray(val)) return exports.coerceArray(val); + if (val.nodeName) return val; + return exports.coerceObject(val); + } +}; + +/** + * Coerce a javascript `Array` to a Stylus `Expression`. + * + * @param {Array} val + * @return {Expression} + * @api private + */ + +exports.coerceArray = function(val){ + var expr = new nodes.Expression; + val.forEach(function(val){ + expr.push(exports.coerce(val)); + }); + return expr; +}; + +/** + * Coerce a javascript object to a Stylus `Expression`. + * + * For example `{ foo: 'bar', bar: 'baz' }` would become + * the expression `(foo 'bar') (bar 'baz')`. + * + * @param {Object} obj + * @return {Expression} + * @api public + */ + +exports.coerceObject = function(obj){ + var expr = new nodes.Expression + , val; + + for (var key in obj) { + val = exports.coerce(obj[key]); + key = new nodes.Ident(key); + expr.push(exports.coerceArray([key, val])); + } + + return expr; +}; + +/** + * Return param names for `fn`. + * + * @param {Function} fn + * @return {Array} + * @api private + */ + +exports.params = function(fn){ + return fn + .toString() + .match(/\(([^)]*)\)/)[1].split(/ *, */); +}; + +/** + * Merge object `b` with `a`. + * + * @param {Object} a + * @param {Object} b + * @return {Object} a + * @api private + */ + +exports.merge = function(a, b){ + for (var k in b) a[k] = b[k]; + return a; +} diff --git a/node_modules/stylus/lib/visitor/compiler.js b/node_modules/stylus/lib/visitor/compiler.js new file mode 100644 index 0000000..2bdf933 --- /dev/null +++ b/node_modules/stylus/lib/visitor/compiler.js @@ -0,0 +1,492 @@ + +/*! + * Stylus - Compiler + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Visitor = require('./') + , nodes = require('../nodes') + , utils = require('../utils') + , fs = require('fs'); + +/** + * Initialize a new `Compiler` with the given `root` Node + * and the following `options`. + * + * Options: + * + * - `compress` Compress the css output, defaults to false + * + * @param {Node} root + * @api public + */ + +var Compiler = module.exports = function Compiler(root, options) { + options = options || {}; + this.compress = options.compress; + this.firebug = options.firebug; + this.linenos = options.linenos; + this.spaces = options['indent spaces'] || 2; + this.indents = 1; + Visitor.call(this, root); + this.stack = []; + this.js = ''; +}; + +/** + * Inherit from `Visitor.prototype`. + */ + +Compiler.prototype.__proto__ = Visitor.prototype; + +/** + * Compile to css, and return a string of CSS. + * + * @return {String} + * @api private + */ + +Compiler.prototype.compile = function(){ + return this.visit(this.root); +}; + +/** + * Return indentation string. + * + * @return {String} + * @api private + */ + +Compiler.prototype.__defineGetter__('indent', function(){ + if (this.compress) return ''; + return new Array(this.indents).join(Array(this.spaces + 1).join(' ')); +}); + +/** + * Visit Root. + */ + +Compiler.prototype.visitRoot = function(block){ + this.buf = ''; + for (var i = 0, len = block.nodes.length; i < len; ++i) { + var node = block.nodes[i]; + if (this.linenos || this.firebug) this.debugInfo(node); + var ret = this.visit(node); + if (ret) this.buf += ret + '\n'; + } + return this.buf; +}; + +/** + * Visit Block. + */ + +Compiler.prototype.visitBlock = function(block){ + var node; + + if (block.hasProperties) { + var arr = [this.compress ? '{' : ' {']; + ++this.indents; + for (var i = 0, len = block.nodes.length; i < len; ++i) { + this.last = len - 1 == i; + node = block.nodes[i]; + switch (node.nodeName) { + case 'null': + case 'expression': + case 'function': + case 'jsliteral': + case 'group': + case 'unit': + continue; + case 'media': + // Prevent double-writing the @media declaration when + // nested inside of a function/mixin + if (node.block.parent.scope) { + continue; + } + default: + arr.push(this.visit(node)); + } + } + --this.indents; + arr.push(this.indent + '}'); + this.buf += arr.join(this.compress ? '' : '\n'); + this.buf += '\n'; + } + + // Nesting + for (var i = 0, len = block.nodes.length; i < len; ++i) { + node = block.nodes[i]; + switch (node.nodeName) { + case 'group': + case 'print': + case 'page': + case 'block': + case 'keyframes': + if (this.linenos || this.firebug) this.debugInfo(node); + this.visit(node); + break; + case 'media': + case 'import': + case 'fontface': + this.visit(node); + break; + } + } +}; + +/** + * Visit Keyframes. + */ + +Compiler.prototype.visitKeyframes = function(node){ + var comma = this.compress ? ',' : ', '; + + var prefix = 'official' == node.prefix + ? '' + : '-' + node.prefix + '-'; + + this.buf += '@' + prefix + 'keyframes ' + + this.visit(node.name) + + (this.compress ? '{' : ' {'); + + ++this.indents; + node.frames.forEach(function(frame){ + if (!this.compress) this.buf += '\n '; + this.buf += this.visit(frame.pos.join(comma)); + this.visit(frame.block); + }, this); + --this.indents; + + this.buf += '}' + (this.compress ? '' : '\n'); +}; + +/** + * Visit Media. + */ + +Compiler.prototype.visitMedia = function(media){ + this.buf += '@media ' + media.val; + this.buf += this.compress ? '{' : ' {\n'; + ++this.indents; + this.visit(media.block); + --this.indents; + this.buf += '}' + (this.compress ? '' : '\n'); +}; + +/** + * Visit Page. + */ + +Compiler.prototype.visitPage = function(page){ + this.buf += this.indent + '@page'; + this.buf += page.selector ? ' ' + page.selector : ''; + this.visit(page.block); +}; + +/** + * Visit Import. + */ + +Compiler.prototype.visitImport = function(imported){ + this.buf += '@import ' + this.visit(imported.path) + ';\n'; +}; + +/** + * Visit FontFace. + */ + +Compiler.prototype.visitFontFace = function(face){ + this.buf += this.indent + '@font-face'; + this.visit(face.block); +}; + +/** + * Visit JSLiteral. + */ + +Compiler.prototype.visitJSLiteral = function(js){ + this.js += '\n' + js.val.replace(/@selector/g, '"' + this.selector + '"'); + return ''; +}; + +/** + * Visit Comment. + */ + +Compiler.prototype.visitComment = function(comment){ + return this.compress + ? comment.suppress + ? '' + : comment.str + : comment.str; +}; + +/** + * Visit Function. + */ + +Compiler.prototype.visitFunction = function(fn){ + return fn.name; +}; + +/** + * Visit Variable. + */ + +Compiler.prototype.visitVariable = function(variable){ + return ''; +}; + +/** + * Visit Charset. + */ + +Compiler.prototype.visitCharset = function(charset){ + return '@charset ' + this.visit(charset.val) + ';'; +}; + +/** + * Visit Literal. + */ + +Compiler.prototype.visitLiteral = function(lit){ + return lit.val.trim().replace(/^ /gm, ''); +}; + +/** + * Visit Boolean. + */ + +Compiler.prototype.visitBoolean = function(bool){ + return bool.toString(); +}; + +/** + * Visit RGBA. + */ + +Compiler.prototype.visitRGBA = function(rgba){ + return rgba.toString(); +}; + +/** + * Visit HSLA. + */ + +Compiler.prototype.visitHSLA = function(hsla){ + return hsla.rgba.toString(); +}; + +/** + * Visit Unit. + */ + +Compiler.prototype.visitUnit = function(unit){ + var type = unit.type || '' + , n = unit.val + , float = n != (n | 0); + + // Compress + if (this.compress) { + // Zero is always '0', unless when + // a percentage, this is required by keyframes + if ('%' != type && 0 == n) return '0'; + // Omit leading '0' on floats + if (float && n < 1 && n > -1) { + return n.toString().replace('0.', '.') + type; + } + } + + return n.toString() + type; +}; + +/** + * Visit Group. + */ + +Compiler.prototype.visitGroup = function(group){ + var stack = this.stack; + + stack.push(group.nodes); + + // selectors + if (group.block.hasProperties) { + var selectors = this.compileSelectors(stack); + this.buf += (this.selector = selectors.join(this.compress ? ',' : ',\n')); + } + + // output block + this.visit(group.block); + stack.pop(); +}; + +/** + * Visit Ident. + */ + +Compiler.prototype.visitIdent = function(ident){ + return ident.name; +}; + +/** + * Visit String. + */ + +Compiler.prototype.visitString = function(string){ + return this.isURL + ? string.val + : string.toString(); +}; + +/** + * Visit Null. + */ + +Compiler.prototype.visitNull = function(node){ + return ''; +}; + +/** + * Visit Call. + */ + +Compiler.prototype.visitCall = function(call){ + this.isURL = 'url' == call.name; + var args = call.args.nodes.map(function(arg){ + return this.visit(arg); + }, this).join(this.compress ? ',' : ', '); + if (this.isURL) args = '"' + args + '"'; + delete this.isURL; + return call.name + '(' + args + ')'; +}; + +/** + * Visit Expression. + */ + +Compiler.prototype.visitExpression = function(expr){ + var buf = [] + , self = this + , len = expr.nodes.length + , nodes = expr.nodes.map(function(node){ return self.visit(node); }); + + nodes.forEach(function(node, i){ + var last = i == len - 1; + buf.push(node); + if ('/' == nodes[i + 1] || '/' == node) return; + if (last) return; + buf.push(expr.isList + ? (self.compress ? ',' : ', ') + : (self.isURL ? '' : ' ')); + }); + + return buf.join(''); +}; + +/** + * Visit Arguments. + */ + +Compiler.prototype.visitArguments = Compiler.prototype.visitExpression; + +/** + * Visit Property. + */ + +Compiler.prototype.visitProperty = function(prop){ + var self = this + , val = this.visit(prop.expr); + return this.indent + (prop.name || prop.segments.join('')) + + (this.compress ? ':' + val : ': ' + val) + + (this.compress + ? (this.last ? '' : ';') + : ';'); +}; + +/** + * Compile selector strings in `arr` from the bottom-up + * to produce the selector combinations. For example + * the following Stylus: + * + * ul + * li + * p + * a + * color: red + * + * Would return: + * + * [ 'ul li a', 'ul p a' ] + * + * @param {Array} arr + * @return {Array} + * @api private + */ + +Compiler.prototype.compileSelectors = function(arr){ + var stack = this.stack + , self = this + , selectors = [] + , buf = []; + + function compile(arr, i) { + if (i) { + arr[i].forEach(function(selector){ + if (selector.inherits) { + buf.unshift(selector.val); + compile(arr, i - 1); + buf.shift(); + } else { + selectors.push(selector.val); + } + }); + } else { + arr[0].forEach(function(selector){ + var str = selector.val.trim(); + if (buf.length) { + for (var i = 0, len = buf.length; i < len; ++i) { + if (~buf[i].indexOf('&')) { + str = buf[i].replace(/&/g, str).trim(); + } else { + str += ' ' + buf[i].trim(); + } + } + } + selectors.push(self.indent + str.trimRight()); + }); + } + } + + compile(arr, arr.length - 1); + + return selectors; +}; + +/** + * Debug info. + */ + +Compiler.prototype.debugInfo = function(node){ + + var path = fs.realpathSync(node.filename) + , line = node.nodes ? node.nodes[0].lineno : node.lineno; + + if (this.linenos){ + this.buf += '\n/* ' + 'line ' + line + ' : ' + path + ' */\n'; + } + + if (this.firebug){ + // debug info for firebug, the crazy formatting is needed + path = 'file\\\:\\\/\\\/' + path.replace(/(\/|\.)/g, '\\$1'); + line = '\\00003' + line; + this.buf += '\n@media -stylus-debug-info' + + '{filename{font-family:' + path + + '}line{font-family:' + line + '}}\n'; + } +} diff --git a/node_modules/stylus/lib/visitor/evaluator.js b/node_modules/stylus/lib/visitor/evaluator.js new file mode 100644 index 0000000..1dcbacc --- /dev/null +++ b/node_modules/stylus/lib/visitor/evaluator.js @@ -0,0 +1,1180 @@ + +/*! + * Stylus - Evaluator + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Visitor = require('./') + , units = require('../units') + , nodes = require('../nodes') + , Stack = require('../stack') + , Frame = require('../stack/frame') + , Scope = require('../stack/scope') + , utils = require('../utils') + , bifs = require('../functions') + , dirname = require('path').dirname + , join = require('path').join + , colors = require('../colors') + , debug = require('debug')('stylus:evaluator') + , fs = require('fs'); + +/** + * Initialize a new `Evaluator` with the given `root` Node + * and the following `options`. + * + * Options: + * + * - `compress` Compress the css output, defaults to false + * - `warn` Warn the user of duplicate function definitions etc + * + * @param {Node} root + * @api private + */ + +var Evaluator = module.exports = function Evaluator(root, options) { + options = options || {}; + Visitor.call(this, root); + this.stack = new Stack; + this.imports = options.imports || []; + this.functions = options.functions || {}; + this.globals = options.globals || {}; + this.paths = options.paths || []; + this.filename = options.filename; + this.includeCSS = options['include css']; + this.paths.push(dirname(options.filename || '.')); + this.stack.push(this.global = new Frame(root)); + this.warnings = options.warn; + this.options = options; + this.calling = []; // TODO: remove, use stack + this.importStack = []; + this.return = 0; +}; + +/** + * Inherit from `Visitor.prototype`. + */ + +Evaluator.prototype.__proto__ = Visitor.prototype; + +/** + * Proxy visit to expose node line numbers. + * + * @param {Node} node + * @return {Node} + * @api private + */ + +var visit = Visitor.prototype.visit; +Evaluator.prototype.visit = function(node){ + try { + return visit.call(this, node); + } catch (err) { + if (err.filename) throw err; + err.lineno = node.lineno; + err.filename = node.filename; + err.stylusStack = this.stack.toString(); + try { + err.input = fs.readFileSync(err.filename, 'utf8'); + } catch (err) { + // ignore + } + throw err; + } +}; + +/** + * Perform evaluation setup: + * + * - populate global scope + * - iterate imports + * + * @api private + */ + +Evaluator.prototype.setup = function(){ + this.populateGlobalScope(); + this.imports.forEach(function(file){ + var expr = new nodes.Expression; + expr.push(new nodes.String(file)); + this.visit(new nodes.Import(expr)); + }, this); +}; + +/** + * Populate the global scope with: + * + * - css colors + * - user-defined globals + * + * @api private + */ + +Evaluator.prototype.populateGlobalScope = function(){ + var scope = this.global.scope; + + // colors + Object.keys(colors).forEach(function(name){ + var rgb = colors[name] + , rgba = new nodes.RGBA(rgb[0], rgb[1], rgb[2], 1) + , node = new nodes.Ident(name, rgba); + scope.add(node); + }); + + // user-defined globals + var globals = this.globals; + Object.keys(globals).forEach(function(name){ + scope.add(new nodes.Ident(name, globals[name])); + }); +}; + +/** + * Evaluate the tree. + * + * @return {Node} + * @api private + */ + +Evaluator.prototype.evaluate = function(){ + debug('eval %s', this.filename); + this.setup(); + return this.visit(this.root); +}; + +/** + * Visit Group. + */ + +Evaluator.prototype.visitGroup = function(group){ + group.nodes = group.nodes.map(function(selector){ + selector.val = this.interpolate(selector); + debug('ruleset %s', selector.val); + return selector; + }, this); + + group.block = this.visit(group.block); + return group; +}; + +/** + * Visit Charset. + */ + +Evaluator.prototype.visitCharset = function(charset){ + return charset; +}; + +/** + * Visit Return. + */ + +Evaluator.prototype.visitReturn = function(ret){ + ret.expr = this.visit(ret.expr); + throw ret; +}; + +/** + * Visit Media. + */ + +Evaluator.prototype.visitMedia = function(media){ + media.block = this.visit(media.block); + return media; +}; + +/** + * Visit FontFace. + */ + +Evaluator.prototype.visitFontFace = function(face){ + face.block = this.visit(face.block); + return face; +}; + +/** + * Visit FontFace. + */ + +Evaluator.prototype.visitPage = function(page){ + page.block = this.visit(page.block); + return page; +}; + +/** + * Visit Keyframes. + */ + +Evaluator.prototype.visitKeyframes = function(keyframes){ + if (keyframes.fabricated) return keyframes; + keyframes.name = this.visit(keyframes.name).first.name; + + keyframes.frames = keyframes.frames.map(function(frame){ + frame.block = this.visit(frame.block); + return frame; + }, this); + + if ('official' != keyframes.prefix) return keyframes; + + this.vendors.forEach(function(prefix){ + var node = keyframes.clone(); + node.prefix = prefix; + node.fabricated = true; + this.currentBlock.push(node); + }, this); + + return nodes.null; +}; + +/** + * Visit Function. + */ + +Evaluator.prototype.visitFunction = function(fn){ + // check local + var local = this.stack.currentFrame.scope.lookup(fn.name); + if (local) this.warn('local ' + local.nodeName + ' "' + fn.name + '" previously defined in this scope'); + + // user-defined + var user = this.functions[fn.name]; + if (user) this.warn('user-defined function "' + fn.name + '" is already defined'); + + // BIF + var bif = bifs[fn.name]; + if (bif) this.warn('built-in function "' + fn.name + '" is already defined'); + + return fn; +}; + +/** + * Visit Each. + */ + +Evaluator.prototype.visitEach = function(each){ + this.return++; + var expr = utils.unwrap(this.visit(utils.unwrap(each.expr))) + , len = expr.nodes.length + , val = new nodes.Ident(each.val) + , key = new nodes.Ident(each.key || '__index__') + , scope = this.currentScope + , block = this.currentBlock + , vals = [] + , body; + this.return--; + + each.block.scope = false; + for (var i = 0; i < len; ++i) { + val.val = expr.nodes[i]; + key.val = new nodes.Unit(i); + scope.add(val); + scope.add(key); + body = this.visit(each.block.clone()); + vals = vals.concat(body.nodes); + } + + this.mixin(vals, block); + return vals[vals.length - 1] || nodes.null; +}; + +/** + * Visit Call. + */ + +Evaluator.prototype.visitCall = function(call){ + debug('call %s', call); + var fn = this.lookup(call.name) + , ret; + + // url() + this.ignoreColors = 'url' == call.name; + + // Variable function + if (fn && 'expression' == fn.nodeName) { + fn = fn.nodes[0]; + } + + // Not a function? try user-defined or built-ins + if (fn && 'function' != fn.nodeName) { + fn = this.lookupFunction(call.name); + } + + // Undefined function, render literal css + if (!fn || fn.nodeName != 'function') { + debug('%s is undefined', call); + var ret = this.literalCall(call); + this.ignoreColors = false; + return ret; + } + + this.calling.push(call.name); + + // Massive stack + if (this.calling.length > 200) { + throw new RangeError('Maximum stylus call stack size exceeded'); + } + + // First node in expression + if ('expression' == fn.nodeName) fn = fn.first; + + // Evaluate arguments + this.return++; + var args = this.visit(call.args); + for (var key in call.args.map) { + call.args.map[key] = this.visit(call.args.map[key]); + } + this.return--; + + // Built-in + if (fn.fn) { + debug('%s is built-in', call); + ret = this.invokeBuiltin(fn.fn, args); + // User-defined + } else if ('function' == fn.nodeName) { + debug('%s is user-defined', call); + ret = this.invokeFunction(fn, args); + } + + this.calling.pop(); + this.ignoreColors = false; + return ret; +}; + +/** + * Visit Ident. + */ + +Evaluator.prototype.visitIdent = function(ident){ + var prop; + // Property lookup + if (ident.property) { + if (prop = this.lookupProperty(ident.name)) { + return this.visit(prop.expr.clone()); + } + return nodes.null; + // Lookup + } else if (ident.val.isNull) { + var val = this.lookup(ident.name); + return val ? this.visit(val) : ident; + // Assign + } else { + this.return++; + ident.val = this.visit(ident.val); + this.return--; + this.currentScope.add(ident); + return ident.val; + } +}; + +/** + * Visit BinOp. + */ + +Evaluator.prototype.visitBinOp = function(binop){ + // Special-case "is defined" pseudo binop + if ('is defined' == binop.op) return this.isDefined(binop.left); + + this.return++; + // Visit operands + var op = binop.op + , left = this.visit(binop.left) + , right = this.visit(binop.right); + this.return--; + + // HACK: ternary + var val = binop.val + ? this.visit(binop.val) + : null; + + // Operate + try { + return this.visit(left.operate(op, right, val)); + } catch (err) { + // disregard coercion issues in equality + // checks, and simply return false + if ('CoercionError' == err.name) { + switch (op) { + case '==': + return nodes.false; + case '!=': + return nodes.true; + } + } + throw err; + } +}; + +/** + * Visit UnaryOp. + */ + +Evaluator.prototype.visitUnaryOp = function(unary){ + var op = unary.op + , node = this.visit(unary.expr); + + if ('!' != op) { + node = node.first.clone(); + utils.assertType(node, 'unit'); + } + + switch (op) { + case '-': + node.val = -node.val; + break; + case '+': + node.val = +node.val; + break; + case '~': + node.val = ~node.val; + break; + case '!': + return node.toBoolean().negate(); + } + + return node; +}; + +/** + * Visit TernaryOp. + */ + +Evaluator.prototype.visitTernary = function(ternary){ + var ok = this.visit(ternary.cond).toBoolean(); + return ok.isTrue + ? this.visit(ternary.trueExpr) + : this.visit(ternary.falseExpr); +}; + +/** + * Visit Expression. + */ + +Evaluator.prototype.visitExpression = function(expr){ + for (var i = 0, len = expr.nodes.length; i < len; ++i) { + expr.nodes[i] = this.visit(expr.nodes[i]); + } + + // support (n * 5)px etc + if (this.castable(expr)) expr = this.cast(expr); + + return expr; +}; + +/** + * Visit Arguments. + */ + +Evaluator.prototype.visitArguments = Evaluator.prototype.visitExpression; + +/** + * Visit Property. + */ + +Evaluator.prototype.visitProperty = function(prop){ + var name = this.interpolate(prop) + , fn = this.lookup(name) + , call = fn && 'function' == fn.nodeName + , literal = ~this.calling.indexOf(name); + + // Function of the same name + if (call && !literal && !prop.literal) { + this.calling.push(name); + var args = nodes.Arguments.fromExpression(utils.unwrap(prop.expr)); + var ret = this.visit(new nodes.Call(name, args)); + this.calling.pop(); + return ret; + // Regular property + } else { + this.return++; + prop.name = name; + prop.literal = true; + this.property = prop; + prop.expr = this.visit(prop.expr); + delete this.property; + this.return--; + return prop; + } +}; + +/** + * Visit Root. + */ + +Evaluator.prototype.visitRoot = function(block){ + for (var i = 0; i < block.nodes.length; ++i) { + block.index = this.rootIndex = i; + block.nodes[i] = this.visit(block.nodes[i]); + } + return block; +}; + +/** + * Visit Block. + */ + +Evaluator.prototype.visitBlock = function(block){ + this.stack.push(new Frame(block)); + for (block.index = 0; block.index < block.nodes.length; ++block.index) { + try { + block.nodes[block.index] = this.visit(block.nodes[block.index]); + } catch (err) { + if ('return' == err.nodeName) { + if (this.return) { + this.stack.pop(); + throw err; + } else { + block.nodes[block.index] = err; + break; + } + } else { + throw err; + } + } + } + this.stack.pop(); + return block; +}; + +/** + * Visit If. + */ + +Evaluator.prototype.visitIf = function(node){ + var ret + , block = this.currentBlock + , negate = node.negate; + + this.return++; + var ok = this.visit(node.cond).first.toBoolean(); + this.return--; + + // Evaluate body + if (negate) { + // unless + if (ok.isFalse) { + ret = this.visit(node.block); + } + } else { + // if + if (ok.isTrue) { + ret = this.visit(node.block); + // else + } else if (node.elses.length) { + var elses = node.elses + , len = elses.length; + for (var i = 0; i < len; ++i) { + // else if + if (elses[i].cond) { + if (this.visit(elses[i].cond).first.toBoolean().isTrue) { + ret = this.visit(elses[i].block); + break; + } + // else + } else { + ret = this.visit(elses[i]); + } + } + } + } + + // mixin conditional statements within a selector group + if (ret && !node.postfix && block.node && 'group' == block.node.nodeName) { + this.mixin(ret.nodes, block); + return nodes.null; + } + + return ret || nodes.null; +}; + +/** + * Visit Extend. + */ + +Evaluator.prototype.visitExtend = function(extend){ + var selector = extend.selector; + this.currentBlock.node.extends.push(selector); + return nodes.null; +}; + +/** + * Visit Import. + */ + +Evaluator.prototype.visitImport = function(imported){ + this.return++; + + var root = this.root + , Parser = require('../parser') + , path = this.visit(imported.path).first + , includeCSS = this.includeCSS + , found + , literal; + + this.return--; + debug('import %s', path); + + // url() passed + if ('url' == path.name) return imported; + + // Enusre string + if (!path.string) throw new Error('@import string expected'); + var name = path = path.string; + + // Literal + if (~path.indexOf('.css')) { + literal = true; + if (!includeCSS) return imported; + } + + // support optional .styl + if (!literal && !~path.indexOf('.styl')) path += '.styl'; + + // Lookup + found = utils.lookup(path, this.paths, this.filename); + found = found || utils.lookup(join(name, 'index.styl'), this.paths, this.filename); + + // Expose imports + imported.path = found; + imported.dirname = dirname(found); + this.paths.push(imported.dirname); + if (this.options._imports) this.options._imports.push(imported); + + // Throw if import failed + if (!found) throw new Error('failed to locate @import file ' + path); + + // Parse the file + this.importStack.push(found); + nodes.filename = found; + + var str = fs.readFileSync(found, 'utf8'); + if (literal) return new nodes.Literal(str); + + // parse + var block = new nodes.Block + , parser = new Parser(str, utils.merge({ root: block }, this.options)); + + try { + block = parser.parse(); + } catch (err) { + err.filename = found; + err.lineno = parser.lexer.lineno; + err.input = str; + throw err; + } + + // Store the modified time + fs.stat(found, function(err, stat){ + if (err) return; + imported.mtime = stat.mtime; + }); + + // Evaluate imported "root" + block.parent = root; + block.scope = false; + var ret = this.visit(block); + this.paths.pop(); + this.importStack.pop(); + + return ret; +}; + +/** + * Invoke `fn` with `args`. + * + * @param {Function} fn + * @param {Array} args + * @return {Node} + * @api private + */ + +Evaluator.prototype.invokeFunction = function(fn, args){ + var block = new nodes.Block(fn.block.parent); + fn.block.parent = block; + + // Clone the function body + // to prevent mutation of subsequent calls + var body = fn.block.clone(); + + // mixin block + var mixinBlock = this.stack.currentFrame.block; + + // new block scope + this.stack.push(new Frame(block)); + var scope = this.currentScope; + + // arguments local + scope.add(new nodes.Ident('arguments', args)); + + // mixin scope introspection + scope.add(new nodes.Ident('mixin', this.return + ? nodes.false + : new nodes.String(mixinBlock.nodeName))); + + // current property + if (this.property) { + var prop = this.propertyExpression(this.property, fn.name); + scope.add(new nodes.Ident('current-property', prop)); + } else { + scope.add(new nodes.Ident('current-property', nodes.null)); + } + + // inject arguments as locals + var i = 0 + , len = args.nodes.length; + fn.params.nodes.forEach(function(node){ + // rest param support + if (node.rest) { + node.val = new nodes.Expression; + for (; i < len; ++i) node.val.push(args.nodes[i]); + node.val.preserve = true; + // argument default support + } else { + var arg = args.map[node.name] || args.nodes[i++]; + node = node.clone(); + if (arg) { + if (!arg.isEmpty) node.val = arg; + } else { + args.push(node.val); + } + + // required argument not satisfied + if (node.val.isNull) { + throw new Error('argument "' + node + '" required for ' + fn); + } + } + + scope.add(node); + }); + + // invoke + return this.invoke(body, true); +}; + +/** + * Invoke built-in `fn` with `args`. + * + * @param {Function} fn + * @param {Array} args + * @return {Node} + * @api private + */ + +Evaluator.prototype.invokeBuiltin = function(fn, args){ + // Map arguments to first node + // providing a nicer js api for + // BIFs. Functions may specify that + // they wish to accept full expressions + // via .raw + if (fn.raw) { + args = args.nodes; + } else { + args = utils.params(fn).reduce(function(ret, param){ + var arg = args.map[param] || args.nodes.shift(); + if (arg) ret.push(arg.first); + return ret; + }, []); + } + + // Invoke the BIF + var body = utils.coerce(fn.apply(this, args)); + + // Always wrapping allows js functions + // to return several values with a single + // Expression node + var expr = new nodes.Expression; + expr.push(body); + body = expr; + + // Invoke + return this.invoke(body); +}; + +/** + * Invoke the given function `body`. + * + * @param {Block} body + * @return {Node} + * @api private + */ + +Evaluator.prototype.invoke = function(body, stack){ + var self = this + , ret; + + // Return + if (this.return) { + ret = this.eval(body.nodes); + if (stack) this.stack.pop(); + // Mixin + } else { + var targetFrame = this.stack[this.stack.length - 2]; + if (targetFrame) this.targetBlock = targetFrame.block; + body = this.visit(body); + if (stack) this.stack.pop(); + this.mixin(body.nodes, this.currentBlock); + ret = nodes.null; + } + + return ret; +}; + +/** + * Mixin the given `nodes` to the given `block`. + * + * @param {Array} nodes + * @param {Block} block + * @api private + */ + +Evaluator.prototype.mixin = function(nodes, block){ + var len = block.nodes.length + , head = block.nodes.slice(0, block.index) + , tail = block.nodes.slice(block.index + 1, len); + this._mixin(nodes, head); + block.nodes = head.concat(tail); +}; + +/** + * Mixin the given `nodes` to the `dest` array. + * + * @param {Array} nodes + * @param {Array} dest + * @api private + */ + +Evaluator.prototype._mixin = function(nodes, dest){ + var node + , len = nodes.length; + for (var i = 0; i < len; ++i) { + switch ((node = nodes[i]).nodeName) { + case 'return': + return; + case 'block': + this._mixin(node.nodes, dest); + break; + default: + dest.push(node); + } + } +}; + +/** + * Evaluate the given `vals`. + * + * @param {Array} vals + * @return {Node} + * @api private + */ + +Evaluator.prototype.eval = function(vals){ + if (!vals) return nodes.null; + var len = vals.length + , node = nodes.null; + + try { + for (var i = 0; i < len; ++i) { + node = vals[i]; + switch (node.nodeName) { + case 'if': + if ('block' != node.block.nodeName) { + node = this.visit(node); + break; + } + case 'each': + case 'block': + node = this.visit(node); + if (node.nodes) node = this.eval(node.nodes); + break; + default: + node = this.visit(node); + } + } + } catch (err) { + if ('return' == err.nodeName) { + return err.expr; + } else { + throw err; + } + } + + return node; +}; + +/** + * Literal function `call`. + * + * @param {Call} call + * @return {call} + * @api private + */ + +Evaluator.prototype.literalCall = function(call){ + call.args = this.visit(call.args); + return call; +}; + +/** + * Lookup property `name`. + * + * @param {String} name + * @return {Property} + * @api private + */ + +Evaluator.prototype.lookupProperty = function(name){ + var i = this.stack.length + , prop = this.property + , curr = prop && prop.name + , index = this.currentBlock.index + , top = i + , nodes + , block + , other; + + while (i--) { + block = this.stack[i].block; + if (!block.node) continue; + switch (block.node.nodeName) { + case 'group': + case 'function': + nodes = block.nodes; + // scan siblings from the property index up + if (i + 1 == top) { + while (index--) { + other = this.interpolate(nodes[index]); + if (name == other) return nodes[index].clone(); + } + // sequential lookup for non-siblings (for now) + } else { + for (var j = 0, len = nodes.length; j < len; ++j) { + if ('property' != nodes[j].nodeName) continue; + other = this.interpolate(nodes[j]); + if (name == other) return nodes[j].clone(); + } + } + break; + } + } + + return nodes.null; +}; + +/** + * Return the closest mixin-able `Block`. + * + * @return {Block} + * @api private + */ + +Evaluator.prototype.__defineGetter__('closestBlock', function(){ + var i = this.stack.length + , block; + while (i--) { + block = this.stack[i].block; + if (block.node) { + switch (block.node.nodeName) { + case 'group': + case 'function': + return block; + } + } + } +}); + +/** + * Lookup `name`, with support for JavaScript + * functions, and BIFs. + * + * @param {String} name + * @return {Node} + * @api private + */ + +Evaluator.prototype.lookup = function(name){ + var val; + if (this.ignoreColors && name in colors) return; + if (val = this.stack.lookup(name)) { + return utils.unwrap(val); + } else { + return this.lookupFunction(name); + } +}; + +/** + * Map segments in `node` returning a string. + * + * @param {Node} node + * @return {String} + * @api private + */ + +Evaluator.prototype.interpolate = function(node){ + var self = this; + return node.segments.map(function(node){ + function toString(node) { + switch (node.nodeName) { + case 'function': + case 'ident': + return node.name; + case 'literal': + case 'string': + case 'unit': + return node.val; + case 'expression': + self.return++; + var ret = toString(self.visit(node).first); + self.return--; + return ret; + } + } + return toString(node); + }).join(''); +}; + +/** + * Lookup JavaScript user-defined or built-in function. + * + * @param {String} name + * @return {Function} + * @api private + */ + +Evaluator.prototype.lookupFunction = function(name){ + var fn = this.functions[name] || bifs[name]; + if (fn) return new nodes.Function(name, fn); +}; + +/** + * Check if the given `node` is an ident, and if it is defined. + * + * @param {Node} node + * @return {Boolean} + * @api private + */ + +Evaluator.prototype.isDefined = function(node){ + if ('ident' == node.nodeName) { + return nodes.Boolean(this.lookup(node.name)); + } else { + throw new Error('invalid "is defined" check on non-variable ' + node); + } +}; + +/** + * Return `Expression` based on the given `prop`, + * replacing cyclic calls to the given function `name` + * with "__CALL__". + * + * @param {Property} prop + * @param {String} name + * @return {Expression} + * @api private + */ + +Evaluator.prototype.propertyExpression = function(prop, name){ + var expr = new nodes.Expression + , val = prop.expr.clone(); + + // name + expr.push(new nodes.String(prop.name)); + + // replace cyclic call with __CALL__ + function replace(node) { + if ('call' == node.nodeName && name == node.name) { + return new nodes.Literal('__CALL__'); + } + + if (node.nodes) node.nodes = node.nodes.map(replace); + return node; + } + + replace(val); + expr.push(val); + return expr; +}; + +/** + * Cast `expr` to the trailing ident. + * + * @param {Expression} expr + * @return {Unit} + * @api private + */ + +Evaluator.prototype.cast = function(expr){ + return new nodes.Unit(expr.first.val, expr.nodes[1].name); +}; + +/** + * Check if `expr` is castable. + * + * @param {Expression} expr + * @return {Boolean} + * @api private + */ + +Evaluator.prototype.castable = function(expr){ + return 2 == expr.nodes.length + && 'unit' == expr.first.nodeName + && ~units.indexOf(expr.nodes[1].name); +}; + +/** + * Warn with the given `msg`. + * + * @param {String} msg + * @api private + */ + +Evaluator.prototype.warn = function(msg){ + if (!this.warnings) return; + console.warn('\033[33mWarning:\033[0m ' + msg); +}; + +/** + * Return the current `Block`. + * + * @return {Block} + * @api private + */ + +Evaluator.prototype.__defineGetter__('currentBlock', function(){ + return this.stack.currentFrame.block; +}); + +/** + * Return an array of vendor names. + * + * @return {Array} + * @api private + */ + +Evaluator.prototype.__defineGetter__('vendors', function(){ + return this.lookup('vendors').nodes.map(function(node){ + return node.string; + }); +}); + +/** + * Return the current frame `Scope`. + * + * @return {Scope} + * @api private + */ + +Evaluator.prototype.__defineGetter__('currentScope', function(){ + return this.stack.currentFrame.scope; +}); + +/** + * Return the current `Frame`. + * + * @return {Frame} + * @api private + */ + +Evaluator.prototype.__defineGetter__('currentFrame', function(){ + return this.stack.currentFrame; +}); diff --git a/node_modules/stylus/lib/visitor/index.js b/node_modules/stylus/lib/visitor/index.js new file mode 100644 index 0000000..8b7c991 --- /dev/null +++ b/node_modules/stylus/lib/visitor/index.js @@ -0,0 +1,31 @@ + +/*! + * Stylus - Visitor + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Initialize a new `Visitor` with the given `root` Node. + * + * @param {Node} root + * @api private + */ + +var Visitor = module.exports = function Visitor(root) { + this.root = root; +}; + +/** + * Visit the given `node`. + * + * @param {Node|Array} node + * @api public + */ + +Visitor.prototype.visit = function(node, fn){ + var method = 'visit' + node.constructor.name; + if (this[method]) return this[method](node); + return node; +}; + diff --git a/node_modules/stylus/lib/visitor/normalizer.js b/node_modules/stylus/lib/visitor/normalizer.js new file mode 100644 index 0000000..93f3cb4 --- /dev/null +++ b/node_modules/stylus/lib/visitor/normalizer.js @@ -0,0 +1,225 @@ + +/*! + * Stylus - Normalizer + * Copyright(c) 2010 LearnBoost + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var Visitor = require('./') + , nodes = require('../nodes') + , utils = require('../utils') + , fs = require('fs'); + +/** + * Initialize a new `Normalizer` with the given `root` Node. + * + * This visitor implements the first stage of the duel-stage + * compiler, tasked with stripping the "garbage" from + * the evaluated nodes, ditching null rules, resolving + * ruleset selectors etc. This step performs the logic + * necessary to facilitate the "@extend" functionality, + * as these must be resolved _before_ buffering output. + * + * @param {Node} root + * @api public + */ + +var Normalizer = module.exports = function Normalizer(root, options) { + options = options || {}; + Visitor.call(this, root); + this.stack = []; + this.extends = {}; + this.map = {}; +}; + +/** + * Inherit from `Visitor.prototype`. + */ + +Normalizer.prototype.__proto__ = Visitor.prototype; + +/** + * Normalize the node tree. + * + * @return {Node} + * @api private + */ + +Normalizer.prototype.normalize = function(){ + return this.visit(this.root); +}; + +/** + * Visit Root. + */ + +Normalizer.prototype.visitRoot = function(block){ + var ret = new nodes.Root + , node; + + for (var i = 0, len = block.nodes.length; i < len; ++i) { + node = block.nodes[i]; + switch (node.nodeName) { + case 'null': + case 'expression': + case 'function': + case 'jsliteral': + case 'unit': + continue; + default: + ret.push(this.visit(node)); + } + } + + return ret; +}; + +/** + * Visit Block. + */ + +Normalizer.prototype.visitBlock = function(block){ + var ret = new nodes.Block + , node; + + if (block.hasProperties) { + for (var i = 0, len = block.nodes.length; i < len; ++i) { + this.last = len - 1 == i; + node = block.nodes[i]; + switch (node.nodeName) { + case 'null': + case 'expression': + case 'function': + case 'jsliteral': + case 'group': + case 'unit': + continue; + default: + ret.push(this.visit(node)); + } + } + } + + // nesting + for (var i = 0, len = block.nodes.length; i < len; ++i) { + node = block.nodes[i]; + ret.push(this.visit(node)); + } + + return block; +}; + +/** + * Visit Group. + */ + +Normalizer.prototype.visitGroup = function(group){ + // TODO: clean this mess up + var stack = this.stack + , map = this.map + , self = this; + + stack.push(group.nodes); + + var selectors = this.compileSelectors(stack); + + // map for extension lookup + selectors.forEach(function(selector){ + map[selector] = map[selector] || []; + map[selector].push(group); + }); + + // extensions + this.extend(group, selectors); + + group.block = this.visit(group.block); + stack.pop(); + return group; +}; + +/** + * Apply `group` extensions. + * + * @param {Group} group + * @param {Array} selectors + * @api private + */ + +Normalizer.prototype.extend = function(group, selectors){ + var map = this.map + , self = this; + + group.extends.forEach(function(extend){ + var groups = map[extend]; + if (!groups) throw new Error('Failed to @extend "' + extend + '"'); + selectors.forEach(function(selector){ + var node = new nodes.Selector; + node.val = selector; + node.inherits = false; + groups.forEach(function(group){ + self.extend(group, selectors); + group.push(node); + }); + }); + }); +}; + +/** + * Compile selector strings in `arr` from the bottom-up + * to produce the selector combinations. For example + * the following Stylus: + * + * ul + * li + * p + * a + * color: red + * + * Would return: + * + * [ 'ul li a', 'ul p a' ] + * + * @param {Array} arr + * @return {Array} + * @api private + */ + +Normalizer.prototype.compileSelectors = function(arr){ + // TODO: remove this duplication + var stack = this.stack + , self = this + , selectors = [] + , buf = []; + + function compile(arr, i) { + if (i) { + arr[i].forEach(function(selector){ + buf.unshift(selector.val); + compile(arr, i - 1); + buf.shift(); + }); + } else { + arr[0].forEach(function(selector){ + var str = selector.val.trim(); + if (buf.length) { + for (var i = 0, len = buf.length; i < len; ++i) { + if (~buf[i].indexOf('&')) { + str = buf[i].replace(/&/g, str).trim(); + } else { + str += ' ' + buf[i].trim(); + } + } + } + selectors.push(str.trimRight()); + }); + } + } + + compile(arr, arr.length - 1); + + return selectors; +}; \ No newline at end of file diff --git a/node_modules/stylus/node_modules/cssom/.gitmodules b/node_modules/stylus/node_modules/cssom/.gitmodules new file mode 100644 index 0000000..6357c00 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/.gitmodules @@ -0,0 +1,6 @@ +[submodule "spec/vendor/objectDiff"] + path = spec/vendor/objectDiff + url = git://github.com/NV/objectDiff.js.git +[submodule "spec/vendor/jasmine-html-reporter"] + path = spec/vendor/jasmine-html-reporter + url = git://github.com/NV/jasmine-html-reporter.git diff --git a/node_modules/stylus/node_modules/cssom/.npmignore b/node_modules/stylus/node_modules/cssom/.npmignore new file mode 100644 index 0000000..9c8f462 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/.npmignore @@ -0,0 +1,7 @@ +docs/ +src/ +test/ +spec/ +Jakefile.js +MIT-LICENSE.txt +README.mdown diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSImportRule.js b/node_modules/stylus/node_modules/cssom/lib/CSSImportRule.js new file mode 100644 index 0000000..3539b3e --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSImportRule.js @@ -0,0 +1,131 @@ +//.CommonJS +var CSSOM = { + CSSRule: require("./CSSRule").CSSRule, + CSSStyleSheet: require("./CSSStyleSheet").CSSStyleSheet, + MediaList: require("./MediaList").MediaList +}; +///CommonJS + + +/** + * @constructor + * @see http://dev.w3.org/csswg/cssom/#cssimportrule + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSImportRule + */ +CSSOM.CSSImportRule = function CSSImportRule() { + CSSOM.CSSRule.call(this); + this.href = ""; + this.media = new CSSOM.MediaList; + this.styleSheet = new CSSOM.CSSStyleSheet; +}; + +CSSOM.CSSImportRule.prototype = new CSSOM.CSSRule; +CSSOM.CSSImportRule.prototype.constructor = CSSOM.CSSImportRule; +CSSOM.CSSImportRule.prototype.type = 3; +CSSOM.CSSImportRule.prototype.__defineGetter__("cssText", function() { + var mediaText = this.media.mediaText; + return "@import url(" + this.href + ")" + (mediaText ? " " + mediaText : "") + ";"; +}); + +CSSOM.CSSImportRule.prototype.__defineSetter__("cssText", function(cssText) { + var i = 0; + + /** + * @import url(partial.css) screen, handheld; + * || | + * after-import media + * | + * url + */ + var state = ''; + + var buffer = ''; + var index; + var mediaText = ''; + for (var character; character = cssText.charAt(i); i++) { + + switch (character) { + case ' ': + case '\t': + case '\r': + case '\n': + case '\f': + if (state === 'after-import') { + state = 'url'; + } else { + buffer += character; + } + break; + + case '@': + if (!state && cssText.indexOf('@import', i) === i) { + state = 'after-import'; + i += 'import'.length; + buffer = ''; + } + break; + + case 'u': + if (state === 'url' && cssText.indexOf('url(', i) === i) { + index = cssText.indexOf(')', i + 1); + if (index === -1) { + throw i + ': ")" not found'; + } + i += 'url('.length; + var url = cssText.slice(i, index); + if (url[0] === url[url.length - 1]) { + if (url[0] === '"' || url[0] === "'") { + url = url.slice(1, -1); + } + } + this.href = url; + i = index; + state = 'media'; + } + break; + + case '"': + if (state === 'url') { + index = cssText.indexOf('"', i + 1); + if (!index) { + throw i + ": '\"' not found"; + } + this.href = cssText.slice(i + 1, index); + i = index; + state = 'media'; + } + break; + + case "'": + if (state === 'url') { + index = cssText.indexOf("'", i + 1); + if (!index) { + throw i + ': "\'" not found'; + } + this.href = cssText.slice(i + 1, index); + i = index; + state = 'media'; + } + break; + + case ';': + if (state === 'media') { + if (buffer) { + this.media.mediaText = buffer.trim(); + } + } + break; + + default: + if (state === 'media') { + buffer += character; + } + break; + } + } +}); + + +//.CommonJS +exports.CSSImportRule = CSSOM.CSSImportRule; +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSKeyframeRule.js b/node_modules/stylus/node_modules/cssom/lib/CSSKeyframeRule.js new file mode 100644 index 0000000..f9ee2b4 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSKeyframeRule.js @@ -0,0 +1,35 @@ +//.CommonJS +var CSSOM = { + CSSRule: require("./CSSRule").CSSRule, + CSSStyleDeclaration: require('./CSSStyleDeclaration').CSSStyleDeclaration +}; +///CommonJS + + +/** + * @constructor + * @see http://www.w3.org/TR/css3-animations/#DOM-CSSKeyframeRule + */ +CSSOM.CSSKeyframeRule = function CSSKeyframeRule() { + CSSOM.CSSRule.call(this); + this.keyText = ''; + this.style = new CSSOM.CSSStyleDeclaration; + this.style.parentRule = this; +}; + +CSSOM.CSSKeyframeRule.prototype = new CSSOM.CSSRule; +CSSOM.CSSKeyframeRule.prototype.constructor = CSSOM.CSSKeyframeRule; +CSSOM.CSSKeyframeRule.prototype.type = 9; +//FIXME +//CSSOM.CSSKeyframeRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule; +//CSSOM.CSSKeyframeRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule; + +// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframeRule.cpp +CSSOM.CSSKeyframeRule.prototype.__defineGetter__("cssText", function() { + return this.keyText + " { " + this.style.cssText + " } "; +}); + + +//.CommonJS +exports.CSSKeyframeRule = CSSOM.CSSKeyframeRule; +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSKeyframesRule.js b/node_modules/stylus/node_modules/cssom/lib/CSSKeyframesRule.js new file mode 100644 index 0000000..0ae70ba --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSKeyframesRule.js @@ -0,0 +1,37 @@ +//.CommonJS +var CSSOM = { + CSSRule: require("./CSSRule").CSSRule +}; +///CommonJS + + +/** + * @constructor + * @see http://www.w3.org/TR/css3-animations/#DOM-CSSKeyframesRule + */ +CSSOM.CSSKeyframesRule = function CSSKeyframesRule() { + CSSOM.CSSRule.call(this); + this.name = ''; + this.cssRules = []; +}; + +CSSOM.CSSKeyframesRule.prototype = new CSSOM.CSSRule; +CSSOM.CSSKeyframesRule.prototype.constructor = CSSOM.CSSKeyframesRule; +CSSOM.CSSKeyframesRule.prototype.type = 8; +//FIXME +//CSSOM.CSSKeyframesRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule; +//CSSOM.CSSKeyframesRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule; + +// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframesRule.cpp +CSSOM.CSSKeyframesRule.prototype.__defineGetter__("cssText", function() { + var cssTexts = []; + for (var i=0, length=this.cssRules.length; i < length; i++) { + cssTexts.push(" " + this.cssRules[i].cssText); + } + return "@" + (this._vendorPrefix || '') + "keyframes " + this.name + " { \n" + cssTexts.join("\n") + "\n}"; +}); + + +//.CommonJS +exports.CSSKeyframesRule = CSSOM.CSSKeyframesRule; +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSMediaRule.js b/node_modules/stylus/node_modules/cssom/lib/CSSMediaRule.js new file mode 100644 index 0000000..a6d15f8 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSMediaRule.js @@ -0,0 +1,39 @@ +//.CommonJS +var CSSOM = { + CSSRule: require("./CSSRule").CSSRule, + MediaList: require("./MediaList").MediaList +}; +///CommonJS + + +/** + * @constructor + * @see http://dev.w3.org/csswg/cssom/#cssmediarule + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSMediaRule + */ +CSSOM.CSSMediaRule = function CSSMediaRule() { + CSSOM.CSSRule.call(this); + this.media = new CSSOM.MediaList; + this.cssRules = []; +}; + +CSSOM.CSSMediaRule.prototype = new CSSOM.CSSRule; +CSSOM.CSSMediaRule.prototype.constructor = CSSOM.CSSMediaRule; +CSSOM.CSSMediaRule.prototype.type = 4; +//FIXME +//CSSOM.CSSMediaRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule; +//CSSOM.CSSMediaRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule; + +// http://opensource.apple.com/source/WebCore/WebCore-658.28/css/CSSMediaRule.cpp +CSSOM.CSSMediaRule.prototype.__defineGetter__("cssText", function() { + var cssTexts = []; + for (var i=0, length=this.cssRules.length; i < length; i++) { + cssTexts.push(this.cssRules[i].cssText); + } + return "@media " + this.media.mediaText + " {" + cssTexts.join("") + "}"; +}); + + +//.CommonJS +exports.CSSMediaRule = CSSOM.CSSMediaRule; +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSRule.js b/node_modules/stylus/node_modules/cssom/lib/CSSRule.js new file mode 100644 index 0000000..4acff83 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSRule.js @@ -0,0 +1,39 @@ +//.CommonJS +var CSSOM = {}; +///CommonJS + + +/** + * @constructor + * @see http://dev.w3.org/csswg/cssom/#the-cssrule-interface + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSRule + */ +CSSOM.CSSRule = function CSSRule() { + this.parentRule = null; + this.parentStyleSheet = null; +}; + +CSSOM.CSSRule.STYLE_RULE = 1; +CSSOM.CSSRule.IMPORT_RULE = 3; +CSSOM.CSSRule.MEDIA_RULE = 4; +CSSOM.CSSRule.FONT_FACE_RULE = 5; +CSSOM.CSSRule.PAGE_RULE = 6; +CSSOM.CSSRule.WEBKIT_KEYFRAMES_RULE = 8; +CSSOM.CSSRule.WEBKIT_KEYFRAME_RULE = 9; + +// Obsolete in CSSOM http://dev.w3.org/csswg/cssom/ +//CSSOM.CSSRule.UNKNOWN_RULE = 0; +//CSSOM.CSSRule.CHARSET_RULE = 2; + +// Never implemented +//CSSOM.CSSRule.VARIABLES_RULE = 7; + +CSSOM.CSSRule.prototype = { + constructor: CSSOM.CSSRule + //FIXME +}; + + +//.CommonJS +exports.CSSRule = CSSOM.CSSRule; +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSStyleDeclaration.js b/node_modules/stylus/node_modules/cssom/lib/CSSStyleDeclaration.js new file mode 100644 index 0000000..365a1d3 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSStyleDeclaration.js @@ -0,0 +1,148 @@ +//.CommonJS +var CSSOM = {}; +///CommonJS + + +/** + * @constructor + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration + */ +CSSOM.CSSStyleDeclaration = function CSSStyleDeclaration(){ + this.length = 0; + this.parentRule = null; + + // NON-STANDARD + this._importants = {}; +}; + + +CSSOM.CSSStyleDeclaration.prototype = { + + constructor: CSSOM.CSSStyleDeclaration, + + /** + * + * @param {string} name + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-getPropertyValue + * @return {string} the value of the property if it has been explicitly set for this declaration block. + * Returns the empty string if the property has not been set. + */ + getPropertyValue: function(name) { + return this[name] || ""; + }, + + /** + * + * @param {string} name + * @param {string} value + * @param {string} [priority=null] "important" or null + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-setProperty + */ + setProperty: function(name, value, priority) { + if (this[name]) { + // Property already exist. Overwrite it. + var index = Array.prototype.indexOf.call(this, name); + if (index < 0) { + this[this.length] = name; + this.length++; + } + } else { + // New property. + this[this.length] = name; + this.length++; + } + this[name] = value; + this._importants[name] = priority; + }, + + /** + * + * @param {string} name + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-removeProperty + * @return {string} the value of the property if it has been explicitly set for this declaration block. + * Returns the empty string if the property has not been set or the property name does not correspond to a known CSS property. + */ + removeProperty: function(name) { + if (!(name in this)) { + return ""; + } + var index = Array.prototype.indexOf.call(this, name); + if (index < 0) { + return ""; + } + var prevValue = this[name]; + this[name] = ""; + + // That's what WebKit and Opera do + Array.prototype.splice.call(this, index, 1); + + // That's what Firefox does + //this[index] = "" + + return prevValue; + }, + + getPropertyCSSValue: function() { + //FIXME + }, + + /** + * + * @param {String} name + */ + getPropertyPriority: function(name) { + return this._importants[name] || ""; + }, + + + /** + * element.style.overflow = "auto" + * element.style.getPropertyShorthand("overflow-x") + * -> "overflow" + */ + getPropertyShorthand: function() { + //FIXME + }, + + isPropertyImplicit: function() { + //FIXME + }, + + // Doesn't work in IE < 9 + get cssText(){ + var properties = []; + for (var i=0, length=this.length; i < length; ++i) { + var name = this[i]; + var value = this.getPropertyValue(name); + var priority = this.getPropertyPriority(name); + if (priority) { + priority = " !" + priority; + } + properties[i] = name + ": " + value + priority + ";"; + } + return properties.join(" "); + }, + + set cssText(cssText){ + var i, name; + for (i = this.length; i--;) { + name = this[i]; + this[name] = ""; + } + Array.prototype.splice.call(this, 0, this.length); + this._importants = {}; + + var dummyRule = CSSOM.parse('#bogus{' + cssText + '}').cssRules[0].style; + var length = dummyRule.length; + for (i = 0; i < length; ++i) { + name = dummyRule[i]; + this.setProperty(dummyRule[i], dummyRule.getPropertyValue(name), dummyRule.getPropertyPriority(name)); + } + } +}; + + +//.CommonJS +exports.CSSStyleDeclaration = CSSOM.CSSStyleDeclaration; +CSSOM.parse = require('./parse').parse; // Cannot be included sooner due to the mutual dependency between parse.js and CSSStyleDeclaration.js +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSStyleRule.js b/node_modules/stylus/node_modules/cssom/lib/CSSStyleRule.js new file mode 100644 index 0000000..4224397 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSStyleRule.js @@ -0,0 +1,189 @@ +//.CommonJS +var CSSOM = { + CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration, + CSSRule: require("./CSSRule").CSSRule +}; +///CommonJS + + +/** + * @constructor + * @see http://dev.w3.org/csswg/cssom/#cssstylerule + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleRule + */ +CSSOM.CSSStyleRule = function CSSStyleRule() { + CSSOM.CSSRule.call(this); + this.selectorText = ""; + this.style = new CSSOM.CSSStyleDeclaration; + this.style.parentRule = this; +}; + +CSSOM.CSSStyleRule.prototype = new CSSOM.CSSRule; +CSSOM.CSSStyleRule.prototype.constructor = CSSOM.CSSStyleRule; +CSSOM.CSSStyleRule.prototype.type = 1; + +CSSOM.CSSStyleRule.prototype.__defineGetter__("cssText", function() { + var text; + if (this.selectorText) { + text = this.selectorText + " {" + this.style.cssText + "}"; + } else { + text = ""; + } + return text; +}); + +CSSOM.CSSStyleRule.prototype.__defineSetter__("cssText", function(cssText) { + var rule = CSSOM.CSSStyleRule.parse(cssText); + this.style = rule.style; + this.selectorText = rule.selectorText; +}); + + +/** + * NON-STANDARD + * lightweight version of parse.js. + * @param {string} ruleText + * @return CSSStyleRule + */ +CSSOM.CSSStyleRule.parse = function(ruleText) { + var i = 0; + var state = "selector"; + var index; + var j = i; + var buffer = ""; + + var SIGNIFICANT_WHITESPACE = { + "selector": true, + "value": true + }; + + var styleRule = new CSSOM.CSSStyleRule; + var selector, name, value, priority=""; + + for (var character; character = ruleText.charAt(i); i++) { + + switch (character) { + + case " ": + case "\t": + case "\r": + case "\n": + case "\f": + if (SIGNIFICANT_WHITESPACE[state]) { + // Squash 2 or more white-spaces in the row into 1 + switch (ruleText.charAt(i - 1)) { + case " ": + case "\t": + case "\r": + case "\n": + case "\f": + break; + default: + buffer += " "; + break; + } + } + break; + + // String + case '"': + j = i + 1; + index = ruleText.indexOf('"', j) + 1; + if (!index) { + throw '" is missing'; + } + buffer += ruleText.slice(i, index); + i = index - 1; + break; + + case "'": + j = i + 1; + index = ruleText.indexOf("'", j) + 1; + if (!index) { + throw "' is missing"; + } + buffer += ruleText.slice(i, index); + i = index - 1; + break; + + // Comment + case "/": + if (ruleText.charAt(i + 1) === "*") { + i += 2; + index = ruleText.indexOf("*/", i); + if (index === -1) { + throw new SyntaxError("Missing */"); + } else { + i = index + 1; + } + } else { + buffer += character; + } + break; + + case "{": + if (state === "selector") { + styleRule.selectorText = buffer.trim(); + buffer = ""; + state = "name"; + } + break; + + case ":": + if (state === "name") { + name = buffer.trim(); + buffer = ""; + state = "value"; + } else { + buffer += character; + } + break; + + case "!": + if (state === "value" && ruleText.indexOf("!important", i) === i) { + priority = "important"; + i += "important".length; + } else { + buffer += character; + } + break; + + case ";": + if (state === "value") { + styleRule.style.setProperty(name, buffer.trim(), priority); + priority = ""; + buffer = ""; + state = "name"; + } else { + buffer += character; + } + break; + + case "}": + if (state === "value") { + styleRule.style.setProperty(name, buffer.trim(), priority); + priority = ""; + buffer = ""; + } else if (state === "name") { + break; + } else { + buffer += character; + } + state = "selector"; + break; + + default: + buffer += character; + break; + + } + } + + return styleRule; + +}; + + +//.CommonJS +exports.CSSStyleRule = CSSOM.CSSStyleRule; +///CommonJS diff --git a/node_modules/stylus/node_modules/cssom/lib/CSSStyleSheet.js b/node_modules/stylus/node_modules/cssom/lib/CSSStyleSheet.js new file mode 100644 index 0000000..38fd683 --- /dev/null +++ b/node_modules/stylus/node_modules/cssom/lib/CSSStyleSheet.js @@ -0,0 +1,85 @@ +//.CommonJS +var CSSOM = { + StyleSheet: require("./StyleSheet").StyleSheet, + CSSStyleRule: require("./CSSStyleRule").CSSStyleRule +}; +///CommonJS + + +/** + * @constructor + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet + */ +CSSOM.CSSStyleSheet = function CSSStyleSheet() { + CSSOM.StyleSheet.call(this); + this.cssRules = []; +}; + + +CSSOM.CSSStyleSheet.prototype = new CSSOM.StyleSheet; +CSSOM.CSSStyleSheet.prototype.constructor = CSSOM.CSSStyleSheet; + + +/** + * Used to insert a new rule into the style sheet. The new rule now becomes part of the cascade. + * + * sheet = new Sheet("body {margin: 0}") + * sheet.toString() + * -> "body{margin:0;}" + * sheet.insertRule("img {border: none}", 0) + * -> 0 + * sheet.toString() + * -> "img{border:none;}body{margin:0;}" + * + * @param {string} rule + * @param {number} index + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet-insertRule + * @return {number} The index within the style sheet's rule collection of the newly inserted rule. + */ +CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) { + if (index < 0 || index > this.cssRules.length) { + throw new RangeError("INDEX_SIZE_ERR"); + } + this.cssRules.splice(index, 0, CSSOM.CSSStyleRule.parse(rule)); + return index; +}; + + +/** + * Used to delete a rule from the style sheet. + * + * sheet = new Sheet("img{border:none} body{margin:0}") + * sheet.toString() + * -> "img{border:none;}body{margin:0;}" + * sheet.deleteRule(0) + * sheet.toString() + * -> "body{margin:0;}" + * + * @param {number} index within the style sheet's rule list of the rule to remove. + * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet-deleteRule + */ +CSSOM.CSSStyleSheet.prototype.deleteRule = function(index) { + if (index < 0 || index >= this.cssRules.length) { + throw new RangeError("INDEX_SIZE_ERR"); + } + this.cssRules.splice(index, 1); +}; + + +/** + * NON-STANDARD + * @return {string} serialize stylesheet + */ +CSSOM.CSSStyleSheet.prototype.toString = function() { + var result = ""; + var rules = this.cssRules; + for (var i=0; i=0.2.0" + }, + "devDependencies": { + "jake": "0.2.x" + }, + "licenses": [ + { + "type": "MIT", + "url": "http://creativecommons.org/licenses/MIT/" + } + ], + "scripts": { + "prepublish": "jake lib/index.js" + }, + "_id": "cssom@0.2.3", + "dependencies": {}, + "optionalDependencies": {}, + "_engineSupported": true, + "_npmVersion": "1.1.16", + "_nodeVersion": "v0.6.15", + "_defaultsLoaded": true, + "_from": "cssom@0.2.x" +} diff --git a/node_modules/stylus/node_modules/debug/.npmignore b/node_modules/stylus/node_modules/debug/.npmignore new file mode 100644 index 0000000..f1250e5 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/.npmignore @@ -0,0 +1,4 @@ +support +test +examples +*.sock diff --git a/node_modules/stylus/node_modules/debug/History.md b/node_modules/stylus/node_modules/debug/History.md new file mode 100644 index 0000000..f3c1a98 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/History.md @@ -0,0 +1,41 @@ + +0.6.0 / 2012-03-16 +================== + + * Added support for "-" prefix in DEBUG [Vinay Pulim] + * Added `.enabled` flag to the node version [TooTallNate] + +0.5.0 / 2012-02-02 +================== + + * Added: humanize diffs. Closes #8 + * Added `debug.disable()` to the CS variant + * Removed padding. Closes #10 + * Fixed: persist client-side variant again. Closes #9 + +0.4.0 / 2012-02-01 +================== + + * Added browser variant support for older browsers [TooTallNate] + * Added `debug.enable('project:*')` to browser variant [TooTallNate] + * Added padding to diff (moved it to the right) + +0.3.0 / 2012-01-26 +================== + + * Added millisecond diff when isatty, otherwise UTC string + +0.2.0 / 2012-01-22 +================== + + * Added wildcard support + +0.1.0 / 2011-12-02 +================== + + * Added: remove colors unless stderr isatty [TooTallNate] + +0.0.1 / 2010-01-03 +================== + + * Initial release diff --git a/node_modules/stylus/node_modules/debug/Makefile b/node_modules/stylus/node_modules/debug/Makefile new file mode 100644 index 0000000..36a3ed7 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/Makefile @@ -0,0 +1,5 @@ + +test: + @echo "populate me" + +.PHONY: test \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/Readme.md b/node_modules/stylus/node_modules/debug/Readme.md new file mode 100644 index 0000000..419fcdf --- /dev/null +++ b/node_modules/stylus/node_modules/debug/Readme.md @@ -0,0 +1,130 @@ + +# debug + + tiny node.js debugging utility. + +## Installation + +``` +$ npm install debug +``` + +## Example + + This module is modelled after node core's debugging technique, allowing you to enable one or more topic-specific debugging functions, for example core does the following within many modules: + +```js +var debug; +if (process.env.NODE_DEBUG && /cluster/.test(process.env.NODE_DEBUG)) { + debug = function(x) { + var prefix = process.pid + ',' + + (process.env.NODE_WORKER_ID ? 'Worker' : 'Master'); + console.error(prefix, x); + }; +} else { + debug = function() { }; +} +``` + + This concept is extremely simple but it works well. With `debug` you simply invoke the exported function to generate your debug function, passing it a name which will determine if a noop function is returned, or a decorated `console.error`, so all of the `console` format string goodies you're used to work fine. A unique color is selected per-function for visibility. + +Example _app.js_: + +```js +var debug = require('debug')('http') + , http = require('http') + , name = 'My App'; + +// fake app + +debug('booting %s', name); + +http.createServer(function(req, res){ + debug(req.method + ' ' + req.url); + res.end('hello\n'); +}).listen(3000, function(){ + debug('listening'); +}); + +// fake worker of some kind + +require('./worker'); +``` + +Example _worker.js_: + +```js +var debug = require('debug')('worker'); + +setInterval(function(){ + debug('doing some work'); +}, 1000); +``` + + The __DEBUG__ environment variable is then used to enable these based on space or comma-delimited names. Here are some examples: + + ![debug http and worker](http://f.cl.ly/items/18471z1H402O24072r1J/Screenshot.png) + + ![debug worker](http://f.cl.ly/items/1X413v1a3M0d3C2c1E0i/Screenshot.png) + +## Millisecond diff + + When actively developing an application it can be useful to see when the time spent between one `debug()` call and the next. Suppose for example you invoke `debug()` before requesting a resource, and after as well, the "+NNNms" will show you how much time was spent between calls. + + ![](http://f.cl.ly/items/2i3h1d3t121M2Z1A3Q0N/Screenshot.png) + + When stdout is not a TTY, `Date#toUTCString()` is used, making it more useful for logging the debug information as shown below: + + ![](http://f.cl.ly/items/112H3i0e0o0P0a2Q2r11/Screenshot.png) + +## Conventions + + If you're using this in one or more of your libraries, you _should_ use the name of your library so that developers may toggle debugging as desired without guessing names. If you have more than one debuggers you _should_ prefix them with your library name and use ":" to separate features. For example "bodyParser" from Connect would then be "connect:bodyParser". + +## Wildcards + + The "*" character may be used as a wildcard. Suppose for example your library has debuggers named "connect:bodyParser", "connect:compress", "connect:session", instead of listing all three with `DEBUG=connect:bodyParser,connect.compress,connect:session`, you may simply do `DEBUG=connect:*`, or to run everything using this module simply use `DEBUG=*`. + + You can also exclude specific debuggers by prefixing them with a "-" character. For example, `DEBUG=* -connect:*` would include all debuggers except those starting with "connect:". + +## Browser support + + Debug works in the browser as well, currently persisted by `localStorage`. For example if you have `worker:a` and `worker:b` as shown below, and wish to debug both type `debug.enable('worker:*')` in the console and refresh the page, this will remain until you disable with `debug.disable()`. + +```js +a = debug('worker:a'); +b = debug('worker:b'); + +setInterval(function(){ + a('doing some work'); +}, 1000); + +setInterval(function(){ + a('doing some work'); +}, 1200); +``` + +## License + +(The MIT License) + +Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca> + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/debug.js b/node_modules/stylus/node_modules/debug/debug.js new file mode 100644 index 0000000..b2f0798 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/debug.js @@ -0,0 +1,122 @@ + +/*! + * debug + * Copyright(c) 2012 TJ Holowaychuk + * MIT Licensed + */ + +/** + * Create a debugger with the given `name`. + * + * @param {String} name + * @return {Type} + * @api public + */ + +function debug(name) { + if (!debug.enabled(name)) return function(){}; + + return function(fmt){ + var curr = new Date; + var ms = curr - (debug[name] || curr); + debug[name] = curr; + + fmt = name + + ' ' + + fmt + + ' +' + debug.humanize(ms); + + // This hackery is required for IE8 + // where `console.log` doesn't have 'apply' + window.console + && console.log + && Function.prototype.apply.call(console.log, console, arguments); + } +} + +/** + * The currently active debug mode names. + */ + +debug.names = []; +debug.skips = []; + +/** + * Enables a debug mode by name. This can include modes + * separated by a colon and wildcards. + * + * @param {String} name + * @api public + */ + +debug.enable = function(name) { + localStorage.debug = name; + + var split = (name || '').split(/[\s,]+/) + , len = split.length; + + for (var i = 0; i < len; i++) { + name = split[i].replace('*', '.*?'); + if (name[0] === '-') { + debug.skips.push(new RegExp('^' + name.substr(1) + '$')); + } + else { + debug.names.push(new RegExp('^' + name + '$')); + } + } +}; + +/** + * Disable debug output. + * + * @api public + */ + +debug.disable = function(){ + debug.enable(''); +}; + +/** + * Humanize the given `ms`. + * + * @param {Number} m + * @return {String} + * @api private + */ + +debug.humanize = function(ms) { + var sec = 1000 + , min = 60 * 1000 + , hour = 60 * min; + + if (ms >= hour) return (ms / hour).toFixed(1) + 'h'; + if (ms >= min) return (ms / min).toFixed(1) + 'm'; + if (ms >= sec) return (ms / sec | 0) + 's'; + return ms + 'ms'; +}; + +/** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + +debug.enabled = function(name) { + for (var i = 0, len = debug.skips.length; i < len; i++) { + if (debug.skips[i].test(name)) { + return false; + } + } + for (var i = 0, len = debug.names.length; i < len; i++) { + if (debug.names[i].test(name)) { + return true; + } + } + return false; +}; + +// persist + +if (window.localStorage) debug.enable(localStorage.debug); \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/example/app.js b/node_modules/stylus/node_modules/debug/example/app.js new file mode 100644 index 0000000..05374d9 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/example/app.js @@ -0,0 +1,19 @@ + +var debug = require('../')('http') + , http = require('http') + , name = 'My App'; + +// fake app + +debug('booting %s', name); + +http.createServer(function(req, res){ + debug(req.method + ' ' + req.url); + res.end('hello\n'); +}).listen(3000, function(){ + debug('listening'); +}); + +// fake worker of some kind + +require('./worker'); \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/example/browser.html b/node_modules/stylus/node_modules/debug/example/browser.html new file mode 100644 index 0000000..7510eee --- /dev/null +++ b/node_modules/stylus/node_modules/debug/example/browser.html @@ -0,0 +1,24 @@ + + + debug() + + + + + + + diff --git a/node_modules/stylus/node_modules/debug/example/wildcards.js b/node_modules/stylus/node_modules/debug/example/wildcards.js new file mode 100644 index 0000000..1fdac20 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/example/wildcards.js @@ -0,0 +1,10 @@ + +var debug = { + foo: require('../')('test:foo'), + bar: require('../')('test:bar'), + baz: require('../')('test:baz') +}; + +debug.foo('foo') +debug.bar('bar') +debug.baz('baz') \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/example/worker.js b/node_modules/stylus/node_modules/debug/example/worker.js new file mode 100644 index 0000000..7f6d288 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/example/worker.js @@ -0,0 +1,22 @@ + +// DEBUG=* node example/worker +// DEBUG=worker:* node example/worker +// DEBUG=worker:a node example/worker +// DEBUG=worker:b node example/worker + +var a = require('../')('worker:a') + , b = require('../')('worker:b'); + +function work() { + a('doing lots of uninteresting work'); + setTimeout(work, Math.random() * 1000); +} + +work(); + +function workb() { + b('doing some work'); + setTimeout(workb, Math.random() * 2000); +} + +workb(); \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/index.js b/node_modules/stylus/node_modules/debug/index.js new file mode 100644 index 0000000..ee54454 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/index.js @@ -0,0 +1,2 @@ + +module.exports = require('./lib/debug'); \ No newline at end of file diff --git a/node_modules/stylus/node_modules/debug/lib/debug.js b/node_modules/stylus/node_modules/debug/lib/debug.js new file mode 100644 index 0000000..984dfb5 --- /dev/null +++ b/node_modules/stylus/node_modules/debug/lib/debug.js @@ -0,0 +1,147 @@ + +/*! + * debug + * Copyright(c) 2012 TJ Holowaychuk + * MIT Licensed + */ + +/** + * Module dependencies. + */ + +var tty = require('tty'); + +/** + * Expose `debug()` as the module. + */ + +module.exports = debug; + +/** + * Library version. + */ + +exports.version = '0.6.0'; + +/** + * Enabled debuggers. + */ + +var names = [] + , skips = []; + +(process.env.DEBUG || '') + .split(/[\s,]+/) + .forEach(function(name){ + name = name.replace('*', '.*?'); + if (name[0] === '-') { + skips.push(new RegExp('^' + name.substr(1) + '$')); + } else { + names.push(new RegExp('^' + name + '$')); + } + }); + +/** + * Colors. + */ + +var colors = [6, 2, 3, 4, 5, 1]; + +/** + * Previous debug() call. + */ + +var prev = {}; + +/** + * Previously assigned color. + */ + +var prevColor = 0; + +/** + * Is stdout a TTY? Colored output is disabled when `true`. + */ + +var isatty = tty.isatty(2); + +/** + * Select a color. + * + * @return {Number} + * @api private + */ + +function color() { + return colors[prevColor++ % colors.length]; +} + +/** + * Humanize the given `ms`. + * + * @param {Number} m + * @return {String} + * @api private + */ + +function humanize(ms) { + var sec = 1000 + , min = 60 * 1000 + , hour = 60 * min; + + if (ms >= hour) return (ms / hour).toFixed(1) + 'h'; + if (ms >= min) return (ms / min).toFixed(1) + 'm'; + if (ms >= sec) return (ms / sec | 0) + 's'; + return ms + 'ms'; +} + +/** + * Create a debugger with the given `name`. + * + * @param {String} name + * @return {Type} + * @api public + */ + +function debug(name) { + function disabled(){} + disabled.enabled = false; + + var match = skips.some(function(re){ + return re.test(name); + }); + + if (match) return disabled; + + match = names.some(function(re){ + return re.test(name); + }); + + if (!match) return disabled; + var c = color(); + + function colored(fmt) { + var curr = new Date; + var ms = curr - (prev[name] || curr); + prev[name] = curr; + + fmt = ' \033[9' + c + 'm' + name + ' ' + + '\033[3' + c + 'm\033[90m' + + fmt + '\033[3' + c + 'm' + + ' +' + humanize(ms) + '\033[0m'; + + console.error.apply(this, arguments); + } + + function plain(fmt) { + fmt = new Date().toUTCString() + + ' ' + name + ' ' + fmt; + console.error.apply(this, arguments); + } + + colored.enabled = plain.enabled = true; + + return isatty + ? colored + : plain; +} diff --git a/node_modules/stylus/node_modules/debug/package.json b/node_modules/stylus/node_modules/debug/package.json new file mode 100644 index 0000000..4e2b08e --- /dev/null +++ b/node_modules/stylus/node_modules/debug/package.json @@ -0,0 +1,32 @@ +{ + "name": "debug", + "version": "0.6.0", + "description": "small debugging utility", + "keywords": [ + "debug", + "log", + "debugger" + ], + "author": { + "name": "TJ Holowaychuk", + "email": "tj@vision-media.ca" + }, + "dependencies": {}, + "devDependencies": { + "mocha": "*" + }, + "main": "index", + "engines": { + "node": "*" + }, + "_id": "debug@0.6.0", + "optionalDependencies": {}, + "_engineSupported": true, + "_npmVersion": "1.1.16", + "_nodeVersion": "v0.6.15", + "_defaultsLoaded": true, + "dist": { + "shasum": "b018b4effa5fc03e8acc75c28b083c7bc1b9e610" + }, + "_from": "debug@*" +} diff --git a/node_modules/stylus/node_modules/mkdirp/.gitignore.orig b/node_modules/stylus/node_modules/mkdirp/.gitignore.orig new file mode 100644 index 0000000..9303c34 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/.gitignore.orig @@ -0,0 +1,2 @@ +node_modules/ +npm-debug.log \ No newline at end of file diff --git a/node_modules/stylus/node_modules/mkdirp/.gitignore.rej b/node_modules/stylus/node_modules/mkdirp/.gitignore.rej new file mode 100644 index 0000000..69244ff --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/.gitignore.rej @@ -0,0 +1,5 @@ +--- /dev/null ++++ .gitignore +@@ -0,0 +1,2 @@ ++node_modules/ ++npm-debug.log \ No newline at end of file diff --git a/node_modules/stylus/node_modules/mkdirp/.npmignore b/node_modules/stylus/node_modules/mkdirp/.npmignore new file mode 100644 index 0000000..9303c34 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/.npmignore @@ -0,0 +1,2 @@ +node_modules/ +npm-debug.log \ No newline at end of file diff --git a/node_modules/stylus/node_modules/mkdirp/.travis.yml b/node_modules/stylus/node_modules/mkdirp/.travis.yml new file mode 100644 index 0000000..f1d0f13 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/.travis.yml @@ -0,0 +1,4 @@ +language: node_js +node_js: + - 0.4 + - 0.6 diff --git a/node_modules/stylus/node_modules/mkdirp/LICENSE b/node_modules/stylus/node_modules/mkdirp/LICENSE new file mode 100644 index 0000000..432d1ae --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/LICENSE @@ -0,0 +1,21 @@ +Copyright 2010 James Halliday (mail@substack.net) + +This project is free software released under the MIT/X11 license: + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/stylus/node_modules/mkdirp/README.markdown b/node_modules/stylus/node_modules/mkdirp/README.markdown new file mode 100644 index 0000000..40de04f --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/README.markdown @@ -0,0 +1,61 @@ +mkdirp +====== + +Like `mkdir -p`, but in node.js! + +[![build status](https://secure.travis-ci.org/substack/node-mkdirp.png)](http://travis-ci.org/substack/node-mkdirp) + +example +======= + +pow.js +------ + var mkdirp = require('mkdirp'); + + mkdirp('/tmp/foo/bar/baz', function (err) { + if (err) console.error(err) + else console.log('pow!') + }); + +Output + pow! + +And now /tmp/foo/bar/baz exists, huzzah! + +methods +======= + +var mkdirp = require('mkdirp'); + +mkdirp(dir, mode, cb) +--------------------- + +Create a new directory and any necessary subdirectories at `dir` with octal +permission string `mode`. + +If `mode` isn't specified, it defaults to `0777 & (~process.umask())`. + +`cb(err, made)` fires with the error or the first directory `made` +that had to be created, if any. + +mkdirp.sync(dir, mode) +---------------------- + +Synchronously create a new directory and any necessary subdirectories at `dir` +with octal permission string `mode`. + +If `mode` isn't specified, it defaults to `0777 & (~process.umask())`. + +Returns the first directory that had to be created, if any. + +install +======= + +With [npm](http://npmjs.org) do: + + npm install mkdirp + +license +======= + +MIT/X11 diff --git a/node_modules/stylus/node_modules/mkdirp/examples/pow.js b/node_modules/stylus/node_modules/mkdirp/examples/pow.js new file mode 100644 index 0000000..e692421 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/examples/pow.js @@ -0,0 +1,6 @@ +var mkdirp = require('mkdirp'); + +mkdirp('/tmp/foo/bar/baz', function (err) { + if (err) console.error(err) + else console.log('pow!') +}); diff --git a/node_modules/stylus/node_modules/mkdirp/examples/pow.js.orig b/node_modules/stylus/node_modules/mkdirp/examples/pow.js.orig new file mode 100644 index 0000000..7741462 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/examples/pow.js.orig @@ -0,0 +1,6 @@ +var mkdirp = require('mkdirp'); + +mkdirp('/tmp/foo/bar/baz', 0755, function (err) { + if (err) console.error(err) + else console.log('pow!') +}); diff --git a/node_modules/stylus/node_modules/mkdirp/examples/pow.js.rej b/node_modules/stylus/node_modules/mkdirp/examples/pow.js.rej new file mode 100644 index 0000000..81e7f43 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/examples/pow.js.rej @@ -0,0 +1,19 @@ +--- examples/pow.js ++++ examples/pow.js +@@ -1,6 +1,15 @@ +-var mkdirp = require('mkdirp').mkdirp; ++var mkdirp = require('../').mkdirp, ++ mkdirpSync = require('../').mkdirpSync; + + mkdirp('/tmp/foo/bar/baz', 0755, function (err) { + if (err) console.error(err) + else console.log('pow!') + }); ++ ++try { ++ mkdirpSync('/tmp/bar/foo/baz', 0755); ++ console.log('double pow!'); ++} ++catch (ex) { ++ console.log(ex); ++} \ No newline at end of file diff --git a/node_modules/stylus/node_modules/mkdirp/index.js b/node_modules/stylus/node_modules/mkdirp/index.js new file mode 100644 index 0000000..6d81c62 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/index.js @@ -0,0 +1,83 @@ +var path = require('path'); +var fs = require('fs'); + +module.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP; + +function mkdirP (p, mode, f, made) { + if (typeof mode === 'function' || mode === undefined) { + f = mode; + mode = 0777 & (~process.umask()); + } + if (!made) made = null; + + var cb = f || function () {}; + if (typeof mode === 'string') mode = parseInt(mode, 8); + p = path.resolve(p); + + fs.mkdir(p, mode, function (er) { + if (!er) { + made = made || p; + return cb(null, made); + } + switch (er.code) { + case 'ENOENT': + mkdirP(path.dirname(p), mode, function (er, made) { + if (er) cb(er, made); + else mkdirP(p, mode, cb, made); + }); + break; + + case 'EEXIST': + fs.stat(p, function (er2, stat) { + // if the stat fails, then that's super weird. + // let the original EEXIST be the failure reason. + if (er2 || !stat.isDirectory()) cb(er, made) + else cb(null, made); + }); + break; + + default: + cb(er, made); + break; + } + }); +} + +mkdirP.sync = function sync (p, mode, made) { + if (mode === undefined) { + mode = 0777 & (~process.umask()); + } + if (!made) made = null; + + if (typeof mode === 'string') mode = parseInt(mode, 8); + p = path.resolve(p); + + try { + fs.mkdirSync(p, mode); + made = made || p; + } + catch (err0) { + switch (err0.code) { + case 'ENOENT' : + made = sync(path.dirname(p), mode, made); + sync(p, mode, made); + break; + + case 'EEXIST' : + var stat; + try { + stat = fs.statSync(p); + } + catch (err1) { + throw err0; + } + if (!stat.isDirectory()) throw err0; + break; + default : + throw err0 + break; + } + } + + return made; +}; diff --git a/node_modules/stylus/node_modules/mkdirp/package.json b/node_modules/stylus/node_modules/mkdirp/package.json new file mode 100644 index 0000000..1cdbea9 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/package.json @@ -0,0 +1,40 @@ +{ + "name": "mkdirp", + "description": "Recursively mkdir, like `mkdir -p`", + "version": "0.3.1", + "author": { + "name": "James Halliday", + "email": "mail@substack.net", + "url": "http://substack.net" + }, + "main": "./index", + "keywords": [ + "mkdir", + "directory" + ], + "repository": { + "type": "git", + "url": "git://github.com/substack/node-mkdirp.git" + }, + "scripts": { + "test": "tap test/*.js" + }, + "devDependencies": { + "tap": "~0.2.4" + }, + "license": "MIT/X11", + "engines": { + "node": "*" + }, + "_id": "mkdirp@0.3.1", + "dependencies": {}, + "optionalDependencies": {}, + "_engineSupported": true, + "_npmVersion": "1.1.16", + "_nodeVersion": "v0.6.15", + "_defaultsLoaded": true, + "dist": { + "shasum": "01c39f7c9c3504f4a07bca0b3842d59d310da1a1" + }, + "_from": "mkdirp@0.3.x" +} diff --git a/node_modules/stylus/node_modules/mkdirp/test/chmod.js b/node_modules/stylus/node_modules/mkdirp/test/chmod.js new file mode 100644 index 0000000..520dcb8 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/chmod.js @@ -0,0 +1,38 @@ +var mkdirp = require('../').mkdirp; +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +var ps = [ '', 'tmp' ]; + +for (var i = 0; i < 25; i++) { + var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + ps.push(dir); +} + +var file = ps.join('/'); + +test('chmod-pre', function (t) { + var mode = 0744 + mkdirp(file, mode, function (er) { + t.ifError(er, 'should not error'); + fs.stat(file, function (er, stat) { + t.ifError(er, 'should exist'); + t.ok(stat && stat.isDirectory(), 'should be directory'); + t.equal(stat && stat.mode & 0777, mode, 'should be 0744'); + t.end(); + }); + }); +}); + +test('chmod', function (t) { + var mode = 0755 + mkdirp(file, mode, function (er) { + t.ifError(er, 'should not error'); + fs.stat(file, function (er, stat) { + t.ifError(er, 'should exist'); + t.ok(stat && stat.isDirectory(), 'should be directory'); + t.end(); + }); + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/clobber.js b/node_modules/stylus/node_modules/mkdirp/test/clobber.js new file mode 100644 index 0000000..0eb7099 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/clobber.js @@ -0,0 +1,37 @@ +var mkdirp = require('../').mkdirp; +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +var ps = [ '', 'tmp' ]; + +for (var i = 0; i < 25; i++) { + var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + ps.push(dir); +} + +var file = ps.join('/'); + +// a file in the way +var itw = ps.slice(0, 3).join('/'); + + +test('clobber-pre', function (t) { + console.error("about to write to "+itw) + fs.writeFileSync(itw, 'I AM IN THE WAY, THE TRUTH, AND THE LIGHT.'); + + fs.stat(itw, function (er, stat) { + t.ifError(er) + t.ok(stat && stat.isFile(), 'should be file') + t.end() + }) +}) + +test('clobber', function (t) { + t.plan(2); + mkdirp(file, 0755, function (err) { + t.ok(err); + t.equal(err.code, 'ENOTDIR'); + t.end(); + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/mkdirp.js b/node_modules/stylus/node_modules/mkdirp/test/mkdirp.js new file mode 100644 index 0000000..b07cd70 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/mkdirp.js @@ -0,0 +1,28 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('woo', function (t) { + t.plan(2); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var file = '/tmp/' + [x,y,z].join('/'); + + mkdirp(file, 0755, function (err) { + if (err) t.fail(err); + else path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, 0755); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }) + }) + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/perm.js b/node_modules/stylus/node_modules/mkdirp/test/perm.js new file mode 100644 index 0000000..23a7abb --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/perm.js @@ -0,0 +1,32 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('async perm', function (t) { + t.plan(2); + var file = '/tmp/' + (Math.random() * (1<<30)).toString(16); + + mkdirp(file, 0755, function (err) { + if (err) t.fail(err); + else path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, 0755); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }) + }) + }); +}); + +test('async root perm', function (t) { + mkdirp('/tmp', 0755, function (err) { + if (err) t.fail(err); + t.end(); + }); + t.end(); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/perm_sync.js b/node_modules/stylus/node_modules/mkdirp/test/perm_sync.js new file mode 100644 index 0000000..f685f60 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/perm_sync.js @@ -0,0 +1,39 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('sync perm', function (t) { + t.plan(2); + var file = '/tmp/' + (Math.random() * (1<<30)).toString(16) + '.json'; + + mkdirp.sync(file, 0755); + path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, 0755); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }) + }); +}); + +test('sync root perm', function (t) { + t.plan(1); + + var file = '/tmp'; + mkdirp.sync(file, 0755); + path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }) + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/race.js b/node_modules/stylus/node_modules/mkdirp/test/race.js new file mode 100644 index 0000000..96a0447 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/race.js @@ -0,0 +1,41 @@ +var mkdirp = require('../').mkdirp; +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('race', function (t) { + t.plan(4); + var ps = [ '', 'tmp' ]; + + for (var i = 0; i < 25; i++) { + var dir = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + ps.push(dir); + } + var file = ps.join('/'); + + var res = 2; + mk(file, function () { + if (--res === 0) t.end(); + }); + + mk(file, function () { + if (--res === 0) t.end(); + }); + + function mk (file, cb) { + mkdirp(file, 0755, function (err) { + if (err) t.fail(err); + else path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, 0755); + t.ok(stat.isDirectory(), 'target not a directory'); + if (cb) cb(); + } + }) + }) + }); + } +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/rel.js b/node_modules/stylus/node_modules/mkdirp/test/rel.js new file mode 100644 index 0000000..7985824 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/rel.js @@ -0,0 +1,32 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('rel', function (t) { + t.plan(2); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var cwd = process.cwd(); + process.chdir('/tmp'); + + var file = [x,y,z].join('/'); + + mkdirp(file, 0755, function (err) { + if (err) t.fail(err); + else path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + process.chdir(cwd); + t.equal(stat.mode & 0777, 0755); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }) + }) + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/return.js b/node_modules/stylus/node_modules/mkdirp/test/return.js new file mode 100644 index 0000000..bce68e5 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/return.js @@ -0,0 +1,25 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('return value', function (t) { + t.plan(4); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var file = '/tmp/' + [x,y,z].join('/'); + + // should return the first dir created. + // By this point, it would be profoundly surprising if /tmp didn't + // already exist, since every other test makes things in there. + mkdirp(file, function (err, made) { + t.ifError(err); + t.equal(made, '/tmp/' + x); + mkdirp(file, function (err, made) { + t.ifError(err); + t.equal(made, null); + }); + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/return_sync.js b/node_modules/stylus/node_modules/mkdirp/test/return_sync.js new file mode 100644 index 0000000..7c222d3 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/return_sync.js @@ -0,0 +1,24 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('return value', function (t) { + t.plan(2); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var file = '/tmp/' + [x,y,z].join('/'); + + // should return the first dir created. + // By this point, it would be profoundly surprising if /tmp didn't + // already exist, since every other test makes things in there. + // Note that this will throw on failure, which will fail the test. + var made = mkdirp.sync(file); + t.equal(made, '/tmp/' + x); + + // making the same file again should have no effect. + made = mkdirp.sync(file); + t.equal(made, null); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/sync.js b/node_modules/stylus/node_modules/mkdirp/test/sync.js new file mode 100644 index 0000000..7530cad --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/sync.js @@ -0,0 +1,32 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('sync', function (t) { + t.plan(2); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var file = '/tmp/' + [x,y,z].join('/'); + + try { + mkdirp.sync(file, 0755); + } catch (err) { + t.fail(err); + return t.end(); + } + + path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, 0755); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }); + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/umask.js b/node_modules/stylus/node_modules/mkdirp/test/umask.js new file mode 100644 index 0000000..64ccafe --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/umask.js @@ -0,0 +1,28 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('implicit mode from umask', function (t) { + t.plan(2); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var file = '/tmp/' + [x,y,z].join('/'); + + mkdirp(file, function (err) { + if (err) t.fail(err); + else path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, 0777 & (~process.umask())); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }) + }) + }); +}); diff --git a/node_modules/stylus/node_modules/mkdirp/test/umask_sync.js b/node_modules/stylus/node_modules/mkdirp/test/umask_sync.js new file mode 100644 index 0000000..4bd5376 --- /dev/null +++ b/node_modules/stylus/node_modules/mkdirp/test/umask_sync.js @@ -0,0 +1,32 @@ +var mkdirp = require('../'); +var path = require('path'); +var fs = require('fs'); +var test = require('tap').test; + +test('umask sync modes', function (t) { + t.plan(2); + var x = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var y = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + var z = Math.floor(Math.random() * Math.pow(16,4)).toString(16); + + var file = '/tmp/' + [x,y,z].join('/'); + + try { + mkdirp.sync(file, 0755); + } catch (err) { + t.fail(err); + return t.end(); + } + + path.exists(file, function (ex) { + if (!ex) t.fail('file not created') + else fs.stat(file, function (err, stat) { + if (err) t.fail(err) + else { + t.equal(stat.mode & 0777, (0777 & (~process.umask()))); + t.ok(stat.isDirectory(), 'target not a directory'); + t.end(); + } + }); + }); +}); diff --git a/node_modules/stylus/package.json b/node_modules/stylus/package.json new file mode 100644 index 0000000..94b0453 --- /dev/null +++ b/node_modules/stylus/package.json @@ -0,0 +1,51 @@ +{ + "name": "stylus", + "description": "Robust, expressive, and feature-rich CSS superset", + "version": "0.25.0", + "author": { + "name": "TJ Holowaychuk", + "email": "tj@vision-media.ca" + }, + "keywords": [ + "css", + "parser", + "style", + "stylesheets", + "jade", + "language" + ], + "repository": { + "type": "git", + "url": "git://github.com/learnboost/stylus.git" + }, + "main": "./index.js", + "engines": { + "node": "> 0.4.x < 0.7.0" + }, + "bin": { + "stylus": "./bin/stylus" + }, + "scripts": { + "prepublish": "npm prune", + "test": "make test" + }, + "dependencies": { + "cssom": "0.2.x", + "mkdirp": "0.3.x", + "debug": "*" + }, + "devDependencies": { + "should": "*", + "mocha": "*" + }, + "_id": "stylus@0.25.0", + "optionalDependencies": {}, + "_engineSupported": true, + "_npmVersion": "1.1.16", + "_nodeVersion": "v0.6.15", + "_defaultsLoaded": true, + "dist": { + "shasum": "9b8446fdfc3a9d67c8715af2aa9c010a1ad21101" + }, + "_from": "stylus" +} diff --git a/node_modules/stylus/testing/index.js b/node_modules/stylus/testing/index.js new file mode 100644 index 0000000..77cdc4e --- /dev/null +++ b/node_modules/stylus/testing/index.js @@ -0,0 +1,21 @@ + +/** + * Module dependencies. + */ + +var stylus = require('../') + , fs = require('fs') + , path = 'testing/small.styl' + , str = fs.readFileSync(path, 'utf8'); + +var start = new Date; + +str = str.replace(/\s*,\s*/g, ', '); + +stylus(str) + .set('filename', path) + .render(function(err, css){ + if (err) throw err; + console.log(css); + // console.log('%dms', new Date - start); + }); \ No newline at end of file diff --git a/node_modules/stylus/testing/small.styl b/node_modules/stylus/testing/small.styl new file mode 100644 index 0000000..e3a1b93 --- /dev/null +++ b/node_modules/stylus/testing/small.styl @@ -0,0 +1,55 @@ + +transition() + for arg in arguments + + foo: arguments + +#logo + transition: transform 300ms, opacity + +// #main +// margin: 0 auto +// @media (min-width: 480px) +// & +// padding: 0 .5em + +// print() +// error('block required') unless block +// @media print { +// & { +// block +// } +// } +// +// body +// foo: bar +// print() +// background: white +// #header +// display: none + +// mixin() +// if block +// .nested +// block +// else +// no: "block was given" +// +// body +// one: 1 +// mixin() +// two: 2 +// three: 3 +// mixin() +// + +// li(n) +// ul li:nth-child({n}) +// block +// +// li(1) +// display: none +// +// ^-- broken + + diff --git a/node_modules/stylus/testing/test.styl b/node_modules/stylus/testing/test.styl new file mode 100644 index 0000000..26f8dc2 --- /dev/null +++ b/node_modules/stylus/testing/test.styl @@ -0,0 +1,19127 @@ + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar'body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + +body + foo: 'bar' +body + foo: 'bar' + + +// mixin(foo, bar) +// foo: foo +// bar: bar +// len: length(arguments) +// +// body +// mixin: one two !important +// +// mixin(args...) +// foo: args +// len: length(arguments) +// +// body +// mixin: foo bar !important +// +// mixin() +// foo: arguments +// len: length(arguments) +// +// body +// mixin: foo bar !important + +// +// foo-bar-baz = 'hey' +// +// body +// type = bar +// foo: foo-{type}-baz +// +// foo +// bar baz + +// foo-bar-baz = 'hey' +// +// body +// foo: foo{'-' + bar + '-' + baz} + +// border-radius(n) +// -webkit-border-radius: n +// -moz-border-radius: n +// border-radius: n +// +// body +// type = radius +// border-{type}(5px) + +// foo-bar-baz() +// foo: 'bar' +// +// body +// foo-{bar}{-baz}() + +// foo-bar-baz() +// 10px 20px +// +// body +// foo: foo-{bar}-baz() \ No newline at end of file