text: // Generated by KavaScript 1.10.1
  (function() {
    var Lexer, SourceMap, compile, ext, fn1, formatSourcePosition, fs, getSourceMap, helpers, i, len, lexer, parser, path, ref, sourceMaps, vm, withPrettyErrors,
      hasProp = {}.hasOwnProperty,
      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; };
  
    fs = require('fs');
  
    vm = require('vm');
  
    path = require('path');
  
    Lexer = require('./lexer').Lexer;
  
    parser = require('./parser').parser;
  
    helpers = require('./helpers');
  
    SourceMap = require('./sourcemap');
  
    exports.VERSION = '1.10.1';
  
    exports.FILE_EXTENSIONS = ['.ks', '.vks', '.ks.md'];
  
    exports.helpers = helpers;
  
    withPrettyErrors = function(fn) {
      return function(code, options) {
        var err;
        if (options == null) {
          options = {};
        }
        try {
          return fn.call(this, code, options);
        } catch (error) {
          err = error;
          if (typeof code !== 'string') {
            throw err;
          }
          throw helpers.updateSyntaxError(err, code, options.filename);
        }
      };
    };
  
    exports.compile = compile = withPrettyErrors(function(code, options) {
      var answer, currentColumn, currentLine, extend, fragment, fragments, header, i, js, len, map, merge, newLines, token, tokens;
      merge = helpers.merge, extend = helpers.extend;
      options = extend({}, options);
      if (options.sourceMap) {
        map = new SourceMap;
      }
      tokens = lexer.tokenize(code, options);
      options.referencedVars = (function() {
        var i, len, results;
        results = [];
        for (i = 0, len = tokens.length; i < len; i++) {
          token = tokens[i];
          if (token.variable) {
            results.push(token[1]);
          }
        }
        return results;
      })();
      fragments = parser.parse(tokens).compileToFragments(options);
      currentLine = 0;
      if (options.header) {
        currentLine += 1;
      }
      if (options.shiftLine) {
        currentLine += 1;
      }
      currentColumn = 0;
      js = "";
      for (i = 0, len = fragments.length; i < len; i++) {
        fragment = fragments[i];
        if (options.sourceMap) {
          if (fragment.locationData && !/^[;\s]*$/.test(fragment.code)) {
            map.add([fragment.locationData.first_line, fragment.locationData.first_column], [currentLine, currentColumn], {
              noReplace: true
            });
          }
          newLines = helpers.count(fragment.code, "\n");
          currentLine += newLines;
          if (newLines) {
            currentColumn = fragment.code.length - (fragment.code.lastIndexOf("\n") + 1);
          } else {
            currentColumn += fragment.code.length;
          }
        }
        js += fragment.code;
      }
      if (options.header) {
        header = "Generated by KavaScript " + this.VERSION;
        js = "// " + header + "\n" + js;
      }
      if (options.sourceMap) {
        answer = {
          js: js
        };
        answer.sourceMap = map;
        answer.v3SourceMap = map.generate(options, code);
        return answer;
      } else {
        return js;
      }
    });
  
    exports.tokens = withPrettyErrors(function(code, options) {
      return lexer.tokenize(code, options);
    });
  
    exports.nodes = withPrettyErrors(function(source, options) {
      if (typeof source === 'string') {
        return parser.parse(lexer.tokenize(source, options));
      } else {
        return parser.parse(source);
      }
    });
  
    exports.run = function(code, options) {
      var answer, dir, mainModule, ref;
      if (options == null) {
        options = {};
      }
      mainModule = require.main;
      mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
      mainModule.moduleCache && (mainModule.moduleCache = {});
      dir = options.filename ? path.dirname(fs.realpathSync(options.filename)) : fs.realpathSync('.');
      mainModule.paths = require('module')._nodeModulePaths(dir);
      if (!helpers.isCoffee(mainModule.filename) || require.extensions) {
        answer = compile(code, options);
        code = (ref = answer.js) != null ? ref : answer;
      }
      return mainModule._compile(code, mainModule.filename);
    };
  
    exports["eval"] = function(code, options) {
      var Module, _module, _require, createContext, i, isContext, js, k, len, o, r, ref, ref1, ref2, ref3, sandbox, v;
      if (options == null) {
        options = {};
      }
      if (!(code = code.trim())) {
        return;
      }
      createContext = (ref = vm.Script.createContext) != null ? ref : vm.createContext;
      isContext = (ref1 = vm.isContext) != null ? ref1 : function(ctx) {
        return options.sandbox instanceof createContext().constructor;
      };
      if (createContext) {
        if (options.sandbox != null) {
          if (isContext(options.sandbox)) {
            sandbox = options.sandbox;
          } else {
            sandbox = createContext();
            ref2 = options.sandbox;
            for (k in ref2) {
              if (!hasProp.call(ref2, k)) continue;
              v = ref2[k];
              sandbox[k] = v;
            }
          }
          sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
        } else {
          sandbox = global;
        }
        sandbox.__filename = options.filename || 'eval';
        sandbox.__dirname = path.dirname(sandbox.__filename);
        if (!(sandbox !== global || sandbox.module || sandbox.require)) {
          Module = require('module');
          sandbox.module = _module = new Module(options.modulename || 'eval');
          sandbox.require = _require = function(path) {
            return Module._load(path, _module, true);
          };
          _module.filename = sandbox.__filename;
          ref3 = Object.getOwnPropertyNames(require);
          for (i = 0, len = ref3.length; i < len; i++) {
            r = ref3[i];
            if (r !== 'paths' && r !== 'arguments' && r !== 'caller') {
              _require[r] = require[r];
            }
          }
          _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
          _require.resolve = function(request) {
            return Module._resolveFilename(request, _module);
          };
        }
      }
      o = {};
      for (k in options) {
        if (!hasProp.call(options, k)) continue;
        v = options[k];
        o[k] = v;
      }
      o.bare = true;
      js = compile(code, o);
      if (sandbox === global) {
        return vm.runInThisContext(js);
      } else {
        return vm.runInContext(js, sandbox);
      }
    };
  
    exports.register = function() {
      return require('./register');
    };
  
    if (require.extensions) {
      ref = this.FILE_EXTENSIONS;
      fn1 = function(ext) {
        var base;
        return (base = require.extensions)[ext] != null ? base[ext] : base[ext] = function() {
          throw new Error("Use KavaScript.register() or require the kavascript/register module to require " + ext + " files.");
        };
      };
      for (i = 0, len = ref.length; i < len; i++) {
        ext = ref[i];
        fn1(ext);
      }
    }
  
    exports._compileFile = function(filename, sourceMap) {
      var answer, err, raw, stripped;
      if (sourceMap == null) {
        sourceMap = false;
      }
      raw = fs.readFileSync(filename, 'utf8');
      stripped = raw.charCodeAt(0) === 0xFEFF ? raw.substring(1) : raw;
      try {
        answer = compile(stripped, {
          filename: filename,
          sourceMap: sourceMap,
          verbose: helpers.isVerbose(filename)
        });
      } catch (error) {
        err = error;
        throw helpers.updateSyntaxError(err, stripped, filename);
      }
      return answer;
    };
  
    lexer = new Lexer;
  
    parser.lexer = {
      lex: function() {
        var tag, token;
        token = parser.tokens[this.pos++];
        if (token) {
          tag = token[0], this.yytext = token[1], this.yylloc = token[2];
          parser.errorToken = token.origin || token;
          this.yylineno = this.yylloc.first_line;
        } else {
          tag = '';
        }
        return tag;
      },
      setInput: function(tokens) {
        parser.tokens = tokens;
        return this.pos = 0;
      },
      upcomingInput: function() {
        return "";
      }
    };
  
    parser.yy = require('./nodes');
  
    parser.yy.parseError = function(message, arg) {
      var errorLoc, errorTag, errorText, errorToken, token, tokens;
      token = arg.token;
      errorToken = parser.errorToken, tokens = parser.tokens;
      errorTag = errorToken[0], errorText = errorToken[1], errorLoc = errorToken[2];
      errorText = (function() {
        switch (false) {
          case errorToken !== tokens[tokens.length - 1]:
            return 'end of input';
          case errorTag !== 'INDENT' && errorTag !== 'OUTDENT':
            return 'indentation';
          case errorTag !== 'IDENTIFIER' && errorTag !== 'NUMBER' && errorTag !== 'STRING' && errorTag !== 'STRING_START' && errorTag !== 'REGEX' && errorTag !== 'REGEX_START':
            return errorTag.replace(/_START$/, '').toLowerCase();
          default:
            return helpers.nameWhitespaceCharacter(errorText);
        }
      })();
      return helpers.throwSyntaxError("unexpected " + errorText, errorLoc);
    };
  
    formatSourcePosition = function(frame, getSourceMapping) {
      var as, column, fileLocation, fileName, functionName, isConstructor, isMethodCall, line, methodName, source, tp, typeName;
      fileName = void 0;
      fileLocation = '';
      if (frame.isNative()) {
        fileLocation = "native";
      } else {
        if (frame.isEval()) {
          fileName = frame.getScriptNameOrSourceURL();
          if (!fileName) {
            fileLocation = (frame.getEvalOrigin()) + ", ";
          }
        } else {
          fileName = frame.getFileName();
        }
        fileName || (fileName = "<anonymous>");
        line = frame.getLineNumber();
        column = frame.getColumnNumber();
        source = getSourceMapping(fileName, line, column);
        fileLocation = source ? fileName + ":" + source[0] + ":" + source[1] : fileName + ":" + line + ":" + column;
      }
      functionName = frame.getFunctionName();
      isConstructor = frame.isConstructor();
      isMethodCall = !(frame.isToplevel() || isConstructor);
      if (isMethodCall) {
        methodName = frame.getMethodName();
        typeName = frame.getTypeName();
        if (functionName) {
          tp = as = '';
          if (typeName && functionName.indexOf(typeName)) {
            tp = typeName + ".";
          }
          if (methodName && functionName.indexOf("." + methodName) !== functionName.length - methodName.length - 1) {
            as = " [as " + methodName + "]";
          }
          return "" + tp + functionName + as + " (" + fileLocation + ")";
        } else {
          return typeName + "." + (methodName || '<anonymous>') + " (" + fileLocation + ")";
        }
      } else if (isConstructor) {
        return "new " + (functionName || '<anonymous>') + " (" + fileLocation + ")";
      } else if (functionName) {
        return functionName + " (" + fileLocation + ")";
      } else {
        return fileLocation;
      }
    };
  
    sourceMaps = {};
  
    getSourceMap = function(filename) {
      var answer, ref1;
      if (sourceMaps[filename]) {
        return sourceMaps[filename];
      }
      if (ref1 = path != null ? path.extname(filename) : void 0, indexOf.call(exports.FILE_EXTENSIONS, ref1) < 0) {
        return;
      }
      answer = exports._compileFile(filename, true);
      return sourceMaps[filename] = answer.sourceMap;
    };
  
    Error.prepareStackTrace = function(err, stack) {
      var frame, frames, getSourceMapping;
      getSourceMapping = function(filename, line, column) {
        var answer, sourceMap;
        sourceMap = getSourceMap(filename);
        if (sourceMap) {
          answer = sourceMap.sourceLocation([line - 1, column - 1]);
        }
        if (answer) {
          return [answer[0] + 1, answer[1] + 1];
        } else {
          return null;
        }
      };
      frames = (function() {
        var j, len1, results;
        results = [];
        for (j = 0, len1 = stack.length; j < len1; j++) {
          frame = stack[j];
          if (frame.getFunction() === exports.run) {
            break;
          }
          results.push("  at " + (formatSourcePosition(frame, getSourceMapping)));
        }
        return results;
      })();
      return (err.toString()) + "\n" + (frames.join('\n')) + "\n";
    };
  
  }).call(this);
  