cssesc-source 0.1.0

data/vendor/node_modules/grunt/internal-tasks/subgrunt.js

@@ -0,0 +1,34 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+module.exports = function(grunt) {
+
+  // Run sub-grunt files, because right now, testing tasks is a pain.
+  grunt.registerMultiTask('subgrunt', 'Run a sub-gruntfile.', function() {
+    var path = require('path');
+    grunt.util.async.forEachSeries(this.filesSrc, function(gruntfile, next) {
+      grunt.log.write('Loading ' + gruntfile + '...');
+      grunt.util.spawn({
+        grunt: true,
+        args: ['--gruntfile', path.resolve(gruntfile)],
+      }, function(error, result) {
+        if (error) {
+          grunt.log.error().error(result.stdout).writeln();
+          next(new Error('Error running sub-gruntfile "' + gruntfile + '".'));
+        } else {
+          grunt.log.ok().verbose.ok(result.stdout);
+          next();
+        }
+      });
+    }, this.async());
+  });
+
+};

data/vendor/node_modules/grunt/lib/grunt.js

@@ -0,0 +1,156 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+// Nodejs libs.
+var path = require('path');
+
+// This allows grunt to require() .coffee files.
+require('coffee-script');
+
+// The module to be exported.
+var grunt = module.exports = {};
+
+// Expose internal grunt libs.
+function gRequire(name) {
+  return grunt[name] = require('./grunt/' + name);
+}
+var util = gRequire('util');
+gRequire('template');
+gRequire('event');
+var fail = gRequire('fail');
+gRequire('file');
+var option = gRequire('option');
+var config = gRequire('config');
+var task = gRequire('task');
+var log = gRequire('log');
+var help = gRequire('help');
+gRequire('cli');
+var verbose = grunt.verbose = log.verbose;
+
+// Expose some grunt metadata.
+grunt.package = require('../package.json');
+grunt.version = grunt.package.version;
+
+// Expose specific grunt lib methods on grunt.
+function gExpose(obj, methodName, newMethodName) {
+  grunt[newMethodName || methodName] = obj[methodName].bind(obj);
+}
+gExpose(task, 'registerTask');
+gExpose(task, 'registerMultiTask');
+gExpose(task, 'registerInitTask');
+gExpose(task, 'renameTask');
+gExpose(task, 'loadTasks');
+gExpose(task, 'loadNpmTasks');
+gExpose(config, 'init', 'initConfig');
+gExpose(fail, 'warn');
+gExpose(fail, 'fatal');
+
+// Expose the task interface. I've never called this manually, and have no idea
+// how it will work. But it might.
+grunt.tasks = function(tasks, options, done) {
+  // Update options with passed-in options.
+  option.init(options);
+
+  // Display the grunt version and quit if the user did --version.
+  var _tasks, _options;
+  if (option('version')) {
+    // Not --verbose.
+    log.writeln('grunt v' + grunt.version);
+
+    if (option('verbose')) {
+      // --verbose
+      verbose.writeln('Install path: ' + path.resolve(__dirname, '..'));
+      // Yes, this is a total hack, but we don't want to log all that verbose
+      // task initialization stuff here.
+      grunt.log.muted = true;
+      // Initialize task system so that available tasks can be listed.
+      grunt.task.init([], {help: true});
+      // Re-enable logging.
+      grunt.log.muted = false;
+
+      // Display available tasks (for shell completion, etc).
+      _tasks = Object.keys(grunt.task._tasks).sort();
+      verbose.writeln('Available tasks: ' + _tasks.join(' '));
+
+      // Display available options (for shell completion, etc).
+      _options = [];
+      Object.keys(grunt.cli.optlist).forEach(function(long) {
+        var o = grunt.cli.optlist[long];
+        _options.push('--' + (o.negate ? 'no-' : '') + long);
+        if (o.short) { _options.push('-' + o.short); }
+      });
+      verbose.writeln('Available options: ' + _options.join(' '));
+    }
+
+    return;
+  }
+
+  // Init colors.
+  log.initColors();
+
+  // Display help and quit if the user did --help.
+  if (option('help')) {
+    help.display();
+    return;
+  }
+
+  // A little header stuff.
+  verbose.header('Initializing').writeflags(option.flags(), 'Command-line options');
+
+  // Determine and output which tasks will be run.
+  var tasksSpecified = tasks && tasks.length > 0;
+  tasks = task.parseArgs([tasksSpecified ? tasks : 'default']);
+
+  // Initialize tasks.
+  task.init(tasks);
+
+  verbose.writeln();
+  if (!tasksSpecified) {
+    verbose.writeln('No tasks specified, running default tasks.');
+  }
+  verbose.writeflags(tasks, 'Running tasks');
+
+  // Handle otherwise unhandleable (probably asynchronous) exceptions.
+  var uncaughtHandler = function(e) {
+    fail.fatal(e, fail.code.TASK_FAILURE);
+  };
+  process.on('uncaughtException', uncaughtHandler);
+
+  // Report, etc when all tasks have completed.
+  task.options({
+    error: function(e) {
+      fail.warn(e, fail.code.TASK_FAILURE);
+    },
+    done: function() {
+      // Stop handling uncaught exceptions so that we don't leave any
+      // unwanted process-level side effects behind. There is no need to do
+      // this in the error callback, because fail.warn() will either kill
+      // the process, or with --force keep on going all the way here.
+      process.removeListener('uncaughtException', uncaughtHandler);
+
+      // Output a final fail / success report.
+      fail.report();
+
+      if (done) {
+        // Execute "done" function when done (only if passed, of course).
+        done();
+      } else {
+        // Otherwise, explicitly exit.
+        util.exit(0);
+      }
+    }
+  });
+
+  // Execute all tasks, in order. Passing each task individually in a forEach
+  // allows the error callback to execute multiple times.
+  tasks.forEach(function(name) { task.run(name); });
+  task.start();
+};

