@openui5/sap.ui.codeeditor 1.94.0 → 1.97.0

package/src/sap/ui/codeeditor/js/ace/worker-lua.js

@@ -209,7 +209,6 @@ window.onmessage = function(e) {
     }
     else if (msg.init) {
         window.initBaseUrls(msg.tlns);
-        require("ace/lib/es5-shim");
         sender = window.sender = window.initSender();
         var clazz = require(msg.module)[msg.classname];
         main = window.main = new clazz(sender);
@@ -599,8 +598,8 @@ EventEmitter._signal = function(eventName, e) {
 
 EventEmitter.once = function(eventName, callback) {
     var _self = this;
-    this.addEventListener(eventName, function newCallback() {
-        _self.removeEventListener(eventName, newCallback);
+    this.on(eventName, function newCallback() {
+        _self.off(eventName, newCallback);
         callback.apply(null, arguments);
     });
     if (!callback) {
@@ -672,7 +671,9 @@ EventEmitter.removeEventListener = function(eventName, callback) {
 };
 
 EventEmitter.removeAllListeners = function(eventName) {
-    if (this._eventRegistry) this._eventRegistry[eventName] = [];
+    if (!eventName) this._eventRegistry = this._defaultHandlers = undefined;
+    if (this._eventRegistry) this._eventRegistry[eventName] = undefined;
+    if (this._defaultHandlers) this._defaultHandlers[eventName] = undefined;
 };
 
 exports.EventEmitter = EventEmitter;
@@ -772,7 +773,7 @@ var Anchor = exports.Anchor = function(doc, row, column) {
         });
     };
     this.detach = function() {
-        this.document.removeEventListener("change", this.$onChange);
+        this.document.off("change", this.$onChange);
     };
     this.attach = function(doc) {
         this.document = doc || this.document;
@@ -1104,6 +1105,16 @@ var Document = function(textOrLines) {
         }
     };
     
+    this.$safeApplyDelta = function(delta) {
+        var docLength = this.$lines.length;
+        if (
+            delta.action == "remove" && delta.start.row < docLength && delta.end.row < docLength
+            || delta.action == "insert" && delta.start.row <= docLength
+        ) {
+            this.applyDelta(delta);
+        }
+    };
+    
     this.$splitAndapplyLargeDelta = function(delta, MAX) {
         var lines = delta.lines;
         var l = lines.length - MAX + 1;
@@ -1126,7 +1137,7 @@ var Document = function(textOrLines) {
         this.applyDelta(delta, true);
     };
     this.revertDelta = function(delta) {
-        this.applyDelta({
+        this.$safeApplyDelta({
             start: this.clonePos(delta.start),
             end: this.clonePos(delta.end),
             action: (delta.action == "insert" ? "remove" : "insert"),
@@ -1416,15 +1427,104 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 }(this, 'luaparse', function (exports) {
   'use strict';
 
-  exports.version = '0.1.4';
+  exports.version = "0.3.1";
 
-  var input, options, length;
+  var input, options, length, features, encodingMode;
   var defaultOptions = exports.defaultOptions = {
       wait: false
     , comments: true
     , scope: false
     , locations: false
     , ranges: false
+    , onCreateNode: null
+    , onCreateScope: null
+    , onDestroyScope: null
+    , onLocalDeclaration: null
+    , luaVersion: '5.1'
+    , encodingMode: 'none'
+  };
+
+  function encodeUTF8(codepoint, highMask) {
+    highMask = highMask || 0;
+
+    if (codepoint < 0x80) {
+      return String.fromCharCode(codepoint);
+    } else if (codepoint < 0x800) {
+      return String.fromCharCode(
+        highMask | 0xc0 |  (codepoint >>  6)        ,
+        highMask | 0x80 | ( codepoint        & 0x3f)
+      );
+    } else if (codepoint < 0x10000) {
+      return String.fromCharCode(
+        highMask | 0xe0 |  (codepoint >> 12)        ,
+        highMask | 0x80 | ((codepoint >>  6) & 0x3f),
+        highMask | 0x80 | ( codepoint        & 0x3f)
+      );
+    } else /* istanbul ignore else */ if (codepoint < 0x110000) {
+      return String.fromCharCode(
+        highMask | 0xf0 |  (codepoint >> 18)        ,
+        highMask | 0x80 | ((codepoint >> 12) & 0x3f),
+        highMask | 0x80 | ((codepoint >>  6) & 0x3f),
+        highMask | 0x80 | ( codepoint        & 0x3f)
+      );
+    } else {
+      return null;
+    }
+  }
+
+  function toHex(num, digits) {
+    var result = num.toString(16);
+    while (result.length < digits)
+      result = '0' + result;
+    return result;
+  }
+
+  function checkChars(rx) {
+    return function (s) {
+      var m = rx.exec(s);
+      if (!m)
+        return s;
+      raise(null, errors.invalidCodeUnit, toHex(m[0].charCodeAt(0), 4).toUpperCase());
+    };
+  }
+
+  var encodingModes = {
+    'pseudo-latin1': {
+      fixup: checkChars(/[^\x00-\xff]/),
+      encodeByte: function (value) {
+        if (value === null)
+          return '';
+        return String.fromCharCode(value);
+      },
+      encodeUTF8: function (codepoint) {
+        return encodeUTF8(codepoint);
+      },
+    },
+    'x-user-defined': {
+      fixup: checkChars(/[^\x00-\x7f\uf780-\uf7ff]/),
+      encodeByte: function (value) {
+        if (value === null)
+          return '';
+        if (value >= 0x80)
+          return String.fromCharCode(value | 0xf700);
+        return String.fromCharCode(value);
+      },
+      encodeUTF8: function (codepoint) {
+        return encodeUTF8(codepoint, 0xf700);
+      }
+    },
+    'none': {
+      discardStrings: true,
+      fixup: function (s) {
+        return s;
+      },
+      encodeByte: function (value) {
+        return '';
+      },
+      encodeUTF8: function (codepoint) {
+        return '';
+      }
+    }
   };
 
   var EOF = 1, StringLiteral = 2, Keyword = 4, Identifier = 8
@@ -1438,11 +1538,26 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
   };
 
   var errors = exports.errors = {
-      unexpected: 'Unexpected %1 \'%2\' near \'%3\''
+      unexpected: 'unexpected %1 \'%2\' near \'%3\''
+    , unexpectedEOF: 'unexpected symbol near \'<eof>\''
     , expected: '\'%1\' expected near \'%2\''
     , expectedToken: '%1 expected near \'%2\''
     , unfinishedString: 'unfinished string near \'%1\''
     , malformedNumber: 'malformed number near \'%1\''
+    , decimalEscapeTooLarge: 'decimal escape too large near \'%1\''
+    , invalidEscape: 'invalid escape sequence near \'%1\''
+    , hexadecimalDigitExpected: 'hexadecimal digit expected near \'%1\''
+    , braceExpected: 'missing \'%1\' near \'%2\''
+    , tooLargeCodepoint: 'UTF-8 value too large near \'%1\''
+    , unfinishedLongString: 'unfinished long string (starting at line %1) near \'%2\''
+    , unfinishedLongComment: 'unfinished long comment (starting at line %1) near \'%2\''
+    , ambiguousSyntax: 'ambiguous syntax (function call x new statement) near \'%1\''
+    , noLoopToBreak: 'no loop to break near \'%1\''
+    , labelAlreadyDefined: 'label \'%1\' already defined on line %2'
+    , labelNotVisible: 'no visible label \'%1\' for <goto>'
+    , gotoJumpInLocalScope: '<goto %1> jumps into the scope of local \'%2\''
+    , cannotUseVararg: 'cannot use \'...\' outside a vararg function near \'%1\''
+    , invalidCodeUnit: 'code unit U+%1 is not allowed in the current encoding mode'
   };
 
   var ast = exports.ast = {
@@ -1705,23 +1820,29 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     if (trackLocations) {
       var location = locations.pop();
       location.complete();
-      if (options.locations) node.loc = location.loc;
-      if (options.ranges) node.range = location.range;
+      location.bless(node);
     }
+    if (options.onCreateNode) options.onCreateNode(node);
     return node;
   }
 
   var slice = Array.prototype.slice
     , toString = Object.prototype.toString
-    , indexOf = function indexOf(array, element) {
-      for (var i = 0, length = array.length; i < length; i++) {
-        if (array[i] === element) return i;
-      }
-      return -1;
+    ;
+
+  var indexOf = /* istanbul ignore next */ function (array, element) {
+    for (var i = 0, length = array.length; i < length; ++i) {
+      if (array[i] === element) return i;
+    }
+    return -1;
+  };
+  if (Array.prototype.indexOf)
+    indexOf = function (array, element) {
+      return array.indexOf(element);
     };
 
   function indexOfObject(array, property, element) {
-    for (var i = 0, length = array.length; i < length; i++) {
+    for (var i = 0, length = array.length; i < length; ++i) {
       if (array[i][property] === element) return i;
     }
     return -1;
@@ -1730,51 +1851,73 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
   function sprintf(format) {
     var args = slice.call(arguments, 1);
     format = format.replace(/%(\d)/g, function (match, index) {
-      return '' + args[index - 1] || '';
+      return '' + args[index - 1] || /* istanbul ignore next */ '';
     });
     return format;
   }
 
-  function extend() {
-    var args = slice.call(arguments)
-      , dest = {}
+  var assign = /* istanbul ignore next */ function (dest) {
+    var args = slice.call(arguments, 1)
       , src, prop;
 
-    for (var i = 0, length = args.length; i < length; i++) {
+    for (var i = 0, length = args.length; i < length; ++i) {
       src = args[i];
-      for (prop in src) if (src.hasOwnProperty(prop)) {
-        dest[prop] = src[prop];
-      }
+      for (prop in src)
+        if (Object.prototype.hasOwnProperty.call(src, prop)) {
+          dest[prop] = src[prop];
+        }
     }
+
     return dest;
+  };
+  if (Object.assign)
+    assign = Object.assign;
+
+  exports.SyntaxError = SyntaxError;
+
+  function fixupError(e) {
+    if (!Object.create)
+      return e;
+    return Object.create(e, {
+      'line': { 'writable': true, value: e.line },
+      'index': { 'writable': true, value: e.index },
+      'column': { 'writable': true, value: e.column }
+    });
   }
 
   function raise(token) {
     var message = sprintf.apply(null, slice.call(arguments, 1))
       , error, col;
 
-    if ('undefined' !== typeof token.line) {
-      col = token.range[0] - token.lineStart;
-      error = new SyntaxError(sprintf('[%1:%2] %3', token.line, col, message));
-      error.line = token.line;
-      error.index = token.range[0];
-      error.column = col;
-    } else {
+    if (token === null || typeof token.line === 'undefined') {
       col = index - lineStart + 1;
-      error = new SyntaxError(sprintf('[%1:%2] %3', line, col, message));
+      error = fixupError(new SyntaxError(sprintf('[%1:%2] %3', line, col, message)));
       error.index = index;
       error.line = line;
       error.column = col;
+    } else {
+      col = token.range[0] - token.lineStart;
+      error = fixupError(new SyntaxError(sprintf('[%1:%2] %3', token.line, col, message)));
+      error.line = token.line;
+      error.index = token.range[0];
+      error.column = col;
     }
     throw error;
   }
 
+  function tokenValue(token) {
+    var raw = input.slice(token.range[0], token.range[1]);
+    if (raw)
+      return raw;
+    return token.value;
+  }
+
   function raiseUnexpectedToken(type, token) {
-    raise(token, errors.expectedToken, type, token.value);
+    raise(token, errors.expectedToken, type, tokenValue(token));
   }
 
-  function unexpected(found, near) {
-    if ('undefined' === typeof near) near = lookahead.value;
+  function unexpected(found) {
+    var near = tokenValue(lookahead);
     if ('undefined' !== typeof found.type) {
       var type;
       switch (found.type) {
@@ -1786,8 +1929,10 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         case BooleanLiteral:  type = 'boolean';     break;
         case NilLiteral:
           return raise(found, errors.unexpected, 'symbol', 'nil', near);
+        case EOF:
+          return raise(found, errors.unexpectedEOF);
       }
-      return raise(found, errors.unexpected, type, found.value, near);
+      return raise(found, errors.unexpected, type, tokenValue(found), near);
     }
     return raise(found, errors.unexpected, 'symbol', found, near);
   }
@@ -1826,8 +1971,9 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     switch (charCode) {
       case 39: case 34: // '"
         return scanStringLiteral();
+
       case 48: case 49: case 50: case 51: case 52: case 53:
-      case 54: case 55: case 56: case 57:
+      case 54: case 55: case 56: case 57: // 0-9
         return scanNumericLiteral();
 
       case 46: // .
@@ -1843,41 +1989,70 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         return scanPunctuator('=');
 
       case 62: // >
+        if (features.bitwiseOperators)
+          if (62 === next) return scanPunctuator('>>');
         if (61 === next) return scanPunctuator('>=');
         return scanPunctuator('>');
 
       case 60: // <
+        if (features.bitwiseOperators)
+          if (60 === next) return scanPunctuator('<<');
         if (61 === next) return scanPunctuator('<=');
         return scanPunctuator('<');
 
       case 126: // ~
         if (61 === next) return scanPunctuator('~=');
+        if (!features.bitwiseOperators)
+          break;
         return scanPunctuator('~');
 
       case 58: // :
-        if (58 === next) return scanPunctuator('::');
+        if (features.labels)
+          if (58 === next) return scanPunctuator('::');
         return scanPunctuator(':');
 
       case 91: // [
         if (91 === next || 61 === next) return scanLongStringLiteral();
         return scanPunctuator('[');
-      case 42: case 47: case 94: case 37: case 44: case 123: case 125:
-      case 93: case 40: case 41: case 59: case 35: case 45: case 43: case 38: case 124:
+
+      case 47: // /
+        if (features.integerDivision)
+          if (47 === next) return scanPunctuator('//');
+        return scanPunctuator('/');
+
+      case 38: case 124: // & |
+        if (!features.bitwiseOperators)
+          break;
+      case 42: case 94: case 37: case 44: case 123: case 125:
+      case 93: case 40: case 41: case 59: case 35: case 45:
+      case 43: // * ^ % , { } ] ( ) ; # - +
         return scanPunctuator(input.charAt(index));
     }
 
     return unexpected(input.charAt(index));
   }
 
+  function consumeEOL() {
+    var charCode = input.charCodeAt(index)
+      , peekCharCode = input.charCodeAt(index + 1);
+
+    if (isLineTerminator(charCode)) {
+      if (10 === charCode && 13 === peekCharCode) ++index;
+      if (13 === charCode && 10 === peekCharCode) ++index;
+      ++line;
+      lineStart = ++index;
+
+      return true;
+    }
+    return false;
+  }
+
   function skipWhiteSpace() {
     while (index < length) {
       var charCode = input.charCodeAt(index);
       if (isWhiteSpace(charCode)) {
-        index++;
-      } else if (isLineTerminator(charCode)) {
-        line++;
-        lineStart = ++index;
-      } else {
+        ++index;
+      } else if (!consumeEOL()) {
         break;
       }
     }
@@ -1886,7 +2061,7 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
   function scanIdentifierOrKeyword() {
     var value, type;
     while (isIdentifierPart(input.charCodeAt(++index)));
-    value = input.slice(tokenStart, index);
+    value = encodingMode.fixup(input.slice(tokenStart, index));
     if (isKeyword(value)) {
       type = Keyword;
     } else if ('true' === value || 'false' === value) {
@@ -1932,42 +2107,59 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 
   function scanStringLiteral() {
     var delimiter = input.charCodeAt(index++)
+      , beginLine = line
+      , beginLineStart = lineStart
       , stringStart = index
-      , string = ''
+      , string = encodingMode.discardStrings ? null : ''
       , charCode;
 
-    while (index < length) {
+    for (;;) {
       charCode = input.charCodeAt(index++);
       if (delimiter === charCode) break;
-      if (92 === charCode) { // \
-        string += input.slice(stringStart, index - 1) + readEscapeSequence();
-        stringStart = index;
-      }
-      else if (index >= length || isLineTerminator(charCode)) {
+      if (index > length || isLineTerminator(charCode)) {
         string += input.slice(stringStart, index - 1);
-        raise({}, errors.unfinishedString, string + String.fromCharCode(charCode));
+        raise(null, errors.unfinishedString, input.slice(tokenStart, index - 1));
+      }
+      if (92 === charCode) { // backslash
+        if (!encodingMode.discardStrings) {
+          var beforeEscape = input.slice(stringStart, index - 1);
+          string += encodingMode.fixup(beforeEscape);
+        }
+        var escapeValue = readEscapeSequence();
+        if (!encodingMode.discardStrings)
+          string += escapeValue;
+        stringStart = index;
       }
     }
-    string += input.slice(stringStart, index - 1);
+    if (!encodingMode.discardStrings) {
+      string += encodingMode.encodeByte(null);
+      string += encodingMode.fixup(input.slice(stringStart, index - 1));
+    }
 
     return {
         type: StringLiteral
       , value: string
-      , line: line
-      , lineStart: lineStart
+      , line: beginLine
+      , lineStart: beginLineStart
+      , lastLine: line
+      , lastLineStart: lineStart
       , range: [tokenStart, index]
     };
   }
 
   function scanLongStringLiteral() {
-    var string = readLongString();
-    if (false === string) raise(token, errors.expected, '[', token.value);
+    var beginLine = line
+      , beginLineStart = lineStart
+      , string = readLongString(false);
+    if (false === string) raise(token, errors.expected, '[', tokenValue(token));
 
     return {
         type: StringLiteral
-      , value: string
-      , line: line
-      , lineStart: lineStart
+      , value: encodingMode.discardStrings ? null : encodingMode.fixup(string)
+      , line: beginLine
+      , lineStart: beginLineStart
+      , lastLine: line
+      , lastLineStart: lineStart
       , range: [tokenStart, index]
     };
   }
@@ -1976,18 +2168,62 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     var character = input.charAt(index)
       , next = input.charAt(index + 1);
 
-    var value = ('0' === character && 'xX'.indexOf(next || null) >= 0) ?
+    var literal = ('0' === character && 'xX'.indexOf(next || null) >= 0) ?
       readHexLiteral() : readDecLiteral();
 
+    var foundImaginaryUnit = readImaginaryUnitSuffix()
+      , foundInt64Suffix = readInt64Suffix();
+
+    if (foundInt64Suffix && (foundImaginaryUnit || literal.hasFractionPart)) {
+      raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+    }
+
     return {
         type: NumericLiteral
-      , value: value
+      , value: literal.value
       , line: line
       , lineStart: lineStart
       , range: [tokenStart, index]
     };
   }
 
+  function readImaginaryUnitSuffix() {
+    if (!features.imaginaryNumbers) return;
+    if ('iI'.indexOf(input.charAt(index) || null) >= 0) {
+      ++index;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  function readInt64Suffix() {
+    if (!features.integerSuffixes) return;
+
+    if ('uU'.indexOf(input.charAt(index) || null) >= 0) {
+      ++index;
+      if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
+        ++index;
+        if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
+          ++index;
+          return 'ULL';
+        } else {
+          raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+        }
+      } else {
+        raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+      }
+    } else if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
+        ++index;
+        if ('lL'.indexOf(input.charAt(index) || null) >= 0) {
+          ++index;
+          return 'LL';
+        } else {
+          raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+        }
+    }
+  }
+
   function readHexLiteral() {
     var fraction = 0 // defaults to 0 as it gets summed
       , binaryExponent = 1 // defaults to 1 as it gets multiplied
@@ -1996,77 +2232,158 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 
     digitStart = index += 2; // Skip 0x part
     if (!isHexDigit(input.charCodeAt(index)))
-      raise({}, errors.malformedNumber, input.slice(tokenStart, index));
+      raise(null, errors.malformedNumber, input.slice(tokenStart, index));
 
-    while (isHexDigit(input.charCodeAt(index))) index++;
+    while (isHexDigit(input.charCodeAt(index))) ++index;
     digit = parseInt(input.slice(digitStart, index), 16);
+    var foundFraction = false;
     if ('.' === input.charAt(index)) {
+      foundFraction = true;
       fractionStart = ++index;
 
-      while (isHexDigit(input.charCodeAt(index))) index++;
+      while (isHexDigit(input.charCodeAt(index))) ++index;
       fraction = input.slice(fractionStart, index);
       fraction = (fractionStart === index) ? 0
         : parseInt(fraction, 16) / Math.pow(16, index - fractionStart);
     }
+    var foundBinaryExponent = false;
     if ('pP'.indexOf(input.charAt(index) || null) >= 0) {
-      index++;
+      foundBinaryExponent = true;
+      ++index;
       if ('+-'.indexOf(input.charAt(index) || null) >= 0)
         binarySign = ('+' === input.charAt(index++)) ? 1 : -1;
 
       exponentStart = index;
       if (!isDecDigit(input.charCodeAt(index)))
-        raise({}, errors.malformedNumber, input.slice(tokenStart, index));
+        raise(null, errors.malformedNumber, input.slice(tokenStart, index));
 
-      while (isDecDigit(input.charCodeAt(index))) index++;
+      while (isDecDigit(input.charCodeAt(index))) ++index;
       binaryExponent = input.slice(exponentStart, index);
       binaryExponent = Math.pow(2, binaryExponent * binarySign);
     }
 
-    return (digit + fraction) * binaryExponent;
+    return {
+      value: (digit + fraction) * binaryExponent,
+      hasFractionPart: foundFraction || foundBinaryExponent
+    };
   }
 
   function readDecLiteral() {
-    while (isDecDigit(input.charCodeAt(index))) index++;
+    while (isDecDigit(input.charCodeAt(index))) ++index;
+    var foundFraction = false;
     if ('.' === input.charAt(index)) {
-      index++;
-      while (isDecDigit(input.charCodeAt(index))) index++;
+      foundFraction = true;
+      ++index;
+      while (isDecDigit(input.charCodeAt(index))) ++index;
     }
+    var foundExponent = false;
     if ('eE'.indexOf(input.charAt(index) || null) >= 0) {
-      index++;
-      if ('+-'.indexOf(input.charAt(index) || null) >= 0) index++;
+      foundExponent = true;
+      ++index;
+      if ('+-'.indexOf(input.charAt(index) || null) >= 0) ++index;
       if (!isDecDigit(input.charCodeAt(index)))
-        raise({}, errors.malformedNumber, input.slice(tokenStart, index));
+        raise(null, errors.malformedNumber, input.slice(tokenStart, index));
 
-      while (isDecDigit(input.charCodeAt(index))) index++;
+      while (isDecDigit(input.charCodeAt(index))) ++index;
     }
 
-    return parseFloat(input.slice(tokenStart, index));
+    return {
+      value: parseFloat(input.slice(tokenStart, index)),
+      hasFractionPart: foundFraction || foundExponent
+    };
   }
 
+  function readUnicodeEscapeSequence() {
+    var sequenceStart = index++;
+
+    if (input.charAt(index++) !== '{')
+      raise(null, errors.braceExpected, '{', '\\' + input.slice(sequenceStart, index));
+    if (!isHexDigit(input.charCodeAt(index)))
+      raise(null, errors.hexadecimalDigitExpected, '\\' + input.slice(sequenceStart, index));
+
+    while (input.charCodeAt(index) === 0x30) ++index;
+    var escStart = index;
+
+    while (isHexDigit(input.charCodeAt(index))) {
+      ++index;
+      if (index - escStart > 6)
+        raise(null, errors.tooLargeCodepoint, '\\' + input.slice(sequenceStart, index));
+    }
+
+    var b = input.charAt(index++);
+    if (b !== '}') {
+      if ((b === '"') || (b === "'"))
+        raise(null, errors.braceExpected, '}', '\\' + input.slice(sequenceStart, index--));
+      else
+        raise(null, errors.hexadecimalDigitExpected, '\\' + input.slice(sequenceStart, index));
+    }
+
+    var codepoint = parseInt(input.slice(escStart, index - 1) || '0', 16);
+    var frag = '\\' + input.slice(sequenceStart, index);
+
+    if (codepoint > 0x10ffff) {
+      raise(null, errors.tooLargeCodepoint, frag);
+    }
+
+    return encodingMode.encodeUTF8(codepoint, frag);
+  }
   function readEscapeSequence() {
     var sequenceStart = index;
     switch (input.charAt(index)) {
-      case 'n': index++; return '\n';
-      case 'r': index++; return '\r';
-      case 't': index++; return '\t';
-      case 'v': index++; return '\x0B';
-      case 'b': index++; return '\b';
-      case 'f': index++; return '\f';
-      case 'z': index++; skipWhiteSpace(); return '';
-      case 'x':
-        if (isHexDigit(input.charCodeAt(index + 1)) &&
-            isHexDigit(input.charCodeAt(index + 2))) {
-          index += 3;
-          return '\\' + input.slice(sequenceStart, index);
+      case 'a': ++index; return '\x07';
+      case 'n': ++index; return '\n';
+      case 'r': ++index; return '\r';
+      case 't': ++index; return '\t';
+      case 'v': ++index; return '\x0b';
+      case 'b': ++index; return '\b';
+      case 'f': ++index; return '\f';
+      case '\r':
+      case '\n':
+        consumeEOL();
+        return '\n';
+
+      case '0': case '1': case '2': case '3': case '4':
+      case '5': case '6': case '7': case '8': case '9':
+        while (isDecDigit(input.charCodeAt(index)) && index - sequenceStart < 3) ++index;
+
+        var frag = input.slice(sequenceStart, index);
+        var ddd = parseInt(frag, 10);
+        if (ddd > 255) {
+          raise(null, errors.decimalEscapeTooLarge, '\\' + ddd);
+        }
+        return encodingMode.encodeByte(ddd, '\\' + frag);
+
+      case 'z':
+        if (features.skipWhitespaceEscape) {
+          ++index;
+          skipWhiteSpace();
+          return '';
         }
-        return '\\' + input.charAt(index++);
-      default:
-        if (isDecDigit(input.charCodeAt(index))) {
-          while (isDecDigit(input.charCodeAt(++index)));
-          return '\\' + input.slice(sequenceStart, index);
+        break;
+
+      case 'x':
+        if (features.hexEscapes) {
+          if (isHexDigit(input.charCodeAt(index + 1)) &&
+              isHexDigit(input.charCodeAt(index + 2))) {
+            index += 3;
+            return encodingMode.encodeByte(parseInt(input.slice(sequenceStart + 1, index), 16), '\\' + input.slice(sequenceStart, index));
+          }
+          raise(null, errors.hexadecimalDigitExpected, '\\' + input.slice(sequenceStart, index + 2));
         }
+        break;
+
+      case 'u':
+        if (features.unicodeEscapes)
+          return readUnicodeEscapeSequence();
+        break;
+
+      case '\\': case '"': case "'":
         return input.charAt(index++);
     }
+
+    if (features.strictEscapes)
+      raise(null, errors.invalidEscape, '\\' + input.slice(sequenceStart, index + 1));
+    return input.charAt(index++);
   }
 
   function scanComment() {
@@ -2081,14 +2398,14 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
       , lineComment = line;
 
     if ('[' === character) {
-      content = readLongString();
+      content = readLongString(true);
       if (false === content) content = character;
       else isLong = true;
     }
     if (!isLong) {
       while (index < length) {
         if (isLineTerminator(input.charCodeAt(index))) break;
-        index++;
+        ++index;
       }
       if (options.comments) content = input.slice(commentStart, index);
     }
@@ -2104,46 +2421,47 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
       if (options.ranges) {
         node.range = [tokenStart, index];
       }
+      if (options.onCreateNode) options.onCreateNode(node);
       comments.push(node);
     }
   }
 
-  function readLongString() {
+  function readLongString(isComment) {
     var level = 0
       , content = ''
       , terminator = false
-      , character, stringStart;
+      , character, stringStart, firstLine = line;
 
-    index++; // [
-    while ('=' === input.charAt(index + level)) level++;
+    ++index; // [
+    while ('=' === input.charAt(index + level)) ++level;
     if ('[' !== input.charAt(index + level)) return false;
 
     index += level + 1;
-    if (isLineTerminator(input.charCodeAt(index))) {
-      line++;
-      lineStart = index++;
-    }
+    if (isLineTerminator(input.charCodeAt(index))) consumeEOL();
 
     stringStart = index;
     while (index < length) {
+      while (isLineTerminator(input.charCodeAt(index))) consumeEOL();
+
       character = input.charAt(index++);
-      if (isLineTerminator(character.charCodeAt(0))) {
-        line++;
-        lineStart = index;
-      }
       if (']' === character) {
         terminator = true;
-        for (var i = 0; i < level; i++) {
+        for (var i = 0; i < level; ++i) {
           if ('=' !== input.charAt(index + i)) terminator = false;
         }
         if (']' !== input.charAt(index + level)) terminator = false;
       }
-      if (terminator) break;
+      if (terminator) {
+        content += input.slice(stringStart, index - 1);
+        index += level + 1;
+        return content;
+      }
     }
-    content += input.slice(stringStart, index - 1);
-    index += level + 1;
 
-    return content;
+    raise(null, isComment ?
+                errors.unfinishedLongComment :
+                errors.unfinishedLongString,
+          firstLine, '<eof>');
   }
 
   function next() {
@@ -2162,7 +2480,7 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 
   function expect(value) {
     if (value === token.value) next();
-    else raise(token, errors.expected, value, token.value);
+    else raise(token, errors.expected, value, tokenValue(token));
   }
 
   function isWhiteSpace(charCode) {
@@ -2182,11 +2500,19 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
   }
 
   function isIdentifierStart(charCode) {
-    return (charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122) || 95 === charCode;
+    if ((charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122) || 95 === charCode)
+      return true;
+    if (features.extendedIdentifiers && charCode >= 128)
+      return true;
+    return false;
   }
 
   function isIdentifierPart(charCode) {
-    return (charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122) || 95 === charCode || (charCode >= 48 && charCode <= 57);
+    if ((charCode >= 65 && charCode <= 90) || (charCode >= 97 && charCode <= 122) || 95 === charCode || (charCode >= 48 && charCode <= 57))
+      return true;
+    if (features.extendedIdentifiers && charCode >= 128)
+      return true;
+    return false;
   }
 
   function isKeyword(id) {
@@ -2196,7 +2522,11 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
       case 3:
         return 'and' === id || 'end' === id || 'for' === id || 'not' === id;
       case 4:
-        return 'else' === id || 'goto' === id || 'then' === id;
+        if ('else' === id || 'then' === id)
+          return true;
+        if (features.labels && !features.contextualGoto)
+          return ('goto' === id);
+        return false;
       case 5:
         return 'break' === id || 'local' === id || 'until' === id || 'while' === id;
       case 6:
@@ -2212,15 +2542,6 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     if (Keyword === token.type) return 'not' === token.value;
     return false;
   }
-  function isCallExpression(expression) {
-    switch (expression.type) {
-      case 'CallExpression':
-      case 'TableCallExpression':
-      case 'StringCallExpression':
-        return true;
-    }
-    return false;
-  }
 
   function isBlockFollow(token) {
     if (EOF === token.type) return true;
@@ -2237,13 +2558,17 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     , scopeDepth
     , globals;
   function createScope() {
-    scopes.push(Array.apply(null, scopes[scopeDepth++]));
+    var scope = scopes[scopeDepth++].slice();
+    scopes.push(scope);
+    if (options.onCreateScope) options.onCreateScope();
   }
-  function exitScope() {
-    scopes.pop();
-    scopeDepth--;
+  function destroyScope() {
+    var scope = scopes.pop();
+    --scopeDepth;
+    if (options.onDestroyScope) options.onDestroyScope();
   }
   function scopeIdentifierName(name) {
+    if (options.onLocalDeclaration) options.onLocalDeclaration(name);
     if (-1 !== indexOf(scopes[scopeDepth], name)) return;
     scopes[scopeDepth].push(name);
   }
@@ -2285,13 +2610,35 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
   }
   Marker.prototype.complete = function() {
     if (options.locations) {
-      this.loc.end.line = previousToken.line;
-      this.loc.end.column = previousToken.range[1] - previousToken.lineStart;
+      this.loc.end.line = previousToken.lastLine || previousToken.line;
+      this.loc.end.column = previousToken.range[1] - (previousToken.lastLineStart || previousToken.lineStart);
     }
     if (options.ranges) {
       this.range[1] = previousToken.range[1];
     }
   };
+
+  Marker.prototype.bless = function (node) {
+    if (this.loc) {
+      var loc = this.loc;
+      node.loc = {
+        start: {
+          line: loc.start.line,
+          column: loc.start.column
+        },
+        end: {
+          line: loc.end.line,
+          column: loc.end.column
+        }
+      };
+    }
+    if (this.range) {
+      node.range = [
+        this.range[0],
+        this.range[1]
+      ];
+    }
+  };
   function markLocation() {
     if (trackLocations) locations.push(createLocationMarker());
   }
@@ -2299,71 +2646,234 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     if (trackLocations) locations.push(marker);
   }
 
+  function FullFlowContext() {
+    this.scopes = [];
+    this.pendingGotos = [];
+  }
+
+  FullFlowContext.prototype.isInLoop = function () {
+    var i = this.scopes.length;
+    while (i --> 0) {
+      if (this.scopes[i].isLoop)
+        return true;
+    }
+    return false;
+  };
+
+  FullFlowContext.prototype.pushScope = function (isLoop) {
+    var scope = {
+      labels: {},
+      locals: [],
+      deferredGotos: [],
+      isLoop: !!isLoop
+    };
+    this.scopes.push(scope);
+  };
+
+  FullFlowContext.prototype.popScope = function () {
+    for (var i = 0; i < this.pendingGotos.length; ++i) {
+      var theGoto = this.pendingGotos[i];
+      if (theGoto.maxDepth >= this.scopes.length)
+        if (--theGoto.maxDepth <= 0)
+          raise(theGoto.token, errors.labelNotVisible, theGoto.target);
+    }
+
+    this.scopes.pop();
+  };
+
+  FullFlowContext.prototype.addGoto = function (target, token) {
+    var localCounts = [];
+
+    for (var i = 0; i < this.scopes.length; ++i) {
+      var scope = this.scopes[i];
+      localCounts.push(scope.locals.length);
+      if (Object.prototype.hasOwnProperty.call(scope.labels, target))
+        return;
+    }
+
+    this.pendingGotos.push({
+      maxDepth: this.scopes.length,
+      target: target,
+      token: token,
+      localCounts: localCounts
+    });
+  };
+
+  FullFlowContext.prototype.addLabel = function (name, token) {
+    var scope = this.currentScope();
+
+    if (Object.prototype.hasOwnProperty.call(scope.labels, name)) {
+      raise(token, errors.labelAlreadyDefined, name, scope.labels[name].line);
+    } else {
+      var newGotos = [];
+
+      for (var i = 0; i < this.pendingGotos.length; ++i) {
+        var theGoto = this.pendingGotos[i];
+
+        if (theGoto.maxDepth >= this.scopes.length && theGoto.target === name) {
+          if (theGoto.localCounts[this.scopes.length - 1] < scope.locals.length) {
+            scope.deferredGotos.push(theGoto);
+          }
+          continue;
+        }
+
+        newGotos.push(theGoto);
+      }
+
+      this.pendingGotos = newGotos;
+    }
+
+    scope.labels[name] = {
+      localCount: scope.locals.length,
+      line: token.line
+    };
+  };
+
+  FullFlowContext.prototype.addLocal = function (name, token) {
+    this.currentScope().locals.push({
+      name: name,
+      token: token
+    });
+  };
+
+  FullFlowContext.prototype.currentScope = function () {
+    return this.scopes[this.scopes.length - 1];
+  };
+
+  FullFlowContext.prototype.raiseDeferredErrors = function () {
+    var scope = this.currentScope();
+    var bads = scope.deferredGotos;
+    for (var i = 0; i < bads.length; ++i) {
+      var theGoto = bads[i];
+      raise(theGoto.token, errors.gotoJumpInLocalScope, theGoto.target, scope.locals[theGoto.localCounts[this.scopes.length - 1]].name);
+    }
+  };
+
+  function LoopFlowContext() {
+    this.level = 0;
+    this.loopLevels = [];
+  }
+
+  LoopFlowContext.prototype.isInLoop = function () {
+    return !!this.loopLevels.length;
+  };
+
+  LoopFlowContext.prototype.pushScope = function (isLoop) {
+    ++this.level;
+    if (isLoop)
+      this.loopLevels.push(this.level);
+  };
+
+  LoopFlowContext.prototype.popScope = function () {
+    var levels = this.loopLevels;
+    var levlen = levels.length;
+    if (levlen) {
+      if (levels[levlen - 1] === this.level)
+        levels.pop();
+    }
+    --this.level;
+  };
+
+  LoopFlowContext.prototype.addGoto =
+  LoopFlowContext.prototype.addLabel =
+  function () { throw new Error('This should never happen'); };
+
+  LoopFlowContext.prototype.addLocal =
+  LoopFlowContext.prototype.raiseDeferredErrors =
+  function () {};
+
+  function makeFlowContext() {
+    return features.labels ? new FullFlowContext() : new LoopFlowContext();
+  }
+
   function parseChunk() {
     next();
     markLocation();
-    var body = parseBlock();
+    if (options.scope) createScope();
+    var flowContext = makeFlowContext();
+    flowContext.allowVararg = true;
+    flowContext.pushScope();
+    var body = parseBlock(flowContext);
+    flowContext.popScope();
+    if (options.scope) destroyScope();
     if (EOF !== token.type) unexpected(token);
     if (trackLocations && !body.length) previousToken = token;
     return finishNode(ast.chunk(body));
   }
 
-  function parseBlock(terminator) {
+  function parseBlock(flowContext) {
     var block = []
       , statement;
-    if (options.scope) createScope();
 
     while (!isBlockFollow(token)) {
-      if ('return' === token.value) {
-        block.push(parseStatement());
+      if ('return' === token.value || (!features.relaxedBreak && 'break' === token.value)) {
+        block.push(parseStatement(flowContext));
         break;
       }
-      statement = parseStatement();
+      statement = parseStatement(flowContext);
+      consume(';');
       if (statement) block.push(statement);
     }
-
-    if (options.scope) exitScope();
     return block;
   }
 
-  function parseStatement() {
+  function parseStatement(flowContext) {
     markLocation();
+
+    if (Punctuator === token.type) {
+      if (consume('::')) return parseLabelStatement(flowContext);
+    }
+    if (features.emptyStatement) {
+      if (consume(';')) {
+        if (trackLocations) locations.pop();
+        return;
+      }
+    }
+
+    flowContext.raiseDeferredErrors();
+
     if (Keyword === token.type) {
       switch (token.value) {
-        case 'local':    next(); return parseLocalStatement();
-        case 'if':       next(); return parseIfStatement();
-        case 'return':   next(); return parseReturnStatement();
+        case 'local':    next(); return parseLocalStatement(flowContext);
+        case 'if':       next(); return parseIfStatement(flowContext);
+        case 'return':   next(); return parseReturnStatement(flowContext);
         case 'function': next();
           var name = parseFunctionName();
           return parseFunctionDeclaration(name);
-        case 'while':    next(); return parseWhileStatement();
-        case 'for':      next(); return parseForStatement();
-        case 'repeat':   next(); return parseRepeatStatement();
-        case 'break':    next(); return parseBreakStatement();
-        case 'do':       next(); return parseDoStatement();
-        case 'goto':     next(); return parseGotoStatement();
+        case 'while':    next(); return parseWhileStatement(flowContext);
+        case 'for':      next(); return parseForStatement(flowContext);
+        case 'repeat':   next(); return parseRepeatStatement(flowContext);
+        case 'break':    next();
+          if (!flowContext.isInLoop())
+            raise(token, errors.noLoopToBreak, token.value);
+          return parseBreakStatement();
+        case 'do':       next(); return parseDoStatement(flowContext);
+        case 'goto':     next(); return parseGotoStatement(flowContext);
       }
     }
 
-    if (Punctuator === token.type) {
-      if (consume('::')) return parseLabelStatement();
+    if (features.contextualGoto &&
+        token.type === Identifier && token.value === 'goto' &&
+        lookahead.type === Identifier && lookahead.value !== 'goto') {
+      next(); return parseGotoStatement(flowContext);
     }
     if (trackLocations) locations.pop();
-    if (consume(';')) return;
 
-    return parseAssignmentOrCallStatement();
+    return parseAssignmentOrCallStatement(flowContext);
   }
 
-  function parseLabelStatement() {
-    var name = token.value
+  function parseLabelStatement(flowContext) {
+    var nameToken = token
       , label = parseIdentifier();
 
     if (options.scope) {
-      scopeIdentifierName('::' + name + '::');
+      scopeIdentifierName('::' + nameToken.value + '::');
       attachScope(label, true);
     }
 
     expect('::');
+
+    flowContext.addLabel(nameToken.value, nameToken);
     return finishNode(ast.labelStatement(label));
   }
 
@@ -2371,43 +2881,57 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     return finishNode(ast.breakStatement());
   }
 
-  function parseGotoStatement() {
+  function parseGotoStatement(flowContext) {
     var name = token.value
+      , gotoToken = previousToken
       , label = parseIdentifier();
 
-    if (options.scope) label.isLabel = scopeHasName('::' + name + '::');
+    flowContext.addGoto(name, gotoToken);
     return finishNode(ast.gotoStatement(label));
   }
 
-  function parseDoStatement() {
-    var body = parseBlock();
+  function parseDoStatement(flowContext) {
+    if (options.scope) createScope();
+    flowContext.pushScope();
+    var body = parseBlock(flowContext);
+    flowContext.popScope();
+    if (options.scope) destroyScope();
     expect('end');
     return finishNode(ast.doStatement(body));
   }
 
-  function parseWhileStatement() {
-    var condition = parseExpectedExpression();
+  function parseWhileStatement(flowContext) {
+    var condition = parseExpectedExpression(flowContext);
     expect('do');
-    var body = parseBlock();
+    if (options.scope) createScope();
+    flowContext.pushScope(true);
+    var body = parseBlock(flowContext);
+    flowContext.popScope();
+    if (options.scope) destroyScope();
     expect('end');
     return finishNode(ast.whileStatement(condition, body));
   }
 
-  function parseRepeatStatement() {
-    var body = parseBlock();
+  function parseRepeatStatement(flowContext) {
+    if (options.scope) createScope();
+    flowContext.pushScope(true);
+    var body = parseBlock(flowContext);
     expect('until');
-    var condition = parseExpectedExpression();
+    flowContext.raiseDeferredErrors();
+    var condition = parseExpectedExpression(flowContext);
+    flowContext.popScope();
+    if (options.scope) destroyScope();
     return finishNode(ast.repeatStatement(condition, body));
   }
 
-  function parseReturnStatement() {
+  function parseReturnStatement(flowContext) {
     var expressions = [];
 
     if ('end' !== token.value) {
-      var expression = parseExpression();
+      var expression = parseExpression(flowContext);
       if (null != expression) expressions.push(expression);
       while (consume(',')) {
-        expression = parseExpectedExpression();
+        expression = parseExpectedExpression(flowContext);
         expressions.push(expression);
       }
       consume(';'); // grammar tells us ; is optional here.
@@ -2415,7 +2939,7 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     return finishNode(ast.returnStatement(expressions));
   }
 
-  function parseIfStatement() {
+  function parseIfStatement(flowContext) {
     var clauses = []
       , condition
       , body
@@ -2424,17 +2948,25 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
       marker = locations[locations.length - 1];
       locations.push(marker);
     }
-    condition = parseExpectedExpression();
+    condition = parseExpectedExpression(flowContext);
     expect('then');
-    body = parseBlock();
+    if (options.scope) createScope();
+    flowContext.pushScope();
+    body = parseBlock(flowContext);
+    flowContext.popScope();
+    if (options.scope) destroyScope();
     clauses.push(finishNode(ast.ifClause(condition, body)));
 
     if (trackLocations) marker = createLocationMarker();
     while (consume('elseif')) {
       pushLocation(marker);
-      condition = parseExpectedExpression();
+      condition = parseExpectedExpression(flowContext);
       expect('then');
-      body = parseBlock();
+      if (options.scope) createScope();
+      flowContext.pushScope();
+      body = parseBlock(flowContext);
+      flowContext.popScope();
+      if (options.scope) destroyScope();
       clauses.push(finishNode(ast.elseifClause(condition, body)));
       if (trackLocations) marker = createLocationMarker();
     }
@@ -2444,7 +2976,11 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         marker = new Marker(previousToken);
         locations.push(marker);
       }
-      body = parseBlock();
+      if (options.scope) createScope();
+      flowContext.pushScope();
+      body = parseBlock(flowContext);
+      flowContext.popScope();
+      if (options.scope) destroyScope();
       clauses.push(finishNode(ast.elseClause(body)));
     }
 
@@ -2452,19 +2988,26 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     return finishNode(ast.ifStatement(clauses));
   }
 
-  function parseForStatement() {
+  function parseForStatement(flowContext) {
     var variable = parseIdentifier()
       , body;
-    if (options.scope) scopeIdentifier(variable);
+
+    if (options.scope) {
+      createScope();
+      scopeIdentifier(variable);
+    }
     if (consume('=')) {
-      var start = parseExpectedExpression();
+      var start = parseExpectedExpression(flowContext);
       expect(',');
-      var end = parseExpectedExpression();
-      var step = consume(',') ? parseExpectedExpression() : null;
+      var end = parseExpectedExpression(flowContext);
+      var step = consume(',') ? parseExpectedExpression(flowContext) : null;
 
       expect('do');
-      body = parseBlock();
+      flowContext.pushScope(true);
+      body = parseBlock(flowContext);
+      flowContext.popScope();
       expect('end');
+      if (options.scope) destroyScope();
 
       return finishNode(ast.forNumericStatement(variable, start, end, step, body));
     }
@@ -2478,20 +3021,24 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
       expect('in');
       var iterators = [];
       do {
-        var expression = parseExpectedExpression();
+        var expression = parseExpectedExpression(flowContext);
         iterators.push(expression);
       } while (consume(','));
 
       expect('do');
-      body = parseBlock();
+      flowContext.pushScope(true);
+      body = parseBlock(flowContext);
+      flowContext.popScope();
       expect('end');
+      if (options.scope) destroyScope();
 
       return finishNode(ast.forGenericStatement(variables, iterators, body));
     }
   }
 
-  function parseLocalStatement() {
-    var name;
+  function parseLocalStatement(flowContext) {
+    var name
+      , declToken = previousToken;
 
     if (Identifier === token.type) {
       var variables = []
@@ -2501,16 +3048,17 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         name = parseIdentifier();
 
         variables.push(name);
+        flowContext.addLocal(name.name, declToken);
       } while (consume(','));
 
       if (consume('=')) {
         do {
-          var expression = parseExpectedExpression();
+          var expression = parseExpectedExpression(flowContext);
           init.push(expression);
         } while (consume(','));
       }
       if (options.scope) {
-        for (var i = 0, l = variables.length; i < l; i++) {
+        for (var i = 0, l = variables.length; i < l; ++i) {
           scopeIdentifier(variables[i]);
         }
       }
@@ -2519,45 +3067,94 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     }
     if (consume('function')) {
       name = parseIdentifier();
-      if (options.scope) scopeIdentifier(name);
+      flowContext.addLocal(name.name, declToken);
+
+      if (options.scope) {
+        scopeIdentifier(name);
+        createScope();
+      }
       return parseFunctionDeclaration(name, true);
     } else {
       raiseUnexpectedToken('<name>', token);
     }
   }
 
-  function parseAssignmentOrCallStatement() {
+  function parseAssignmentOrCallStatement(flowContext) {
     var previous = token
-      , expression, marker;
+      , marker, startMarker;
+    var lvalue, base, name;
 
-    if (trackLocations) marker = createLocationMarker();
-    expression = parsePrefixExpression();
+    var targets = [];
 
-    if (null == expression) return unexpected(token);
-    if (',='.indexOf(token.value) >= 0) {
-      var variables = [expression]
-        , init = []
-        , exp;
+    if (trackLocations) startMarker = createLocationMarker();
 
-      while (consume(',')) {
-        exp = parsePrefixExpression();
-        if (null == exp) raiseUnexpectedToken('<expression>', token);
-        variables.push(exp);
+    do {
+      if (trackLocations) marker = createLocationMarker();
+
+      if (Identifier === token.type) {
+        name = token.value;
+        base = parseIdentifier();
+        if (options.scope) attachScope(base, scopeHasName(name));
+        lvalue = true;
+      } else if ('(' === token.value) {
+        next();
+        base = parseExpectedExpression(flowContext);
+        expect(')');
+        lvalue = false;
+      } else {
+        return unexpected(token);
       }
-      expect('=');
-      do {
-        exp = parseExpectedExpression();
-        init.push(exp);
-      } while (consume(','));
 
+      both: for (;;) {
+        var newBase;
+
+        switch (StringLiteral === token.type ? '"' : token.value) {
+        case '.':
+        case '[':
+          lvalue = true;
+          break;
+        case ':':
+        case '(':
+        case '{':
+        case '"':
+          lvalue = null;
+          break;
+        default:
+          break both;
+        }
+
+        base = parsePrefixExpressionPart(base, marker, flowContext);
+      }
+
+      targets.push(base);
+
+      if (',' !== token.value)
+        break;
+
+      if (!lvalue) {
+        return unexpected(token);
+      }
+
+      next();
+    } while (true);
+
+    if (targets.length === 1 && lvalue === null) {
       pushLocation(marker);
-      return finishNode(ast.assignmentStatement(variables, init));
-    }
-    if (isCallExpression(expression)) {
-      pushLocation(marker);
-      return finishNode(ast.callStatement(expression));
+      return finishNode(ast.callStatement(targets[0]));
+    } else if (!lvalue) {
+      return unexpected(token);
     }
-    return unexpected(previous);
+
+    expect('=');
+
+    var values = [];
+
+    do {
+      values.push(parseExpectedExpression(flowContext));
+    } while (consume(','));
+
+    pushLocation(startMarker);
+    return finishNode(ast.assignmentStatement(targets, values));
   }
 
   function parseIdentifier() {
@@ -2569,6 +3166,9 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
   }
 
   function parseFunctionDeclaration(name, isLocal) {
+    var flowContext = makeFlowContext();
+    flowContext.pushScope();
+
     var parameters = [];
     expect('(');
     if (!consume(')')) {
@@ -2580,20 +3180,22 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
           parameters.push(parameter);
 
           if (consume(',')) continue;
-          else if (consume(')')) break;
         }
         else if (VarargLiteral === token.type) {
-          parameters.push(parsePrimaryExpression());
-          expect(')');
-          break;
+          flowContext.allowVararg = true;
+          parameters.push(parsePrimaryExpression(flowContext));
         } else {
           raiseUnexpectedToken('<name> or \'...\'', token);
         }
+        expect(')');
+        break;
       }
     }
 
-    var body = parseBlock();
+    var body = parseBlock(flowContext);
+    flowContext.popScope();
     expect('end');
+    if (options.scope) destroyScope();
 
     isLocal = isLocal || false;
     return finishNode(ast.functionStatement(name, parameters, isLocal, body));
@@ -2605,47 +3207,51 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     if (trackLocations) marker = createLocationMarker();
     base = parseIdentifier();
 
-    if (options.scope) attachScope(base, false);
+    if (options.scope) {
+      attachScope(base, scopeHasName(base.name));
+      createScope();
+    }
 
     while (consume('.')) {
       pushLocation(marker);
       name = parseIdentifier();
-      if (options.scope) attachScope(name, false);
       base = finishNode(ast.memberExpression(base, '.', name));
     }
 
     if (consume(':')) {
       pushLocation(marker);
       name = parseIdentifier();
-      if (options.scope) attachScope(name, false);
       base = finishNode(ast.memberExpression(base, ':', name));
+      if (options.scope) scopeIdentifierName('self');
     }
 
     return base;
   }
 
-  function parseTableConstructor() {
+  function parseTableConstructor(flowContext) {
     var fields = []
       , key, value;
 
     while (true) {
       markLocation();
       if (Punctuator === token.type && consume('[')) {
-        key = parseExpectedExpression();
+        key = parseExpectedExpression(flowContext);
         expect(']');
         expect('=');
-        value = parseExpectedExpression();
+        value = parseExpectedExpression(flowContext);
         fields.push(finishNode(ast.tableKey(key, value)));
       } else if (Identifier === token.type) {
-        key = parseExpectedExpression();
-        if (consume('=')) {
-          value = parseExpectedExpression();
+        if ('=' === lookahead.value) {
+          key = parseIdentifier();
+          next();
+          value = parseExpectedExpression(flowContext);
           fields.push(finishNode(ast.tableKeyString(key, value)));
         } else {
-          fields.push(finishNode(ast.tableValue(key)));
+          value = parseExpectedExpression(flowContext);
+          fields.push(finishNode(ast.tableValue(value)));
         }
       } else {
-        if (null == (value = parseExpression())) {
+        if (null == (value = parseExpression(flowContext))) {
           locations.pop();
           break;
         }
@@ -2655,19 +3261,19 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         next();
         continue;
       }
-      if ('}' === token.value) break;
+      break;
     }
     expect('}');
     return finishNode(ast.tableConstructorExpression(fields));
   }
 
-  function parseExpression() {
-    var expression = parseSubExpression(0);
+  function parseExpression(flowContext) {
+    var expression = parseSubExpression(0, flowContext);
     return expression;
   }
 
-  function parseExpectedExpression() {
-    var expression = parseExpression();
+  function parseExpectedExpression(flowContext) {
+    var expression = parseExpression(flowContext);
     if (null == expression) raiseUnexpectedToken('<expression>', token);
     else return expression;
   }
@@ -2678,23 +3284,29 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 
     if (1 === length) {
       switch (charCode) {
-        case 94: return 10; // ^
-        case 42: case 47: case 37: return 7; // * / %
-        case 43: case 45: return 6; // + -
+        case 94: return 12; // ^
+        case 42: case 47: case 37: return 10; // * / %
+        case 43: case 45: return 9; // + -
+        case 38: return 6; // &
+        case 126: return 5; // ~
+        case 124: return 4; // |
         case 60: case 62: return 3; // < >
-        case 38: case 124: return 7; // & |
       }
     } else if (2 === length) {
       switch (charCode) {
-        case 46: return 5; // ..
-        case 60: case 62: case 61: case 126: return 3; // <= >= == ~=
+        case 47: return 10; // //
+        case 46: return 8; // ..
+        case 60: case 62:
+            if('<<' === operator || '>>' === operator) return 7; // << >>
+            return 3; // <= >=
+        case 61: case 126: return 3; // == ~=
         case 111: return 1; // or
       }
     } else if (97 === charCode && 'and' === operator) return 2;
     return 0;
   }
 
-  function parseSubExpression(minPrecedence) {
+  function parseSubExpression(minPrecedence, flowContext) {
     var operator = token.value
       , expression, marker;
 
@@ -2702,14 +3314,14 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     if (isUnary(token)) {
       markLocation();
       next();
-      var argument = parseSubExpression(8);
+      var argument = parseSubExpression(10, flowContext);
       if (argument == null) raiseUnexpectedToken('<expression>', token);
       expression = finishNode(ast.unaryExpression(operator, argument));
     }
     if (null == expression) {
-      expression = parsePrimaryExpression();
+      expression = parsePrimaryExpression(flowContext);
       if (null == expression) {
-        expression = parsePrefixExpression();
+        expression = parsePrefixExpression(flowContext);
       }
     }
     if (null == expression) return null;
@@ -2722,9 +3334,9 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         binaryPrecedence(operator) : 0;
 
       if (precedence === 0 || precedence <= minPrecedence) break;
-      if ('^' === operator || '..' === operator) precedence--;
+      if ('^' === operator || '..' === operator) --precedence;
       next();
-      var right = parseSubExpression(precedence);
+      var right = parseSubExpression(precedence, flowContext);
       if (null == right) raiseUnexpectedToken('<expression>', token);
       if (trackLocations) locations.push(marker);
       expression = finishNode(ast.binaryExpression(operator, expression, right));
@@ -2733,77 +3345,79 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     return expression;
   }
 
-  function parsePrefixExpression() {
-    var base, name, marker
-      , isLocal;
+  function parsePrefixExpressionPart(base, marker, flowContext) {
+    var expression, identifier;
+
+    if (Punctuator === token.type) {
+      switch (token.value) {
+        case '[':
+          pushLocation(marker);
+          next();
+          expression = parseExpectedExpression(flowContext);
+          expect(']');
+          return finishNode(ast.indexExpression(base, expression));
+        case '.':
+          pushLocation(marker);
+          next();
+          identifier = parseIdentifier();
+          return finishNode(ast.memberExpression(base, '.', identifier));
+        case ':':
+          pushLocation(marker);
+          next();
+          identifier = parseIdentifier();
+          base = finishNode(ast.memberExpression(base, ':', identifier));
+          pushLocation(marker);
+          return parseCallExpression(base, flowContext);
+        case '(': case '{': // args
+          pushLocation(marker);
+          return parseCallExpression(base, flowContext);
+      }
+    } else if (StringLiteral === token.type) {
+      pushLocation(marker);
+      return parseCallExpression(base, flowContext);
+    }
+
+    return null;
+  }
+
+  function parsePrefixExpression(flowContext) {
+    var base, name, marker;
 
     if (trackLocations) marker = createLocationMarker();
     if (Identifier === token.type) {
       name = token.value;
       base = parseIdentifier();
-      if (options.scope) attachScope(base, isLocal = scopeHasName(name));
+      if (options.scope) attachScope(base, scopeHasName(name));
     } else if (consume('(')) {
-      base = parseExpectedExpression();
+      base = parseExpectedExpression(flowContext);
       expect(')');
-      if (options.scope) isLocal = base.isLocal;
     } else {
       return null;
     }
-    var expression, identifier;
-    while (true) {
-      if (Punctuator === token.type) {
-        switch (token.value) {
-          case '[':
-            pushLocation(marker);
-            next();
-            expression = parseExpectedExpression();
-            base = finishNode(ast.indexExpression(base, expression));
-            expect(']');
-            break;
-          case '.':
-            pushLocation(marker);
-            next();
-            identifier = parseIdentifier();
-            if (options.scope) attachScope(identifier, isLocal);
-            base = finishNode(ast.memberExpression(base, '.', identifier));
-            break;
-          case ':':
-            pushLocation(marker);
-            next();
-            identifier = parseIdentifier();
-            if (options.scope) attachScope(identifier, isLocal);
-            base = finishNode(ast.memberExpression(base, ':', identifier));
-            pushLocation(marker);
-            base = parseCallExpression(base);
-            break;
-          case '(': case '{': // args
-            pushLocation(marker);
-            base = parseCallExpression(base);
-            break;
-          default:
-            return base;
-        }
-      } else if (StringLiteral === token.type) {
-        pushLocation(marker);
-        base = parseCallExpression(base);
-      } else {
+    for (;;) {
+      var newBase = parsePrefixExpressionPart(base, marker, flowContext);
+      if (newBase === null)
         break;
-      }
+      base = newBase;
     }
 
     return base;
   }
 
-  function parseCallExpression(base) {
+  function parseCallExpression(base, flowContext) {
     if (Punctuator === token.type) {
       switch (token.value) {
         case '(':
+          if (!features.emptyStatement) {
+            if (token.line !== previousToken.line)
+              raise(null, errors.ambiguousSyntax, token.value);
+          }
           next();
           var expressions = [];
-          var expression = parseExpression();
+          var expression = parseExpression(flowContext);
           if (null != expression) expressions.push(expression);
           while (consume(',')) {
-            expression = parseExpectedExpression();
+            expression = parseExpectedExpression(flowContext);
             expressions.push(expression);
           }
 
@@ -2813,17 +3427,17 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
         case '{':
           markLocation();
           next();
-          var table = parseTableConstructor();
+          var table = parseTableConstructor(flowContext);
           return finishNode(ast.tableCallExpression(base, table));
       }
     } else if (StringLiteral === token.type) {
-      return finishNode(ast.stringCallExpression(base, parsePrimaryExpression()));
+      return finishNode(ast.stringCallExpression(base, parsePrimaryExpression(flowContext)));
     }
 
     raiseUnexpectedToken('function arguments', token);
   }
 
-  function parsePrimaryExpression() {
+  function parsePrimaryExpression(flowContext) {
     var literals = StringLiteral | NumericLiteral | BooleanLiteral | NilLiteral | VarargLiteral
       , value = token.value
       , type = token.type
@@ -2831,6 +3445,10 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 
     if (trackLocations) marker = createLocationMarker();
 
+    if (type === VarargLiteral && !flowContext.allowVararg) {
+      raise(token, errors.cannotUseVararg, token.value);
+    }
+
     if (type & literals) {
       pushLocation(marker);
       var raw = input.slice(token.range[0], token.range[1]);
@@ -2839,15 +3457,50 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     } else if (Keyword === type && 'function' === value) {
       pushLocation(marker);
       next();
+      if (options.scope) createScope();
       return parseFunctionDeclaration(null);
     } else if (consume('{')) {
       pushLocation(marker);
-      return parseTableConstructor();
+      return parseTableConstructor(flowContext);
     }
   }
 
   exports.parse = parse;
 
+  var versionFeatures = {
+    '5.1': {
+    },
+    '5.2': {
+      labels: true,
+      emptyStatement: true,
+      hexEscapes: true,
+      skipWhitespaceEscape: true,
+      strictEscapes: true,
+      relaxedBreak: true
+    },
+    '5.3': {
+      labels: true,
+      emptyStatement: true,
+      hexEscapes: true,
+      skipWhitespaceEscape: true,
+      strictEscapes: true,
+      unicodeEscapes: true,
+      bitwiseOperators: true,
+      integerDivision: true,
+      relaxedBreak: true
+    },
+    'LuaJIT': {
+      labels: true,
+      contextualGoto: true,
+      hexEscapes: true,
+      skipWhitespaceEscape: true,
+      strictEscapes: true,
+      unicodeEscapes: true,
+      imaginaryNumbers: true,
+      integerSuffixes: true
+    }
+  };
+
   function parse(_input, _options) {
     if ('undefined' === typeof _options && 'object' === typeof _input) {
       _options = _input;
@@ -2856,7 +3509,7 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     if (!_options) _options = {};
 
     input = _input || '';
-    options = extend(defaultOptions, _options);
+    options = assign({}, defaultOptions, _options);
     index = 0;
     line = 1;
     lineStart = 0;
@@ -2866,6 +3519,20 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     globals = [];
     locations = [];
 
+    if (!Object.prototype.hasOwnProperty.call(versionFeatures, options.luaVersion)) {
+      throw new Error(sprintf("Lua version '%1' not supported", options.luaVersion));
+    }
+
+    features = assign({}, versionFeatures[options.luaVersion]);
+    if (options.extendedIdentifiers !== void 0)
+      features.extendedIdentifiers = !!options.extendedIdentifiers;
+
+    if (!Object.prototype.hasOwnProperty.call(encodingModes, options.encodingMode)) {
+      throw new Error(sprintf("Encoding mode '%1' not supported", options.encodingMode));
+    }
+
+    encodingMode = encodingModes[options.encodingMode];
+
     if (options.comments) comments = [];
     if (!options.wait) return end();
     return exports;
@@ -2881,6 +3548,9 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
 
   function end(_input) {
     if ('undefined' !== typeof _input) write(_input);
+    if (input && input.substr(0, 2) === '#!') input = input.replace(/^.*/, function (line) {
+      return line.replace(/./g, ' ');
+    });
 
     length = input.length;
     trackLocations = options.locations || options.ranges;
@@ -2889,7 +3559,6 @@ ace.define("ace/mode/lua/luaparse",[], function(require, exports, module) {
     var chunk = parseChunk();
     if (options.comments) chunk.comments = comments;
     if (options.scope) chunk.globals = globals;
-
     if (locations.length > 0)
       throw new Error('Location tracking failed. This is most likely a bug in luaparse');
 
@@ -2922,7 +3591,7 @@ oop.inherits(Worker, Mirror);
         try {
             luaparse.parse(value);
         } catch(e) {
-            if (e instanceof SyntaxError) {
+            if (e instanceof luaparse.SyntaxError) {
                 errors.push({
                     row: e.line - 1,
                     column: e.column,
@@ -2937,700 +3606,3 @@ oop.inherits(Worker, Mirror);
 }).call(Worker.prototype);
 
 });
-
-ace.define("ace/lib/es5-shim",[], function(require, exports, module) {
-
-function Empty() {}
-
-if (!Function.prototype.bind) {
-    Function.prototype.bind = function bind(that) { // .length is 1
-        var target = this;
-        if (typeof target != "function") {
-            throw new TypeError("Function.prototype.bind called on incompatible " + target);
-        }
-        var args = slice.call(arguments, 1); // for normal call
-        var bound = function () {
-
-            if (this instanceof bound) {
-
-                var result = target.apply(
-                    this,
-                    args.concat(slice.call(arguments))
-                );
-                if (Object(result) === result) {
-                    return result;
-                }
-                return this;
-
-            } else {
-                return target.apply(
-                    that,
-                    args.concat(slice.call(arguments))
-                );
-
-            }
-
-        };
-        if(target.prototype) {
-            Empty.prototype = target.prototype;
-            bound.prototype = new Empty();
-            Empty.prototype = null;
-        }
-        return bound;
-    };
-}
-var call = Function.prototype.call;
-var prototypeOfArray = Array.prototype;
-var prototypeOfObject = Object.prototype;
-var slice = prototypeOfArray.slice;
-var _toString = call.bind(prototypeOfObject.toString);
-var owns = call.bind(prototypeOfObject.hasOwnProperty);
-var defineGetter;
-var defineSetter;
-var lookupGetter;
-var lookupSetter;
-var supportsAccessors;
-if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
-    defineGetter = call.bind(prototypeOfObject.__defineGetter__);
-    defineSetter = call.bind(prototypeOfObject.__defineSetter__);
-    lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
-    lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
-}
-if ([1,2].splice(0).length != 2) {
-    if(function() { // test IE < 9 to splice bug - see issue #138
-        function makeArray(l) {
-            var a = new Array(l+2);
-            a[0] = a[1] = 0;
-            return a;
-        }
-        var array = [], lengthBefore;
-        
-        array.splice.apply(array, makeArray(20));
-        array.splice.apply(array, makeArray(26));
-
-        lengthBefore = array.length; //46
-        array.splice(5, 0, "XXX"); // add one element
-
-        lengthBefore + 1 == array.length
-
-        if (lengthBefore + 1 == array.length) {
-            return true;// has right splice implementation without bugs
-        }
-    }()) {//IE 6/7
-        var array_splice = Array.prototype.splice;
-        Array.prototype.splice = function(start, deleteCount) {
-            if (!arguments.length) {
-                return [];
-            } else {
-                return array_splice.apply(this, [
-                    start === void 0 ? 0 : start,
-                    deleteCount === void 0 ? (this.length - start) : deleteCount
-                ].concat(slice.call(arguments, 2)))
-            }
-        };
-    } else {//IE8
-        Array.prototype.splice = function(pos, removeCount){
-            var length = this.length;
-            if (pos > 0) {
-                if (pos > length)
-                    pos = length;
-            } else if (pos == void 0) {
-                pos = 0;
-            } else if (pos < 0) {
-                pos = Math.max(length + pos, 0);
-            }
-
-            if (!(pos+removeCount < length))
-                removeCount = length - pos;
-
-            var removed = this.slice(pos, pos+removeCount);
-            var insert = slice.call(arguments, 2);
-            var add = insert.length;            
-            if (pos === length) {
-                if (add) {
-                    this.push.apply(this, insert);
-                }
-            } else {
-                var remove = Math.min(removeCount, length - pos);
-                var tailOldPos = pos + remove;
-                var tailNewPos = tailOldPos + add - remove;
-                var tailCount = length - tailOldPos;
-                var lengthAfterRemove = length - remove;
-
-                if (tailNewPos < tailOldPos) { // case A
-                    for (var i = 0; i < tailCount; ++i) {
-                        this[tailNewPos+i] = this[tailOldPos+i];
-                    }
-                } else if (tailNewPos > tailOldPos) { // case B
-                    for (i = tailCount; i--; ) {
-                        this[tailNewPos+i] = this[tailOldPos+i];
-                    }
-                } // else, add == remove (nothing to do)
-
-                if (add && pos === lengthAfterRemove) {
-                    this.length = lengthAfterRemove; // truncate array
-                    this.push.apply(this, insert);
-                } else {
-                    this.length = lengthAfterRemove + add; // reserves space
-                    for (i = 0; i < add; ++i) {
-                        this[pos+i] = insert[i];
-                    }
-                }
-            }
-            return removed;
-        };
-    }
-}
-if (!Array.isArray) {
-    Array.isArray = function isArray(obj) {
-        return _toString(obj) == "[object Array]";
-    };
-}
-var boxedString = Object("a"),
-    splitString = boxedString[0] != "a" || !(0 in boxedString);
-
-if (!Array.prototype.forEach) {
-    Array.prototype.forEach = function forEach(fun /*, thisp*/) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                object,
-            thisp = arguments[1],
-            i = -1,
-            length = self.length >>> 0;
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(); // TODO message
-        }
-
-        while (++i < length) {
-            if (i in self) {
-                fun.call(thisp, self[i], i, object);
-            }
-        }
-    };
-}
-if (!Array.prototype.map) {
-    Array.prototype.map = function map(fun /*, thisp*/) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                object,
-            length = self.length >>> 0,
-            result = Array(length),
-            thisp = arguments[1];
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(fun + " is not a function");
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self)
-                result[i] = fun.call(thisp, self[i], i, object);
-        }
-        return result;
-    };
-}
-if (!Array.prototype.filter) {
-    Array.prototype.filter = function filter(fun /*, thisp */) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                    object,
-            length = self.length >>> 0,
-            result = [],
-            value,
-            thisp = arguments[1];
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(fun + " is not a function");
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self) {
-                value = self[i];
-                if (fun.call(thisp, value, i, object)) {
-                    result.push(value);
-                }
-            }
-        }
-        return result;
-    };
-}
-if (!Array.prototype.every) {
-    Array.prototype.every = function every(fun /*, thisp */) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                object,
-            length = self.length >>> 0,
-            thisp = arguments[1];
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(fun + " is not a function");
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self && !fun.call(thisp, self[i], i, object)) {
-                return false;
-            }
-        }
-        return true;
-    };
-}
-if (!Array.prototype.some) {
-    Array.prototype.some = function some(fun /*, thisp */) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                object,
-            length = self.length >>> 0,
-            thisp = arguments[1];
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(fun + " is not a function");
-        }
-
-        for (var i = 0; i < length; i++) {
-            if (i in self && fun.call(thisp, self[i], i, object)) {
-                return true;
-            }
-        }
-        return false;
-    };
-}
-if (!Array.prototype.reduce) {
-    Array.prototype.reduce = function reduce(fun /*, initial*/) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                object,
-            length = self.length >>> 0;
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(fun + " is not a function");
-        }
-        if (!length && arguments.length == 1) {
-            throw new TypeError("reduce of empty array with no initial value");
-        }
-
-        var i = 0;
-        var result;
-        if (arguments.length >= 2) {
-            result = arguments[1];
-        } else {
-            do {
-                if (i in self) {
-                    result = self[i++];
-                    break;
-                }
-                if (++i >= length) {
-                    throw new TypeError("reduce of empty array with no initial value");
-                }
-            } while (true);
-        }
-
-        for (; i < length; i++) {
-            if (i in self) {
-                result = fun.call(void 0, result, self[i], i, object);
-            }
-        }
-
-        return result;
-    };
-}
-if (!Array.prototype.reduceRight) {
-    Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {
-        var object = toObject(this),
-            self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                object,
-            length = self.length >>> 0;
-        if (_toString(fun) != "[object Function]") {
-            throw new TypeError(fun + " is not a function");
-        }
-        if (!length && arguments.length == 1) {
-            throw new TypeError("reduceRight of empty array with no initial value");
-        }
-
-        var result, i = length - 1;
-        if (arguments.length >= 2) {
-            result = arguments[1];
-        } else {
-            do {
-                if (i in self) {
-                    result = self[i--];
-                    break;
-                }
-                if (--i < 0) {
-                    throw new TypeError("reduceRight of empty array with no initial value");
-                }
-            } while (true);
-        }
-
-        do {
-            if (i in this) {
-                result = fun.call(void 0, result, self[i], i, object);
-            }
-        } while (i--);
-
-        return result;
-    };
-}
-if (!Array.prototype.indexOf || ([0, 1].indexOf(1, 2) != -1)) {
-    Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) {
-        var self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                toObject(this),
-            length = self.length >>> 0;
-
-        if (!length) {
-            return -1;
-        }
-
-        var i = 0;
-        if (arguments.length > 1) {
-            i = toInteger(arguments[1]);
-        }
-        i = i >= 0 ? i : Math.max(0, length + i);
-        for (; i < length; i++) {
-            if (i in self && self[i] === sought) {
-                return i;
-            }
-        }
-        return -1;
-    };
-}
-if (!Array.prototype.lastIndexOf || ([0, 1].lastIndexOf(0, -3) != -1)) {
-    Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) {
-        var self = splitString && _toString(this) == "[object String]" ?
-                this.split("") :
-                toObject(this),
-            length = self.length >>> 0;
-
-        if (!length) {
-            return -1;
-        }
-        var i = length - 1;
-        if (arguments.length > 1) {
-            i = Math.min(i, toInteger(arguments[1]));
-        }
-        i = i >= 0 ? i : length - Math.abs(i);
-        for (; i >= 0; i--) {
-            if (i in self && sought === self[i]) {
-                return i;
-            }
-        }
-        return -1;
-    };
-}
-if (!Object.getPrototypeOf) {
-    Object.getPrototypeOf = function getPrototypeOf(object) {
-        return object.__proto__ || (
-            object.constructor ?
-            object.constructor.prototype :
-            prototypeOfObject
-        );
-    };
-}
-if (!Object.getOwnPropertyDescriptor) {
-    var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a " +
-                         "non-object: ";
-    Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
-        if ((typeof object != "object" && typeof object != "function") || object === null)
-            throw new TypeError(ERR_NON_OBJECT + object);
-        if (!owns(object, property))
-            return;
-
-        var descriptor, getter, setter;
-        descriptor =  { enumerable: true, configurable: true };
-        if (supportsAccessors) {
-            var prototype = object.__proto__;
-            object.__proto__ = prototypeOfObject;
-
-            var getter = lookupGetter(object, property);
-            var setter = lookupSetter(object, property);
-            object.__proto__ = prototype;
-
-            if (getter || setter) {
-                if (getter) descriptor.get = getter;
-                if (setter) descriptor.set = setter;
-                return descriptor;
-            }
-        }
-        descriptor.value = object[property];
-        return descriptor;
-    };
-}
-if (!Object.getOwnPropertyNames) {
-    Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
-        return Object.keys(object);
-    };
-}
-if (!Object.create) {
-    var createEmpty;
-    if (Object.prototype.__proto__ === null) {
-        createEmpty = function () {
-            return { "__proto__": null };
-        };
-    } else {
-        createEmpty = function () {
-            var empty = {};
-            for (var i in empty)
-                empty[i] = null;
-            empty.constructor =
-            empty.hasOwnProperty =
-            empty.propertyIsEnumerable =
-            empty.isPrototypeOf =
-            empty.toLocaleString =
-            empty.toString =
-            empty.valueOf =
-            empty.__proto__ = null;
-            return empty;
-        }
-    }
-
-    Object.create = function create(prototype, properties) {
-        var object;
-        if (prototype === null) {
-            object = createEmpty();
-        } else {
-            if (typeof prototype != "object")
-                throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'");
-            var Type = function () {};
-            Type.prototype = prototype;
-            object = new Type();
-            object.__proto__ = prototype;
-        }
-        if (properties !== void 0)
-            Object.defineProperties(object, properties);
-        return object;
-    };
-}
-
-function doesDefinePropertyWork(object) {
-    try {
-        Object.defineProperty(object, "sentinel", {});
-        return "sentinel" in object;
-    } catch (exception) {
-    }
-}
-if (Object.defineProperty) {
-    var definePropertyWorksOnObject = doesDefinePropertyWork({});
-    var definePropertyWorksOnDom = typeof document == "undefined" ||
-        doesDefinePropertyWork(document.createElement("div"));
-    if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
-        var definePropertyFallback = Object.defineProperty;
-    }
-}
-
-if (!Object.defineProperty || definePropertyFallback) {
-    var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";
-    var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: "
-    var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " +
-                                      "on this javascript engine";
-
-    Object.defineProperty = function defineProperty(object, property, descriptor) {
-        if ((typeof object != "object" && typeof object != "function") || object === null)
-            throw new TypeError(ERR_NON_OBJECT_TARGET + object);
-        if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null)
-            throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
-        if (definePropertyFallback) {
-            try {
-                return definePropertyFallback.call(Object, object, property, descriptor);
-            } catch (exception) {
-            }
-        }
-        if (owns(descriptor, "value")) {
-
-            if (supportsAccessors && (lookupGetter(object, property) ||
-                                      lookupSetter(object, property)))
-            {
-                var prototype = object.__proto__;
-                object.__proto__ = prototypeOfObject;
-                delete object[property];
-                object[property] = descriptor.value;
-                object.__proto__ = prototype;
-            } else {
-                object[property] = descriptor.value;
-            }
-        } else {
-            if (!supportsAccessors)
-                throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
-            if (owns(descriptor, "get"))
-                defineGetter(object, property, descriptor.get);
-            if (owns(descriptor, "set"))
-                defineSetter(object, property, descriptor.set);
-        }
-
-        return object;
-    };
-}
-if (!Object.defineProperties) {
-    Object.defineProperties = function defineProperties(object, properties) {
-        for (var property in properties) {
-            if (owns(properties, property))
-                Object.defineProperty(object, property, properties[property]);
-        }
-        return object;
-    };
-}
-if (!Object.seal) {
-    Object.seal = function seal(object) {
-        return object;
-    };
-}
-if (!Object.freeze) {
-    Object.freeze = function freeze(object) {
-        return object;
-    };
-}
-try {
-    Object.freeze(function () {});
-} catch (exception) {
-    Object.freeze = (function freeze(freezeObject) {
-        return function freeze(object) {
-            if (typeof object == "function") {
-                return object;
-            } else {
-                return freezeObject(object);
-            }
-        };
-    })(Object.freeze);
-}
-if (!Object.preventExtensions) {
-    Object.preventExtensions = function preventExtensions(object) {
-        return object;
-    };
-}
-if (!Object.isSealed) {
-    Object.isSealed = function isSealed(object) {
-        return false;
-    };
-}
-if (!Object.isFrozen) {
-    Object.isFrozen = function isFrozen(object) {
-        return false;
-    };
-}
-if (!Object.isExtensible) {
-    Object.isExtensible = function isExtensible(object) {
-        if (Object(object) === object) {
-            throw new TypeError(); // TODO message
-        }
-        var name = '';
-        while (owns(object, name)) {
-            name += '?';
-        }
-        object[name] = true;
-        var returnValue = owns(object, name);
-        delete object[name];
-        return returnValue;
-    };
-}
-if (!Object.keys) {
-    var hasDontEnumBug = true,
-        dontEnums = [
-            "toString",
-            "toLocaleString",
-            "valueOf",
-            "hasOwnProperty",
-            "isPrototypeOf",
-            "propertyIsEnumerable",
-            "constructor"
-        ],
-        dontEnumsLength = dontEnums.length;
-
-    for (var key in {"toString": null}) {
-        hasDontEnumBug = false;
-    }
-
-    Object.keys = function keys(object) {
-
-        if (
-            (typeof object != "object" && typeof object != "function") ||
-            object === null
-        ) {
-            throw new TypeError("Object.keys called on a non-object");
-        }
-
-        var keys = [];
-        for (var name in object) {
-            if (owns(object, name)) {
-                keys.push(name);
-            }
-        }
-
-        if (hasDontEnumBug) {
-            for (var i = 0, ii = dontEnumsLength; i < ii; i++) {
-                var dontEnum = dontEnums[i];
-                if (owns(object, dontEnum)) {
-                    keys.push(dontEnum);
-                }
-            }
-        }
-        return keys;
-    };
-
-}
-if (!Date.now) {
-    Date.now = function now() {
-        return new Date().getTime();
-    };
-}
-var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" +
-    "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" +
-    "\u2029\uFEFF";
-if (!String.prototype.trim || ws.trim()) {
-    ws = "[" + ws + "]";
-    var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),
-        trimEndRegexp = new RegExp(ws + ws + "*$");
-    String.prototype.trim = function trim() {
-        return String(this).replace(trimBeginRegexp, "").replace(trimEndRegexp, "");
-    };
-}
-
-function toInteger(n) {
-    n = +n;
-    if (n !== n) { // isNaN
-        n = 0;
-    } else if (n !== 0 && n !== (1/0) && n !== -(1/0)) {
-        n = (n > 0 || -1) * Math.floor(Math.abs(n));
-    }
-    return n;
-}
-
-function isPrimitive(input) {
-    var type = typeof input;
-    return (
-        input === null ||
-        type === "undefined" ||
-        type === "boolean" ||
-        type === "number" ||
-        type === "string"
-    );
-}
-
-function toPrimitive(input) {
-    var val, valueOf, toString;
-    if (isPrimitive(input)) {
-        return input;
-    }
-    valueOf = input.valueOf;
-    if (typeof valueOf === "function") {
-        val = valueOf.call(input);
-        if (isPrimitive(val)) {
-            return val;
-        }
-    }
-    toString = input.toString;
-    if (typeof toString === "function") {
-        val = toString.call(input);
-        if (isPrimitive(val)) {
-            return val;
-        }
-    }
-    throw new TypeError();
-}
-var toObject = function (o) {
-    if (o == null) { // this matches both null and undefined
-        throw new TypeError("can't convert "+o+" to object");
-    }
-    return Object(o);
-};
-
-});