cssesc-source 0.1.0

data/vendor/node_modules/grunt/node_modules/coffee-script/lib/coffee-script/repl.js

@@ -0,0 +1,261 @@
+// Generated by CoffeeScript 1.3.3
+(function() {
+  var ACCESSOR, CoffeeScript, Module, REPL_PROMPT, REPL_PROMPT_CONTINUATION, REPL_PROMPT_MULTILINE, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, getCompletions, inspect, multilineMode, pipedInput, readline, repl, run, stdin, stdout;
+
+  stdin = process.openStdin();
+
+  stdout = process.stdout;
+
+  CoffeeScript = require('./coffee-script');
+
+  readline = require('readline');
+
+  inspect = require('util').inspect;
+
+  Script = require('vm').Script;
+
+  Module = require('module');
+
+  REPL_PROMPT = 'coffee> ';
+
+  REPL_PROMPT_MULTILINE = '------> ';
+
+  REPL_PROMPT_CONTINUATION = '......> ';
+
+  enableColours = false;
+
+  if (process.platform !== 'win32') {
+    enableColours = !process.env.NODE_DISABLE_COLORS;
+  }
+
+  error = function(err) {
+    return stdout.write((err.stack || err.toString()) + '\n');
+  };
+
+  ACCESSOR = /\s*([\w\.]+)(?:\.(\w*))$/;
+
+  SIMPLEVAR = /(\w+)$/i;
+
+  autocomplete = function(text) {
+    return completeAttribute(text) || completeVariable(text) || [[], text];
+  };
+
+  completeAttribute = function(text) {
+    var all, completions, key, match, obj, possibilities, prefix, val;
+    if (match = text.match(ACCESSOR)) {
+      all = match[0], obj = match[1], prefix = match[2];
+      try {
+        val = Script.runInThisContext(obj);
+      } catch (error) {
+        return;
+      }
+      val = Object(val);
+      possibilities = Object.getOwnPropertyNames(val);
+      for (key in val) {
+        if (~possibilities.indexOf(val)) {
+          possibilities.push(key);
+        }
+      }
+      completions = getCompletions(prefix, possibilities);
+      return [completions, prefix];
+    }
+  };
+
+  completeVariable = function(text) {
+    var completions, free, keywords, possibilities, r, vars, _ref;
+    free = (_ref = text.match(SIMPLEVAR)) != null ? _ref[1] : void 0;
+    if (text === "") {
+      free = "";
+    }
+    if (free != null) {
+      vars = Script.runInThisContext('Object.getOwnPropertyNames(Object(this))');
+      keywords = (function() {
+        var _i, _len, _ref1, _results;
+        _ref1 = CoffeeScript.RESERVED;
+        _results = [];
+        for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+          r = _ref1[_i];
+          if (r.slice(0, 2) !== '__') {
+            _results.push(r);
+          }
+        }
+        return _results;
+      })();
+      possibilities = vars.concat(keywords);
+      completions = getCompletions(free, possibilities);
+      return [completions, free];
+    }
+  };
+
+  getCompletions = function(prefix, candidates) {
+    var el, _i, _len, _results;
+    _results = [];
+    for (_i = 0, _len = candidates.length; _i < _len; _i++) {
+      el = candidates[_i];
+      if (el.indexOf(prefix) === 0) {
+        _results.push(el);
+      }
+    }
+    return _results;
+  };
+
+  process.on('uncaughtException', error);
+
+  backlog = '';
+
+  run = function(buffer) {
+    var code, returnValue, _;
+    buffer = buffer.replace(/(^|[\r\n]+)(\s*)##?(?:[^#\r\n][^\r\n]*|)($|[\r\n])/, "$1$2$3");
+    buffer = buffer.replace(/[\r\n]+$/, "");
+    if (multilineMode) {
+      backlog += "" + buffer + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
+    if (!buffer.toString().trim() && !backlog) {
+      repl.prompt();
+      return;
+    }
+    code = backlog += buffer;
+    if (code[code.length - 1] === '\\') {
+      backlog = "" + backlog.slice(0, -1) + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
+    repl.setPrompt(REPL_PROMPT);
+    backlog = '';
+    try {
+      _ = global._;
+      returnValue = CoffeeScript["eval"]("_=(" + code + "\n)", {
+        filename: 'repl',
+        modulename: 'repl'
+      });
+      if (returnValue === void 0) {
+        global._ = _;
+      }
+      repl.output.write("" + (inspect(returnValue, false, 2, enableColours)) + "\n");
+    } catch (err) {
+      error(err);
+    }
+    return repl.prompt();
+  };
+
+  if (stdin.readable) {
+    pipedInput = '';
+    repl = {
+      prompt: function() {
+        return stdout.write(this._prompt);
+      },
+      setPrompt: function(p) {
+        return this._prompt = p;
+      },
+      input: stdin,
+      output: stdout,
+      on: function() {}
+    };
+    stdin.on('data', function(chunk) {
+      var line, lines, _i, _len, _ref;
+      pipedInput += chunk;
+      if (!/\n/.test(pipedInput)) {
+        return;
+      }
+      lines = pipedInput.split("\n");
+      pipedInput = lines[lines.length - 1];
+      _ref = lines.slice(0, -1);
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        if (!(line)) {
+          continue;
+        }
+        stdout.write("" + line + "\n");
+        run(line);
+      }
+    });
+    stdin.on('end', function() {
+      var line, _i, _len, _ref;
+      _ref = pipedInput.trim().split("\n");
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        line = _ref[_i];
+        if (!(line)) {
+          continue;
+        }
+        stdout.write("" + line + "\n");
+        run(line);
+      }
+      stdout.write('\n');
+      return process.exit(0);
+    });
+  } else {
+    if (readline.createInterface.length < 3) {
+      repl = readline.createInterface(stdin, autocomplete);
+      stdin.on('data', function(buffer) {
+        return repl.write(buffer);
+      });
+    } else {
+      repl = readline.createInterface(stdin, stdout, autocomplete);
+    }
+  }
+
+  multilineMode = false;
+
+  repl.input.on('keypress', function(char, key) {
+    var cursorPos, newPrompt;
+    if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'v')) {
+      return;
+    }
+    cursorPos = repl.cursor;
+    repl.output.cursorTo(0);
+    repl.output.clearLine(1);
+    multilineMode = !multilineMode;
+    if (!multilineMode && backlog) {
+      repl._line();
+    }
+    backlog = '';
+    repl.setPrompt((newPrompt = multilineMode ? REPL_PROMPT_MULTILINE : REPL_PROMPT));
+    repl.prompt();
+    return repl.output.cursorTo(newPrompt.length + (repl.cursor = cursorPos));
+  });
+
+  repl.input.on('keypress', function(char, key) {
+    if (!(multilineMode && repl.line)) {
+      return;
+    }
+    if (!(key && key.ctrl && !key.meta && !key.shift && key.name === 'd')) {
+      return;
+    }
+    multilineMode = false;
+    return repl._line();
+  });
+
+  repl.on('attemptClose', function() {
+    if (multilineMode) {
+      multilineMode = false;
+      repl.output.cursorTo(0);
+      repl.output.clearLine(1);
+      repl._onLine(repl.line);
+      return;
+    }
+    if (backlog) {
+      backlog = '';
+      repl.output.write('\n');
+      repl.setPrompt(REPL_PROMPT);
+      return repl.prompt();
+    } else {
+      return repl.close();
+    }
+  });
+
+  repl.on('close', function() {
+    repl.output.write('\n');
+    return repl.input.destroy();
+  });
+
+  repl.on('line', run);
+
+  repl.setPrompt(REPL_PROMPT);
+
+  repl.prompt();
+
+}).call(this);