data/vendor/node_modules/grunt/lib/grunt/cli.js

@@ -0,0 +1,128 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+var grunt = require('../grunt');
+
+// Nodejs libs.
+var path = require('path');
+
+// External libs.
+var nopt = require('nopt');
+
+// This is only executed when run via command line.
+var cli = module.exports = function(options, done) {
+  // CLI-parsed options override any passed-in "default" options.
+  if (options) {
+    // For each defult option...
+    Object.keys(options).forEach(function(key) {
+      if (!(key in cli.options)) {
+        // If this option doesn't exist in the parsed cli.options, add it in.
+        cli.options[key] = options[key];
+      } else if (cli.optlist[key].type === Array) {
+        // If this option's type is Array, append it to any existing array
+        // (or create a new array).
+        [].push.apply(cli.options[key], options[key]);
+      }
+    });
+  }
+
+  // Run tasks.
+  grunt.tasks(cli.tasks, cli.options, done);
+};
+
+// Default options.
+var optlist = cli.optlist = {
+  help: {
+    short: 'h',
+    info: 'Display this help text.',
+    type: Boolean
+  },
+  base: {
+    info: 'Specify an alternate base path. By default, all file paths are relative to the Gruntfile. (grunt.file.setBase) *',
+    type: path
+  },
+  color: {
+    info: 'Disable colored output.',
+    type: Boolean,
+    negate: true
+  },
+  gruntfile: {
+    info: 'Specify an alternate Gruntfile. By default, grunt looks in the current or parent directories for the nearest Gruntfile.js or Gruntfile.coffee file.',
+    type: path
+  },
+  debug: {
+    short: 'd',
+    info: 'Enable debugging mode for tasks that support it.',
+    type: Number
+  },
+  stack: {
+    info: 'Print a stack trace when exiting with a warning or fatal error.',
+    type: Boolean
+  },
+  force: {
+    short: 'f',
+    info: 'A way to force your way past warnings. Want a suggestion? Don\'t use this option, fix your code.',
+    type: Boolean
+  },
+  tasks: {
+    info: 'Additional directory paths to scan for task and "extra" files. (grunt.loadTasks) *',
+    type: Array
+  },
+  npm: {
+    info: 'Npm-installed grunt plugins to scan for task and "extra" files. (grunt.loadNpmTasks) *',
+    type: Array
+  },
+  write: {
+    info: 'Disable writing files (dry run).',
+    type: Boolean,
+    negate: true
+  },
+  verbose: {
+    short: 'v',
+    info: 'Verbose mode. A lot more information output.',
+    type: Boolean
+  },
+  version: {
+    short: 'V',
+    info: 'Print the grunt version. Combine with --verbose for more info.',
+    type: Boolean
+  },
+  // Even though shell auto-completion is now handled by grunt-cli, leave this
+  // option here for display in the --help screen.
+  completion: {
+    info: 'Output shell auto-completion rules. See the grunt-cli documentation for more information.',
+    type: String
+  },
+};
+
+// Parse `optlist` into a form that nopt can handle.
+var aliases = {};
+var known = {};
+
+Object.keys(optlist).forEach(function(key) {
+  var short = optlist[key].short;
+  if (short) {
+    aliases[short] = '--' + key;
+  }
+  known[key] = optlist[key].type;
+});
+
+var parsed = nopt(known, aliases, process.argv, 2);
+cli.tasks = parsed.argv.remain;
+cli.options = parsed;
+delete parsed.argv;
+
+// Initialize any Array options that weren't initialized.
+Object.keys(optlist).forEach(function(key) {
+  if (optlist[key].type === Array && !(key in cli.options)) {
+    cli.options[key] = [];
+  }
+});

data/vendor/node_modules/grunt/lib/grunt/config.js

@@ -0,0 +1,118 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+var grunt = require('../grunt');
+
+// Get/set config data. If value was passed, set. Otherwise, get.
+var config = module.exports = function(prop, value) {
+  if (arguments.length === 2) {
+    // Two arguments were passed, set the property's value.
+    return config.set(prop, value);
+  } else {
+    // Get the property's value (or the entire data object).
+    return config.get(prop);
+  }
+};
+
+// The actual config data.
+config.data = {};
+
+// Escape any . in name with \. so dot-based namespacing works properly.
+config.escape = function(str) {
+  return str.replace(/\./g, '\\.');
+};
+
+// Return prop as a string.
+config.getPropString = function(prop) {
+  return Array.isArray(prop) ? prop.map(config.escape).join('.') : prop;
+};
+
+// Get raw, unprocessed config data.
+config.getRaw = function(prop) {
+  if (prop) {
+    // Prop was passed, get that specific property's value.
+    return grunt.util.namespace.get(config.data, config.getPropString(prop));
+  } else {
+    // No prop was passed, return the entire config.data object.
+    return config.data;
+  }
+};
+
+// Match '<%= FOO %>' where FOO is a propString, eg. foo or foo.bar but not
+// a method call like foo() or foo.bar().
+var propStringTmplRe = /^<%=\s*([a-z0-9_$]+(?:\.[a-z0-9_$]+)*)\s*%>$/i;
+
+// Get config data, recursively processing templates.
+config.get = function(prop) {
+  return config.process(config.getRaw(prop));
+};
+
+// Expand a config value recursively. Used for post-processing raw values
+// already retrieved from the config.
+config.process = function(raw) {
+  return grunt.util.recurse(raw, function(value) {
+    // If the value is not a string, return it.
+    if (typeof value !== 'string') { return value; }
+    // If possible, access the specified property via config.get, in case it
+    // doesn't refer to a string, but instead refers to an object or array.
+    var matches = value.match(propStringTmplRe);
+    var result;
+    if (matches) {
+      result = config.get(matches[1]);
+      // If the result retrieved from the config data wasn't null or undefined,
+      // return it.
+      if (result != null) { return result; }
+    }
+    // Process the string as a template.
+    return grunt.template.process(value, {data: config.data});
+  });
+};
+
+// Set config data.
+config.set = function(prop, value) {
+  return grunt.util.namespace.set(config.data, config.getPropString(prop), value);
+};
+
+// Initialize config data.
+config.init = function(obj) {
+  grunt.verbose.write('Initializing config...').ok();
+  // Initialize and return data.
+  return (config.data = obj || {});
+};
+
+// Test to see if required config params have been defined. If not, throw an
+// exception (use this inside of a task).
+config.requires = function() {
+  var p = grunt.util.pluralize;
+  var props = grunt.util.toArray(arguments).map(config.getPropString);
+  var msg = 'Verifying propert' + p(props.length, 'y/ies') +
+    ' ' + grunt.log.wordlist(props) + ' exist' + p(props.length, 's') +
+    ' in config...';
+  grunt.verbose.write(msg);
+  var failProps = config.data && props.filter(function(prop) {
+    return config.get(prop) == null;
+  }).map(function(prop) {
+    return '"' + prop + '"';
+  });
+  if (config.data && failProps.length === 0) {
+    grunt.verbose.ok();
+    return true;
+  } else {
+    grunt.verbose.or.write(msg);
+    grunt.log.error().error('Unable to process task.');
+    if (!config.data) {
+      throw grunt.util.error('Unable to load config.');
+    } else {
+      throw grunt.util.error('Required config propert' +
+        p(failProps.length, 'y/ies') + ' ' + failProps.join(', ') + ' missing.');
+    }
+  }
+};

data/vendor/node_modules/grunt/lib/grunt/event.js

@@ -0,0 +1,16 @@
+/*
+ * grunt
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman
+ * Licensed under the MIT license.
+ * https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+ */
+
+'use strict';
+
+// External lib.
+var EventEmitter2 = require('eventemitter2').EventEmitter2;
+
+// Awesome.
+module.exports = new EventEmitter2({wildcard: true});