data/vendor/node_modules/grunt/node_modules/coffee-script/lib/coffee-script/rewriter.js

@@ -0,0 +1,349 @@
+// Generated by CoffeeScript 1.3.3
+(function() {
+  var BALANCED_PAIRS, EXPRESSION_CLOSE, EXPRESSION_END, EXPRESSION_START, IMPLICIT_BLOCK, IMPLICIT_CALL, IMPLICIT_END, IMPLICIT_FUNC, IMPLICIT_UNSPACED_CALL, INVERSES, LINEBREAKS, SINGLE_CLOSERS, SINGLE_LINERS, left, rite, _i, _len, _ref,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
+    __slice = [].slice;
+
+  exports.Rewriter = (function() {
+
+    function Rewriter() {}
+
+    Rewriter.prototype.rewrite = function(tokens) {
+      this.tokens = tokens;
+      this.removeLeadingNewlines();
+      this.removeMidExpressionNewlines();
+      this.closeOpenCalls();
+      this.closeOpenIndexes();
+      this.addImplicitIndentation();
+      this.tagPostfixConditionals();
+      this.addImplicitBraces();
+      this.addImplicitParentheses();
+      return this.tokens;
+    };
+
+    Rewriter.prototype.scanTokens = function(block) {
+      var i, token, tokens;
+      tokens = this.tokens;
+      i = 0;
+      while (token = tokens[i]) {
+        i += block.call(this, token, i, tokens);
+      }
+      return true;
+    };
+
+    Rewriter.prototype.detectEnd = function(i, condition, action) {
+      var levels, token, tokens, _ref, _ref1;
+      tokens = this.tokens;
+      levels = 0;
+      while (token = tokens[i]) {
+        if (levels === 0 && condition.call(this, token, i)) {
+          return action.call(this, token, i);
+        }
+        if (!token || levels < 0) {
+          return action.call(this, token, i - 1);
+        }
+        if (_ref = token[0], __indexOf.call(EXPRESSION_START, _ref) >= 0) {
+          levels += 1;
+        } else if (_ref1 = token[0], __indexOf.call(EXPRESSION_END, _ref1) >= 0) {
+          levels -= 1;
+        }
+        i += 1;
+      }
+      return i - 1;
+    };
+
+    Rewriter.prototype.removeLeadingNewlines = function() {
+      var i, tag, _i, _len, _ref;
+      _ref = this.tokens;
+      for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
+        tag = _ref[i][0];
+        if (tag !== 'TERMINATOR') {
+          break;
+        }
+      }
+      if (i) {
+        return this.tokens.splice(0, i);
+      }
+    };
+
+    Rewriter.prototype.removeMidExpressionNewlines = function() {
+      return this.scanTokens(function(token, i, tokens) {
+        var _ref;
+        if (!(token[0] === 'TERMINATOR' && (_ref = this.tag(i + 1), __indexOf.call(EXPRESSION_CLOSE, _ref) >= 0))) {
+          return 1;
+        }
+        tokens.splice(i, 1);
+        return 0;
+      });
+    };
+
+    Rewriter.prototype.closeOpenCalls = function() {
+      var action, condition;
+      condition = function(token, i) {
+        var _ref;
+        return ((_ref = token[0]) === ')' || _ref === 'CALL_END') || token[0] === 'OUTDENT' && this.tag(i - 1) === ')';
+      };
+      action = function(token, i) {
+        return this.tokens[token[0] === 'OUTDENT' ? i - 1 : i][0] = 'CALL_END';
+      };
+      return this.scanTokens(function(token, i) {
+        if (token[0] === 'CALL_START') {
+          this.detectEnd(i + 1, condition, action);
+        }
+        return 1;
+      });
+    };
+
+    Rewriter.prototype.closeOpenIndexes = function() {
+      var action, condition;
+      condition = function(token, i) {
+        var _ref;
+        return (_ref = token[0]) === ']' || _ref === 'INDEX_END';
+      };
+      action = function(token, i) {
+        return token[0] = 'INDEX_END';
+      };
+      return this.scanTokens(function(token, i) {
+        if (token[0] === 'INDEX_START') {
+          this.detectEnd(i + 1, condition, action);
+        }
+        return 1;
+      });
+    };
+
+    Rewriter.prototype.addImplicitBraces = function() {
+      var action, condition, sameLine, stack, start, startIndent, startIndex, startsLine;
+      stack = [];
+      start = null;
+      startsLine = null;
+      sameLine = true;
+      startIndent = 0;
+      startIndex = 0;
+      condition = function(token, i) {
+        var one, tag, three, two, _ref, _ref1;
+        _ref = this.tokens.slice(i + 1, (i + 3) + 1 || 9e9), one = _ref[0], two = _ref[1], three = _ref[2];
+        if ('HERECOMMENT' === (one != null ? one[0] : void 0)) {
+          return false;
+        }
+        tag = token[0];
+        if (__indexOf.call(LINEBREAKS, tag) >= 0) {
+          sameLine = false;
+        }
+        return (((tag === 'TERMINATOR' || tag === 'OUTDENT') || (__indexOf.call(IMPLICIT_END, tag) >= 0 && sameLine && !(i - startIndex === 1))) && ((!startsLine && this.tag(i - 1) !== ',') || !((two != null ? two[0] : void 0) === ':' || (one != null ? one[0] : void 0) === '@' && (three != null ? three[0] : void 0) === ':'))) || (tag === ',' && one && ((_ref1 = one[0]) !== 'IDENTIFIER' && _ref1 !== 'NUMBER' && _ref1 !== 'STRING' && _ref1 !== '@' && _ref1 !== 'TERMINATOR' && _ref1 !== 'OUTDENT'));
+      };
+      action = function(token, i) {
+        var tok;
+        tok = this.generate('}', '}', token[2]);
+        return this.tokens.splice(i, 0, tok);
+      };
+      return this.scanTokens(function(token, i, tokens) {
+        var ago, idx, prevTag, tag, tok, value, _ref, _ref1;
+        if (_ref = (tag = token[0]), __indexOf.call(EXPRESSION_START, _ref) >= 0) {
+          stack.push([(tag === 'INDENT' && this.tag(i - 1) === '{' ? '{' : tag), i]);
+          return 1;
+        }
+        if (__indexOf.call(EXPRESSION_END, tag) >= 0) {
+          start = stack.pop();
+          return 1;
+        }
+        if (!(tag === ':' && ((ago = this.tag(i - 2)) === ':' || ((_ref1 = stack[stack.length - 1]) != null ? _ref1[0] : void 0) !== '{'))) {
+          return 1;
+        }
+        sameLine = true;
+        startIndex = i + 1;
+        stack.push(['{']);
+        idx = ago === '@' ? i - 2 : i - 1;
+        while (this.tag(idx - 2) === 'HERECOMMENT') {
+          idx -= 2;
+        }
+        prevTag = this.tag(idx - 1);
+        startsLine = !prevTag || (__indexOf.call(LINEBREAKS, prevTag) >= 0);
+        value = new String('{');
+        value.generated = true;
+        tok = this.generate('{', value, token[2]);
+        tokens.splice(idx, 0, tok);
+        this.detectEnd(i + 2, condition, action);
+        return 2;
+      });
+    };
+
+    Rewriter.prototype.addImplicitParentheses = function() {
+      var action, condition, noCall, seenControl, seenSingle;
+      noCall = seenSingle = seenControl = false;
+      condition = function(token, i) {
+        var post, tag, _ref, _ref1;
+        tag = token[0];
+        if (!seenSingle && token.fromThen) {
+          return true;
+        }
+        if (tag === 'IF' || tag === 'ELSE' || tag === 'CATCH' || tag === '->' || tag === '=>' || tag === 'CLASS') {
+          seenSingle = true;
+        }
+        if (tag === 'IF' || tag === 'ELSE' || tag === 'SWITCH' || tag === 'TRY' || tag === '=') {
+          seenControl = true;
+        }
+        if ((tag === '.' || tag === '?.' || tag === '::') && this.tag(i - 1) === 'OUTDENT') {
+          return true;
+        }
+        return !token.generated && this.tag(i - 1) !== ',' && (__indexOf.call(IMPLICIT_END, tag) >= 0 || (tag === 'INDENT' && !seenControl)) && (tag !== 'INDENT' || (((_ref = this.tag(i - 2)) !== 'CLASS' && _ref !== 'EXTENDS') && (_ref1 = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref1) < 0) && !((post = this.tokens[i + 1]) && post.generated && post[0] === '{')));
+      };
+      action = function(token, i) {
+        return this.tokens.splice(i, 0, this.generate('CALL_END', ')', token[2]));
+      };
+      return this.scanTokens(function(token, i, tokens) {
+        var callObject, current, next, prev, tag, _ref, _ref1, _ref2;
+        tag = token[0];
+        if (tag === 'CLASS' || tag === 'IF' || tag === 'FOR' || tag === 'WHILE') {
+          noCall = true;
+        }
+        _ref = tokens.slice(i - 1, (i + 1) + 1 || 9e9), prev = _ref[0], current = _ref[1], next = _ref[2];
+        callObject = !noCall && tag === 'INDENT' && next && next.generated && next[0] === '{' && prev && (_ref1 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref1) >= 0);
+        seenSingle = false;
+        seenControl = false;
+        if (__indexOf.call(LINEBREAKS, tag) >= 0) {
+          noCall = false;
+        }
+        if (prev && !prev.spaced && tag === '?') {
+          token.call = true;
+        }
+        if (token.fromThen) {
+          return 1;
+        }
+        if (!(callObject || (prev != null ? prev.spaced : void 0) && (prev.call || (_ref2 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref2) >= 0)) && (__indexOf.call(IMPLICIT_CALL, tag) >= 0 || !(token.spaced || token.newLine) && __indexOf.call(IMPLICIT_UNSPACED_CALL, tag) >= 0))) {
+          return 1;
+        }
+        tokens.splice(i, 0, this.generate('CALL_START', '(', token[2]));
+        this.detectEnd(i + 1, condition, action);
+        if (prev[0] === '?') {
+          prev[0] = 'FUNC_EXIST';
+        }
+        return 2;
+      });
+    };
+
+    Rewriter.prototype.addImplicitIndentation = function() {
+      var action, condition, indent, outdent, starter;
+      starter = indent = outdent = null;
+      condition = function(token, i) {
+        var _ref;
+        return token[1] !== ';' && (_ref = token[0], __indexOf.call(SINGLE_CLOSERS, _ref) >= 0) && !(token[0] === 'ELSE' && (starter !== 'IF' && starter !== 'THEN'));
+      };
+      action = function(token, i) {
+        return this.tokens.splice((this.tag(i - 1) === ',' ? i - 1 : i), 0, outdent);
+      };
+      return this.scanTokens(function(token, i, tokens) {
+        var tag, _ref, _ref1;
+        tag = token[0];
+        if (tag === 'TERMINATOR' && this.tag(i + 1) === 'THEN') {
+          tokens.splice(i, 1);
+          return 0;
+        }
+        if (tag === 'ELSE' && this.tag(i - 1) !== 'OUTDENT') {
+          tokens.splice.apply(tokens, [i, 0].concat(__slice.call(this.indentation(token))));
+          return 2;
+        }
+        if (tag === 'CATCH' && ((_ref = this.tag(i + 2)) === 'OUTDENT' || _ref === 'TERMINATOR' || _ref === 'FINALLY')) {
+          tokens.splice.apply(tokens, [i + 2, 0].concat(__slice.call(this.indentation(token))));
+          return 4;
+        }
+        if (__indexOf.call(SINGLE_LINERS, tag) >= 0 && this.tag(i + 1) !== 'INDENT' && !(tag === 'ELSE' && this.tag(i + 1) === 'IF')) {
+          starter = tag;
+          _ref1 = this.indentation(token, true), indent = _ref1[0], outdent = _ref1[1];
+          if (starter === 'THEN') {
+            indent.fromThen = true;
+          }
+          tokens.splice(i + 1, 0, indent);
+          this.detectEnd(i + 2, condition, action);
+          if (tag === 'THEN') {
+            tokens.splice(i, 1);
+          }
+          return 1;
+        }
+        return 1;
+      });
+    };
+
+    Rewriter.prototype.tagPostfixConditionals = function() {
+      var action, condition, original;
+      original = null;
+      condition = function(token, i) {
+        var _ref;
+        return (_ref = token[0]) === 'TERMINATOR' || _ref === 'INDENT';
+      };
+      action = function(token, i) {
+        if (token[0] !== 'INDENT' || (token.generated && !token.fromThen)) {
+          return original[0] = 'POST_' + original[0];
+        }
+      };
+      return this.scanTokens(function(token, i) {
+        if (token[0] !== 'IF') {
+          return 1;
+        }
+        original = token;
+        this.detectEnd(i + 1, condition, action);
+        return 1;
+      });
+    };
+
+    Rewriter.prototype.indentation = function(token, implicit) {
+      var indent, outdent;
+      if (implicit == null) {
+        implicit = false;
+      }
+      indent = ['INDENT', 2, token[2]];
+      outdent = ['OUTDENT', 2, token[2]];
+      if (implicit) {
+        indent.generated = outdent.generated = true;
+      }
+      return [indent, outdent];
+    };
+
+    Rewriter.prototype.generate = function(tag, value, line) {
+      var tok;
+      tok = [tag, value, line];
+      tok.generated = true;
+      return tok;
+    };
+
+    Rewriter.prototype.tag = function(i) {
+      var _ref;
+      return (_ref = this.tokens[i]) != null ? _ref[0] : void 0;
+    };
+
+    return Rewriter;
+
+  })();
+
+  BALANCED_PAIRS = [['(', ')'], ['[', ']'], ['{', '}'], ['INDENT', 'OUTDENT'], ['CALL_START', 'CALL_END'], ['PARAM_START', 'PARAM_END'], ['INDEX_START', 'INDEX_END']];
+
+  exports.INVERSES = INVERSES = {};
+
+  EXPRESSION_START = [];
+
+  EXPRESSION_END = [];
+
+  for (_i = 0, _len = BALANCED_PAIRS.length; _i < _len; _i++) {
+    _ref = BALANCED_PAIRS[_i], left = _ref[0], rite = _ref[1];
+    EXPRESSION_START.push(INVERSES[rite] = left);
+    EXPRESSION_END.push(INVERSES[left] = rite);
+  }
+
+  EXPRESSION_CLOSE = ['CATCH', 'WHEN', 'ELSE', 'FINALLY'].concat(EXPRESSION_END);
+
+  IMPLICIT_FUNC = ['IDENTIFIER', 'SUPER', ')', 'CALL_END', ']', 'INDEX_END', '@', 'THIS'];
+
+  IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'NULL', 'UNDEFINED', 'UNARY', 'SUPER', '@', '->', '=>', '[', '(', '{', '--', '++'];
+
+  IMPLICIT_UNSPACED_CALL = ['+', '-'];
+
+  IMPLICIT_BLOCK = ['->', '=>', '{', '[', ','];
+
+  IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR'];
+
+  SINGLE_LINERS = ['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN'];
+
+  SINGLE_CLOSERS = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN'];
+
+  LINEBREAKS = ['TERMINATOR', 'INDENT', 'OUTDENT'];
+
+}).call(this);